@rian8337/osu-droid-replay-analyzer 4.0.0-beta.9 → 4.0.0-beta.91

package/dist/index.js

@@ -1,11 +1,9 @@
 'use strict';
 
 var osuBase = require('@rian8337/osu-base');
-var osuDifficultyCalculator = require('@rian8337/osu-difficulty-calculator');
-var osuRebalanceDifficultyCalculator = require('@rian8337/osu-rebalance-difficulty-calculator');
-var unzipper = require('unzipper');
 var javaDeserialization = require('java-deserialization');
 var node_stream = require('node:stream');
+var unzipper = require('unzipper');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -36,442 +34,882 @@ exports.MovementType = void 0;
     /**
      * The player places their finger on the screen.
      */
-    MovementType[MovementType["down"] = 0] = "down";
+    MovementType[MovementType["Down"] = 0] = "Down";
     /**
      * The player drags their finger on the screen.
      */
-    MovementType[MovementType["move"] = 1] = "move";
+    MovementType[MovementType["Move"] = 1] = "Move";
     /**
      * The player releases their finger from the screen.
      */
-    MovementType[MovementType["up"] = 2] = "up";
+    MovementType[MovementType["Up"] = 2] = "Up";
 })(exports.MovementType || (exports.MovementType = {}));
 
 /**
- * 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);
-        this.id = id;
-    }
-}
-
-/**
- * Represents a group of cursor occurrences representing a cursor instance's
- * movement when a player places their finger on the screen.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores.
  */
-class CursorOccurrenceGroup {
+class RebalanceSliderCheeseChecker {
     /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    get down() {
-        return this._down;
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
     }
     /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
+     * Checks if relevant sliders in the given beatmap was cheesed.
      */
-    set down(value) {
-        if (value.id !== exports.MovementType.down) {
-            throw new TypeError("Attempting to set the down cursor occurrence to one with different movement type.");
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            this.difficultyAttributes.sliderFactor === 1) {
+            return 1;
         }
-        this._down = value;
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
     }
     /**
-     * The cursor occurrences of movement type `movementType.MOVE`.
+     * Checks for sliders that were cheesed.
      */
-    get moves() {
-        return this._moves;
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
+            }
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === osuBase.HitResult.Miss) {
+                continue;
+            }
+            let lateHitThreshold = this.hitWindow50;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow50 ||
+                objectData.accuracy > lateHitThreshold) {
+                continue;
+            }
+            const objectStartPosition = object.stackedPosition;
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.Up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.Move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
+            }
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
+            }
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
+                    break;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.stackedPosition;
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.Move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
+                    }
+                    case exports.MovementType.Up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            }
+        }
+        return cheesedDifficultyRatings;
     }
     /**
-     * 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.
+     * Calculates the slider cheese penalty.
      */
-    get up() {
-        return this._up;
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+            summedDifficultyRating *
+                this.difficultyAttributes.sliderFactor, 2));
     }
-    /**
-     * 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.
-     */
-    set up(value) {
-        if (value && value.id !== exports.MovementType.up) {
-            throw new TypeError("Attempting to set the up cursor occurrence to one with different movement type.");
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
         }
-        this._up = value;
+        return cursor.position;
     }
