@rian8337/osu-droid-replay-analyzer 4.0.0-beta.2 → 4.0.0-beta.20

package/dist/index.js

@@ -51,18 +51,6 @@ exports.MovementType = void 0;
  * Represents a cursor's occurrence.
  */
 class CursorOccurrence {
-    /**
-     * The time of this occurrence.
-     */
-    time;
-    /**
-     * The position of the occurrence.
-     */
-    position;
-    /**
-     * The movement ID of the occurrence.
-     */
-    id;
     constructor(time, x, y, id) {
         this.time = time;
         this.position = new osuBase.Vector2(x, y);
@@ -125,7 +113,8 @@ class CursorOccurrenceGroup {
      * The time at which this cursor occurrence group ends.
      */
     get endTime() {
-        return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this._up) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : (_c = this._moves.at(-1)) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : this._down.time;
     }
     /**
      * The duration this cursor occurrence group is active for.
@@ -145,20 +134,6 @@ class CursorOccurrenceGroup {
         }
         return cursors;
     }
-    /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
-     */
-    _down;
-    /**
-     * The cursor occurrences of movement type `movementType.MOVE`.
-     */
-    _moves;
-    /**
-     * The cursor occurrence of movement type `movementType.UP`.
-     *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
-     */
-    _up;
     constructor(down, moves, up) {
         this._down = down;
         this._moves = moves;
@@ -182,13 +157,14 @@ class CursorOccurrenceGroup {
      * @returns The cursor occurrence at the given time, `null` if not found.
      */
     cursorAt(time) {
+        var _a;
         if (!this.isActiveAt(time)) {
             return null;
         }
         if (this._down.time === time) {
             return this._down;
         }
-        if (this._up?.time === time) {
+        if (((_a = this._up) === null || _a === void 0 ? void 0 : _a.time) === time) {
             return this._up;
         }
         let l = 0;
@@ -218,17 +194,14 @@ class CursorOccurrenceGroup {
  * This is used when analyzing replays using replay analyzer.
  */
 class CursorData {
-    /**
-     * The occurrence groups of this cursor instance.
-     */
-    occurrenceGroups = [];
     /**
      * The time at which the first occurrence of this cursor instance occurs.
      *
      * Will return `null` if there are no occurrences.
      */
     get earliestOccurrenceTime() {
-        return this.occurrenceGroups.at(0)?.startTime ?? null;
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : null;
     }
     /**
      * The time at which the latest occurrence of this cursor instance occurs.
@@ -236,7 +209,8 @@ class CursorData {
      * Will return `null` if there are no occurrences.
      */
     get latestOccurrenceTime() {
-        return this.occurrenceGroups.at(-1)?.endTime ?? null;
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(-1)) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : null;
     }
     /**
      * The amount of cursor occurrences of this cursor instance.
@@ -263,6 +237,10 @@ class CursorData {
         return this.occurrenceGroups.flatMap((v) => v.allOccurrences);
     }
     constructor(values) {
+        /**
+         * The occurrence groups of this cursor instance.
+         */
+        this.occurrenceGroups = [];
         let downOccurrence = null;
         let moveOccurrences = [];
         for (let i = 0; i < values.size; ++i) {
@@ -312,6 +290,502 @@ exports.HitResult = void 0;
     HitResult[HitResult["great"] = 4] = "great";
 })(exports.HitResult || (exports.HitResult = {}));
 
+/**
+ * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ */
+class RebalanceThreeFingerChecker {
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap, data, difficultyAttributes) {
+        /**
+         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+         *
+         * Increasing this number will increase detection accuracy, however
+         * it also increases the chance of falsely flagged plays.
+         */
+        this.threeFingerRatioThreshold = 0.01;
+        /**
+         * Extended sections of the beatmap for drag detection.
+         */
+        this.beatmapSections = [];
+        /**
+         * A reprocessed break points to match right on object time.
+         *
+         * This is used to increase detection accuracy since break points do not start right at the
+         * start of the hitobject before it and do not end right at the first hitobject after it.
+         */
+        this.breakPointAccurateTimes = [];
+        /**
+         * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+         *
+         * Each index represents the cursor index.
+         */
+        this.downCursorInstances = [];
+        /**
+         * Nerf factors from all sections that were three-fingered.
+         */
+        this.nerfFactors = [];
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        this.hitWindow = new osuBase.DroidHitWindow(od);
+        this.hitObjects = beatmap.hitObjects.objects;
+    }
+    /**
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     *
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    static isEligibleToDetect(difficultyAttributes) {
+        return difficultyAttributes.possibleThreeFingeredSections.length > 0;
+    }
+    /**
+     * 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.
+     */
+    check() {
+        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getAccurateBreakPoints();
+        this.filterCursorInstances();
+        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getBeatmapSections();
+        this.calculateNerfFactors();
+        const finalPenalty = this.calculateFinalPenalty();
+        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
+    }
+    /**
+     * Generates a new set of "accurate break points".
+     *
+     * 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.
+     */
+    getAccurateBreakPoints() {
+        const objectData = this.data.hitObjectData;
+        for (const breakPoint of this.beatmap.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(this.hitObjects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, this.hitObjects.length - 2);
+            const objectBefore = this.hitObjects[beforeIndex];
+            const objectBeforeData = objectData[beforeIndex];
+            let timeBefore = objectBefore.endTime;
+            if (objectBefore instanceof osuBase.Circle) {
+                if (objectBeforeData.result !== exports.HitResult.miss) {
+                    timeBefore += objectBeforeData.accuracy;
+                }
+                else {
+                    timeBefore += this.hitWindow.hitWindowFor50(this.isPrecise);
+                }
+            }
+            const afterIndex = beforeIndex + 1;
+            const objectAfter = this.hitObjects[afterIndex];
+            const objectAfterData = objectData[afterIndex];
+            let timeAfter = this.hitObjects[afterIndex].startTime;
+            if (objectAfter instanceof osuBase.Circle &&
+                objectAfterData.result !== exports.HitResult.miss) {
+                timeAfter += objectAfterData.accuracy;
+            }
+            this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
+                startTime: timeBefore,
+                endTime: timeAfter,
+            }));
+        }
+    }
+    /**
+     * Filters the original cursor instances, returning only those with `movementType.DOWN` movement ID.
+     *
+     * This also filters cursors that are in break period or happen before start/after end of the beatmap.
+     */
+    filterCursorInstances() {
+        const objectData = this.data.hitObjectData;
+        const firstObjectResult = objectData[0].result;
+        const lastObjectResult = objectData.at(-1).result;
+        const firstObject = this.hitObjects[0];
+        const lastObject = this.hitObjects.at(-1);
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (firstObject instanceof osuBase.Circle) {
+            switch (firstObjectResult) {
+                case exports.HitResult.great:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+        if (lastObject instanceof osuBase.Circle) {
+            switch (lastObjectResult) {
+                case exports.HitResult.great:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+                default:
+                    lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
+            }
+        }
+        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 = 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);
+        }
+    }
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    getBeatmapSections() {
+        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        for (const section of this.difficultyAttributes
+            .possibleThreeFingeredSections) {
+            const dragFingerIndex = this.findDragIndex(section);
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
+            }
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
+        }
+    }
+    /**
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     *
+     * @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, ...excludedCursorIndices) {
+        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            objectData.accuracy === Math.floor(hitWindow50) + 13) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        // We are not directly using hit time to determine which cursor pressed the object
+        // to account for time difference between hit registration and object judgement.
+        let minHitTime = object.startTime;
+        let maxHitTime = object.startTime;
+        if (object instanceof osuBase.Circle) {
+            let hitWindowGap = hitWindow50;
+            switch (objectData.result) {
+                case exports.HitResult.great:
+                    hitWindowGap = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    hitWindowGap = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+            }
+            minHitTime -= hitWindowGap;
+            maxHitTime += hitWindowGap;
+        }
+        else if (object instanceof osuBase.Slider) {
+            minHitTime -= hitWindow50;
+            maxHitTime += Math.min(hitWindow50, object.spanDuration);
+        }
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = null;
+        let nearestCursorIndex = null;
+        let nearestTime = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (excludedCursorIndices.includes(i)) {
+                continue;
+            }
+            const cursors = this.downCursorInstances[i];
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time < minHitTime) {
+                    continue;
+                }
+                if (cursor.time > maxHitTime) {
+                    break;
+                }
+                const deltaTime = Math.abs(hitTime - cursor.time);
+                if (deltaTime > nearestTime) {
+                    break;
+                }
+                nearestCursorInstanceIndex = i;
+                nearestCursorIndex = j;
+                nearestTime = deltaTime;
+            }
+        }
+        return {
+            pressingCursorInstanceIndex: nearestCursorInstanceIndex !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
+            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
+        };
+    }
+    /**
+     * Checks if a section is dragged and returns the index of the drag finger.
+     *
+     * If the section is not dragged, -1 will be returned.
+     *
+     * @param section The section to check.
+     */
+    findDragIndex(section) {
+        var _a;
+        const objectData = this.data.hitObjectData;
+        const firstObject = this.hitObjects[section.firstObjectIndex];
+        const lastObject = this.hitObjects[section.lastObjectIndex];
+        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);
+            }
+        }
+        else if (firstObject instanceof osuBase.Slider) {
+            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);
+            }
+        }
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectMaxHitTime += Math.min(this.hitWindow.hitWindowFor50(this.isPrecise), lastObject.spanDuration);
+        }
+        // Since there may be more than 1 cursor instance index,
+        // we check which cursor instance follows hitobjects all over.
+        const cursorIndices = [];
+        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;
+            }
+            cursorIndices.push(i);
+        }
+        const sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
+        const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
+        for (let i = 0; i < sectionObjects.length && cursorIndices.some((v) => v !== -1); ++i) {
+            const 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;
+            }
+            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 < cursorIndices.length; ++j) {
+                if (cursorIndices[j] === -1) {
+                    continue;
+                }
+                const cursorData = this.data.cursorMovement[cursorIndices[j]];
+                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
+                if (!cursorGroup) {
+                    continue;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                let isInObject = false;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    // Only consider cursor at interval prev.time <= hitTime <= current.time.
+                    if (prevCursor.time <= hitTime && cursor.time >= hitTime) {
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                isInObject =
+                                    prevCursor.position.getDistance(objectPosition) <= object.radius;
+                                break;
+                            case exports.MovementType.move: {
+                                // Interpolate movement.
+                                const t = (hitTime - 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.radius;
+                            }
+                        }
+                        break;
+                    }
+                }
+                if (!isInObject) {
+                    cursorIndices[j] = -1;
+                }
+            }
+        }
+        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
+    }
+    /**
+     * Creates nerf factors by scanning through objects.
+     */
+    calculateNerfFactors() {
+        for (const beatmapSection of this.beatmapSections) {
+            const cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorIndex === -1 ||
+                    object.pressingCursorInstanceIndex ===
+                        beatmapSection.dragFingerIndex) {
+                    continue;
+                }
+                ++cursorCounts[object.pressingCursorInstanceIndex];
+            }
+            if (beatmapSection.dragFingerIndex !== -1) {
+                // Remove the drag index to prevent it from being picked up into the detection.
+                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
+            }
+            // This index will be used to detect if a section is 3-fingered.
+            // If the section is dragged, the dragged instance will be ignored,
+            // hence why the index is 1 less than nondragged section.
+            const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
+            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
+            // to check if the section is 3-fingered.
+            const threeFingerRatio = cursorCounts
+                .slice(fingerSplitIndex)
+                .reduce((acc, value) => acc + value, 0) /
+                Math.max(cursorCounts
+                    .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0), 1);
+            if (threeFingerRatio > this.threeFingerRatioThreshold) {
+                const threeFingeredObjectCount = cursorCounts
+                    .slice(fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0);
+                const sectionObjectCount = beatmapSection.lastObjectIndex -
+                    beatmapSection.firstObjectIndex +
+                    1;
+                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
+                // We can ignore the first 3 (2 for drag) filled cursor instances
+                // since they are guaranteed not 3 finger.
+                const threeFingerCursorCounts = cursorCounts
+                    .slice(fingerSplitIndex)
+                    .filter((amount) => amount > 0);
+                // Finger factor applies more penalty if more fingers were used.
+                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
+                // Length factor applies more penalty if there are more 3-fingered object.
+                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
+                this.nerfFactors.push({
+                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
+                    fingerFactor: fingerFactor,
+                    lengthFactor: lengthFactor,
+                });
+            }
+        }
+    }
+    /**
+     * Calculates the final penalty.
+     */
+    calculateFinalPenalty() {
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 /**
  * Represents a replay data in an osu!droid replay.
  *
@@ -320,25 +794,6 @@ exports.HitResult = void 0;
  * 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;
@@ -357,8 +812,12 @@ class ReplayData {
         this.convertedMods = values.convertedMods || [];
         this.cursorMovement = values.cursorMovement;
         this.hitObjectData = values.hitObjectData;
-        this.speedModification = values.speedModification || 1;
-        this.forcedAR = values.forcedAR;
+        this.speedMultiplier = values.speedMultiplier || 1;
+        this.forceCS = values.forceCS;
+        this.forceAR = values.forceAR;
+        this.forceOD = values.forceOD;
+        this.forceHP = values.forceHP;
+        this.flashlightFollowDelay = values.flashlightFollowDelay;
     }
 }
 
@@ -366,112 +825,51 @@ class ReplayData {
  * Utility to check whether or not a beatmap is three-fingered.
  */
 class ThreeFingerChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The 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;
-    /**
-     * The threshold for the amount of cursors that are assumed to be pressed
-     * by a single finger.
-     */
-    cursorDistancingCountThreshold = 10;
-    /**
-     * The threshold for the time difference of cursors that are assumed to be pressed
-     * by a single finger, in milliseconds.
-     */
-    cursorDistancingTimeThreshold = 1000;
-    /**
-     * The amount of notes that has a tap strain exceeding `strainThreshold`.
-     */
-    strainNoteCount;
-    /**
-     * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-     *
-     * Increasing this number will increase detection accuracy, however
-     * it also increases the chance of falsely flagged plays.
-     */
-    threeFingerRatioThreshold = 0.01;
-    /**
-     * Extended sections of the beatmap for drag detection.
-     */
-    beatmapSections = [];
-    /**
-     * This threshold is used to filter out accidental taps.
-     *
-     * Increasing this number makes the filtration more sensitive, however it
-     * will also increase the chance of 3-fingered plays getting out from
-     * being flagged.
-     */
-    accidentalTapThreshold = 400;
-    /**
-     * The hit window of this beatmap. Keep in mind that speed-changing mods do not change hit window length in game logic.
-     */
-    hitWindow;
-    /**
-     * A reprocessed break points to match right on object time.
-     *
-     * This is used to increase detection accuracy since break points do not start right at the
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    breakPointAccurateTimes = [];
-    /**
-     * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    downCursorInstances = [];
-    /**
-     * Nerf factors from all sections that were three-fingered.
-     */
-    nerfFactors = [];
-    /**
-     * Whether this score uses the Precise mod.
-     */
-    isPrecise;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
+        /**
+         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
+         *
+         * Increasing this number will increase detection accuracy, however
+         * it also increases the chance of falsely flagged plays.
+         */
+        this.threeFingerRatioThreshold = 0.01;
+        /**
+         * Extended sections of the beatmap for drag detection.
+         */
+        this.beatmapSections = [];
+        /**
+         * A reprocessed break points to match right on object time.
+         *
+         * This is used to increase detection accuracy since break points do not start right at the
+         * start of the hitobject before it and do not end right at the first hitobject after it.
+         */
+        this.breakPointAccurateTimes = [];
+        /**
+         * A cursor occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+         *
+         * Each index represents the cursor index.
+         */
+        this.downCursorInstances = [];
+        /**
+         * Nerf factors from all sections that were three-fingered.
+         */
+        this.nerfFactors = [];
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const 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();
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
         this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
-        this.hitWindow = new osuBase.DroidHitWindow(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.hitWindow = new osuBase.DroidHitWindow(od);
+        this.hitObjects = beatmap.hitObjects.objects;
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -492,7 +890,7 @@ class ThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.strainNoteCount === 0) {
+        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getAccurateBreakPoints();
@@ -501,11 +899,6 @@ class ThreeFingerChecker {
             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,42 +907,31 @@ 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 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 beforeIndex = osuBase.MathUtils.clamp(this.hitObjects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, this.hitObjects.length - 2);
+            const objectBefore = this.hitObjects[beforeIndex];
+            const objectBeforeData = objectData[beforeIndex];
+            let timeBefore = objectBefore.endTime;
+            if (objectBefore instanceof osuBase.Circle) {
+                if (objectBeforeData.result !== exports.HitResult.miss) {
+                    timeBefore += objectBeforeData.accuracy;
+                }
+                else {
+                    timeBefore += this.hitWindow.hitWindowFor50(this.isPrecise);
+                }
             }
-            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 = this.hitObjects[afterIndex];
+            const objectAfterData = objectData[afterIndex];
+            let timeAfter = this.hitObjects[afterIndex].startTime;
+            if (objectAfter instanceof osuBase.Circle &&
+                objectAfterData.result !== exports.HitResult.miss) {
+                timeAfter += objectAfterData.accuracy;
             }
-            timeAfter += afterIndexHitWindowLength;
             this.breakPointAccurateTimes.push(new osuBase.BreakPoint({
                 startTime: timeBefore,
                 endTime: timeAfter,
@@ -562,13 +944,14 @@ 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 objectData = this.data.hitObjectData;
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
+        const firstObject = this.hitObjects[0];
+        const lastObject = this.hitObjects.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) {
+        if (firstObject instanceof osuBase.Circle) {
             switch (firstObjectResult) {
                 case exports.HitResult.great:
                     firstObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
@@ -582,7 +965,7 @@ class ThreeFingerChecker {
         }
         // 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) {
+        if (lastObject instanceof osuBase.Circle) {
             switch (lastObjectResult) {
                 case exports.HitResult.great:
                     lastObjectHitWindow = this.hitWindow.hitWindowFor300(this.isPrecise);
@@ -594,16 +977,17 @@ class ThreeFingerChecker {
                     lastObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
+        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,24 +1008,93 @@ class ThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
+        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            this.beatmapSections.push({
-                ...section,
-                isDragged: false,
-                dragFingerIndex: -1,
-            });
+            const dragFingerIndex = this.findDragIndex(section);
+            const objects = [];
+            for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
+                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
+            }
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
         }
     }
     /**
-     * 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;
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     *
+     * @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, ...excludedCursorIndices) {
+        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            objectData.accuracy === Math.floor(hitWindow50) + 13) {
+            return {
+                pressingCursorInstanceIndex: -1,
+                pressingCursorIndex: -1,
+            };
+        }
+        // We are not directly using hit time to determine which cursor pressed the object
+        // to account for time difference between hit registration and object judgement.
+        let minHitTime = object.startTime;
+        let maxHitTime = object.startTime;
+        if (object instanceof osuBase.Circle) {
+            let hitWindowGap = hitWindow50;
+            switch (objectData.result) {
+                case exports.HitResult.great:
+                    hitWindowGap = this.hitWindow.hitWindowFor300(this.isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    hitWindowGap = this.hitWindow.hitWindowFor100(this.isPrecise);
+                    break;
+            }
+            minHitTime -= hitWindowGap;
+            maxHitTime += hitWindowGap;
+        }
+        else if (object instanceof osuBase.Slider) {
+            minHitTime -= hitWindow50;
+            maxHitTime += Math.min(hitWindow50, object.spanDuration);
+        }
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = null;
+        let nearestCursorIndex = null;
+        let nearestTime = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (excludedCursorIndices.includes(i)) {
+                continue;
+            }
+            const cursors = this.downCursorInstances[i];
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time < minHitTime) {
+                    continue;
+                }
+                if (cursor.time > maxHitTime) {
+                    break;
+                }
+                const deltaTime = Math.abs(hitTime - cursor.time);
+                if (deltaTime > nearestTime) {
+                    break;
+                }
+                nearestCursorInstanceIndex = i;
+                nearestCursorIndex = j;
+                nearestTime = deltaTime;
+            }
         }
+        return {
+            pressingCursorInstanceIndex: nearestCursorInstanceIndex !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
+            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
+        };
     }
     /**
      * Checks if a section is dragged and returns the index of the drag finger.
@@ -650,11 +1103,11 @@ class ThreeFingerChecker {
      *
      * @param section The section to check.
      */
-    checkDrag(section) {
-        const { objects } = this.beatmap.hitObjects;
+    findDragIndex(section) {
+        var _a;
         const objectData = this.data.hitObjectData;
-        const firstObject = objects[section.firstObjectIndex];
-        const lastObject = objects[section.lastObjectIndex];
+        const firstObject = this.hitObjects[section.firstObjectIndex];
+        const lastObject = this.hitObjects[section.lastObjectIndex];
         let firstObjectMinHitTime = firstObject.startTime;
         if (firstObject instanceof osuBase.Circle) {
             switch (objectData[section.firstObjectIndex].result) {
@@ -668,7 +1121,7 @@ class ThreeFingerChecker {
                     firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
-        else {
+        else if (firstObject instanceof osuBase.Slider) {
             firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
         }
         let lastObjectMaxHitTime = lastObject.startTime;
@@ -684,12 +1137,12 @@ class ThreeFingerChecker {
                     lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
             }
         }
-        else {
-            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
+        else if (lastObject instanceof osuBase.Slider) {
+            lastObjectMaxHitTime += Math.min(this.hitWindow.hitWindowFor50(this.isPrecise), lastObject.spanDuration);
         }
         // Since there may be more than 1 cursor instance index,
         // we check which cursor instance follows hitobjects all over.
-        const cursorIndexes = [];
+        const cursorIndices = [];
         for (let i = 0; i < this.data.cursorMovement.length; ++i) {
             const c = this.data.cursorMovement[i];
             if (c.occurrenceGroups.length === 0) {
@@ -706,21 +1159,13 @@ class ThreeFingerChecker {
                 0) {
                 continue;
             }
-            cursorIndexes.push(i);
+            cursorIndices.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 sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
+        const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
         const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
-        for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
-            let object = sectionObjects[i];
+        for (let i = 0; i < sectionObjects.length && cursorIndices.some((v) => v !== -1); ++i) {
+            const object = sectionObjects[i];
             const objectData = sectionReplayObjectData[i];
             if (object instanceof osuBase.Spinner ||
                 objectData.result === exports.HitResult.miss) {
@@ -731,210 +1176,101 @@ class ThreeFingerChecker {
                 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) {
+            for (let j = 0; j < cursorIndices.length; ++j) {
+                if (cursorIndices[j] === -1) {
                     continue;
                 }
-                const cursorData = this.data.cursorMovement[cursorIndexes[j]];
+                const cursorData = this.data.cursorMovement[cursorIndices[j]];
                 const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
                 if (!cursorGroup) {
                     continue;
                 }
                 const cursors = cursorGroup.allOccurrences;
+                let isInObject = false;
                 for (let k = 1; k < cursors.length; ++k) {
                     const cursor = cursors[k];
                     const prevCursor = cursors[k - 1];
-                    if (prevCursor.time < object.startTime - hitWindow50) {
-                        continue;
-                    }
-                    if (prevCursor.time > object.startTime + hitWindow50) {
-                        break;
-                    }
-                    let isInObject = false;
-                    switch (cursor.id) {
-                        case exports.MovementType.up:
-                            isInObject =
-                                prevCursor.position.getDistance(objectPosition) <= object.getRadius(osuBase.Modes.droid);
-                            break;
-                        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) /
+                    // Only consider cursor at interval prev.time <= hitTime <= current.time.
+                    if (prevCursor.time <= hitTime && cursor.time >= hitTime) {
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                isInObject =
+                                    prevCursor.position.getDistance(objectPosition) <= object.radius;
+                                break;
+                            case exports.MovementType.move: {
+                                // Interpolate movement.
+                                const t = (hitTime - 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);
+                                    objectPosition.getDistance(cursorPosition) <= object.radius;
                             }
-                    }
-                    if (!isInObject) {
-                        cursorIndexes[j] = -1;
+                        }
+                        break;
                     }
                 }
+                if (!isInObject) {
+                    cursorIndices[j] = -1;
+                }
             }
         }
-        return cursorIndexes.find((v) => v !== -1) ?? -1;
-    }
-    /**
-     * Attempts to prevent accidental taps from being flagged.
-     *
-     * 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;
-        }
-        const { objects } = this.beatmap.hitObjects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.length, 0);
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (filledCursorAmount <= 3) {
-                break;
-            }
-            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;
-            }
-            this.downCursorInstances[i] = cursorInstances;
-        }
+        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
     }
     /**
      * 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 cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorIndex === -1 ||
+                    object.pressingCursorInstanceIndex ===
+                        beatmapSection.dragFingerIndex) {
                     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,
-                        });
-                    }
-                }
-                cursorAmounts.push(amount);
+                ++cursorCounts[object.pressingCursorInstanceIndex];
+            }
+            if (beatmapSection.dragFingerIndex !== -1) {
+                // Remove the drag index to prevent it from being picked up into the detection.
+                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
             }
             // This index will be used to detect if a section is 3-fingered.
             // If the section is dragged, the dragged instance will be ignored,
             // hence why the index is 1 less than nondragged section.
-            const fingerSplitIndex = dragIndex !== -1 ? 2 : 3;
+            const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
             // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
             // to check if the section is 3-fingered.
-            const threeFingerRatio = cursorAmounts
+            const threeFingerRatio = cursorCounts
                 .slice(fingerSplitIndex)
                 .reduce((acc, value) => acc + value, 0) /
-                cursorAmounts
+                Math.max(cursorCounts
                     .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0), 1);
+            if (threeFingerRatio > this.threeFingerRatioThreshold) {
+                const threeFingeredObjectCount = cursorCounts
+                    .slice(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;
-                    }
-                    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 -
+                const sectionObjectCount = beatmapSection.lastObjectIndex -
                     beatmapSection.firstObjectIndex +
                     1;
+                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
                 // We can ignore the first 3 (2 for drag) filled cursor instances
                 // since they are guaranteed not 3 finger.
-                const threeFingerCursorAmounts = cursorAmounts
+                const threeFingerCursorCounts = cursorCounts
                     .slice(fingerSplitIndex)
                     .filter((amount) => amount > 0);
                 // Finger factor applies more penalty if more fingers were used.
-                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
-                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) * value * objectCount) /
-                            this.strainNoteCount, 0.9), 1)
-                    : Math.pow(validPresses.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) *
-                            (value.count /
-                                (this
-                                    .cursorDistancingCountThreshold *
-                                    2)) *
-                            objectCount) /
-                            this.strainNoteCount, 0.2), 1), 0.2);
+                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
                 // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
                 this.nerfFactors.push({
-                    strainFactor: Math.max(1, beatmapSection.sumStrain),
-                    fingerFactor,
-                    lengthFactor,
+                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
+                    fingerFactor: fingerFactor,
+                    lengthFactor: lengthFactor,
                 });
             }
         }
@@ -943,10 +1279,9 @@ class ThreeFingerChecker {
      * 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);
     }
 }
 
@@ -954,49 +1289,6 @@ class ThreeFingerChecker {
  * Contains information about which cursor index hits a hitobject.
  */
 class IndexedHitObject {
-    /**
-     * The cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    cursorIndex;
-    /**
-     * The group index of the cursor within the cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    groupIndex;
-    /**
-     * The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
-     *
-     * If -1, the detection was unable to find any cursor that attempted to hit
-     * the hitobject or it did not meet the criteria for detection.
-     */
-    occurrenceIndex;
-    /**
-     * The angle of the movement of the cursor towards the next hitobject.
-     */
-    angle;
-    /**
-     * If this is a slider, whether the slider was cheesed.
-     */
-    sliderCheesed = false;
-    /**
-     * The underlying difficulty hitobject.
-     */
-    object;
-    /**
-     * The position of the cursor at the end of this hitobject.
-     *
-     * Will be altered during detection.
-     */
-    endCursorPosition;
-    /**
-     * Whether the hitobject is likely two-handed.
-     */
-    is2Handed;
     /**
      * @param object The underlying difficulty hitobject.
      * @param cursorIndex The cursor index that moves towards the hitobject.
@@ -1005,6 +1297,10 @@ class IndexedHitObject {
      * @param angle The angle of the movement of the cursor that moves towards the hitobject.
      */
     constructor(object, cursorIndex, groupIndex, occurrenceIndex, angle, is2Handed) {
+        /**
+         * If this is a slider, whether the slider was cheesed.
+         */
+        this.sliderCheesed = false;
         this.object = object;
         this.cursorIndex = cursorIndex;
         this.groupIndex = groupIndex;
@@ -1020,40 +1316,24 @@ class IndexedHitObject {
  * Utility to check whether or not a beatmap is two-handed.
  */
 class TwoHandChecker {
-    /**
-     * The difficulty calculator that is being analyzed.
-     */
-    calculator;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The hitobjects of the beatmap that have been assigned with their respective cursor index.
-     */
-    indexedHitObjects = [];
-    /**
-     * The osu!droid hitwindow of the analyzed beatmap.
-     */
-    hitWindow;
-    /**
-     * The 50 osu!droid hit window of the analyzed beatmap.
-     */
-    hitWindow50;
     // private csvString: string;
     /**
      * @param calculator The difficulty calculator to analyze.
      * @param data The data of the replay.
      */
     constructor(calculator, data) {
+        /**
+         * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+         */
+        this.indexedHitObjects = [];
         this.calculator = calculator;
         this.data = data;
-        const 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();
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: calculator.beatmap.difficulty.od,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.hitWindow = new osuBase.DroidHitWindow(od);
         this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
         // this.csvString = `Mods,${
         //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
@@ -1236,9 +1516,8 @@ class TwoHandChecker {
         const prevToCurrentMovement = object
             .getStackedPosition(osuBase.Modes.droid)
             .subtract(prevObjectEndPosition);
-        const radius = object.getRadius(osuBase.Modes.droid);
         // Don't consider objects that are too close to each other.
-        if (prevToCurrentMovement.length <= radius) {
+        if (prevToCurrentMovement.length <= object.radius) {
             return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
         }
         // The case for a one-handed object is that there will be a slight movement in the cursor towards
@@ -1367,7 +1646,6 @@ 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);
         // For sliders, set the hit window to as lenient as possible.
@@ -1382,7 +1660,7 @@ class TwoHandChecker {
             }
         }
         // 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 +1668,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,7 +1685,8 @@ class TwoHandChecker {
                 }
                 // Validate the down press first.
                 const { down } = cursorGroup;
-                if (down.position.getDistance(objectPosition) <= radius &&
+                if (down.position.getDistance(objectPosition) <=
+                    object.radius &&
                     Math.abs(down.time - object.startTime) <= hitWindow) {
                     if (objectIndex > 0) {
                         const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
@@ -1478,12 +1757,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;
                     }
                 }
@@ -1531,7 +1811,7 @@ class TwoHandChecker {
         else {
             objectEndPosition = object.getStackedPosition(osuBase.Modes.droid);
         }
-        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;
@@ -1631,22 +1911,6 @@ class TwoHandChecker {
  * Utility to check whether relevant sliders in a beatmap are cheesed.
  */
 class SliderCheeseChecker {
-    /**
-     * The beatmap that is being analyzed.
-     */
-    beatmap;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The 50 osu!droid hit window of the analyzed beatmap.
-     */
-    hitWindow50;
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
@@ -1656,18 +1920,21 @@ class SliderCheeseChecker {
         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();
-        this.hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
+            convertOverallDifficulty: false,
+        }).overallDifficulty;
+        this.hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
     }
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
      */
     check() {
-        if (this.difficultyAttributes.difficultSliders.length === 0) {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            (this.difficultyAttributes.sliderFactor === 1 &&
+                this.difficultyAttributes.flashlightSliderFactor === 1 &&
+                this.difficultyAttributes.visualSliderFactor === 1)) {
             return {
                 aimPenalty: 1,
                 flashlightPenalty: 1,
@@ -1681,15 +1948,11 @@ class SliderCheeseChecker {
      * Checks for sliders that were cheesed.
      */
     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 = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
-        const acceptableRadius = 128 * scale;
+        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()
@@ -1698,18 +1961,19 @@ class SliderCheeseChecker {
                 continue;
             }
             const objectData = this.data.hitObjectData[difficultSlider.index];
-            // If a slider break occurs, we disregard the check for that slider.
-            if (objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+            // 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 = (this.beatmap.hitObjects.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 object = objects[difficultSlider.index];
             const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
-            // Get the closest tap distance across all cursor.
+            // 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) {
@@ -1718,24 +1982,72 @@ class SliderCheeseChecker {
                 let closestIndex = cursorGroups.length;
                 for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
                     const group = cursorGroups[j];
-                    if (group.startTime < object.startTime - this.hitWindow50) {
+                    if (group.endTime < minTimeLimit) {
                         continue;
                     }
-                    if (group.startTime > object.startTime + this.hitWindow50) {
+                    if (group.startTime > maxTimeLimit) {
                         break;
                     }
-                    const distance = group.down.position.getDistance(objectStartPosition);
-                    if (closestDistance > distance) {
-                        closestDistance = distance;
-                        closestIndex = j;
+                    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) {
+            if (closestDistance > acceptableRadius / 2) {
                 cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
                 continue;
             }
@@ -1752,12 +2064,7 @@ class SliderCheeseChecker {
                 if (!tickWasHit) {
                     continue;
                 }
-                let nestedObject = object.nestedHitObjects[i];
-                if (nestedObject.droidScale !== scale) {
-                    // Deep clone the object so that we can assign scale properly
-                    nestedObject = osuBase.Utils.deepCopy(nestedObject);
-                    nestedObject.droidScale = scale;
-                }
+                const nestedObject = object.nestedHitObjects[i];
                 const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
                 while (occurrenceLoopIndex < allOccurrences.length &&
                     allOccurrences[occurrenceLoopIndex].time <
@@ -1794,17 +2101,17 @@ class SliderCheeseChecker {
      * Calculates the slider cheese penalty.
      */
     calculateSliderCheesePenalty(cheesedDifficultyRatings) {
-        const summedDifficultyRating = cheesedDifficultyRatings.reduce((a, v) => a + v, 0);
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
         return {
-            aimPenalty: Math.pow(1 -
+            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
                 summedDifficultyRating *
-                    this.difficultyAttributes.sliderFactor, 3),
-            flashlightPenalty: Math.pow(1 -
+                    this.difficultyAttributes.sliderFactor, 2)),
+            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
                 summedDifficultyRating *
-                    this.difficultyAttributes.flashlightSliderFactor, 3),
-            visualPenalty: Math.pow(1 -
+                    this.difficultyAttributes.flashlightSliderFactor, 2)),
+            visualPenalty: Math.max(this.difficultyAttributes.visualSliderFactor, Math.pow(1 -
                 summedDifficultyRating *
-                    this.difficultyAttributes.visualSliderFactor, 3),
+                    this.difficultyAttributes.visualSliderFactor, 2)),
         };
     }
 }
@@ -1817,77 +2124,57 @@ class SliderCheeseChecker {
  * Once analyzed, the result can be accessed via the `data` property.
  */
 class ReplayAnalyzer {
-    /**
-     * The score ID of the replay.
-     */
-    scoreID;
-    /**
-     * The original odr file of the replay.
-     */
-    originalODR = null;
-    /**
-     * The fixed odr file of the replay.
-     */
-    fixedODR = null;
-    /**
-     * Whether or not the play is considered using >=3 finger abuse.
-     */
-    is3Finger;
-    /**
-     * Whether or not the play is considered 2-handed.
-     */
-    is2Hand;
-    /**
-     * The beatmap that is being analyzed. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` is required for three finger or two hand analyzing.
-     */
-    beatmap;
-    /**
-     * The difficulty attributes of the beatmap.
-     */
-    difficultyAttributes;
-    /**
-     * The results of the analyzer. `null` when initialized.
-     */
-    data = null;
-    /**
-     * Penalty value used to penalize dpp for 2-hand.
-     */
-    aimPenalty = 1;
-    /**
-     * Penalty value used to penalize dpp for 3 finger abuse.
-     */
-    tapPenalty = 1;
-    /**
-     * Penalty values used to penalize dpp for slider cheesing.
-     */
-    sliderCheesePenalty = {
-        aimPenalty: 1,
-        flashlightPenalty: 1,
-        visualPenalty: 1,
-    };
-    /**
-     * Whether this replay has been checked against 3 finger usage.
-     */
-    hasBeenCheckedFor3Finger = false;
-    /**
-     * Whether this replay has been checked against 2 hand usage.
-     */
-    hasBeenCheckedFor2Hand = false;
-    /**
-     * Whether this repla has been checked against slider cheesing.
-     */
-    hasBeenCheckedForSliderCheesing = false;
-    /**
-     * The amount of two-handed objects.
-     */
-    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) {
+        /**
+         * The original odr file of the replay.
+         */
+        this.originalODR = null;
+        /**
+         * The fixed odr file of the replay.
+         */
+        this.fixedODR = null;
+        /**
+         * The results of the analyzer. `null` when initialized.
+         */
+        this.data = null;
+        /**
+         * Penalty value used to penalize dpp for 2-hand.
+         */
+        this.aimPenalty = 1;
+        /**
+         * Penalty value used to penalize dpp for 3 finger abuse.
+         */
+        this.tapPenalty = 1;
+        /**
+         * Penalty values used to penalize dpp for slider cheesing.
+         */
+        this.sliderCheesePenalty = {
+            aimPenalty: 1,
+            flashlightPenalty: 1,
+            visualPenalty: 1,
+        };
+        /**
+         * Whether this replay has been checked against 3 finger usage.
+         */
+        this.hasBeenCheckedFor3Finger = false;
+        /**
+         * Whether this replay has been checked against 2 hand usage.
+         */
+        this.hasBeenCheckedFor2Hand = false;
+        /**
+         * Whether this replay has been checked against slider cheesing.
+         */
+        this.hasBeenCheckedForSliderCheesing = false;
+        /**
+         * The amount of two-handed objects.
+         */
+        this.twoHandedNoteCount = 0;
+        // Sizes of primitive data types in Java (in bytes)
+        this.BYTE_LENGTH = 1;
+        this.SHORT_LENGTH = 2;
+        this.INT_LENGTH = 4;
+        this.FLOAT_LENGTH = 4;
+        this.LONG_LENGTH = 8;
         this.scoreID = values.scoreID;
         this.beatmap = values.map;
         this.difficultyAttributes = values.difficultyAttributes;
@@ -1898,35 +2185,39 @@ class ReplayAnalyzer {
     /**
      * Analyzes a replay.
      */
-    async analyze() {
-        if (!this.originalODR && !this.fixedODR) {
-            this.originalODR = await this.downloadReplay();
-        }
-        if (!this.originalODR) {
-            return this;
-        }
-        if (!this.fixedODR) {
-            this.fixedODR = await this.decompress().catch(() => null);
-        }
-        if (!this.fixedODR) {
+    analyze() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.originalODR && !this.fixedODR) {
+                this.originalODR = yield this.downloadReplay();
+            }
+            if (!this.originalODR) {
+                return this;
+            }
+            if (!this.fixedODR) {
+                this.fixedODR = yield this.decompress().catch(() => null);
+            }
+            if (!this.fixedODR) {
+                return this;
+            }
+            this.parseReplay();
             return this;
-        }
-        this.parseReplay();
-        return this;
+        });
     }
     /**
      * Downloads the given score ID's replay.
      */
-    async downloadReplay() {
-        const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
-            .setRequireAPIkey(false)
-            .setEndpoint("upload")
-            .addParameter("", `${this.scoreID}.odr`);
-        const result = await apiRequestBuilder.sendRequest();
-        if (result.statusCode !== 200) {
-            return null;
-        }
-        return result.data;
+    downloadReplay() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const apiRequestBuilder = new osuBase.DroidAPIRequestBuilder()
+                .setRequireAPIkey(false)
+                .setEndpoint("upload")
+                .addParameter("", `${this.scoreID}.odr`);
+            const result = yield apiRequestBuilder.sendRequest();
+            if (result.statusCode !== 200) {
+                return null;
+            }
+            return result.data;
+        });
     }
     /**
      * Decompresses a replay.
@@ -1940,15 +2231,15 @@ class ReplayAnalyzer {
             stream.push(null);
             stream
                 .pipe(unzipper.Parse())
-                .on("entry", async (entry) => {
+                .on("entry", (entry) => __awaiter(this, void 0, void 0, function* () {
                 const fileName = entry.path;
                 if (fileName === "data") {
-                    return resolve(await entry.buffer());
+                    return resolve(yield entry.buffer());
                 }
                 else {
                     entry.autodrain();
                 }
-            })
+            }))
                 .on("error", (e) => {
                 setTimeout(() => reject(e), 2000);
             });
@@ -1958,6 +2249,10 @@ class ReplayAnalyzer {
      * Parses a replay after being downloaded and converted to a buffer.
      */
     parseReplay() {
+        var _a, _b, _c;
+        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
@@ -1965,7 +2260,7 @@ class ReplayAnalyzer {
         try {
             rawObject = javaDeserialization__namespace.parse(this.fixedODR);
         }
-        catch {
+        catch (_d) {
             return;
         }
         const resultObject = {
@@ -1975,29 +2270,16 @@ class ReplayAnalyzer {
             hash: rawObject[3],
             cursorMovement: [],
             hitObjectData: [],
+            accuracy: new osuBase.Accuracy({ n300: 0 }),
+            rank: "",
         };
-        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];
-            resultObject.playerName = rawObject[5];
-            resultObject.rawMods = rawObject[6].elements;
-            resultObject.convertedMods = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(rawObject[6].elements));
-            // Determine rank
+        const determineRank = () => {
+            var _a, _b;
             const totalHits = resultObject.accuracy.n300 +
                 resultObject.accuracy.n100 +
                 resultObject.accuracy.n50 +
                 resultObject.accuracy.nmiss;
-            const isHidden = resultObject.convertedMods.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight);
+            const isHidden = (_b = (_a = resultObject.convertedMods) === null || _a === void 0 ? void 0 : _a.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight)) !== null && _b !== void 0 ? _b : false;
             const hit300Ratio = resultObject.accuracy.n300 / totalHits;
             switch (true) {
                 case resultObject.accuracy.value() === 1:
@@ -2032,13 +2314,53 @@ class ReplayAnalyzer {
                 default:
                     resultObject.rank = "D";
             }
+        };
+        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];
+            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", ""));
+            const str = rawObject[7].split("|");
+            for (const s of str) {
+                switch (true) {
+                    // Forced stats
+                    case s.startsWith("CS"):
+                        resultObject.forceCS = parseFloat(s.replace("CS", ""));
+                        break;
+                    case s.startsWith("AR"):
+                        resultObject.forceAR = parseFloat(s.replace("AR", ""));
+                        break;
+                    case s.startsWith("OD"):
+                        resultObject.forceOD = parseFloat(s.replace("OD", ""));
+                        break;
+                    case s.startsWith("HP"):
+                        resultObject.forceHP = parseFloat(s.replace("HP", ""));
+                        break;
+                    // FL follow delay
+                    case s.startsWith("FLD"):
+                        resultObject.flashlightFollowDelay =
+                            parseFloat(s.replace("FLD", "")) || 0.12;
+                        break;
+                    // Speed multiplier
+                    case s.startsWith("x"):
+                        resultObject.speedMultiplier =
+                            parseFloat(s.replace("x", "")) || 1;
+                        break;
+                }
             }
         }
         let bufferIndex;
@@ -2111,7 +2433,7 @@ class ReplayAnalyzer {
             const replayObjectData = {
                 accuracy: 0,
                 tickset: [],
-                result: 0,
+                result: exports.HitResult.miss,
             };
             replayObjectData.accuracy =
                 replayDataBuffer.readInt16BE(bufferCounter);
@@ -2139,41 +2461,41 @@ class ReplayAnalyzer {
             resultObject.hitObjectData.push(replayObjectData);
         }
         // Parse max combo, hit results, and accuracy in old replay version
-        if (resultObject.replayVersion < 3 && this.beatmap) {
-            let hit300 = 0;
-            let hit300k = 0;
-            let hit100 = 0;
-            let hit100k = 0;
-            let hit50 = 0;
-            let hit0 = 0;
-            let grantsGekiOrKatu = true;
-            const objects = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+        if (resultObject.replayVersion < 3) {
+            const objects = (_a = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
                 this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
                 ? this.beatmap.beatmap
-                : this.beatmap).hitObjects.objects;
+                : this.beatmap)) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
+            let grantsGekiOrKatu = true;
             for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
                 // Hit result
                 const hitObjectData = resultObject.hitObjectData[i];
-                const isNextNewCombo = i + 1 !== objects.length ? objects[i + 1].isNewCombo : true;
+                const isNextNewCombo = objects
+                    ? i + 1 !== objects.length
+                        ? objects[i + 1].isNewCombo
+                        : true
+                    : false;
                 switch (hitObjectData.result) {
                     case exports.HitResult.miss:
-                        ++hit0;
+                        ++resultObject.accuracy.nmiss;
                         grantsGekiOrKatu = false;
                         break;
                     case exports.HitResult.meh:
-                        ++hit50;
+                        ++resultObject.accuracy.n50;
                         grantsGekiOrKatu = false;
                         break;
                     case exports.HitResult.good:
-                        ++hit100;
+                        ++resultObject.accuracy.n100;
                         if (grantsGekiOrKatu && isNextNewCombo) {
-                            ++hit100k;
+                            (_b = resultObject.hit100k) !== null && _b !== void 0 ? _b : (resultObject.hit100k = 0);
+                            ++resultObject.hit100k;
                         }
                         break;
                     case exports.HitResult.great:
-                        ++hit300;
+                        ++resultObject.accuracy.n300;
                         if (grantsGekiOrKatu && isNextNewCombo) {
-                            ++hit300k;
+                            (_c = resultObject.hit300k) !== null && _c !== void 0 ? _c : (resultObject.hit300k = 0);
+                            ++resultObject.hit300k;
                         }
                         break;
                 }
@@ -2181,55 +2503,7 @@ class ReplayAnalyzer {
                     grantsGekiOrKatu = true;
                 }
             }
-            resultObject.hit300k = hit300k;
-            resultObject.hit100k = hit100k;
-            resultObject.accuracy = new osuBase.Accuracy({
-                n300: hit300,
-                n100: hit100,
-                n50: hit50,
-                nmiss: hit0,
-                nobjects: hit300 + hit100 + hit50 + hit0,
-            });
-            // Determine rank
-            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";
-            }
+            determineRank();
         }
         this.data = new ReplayData(resultObject);
     }
@@ -2251,12 +2525,12 @@ class ReplayAnalyzer {
             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));
+        const { objects } = beatmap.hitObjects;
+        const od = osuBase.calculateDroidDifficultyStatistics({
+            overallDifficulty: beatmap.difficulty.od,
+            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
+        }).overallDifficulty;
+        const hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
         // The accuracy of sliders is set to (50 hit window)ms + 13ms if their head was not hit:
         // https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821
         //
@@ -2270,8 +2544,8 @@ class ReplayAnalyzer {
                 accuracies.push(0);
                 continue;
             }
-            const accuracy = v.accuracy;
-            if (o instanceof osuBase.Slider && v.accuracy === sliderbreakHitOffset) {
+            const { accuracy } = v;
+            if (o instanceof osuBase.Slider && accuracy === sliderbreakHitOffset) {
                 accuracies.push(0);
                 continue;
             }
@@ -2310,13 +2584,11 @@ class ReplayAnalyzer {
             MOD_PERFECT: "f",
             MOD_SUDDENDEATH: "u",
             MOD_SCOREV2: "v",
+            MOD_FLASHLIGHT: "i",
         };
         let modString = "";
         for (const mod of replayMods) {
             for (const property in replayModsConstants) {
-                if (!(property in replayModsConstants)) {
-                    continue;
-                }
                 if (!mod.includes(property)) {
                     continue;
                 }
@@ -2333,12 +2605,36 @@ class ReplayAnalyzer {
      * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkFor3Finger() {
+        var _a;
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const threeFingerChecker = new ThreeFingerChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
+        if (!this.convertedBeatmap) {
+            const mods = this.data.convertedMods.slice();
+            if ([
+                this.data.forceCS,
+                this.data.forceAR,
+                this.data.forceOD,
+                this.data.forceHP,
+            ].some((v) => v !== undefined)) {
+                mods.push(new osuBase.ModDifficultyAdjust({
+                    cs: this.data.forceCS,
+                    ar: this.data.forceAR,
+                    od: this.data.forceOD,
+                    hp: this.data.forceHP,
+                }));
+            }
+            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+                ? this.beatmap
+                : this.beatmap.beatmap).convert({
+                mode: osuBase.Modes.droid,
+                mods: mods,
+                customSpeedMultiplier: this.data.speedMultiplier,
+            }));
+        }
+        const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes)
+            : new ThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
         const result = threeFingerChecker.check();
         this.is3Finger = result.is3Finger;
         this.tapPenalty = result.penalty;
@@ -2367,12 +2663,34 @@ class ReplayAnalyzer {
      * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
      */
     checkForSliderCheesing() {
+        var _a;
         if (!this.beatmap || !this.data || !this.difficultyAttributes) {
             return;
         }
-        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap instanceof osuBase.Beatmap
-            ? this.beatmap
-            : this.beatmap.beatmap, this.data, this.difficultyAttributes);
+        if (!this.convertedBeatmap) {
+            const mods = this.data.convertedMods.slice();
+            if ([
+                this.data.forceCS,
+                this.data.forceAR,
+                this.data.forceOD,
+                this.data.forceHP,
+            ].some((v) => v !== undefined)) {
+                mods.push(new osuBase.ModDifficultyAdjust({
+                    cs: this.data.forceCS,
+                    ar: this.data.forceAR,
+                    od: this.data.forceOD,
+                    hp: this.data.forceHP,
+                }));
+            }
+            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
+                ? this.beatmap
+                : this.beatmap.beatmap).convert({
+                mode: osuBase.Modes.droid,
+                mods: mods,
+                customSpeedMultiplier: this.data.speedMultiplier,
+            }));
+        }
+        const sliderCheeseChecker = new SliderCheeseChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }
@@ -2386,33 +2704,6 @@ class ReplayAnalyzer {
  * This is used when analyzing replays using replay analyzer.
  */
 class ReplayObjectData {
-    /**
-     * For circles, this is the offset at which the circle was hit. If the hit accuracy is 10000, it means the circle was tapped too late ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/HitCircle.java#L298-L306)).
-     *
-     * For sliders, this is the offset at which the slider head was hit. For
-     * sliderbreaks, the accuracy would be `Math.floor(<hit window 50>ms) + 13ms` ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821)).
-     *
-     * For spinners, this is the total amount at which the spinner was spinned:
-     * ```js
-     * const rotations = Math.floor(data.accuracy / 4);
-     * ```
-     * The remainder of the division denotes the hit result of the spinner:
-     * - `HitResult.great`: 3
-     * - `HitResult.good`: 2
-     * - `HitResult.meh`: 1
-     * - `HitResult.miss`: 0
-     */
-    accuracy;
-    /**
-     * The tickset of the hitobject.
-     *
-     * This is used to determine whether or not a slider event (tick, repeat, and end) is hit based on the order they appear.
-     */
-    tickset;
-    /**
-     * The bitwise hit result of the hitobject.
-     */
-    result;
     constructor(values) {
         this.accuracy = values.accuracy;
         this.tickset = values.tickset;
@@ -2423,6 +2714,7 @@ class ReplayObjectData {
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
+exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;