+}
+
+/**
+ * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ */
+class RebalanceThreeFingerChecker {
     /**
-     * The time at which this cursor occurrence group starts.
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    get startTime() {
-        return this._down.time;
+    constructor(beatmap, data, difficultyAttributes) {
+        /**
+         * 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;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
+        this.hitWindow = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od);
     }
     /**
-     * The time at which this cursor occurrence group ends.
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     *
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    get endTime() {
-        return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
+    static isEligibleToDetect(difficultyAttributes) {
+        return difficultyAttributes.possibleThreeFingeredSections.length > 0;
     }
     /**
-     * The duration this cursor occurrence group is active for.
+     * Checks if the given beatmap is 3-fingered and also returns the final penalty.
+     *
+     * The beatmap will be separated into sections and each section will be determined
+     * whether or not it is dragged.
+     *
+     * After that, each section will be assigned a nerf factor based on whether or not
+     * the section is 3-fingered. These nerf factors will be summed up into a final
+     * nerf factor, taking beatmap difficulty into account.
      */
-    get duration() {
-        return this.endTime - this.startTime;
+    check() {
+        if (!RebalanceThreeFingerChecker.isEligibleToDetect(this.difficultyAttributes) ||
+            this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getAccurateBreakPoints();
+        this.filterCursorInstances();
+        this.getBeatmapSections();
+        this.calculateNerfFactors();
+        const finalPenalty = this.calculateFinalPenalty();
+        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
     }
     /**
-     * All cursor occurrences in this group.
+     * Generates a new set of "accurate break points".
      *
-     * This iterates all occurrences and as such should be used sparingly or stored locally.
+     * This is done to increase detection accuracy since break points do not start right at the
+     * end of the hitobject before it and do not end right at the first hitobject after it.
      */
-    get allOccurrences() {
-        const cursors = [this._down, ...this._moves];
-        if (this._up) {
-            cursors.push(this._up);
+    getAccurateBreakPoints() {
+        const objects = this.beatmap.hitObjects.objects;
+        const objectData = this.data.hitObjectData;
+        for (const breakPoint of this.beatmap.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            const objectBefore = objects[beforeIndex];
+            const objectBeforeData = objectData[beforeIndex];
+            let timeBefore = objectBefore.endTime;
+            if (objectBefore instanceof osuBase.Circle) {
+                if (objectBeforeData.result !== osuBase.HitResult.Miss) {
+                    timeBefore += objectBeforeData.accuracy;
+                }
+                else {
+                    timeBefore += this.hitWindow.mehWindow;
+                }
+            }
+            const afterIndex = beforeIndex + 1;
+            const objectAfter = objects[afterIndex];
+            const objectAfterData = objectData[afterIndex];
+            let timeAfter = objectAfter.startTime;
+            if (objectAfter instanceof osuBase.Circle &&
+                objectAfterData.result !== osuBase.HitResult.Miss) {
+                timeAfter += objectAfterData.accuracy;
+            }
+            this.breakPointAccurateTimes.push(new osuBase.BreakPoint(timeBefore, timeAfter));
         }
-        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`.
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
      *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
+     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
-    _up;
-    constructor(down, moves, up) {
-        this._down = down;
-        this._moves = moves;
-        // Re-set down cursor occurrence for checking.
-        this.down = down;
-        this.up = up;
-    }
-    /**
-     * Determines whether this cursor occurrence group is active at the specified time.
-     *
-     * @param time The time.
-     * @returns Whether this cursor occurrence group is active at the specified time.
-     */
-    isActiveAt(time) {
-        return time >= this.startTime && time <= this.endTime;
-    }
-    /**
-     * Finds the cursor occurrence that is active at a given time.
-     *
-     * @param time The time.
-     * @returns The cursor occurrence at the given time, `null` if not found.
-     */
-    cursorAt(time) {
-        if (!this.isActiveAt(time)) {
-            return null;
+    filterCursorInstances() {
+        const objects = this.beatmap.hitObjects.objects;
+        const objectData = this.data.hitObjectData;
+        const firstObjectResult = objectData[0].result;
+        const lastObjectResult = objectData.at(-1).result;
+        const firstObject = objects[0];
+        const lastObject = objects.at(-1);
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let firstObjectHitWindow = this.hitWindow.mehWindow;
+        if (firstObject instanceof osuBase.Circle) {
+            switch (firstObjectResult) {
+                case osuBase.HitResult.Great:
+                    firstObjectHitWindow = this.hitWindow.greatWindow;
+                    break;
+                case osuBase.HitResult.Good:
+                    firstObjectHitWindow = this.hitWindow.okWindow;
+                    break;
+                default:
+                    firstObjectHitWindow = this.hitWindow.mehWindow;
+            }
         }
-        if (this._down.time === time) {
-            return this._down;
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let lastObjectHitWindow = this.hitWindow.mehWindow;
+        if (lastObject instanceof osuBase.Circle) {
+            switch (lastObjectResult) {
+                case osuBase.HitResult.Great:
+                    lastObjectHitWindow = this.hitWindow.greatWindow;
+                    break;
+                case osuBase.HitResult.Good:
+                    lastObjectHitWindow = this.hitWindow.okWindow;
+                    break;
+                default:
+                    lastObjectHitWindow = this.hitWindow.mehWindow;
+            }
         }
-        if (this._up?.time === time) {
-            return this._up;
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectHitWindow = Math.min(lastObject.spanDuration, lastObjectHitWindow);
         }
-        let l = 0;
-        let r = this._moves.length - 2;
-        while (l <= r) {
-            const pivot = l + ((r - l) >> 1);
-            if (this._moves[pivot].time < time) {
-                l = pivot + 1;
-            }
-            else if (this._moves[pivot].time > time) {
-                r = pivot - 1;
-            }
-            else {
-                return this._moves[pivot];
+        // These hit time uses hit window length as threshold.
+        // This is because cursors aren't recorded exactly at hit time,
+        // probably due to the game's behavior.
+        const firstObjectHitTime = firstObject.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = lastObject.startTime + lastObjectHitWindow;
+        for (const cursorInstance of this.data.cursorMovement) {
+            const validOccurrences = [];
+            for (const group of cursorInstance.occurrenceGroups) {
+                if (group.startTime < firstObjectHitTime) {
+                    continue;
+                }
+                if (group.startTime > lastObjectHitTime) {
+                    break;
+                }
+                if (this.breakPointAccurateTimes.some((v) => group.startTime >= v.startTime &&
+                    group.endTime <= v.endTime)) {
+                    continue;
+                }
+                validOccurrences.push(group.down);
             }
+            this.downCursorInstances.push(validOccurrences);
         }
-        // l will be the first cursor occurrence with time > this._moves[l].time, but we want the one before it
-        return this._moves[l - 1];
     }
-}
-
-/**
- * Represents a cursor instance in an osu!droid replay.
- *
- * Stores cursor movement data in the form of `CursorOccurrenceGroup`s.
- *
- * 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.
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
      */
-    get earliestOccurrenceTime() {
-        return this.occurrenceGroups.at(0)?.startTime ?? null;
+    getBeatmapSections() {
+        const beatmapObjects = this.beatmap.hitObjects.objects;
+        const aimCursorGroupLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        // This intentionally starts from 1 because we need to look at the previous cursor.
+        const aimCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 1);
+        const pressCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        for (const section of this.difficultyAttributes
+            .possibleThreeFingeredSections) {
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                const object = beatmapObjects[i];
+                const objectData = this.data.hitObjectData[i];
+                objects.push({
+                    object: object,
+                    aimingCursorInstanceIndex: this.getObjectAimIndex(object, objectData, aimCursorGroupLookupIndices, aimCursorLookupIndices),
+                    pressingCursorInstanceIndex: this.getObjectPressIndex(object, objectData, pressCursorLookupIndices),
+                });
+            }
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { objects: objects }));
+        }
     }
     /**
-     * The time at which the latest occurrence of this cursor instance occurs.
+     * Obtains the index of the cursor that aimed the object at the nearest time.
      *
-     * Will return `null` if there are no occurrences.
-     */
-    get latestOccurrenceTime() {
-        return this.occurrenceGroups.at(-1)?.endTime ?? null;
-    }
-    /**
-     * The amount of cursor occurrences of this cursor instance.
-     */
-    get totalOccurrences() {
-        return this.occurrenceGroups.reduce((a, v) => {
-            // Down cursor.
-            ++a;
-            // Move cursors.
-            a += v.moves.length;
-            if (v.up) {
-                // Up cursor.
-                ++a;
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorInstanceIndices The cursor indices to start looking for the cursor instance from, to save computation time.
+     * @param cursorGroupIndices The cursor indices to start looking for the cursor group from, to save computation time.
+     * @param cursorIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
+        if (objectData.result === osuBase.HitResult.Miss || object instanceof osuBase.Spinner) {
+            return -1;
+        }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
             }
-            return a;
-        }, 0);
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
+            }
+        }
+        const hitTime = object.startTime + objectData.accuracy;
+        const objectPosition = object.stackedPosition;
+        // We are maintaining the closest distance to the object.
+        // This is because the radius that is calculated is using an estimation.
+        // As such, it does not reflect the actual object radius in gameplay.
+        let closestDistance = Number.POSITIVE_INFINITY;
+        let nearestCursorIndex = -1;
+        // Observe the cursor position at the object's hit time.
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = cursorGroupIndices[i]; j < cursorData.occurrenceGroups.length; cursorGroupIndices[i] = ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < hitTime) {
+                    // Reset cursor index pointer.
+                    cursorIndices[i] = 1;
+                    continue;
+                }
+                if (cursorGroup.startTime > hitTime) {
+                    break;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = cursorIndices[i]; k < cursors.length; cursorIndices[i] = ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    // Cursor is past the object's hit time.
+                    if (prevCursor.time > hitTime) {
+                        break;
+                    }
+                    // Cursor is before the object's hit time.
+                    if (hitTime > cursor.time) {
+                        continue;
+                    }
+                    let distance;
+                    const currentPosition = this.getCursorPosition(cursor);
+                    const prevPosition = this.getCursorPosition(prevCursor);
+                    switch (cursor.id) {
+                        case exports.MovementType.Up:
+                            distance = prevPosition.getDistance(objectPosition);
+                            break;
+                        case exports.MovementType.Move: {
+                            // Interpolate movement.
+                            const t = (hitTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                            distance =
+                                objectPosition.getDistance(cursorPosition);
+                            break;
+                        }
+                        case exports.MovementType.Down:
+                            continue;
+                    }
+                    if (closestDistance > distance) {
+                        closestDistance = distance;
+                        nearestCursorIndex = i;
+                    }
+                }
+                // Reset cursor index pointer on end of group.
+                if (cursorIndices[i] === cursors.length) {
+                    cursorIndices[i] = 1;
+                }
+                break;
+            }
+            // The previous object may still be hit with the same cursor group or cursor index.
+            cursorGroupIndices[i] = Math.max(0, cursorGroupIndices[i] - 1);
+            cursorIndices[i] = Math.max(1, cursorIndices[i] - 1);
+        }
+        return nearestCursorIndex;
     }
     /**
-     * All cursor occurrences of this cursor instnace.
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
      *
-     * This iterates all occurrence groups and as such should be used sparingly or stored locally.
-     */
-    get allOccurrences() {
-        return this.occurrenceGroups.flatMap((v) => v.allOccurrences);
-    }
-    constructor(values) {
-        let downOccurrence = null;
-        let moveOccurrences = [];
-        for (let i = 0; i < values.size; ++i) {
-            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
-            switch (occurrence.id) {
-                case exports.MovementType.down:
-                    downOccurrence = occurrence;
-                    break;
-                case exports.MovementType.move:
-                    moveOccurrences.push(occurrence);
-                    break;
-                case exports.MovementType.up:
-                    if (downOccurrence) {
-                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
-                        downOccurrence = null;
-                    }
-                    moveOccurrences = [];
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorLookupIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @param excludedIndices The cursor indices that should not be checked.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectPressIndex(object, objectData, cursorLookupIndices) {
+        if (objectData.result === osuBase.HitResult.Miss || object instanceof osuBase.Spinner) {
+            return -1;
+        }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
             }
         }
-        // Add the final cursor occurrence group as the loop may not catch it for special cases.
-        if (downOccurrence && moveOccurrences.length > 0) {
-            this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences));
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = -1;
+        let nearestTime = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            const cursors = this.downCursorInstances[i];
+            let cursorNearestTime = Number.POSITIVE_INFINITY;
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time > hitTime) {
+                    break;
+                }
+                cursorNearestTime = hitTime - cursor.time;
+            }
+            if (cursorNearestTime < nearestTime) {
+                nearestCursorInstanceIndex = i;
+                nearestTime = cursorNearestTime;
+            }
         }
+        return nearestCursorInstanceIndex;
     }
-}
-
-/**
- * The result of a hit in an osu!droid replay.
- */
-exports.HitResult = void 0;
-(function (HitResult) {
-    /**
-     * Miss (0).
-     */
-    HitResult[HitResult["miss"] = 1] = "miss";
-    /**
-     * Meh (50).
-     */
-    HitResult[HitResult["meh"] = 2] = "meh";
     /**
-     * Good (100).
+     * Creates nerf factors by scanning through objects.
      */
-    HitResult[HitResult["good"] = 3] = "good";
+    calculateNerfFactors() {
+        for (const beatmapSection of this.beatmapSections) {
+            const threeFingerCursorCounts = osuBase.Utils.initializeArray(Math.max(0, this.downCursorInstances.length - 2), 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorInstanceIndex === -1) {
+                    continue;
+                }
+                if (object.aimingCursorInstanceIndex < 3) {
+                    // The aim cursor is in the first three cursors. They are counted as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                        case 2:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 3];
+                            break;
+                    }
+                }
+                else {
+                    // The aim cursor is somewhere else. only count the first 2 cursors as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 2];
+                            break;
+                    }
+                }
+            }
+            const threeFingerCursorCount = threeFingerCursorCounts.reduce((a, v) => a + v, 0);
+            if (threeFingerCursorCount === 0) {
+                continue;
+            }
+            const sectionObjectCount = beatmapSection.objects.length;
+            const threeFingeredObjectRatio = threeFingerCursorCount / sectionObjectCount;
+            const strainFactor = Math.max(1, beatmapSection.sumStrain * threeFingeredObjectRatio);
+            // Finger factor applies more penalty if more fingers were used.
+            const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                Math.pow(((index + 1) * count) / sectionObjectCount, 0.9), 1);
+            // Length factor applies more penalty if there are more 3-fingered object.
+            const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 0.8);
+            this.nerfFactors.push({
+                strainFactor: strainFactor,
+                fingerFactor: fingerFactor,
+                lengthFactor: lengthFactor,
+            });
+        }
+    }
     /**
-     * Great (300).
+     * Calculates the final penalty.
      */
-    HitResult[HitResult["great"] = 4] = "great";
-})(exports.HitResult || (exports.HitResult = {}));
-
-/**
- * Represents a replay data in an osu!droid replay.
- *
- * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
- *
- * 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;
-    speedModification;
-    forcedAR;
-    constructor(values) {
-        this.replayVersion = values.replayVersion;
-        this.folderName = values.folderName;
-        this.fileName = values.fileName;
-        this.hash = values.hash;
-        this.time = new Date(values.time || 0);
-        this.hit300k = values.hit300k || 0;
-        this.hit100k = values.hit100k || 0;
-        this.score = values.score || 0;
-        this.maxCombo = values.maxCombo || 0;
-        this.accuracy = values.accuracy || new osuBase.Accuracy({});
-        this.isFullCombo = values.isFullCombo || false;
-        this.playerName = values.playerName || "";
-        this.rawMods = values.rawMods || "";
-        this.rank = values.rank || "";
-        this.convertedMods = values.convertedMods || [];
-        this.cursorMovement = values.cursorMovement;
-        this.hitObjectData = values.hitObjectData;
-        this.speedModification = values.speedModification || 1;
-        this.forcedAR = values.forcedAR;
+    calculateFinalPenalty() {
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
     }
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
-class ThreeFingerChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The true scale of objects.
-     */
-    trueScale;
-    /**
-     * 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;
+class SliderCheeseChecker {
     /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    cursorDistancingCountThreshold = 10;
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
+    }
     /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
+     * Checks if relevant sliders in the given beatmap was cheesed.
      */
-    cursorDistancingTimeThreshold = 1000;
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            this.difficultyAttributes.sliderFactor === 1) {
+            return 1;
+        }
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
+    }
     /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
+     * Checks for sliders that were cheesed.
      */
-    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 = [];
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
+            }
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === osuBase.HitResult.Miss) {
+                continue;
+            }
+            let lateHitThreshold = this.hitWindow50;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow50 ||
+                objectData.accuracy > lateHitThreshold) {
+                continue;
+            }
+            const objectStartPosition = object.stackedPosition;
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.Up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.Move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
+            }
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
+            }
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
+                    break;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.stackedPosition;
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.Move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
+                    }
+                    case exports.MovementType.Up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            }
+        }
+        return cheesedDifficultyRatings;
+    }
     /**
-     * Whether this score uses the Precise mod.
+     * Calculates the slider cheese penalty.
      */
-    isPrecise;
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+            summedDifficultyRating *
+                this.difficultyAttributes.sliderFactor, 2));
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
+
+/**
+ * Utility to check whether or not a beatmap is three-fingered for live scores.
+ */
+class ThreeFingerChecker {
     /**
      * @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) {
+        /**
+         * 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 stats = new osuBase.MapStats({
-            od: this.beatmap.difficulty.od,
-            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
-        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        this.strainNoteCount =
-            this.difficultyAttributes.possibleThreeFingeredSections.reduce((a, v) => a + v.lastObjectIndex - v.firstObjectIndex + 1, 0);
-        const circleSize = new osuBase.MapStats({
-            cs: this.beatmap.difficulty.cs,
-            mods: this.difficultyAttributes.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        this.trueScale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
+        this.hitWindow = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od)
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od);
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -492,20 +930,13 @@ class ThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.strainNoteCount === 0) {
+        if (!ThreeFingerChecker.isEligibleToDetect(this.difficultyAttributes) ||
+            this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 3) {
             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();
-        this.detectDragPlay();
-        this.preventAccidentalTaps();
-        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 };
@@ -514,46 +945,33 @@ class ThreeFingerChecker {
      * Generates a new set of "accurate break points".
      *
      * This is done 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.
+     * end of the hitobject before it and do not end right at the first hitobject after it.
      */
     getAccurateBreakPoints() {
-        const { objects } = this.beatmap.hitObjects;
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         for (const breakPoint of this.beatmap.events.breaks) {
             const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
-            let timeBefore = objects[beforeIndex].endTime;
-            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
-            switch (objectData[beforeIndex].result) {
-                case exports.HitResult.great:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
+            const objectBefore = objects[beforeIndex];
+            const objectBeforeData = objectData[beforeIndex];
+            let timeBefore = objectBefore.endTime;
+            if (objectBefore instanceof osuBase.Circle) {
+                if (objectBeforeData.result !== osuBase.HitResult.Miss) {
+                    timeBefore += objectBeforeData.accuracy;
+                }
+                else {
+                    timeBefore += this.hitWindow.mehWindow;
+                }
             }
-            timeBefore += beforeIndexHitWindowLength;
             const afterIndex = beforeIndex + 1;
-            let timeAfter = objects[afterIndex].startTime;
-            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
-            switch (objectData[afterIndex].result) {
-                case exports.HitResult.great:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(this.isPrecise);
+            const objectAfter = objects[afterIndex];
+            const objectAfterData = objectData[afterIndex];
+            let timeAfter = objectAfter.startTime;
+            if (objectAfter instanceof osuBase.Circle &&
+                objectAfterData.result !== osuBase.HitResult.Miss) {
+                timeAfter += objectAfterData.accuracy;
             }
-            timeAfter += afterIndexHitWindowLength;
-            this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
-                startTime: timeBefore,
-                endTime: timeAfter,
-            }));
+            this.breakPointAccurateTimes.push(new osuBase.BreakPoint(timeBefore, timeAfter));
         }
     }
     /**
@@ -562,48 +980,51 @@ class ThreeFingerChecker {
      * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
     filterCursorInstances() {
-        const { objects } = this.beatmap.hitObjects;
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
+        const firstObject = objects[0];
+        const lastObject = objects.at(-1);
         // For sliders, automatically set hit window length to be as lenient as possible.
-        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
-        if (objects[0] instanceof osuBase.Circle) {
+        let firstObjectHitWindow = this.hitWindow.mehWindow;
+        if (firstObject instanceof osuBase.Circle) {
             switch (firstObjectResult) {
-                case exports.HitResult.great:
-                    firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                case osuBase.HitResult.Great:
+                    firstObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
-                    firstObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                case osuBase.HitResult.Good:
+                    firstObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
-                    firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+                    firstObjectHitWindow = this.hitWindow.mehWindow;
             }
         }
         // For sliders, automatically set hit window length to be as lenient as possible.
-        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
-        if (objects.at(-1) instanceof osuBase.Circle) {
+        let lastObjectHitWindow = this.hitWindow.mehWindow;
+        if (lastObject instanceof osuBase.Circle) {
             switch (lastObjectResult) {
-                case exports.HitResult.great:
-                    lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                case osuBase.HitResult.Great:
+                    lastObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
-                    lastObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                case osuBase.HitResult.Good:
+                    lastObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
-                    lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+                    lastObjectHitWindow = this.hitWindow.mehWindow;
             }
         }
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectHitWindow = Math.min(lastObject.spanDuration, lastObjectHitWindow);
+        }
         // These hit time uses hit window length as threshold.
         // This is because cursors aren't recorded exactly at hit time,
         // probably due to the game's behavior.
-        const firstObjectHitTime = objects[0].startTime - firstObjectHitWindow;
-        const lastObjectHitTime = objects.at(-1).startTime + lastObjectHitWindow;
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const cursorInstance = this.data.cursorMovement[i];
+        const firstObjectHitTime = firstObject.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = lastObject.startTime + lastObjectHitWindow;
+        for (const cursorInstance of this.data.cursorMovement) {
             const validOccurrences = [];
-            for (let j = 0; j < cursorInstance.occurrenceGroups.length; ++j) {
-                const group = cursorInstance.occurrenceGroups[j];
+            for (const group of cursorInstance.occurrenceGroups) {
                 if (group.startTime < firstObjectHitTime) {
                     continue;
                 }
@@ -624,329 +1045,231 @@ class ThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
+        const beatmapObjects = this.beatmap.hitObjects.objects;
+        const aimCursorGroupLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        // This intentionally starts from 1 because we need to look at the previous cursor.
+        const aimCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 1);
+        const pressCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            this.beatmapSections.push({
-                ...section,
-                isDragged: false,
-                dragFingerIndex: -1,
-            });
-        }
-    }
-    /**
-     * Checks whether or not each beatmap sections is dragged.
-     */
-    detectDragPlay() {
-        for (let i = 0; i < this.beatmapSections.length; ++i) {
-            const dragIndex = this.checkDrag(this.beatmapSections[i]);
-            this.beatmapSections[i].dragFingerIndex = dragIndex;
-            this.beatmapSections[i].isDragged = dragIndex !== -1;
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                const object = beatmapObjects[i];
+                const objectData = this.data.hitObjectData[i];
+                objects.push({
+                    object: object,
+                    aimingCursorInstanceIndex: this.getObjectAimIndex(object, objectData, aimCursorGroupLookupIndices, aimCursorLookupIndices),
+                    pressingCursorInstanceIndex: this.getObjectPressIndex(object, objectData, pressCursorLookupIndices),
+                });
+            }
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { objects: objects }));
         }
     }
     /**
-     * Checks if a section is dragged and returns the index of the drag finger.
+     * Obtains the index of the cursor that aimed the object at the nearest time.
      *
-     * If the section is not dragged, -1 will be returned.
-     *
-     * @param section The section to check.
-     */
-    checkDrag(section) {
-        const { objects } = this.beatmap.hitObjects;
-        const objectData = this.data.hitObjectData;
-        const firstObject = objects[section.firstObjectIndex];
-        const lastObject = objects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.startTime;
-        if (firstObject instanceof osuBase.Circle) {
-            switch (objectData[section.firstObjectIndex].result) {
-                case exports.HitResult.great:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorInstanceIndices The cursor indices to start looking for the cursor instance from, to save computation time.
+     * @param cursorGroupIndices The cursor indices to start looking for the cursor group from, to save computation time.
+     * @param cursorIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
+        if (objectData.result === osuBase.HitResult.Miss || object instanceof osuBase.Spinner) {
+            return -1;
+        }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
             }
-        }
-        else {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
-        }
-        let lastObjectMaxHitTime = lastObject.startTime;
-        if (lastObject instanceof osuBase.Circle) {
-            switch (objectData[section.lastObjectIndex].result) {
-                case exports.HitResult.great:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
             }
         }
-        else {
-            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
-        }
-        // Since there may be more than 1 cursor instance index,
-        // we check which cursor instance follows hitobjects all over.
-        const cursorIndexes = [];
+        const hitTime = object.startTime + objectData.accuracy;
+        const objectPosition = object.stackedPosition;
+        // We are maintaining the closest distance to the object.
+        // This is because the radius that is calculated is using an estimation.
+        // As such, it does not reflect the actual object radius in gameplay.
+        let closestDistance = Number.POSITIVE_INFINITY;
+        let nearestCursorIndex = -1;
+        // Observe the cursor position at the object's hit time.
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.occurrenceGroups.length === 0) {
-                continue;
-            }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
-                v.endTime <= lastObjectMaxHitTime).length === 0) {
-                continue;
-            }
-            // If this cursor instance doesn't move, it's not the cursor instance we want.
-            if (c.occurrenceGroups.filter((v) => v.moves.length > 0).length ===
-                0) {
-                continue;
-            }
-            cursorIndexes.push(i);
-        }
-        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
-    }
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
-    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
-        for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
-            let object = sectionObjects[i];
-            const objectData = sectionReplayObjectData[i];
-            if (object instanceof osuBase.Spinner ||
-                objectData.result === exports.HitResult.miss) {
-                continue;
-            }
-            // Exclude sliderbreaks.
-            if (object instanceof osuBase.Slider &&
-                objectData.accuracy === Math.floor(hitWindow50) + 13) {
-                continue;
-            }
-            if (object.droidScale !== this.trueScale) {
-                // Deep copy the instance so that we can assign scale.
-                object = osuBase.Utils.deepCopy(object);
-                object.droidScale = this.trueScale;
-            }
-            const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
-            const hitTime = object.startTime + objectData.accuracy;
-            // Observe the cursor position at the object's hit time.
-            for (let j = 0; j < cursorIndexes.length; ++j) {
-                if (cursorIndexes[j] === -1) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = cursorGroupIndices[i]; j < cursorData.occurrenceGroups.length; cursorGroupIndices[i] = ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < hitTime) {
+                    // Reset cursor index pointer.
+                    cursorIndices[i] = 1;
                     continue;
                 }
-                const cursorData = this.data.cursorMovement[cursorIndexes[j]];
-                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
-                if (!cursorGroup) {
-                    continue;
+                if (cursorGroup.startTime > hitTime) {
+                    break;
                 }
                 const cursors = cursorGroup.allOccurrences;
-                for (let k = 1; k < cursors.length; ++k) {
+                for (let k = cursorIndices[i]; k < cursors.length; cursorIndices[i] = ++k) {
                     const cursor = cursors[k];
                     const prevCursor = cursors[k - 1];
-                    if (prevCursor.time < object.startTime - hitWindow50) {
-                        continue;
-                    }
-                    if (prevCursor.time > object.startTime + hitWindow50) {
+                    // Cursor is past the object's hit time.
+                    if (prevCursor.time > hitTime) {
                         break;
                     }
-                    let isInObject = false;
+                    // Cursor is before the object's hit time.
+                    if (hitTime > cursor.time) {
+                        continue;
+                    }
+                    let distance;
+                    const currentPosition = this.getCursorPosition(cursor);
+                    const prevPosition = this.getCursorPosition(prevCursor);
                     switch (cursor.id) {
-                        case exports.MovementType.up:
-                            isInObject =
-                                prevCursor.position.getDistance(objectPosition) <= object.getRadius(osuBase.Modes.droid);
+                        case exports.MovementType.Up:
+                            distance = prevPosition.getDistance(objectPosition);
                             break;
-                        case exports.MovementType.move:
+                        case exports.MovementType.Move: {
                             // Interpolate movement.
-                            for (let mSecPassed = prevCursor.time; !isInObject &&
-                                mSecPassed <=
-                                    Math.min(cursor.time, object.startTime + hitWindow50); ++mSecPassed) {
-                                const t = (mSecPassed - prevCursor.time) /
-                                    (cursor.time - prevCursor.time);
-                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
-                                isInObject =
-                                    objectPosition.getDistance(cursorPosition) <= object.getRadius(osuBase.Modes.droid);
-                            }
+                            const t = (hitTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                            distance =
+                                objectPosition.getDistance(cursorPosition);
+                            break;
+                        }
+                        case exports.MovementType.Down:
+                            continue;
                     }
-                    if (!isInObject) {
-                        cursorIndexes[j] = -1;
+                    if (closestDistance > distance) {
+                        closestDistance = distance;
+                        nearestCursorIndex = i;
                     }
                 }
+                // Reset cursor index pointer on end of group.
+                if (cursorIndices[i] === cursors.length) {
+                    cursorIndices[i] = 1;
+                }
+                break;
             }
+            // The previous object may still be hit with the same cursor group or cursor index.
+            cursorGroupIndices[i] = Math.max(0, cursorGroupIndices[i] - 1);
+            cursorIndices[i] = Math.max(1, cursorIndices[i] - 1);
         }
-        return cursorIndexes.find((v) => v !== -1) ?? -1;
+        return nearestCursorIndex;
     }
     /**
-     * Attempts to prevent accidental taps from being flagged.
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
      *
-     * This detection will filter cursors that don't hit
-     * any object in beatmap sections, thus eliminating any
-     * unnecessary taps.
-     */
-    preventAccidentalTaps() {
-        let filledCursorAmount = this.downCursorInstances.filter((v) => v.length > 0).length;
-        if (filledCursorAmount <= 3) {
-            return;
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorLookupIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @param excludedIndices The cursor indices that should not be checked.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectPressIndex(object, objectData, cursorLookupIndices) {
+        if (objectData.result === osuBase.HitResult.Miss || object instanceof osuBase.Spinner) {
+            return -1;
+        }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
+            }
         }
-        const { objects } = this.beatmap.hitObjects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.length, 0);
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = -1;
+        let nearestTime = Number.POSITIVE_INFINITY;
         for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (filledCursorAmount <= 3) {
-                break;
+            const cursors = this.downCursorInstances[i];
+            let cursorNearestTime = Number.POSITIVE_INFINITY;
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time > hitTime) {
+                    break;
+                }
+                cursorNearestTime = hitTime - cursor.time;
             }
-            const cursorInstances = this.downCursorInstances[i];
-            // Use an estimation for accidental tap threshold.
-            if (cursorInstances.length <=
-                Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstances.length / totalCursorAmount <
-                    this.threeFingerRatioThreshold * 2) {
-                --filledCursorAmount;
-                cursorInstances.length = 0;
+            if (cursorNearestTime < nearestTime) {
+                nearestCursorInstanceIndex = i;
+                nearestTime = cursorNearestTime;
             }
-            this.downCursorInstances[i] = cursorInstances;
         }
+        return nearestCursorInstanceIndex;
     }
     /**
      * Creates nerf factors by scanning through objects.
-     *
-     * This check will ignore all objects with speed strain below `strainThreshold`.
      */
     calculateNerfFactors() {
-        const { objects } = this.beatmap.hitObjects;
-        const objectData = this.data.hitObjectData;
-        // We only filter cursor instances that are above the strain threshold.
-        // This minimalizes the amount of cursor instances to analyze.
         for (const beatmapSection of this.beatmapSections) {
-            const dragIndex = beatmapSection.dragFingerIndex;
-            const startTime = objects[beatmapSection.firstObjectIndex].startTime +
-                (objectData[beatmapSection.firstObjectIndex].result !==
-                    exports.HitResult.miss
-                    ? objectData[beatmapSection.firstObjectIndex].accuracy
-                    : -this.hitWindow.hitWindowFor50(this.isPrecise));
-            const endTime = objects[beatmapSection.lastObjectIndex].endTime +
-                (objectData[beatmapSection.lastObjectIndex].result !==
-                    exports.HitResult.miss
-                    ? objectData[beatmapSection.lastObjectIndex].accuracy
-                    : this.hitWindow.hitWindowFor50(this.isPrecise));
-            const cursorAmounts = [];
-            const cursorVectorTimes = [];
-            for (let i = 0; i < this.downCursorInstances.length; ++i) {
-                // Do not include drag cursor instance.
-                if (i === dragIndex) {
+            const threeFingerCursorCounts = osuBase.Utils.initializeArray(Math.max(0, this.downCursorInstances.length - 2), 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorInstanceIndex === -1) {
                     continue;
                 }
-                const cursors = this.downCursorInstances[i];
-                let amount = 0;
-                for (let j = 0; j < cursors.length; ++j) {
-                    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,
-                        });
+                if (object.aimingCursorInstanceIndex < 3) {
+                    // The aim cursor is in the first three cursors. They are counted as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                        case 2:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 3];
+                            break;
                     }
                 }
-                cursorAmounts.push(amount);
-            }
-            // 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.
-            const fingerSplitIndex = dragIndex !== -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
-                .slice(fingerSplitIndex)
-                .reduce((acc, value) => acc + value, 0) /
-                cursorAmounts
-                    .slice(0, fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0);
-            const similarPresses = [];
-            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) {
-                        similarPresses.splice(pressIndex, 1);
-                        similarPresses.push({
-                            vector: cursorVectorTime.vector,
-                            count: 1,
-                            lastTime: cursorVectorTime.time,
-                        });
-                        continue;
+                else {
+                    // The aim cursor is somewhere else. only count the first 2 cursors as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 2];
+                            break;
                     }
-                    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 validPresses = similarPresses
-                .filter((v) => v.count >= this.cursorDistancingCountThreshold)
-                .sort((a, b) => b.count - a.count)
-                .slice(2);
-            // Ignore cursor presses that are only 1 for now since they are very likely to be accidental
-            if ((threeFingerRatio > this.threeFingerRatioThreshold &&
-                cursorAmounts.filter((v) => v > 1).length >
-                    fingerSplitIndex) ||
-                validPresses.length > 0) {
-                // Strain factor
-                const objectCount = beatmapSection.lastObjectIndex -
-                    beatmapSection.firstObjectIndex +
-                    1;
-                // We can ignore the first 3 (2 for drag) filled cursor instances
-                // since they are guaranteed not 3 finger.
-                const threeFingerCursorAmounts = cursorAmounts
-                    .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(validPresses.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) *
-                            (value.count /
-                                (this
-                                    .cursorDistancingCountThreshold *
-                                    2)) *
-                            objectCount) /
-                            this.strainNoteCount, 0.2), 1), 0.2);
-                // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
-                this.nerfFactors.push({
-                    strainFactor: Math.max(1, beatmapSection.sumStrain),
-                    fingerFactor,
-                    lengthFactor,
-                });
             }
+            const threeFingerCursorCount = threeFingerCursorCounts.reduce((a, v) => a + v, 0);
+            if (threeFingerCursorCount === 0) {
+                continue;
+            }
+            const sectionObjectCount = beatmapSection.objects.length;
+            const threeFingeredObjectRatio = threeFingerCursorCount / sectionObjectCount;
+            const strainFactor = Math.max(1, beatmapSection.sumStrain * threeFingeredObjectRatio);
+            // Finger factor applies more penalty if more fingers were used.
+            const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                Math.pow(((index + 1) * count) / sectionObjectCount, 0.9), 1);
+            // Length factor applies more penalty if there are more 3-fingered object.
+            const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 0.8);
+            this.nerfFactors.push({
+                strainFactor: strainFactor,
+                fingerFactor: fingerFactor,
+                lengthFactor: lengthFactor,
+            });
         }
     }
     /**
      * Calculates the final penalty.
      */
     calculateFinalPenalty() {
-        return (1 +
-            this.nerfFactors.reduce((a, n) => a +
-                0.015 *
-                    Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 0));
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
     }
 }
 
@@ -955,63 +1278,24 @@ class ThreeFingerChecker {
  */
 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 object The underlying hitobject.
      * @param cursorIndex The cursor index that moves towards the hitobject.
      * @param groupIndex The group index of the cursor within the cursor index that hits the hitobject.
      * @param occurrenceIndex The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
      * @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;
         this.occurrenceIndex = occurrenceIndex;
         this.angle = angle;
         this.is2Handed = is2Handed;
-        this.endCursorPosition = this.object.object.getStackedEndPosition(osuBase.Modes.droid);
+        this.endCursorPosition = this.object.stackedEndPosition;
     }
 }
 
@@ -1020,41 +1304,26 @@ 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 beatmap The beatmap to analyze.
+     * @param attributes The difficulty attributes to analyze.
      * @param data The data of the replay.
      */
-    constructor(calculator, data) {
-        this.calculator = calculator;
+    constructor(beatmap, attributes, data) {
+        /**
+         * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+         */
+        this.indexedHitObjects = [];
+        this.beatmap = beatmap;
+        this.attributes = attributes;
         this.data = data;
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+        const greatWindow = new osuBase.OsuHitWindow(attributes.overallDifficulty).greatWindow *
+            attributes.clockRate;
+        this.hitWindow = attributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(osuBase.PreciseDroidHitWindow.greatWindowToOD(greatWindow))
+            : new osuBase.DroidHitWindow(osuBase.DroidHitWindow.greatWindowToOD(greatWindow));
+        this.isHardRock = attributes.mods.has(osuBase.ModHardRock);
         // this.csvString = `Mods,${
         //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
         // }\nCombo,${data.maxCombo}\nAccuracy,"${(
@@ -1114,26 +1383,36 @@ class TwoHandChecker {
         //     ),
         //     this.csvString
         // );
-        let twoHandedNoteCount = 0;
-        const maxStrain = Math.max(...this.calculator.objects.map((v) => v.aimStrainWithSliders));
-        if (maxStrain) {
-            twoHandedNoteCount = this.indexedHitObjects.reduce((total, object) => {
-                if (!object.is2Handed) {
-                    return total;
-                }
-                return (total +
-                    1 /
-                        (1 +
-                            Math.exp(-((object.object.aimStrainWithSliders /
-                                maxStrain) *
-                                12 -
-                                6))));
-            }, 0);
-        }
+        // let twoHandedNoteCount = 0;
+        // const maxStrain = Math.max(
+        //     ...this.attributes.objects.map((v) => v.aimStrainWithSliders),
+        // );
+        // if (maxStrain) {
+        //     twoHandedNoteCount = this.indexedHitObjects.reduce(
+        //         (total, object) => {
+        //             if (!object.is2Handed) {
+        //                 return total;
+        //             }
+        //             return (
+        //                 total +
+        //                 1 /
+        //                     (1 +
+        //                         Math.exp(
+        //                             -(
+        //                                 (object.object.aimStrainWithSliders /
+        //                                     maxStrain) *
+        //                                     12 -
+        //                                 6
+        //                             ),
+        //                         ))
+        //             );
+        //         },
+        //         0,
+        //     );
+        // }
         return {
-            is2Hand: twoHandedNoteCount >
-                this.calculator.attributes.aimNoteCount * 0.15,
-            twoHandedNoteCount: twoHandedNoteCount,
+            is2Hand: false, // 0 > this.attributes.aimNoteCount * 0.15,
+            twoHandedNoteCount: 0,
         };
     }
     /**
@@ -1141,8 +1420,7 @@ class TwoHandChecker {
      */
     indexHitObjects() {
         const indexes = [];
-        for (let i = 0; i <
-            Math.min(this.data.hitObjectData.length, this.calculator.objects.length); ++i) {
+        for (let i = 0; i < this.data.hitObjectData.length; ++i) {
             const indexedHitObject = this.getIndexedHitObject(i);
             indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i]);
             indexes.push(indexedHitObject.cursorIndex);
@@ -1203,43 +1481,40 @@ class TwoHandChecker {
      * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
      */
     getIndexedHitObject(objectIndex) {
-        const diffObject = this.calculator.objects[objectIndex];
-        const { object } = diffObject;
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         // We don't care about the first object and spinners.
         if (objectIndex === 0 || object instanceof osuBase.Spinner) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         // We don't care if the aim strain is too low.
         // if (diffObject.aimStrainWithSliders < 200) {
         //     return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         // }
-        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        const prevObject = this.beatmap.hitObjects.objects[objectIndex - 1];
         const prevObjectData = this.data.hitObjectData[objectIndex - 1];
         if (prevObject instanceof osuBase.Spinner ||
-            prevObjectData.result === exports.HitResult.miss) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            prevObjectData.result === osuBase.HitResult.Miss) {
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
-        const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
-        let prevObjectEndPosition = prevObject.getStackedEndPosition(osuBase.Modes.droid);
+        const objectStartPosition = object.stackedPosition;
+        let prevObjectEndPosition = prevObject.stackedEndPosition;
         if (prevObject instanceof osuBase.Slider) {
-            if (prevObject.lazyTravelDistance > 0) {
-                const lazyEndMovement = objectStartPosition.subtract(prevObject.lazyEndPosition);
+            if (prevObject.distance > 0) {
+                const endPosition = prevObject.stackedEndPosition;
+                const lazyEndMovement = objectStartPosition.subtract(endPosition);
                 const actualEndMovement = objectStartPosition.subtract(prevObjectEndPosition);
                 if (lazyEndMovement.length < actualEndMovement.length) {
-                    prevObjectEndPosition = prevObject.lazyEndPosition;
+                    prevObjectEndPosition = endPosition;
                 }
             }
             else {
-                prevObjectEndPosition = prevObject.getStackedPosition(osuBase.Modes.droid);
+                prevObjectEndPosition = prevObject.stackedPosition;
             }
         }
-        const prevToCurrentMovement = object
-            .getStackedPosition(osuBase.Modes.droid)
-            .subtract(prevObjectEndPosition);
-        const radius = object.getRadius(osuBase.Modes.droid);
+        const prevToCurrentMovement = object.stackedPosition.subtract(prevObjectEndPosition);
         // Don't consider objects that are too close to each other.
-        if (prevToCurrentMovement.length <= radius) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        if (prevToCurrentMovement.length <= object.radius) {
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         // The case for a one-handed object is that there will be a slight movement in the cursor towards
         // the next object in fast patterns. We should not be worried about slow patterns as they will only
@@ -1259,12 +1534,12 @@ class TwoHandChecker {
         this.indexedHitObjects[objectIndex - 1].endCursorPosition =
             prevObjectInformation.position;
         if (prevObjectInformation.position.x === Number.POSITIVE_INFINITY) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         if (prevObjectInformation.cursorIndex ===
             objectInformation.cursorIndex &&
             prevObjectInformation.groupIndex === objectInformation.groupIndex) {
-            return new IndexedHitObject(diffObject, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
+            return new IndexedHitObject(object, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
         }
         const cursorData = this.data.cursorMovement[prevObjectInformation.cursorIndex];
         // There can be multiple angles to which the cursor moves towards the next object.
@@ -1276,13 +1551,15 @@ class TwoHandChecker {
         for (let i = prevObjectInformation.occurrenceIndex + 1; i < cursors.length; ++i) {
             const cursor = cursors[i];
             const prevCursor = cursors[i - 1];
-            if (cursor.position.equals(prevCursor.position)) {
+            const currentPosition = this.getCursorPosition(cursor);
+            const prevPosition = this.getCursorPosition(prevCursor);
+            if (currentPosition.equals(prevPosition)) {
                 continue;
             }
-            if (cursor.id === exports.MovementType.up) {
+            if (cursor.id === exports.MovementType.Up) {
                 break;
             }
-            const currentMovement = cursor.position.subtract(prevCursor.position);
+            const currentMovement = currentPosition.subtract(prevPosition);
             const dot = prevToCurrentCursorMovement.dot(currentMovement);
             const det = prevToCurrentCursorMovement.x * currentMovement.y -
                 prevToCurrentCursorMovement.y * currentMovement.x;
@@ -1344,9 +1621,9 @@ class TwoHandChecker {
         //     }
         // }
         if (!Number.isFinite(finalAngle)) {
-            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+            return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
-        return new IndexedHitObject(diffObject, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
+        return new IndexedHitObject(object, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
     }
     /**
      * Gets the position of the cursor that presses an object.
@@ -1355,9 +1632,9 @@ class TwoHandChecker {
      * @returns The position of the cursor that presses the object.
      */
     getCursorPositionForObjectStart(objectIndex) {
-        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         const data = this.data.hitObjectData[objectIndex];
-        const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+        const objectPosition = object.stackedPosition;
         if (object instanceof osuBase.Spinner) {
             return {
                 position: objectPosition,
@@ -1367,22 +1644,20 @@ class TwoHandChecker {
                 cursorTime: object.startTime,
             };
         }
-        const radius = object.getRadius(osuBase.Modes.droid);
-        let hitWindow = this.hitWindow50;
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        let hitWindow = this.hitWindow.mehWindow;
         // For sliders, set the hit window to as lenient as possible.
         if (object instanceof osuBase.Circle) {
             switch (data.result) {
-                case exports.HitResult.great:
-                    hitWindow = this.hitWindow.hitWindowFor300(isPrecise);
+                case osuBase.HitResult.Great:
+                    hitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
-                    hitWindow = this.hitWindow.hitWindowFor100(isPrecise);
+                case osuBase.HitResult.Good:
+                    hitWindow = this.hitWindow.okWindow;
                     break;
             }
         }
         // TODO: what to do for head sliderbreaks?
-        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY);
         let nearestCursorIndex = 0;
         let nearestGroupIndex = 0;
         let nearestCursorGroupIndex = 0;
@@ -1390,12 +1665,12 @@ class TwoHandChecker {
         const minimumActiveTime = object.startTime - hitWindow;
         const maximumActiveTime = object.startTime + hitWindow;
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            if (nearestPosition.getDistance(objectPosition) <= radius) {
+            if (nearestPosition.getDistance(objectPosition) <= object.radius) {
                 break;
             }
             const cursorData = this.data.cursorMovement[i];
             for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
-                if (nearestPosition.getDistance(objectPosition) <= radius) {
+                if (nearestPosition.getDistance(objectPosition) <= object.radius) {
                     break;
                 }
                 const cursorGroup = cursorData.occurrenceGroups[j];
@@ -1407,13 +1682,14 @@ class TwoHandChecker {
                 }
                 // Validate the down press first.
                 const { down } = cursorGroup;
-                if (down.position.getDistance(objectPosition) <= radius &&
+                const downPosition = this.getCursorPosition(down);
+                if (downPosition.getDistance(objectPosition) <= object.radius &&
                     Math.abs(down.time - object.startTime) <= hitWindow) {
                     if (objectIndex > 0) {
-                        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+                        const prevObject = this.beatmap.hitObjects.objects[objectIndex - 1];
                         if (down.time > prevObject.endTime) {
                             return {
-                                position: down.position,
+                                position: downPosition,
                                 cursorIndex: i,
                                 groupIndex: j,
                                 occurrenceIndex: 0,
@@ -1423,7 +1699,7 @@ class TwoHandChecker {
                     }
                     else {
                         return {
-                            position: down.position,
+                            position: downPosition,
                             cursorIndex: i,
                             groupIndex: j,
                             occurrenceIndex: 0,
@@ -1442,8 +1718,8 @@ class TwoHandChecker {
                         break;
                     }
                     let cursorPosition;
-                    if (cursor.id === exports.MovementType.up) {
-                        cursorPosition = prevCursor.position;
+                    if (cursor.id === exports.MovementType.Up) {
+                        cursorPosition = this.getCursorPosition(prevCursor);
                         const distance = cursorPosition.getDistance(objectPosition);
                         if (distance <
                             nearestPosition.getDistance(objectPosition)) {
@@ -1468,7 +1744,7 @@ class TwoHandChecker {
                             }
                             const t = (cursorGroup.down.time - prevCursor.time) /
                                 (cursor.time - prevCursor.time);
-                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            cursorPosition = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), t);
                             const distance = cursorPosition.getDistance(objectPosition);
                             if (distance <
                                 nearestPosition.getDistance(objectPosition)) {
@@ -1478,12 +1754,13 @@ class TwoHandChecker {
                                 nearestCursorGroupIndex = k;
                                 nearestCursorTime = cursorGroup.down.time;
                             }
-                            if (distance <= radius) {
+                            if (distance <= object.radius) {
                                 break;
                             }
                         }
                     }
-                    if (nearestPosition.getDistance(objectPosition) <= radius) {
+                    if (nearestPosition.getDistance(objectPosition) <=
+                        object.radius) {
                         break;
                     }
                 }
@@ -1514,24 +1791,25 @@ class TwoHandChecker {
      * @returns The position of the cursor at the object's end position.
      */
     getCursorPositionForObjectEnd(objectIndex) {
-        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const object = this.beatmap.hitObjects.objects[objectIndex];
         if (!(object instanceof osuBase.Slider)) {
             return this.getCursorPositionForObjectStart(objectIndex);
         }
-        const nextObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
-        let objectEndPosition = object.getStackedEndPosition(osuBase.Modes.droid);
-        if (object.lazyTravelDistance > 0 && nextObject) {
-            const nextStartPosition = nextObject.getStackedPosition(osuBase.Modes.droid);
-            const lazyEndMovement = nextStartPosition.subtract(object.lazyEndPosition);
+        const nextObject = this.beatmap.hitObjects.objects[objectIndex - 1];
+        let objectEndPosition = object.stackedEndPosition;
+        if (object.distance > 0 && nextObject) {
+            const endPosition = object.stackedEndPosition;
+            const nextStartPosition = nextObject.stackedPosition;
+            const lazyEndMovement = nextStartPosition.subtract(endPosition);
             const actualEndMovement = nextStartPosition.subtract(objectEndPosition);
             if (lazyEndMovement.length < actualEndMovement.length) {
-                objectEndPosition = object.lazyEndPosition;
+                objectEndPosition = endPosition;
             }
         }
         else {
-            objectEndPosition = object.getStackedPosition(osuBase.Modes.droid);
+            objectEndPosition = object.stackedPosition;
         }
-        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY);
         let nearestCursorIndex = 0;
         let nearestGroupIndex = 0;
         let nearestCursorGroupIndex = 0;
@@ -1551,19 +1829,19 @@ class TwoHandChecker {
                     const cursor = cursors[k];
                     let cursorPosition;
                     switch (cursor.id) {
-                        case exports.MovementType.down:
-                            cursorPosition = cursor.position;
+                        case exports.MovementType.Down:
+                            cursorPosition = this.getCursorPosition(cursor);
                             break;
-                        case exports.MovementType.up: {
+                        case exports.MovementType.Up: {
                             const prevCursor = cursors[k - 1];
-                            cursorPosition = prevCursor.position;
+                            cursorPosition = this.getCursorPosition(prevCursor);
                             break;
                         }
-                        case exports.MovementType.move: {
+                        case exports.MovementType.Move: {
                             const prevCursor = cursors[k - 1];
                             const t = osuBase.MathUtils.clamp((object.endTime - prevCursor.time) /
                                 (cursor.time - prevCursor.time), 0, 1);
-                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            cursorPosition = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), t);
                             break;
                         }
                     }
@@ -1573,15 +1851,15 @@ class TwoHandChecker {
                         nearestCursorIndex = i;
                         nearestGroupIndex = j;
                         switch (cursor.id) {
-                            case exports.MovementType.down:
+                            case exports.MovementType.Down:
                                 nearestCursorGroupIndex = k;
                                 nearestCursorTime = cursor.time;
                                 break;
-                            case exports.MovementType.up:
+                            case exports.MovementType.Up:
                                 nearestCursorGroupIndex = k - 1;
                                 nearestCursorTime = cursors[k - 1].time;
                                 break;
-                            case exports.MovementType.move:
+                            case exports.MovementType.Move:
                                 nearestCursorGroupIndex = k;
                                 nearestCursorTime = object.endTime;
                                 break;
@@ -1618,376 +1896,683 @@ class TwoHandChecker {
      * @returns Whether the slider was cheesed.
      */
     checkSliderCheesing(indexedHitObject, hitData) {
-        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
-            hitData.result === exports.HitResult.miss ||
+        if (!(indexedHitObject.object instanceof osuBase.Slider) ||
+            hitData.result === osuBase.HitResult.Miss ||
             indexedHitObject.cursorIndex === -1) {
             return false;
         }
         return false;
     }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
 }
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Represents a cursor's occurrence.
  */
-class SliderCheeseChecker {
+class CursorOccurrence {
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
     /**
-     * The beatmap that is being analyzed.
+     * Returns a string representation of this `CursorOccurrence`.
      */
-    beatmap;
+    toString() {
+        let str = `${this.time.toString()}ms `;
+        switch (this.id) {
+            case exports.MovementType.Down:
+                str += "Down";
+                break;
+            case exports.MovementType.Up:
+                str += "Up";
+                break;
+            case exports.MovementType.Move:
+                str += "Move";
+                break;
+        }
+        if (this.id !== exports.MovementType.Up) {
+            str += ` (${this.position.x.toFixed(2)}, ${this.position.y.toFixed(2)})`;
+        }
+        return str;
+    }
+}
+
+/**
+ * Represents a group of cursor occurrences representing a cursor instance's
+ * movement when a player places their finger on the screen.
+ */
+class CursorOccurrenceGroup {
     /**
-     * The data of the replay.
+     * The cursor occurrence of movement type `movementType.DOWN`.
      */
-    data;
+    get down() {
+        return this._down;
+    }
     /**
-     * The difficulty attributes of the beatmap.
+     * The cursor occurrence of movement type `movementType.DOWN`.
      */
-    difficultyAttributes;
+    set down(value) {
+        if (value.id !== exports.MovementType.Down) {
+            throw new TypeError("Attempting to set the down cursor occurrence to one with different movement type.");
+        }
+        this._down = value;
+    }
     /**
-     * The 50 osu!droid hit window of the analyzed beatmap.
+     * The cursor occurrences of movement type `movementType.MOVE`.
      */
-    hitWindow50;
+    get moves() {
+        return this._moves;
+    }
     /**
-     * @param beatmap The beatmap to analyze.
-     * @param data The data of the replay.
-     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     * 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.
      */
-    constructor(beatmap, data, difficultyAttributes) {
-        this.beatmap = beatmap;
-        this.data = data;
-        this.difficultyAttributes = difficultyAttributes;
-        const stats = new osuBase.MapStats({
-            od: this.beatmap.difficulty.od,
-            mods: this.difficultyAttributes.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate({ mode: osuBase.Modes.droid, convertDroidOD: false });
-        this.hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
+    get up() {
+        return this._up;
     }
     /**
-     * Checks if relevant sliders in the given beatmap was cheesed.
+     * 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.
      */
-    check() {
-        if (this.difficultyAttributes.difficultSliders.length === 0 ||
-            (this.difficultyAttributes.sliderFactor === 1 &&
-                this.difficultyAttributes.flashlightSliderFactor === 1 &&
-                this.difficultyAttributes.visualSliderFactor === 1)) {
-            return {
-                aimPenalty: 1,
-                flashlightPenalty: 1,
-                visualPenalty: 1,
-            };
+    set up(value) {
+        if (value && value.id !== exports.MovementType.Up) {
+            throw new TypeError("Attempting to set the up cursor occurrence to one with different movement type.");
         }
-        const cheesedDifficultyRatings = this.checkSliderCheesing();
-        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
+        this._up = value;
     }
     /**
-     * Checks for sliders that were cheesed.
+     * The time at which this cursor occurrence group starts.
      */
-    checkSliderCheesing() {
-        const { objects } = this.beatmap.hitObjects;
-        const cheesedDifficultyRatings = [];
-        // Current loop indices are stored for efficiency.
-        const cursorLoopIndices = osuBase.Utils.initializeArray(10, 0);
-        const circleSize = new osuBase.MapStats({
-            cs: this.beatmap.difficulty.cs,
-            mods: this.difficultyAttributes.mods,
-        }).calculate({ mode: osuBase.Modes.droid }).cs;
-        const scale = osuBase.CircleSizeCalculator.standardCSToStandardScale(circleSize);
-        const acceptableRadius = 64 * scale * 2.4;
-        // Sort difficult sliders by index so that cursor loop indices work properly.
-        for (const difficultSlider of this.difficultyAttributes.difficultSliders
-            .slice()
-            .sort((a, b) => a.index - b.index)) {
-            if (difficultSlider.index >= this.data.hitObjectData.length) {
-                continue;
-            }
-            const objectData = this.data.hitObjectData[difficultSlider.index];
-            // If a miss or slider break occurs, we disregard the check for that slider.
-            if (objectData.result === exports.HitResult.miss ||
-                objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
-                continue;
-            }
-            let object = objects[difficultSlider.index];
-            if (object.droidScale !== scale) {
-                // Deep clone the object so that we can assign scale properly.
-                object = osuBase.Utils.deepCopy(object);
-                object.droidScale = scale;
-            }
-            const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
-            // These time boundaries should consider the delta time between the previous and next
-            // object as well as their hit accuracy. However, they are somewhat complicated to
-            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
-            const minTimeLimit = object.startTime - this.hitWindow50;
-            const maxTimeLimit = object.startTime + this.hitWindow50;
-            // Get the closest tap distance across all cursors.
-            const closestDistances = [];
-            const closestGroupIndices = [];
-            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
-                let closestDistance = Number.POSITIVE_INFINITY;
-                let closestIndex = cursorGroups.length;
-                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
-                    const group = cursorGroups[j];
-                    if (group.endTime < minTimeLimit) {
-                        continue;
-                    }
-                    if (group.startTime > maxTimeLimit) {
-                        break;
-                    }
-                    if (group.startTime >= minTimeLimit) {
-                        const distance = group.down.position.getDistance(objectStartPosition);
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
-                            break;
-                        }
-                    }
-                    // Normally, we check if there are cursor presses within the group's active time.
-                    // However, some funky workarounds are used throughout the game for replays, so
-                    // for the time being we only check for cursor distances across the group.
-                    const { allOccurrences } = group;
-                    for (let k = 1; k < allOccurrences.length; ++k) {
-                        const occurrence = allOccurrences[k];
-                        const prevOccurrence = allOccurrences[k - 1];
-                        let distance = Number.POSITIVE_INFINITY;
-                        switch (occurrence.id) {
-                            case exports.MovementType.up:
-                                distance =
-                                    prevOccurrence.position.getDistance(objectStartPosition);
-                                break;
-                            case exports.MovementType.move:
-                                for (let mSecPassed = Math.max(prevOccurrence.time, minTimeLimit); mSecPassed <=
-                                    Math.min(occurrence.time, maxTimeLimit); ++mSecPassed) {
-                                    const t = (mSecPassed - prevOccurrence.time) /
-                                        (occurrence.time - prevOccurrence.time);
-                                    const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevOccurrence.position.x, occurrence.position.x, t), osuBase.Interpolation.lerp(prevOccurrence.position.y, occurrence.position.y, t));
-                                    distance =
-                                        cursorPosition.getDistance(objectStartPosition);
-                                    if (closestDistance > distance) {
-                                        closestDistance = distance;
-                                        closestIndex = j;
-                                    }
-                                    if (closestDistance <=
-                                        acceptableRadius / 2) {
-                                        break;
-                                    }
-                                }
-                        }
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
-                            break;
-                        }
-                    }
-                }
-                closestDistances.push(closestDistance);
-                closestGroupIndices.push(closestIndex);
-                if (cursorLoopIndices[i] > 0) {
-                    // Decrement the index. The previous group may also have a role on the next slider.
-                    --cursorLoopIndices[i];
-                }
-            }
-            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
-            const closestDistance = closestDistances[cursorIndex];
-            if (closestDistance > acceptableRadius / 2) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
-                continue;
+    get startTime() {
+        return this._down.time;
+    }
+    /**
+     * The time at which this cursor occurrence group ends.
+     */
+    get endTime() {
+        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.
+     */
+    get duration() {
+        return this.endTime - this.startTime;
+    }
+    /**
+     * All cursor occurrences in this group.
+     *
+     * This iterates all occurrences and as such should be used sparingly or stored locally.
+     */
+    get allOccurrences() {
+        const cursors = [this._down, ...this._moves];
+        if (this._up) {
+            cursors.push(this._up);
+        }
+        return cursors;
+    }
+    constructor(down, moves, up) {
+        this._down = down;
+        this._moves = moves;
+        // Re-set down cursor occurrence for checking.
+        this.down = down;
+        this.up = up;
+    }
+    /**
+     * Determines whether this cursor occurrence group is active at the specified time.
+     *
+     * @param time The time.
+     * @returns Whether this cursor occurrence group is active at the specified time.
+     */
+    isActiveAt(time) {
+        return time >= this.startTime && time <= this.endTime;
+    }
+    /**
+     * Finds the cursor occurrence that is active at a given time.
+     *
+     * @param time The time.
+     * @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 (((_a = this._up) === null || _a === void 0 ? void 0 : _a.time) === time) {
+            return this._up;
+        }
+        let l = 0;
+        let r = this._moves.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this._moves[pivot].time < time) {
+                l = pivot + 1;
             }
-            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
-            let isCheesed = false;
-            // Track cursor movement to see if it lands on every tick.
-            let occurrenceLoopIndex = 1;
-            const { allOccurrences } = group;
-            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
-                if (isCheesed) {
-                    break;
-                }
-                const tickWasHit = objectData.tickset[i - 1];
-                if (!tickWasHit) {
-                    continue;
-                }
-                const nestedObject = object.nestedHitObjects[i];
-                nestedObject.droidScale = scale;
-                // Special treatment for slider tail where its treated as a "legacy tail" in osu!standard.
-                // In that case, its time is assumed to be 36ms behind the slider's end time. However, that
-                // is not the case for osu!droid.
-                if (nestedObject instanceof osuBase.SliderTail) {
-                    nestedObject.startTime = object.endTime;
-                    nestedObject.endTime = object.endTime;
-                }
-                const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
-                while (occurrenceLoopIndex < allOccurrences.length &&
-                    allOccurrences[occurrenceLoopIndex].time <
-                        nestedObject.startTime) {
-                    ++occurrenceLoopIndex;
-                }
-                if (occurrenceLoopIndex === allOccurrences.length) {
-                    continue;
-                }
-                const occurrence = allOccurrences[occurrenceLoopIndex];
-                const prevOccurrence = allOccurrences[occurrenceLoopIndex - 1];
-                switch (occurrence.id) {
-                    case exports.MovementType.move: {
-                        // Interpolate cursor position during nested object time.
-                        const t = (nestedObject.startTime - prevOccurrence.time) /
-                            (occurrence.time - prevOccurrence.time);
-                        const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevOccurrence.position.x, occurrence.position.x, t), osuBase.Interpolation.lerp(prevOccurrence.position.y, occurrence.position.y, t));
-                        const distance = cursorPosition.getDistance(nestedPosition);
-                        isCheesed = distance > acceptableRadius;
-                        break;
-                    }
-                    case exports.MovementType.up:
-                        isCheesed =
-                            prevOccurrence.position.getDistance(nestedPosition) > acceptableRadius;
-                }
+            else if (this._moves[pivot].time > time) {
+                r = pivot - 1;
             }
-            if (isCheesed) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            else {
+                return this._moves[pivot];
             }
         }
-        return cheesedDifficultyRatings;
+        // l will be the first cursor occurrence with time > this._moves[l].time, but we want the one before it
+        return this._moves[l - 1];
     }
     /**
-     * Calculates the slider cheese penalty.
+     * Returns a string representation of this `CursorOccurrenceGroup`.
      */
-    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
-        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
-        return {
-            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.sliderFactor, 2)),
-            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.flashlightSliderFactor, 2)),
-            visualPenalty: Math.max(this.difficultyAttributes.visualSliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.visualSliderFactor, 2)),
-        };
+    toString() {
+        return `Down: ${this.down.time.toString()}ms (${this.down.position.x.toFixed(2)}, ${this.down.position.y.toFixed(2)}) | Moves: ${this.moves.length.toString()} | Up: ${this.up ? `${this.up.time.toString()}ms` : "N/A"}`;
     }
 }
 
 /**
- * A replay analyzer that analyzes a replay from osu!droid.
+ * Represents a cursor instance in an osu!droid replay.
  *
- * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
+ * Stores cursor movement data in the form of `CursorOccurrenceGroup`s.
  *
- * Once analyzed, the result can be accessed via the `data` property.
+ * This is used when analyzing replays using replay analyzer.
  */
-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;
+class CursorData {
     /**
-     * Whether or not the play is considered using >=3 finger abuse.
+     * The time at which the first occurrence of this cursor instance occurs.
+     *
+     * Will return `null` if there are no occurrences.
      */
-    is3Finger;
+    get earliestOccurrenceTime() {
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : null;
+    }
     /**
-     * Whether or not the play is considered 2-handed.
+     * The time at which the latest occurrence of this cursor instance occurs.
+     *
+     * Will return `null` if there are no occurrences.
      */
-    is2Hand;
+    get latestOccurrenceTime() {
+        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 beatmap that is being analyzed. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` is required for three finger or two hand analyzing.
+     * The amount of cursor occurrences of this cursor instance.
      */
-    beatmap;
+    get totalOccurrences() {
+        return this.occurrenceGroups.reduce((a, v) => {
+            // Down cursor.
+            ++a;
+            // Move cursors.
+            a += v.moves.length;
+            if (v.up) {
+                // Up cursor.
+                ++a;
+            }
+            return a;
+        }, 0);
+    }
     /**
-     * The difficulty attributes of the beatmap.
+     * All cursor occurrences of this cursor instnace.
+     *
+     * This iterates all occurrence groups and as such should be used sparingly or stored locally.
      */
-    difficultyAttributes;
+    get allOccurrences() {
+        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) {
+            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
+            switch (occurrence.id) {
+                case exports.MovementType.Down:
+                    downOccurrence = occurrence;
+                    break;
+                case exports.MovementType.Move:
+                    moveOccurrences.push(occurrence);
+                    break;
+                case exports.MovementType.Up:
+                    if (downOccurrence) {
+                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
+                        downOccurrence = null;
+                    }
+                    moveOccurrences = [];
+            }
+        }
+        // Add the final cursor occurrence group as the loop may not catch it for special cases.
+        if (downOccurrence && moveOccurrences.length > 0) {
+            this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences));
+        }
+    }
+}
+
+/**
+ * Represents a replay data in an osu!droid replay version 1 and 2.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayData {
+    constructor(values) {
+        this.replayVersion = values.replayVersion;
+        this.folderName = values.folderName;
+        this.fileName = values.fileName;
+        this.hash = values.hash;
+        this.accuracy = values.accuracy;
+        this.rank = values.rank;
+        this.hit300k = values.hit300k;
+        this.hit100k = values.hit100k;
+        this.cursorMovement = values.cursorMovement;
+        this.hitObjectData = values.hitObjectData;
+    }
     /**
-     * The results of the analyzer. `null` when initialized.
+     * Whether the replay's version is 3 or later.
      */
-    data = null;
+    isReplayV3() {
+        return this.replayVersion >= 3;
+    }
+}
+
+/**
+ * Represents a replay data for replay version 3 and later.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayV3Data extends ReplayData {
     /**
-     * Penalty value used to penalize dpp for 2-hand.
+     * The total score achieved in the play, after applying score multiplier from mods.
      */
-    aimPenalty = 1;
+    get totalScore() {
+        var _a;
+        if (this.replayVersion < 8) {
+            return this.score;
+        }
+        (_a = this.scoreMultiplier) !== null && _a !== void 0 ? _a : (this.scoreMultiplier = osuBase.ModUtil.calculateScoreMultiplier(this.convertedMods.values(), osuBase.Modes.Droid));
+        return Math.round(Math.fround(this.score * this.scoreMultiplier));
+    }
+    constructor(values) {
+        super(values);
+        this.time = values.time;
+        this.score = values.score;
+        this.maxCombo = values.maxCombo;
+        this.isFullCombo = values.isFullCombo;
+        this.playerName = values.playerName;
+        this.convertedMods = values.convertedMods;
+    }
+}
+
+/******************************************************************************
+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, Iterator */
+
+
+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;
+};
+
+/**
+ * A replay analyzer that analyzes a replay from osu!droid.
+ *
+ * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
+ *
+ * Once analyzed, the result can be accessed via the `data` property.
+ */
+class ReplayAnalyzer {
+    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 = 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;
+        this.bufferOffset = 0;
+        this.scoreID = values === null || values === void 0 ? void 0 : values.scoreID;
+        this.beatmap = values === null || values === void 0 ? void 0 : values.map;
+        this.difficultyAttributes = values === null || values === void 0 ? void 0 : values.difficultyAttributes;
+        if (this.beatmap instanceof osuBase.DroidPlayableBeatmap) {
+            this.playableBeatmap = this.beatmap;
+        }
+    }
     /**
-     * Penalty value used to penalize dpp for 3 finger abuse.
+     * Analyzes a replay.
      */
-    tapPenalty = 1;
+    analyze() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.originalODR && !this.fixedODR) {
+                this.originalODR = yield this.downloadReplay();
+            }
+            if (!this.originalODR) {
+                return this;
+            }
+            (_a = this.fixedODR) !== null && _a !== void 0 ? _a : (this.fixedODR = yield this.decompress().catch(() => null));
+            if (!this.fixedODR) {
+                return this;
+            }
+            this.parseReplay();
+            return this;
+        });
+    }
     /**
-     * Penalty values used to penalize dpp for slider cheesing.
+     * Gets hit error information of the replay.
+     *
+     * `analyze()` must be called before calling this, and `beatmap` must be defined.
      */
-    sliderCheesePenalty = {
-        aimPenalty: 1,
-        flashlightPenalty: 1,
-        visualPenalty: 1,
-    };
+    calculateHitError() {
+        var _a, _b;
+        if (!this.data || !this.beatmap) {
+            return null;
+        }
+        const hitObjectData = this.data.hitObjectData;
+        let positiveCount = 0;
+        let negativeCount = 0;
+        let positiveTotal = 0;
+        let negativeTotal = 0;
+        const { objects } = this.beatmap.hitObjects;
+        const mods = this.data.isReplayV3()
+            ? this.data.convertedMods
+            : ((_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods) !== null && _b !== void 0 ? _b : new osuBase.ModMap());
+        const adjustedDifficulty = new osuBase.BeatmapDifficulty(this.beatmap.difficulty);
+        osuBase.ModUtil.applyModsToBeatmapDifficulty(adjustedDifficulty, osuBase.Modes.Droid, mods);
+        const mehWindow = mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(adjustedDifficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(adjustedDifficulty.od).mehWindow;
+        const accuracies = [];
+        for (let i = 0; i < hitObjectData.length; ++i) {
+            const v = hitObjectData[i];
+            const o = objects[i];
+            if (o instanceof osuBase.Spinner || v.result === osuBase.HitResult.Miss) {
+                continue;
+            }
+            const { accuracy } = v;
+            // Do not include slider breaks.
+            if (o instanceof osuBase.Slider) {
+                let lateHitThreshold = mehWindow;
+                // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+                if (this.data.replayVersion < 8) {
+                    lateHitThreshold = Math.min(mehWindow, o.duration);
+                }
+                if (-mehWindow > accuracy || accuracy > lateHitThreshold) {
+                    continue;
+                }
+            }
+            accuracies.push(accuracy);
+            if (accuracy >= 0) {
+                positiveTotal += accuracy;
+                ++positiveCount;
+            }
+            else {
+                negativeTotal += accuracy;
+                ++negativeCount;
+            }
+        }
+        return {
+            positiveAvg: positiveTotal / positiveCount || 0,
+            negativeAvg: negativeTotal / negativeCount || 0,
+            unstableRate: osuBase.MathUtils.calculateStandardDeviation(accuracies) * 10,
+        };
+    }
     /**
-     * Whether this replay has been checked against 3 finger usage.
+     * Obtains the amount of slider ticks and ends hit in the replay.
+     *
+     * This requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @returns Slider hit information or `null` if the replay has not been analyzed or the beatmap is not defined.
      */
-    hasBeenCheckedFor3Finger = false;
+    obtainSliderHitInformation() {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const sliderInformation = {
+            tick: { obtained: 0, total: beatmap.hitObjects.sliderTicks },
+            end: { obtained: 0, total: beatmap.hitObjects.sliders },
+        };
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            if (objectData.result === osuBase.HitResult.Miss ||
+                !(object instanceof osuBase.Slider)) {
+                continue;
+            }
+            // Exclude the head circle.
+            for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                const nested = object.nestedHitObjects[j];
+                if (!objectData.tickset[j - 1]) {
+                    continue;
+                }
+                if (nested instanceof osuBase.SliderTick) {
+                    ++sliderInformation.tick.obtained;
+                }
+                else if (nested instanceof osuBase.SliderTail) {
+                    ++sliderInformation.end.obtained;
+                }
+            }
+        }
+        return sliderInformation;
+    }
     /**
-     * Whether this replay has been checked against 2 hand usage.
+     * Simulates a hit window for the replay.
+     *
+     * This does not account for required spins in a spinner.
+     *
+     * Requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @param hitWindow The hit window to simulate.
+     * @returns The accuracy of the replay based on the hit window, or `null` if the replay has not been analyzed or the beatmap is not defined.
      */
-    hasBeenCheckedFor2Hand = false;
+    simulateHitWindow(hitWindow) {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const accuracy = new osuBase.Accuracy({ n300: 0, n100: 0, n50: 0, nmiss: 0 });
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            const hitAccuracy = Math.abs(objectData.accuracy);
+            let { result } = objectData;
+            if (object instanceof osuBase.Circle) {
+                if (hitAccuracy <= hitWindow.greatWindow) {
+                    result = osuBase.HitResult.Great;
+                }
+                else if (hitAccuracy <= hitWindow.okWindow) {
+                    result = osuBase.HitResult.Good;
+                }
+                else if (hitAccuracy <= hitWindow.mehWindow) {
+                    result = osuBase.HitResult.Meh;
+                }
+                else {
+                    result = osuBase.HitResult.Miss;
+                }
+            }
+            else if (object instanceof osuBase.Slider) {
+                if (hitAccuracy <=
+                    Math.min(hitWindow.mehWindow, object.duration)) {
+                    let ticksObtained = 1;
+                    for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                        if (objectData.tickset[j - 1]) {
+                            ++ticksObtained;
+                        }
+                    }
+                    if (ticksObtained === object.nestedHitObjects.length) {
+                        result = osuBase.HitResult.Great;
+                    }
+                    else if (ticksObtained >=
+                        Math.trunc(object.nestedHitObjects.length / 2)) {
+                        result = osuBase.HitResult.Good;
+                    }
+                    else if (ticksObtained > 0) {
+                        result = osuBase.HitResult.Meh;
+                    }
+                    else {
+                        result = osuBase.HitResult.Miss;
+                    }
+                }
+                else {
+                    result = osuBase.HitResult.Miss;
+                }
+            }
+            switch (result) {
+                case osuBase.HitResult.Miss:
+                    ++accuracy.nmiss;
+                    break;
+                case osuBase.HitResult.Meh:
+                    ++accuracy.n50;
+                    break;
+                case osuBase.HitResult.Good:
+                    ++accuracy.n100;
+                    break;
+                case osuBase.HitResult.Great:
+                    ++accuracy.n300;
+                    break;
+            }
+        }
+        return accuracy;
+    }
     /**
-     * Whether this repla has been checked against slider cheesing.
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
-    hasBeenCheckedForSliderCheesing = false;
+    checkFor3Finger() {
+        var _a;
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
+            return;
+        }
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceThreeFingerChecker(this.playableBeatmap, this.data, this.difficultyAttributes)
+            : new ThreeFingerChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        const result = threeFingerChecker.check();
+        this.is3Finger = result.is3Finger;
+        this.tapPenalty = result.penalty;
+        this.hasBeenCheckedFor3Finger = true;
+    }
     /**
-     * The amount of two-handed objects.
+     * Checks if a play is using 2 hands.
+     *
+     * Requires `analyze()` to be called first as well as `beatmap` and `difficultyAttributes` to be defined.
      */
-    twoHandedNoteCount = 0;
-    // 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) {
-        this.scoreID = values.scoreID;
-        this.beatmap = values.map;
-        this.difficultyAttributes = values.difficultyAttributes;
-        if (this.beatmap && !(this.beatmap instanceof osuBase.Beatmap)) {
-            this.difficultyAttributes = this.beatmap.attributes;
+    checkFor2Hand() {
+        var _a;
+        if (!this.beatmap || !this.difficultyAttributes || !this.data) {
+            return;
         }
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const twoHandChecker = new TwoHandChecker(this.playableBeatmap, this.difficultyAttributes, this.data);
+        const result = twoHandChecker.check();
+        this.is2Hand = result.is2Hand;
+        this.twoHandedNoteCount = result.twoHandedNoteCount;
+        this.hasBeenCheckedFor2Hand = true;
     }
     /**
-     * Analyzes a replay.
+     * Checks if a play has cheesed sliders.
+     *
+     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
-    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) {
-            return this;
+    checkForSliderCheesing() {
+        var _a;
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
+            return;
         }
-        this.parseReplay();
-        return this;
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const sliderCheeseChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceSliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes)
+            : new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        this.sliderCheesePenalty = sliderCheeseChecker.check();
+        this.hasBeenCheckedForSliderCheesing = true;
     }
     /**
      * 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* () {
+            if (this.scoreID === undefined) {
+                return null;
+            }
+            const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
+                .setRequireAPIkey(false)
+                .setEndpoint("upload")
+                .addParameter("", `${this.scoreID.toString()}.odr`);
+            const result = yield apiRequestBuilder.sendRequest();
+            if (result.statusCode !== 200) {
+                return null;
+            }
+            return result.data;
+        });
     }
     /**
      * Decompresses a replay.
@@ -2001,17 +2586,20 @@ class ReplayAnalyzer {
             stream.push(null);
             stream
                 .pipe(unzipper.Parse())
-                .on("entry", async (entry) => {
+                .on("entry", (entry) => {
                 const fileName = entry.path;
                 if (fileName === "data") {
-                    return resolve(await entry.buffer());
+                    resolve(entry.buffer());
+                    return;
                 }
                 else {
                     entry.autodrain();
                 }
             })
                 .on("error", (e) => {
-                setTimeout(() => reject(e), 2000);
+                setTimeout(() => {
+                    reject(e);
+                }, 2000);
             });
         });
     }
@@ -2019,14 +2607,16 @@ class ReplayAnalyzer {
      * Parses a replay after being downloaded and converted to a buffer.
      */
     parseReplay() {
+        if (!this.fixedODR) {
+            return;
+        }
         // javaDeserialization can only somewhat parse some string field
-        // the rest will be a buffer that we need to manually parse
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // the rest will be a buffer that we need to manually parse.
         let rawObject;
         try {
             rawObject = javaDeserialization__namespace.parse(this.fixedODR);
         }
-        catch {
+        catch (_a) {
             return;
         }
         const resultObject = {
@@ -2037,88 +2627,62 @@ class ReplayAnalyzer {
             cursorMovement: [],
             hitObjectData: [],
             accuracy: new osuBase.Accuracy({ n300: 0 }),
-            rank: "",
-        };
-        const determineRank = () => {
-            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 hit300Ratio = resultObject.accuracy.n300 / totalHits;
-            switch (true) {
-                case resultObject.accuracy.value() === 1:
-                    if (isHidden) {
-                        resultObject.rank = "XH";
-                    }
-                    else {
-                        resultObject.rank = "X";
-                    }
-                    break;
-                case hit300Ratio > 0.9 &&
-                    resultObject.accuracy.n50 / totalHits < 0.01 &&
-                    !resultObject.accuracy.nmiss:
-                    if (isHidden) {
-                        resultObject.rank = "SH";
-                    }
-                    else {
-                        resultObject.rank = "S";
-                    }
-                    break;
-                case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
-                    hit300Ratio > 0.9:
-                    resultObject.rank = "A";
-                    break;
-                case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
-                    hit300Ratio > 0.8:
-                    resultObject.rank = "B";
-                    break;
-                case hit300Ratio > 0.6:
-                    resultObject.rank = "C";
-                    break;
-                default:
-                    resultObject.rank = "D";
-            }
+            rank: "D",
+            convertedMods: new osuBase.ModMap(),
+            hit100k: 0,
+            hit300k: 0,
+            isFullCombo: false,
+            maxCombo: 0,
+            playerName: "",
+            score: 0,
+            time: new Date(0),
         };
         if (resultObject.replayVersion >= 3) {
-            resultObject.time = new Date(Number(rawObject[4].readBigUInt64BE(0)));
-            resultObject.hit300k = rawObject[4].readInt32BE(8);
-            resultObject.hit100k = rawObject[4].readInt32BE(16);
-            resultObject.score = rawObject[4].readInt32BE(32);
-            resultObject.maxCombo = rawObject[4].readInt32BE(36);
-            resultObject.accuracy = new osuBase.Accuracy({
-                n300: rawObject[4].readInt32BE(12),
-                n100: rawObject[4].readInt32BE(20),
-                n50: rawObject[4].readInt32BE(24),
-                nmiss: rawObject[4].readInt32BE(28),
-            });
-            resultObject.isFullCombo = !!rawObject[4][44];
+            const buf = rawObject[4];
+            resultObject.time.setTime(Number(buf.readBigUInt64BE(0)));
+            resultObject.hit300k = buf.readInt32BE(8);
+            resultObject.accuracy.n300 = buf.readInt32BE(12);
+            resultObject.hit100k = buf.readInt32BE(16);
+            resultObject.accuracy.n100 = buf.readInt32BE(20);
+            resultObject.accuracy.n50 = buf.readInt32BE(24);
+            resultObject.accuracy.nmiss = buf.readInt32BE(28);
+            resultObject.score = buf.readInt32BE(32);
+            resultObject.maxCombo = buf.readInt32BE(36);
+            resultObject.isFullCombo = resultObject.accuracy.value() === 1;
             resultObject.playerName = rawObject[5];
-            resultObject.rawMods = rawObject[6].elements;
-            resultObject.convertedMods = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(rawObject[6].elements));
-            determineRank();
-        }
-        if (resultObject.replayVersion >= 4) {
-            const s = rawObject[7].split("|");
-            resultObject.speedModification =
-                parseFloat(s[0].replace("x", "")) || 1;
-            if (s.length > 1) {
-                resultObject.forcedAR = parseFloat(s[1].replace("AR", ""));
+            if (resultObject.replayVersion >= 7) {
+                resultObject.convertedMods = osuBase.ModUtil.deserializeMods(JSON.parse(rawObject[6]));
+            }
+            else {
+                resultObject.convertedMods = this.convertDroidMods(resultObject.replayVersion, Object.values(rawObject[6]
+                    .elements));
+                if (resultObject.replayVersion >= 4) {
+                    osuBase.DroidLegacyModConverter.parseExtraModString(resultObject.convertedMods, rawObject[7].split("|"));
+                }
             }
+            resultObject.rank = this.calculateRank(resultObject);
+        }
+        if (resultObject.replayVersion <= 6) {
+            resultObject.convertedMods.set(osuBase.ModReplayV6);
         }
         let bufferIndex;
-        switch (true) {
-            // replay v4 and above
-            case resultObject.replayVersion >= 4:
-                bufferIndex = 8;
+        switch (resultObject.replayVersion) {
+            case 1:
+            case 2:
+                bufferIndex = 4;
                 break;
-            // replay v3
-            case resultObject.replayVersion === 3:
+            case 3:
+            case 7:
+            case 8:
                 bufferIndex = 7;
                 break;
-            // replay v1 and v2
+            case 4:
+            case 5:
+            case 6:
+                bufferIndex = 8;
+                break;
             default:
-                bufferIndex = 4;
+                throw new Error(`Unsupported replay version: ${resultObject.replayVersion.toString()}`);
         }
         const replayDataBufferArray = [];
         while (bufferIndex < rawObject.length) {
@@ -2126,39 +2690,87 @@ class ReplayAnalyzer {
         }
         // Merge all cursor movement and hit object data section into one for better control when parsing
         const replayDataBuffer = Buffer.concat(replayDataBufferArray);
-        let bufferCounter = 0;
-        const size = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
-        // Parse movement data
-        for (let x = 0; x < size; x++) {
-            const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
-            bufferCounter += this.INT_LENGTH;
+        this.bufferOffset = 0;
+        this.parseMovementData(resultObject, replayDataBuffer);
+        this.parseHitObjectData(resultObject, replayDataBuffer);
+        this.parseOldReplayInformation(resultObject);
+        switch (resultObject.replayVersion) {
+            case 1:
+            case 2:
+                this.data = new ReplayData(resultObject);
+                break;
+            default:
+                this.data = new ReplayV3Data(resultObject);
+        }
+    }
+    /**
+     * Converts replay mods to droid mod string.
+     */
+    convertDroidMods(replayVersion, replayMods) {
+        const replayModsConstants = {
+            MOD_AUTO: osuBase.ModAuto,
+            MOD_AUTOPILOT: osuBase.ModAutopilot,
+            MOD_NOFAIL: osuBase.ModNoFail,
+            MOD_EASY: osuBase.ModEasy,
+            MOD_HIDDEN: osuBase.ModHidden,
+            MOD_TRACEABLE: osuBase.ModTraceable,
+            MOD_HARDROCK: osuBase.ModHardRock,
+            MOD_DOUBLETIME: osuBase.ModDoubleTime,
+            MOD_HALFTIME: osuBase.ModHalfTime,
+            MOD_NIGHTCORE: osuBase.ModNightCore,
+            MOD_PRECISE: osuBase.ModPrecise,
+            MOD_SMALLCIRCLE: osuBase.ModSmallCircle,
+            MOD_REALLYEASY: osuBase.ModReallyEasy,
+            MOD_RELAX: osuBase.ModRelax,
+            MOD_PERFECT: osuBase.ModPerfect,
+            MOD_SUDDENDEATH: osuBase.ModSuddenDeath,
+            MOD_SCOREV2: osuBase.ModScoreV2,
+            MOD_FLASHLIGHT: osuBase.ModFlashlight,
+        };
+        const map = new osuBase.ModMap();
+        for (const mod of replayMods) {
+            for (const property in Object(replayModsConstants)) {
+                if (!mod.includes(property)) {
+                    continue;
+                }
+                if (replayVersion <= 3 && mod === "MOD_NIGHTCORE") {
+                    // In replay v3, the NightCore mod is bugged. See ModOldNightCore's description.
+                    map.set(new osuBase.ModOldNightCore());
+                }
+                else {
+                    map.set(replayModsConstants[property]);
+                }
+                break;
+            }
+        }
+        return map;
+    }
+    parseMovementData(resultObject, replayDataBuffer) {
+        resultObject.cursorMovement.length = 0;
+        const size = this.readInt(replayDataBuffer);
+        for (let i = 0; i < size; i++) {
+            const moveSize = this.readInt(replayDataBuffer);
             const time = [];
             const x = [];
             const y = [];
             const id = [];
-            for (let i = 0; i < moveSize; i++) {
-                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
-                bufferCounter += this.INT_LENGTH;
-                id[i] = time[i] & 3;
-                time[i] >>= 2;
-                if (id[i] !== exports.MovementType.up) {
+            for (let j = 0; j < moveSize; j++) {
+                time[j] = this.readInt(replayDataBuffer);
+                id[j] = time[j] & 3;
+                time[j] >>= 2;
+                if (id[j] !== exports.MovementType.Up) {
                     if (resultObject.replayVersion >= 5) {
-                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
-                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
+                        x[j] = this.readFloat(replayDataBuffer);
+                        y[j] = this.readFloat(replayDataBuffer);
                     }
                     else {
-                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
-                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
+                        x[j] = this.readShort(replayDataBuffer);
+                        y[j] = this.readShort(replayDataBuffer);
                     }
                 }
                 else {
-                    x[i] = -1;
-                    y[i] = -1;
+                    x[j] = -1;
+                    y[j] = -1;
                 }
             }
             resultObject.cursorMovement.push(new CursorData({
@@ -2169,25 +2781,23 @@ class ReplayAnalyzer {
                 id: id,
             }));
         }
-        const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
+    }
+    parseHitObjectData(resultObject, replayDataBuffer) {
+        resultObject.hitObjectData.length = 0;
+        const replayObjectLength = this.readInt(replayDataBuffer);
         // Parse result data
         for (let i = 0; i < replayObjectLength; i++) {
             const replayObjectData = {
                 accuracy: 0,
                 tickset: [],
-                result: exports.HitResult.miss,
+                result: osuBase.HitResult.Miss,
             };
-            replayObjectData.accuracy =
-                replayDataBuffer.readInt16BE(bufferCounter);
-            bufferCounter += this.SHORT_LENGTH;
-            const len = replayDataBuffer.readInt8(bufferCounter);
-            bufferCounter += this.BYTE_LENGTH;
+            replayObjectData.accuracy = this.readShort(replayDataBuffer);
+            const len = this.readByte(replayDataBuffer);
             if (len > 0) {
                 const bytes = [];
                 for (let j = 0; j < len; j++) {
-                    bytes.push(replayDataBuffer.readInt8(bufferCounter));
-                    bufferCounter += this.BYTE_LENGTH;
+                    bytes.push(this.readByte(replayDataBuffer));
                 }
                 // Int/int division in Java; numbers must be truncated to get actual number
                 for (let j = 0; j < len * 8; j++) {
@@ -2197,252 +2807,127 @@ class ReplayAnalyzer {
                 }
             }
             if (resultObject.replayVersion >= 1) {
-                replayObjectData.result =
-                    replayDataBuffer.readInt8(bufferCounter);
-                bufferCounter += this.BYTE_LENGTH;
+                replayObjectData.result = this.readByte(replayDataBuffer);
             }
             resultObject.hitObjectData.push(replayObjectData);
         }
-        // Parse max combo, hit results, and accuracy in old replay version
-        if (resultObject.replayVersion < 3) {
-            const objects = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-                this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-                ? this.beatmap.beatmap
-                : this.beatmap)?.hitObjects.objects;
-            let grantsGekiOrKatu = true;
-            for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
-                // Hit result
-                const hitObjectData = resultObject.hitObjectData[i];
-                const isNextNewCombo = objects
-                    ? i + 1 !== objects.length
-                        ? objects[i + 1].isNewCombo
-                        : true
-                    : false;
-                switch (hitObjectData.result) {
-                    case exports.HitResult.miss:
-                        ++resultObject.accuracy.nmiss;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.HitResult.meh:
-                        ++resultObject.accuracy.n50;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.HitResult.good:
-                        ++resultObject.accuracy.n100;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            resultObject.hit100k ??= 0;
-                            ++resultObject.hit100k;
-                        }
-                        break;
-                    case exports.HitResult.great:
-                        ++resultObject.accuracy.n300;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            resultObject.hit300k ??= 0;
-                            ++resultObject.hit300k;
-                        }
-                        break;
-                }
-                if (isNextNewCombo) {
-                    grantsGekiOrKatu = true;
-                }
-            }
-            determineRank();
-        }
-        this.data = new ReplayData(resultObject);
     }
-    /**
-     * Gets hit error information of the replay.
-     *
-     * `analyze()` must be called before calling this.
-     */
-    calculateHitError() {
-        if (!this.data || !this.beatmap) {
-            return null;
+    parseOldReplayInformation(resultObject) {
+        var _a;
+        // Parse max combo, hit results, and accuracy in old replay version
+        if (resultObject.replayVersion >= 3) {
+            return;
         }
-        const hitObjectData = this.data.hitObjectData;
-        let positiveCount = 0;
-        let negativeCount = 0;
-        let positiveTotal = 0;
-        let negativeTotal = 0;
-        const beatmap = this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-            ? this.beatmap.beatmap
-            : this.beatmap;
-        const objects = beatmap.hitObjects.objects;
-        const stats = new osuBase.MapStats({
-            od: beatmap.difficulty.od,
-            mods: this.data.convertedMods.filter((m) => !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
-        }).calculate();
-        const hitWindow50 = new osuBase.DroidHitWindow(stats.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:
-        // https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821
-        //
-        // In such cases, the slider is skipped.
-        const sliderbreakHitOffset = Math.floor(hitWindow50) + 13;
-        const accuracies = [];
-        for (let i = 0; i < hitObjectData.length; ++i) {
-            const v = hitObjectData[i];
-            const o = objects[i];
-            if (o instanceof osuBase.Spinner || v.result === exports.HitResult.miss) {
-                accuracies.push(0);
-                continue;
-            }
-            const accuracy = v.accuracy;
-            if (o instanceof osuBase.Slider && v.accuracy === sliderbreakHitOffset) {
-                accuracies.push(0);
-                continue;
-            }
-            accuracies.push(accuracy);
-            if (accuracy >= 0) {
-                positiveTotal += accuracy;
-                ++positiveCount;
+        const objects = (_a = this.beatmap) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
+        let grantsGekiOrKatu = true;
+        resultObject.hit300k = 0;
+        resultObject.hit100k = 0;
+        for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
+            // Hit result
+            const hitObjectData = resultObject.hitObjectData[i];
+            const isNextNewCombo = objects
+                ? i + 1 !== objects.length
+                    ? objects[i + 1].isNewCombo
+                    : true
+                : false;
+            switch (hitObjectData.result) {
+                case osuBase.HitResult.Miss:
+                    ++resultObject.accuracy.nmiss;
+                    grantsGekiOrKatu = false;
+                    break;
+                case osuBase.HitResult.Meh:
+                    ++resultObject.accuracy.n50;
+                    grantsGekiOrKatu = false;
+                    break;
+                case osuBase.HitResult.Good:
+                    ++resultObject.accuracy.n100;
+                    if (grantsGekiOrKatu && isNextNewCombo) {
+                        ++resultObject.hit100k;
+                    }
+                    break;
+                case osuBase.HitResult.Great:
+                    ++resultObject.accuracy.n300;
+                    if (grantsGekiOrKatu && isNextNewCombo) {
+                        ++resultObject.hit300k;
+                    }
+                    break;
             }
-            else {
-                negativeTotal += accuracy;
-                ++negativeCount;
+            if (isNextNewCombo) {
+                grantsGekiOrKatu = true;
             }
         }
-        return {
-            positiveAvg: positiveTotal / positiveCount || 0,
-            negativeAvg: negativeTotal / negativeCount || 0,
-            unstableRate: osuBase.MathUtils.calculateStandardDeviation(accuracies) * 10,
-        };
+        resultObject.rank = this.calculateRank(resultObject);
     }
-    /**
-     * Converts replay mods to droid mod string.
-     */
-    convertDroidMods(replayMods) {
-        const replayModsConstants = {
-            MOD_NOFAIL: "n",
-            MOD_EASY: "e",
-            MOD_HIDDEN: "h",
-            MOD_HARDROCK: "r",
-            MOD_DOUBLETIME: "d",
-            MOD_HALFTIME: "t",
-            MOD_NIGHTCORE: "c",
-            MOD_PRECISE: "s",
-            MOD_SMALLCIRCLE: "m",
-            MOD_SPEEDUP: "b",
-            MOD_REALLYEASY: "l",
-            MOD_PERFECT: "f",
-            MOD_SUDDENDEATH: "u",
-            MOD_SCOREV2: "v",
-        };
-        let modString = "";
-        for (const mod of replayMods) {
-            for (const property in replayModsConstants) {
-                if (!(property in replayModsConstants)) {
-                    continue;
-                }
-                if (!mod.includes(property)) {
-                    continue;
-                }
-                modString +=
-                    replayModsConstants[property];
-                break;
-            }
+    calculateRank(resultObject) {
+        const totalHits = resultObject.accuracy.n300 +
+            resultObject.accuracy.n100 +
+            resultObject.accuracy.n50 +
+            resultObject.accuracy.nmiss;
+        const isHidden = resultObject.convertedMods.has(osuBase.ModHidden) ||
+            resultObject.convertedMods.has(osuBase.ModFlashlight);
+        const hit300Ratio = resultObject.accuracy.n300 / totalHits;
+        switch (true) {
+            case resultObject.accuracy.value() === 1:
+                return isHidden ? "XH" : "X";
+            case hit300Ratio > 0.9 &&
+                resultObject.accuracy.n50 / totalHits < 0.01 &&
+                !resultObject.accuracy.nmiss:
+                return isHidden ? "SH" : "S";
+            case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
+                hit300Ratio > 0.9:
+                return "A";
+            case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
+                hit300Ratio > 0.8:
+                return "B";
+            case hit300Ratio > 0.6:
+                return "C";
+            default:
+                return "D";
         }
-        return modString;
     }
-    /**
-     * Checks if a play is using 3 fingers.
-     *
-     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
-     */
-    checkFor3Finger() {
-        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
-            return;
-        }
-        const threeFingerChecker = new ThreeFingerChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
-        const result = threeFingerChecker.check();
-        this.is3Finger = result.is3Finger;
-        this.tapPenalty = result.penalty;
-        this.hasBeenCheckedFor3Finger = true;
+    constructPlayableBeatmap() {
+        var _a;
+        if (this.beatmap instanceof osuBase.DroidPlayableBeatmap) {
+            return this.beatmap;
+        }
+        if (!this.beatmap || !this.data) {
+            throw new Error("Beatmap and replay data must be defined.");
+        }
+        const mods = this.data.isReplayV3()
+            ? this.data.convertedMods
+            : (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods;
+        return this.beatmap.createDroidPlayableBeatmap(mods);
     }
-    /**
-     * Checks if a play is using 2 hands.
-     *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
-     */
-    checkFor2Hand() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
-            return;
-        }
-        const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
-        const result = twoHandChecker.check();
-        this.is2Hand = result.is2Hand;
-        this.twoHandedNoteCount = result.twoHandedNoteCount;
-        this.hasBeenCheckedFor2Hand = true;
+    readByte(buffer) {
+        const num = buffer.readInt8(this.bufferOffset);
+        this.bufferOffset += 1;
+        return num;
     }
-    /**
-     * Checks if a play has cheesed sliders.
-     *
-     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
-     */
-    checkForSliderCheesing() {
-        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
-            return;
-        }
-        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
-        this.sliderCheesePenalty = sliderCheeseChecker.check();
-        this.hasBeenCheckedForSliderCheesing = true;
+    readShort(buffer) {
+        const num = buffer.readInt16BE(this.bufferOffset);
+        this.bufferOffset += 2;
+        return num;
     }
-}
-
-/**
- * Represents a hitobject in an osu!droid replay.
- *
- * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
- *
- * 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;
-        this.result = values.result;
+    readInt(buffer) {
+        const num = buffer.readInt32BE(this.bufferOffset);
+        this.bufferOffset += 4;
+        return num;
+    }
+    readFloat(buffer) {
+        const num = buffer.readFloatBE(this.bufferOffset);
+        this.bufferOffset += 4;
+        return num;
     }
 }
 
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
+exports.RebalanceSliderCheeseChecker = RebalanceSliderCheeseChecker;
+exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
-exports.ReplayObjectData = ReplayObjectData;
+exports.ReplayV3Data = ReplayV3Data;
 exports.SliderCheeseChecker = SliderCheeseChecker;
 exports.ThreeFingerChecker = ThreeFingerChecker;
 exports.TwoHandChecker = TwoHandChecker;