@rian8337/osu-droid-replay-analyzer 2.2.0 → 2.3.0

package/dist/index.js

@@ -29,1972 +29,1972 @@ function _interopNamespace(e) {
 
 var javaDeserialization__namespace = /*#__PURE__*/_interopNamespace(javaDeserialization);
 
-/**
- * Represents a cursor's occurrence.
- */
-class CursorOccurrence {
-    /**
-     * The time of this occurrence.
-     */
-    time;
-    /**
-     * The position of the occurrence.
-     */
-    position;
-    /**
-     * The movement ID of the occurrence.
-     */
-    id;
-    constructor(time, x, y, id) {
-        this.time = time;
-        this.position = new osuBase.Vector2(x, y);
-        this.id = id;
-    }
+/**
+ * Represents a cursor's occurrence.
+ */
+class CursorOccurrence {
+    /**
+     * The time of this occurrence.
+     */
+    time;
+    /**
+     * The position of the occurrence.
+     */
+    position;
+    /**
+     * The movement ID of the occurrence.
+     */
+    id;
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
 }
 
-/**
- * Represents a cursor instance in an osu!droid replay.
- *
- * Stores cursor movement data in the form of `CursorOccurrence`s.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class CursorData {
-    /**
-     * The occurrences of this cursor instance.
-     */
-    occurrences = [];
-    constructor(values) {
-        for (let i = 0; i < values.size; ++i) {
-            this.occurrences.push(new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]));
-        }
-    }
+/**
+ * Represents a cursor instance in an osu!droid replay.
+ *
+ * Stores cursor movement data in the form of `CursorOccurrence`s.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class CursorData {
+    /**
+     * The occurrences of this cursor instance.
+     */
+    occurrences = [];
+    constructor(values) {
+        for (let i = 0; i < values.size; ++i) {
+            this.occurrences.push(new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]));
+        }
+    }
 }
 
-/**
- * The result of a hit in an osu!droid replay.
- */
-exports.hitResult = void 0;
-(function (hitResult) {
-    /**
-     * Miss (0).
-     */
-    hitResult[hitResult["RESULT_0"] = 1] = "RESULT_0";
-    /**
-     * Meh (50).
-     */
-    hitResult[hitResult["RESULT_50"] = 2] = "RESULT_50";
-    /**
-     * Great (100).
-     */
-    hitResult[hitResult["RESULT_100"] = 3] = "RESULT_100";
-    /**
-     * Good (300).
-     */
-    hitResult[hitResult["RESULT_300"] = 4] = "RESULT_300";
+/**
+ * The result of a hit in an osu!droid replay.
+ */
+exports.hitResult = void 0;
+(function (hitResult) {
+    /**
+     * Miss (0).
+     */
+    hitResult[hitResult["RESULT_0"] = 1] = "RESULT_0";
+    /**
+     * Meh (50).
+     */
+    hitResult[hitResult["RESULT_50"] = 2] = "RESULT_50";
+    /**
+     * Great (100).
+     */
+    hitResult[hitResult["RESULT_100"] = 3] = "RESULT_100";
+    /**
+     * Good (300).
+     */
+    hitResult[hitResult["RESULT_300"] = 4] = "RESULT_300";
 })(exports.hitResult || (exports.hitResult = {}));
 
-/**
- * Movement type of a cursor in an osu!droid replay.
- */
-exports.movementType = void 0;
-(function (movementType) {
-    movementType[movementType["DOWN"] = 0] = "DOWN";
-    movementType[movementType["MOVE"] = 1] = "MOVE";
-    movementType[movementType["UP"] = 2] = "UP";
+/**
+ * Movement type of a cursor in an osu!droid replay.
+ */
+exports.movementType = void 0;
+(function (movementType) {
+    movementType[movementType["DOWN"] = 0] = "DOWN";
+    movementType[movementType["MOVE"] = 1] = "MOVE";
+    movementType[movementType["UP"] = 2] = "UP";
 })(exports.movementType || (exports.movementType = {}));
 
-/**
- * Represents a replay data in an osu!droid replay.
- *
- * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class ReplayData {
-    replayVersion;
-    folderName;
-    fileName;
-    hash;
-    time;
-    hit300k;
-    hit100k;
-    score;
-    maxCombo;
-    accuracy;
-    isFullCombo;
-    playerName;
-    rawMods;
-    rank;
-    convertedMods;
-    cursorMovement;
-    hitObjectData;
-    speedModification;
-    forcedAR;
-    constructor(values) {
-        this.replayVersion = values.replayVersion;
-        this.folderName = values.folderName;
-        this.fileName = values.fileName;
-        this.hash = values.hash;
-        this.time = new Date(values.time || 0);
-        this.hit300k = values.hit300k || 0;
-        this.hit100k = values.hit100k || 0;
-        this.score = values.score || 0;
-        this.maxCombo = values.maxCombo || 0;
-        this.accuracy = values.accuracy || new osuBase.Accuracy({});
-        this.isFullCombo = values.isFullCombo || false;
-        this.playerName = values.playerName || "";
-        this.rawMods = values.rawMods || "";
-        this.rank = values.rank || "";
-        this.convertedMods = values.convertedMods || [];
-        this.cursorMovement = values.cursorMovement;
-        this.hitObjectData = values.hitObjectData;
-        this.speedModification = values.speedModification || 1;
-        this.forcedAR = values.forcedAR;
-    }
+/**
+ * Represents a replay data in an osu!droid replay.
+ *
+ * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayData {
+    replayVersion;
+    folderName;
+    fileName;
+    hash;
+    time;
+    hit300k;
+    hit100k;
+    score;
+    maxCombo;
+    accuracy;
+    isFullCombo;
+    playerName;
+    rawMods;
+    rank;
+    convertedMods;
+    cursorMovement;
+    hitObjectData;
+    speedModification;
+    forcedAR;
+    constructor(values) {
+        this.replayVersion = values.replayVersion;
+        this.folderName = values.folderName;
+        this.fileName = values.fileName;
+        this.hash = values.hash;
+        this.time = new Date(values.time || 0);
+        this.hit300k = values.hit300k || 0;
+        this.hit100k = values.hit100k || 0;
+        this.score = values.score || 0;
+        this.maxCombo = values.maxCombo || 0;
+        this.accuracy = values.accuracy || new osuBase.Accuracy({});
+        this.isFullCombo = values.isFullCombo || false;
+        this.playerName = values.playerName || "";
+        this.rawMods = values.rawMods || "";
+        this.rank = values.rank || "";
+        this.convertedMods = values.convertedMods || [];
+        this.cursorMovement = values.cursorMovement;
+        this.hitObjectData = values.hitObjectData;
+        this.speedModification = values.speedModification || 1;
+        this.forcedAR = values.forcedAR;
+    }
 }
 
-/**
- * A beatmap section generator that generates beatmap section based on aim/speed strain.
- */
-class BeatmapSectionGenerator {
-    /**
-     * Generates `BeatmapSection`s for the specified beatmap.
-     *
-     * @param calculator The difficulty calculator to generate for.
-     * @param minSectionObjectCount The maximum delta time allowed between two beatmap sections.
-     * Increasing this number decreases the amount of beatmap sections in general. Note that this value does not account for the speed multiplier of
-     * the play, similar to the way replay object data is stored.
-     * @param maxSectionDeltaTime The minimum object count required to make a beatmap section. Increasing this number decreases the amount of beatmap sections.
-     */
-    static generateSections(calculator, minSectionObjectCount, maxSectionDeltaTime) {
-        const beatmapSections = [];
-        let firstObjectIndex = 0;
-        for (let i = 0; i < calculator.objects.length - 1; ++i) {
-            const current = calculator.objects[i];
-            const next = calculator.objects[i + 1];
-            const realDeltaTime = next.object.startTime - current.object.endTime;
-            if (realDeltaTime >= maxSectionDeltaTime) {
-                // Ignore sections that don't meet object count requirement.
-                if (i - firstObjectIndex < minSectionObjectCount) {
-                    firstObjectIndex = i + 1;
-                    continue;
-                }
-                beatmapSections.push({
-                    firstObjectIndex,
-                    lastObjectIndex: i,
-                });
-                firstObjectIndex = i + 1;
-            }
-        }
-        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-        if (calculator.objects.length - firstObjectIndex >
-            minSectionObjectCount) {
-            beatmapSections.push({
-                firstObjectIndex,
-                lastObjectIndex: calculator.objects.length - 1,
-            });
-        }
-        return beatmapSections;
-    }
+/**
+ * A beatmap section generator that generates beatmap section based on aim/speed strain.
+ */
+class BeatmapSectionGenerator {
+    /**
+     * Generates `BeatmapSection`s for the specified beatmap.
+     *
+     * @param calculator The difficulty calculator to generate for.
+     * @param minSectionObjectCount The maximum delta time allowed between two beatmap sections.
+     * Increasing this number decreases the amount of beatmap sections in general. Note that this value does not account for the speed multiplier of
+     * the play, similar to the way replay object data is stored.
+     * @param maxSectionDeltaTime The minimum object count required to make a beatmap section. Increasing this number decreases the amount of beatmap sections.
+     */
+    static generateSections(calculator, minSectionObjectCount, maxSectionDeltaTime) {
+        const beatmapSections = [];
+        let firstObjectIndex = 0;
+        for (let i = 0; i < calculator.objects.length - 1; ++i) {
+            const current = calculator.objects[i];
+            const next = calculator.objects[i + 1];
+            const realDeltaTime = next.object.startTime - current.object.endTime;
+            if (realDeltaTime >= maxSectionDeltaTime) {
+                // Ignore sections that don't meet object count requirement.
+                if (i - firstObjectIndex < minSectionObjectCount) {
+                    firstObjectIndex = i + 1;
+                    continue;
+                }
+                beatmapSections.push({
+                    firstObjectIndex,
+                    lastObjectIndex: i,
+                });
+                firstObjectIndex = i + 1;
+            }
+        }
+        // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
+        if (calculator.objects.length - firstObjectIndex >
+            minSectionObjectCount) {
+            beatmapSections.push({
+                firstObjectIndex,
+                lastObjectIndex: calculator.objects.length - 1,
+            });
+        }
+        return beatmapSections;
+    }
 }
 
-/**
- * Represents a section of a beatmap.
- */
-class BeatmapSection {
-    /**
-     * The index of the first `DifficultyHitObject` of this beatmap section.
-     */
-    firstObjectIndex;
-    /**
-     * The index of the last `DifficultyHitObject` of this beatmap section.
-     */
-    lastObjectIndex;
-    /**
-     * @param firstObjectIndex The index of the first `DifficultyHitObject` of this beatmap section.
-     * @param lastObjectIndex The index of the last `DifficultyHitObject` of this beatmap section.
-     */
-    constructor(firstObjectIndex, lastObjectIndex) {
-        this.firstObjectIndex = firstObjectIndex;
-        this.lastObjectIndex = lastObjectIndex;
-    }
+/**
+ * Represents a section of a beatmap.
+ */
+class BeatmapSection {
+    /**
+     * The index of the first `DifficultyHitObject` of this beatmap section.
+     */
+    firstObjectIndex;
+    /**
+     * The index of the last `DifficultyHitObject` of this beatmap section.
+     */
+    lastObjectIndex;
+    /**
+     * @param firstObjectIndex The index of the first `DifficultyHitObject` of this beatmap section.
+     * @param lastObjectIndex The index of the last `DifficultyHitObject` of this beatmap section.
+     */
+    constructor(firstObjectIndex, lastObjectIndex) {
+        this.firstObjectIndex = firstObjectIndex;
+        this.lastObjectIndex = lastObjectIndex;
+    }
 }
 
-/**
- * A section of a beatmap with extra information used for detecting three-finger usage.
- */
-class ThreeFingerBeatmapSection extends BeatmapSection {
-    /**
-     * Whether or not this beatmap section is dragged.
-     */
-    isDragged;
-    /**
-     * The index of the cursor that is dragging this section.
-     */
-    dragFingerIndex;
-    constructor(values) {
-        super(values.firstObjectIndex, values.lastObjectIndex);
-        this.isDragged = values.isDragged;
-        this.dragFingerIndex = values.dragFingerIndex;
-    }
+/**
+ * A section of a beatmap with extra information used for detecting three-finger usage.
+ */
+class ThreeFingerBeatmapSection extends BeatmapSection {
+    /**
+     * Whether or not this beatmap section is dragged.
+     */
+    isDragged;
+    /**
+     * The index of the cursor that is dragging this section.
+     */
+    dragFingerIndex;
+    constructor(values) {
+        super(values.firstObjectIndex, values.lastObjectIndex);
+        this.isDragged = values.isDragged;
+        this.dragFingerIndex = values.dragFingerIndex;
+    }
 }
 
-/**
- * Utility to check whether or not a beatmap is three-fingered.
- */
-class ThreeFingerChecker {
-    /**
-     * The difficulty calculator that is being analyzed.
-     */
-    calculator;
-    /**
-     * The data of the replay.
-     */
-    data;
-    /**
-     * The strain threshold to start detecting for 3-fingered section.
-     *
-     * Increasing this number will result in less sections being flagged.
-     */
-    static strainThreshold = 175;
-    /**
-     * 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;
-    /**
-     * The maximum delta time allowed between two beatmap sections.
-     *
-     * Increasing this number decreases the amount of beatmap sections in general.
-     *
-     * Note that this value does not account for the speed multiplier of
-     * the play, similar to the way replay object data is stored.
-     */
-    maxSectionDeltaTime = 2000;
-    /**
-     * The minimum object count required to make a beatmap section.
-     *
-     * Increasing this number decreases the amount of beatmap sections.
-     */
-    minSectionObjectCount = 5;
-    /**
-     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
-     */
-    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 data array that only contains `movementType.DOWN` movement ID occurrences.
-     */
-    downCursorInstances = [];
-    /**
-     * Nerf factors from all sections that were three-fingered.
-     */
-    nerfFactors = [];
-    /**
-     * @param calculator The difficulty calculator to analyze.
-     * @param data The data of the replay.
-     */
-    constructor(calculator, data) {
-        this.calculator = calculator;
-        this.data = data;
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
-                .map((v) => v.droidString)
-                .includes(m.droidString)),
-        }).calculate();
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-        const strainNotes = calculator.objects.filter(
-        //@ts-expect-error: No overloads match, but this is fine.
-        (v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
-        this.strainNoteCount = strainNotes.length;
-    }
-    /**
-     * Checks whether a beatmap is eligible to be detected for 3-finger.
-     */
-    static isEligibleToDetect(map) {
-        return map.objects.some((v) => v.originalTapStrain >= this.strainThreshold);
-    }
-    /**
-     * 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.strainNoteCount === 0) {
-            return { is3Finger: false, penalty: 1 };
-        }
-        this.getAccurateBreakPoints();
-        this.filterCursorInstances();
-        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
-            .length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
-        this.getBeatmapSections();
-        this.detectDragPlay();
-        this.getDetailedBeatmapSections();
-        this.preventAccidentalTaps();
-        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
-            .length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
-        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
-     * start of the hitobject before it and do not end right at the first hitobject after it.
-     */
-    getAccurateBreakPoints() {
-        const objects = this.calculator.objects;
-        const objectData = this.data.hitObjectData;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
-        for (const breakPoint of this.calculator.beatmap.events.breaks) {
-            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.object.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
-            let timeBefore = objects[beforeIndex].object.endTime;
-            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
-            switch (objectData[beforeIndex].result) {
-                case exports.hitResult.RESULT_300:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    beforeIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-            timeBefore += beforeIndexHitWindowLength;
-            const afterIndex = beforeIndex + 1;
-            let timeAfter = objects[afterIndex].object.startTime;
-            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
-            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
-            switch (objectData[afterIndex].result) {
-                case exports.hitResult.RESULT_300:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    afterIndexHitWindowLength =
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-            timeAfter += afterIndexHitWindowLength;
-            this.breakPointAccurateTimes.push({
-                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 objects = this.calculator.objects;
-        const objectData = this.data.hitObjectData;
-        const firstObjectResult = objectData[0].result;
-        const lastObjectResult = objectData.at(-1).result;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
-        // For sliders, automatically set hit window length to be as lenient as possible.
-        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
-        if (objects[0].object instanceof osuBase.Circle) {
-            switch (firstObjectResult) {
-                case exports.hitResult.RESULT_300:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    firstObjectHitWindow =
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        // For sliders, automatically set hit window length to be as lenient as possible.
-        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
-        if (objects.at(-1).object instanceof osuBase.Circle) {
-            switch (lastObjectResult) {
-                case exports.hitResult.RESULT_300:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    lastObjectHitWindow =
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        // 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].object.startTime - firstObjectHitWindow;
-        const lastObjectHitTime = objects.at(-1).object.startTime + lastObjectHitWindow;
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const cursorInstance = this.data.cursorMovement[i];
-            const newCursorData = new CursorData({
-                size: 0,
-                time: [],
-                x: [],
-                y: [],
-                id: [],
-            });
-            for (let j = 0; j < cursorInstance.occurrences.length; ++j) {
-                if (cursorInstance.occurrences[j].id !== exports.movementType.DOWN) {
-                    continue;
-                }
-                const time = cursorInstance.occurrences[j].time;
-                if (time < firstObjectHitTime || time > lastObjectHitTime) {
-                    continue;
-                }
-                if (this.breakPointAccurateTimes.some((v) => time >= v.startTime && time <= v.endTime)) {
-                    continue;
-                }
-                newCursorData.occurrences.push(new CursorOccurrence(time, cursorInstance.occurrences[j].position.x, cursorInstance.occurrences[j].position.y, cursorInstance.occurrences[j].id));
-            }
-            this.downCursorInstances.push(newCursorData);
-        }
-    }
-    /**
-     * Divides the beatmap into sections, which will be used to
-     * detect dragged sections and improve detection speed.
-     */
-    getBeatmapSections() {
-        const beatmapSections = BeatmapSectionGenerator.generateSections(this.calculator, this.minSectionObjectCount, this.maxSectionDeltaTime);
-        for (const beatmapSection of beatmapSections) {
-            this.beatmapSections.push(new ThreeFingerBeatmapSection({
-                firstObjectIndex: beatmapSection.firstObjectIndex,
-                lastObjectIndex: beatmapSection.lastObjectIndex,
-                isDragged: false,
-                dragFingerIndex: -1,
-            }));
-        }
-    }
-    /**
-     * Checks whether or not each beatmap sections is dragged.
-     */
-    detectDragPlay() {
-        for (let i = 0; i < this.beatmapSections.length; ++i) {
-            const dragIndex = this.checkDrag(this.beatmapSections[i]);
-            this.beatmapSections[i].dragFingerIndex = dragIndex;
-            this.beatmapSections[i].isDragged = dragIndex !== -1;
-        }
-    }
-    /**
-     * 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.
-     */
-    checkDrag(section) {
-        const objects = this.calculator.objects;
-        const objectData = this.data.hitObjectData;
-        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
-        const firstObject = objects[section.firstObjectIndex];
-        const lastObject = objects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.object.startTime;
-        if (firstObject.object instanceof osuBase.Circle) {
-            switch (objectData[section.firstObjectIndex].result) {
-                case exports.hitResult.RESULT_300:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    firstObjectMinHitTime -=
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        else {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(isPrecise);
-        }
-        let lastObjectMaxHitTime = lastObject.object.startTime;
-        if (lastObject.object instanceof osuBase.Circle) {
-            switch (objectData[section.lastObjectIndex].result) {
-                case exports.hitResult.RESULT_300:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-                default:
-                    lastObjectMaxHitTime +=
-                        this.hitWindow.hitWindowFor50(isPrecise);
-            }
-        }
-        else {
-            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(isPrecise);
-        }
-        // Since there may be more than 1 cursor instance index,
-        // we check which cursor instance follows hitobjects all over.
-        const cursorIndexes = [];
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.occurrences.length === 0) {
-                continue;
-            }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.occurrences.filter((v) => v.time >= firstObjectMinHitTime &&
-                v.time <= lastObjectMaxHitTime).length === 0) {
-                continue;
-            }
-            // If this cursor instance doesn't move, it's not the cursor instance we want.
-            if (c.occurrences.filter((v) => v.id === exports.movementType.MOVE)
-                .length === 0) {
-                continue;
-            }
-            cursorIndexes.push(i);
-        }
-        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
-    }
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
-    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        let objectIndex = sectionObjects.findIndex((v, i) => !(v.object instanceof osuBase.Spinner) &&
-            sectionReplayObjectData[i].result !== exports.hitResult.RESULT_0);
-        if (objectIndex === -1) {
-            return -1;
-        }
-        while (cursorIndexes.length > 0) {
-            if (objectIndex === sectionObjects.length) {
-                break;
-            }
-            const o = sectionObjects[objectIndex];
-            const s = sectionReplayObjectData[objectIndex];
-            ++objectIndex;
-            if (s.result === exports.hitResult.RESULT_0) {
-                continue;
-            }
-            // Get the cursor instance that is closest to the object's hit time.
-            for (let j = 0; j < cursorIndexes.length; ++j) {
-                const c = this.data.cursorMovement[cursorIndexes[j]];
-                // Cursor instances aren't always recorded at all times,
-                // therefore the game emulates the movement between
-                // movementType.MOVE cursors.
-                const hitTime = o.object.startTime + s.accuracy;
-                const nextHitIndex = c.occurrences.findIndex((v) => v.time >= hitTime);
-                const hitIndex = nextHitIndex - 1;
-                if (hitIndex <= -1) {
-                    cursorIndexes[j] = -1;
-                    continue;
-                }
-                if (c.occurrences[hitIndex].id === exports.movementType.UP) {
-                    cursorIndexes[j] = -1;
-                    continue;
-                }
-                const cursorPosition = new osuBase.Vector2(c.occurrences[hitIndex].position.x, c.occurrences[hitIndex].position.y);
-                let isInObject = false;
-                if (c.occurrences[nextHitIndex].id === exports.movementType.MOVE ||
-                    c.occurrences[hitIndex].id === exports.movementType.MOVE) {
-                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
-                    // This minimizes rounding error.
-                    for (let mSecPassed = c.occurrences[hitIndex].time; mSecPassed <= c.occurrences[nextHitIndex].time; ++mSecPassed) {
-                        const t = (mSecPassed - c.occurrences[nextHitIndex].time) /
-                            (c.occurrences[hitIndex].time -
-                                c.occurrences[nextHitIndex].time);
-                        cursorPosition.x = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.x, c.occurrences[nextHitIndex].position.x, t);
-                        cursorPosition.y = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.y, c.occurrences[nextHitIndex].position.y, t);
-                        if (o.object.stackedPosition.getDistance(cursorPosition) <= o.object.radius) {
-                            isInObject = true;
-                            break;
-                        }
-                    }
-                }
-                else {
-                    isInObject =
-                        o.object.stackedPosition.getDistance(cursorPosition) <=
-                            o.object.radius;
-                }
-                if (!isInObject) {
-                    cursorIndexes[j] = -1;
-                }
-            }
-            cursorIndexes = cursorIndexes.filter((v) => v !== -1);
-        }
-        return cursorIndexes.shift() ?? -1;
-    }
-    /**
-     * Redivides the beatmap into sections.
-     *
-     * The result will be used to detect for three-fingered
-     * sections.
-     */
-    getDetailedBeatmapSections() {
-        const objects = this.calculator.objects;
-        const newBeatmapSections = [];
-        for (const beatmapSection of this.beatmapSections) {
-            let inSpeedSection = false;
-            let newFirstObjectIndex = beatmapSection.firstObjectIndex;
-            for (let i = beatmapSection.firstObjectIndex; i <= beatmapSection.lastObjectIndex; ++i) {
-                if (!inSpeedSection &&
-                    objects[i].originalTapStrain >=
-                        ThreeFingerChecker.strainThreshold) {
-                    inSpeedSection = true;
-                    newFirstObjectIndex = i;
-                    continue;
-                }
-                if (inSpeedSection &&
-                    objects[i].originalTapStrain <
-                        ThreeFingerChecker.strainThreshold) {
-                    inSpeedSection = false;
-                    newBeatmapSections.push({
-                        firstObjectIndex: newFirstObjectIndex,
-                        lastObjectIndex: i,
-                        isDragged: beatmapSection.isDragged,
-                        dragFingerIndex: beatmapSection.dragFingerIndex,
-                    });
-                }
-            }
-            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
-            if (inSpeedSection) {
-                newBeatmapSections.push({
-                    firstObjectIndex: newFirstObjectIndex,
-                    lastObjectIndex: beatmapSection.lastObjectIndex,
-                    isDragged: beatmapSection.isDragged,
-                    dragFingerIndex: beatmapSection.dragFingerIndex,
-                });
-            }
-        }
-        this.beatmapSections.length = 0;
-        this.beatmapSections.push(...newBeatmapSections);
-    }
-    /**
-     * 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.occurrences.length > 0).length;
-        if (filledCursorAmount <= 3) {
-            return;
-        }
-        const objects = this.calculator.objects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.occurrences.length, 0);
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (filledCursorAmount <= 3) {
-                break;
-            }
-            const cursorInstance = this.downCursorInstances[i];
-            // Use an estimation for accidental tap threshold.
-            if (cursorInstance.occurrences.length <=
-                Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstance.occurrences.length / totalCursorAmount <
-                    this.threeFingerRatioThreshold * 2) {
-                --filledCursorAmount;
-                cursorInstance.occurrences.length = 0;
-            }
-            this.downCursorInstances[i] = cursorInstance;
-        }
-    }
-    /**
-     * Creates nerf factors by scanning through objects.
-     *
-     * This check will ignore all objects with speed strain below `strainThreshold`.
-     */
-    calculateNerfFactors() {
-        const objects = this.calculator.objects;
-        const objectData = this.data.hitObjectData;
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
-        // 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].object.startTime +
-                (objectData[beatmapSection.firstObjectIndex].result !==
-                    exports.hitResult.RESULT_0
-                    ? objectData[beatmapSection.firstObjectIndex].accuracy
-                    : -this.hitWindow.hitWindowFor50(isPrecise));
-            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
-                (objectData[beatmapSection.lastObjectIndex].result !==
-                    exports.hitResult.RESULT_0
-                    ? objectData[beatmapSection.lastObjectIndex].accuracy
-                    : this.hitWindow.hitWindowFor50(isPrecise));
-            // Filter cursor instances during section.
-            this.downCursorInstances.forEach((c) => {
-                const i = c.occurrences.findIndex((t) => t.time >= startTime);
-                if (i !== -1) {
-                    c.occurrences = c.occurrences.slice(i);
-                }
-            });
-            const cursorAmounts = [];
-            const cursorVectorTimes = [];
-            for (let i = 0; i < this.downCursorInstances.length; ++i) {
-                // Do not include drag cursor instance.
-                if (i === dragIndex) {
-                    continue;
-                }
-                const cursorData = this.downCursorInstances[i];
-                let amount = 0;
-                for (let j = 0; j < cursorData.occurrences.length; ++j) {
-                    if (cursorData.occurrences[j].time >= startTime &&
-                        cursorData.occurrences[j].time <= endTime) {
-                        ++amount;
-                        cursorVectorTimes.push({
-                            vector: new osuBase.Vector2(cursorData.occurrences[j].position.x, cursorData.occurrences[j].position.y),
-                            time: cursorData.occurrences[j].time,
-                        });
-                    }
-                }
-                cursorAmounts.push(amount);
-            }
-            // This index will be used to detect if a section is 3-fingered.
-            // If the section is dragged, the dragged instance will be ignored,
-            // hence why the index is 1 less than nondragged section.
-            const fingerSplitIndex = dragIndex !== -1 ? 2 : 3;
-            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
-            // to check if the section is 3-fingered.
-            const threeFingerRatio = cursorAmounts
-                .slice(fingerSplitIndex)
-                .reduce((acc, value) => acc + value, 0) /
-                cursorAmounts
-                    .slice(0, fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0);
-            const similarPresses = [];
-            for (const cursorVectorTime of cursorVectorTimes) {
-                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
-                    this.cursorDistancingDistanceThreshold);
-                if (pressIndex !== -1) {
-                    if (cursorVectorTime.time -
-                        similarPresses[pressIndex].lastTime >=
-                        this.cursorDistancingTimeThreshold) {
-                        similarPresses.splice(pressIndex, 1);
-                        similarPresses.push({
-                            vector: cursorVectorTime.vector,
-                            count: 1,
-                            lastTime: cursorVectorTime.time,
-                        });
-                        continue;
-                    }
-                    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 > 3) ||
-                validPresses.length > 0) {
-                // Strain factor
-                const objectCount = beatmapSection.lastObjectIndex -
-                    beatmapSection.firstObjectIndex +
-                    1;
-                const strainFactor = Math.pow(objects
-                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
-                    .reduce((acc, value) => acc +
-                    value.originalTapStrain /
-                        ThreeFingerChecker.strainThreshold, 0), 0.75);
-                // We can ignore the first 3 (2 for drag) filled cursor instances
-                // since they are guaranteed not 3 finger.
-                const threeFingerCursorAmounts = cursorAmounts
-                    .slice(fingerSplitIndex)
-                    .filter((amount) => amount > 0);
-                // Finger factor applies more penalty if more fingers were used.
-                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
-                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) * value * objectCount) /
-                            this.strainNoteCount, 0.9), 1)
-                    : Math.pow(validPresses.reduce((acc, value, index) => acc +
-                        Math.pow(((index + 1) *
-                            (value.count /
-                                (this
-                                    .cursorDistancingCountThreshold *
-                                    2)) *
-                            objectCount) /
-                            this.strainNoteCount, 0.2), 1), 0.2);
-                // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
-                this.nerfFactors.push({
-                    strainFactor: Math.max(1, strainFactor),
-                    fingerFactor,
-                    lengthFactor,
-                });
-            }
-        }
-    }
-    /**
-     * Calculates the final penalty.
-     */
-    calculateFinalPenalty() {
-        return (1 +
-            this.nerfFactors.reduce((a, n) => a +
-                0.015 *
-                    Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 0));
-    }
+/**
+ * Utility to check whether or not a beatmap is three-fingered.
+ */
+class ThreeFingerChecker {
+    /**
+     * The difficulty calculator that is being analyzed.
+     */
+    calculator;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The strain threshold to start detecting for 3-fingered section.
+     *
+     * Increasing this number will result in less sections being flagged.
+     */
+    static strainThreshold = 175;
+    /**
+     * 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;
+    /**
+     * The maximum delta time allowed between two beatmap sections.
+     *
+     * Increasing this number decreases the amount of beatmap sections in general.
+     *
+     * Note that this value does not account for the speed multiplier of
+     * the play, similar to the way replay object data is stored.
+     */
+    maxSectionDeltaTime = 2000;
+    /**
+     * The minimum object count required to make a beatmap section.
+     *
+     * Increasing this number decreases the amount of beatmap sections.
+     */
+    minSectionObjectCount = 5;
+    /**
+     * The sections of the beatmap that was cut based on `maxSectionDeltaTime` and `minSectionObjectCount`.
+     */
+    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 data array that only contains `movementType.DOWN` movement ID occurrences.
+     */
+    downCursorInstances = [];
+    /**
+     * Nerf factors from all sections that were three-fingered.
+     */
+    nerfFactors = [];
+    /**
+     * @param calculator The difficulty calculator to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(calculator, data) {
+        this.calculator = calculator;
+        this.data = data;
+        const stats = new osuBase.MapStats({
+            od: this.calculator.beatmap.difficulty.od,
+            mods: this.calculator.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
+                .map((v) => v.droidString)
+                .includes(m.droidString)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        const strainNotes = calculator.objects.filter(
+        //@ts-expect-error: No overloads match, but this is fine.
+        (v) => v.originalTapStrain >= ThreeFingerChecker.strainThreshold);
+        this.strainNoteCount = strainNotes.length;
+    }
+    /**
+     * Checks whether a beatmap is eligible to be detected for 3-finger.
+     */
+    static isEligibleToDetect(map) {
+        return map.objects.some((v) => v.originalTapStrain >= this.strainThreshold);
+    }
+    /**
+     * 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.strainNoteCount === 0) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getAccurateBreakPoints();
+        this.filterCursorInstances();
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getBeatmapSections();
+        this.detectDragPlay();
+        this.getDetailedBeatmapSections();
+        this.preventAccidentalTaps();
+        if (this.downCursorInstances.filter((v) => v.occurrences.length > 0)
+            .length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        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
+     * start of the hitobject before it and do not end right at the first hitobject after it.
+     */
+    getAccurateBreakPoints() {
+        const objects = this.calculator.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        for (const breakPoint of this.calculator.beatmap.events.breaks) {
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.object.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            let timeBefore = objects[beforeIndex].object.endTime;
+            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
+            let beforeIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            switch (objectData[beforeIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+            timeBefore += beforeIndexHitWindowLength;
+            const afterIndex = beforeIndex + 1;
+            let timeAfter = objects[afterIndex].object.startTime;
+            // For sliders and spinners, automatically set hit window length to be as lenient as possible.
+            let afterIndexHitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+            switch (objectData[afterIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+            timeAfter += afterIndexHitWindowLength;
+            this.breakPointAccurateTimes.push({
+                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 objects = this.calculator.objects;
+        const objectData = this.data.hitObjectData;
+        const firstObjectResult = objectData[0].result;
+        const lastObjectResult = objectData.at(-1).result;
+        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let firstObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
+        if (objects[0].object instanceof osuBase.Circle) {
+            switch (firstObjectResult) {
+                case exports.hitResult.RESULT_300:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        // For sliders, automatically set hit window length to be as lenient as possible.
+        let lastObjectHitWindow = this.hitWindow.hitWindowFor50(isPrecise);
+        if (objects.at(-1).object instanceof osuBase.Circle) {
+            switch (lastObjectResult) {
+                case exports.hitResult.RESULT_300:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        // 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].object.startTime - firstObjectHitWindow;
+        const lastObjectHitTime = objects.at(-1).object.startTime + lastObjectHitWindow;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorInstance = this.data.cursorMovement[i];
+            const newCursorData = new CursorData({
+                size: 0,
+                time: [],
+                x: [],
+                y: [],
+                id: [],
+            });
+            for (let j = 0; j < cursorInstance.occurrences.length; ++j) {
+                if (cursorInstance.occurrences[j].id !== exports.movementType.DOWN) {
+                    continue;
+                }
+                const time = cursorInstance.occurrences[j].time;
+                if (time < firstObjectHitTime || time > lastObjectHitTime) {
+                    continue;
+                }
+                if (this.breakPointAccurateTimes.some((v) => time >= v.startTime && time <= v.endTime)) {
+                    continue;
+                }
+                newCursorData.occurrences.push(new CursorOccurrence(time, cursorInstance.occurrences[j].position.x, cursorInstance.occurrences[j].position.y, cursorInstance.occurrences[j].id));
+            }
+            this.downCursorInstances.push(newCursorData);
+        }
+    }
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    getBeatmapSections() {
+        const beatmapSections = BeatmapSectionGenerator.generateSections(this.calculator, this.minSectionObjectCount, this.maxSectionDeltaTime);
+        for (const beatmapSection of beatmapSections) {
+            this.beatmapSections.push(new ThreeFingerBeatmapSection({
+                firstObjectIndex: beatmapSection.firstObjectIndex,
+                lastObjectIndex: beatmapSection.lastObjectIndex,
+                isDragged: false,
+                dragFingerIndex: -1,
+            }));
+        }
+    }
+    /**
+     * Checks whether or not each beatmap sections is dragged.
+     */
+    detectDragPlay() {
+        for (let i = 0; i < this.beatmapSections.length; ++i) {
+            const dragIndex = this.checkDrag(this.beatmapSections[i]);
+            this.beatmapSections[i].dragFingerIndex = dragIndex;
+            this.beatmapSections[i].isDragged = dragIndex !== -1;
+        }
+    }
+    /**
+     * 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.
+     */
+    checkDrag(section) {
+        const objects = this.calculator.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const firstObject = objects[section.firstObjectIndex];
+        const lastObject = objects[section.lastObjectIndex];
+        let firstObjectMinHitTime = firstObject.object.startTime;
+        if (firstObject.object instanceof osuBase.Circle) {
+            switch (objectData[section.firstObjectIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        else {
+            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(isPrecise);
+        }
+        let lastObjectMaxHitTime = lastObject.object.startTime;
+        if (lastObject.object instanceof osuBase.Circle) {
+            switch (objectData[section.lastObjectIndex].result) {
+                case exports.hitResult.RESULT_300:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+                default:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor50(isPrecise);
+            }
+        }
+        else {
+            lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(isPrecise);
+        }
+        // Since there may be more than 1 cursor instance index,
+        // we check which cursor instance follows hitobjects all over.
+        const cursorIndexes = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrences.length === 0) {
+                continue;
+            }
+            // Do not include cursors that don't have an occurence in this section
+            // this speeds up checking process.
+            if (c.occurrences.filter((v) => v.time >= firstObjectMinHitTime &&
+                v.time <= lastObjectMaxHitTime).length === 0) {
+                continue;
+            }
+            // If this cursor instance doesn't move, it's not the cursor instance we want.
+            if (c.occurrences.filter((v) => v.id === exports.movementType.MOVE)
+                .length === 0) {
+                continue;
+            }
+            cursorIndexes.push(i);
+        }
+        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
+    }
+    /**
+     * Finds the drag index of the section.
+     *
+     * @param sectionObjects The objects in the section.
+     * @param sectionReplayObjectData The hitobject data of all objects in the section.
+     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
+     */
+    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
+        let objectIndex = sectionObjects.findIndex((v, i) => !(v.object instanceof osuBase.Spinner) &&
+            sectionReplayObjectData[i].result !== exports.hitResult.RESULT_0);
+        if (objectIndex === -1) {
+            return -1;
+        }
+        while (cursorIndexes.length > 0) {
+            if (objectIndex === sectionObjects.length) {
+                break;
+            }
+            const o = sectionObjects[objectIndex];
+            const s = sectionReplayObjectData[objectIndex];
+            ++objectIndex;
+            if (s.result === exports.hitResult.RESULT_0) {
+                continue;
+            }
+            // Get the cursor instance that is closest to the object's hit time.
+            for (let j = 0; j < cursorIndexes.length; ++j) {
+                const c = this.data.cursorMovement[cursorIndexes[j]];
+                // Cursor instances aren't always recorded at all times,
+                // therefore the game emulates the movement between
+                // movementType.MOVE cursors.
+                const hitTime = o.object.startTime + s.accuracy;
+                const nextHitIndex = c.occurrences.findIndex((v) => v.time >= hitTime);
+                const hitIndex = nextHitIndex - 1;
+                if (hitIndex <= -1) {
+                    cursorIndexes[j] = -1;
+                    continue;
+                }
+                if (c.occurrences[hitIndex].id === exports.movementType.UP) {
+                    cursorIndexes[j] = -1;
+                    continue;
+                }
+                const cursorPosition = new osuBase.Vector2(c.occurrences[hitIndex].position.x, c.occurrences[hitIndex].position.y);
+                let isInObject = false;
+                if (c.occurrences[nextHitIndex].id === exports.movementType.MOVE ||
+                    c.occurrences[hitIndex].id === exports.movementType.MOVE) {
+                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
+                    // This minimizes rounding error.
+                    for (let mSecPassed = c.occurrences[hitIndex].time; mSecPassed <= c.occurrences[nextHitIndex].time; ++mSecPassed) {
+                        const t = (mSecPassed - c.occurrences[nextHitIndex].time) /
+                            (c.occurrences[hitIndex].time -
+                                c.occurrences[nextHitIndex].time);
+                        cursorPosition.x = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.x, c.occurrences[nextHitIndex].position.x, t);
+                        cursorPosition.y = osuBase.Interpolation.lerp(c.occurrences[hitIndex].position.y, c.occurrences[nextHitIndex].position.y, t);
+                        if (o.object.stackedPosition.getDistance(cursorPosition) <= o.object.radius) {
+                            isInObject = true;
+                            break;
+                        }
+                    }
+                }
+                else {
+                    isInObject =
+                        o.object.stackedPosition.getDistance(cursorPosition) <=
+                            o.object.radius;
+                }
+                if (!isInObject) {
+                    cursorIndexes[j] = -1;
+                }
+            }
+            cursorIndexes = cursorIndexes.filter((v) => v !== -1);
+        }
+        return cursorIndexes.shift() ?? -1;
+    }
+    /**
+     * Redivides the beatmap into sections.
+     *
+     * The result will be used to detect for three-fingered
+     * sections.
+     */
+    getDetailedBeatmapSections() {
+        const objects = this.calculator.objects;
+        const newBeatmapSections = [];
+        for (const beatmapSection of this.beatmapSections) {
+            let inSpeedSection = false;
+            let newFirstObjectIndex = beatmapSection.firstObjectIndex;
+            for (let i = beatmapSection.firstObjectIndex; i <= beatmapSection.lastObjectIndex; ++i) {
+                if (!inSpeedSection &&
+                    objects[i].originalTapStrain >=
+                        ThreeFingerChecker.strainThreshold) {
+                    inSpeedSection = true;
+                    newFirstObjectIndex = i;
+                    continue;
+                }
+                if (inSpeedSection &&
+                    objects[i].originalTapStrain <
+                        ThreeFingerChecker.strainThreshold) {
+                    inSpeedSection = false;
+                    newBeatmapSections.push({
+                        firstObjectIndex: newFirstObjectIndex,
+                        lastObjectIndex: i,
+                        isDragged: beatmapSection.isDragged,
+                        dragFingerIndex: beatmapSection.dragFingerIndex,
+                    });
+                }
+            }
+            // Don't forget to manually add the last beatmap section, which would otherwise be ignored.
+            if (inSpeedSection) {
+                newBeatmapSections.push({
+                    firstObjectIndex: newFirstObjectIndex,
+                    lastObjectIndex: beatmapSection.lastObjectIndex,
+                    isDragged: beatmapSection.isDragged,
+                    dragFingerIndex: beatmapSection.dragFingerIndex,
+                });
+            }
+        }
+        this.beatmapSections.length = 0;
+        this.beatmapSections.push(...newBeatmapSections);
+    }
+    /**
+     * 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.occurrences.length > 0).length;
+        if (filledCursorAmount <= 3) {
+            return;
+        }
+        const objects = this.calculator.objects;
+        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.occurrences.length, 0);
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (filledCursorAmount <= 3) {
+                break;
+            }
+            const cursorInstance = this.downCursorInstances[i];
+            // Use an estimation for accidental tap threshold.
+            if (cursorInstance.occurrences.length <=
+                Math.ceil(objects.length / this.accidentalTapThreshold) &&
+                cursorInstance.occurrences.length / totalCursorAmount <
+                    this.threeFingerRatioThreshold * 2) {
+                --filledCursorAmount;
+                cursorInstance.occurrences.length = 0;
+            }
+            this.downCursorInstances[i] = cursorInstance;
+        }
+    }
+    /**
+     * Creates nerf factors by scanning through objects.
+     *
+     * This check will ignore all objects with speed strain below `strainThreshold`.
+     */
+    calculateNerfFactors() {
+        const objects = this.calculator.objects;
+        const objectData = this.data.hitObjectData;
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        // 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].object.startTime +
+                (objectData[beatmapSection.firstObjectIndex].result !==
+                    exports.hitResult.RESULT_0
+                    ? objectData[beatmapSection.firstObjectIndex].accuracy
+                    : -this.hitWindow.hitWindowFor50(isPrecise));
+            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
+                (objectData[beatmapSection.lastObjectIndex].result !==
+                    exports.hitResult.RESULT_0
+                    ? objectData[beatmapSection.lastObjectIndex].accuracy
+                    : this.hitWindow.hitWindowFor50(isPrecise));
+            // Filter cursor instances during section.
+            this.downCursorInstances.forEach((c) => {
+                const i = c.occurrences.findIndex((t) => t.time >= startTime);
+                if (i !== -1) {
+                    c.occurrences = c.occurrences.slice(i);
+                }
+            });
+            const cursorAmounts = [];
+            const cursorVectorTimes = [];
+            for (let i = 0; i < this.downCursorInstances.length; ++i) {
+                // Do not include drag cursor instance.
+                if (i === dragIndex) {
+                    continue;
+                }
+                const cursorData = this.downCursorInstances[i];
+                let amount = 0;
+                for (let j = 0; j < cursorData.occurrences.length; ++j) {
+                    if (cursorData.occurrences[j].time >= startTime &&
+                        cursorData.occurrences[j].time <= endTime) {
+                        ++amount;
+                        cursorVectorTimes.push({
+                            vector: new osuBase.Vector2(cursorData.occurrences[j].position.x, cursorData.occurrences[j].position.y),
+                            time: cursorData.occurrences[j].time,
+                        });
+                    }
+                }
+                cursorAmounts.push(amount);
+            }
+            // This index will be used to detect if a section is 3-fingered.
+            // If the section is dragged, the dragged instance will be ignored,
+            // hence why the index is 1 less than nondragged section.
+            const fingerSplitIndex = dragIndex !== -1 ? 2 : 3;
+            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
+            // to check if the section is 3-fingered.
+            const threeFingerRatio = cursorAmounts
+                .slice(fingerSplitIndex)
+                .reduce((acc, value) => acc + value, 0) /
+                cursorAmounts
+                    .slice(0, fingerSplitIndex)
+                    .reduce((acc, value) => acc + value, 0);
+            const similarPresses = [];
+            for (const cursorVectorTime of cursorVectorTimes) {
+                const pressIndex = similarPresses.findIndex((v) => v.vector.getDistance(cursorVectorTime.vector) <=
+                    this.cursorDistancingDistanceThreshold);
+                if (pressIndex !== -1) {
+                    if (cursorVectorTime.time -
+                        similarPresses[pressIndex].lastTime >=
+                        this.cursorDistancingTimeThreshold) {
+                        similarPresses.splice(pressIndex, 1);
+                        similarPresses.push({
+                            vector: cursorVectorTime.vector,
+                            count: 1,
+                            lastTime: cursorVectorTime.time,
+                        });
+                        continue;
+                    }
+                    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 > 3) ||
+                validPresses.length > 0) {
+                // Strain factor
+                const objectCount = beatmapSection.lastObjectIndex -
+                    beatmapSection.firstObjectIndex +
+                    1;
+                const strainFactor = Math.pow(objects
+                    .slice(beatmapSection.firstObjectIndex, beatmapSection.lastObjectIndex)
+                    .reduce((acc, value) => acc +
+                    value.originalTapStrain /
+                        ThreeFingerChecker.strainThreshold, 0), 0.75);
+                // We can ignore the first 3 (2 for drag) filled cursor instances
+                // since they are guaranteed not 3 finger.
+                const threeFingerCursorAmounts = cursorAmounts
+                    .slice(fingerSplitIndex)
+                    .filter((amount) => amount > 0);
+                // Finger factor applies more penalty if more fingers were used.
+                const fingerFactor = threeFingerRatio > this.threeFingerRatioThreshold
+                    ? threeFingerCursorAmounts.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) * value * objectCount) /
+                            this.strainNoteCount, 0.9), 1)
+                    : Math.pow(validPresses.reduce((acc, value, index) => acc +
+                        Math.pow(((index + 1) *
+                            (value.count /
+                                (this
+                                    .cursorDistancingCountThreshold *
+                                    2)) *
+                            objectCount) /
+                            this.strainNoteCount, 0.2), 1), 0.2);
+                // Length factor applies more penalty if there are more 3-fingered object.
+                const lengthFactor = 1 + Math.pow(objectCount / this.strainNoteCount, 1.2);
+                this.nerfFactors.push({
+                    strainFactor: Math.max(1, strainFactor),
+                    fingerFactor,
+                    lengthFactor,
+                });
+            }
+        }
+    }
+    /**
+     * Calculates the final penalty.
+     */
+    calculateFinalPenalty() {
+        return (1 +
+            this.nerfFactors.reduce((a, n) => a +
+                0.015 *
+                    Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 0));
+    }
 }
 
-/**
- * Contains information about which cursor index hits a hitobject.
- */
-class IndexedHitObject {
-    /**
-     * The accepted index of the cursor that hits the hitobject.
-     */
-    acceptedCursorIndex;
-    /**
-     * The actual index of the cursor that hits the hitobject.
-     */
-    actualCursorIndex;
-    /**
-     * The occurrence index of the cursor that hits the hitobject.
-     */
-    occurrenceIndex;
-    /**
-     * If this is a slider, whether the slider was cheesed.
-     */
-    sliderCheesed = false;
-    /**
-     * The underlying difficulty hitobject.
-     */
-    object;
-    /**
-     * @param object The underlying difficulty hitobject.
-     * @param acceptedCursorIndex The accepted index of the cursor that hits the hitobject.
-     * @param actualCursorIndex The actual index of the cursor that hits the hitobject.
-     * @param occurrenceIndex The occurrence index of the cursor that hits the hitobject.
-     */
-    constructor(object, acceptedCursorIndex, actualCursorIndex, occurrenceIndex) {
-        this.object = object;
-        this.acceptedCursorIndex = acceptedCursorIndex;
-        this.actualCursorIndex = actualCursorIndex;
-        this.occurrenceIndex = occurrenceIndex;
-    }
+/**
+ * Contains information about which cursor index hits a hitobject.
+ */
+class IndexedHitObject {
+    /**
+     * The accepted index of the cursor that hits the hitobject.
+     */
+    acceptedCursorIndex;
+    /**
+     * The actual index of the cursor that hits the hitobject.
+     */
+    actualCursorIndex;
+    /**
+     * The occurrence index of the cursor that hits the hitobject.
+     */
+    occurrenceIndex;
+    /**
+     * If this is a slider, whether the slider was cheesed.
+     */
+    sliderCheesed = false;
+    /**
+     * The underlying difficulty hitobject.
+     */
+    object;
+    /**
+     * @param object The underlying difficulty hitobject.
+     * @param acceptedCursorIndex The accepted index of the cursor that hits the hitobject.
+     * @param actualCursorIndex The actual index of the cursor that hits the hitobject.
+     * @param occurrenceIndex The occurrence index of the cursor that hits the hitobject.
+     */
+    constructor(object, acceptedCursorIndex, actualCursorIndex, occurrenceIndex) {
+        this.object = object;
+        this.acceptedCursorIndex = acceptedCursorIndex;
+        this.actualCursorIndex = actualCursorIndex;
+        this.occurrenceIndex = occurrenceIndex;
+    }
 }
 
-/**
- * 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 minimum count of a cursor index occurrence to be valid.
-     *
-     * This is used to prevent excessive penalty by splitting the beatmap into
-     * those that do not worth any strain.
-     */
-    minCursorIndexCount = 5;
-    /**
-     * @param calculator The difficulty calculator to analyze.
-     * @param data The data of the replay.
-     */
-    constructor(calculator, data) {
-        this.calculator = calculator;
-        this.data = data;
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
-                .map((v) => v.droidString)
-                .includes(m.droidString)),
-        }).calculate();
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-    }
-    /**
-     * Checks if a beatmap is two-handed.
-     */
-    check() {
-        if (this.data.cursorMovement.filter((v) => v.occurrences.length > 0)
-            .length <= 1) {
-            return { is2Hand: false, cursorIndexes: [] };
-        }
-        this.indexHitObjects();
-        this.applyPenalty();
-        const indexes = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
-        for (const object of this.indexedHitObjects) {
-            ++indexes[object.acceptedCursorIndex];
-        }
-        return {
-            is2Hand: indexes.filter((v) => v > 0).length !== 1,
-            cursorIndexes: this.indexedHitObjects.map((v) => v.acceptedCursorIndex),
-        };
-    }
-    /**
-     * Converts hitobjects into indexed hit objects.
-     */
-    indexHitObjects() {
-        const hitWindowOffset = this.getHitWindowOffset();
-        const indexes = [];
-        for (let i = 0; i < this.calculator.objects.length; ++i) {
-            const indexedHitObject = this.getIndexedHitObject(i, hitWindowOffset);
-            indexes.push(indexedHitObject.acceptedCursorIndex);
-            this.indexedHitObjects.push(indexedHitObject);
-        }
-        const indexCounts = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
-        for (const index of indexes) {
-            if (index === -1) {
-                continue;
-            }
-            ++indexCounts[index];
-        }
-        const mainCursorIndex = indexCounts.length > 0
-            ? indexCounts.indexOf(Math.max(...indexCounts))
-            : 0;
-        const ignoredCursorIndexes = [];
-        for (let i = 0; i < indexCounts.length; ++i) {
-            if (indexCounts[i] < this.minCursorIndexCount &&
-                i !== mainCursorIndex) {
-                ignoredCursorIndexes.push(i);
-            }
-        }
-        // Add cursor presses that don't fulfill minimum cursor
-        // count to the farthest cursor index that isn't 0.
-        let defaultMinCursorCountIndex = this.data.cursorMovement.length - 1;
-        for (; defaultMinCursorCountIndex > 0; --defaultMinCursorCountIndex) {
-            if (indexCounts[defaultMinCursorCountIndex] >=
-                this.minCursorIndexCount &&
-                !ignoredCursorIndexes.includes(defaultMinCursorCountIndex)) {
-                break;
-            }
-        }
-        this.indexedHitObjects.forEach((indexedHitObject, i) => {
-            if (indexedHitObject.acceptedCursorIndex === -1 ||
-                indexedHitObject.actualCursorIndex === -1) {
-                indexedHitObject.acceptedCursorIndex = mainCursorIndex;
-                indexedHitObject.actualCursorIndex = mainCursorIndex;
-            }
-            if (ignoredCursorIndexes.includes(indexedHitObject.acceptedCursorIndex)) {
-                indexedHitObject.acceptedCursorIndex =
-                    defaultMinCursorCountIndex;
-            }
-            // For sliders, we need to consider two cases. The first case is when the player doesn't drag
-            // the slider. The second case is when the player drags the slider.
-            if (indexedHitObject.object.object instanceof osuBase.Slider) {
-                indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i], hitWindowOffset);
-            }
-        });
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.acceptedCursorIndex === i).length);
-        }
-    }
-    /**
-     * Gets the hit window offset to be applied to `getCursorIndex`.
-     */
-    getHitWindowOffset() {
-        const deltaTimes = [];
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            for (let j = 0; j < c.occurrences.length; ++j) {
-                if (c.occurrences[j].time <
-                    this.calculator.beatmap.hitObjects.objects[0].startTime -
-                        this.hitWindow.hitWindowFor50()) {
-                    continue;
-                }
-                if (c.occurrences[j].id !== exports.movementType.MOVE) {
-                    continue;
-                }
-                const deltaTime = c.occurrences[j]?.time - c.occurrences[j - 1]?.time || 0;
-                if (deltaTime > 0) {
-                    deltaTimes.push(deltaTime);
-                }
-            }
-        }
-        return Math.min(...deltaTimes);
-    }
-    /**
-     * Gets the cursor index that hits the given object.
-     *
-     * @param index The index of the object to check.
-     * @param hitWindowOffset The offset for hit window to compensate for replay hit inaccuracies.
-     * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
-     */
-    getIndexedHitObject(index, hitWindowOffset) {
-        const object = this.calculator.objects[index];
-        const data = this.data.hitObjectData[index];
-        if (object.object instanceof osuBase.Spinner ||
-            data.result === exports.hitResult.RESULT_0) {
-            return new IndexedHitObject(object, -1, -1, -1);
-        }
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
-        // For sliders, automatically set hit window to be as lenient as possible.
-        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
-        if (!(object.object instanceof osuBase.Slider)) {
-            switch (data.result) {
-                case exports.hitResult.RESULT_300:
-                    hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
-                    break;
-                case exports.hitResult.RESULT_100:
-                    hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
-                    break;
-            }
-        }
-        const startTime = object.object.startTime;
-        const hitTime = startTime + data.accuracy;
-        const minimumHitTime = startTime - hitWindowLength - hitWindowOffset;
-        const maximumHitTime = startTime + hitWindowLength + hitWindowOffset;
-        const cursorInformations = [];
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.occurrences.length === 0) {
-                continue;
-            }
-            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.occurrences.findIndex((v) => v.time >= minimumHitTime), 1, c.occurrences.length - 1) - 1;
-            let hitTimeAfterIndex = c.occurrences.findIndex(
-            // There is a special case for sliders where the time leniency in droid is a lot bigger compared to PC.
-            // To prevent slider end time from ending earlier than hit window leniency, we use the maximum value between both.
-            (v) => v.time >= Math.max(object.object.endTime, maximumHitTime));
-            if (hitTimeAfterIndex === -1) {
-                // Maximum hit time or object end time may be out of bounds for every presses.
-                // We set the index to the latest cursor occurrence if that happens.
-                hitTimeAfterIndex = c.occurrences.length;
-            }
-            --hitTimeAfterIndex;
-            // Sometimes a `movementType.UP` instance occurs at the same time as a `movementType.MOVE`
-            // or a cursor is recorded twice in one time, therefore this check is required.
-            while (c.occurrences[hitTimeBeforeIndex]?.time ===
-                c.occurrences[hitTimeBeforeIndex - 1]?.time &&
-                hitTimeBeforeIndex > 0) {
-                --hitTimeBeforeIndex;
-            }
-            // We track the cursor movement along those indexes.
-            // Current cursor position is in `hitTimeBeforeIndex`.
-            let distance = Number.POSITIVE_INFINITY;
-            let j = hitTimeBeforeIndex;
-            for (j; j <= hitTimeAfterIndex; ++j) {
-                const occurrence = c.occurrences[j];
-                const nextOccurrence = c.occurrences[j + 1];
-                const cursorPosition = occurrence.position;
-                if (occurrence.time < minimumHitTime &&
-                    nextOccurrence?.id !== exports.movementType.MOVE) {
-                    continue;
-                }
-                if (occurrence.time > hitTime + hitWindowOffset) {
-                    // Set distance to minimum just for the last.
-                    if (occurrence.id !== exports.movementType.UP) {
-                        distance = Math.min(distance, object.object.stackedPosition.getDistance(cursorPosition));
-                    }
-                    break;
-                }
-                if (occurrence.id === exports.movementType.UP) {
-                    continue;
-                }
-                distance =
-                    object.object.stackedPosition.getDistance(cursorPosition);
-                if (nextOccurrence?.id === exports.movementType.MOVE &&
-                    occurrence.time !== nextOccurrence.time &&
-                    !occurrence.position.equals(nextOccurrence.position)) {
-                    // If next cursor is a `move` instance and it doesn't go out of time
-                    // range, we interpolate cursor position between two occurrences.
-                    const nextPosition = nextOccurrence.position;
-                    const displacement = nextPosition.subtract(cursorPosition);
-                    for (let mSecPassed = Math.max(minimumHitTime, occurrence.time); mSecPassed <= Math.min(hitTime, nextOccurrence.time); ++mSecPassed) {
-                        const progress = (mSecPassed - occurrence.time) /
-                            (nextOccurrence.time - occurrence.time);
-                        distance = object.object.stackedPosition.getDistance(cursorPosition.add(displacement.scale(progress)));
-                    }
-                }
-            }
-            if (distance > object.object.radius) {
-                continue;
-            }
-            // The case for a one-handed object is that there will be a slight movement in the cursor towards
-            // the next object in fast patterns. We should not be worried about slow patterns as they will only
-            // make a minimal difference and aim strain threshold should filter them out.
-            // In order to verify if the player does that, we check if the movement towards the next
-            // object is sufficient enough to be two-handed. This is done by checking if the movement
-            // from the current object to the next object and the movement from the current object
-            // to the significant move cursor occurrence produces an angle that is acute enough.
-            // let isAngleFulfilled: boolean = false;
-            // Aside of angles, we need to consider if the player dragged from the previous object to the current object.
-            let isDragged = false;
-            // Get the latest down or movement cursor occurrence.
-            while (c.occurrences[j]?.id === exports.movementType.UP &&
-                j > hitTimeBeforeIndex) {
-                --j;
-            }
-            if (object.object instanceof osuBase.Circle) {
-                // For circles, we only need to consider the actual press on the circle.
-                // Therefore, we need to get the latest down cursor occurrence instead.
-                while (c.occurrences[j]?.id !== exports.movementType.DOWN &&
-                    j > hitTimeBeforeIndex) {
-                    --j;
-                }
-            }
-            // Theoretically there can only be 1 up occurrence, but this is a
-            // consideration if the user manually adds cursor occurrences.
-            if (c.occurrences[j]?.id === exports.movementType.UP) {
-                ++j;
-            }
-            // Some move instances move in the exact same place. Not sure why, most likely
-            // because the position is recorded as int in the game and the movement is too small to
-            // convert into +1 or -1.
-            // let nextSignificantOccurrenceIndex: number = j + 1;
-            // while (
-            //     c.occurrences[j] &&
-            //     c.occurrences[nextSignificantOccurrenceIndex] &&
-            //     c.occurrences[j].position.equals(
-            //         c.occurrences[nextSignificantOccurrenceIndex].position
-            //     )
-            // ) {
-            //     ++nextSignificantOccurrenceIndex;
-            // }
-            // const nextSignificantOccurrence: CursorOccurrence =
-            //     c.occurrences[nextSignificantOccurrenceIndex];
-            // const next: DifficultyHitObject | RebalanceDifficultyHitObject =
-            //     this.map.objects[index + 1];
-            // Angle detection.
-            /* if (nextSignificantOccurrence?.id === movementType.MOVE && next) {
-                // Get the object's actual end position.
-                let actualEndPosition: Vector2 =
-                    object.object.stackedEndPosition;
-
-                if (
-                    object.object instanceof Slider &&
-                    object.object.lazyEndPosition
-                ) {
-                    // For sliders, we take the closest distance between the lazy end position
-                    // and stacked end position towards the next significant cursor occurrence.
-                    // This assumes that the player takes the simpler movement.
-                    const lazyEndDistance: number =
-                        object.object.lazyEndPosition.getDistance(
-                            nextSignificantOccurrence.position
-                        );
-                    const actualEndDistance: number =
-                        object.object.stackedEndPosition.getDistance(
-                            nextSignificantOccurrence.position
-                        );
-
-                    if (lazyEndDistance < actualEndDistance) {
-                        actualEndPosition = object.object.lazyEndPosition;
-                    }
-                }
-
-                // Get the movement vector towards the next cursor occurrence by subtracting
-                // the next cursor occurrence with the object's position.
-                const movementVec: Vector2 =
-                    nextSignificantOccurrence.position.subtract(
-                        actualEndPosition
-                    );
-
-                const currentToNext: Vector2 =
-                    next.object.stackedPosition.subtract(actualEndPosition);
-
-                const dot: number = currentToNext.dot(movementVec);
-                const det: number =
-                    currentToNext.x * movementVec.y -
-                    currentToNext.y * movementVec.x;
-
-                const movementToNextAngle: number = Math.abs(
-                    Math.atan2(det, dot)
-                );
-
-                isAngleFulfilled = movementToNextAngle < Math.PI / 6;
-            } */
-            // Dragging detection.
-            let dragTimeThreshold = 0;
-            const prev = this.calculator.objects[index - 1];
-            if (prev) {
-                // The previous object might be a slider, so we need to get
-                // the hit data of it to get an accurate time threshold.
-                const prevData = this.data.hitObjectData[index - 1];
-                dragTimeThreshold = prev.object.startTime;
-                if (!(prev.object instanceof osuBase.Spinner)) {
-                    dragTimeThreshold += prevData.accuracy;
-                }
-                if (prev.object instanceof osuBase.Slider) {
-                    dragTimeThreshold = Math.max(dragTimeThreshold, prev.object.endTime);
-                }
-            }
-            let occurrenceStartIndex = hitTimeAfterIndex;
-            while (c.occurrences[occurrenceStartIndex]?.time >=
-                dragTimeThreshold &&
-                occurrenceStartIndex > 0) {
-                --occurrenceStartIndex;
-            }
-            // The above loop will make the start index before or right when
-            // the previous object was hit or ended, but we want the index after it.
-            ++occurrenceStartIndex;
-            const dragOccurrences = c.occurrences.slice(occurrenceStartIndex, hitTimeAfterIndex);
-            isDragged =
-                dragOccurrences.length > 0 &&
-                    // We only care when the cursor approaches the current object. It doesn't
-                    // matter whether the previous object was pressed or dragged.
-                    dragOccurrences
-                        .at(-1)
-                        .position.getDistance(object.object.stackedPosition) <=
-                        object.object.radius &&
-                    dragOccurrences.every((v) => v.id === exports.movementType.MOVE);
-            cursorInformations.push({
-                // If the angle is fulfilled or the player dragged,
-                // we set the cursor index to the main cursor index.
-                acceptedCursorIndex: /* isAngleFulfilled ||  */ isDragged
-                    ? -1
-                    : i,
-                actualCursorIndex: i,
-                occurrenceIndex: j,
-                distanceDiff: distance,
-            });
-        }
-        // Cursors have been filtered to see which of them is inside the object.
-        // Now we look at which cursor is closest to the center of the object.
-        const minDistanceDiff = Math.min(...cursorInformations.map((v) => v.distanceDiff));
-        const acceptedCursorInformation = cursorInformations.find((c) => c.distanceDiff === minDistanceDiff);
-        return new IndexedHitObject(object, acceptedCursorInformation?.acceptedCursorIndex ?? -1, acceptedCursorInformation?.actualCursorIndex ?? -1, acceptedCursorInformation?.occurrenceIndex ?? -1);
-    }
-    /**
-     * Checks whether a slider was cheesed.
-     *
-     * This is done by checking if a cursor follows a slider all the way to its end position.
-     *
-     * @param indexedHitObject The indexed slider.
-     * @param hitData The hit data of the slider.
-     * @param actualCursorIndex The actual cursor index that hit the slider.
-     * @param hitWindowOffset The offset that was calculated by `getHitWindowOffset()`
-     * @returns Whether the slider was cheesed.
-     */
-    checkSliderCheesing(indexedHitObject, hitData, hitWindowOffset) {
-        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
-            hitData.result === exports.hitResult.RESULT_0) {
-            return false;
-        }
-        let cursorLoopIndex = Math.max(0, indexedHitObject.occurrenceIndex);
-        const c = this.data.cursorMovement[indexedHitObject.actualCursorIndex];
-        const acceptableRadius = indexedHitObject.object.object.radius * 2.4;
-        for (let i = 1; i < indexedHitObject.object.object.nestedHitObjects.length; ++i) {
-            const tickWasHit = hitData.tickset[i - 1];
-            if (!tickWasHit) {
-                continue;
-            }
-            const object = indexedHitObject.object.object.nestedHitObjects[i];
-            let j = cursorLoopIndex;
-            let cursorHitTick = false;
-            for (j; j < c.occurrences.length; ++j) {
-                if (c.occurrences[j].time <
-                    object.startTime - hitWindowOffset) {
-                    continue;
-                }
-                if (c.occurrences[j].time >
-                    object.startTime + hitWindowOffset) {
-                    break;
-                }
-                if (c.occurrences[j].position.getDistance(object.stackedPosition) <= acceptableRadius) {
-                    cursorHitTick = true;
-                    break;
-                }
-            }
-            if (!cursorHitTick) {
-                return true;
-            }
-            cursorLoopIndex = j;
-        }
-        return false;
-    }
-    /**
-     * Applies penalty to the original star rating instance.
-     */
-    applyPenalty() {
-        const beatmaps = new Array(this.data.cursorMovement.length);
-        this.indexedHitObjects.forEach((o) => {
-            if (!beatmaps[o.acceptedCursorIndex]) {
-                const map = osuBase.Utils.deepCopy(this.calculator.beatmap);
-                map.hitObjects.clear();
-                beatmaps[o.acceptedCursorIndex] = map;
-            }
-            beatmaps[o.acceptedCursorIndex].hitObjects.add(o.object.object);
-        });
-        // Preserve some values that aren't reasonable for them to be changed.
-        const preservedValues = this.calculator.objects.map((v) => {
-            return {
-                noteDensity: v.noteDensity,
-                overlappingFactor: v.overlappingFactor,
-                rhythmStrain: v.rhythmStrain,
-                rhythmMultiplier: v.rhythmMultiplier,
-            };
-        });
-        this.calculator.objects.length = 0;
-        beatmaps.forEach((beatmap) => {
-            if (!beatmap) {
-                return;
-            }
-            const difficultyCalculator = Object.assign(osuBase.Utils.deepCopy(this.calculator), { beatmap: beatmap });
-            difficultyCalculator.generateDifficultyHitObjects();
-            difficultyCalculator.objects[0].deltaTime =
-                difficultyCalculator.objects[0].startTime -
-                    this.indexedHitObjects[0].object.startTime;
-            difficultyCalculator.objects[0].strainTime = Math.max(25, difficultyCalculator.objects[0].deltaTime);
-            (this.calculator.objects).push(...difficultyCalculator.objects);
-        });
-        this.calculator.objects.sort((a, b) => a.startTime - b.startTime);
-        // Reassign preserved values before calculating.
-        for (let i = 0; i < this.calculator.objects.length; ++i) {
-            const diffObject = this.calculator.objects[i];
-            const indexedHitObject = this.indexedHitObjects[i];
-            const preservedValue = preservedValues[i];
-            diffObject.noteDensity = preservedValue.noteDensity;
-            diffObject.overlappingFactor = preservedValue.overlappingFactor;
-            diffObject.rhythmStrain = preservedValue.rhythmStrain;
-            diffObject.rhythmMultiplier = preservedValue.rhythmMultiplier;
-            // Set slider travel distance to 0 if the slider was cheesed.
-            if (indexedHitObject.sliderCheesed) {
-                diffObject.travelDistance = 0;
-            }
-        }
-        // Do not include rhythm skill.
-        this.calculator.calculateAim();
-        this.calculator.calculateTap();
-        this.calculator.calculateFlashlight();
-        this.calculator.calculateVisual();
-        this.calculator.calculateTotal();
-    }
+/**
+ * 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 minimum count of a cursor index occurrence to be valid.
+     *
+     * This is used to prevent excessive penalty by splitting the beatmap into
+     * those that do not worth any strain.
+     */
+    minCursorIndexCount = 5;
+    /**
+     * @param calculator The difficulty calculator to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(calculator, data) {
+        this.calculator = calculator;
+        this.data = data;
+        const stats = new osuBase.MapStats({
+            od: this.calculator.beatmap.difficulty.od,
+            mods: this.calculator.mods.filter((m) => !osuBase.ModUtil.speedChangingMods
+                .map((v) => v.droidString)
+                .includes(m.droidString)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+    }
+    /**
+     * Checks if a beatmap is two-handed.
+     */
+    check() {
+        if (this.data.cursorMovement.filter((v) => v.occurrences.length > 0)
+            .length <= 1) {
+            return { is2Hand: false, cursorIndexes: [] };
+        }
+        this.indexHitObjects();
+        this.applyPenalty();
+        const indexes = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        for (const object of this.indexedHitObjects) {
+            ++indexes[object.acceptedCursorIndex];
+        }
+        return {
+            is2Hand: indexes.filter((v) => v > 0).length !== 1,
+            cursorIndexes: this.indexedHitObjects.map((v) => v.acceptedCursorIndex),
+        };
+    }
+    /**
+     * Converts hitobjects into indexed hit objects.
+     */
+    indexHitObjects() {
+        const hitWindowOffset = this.getHitWindowOffset();
+        const indexes = [];
+        for (let i = 0; i < this.calculator.objects.length; ++i) {
+            const indexedHitObject = this.getIndexedHitObject(i, hitWindowOffset);
+            indexes.push(indexedHitObject.acceptedCursorIndex);
+            this.indexedHitObjects.push(indexedHitObject);
+        }
+        const indexCounts = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        for (const index of indexes) {
+            if (index === -1) {
+                continue;
+            }
+            ++indexCounts[index];
+        }
+        const mainCursorIndex = indexCounts.length > 0
+            ? indexCounts.indexOf(Math.max(...indexCounts))
+            : 0;
+        const ignoredCursorIndexes = [];
+        for (let i = 0; i < indexCounts.length; ++i) {
+            if (indexCounts[i] < this.minCursorIndexCount &&
+                i !== mainCursorIndex) {
+                ignoredCursorIndexes.push(i);
+            }
+        }
+        // Add cursor presses that don't fulfill minimum cursor
+        // count to the farthest cursor index that isn't 0.
+        let defaultMinCursorCountIndex = this.data.cursorMovement.length - 1;
+        for (; defaultMinCursorCountIndex > 0; --defaultMinCursorCountIndex) {
+            if (indexCounts[defaultMinCursorCountIndex] >=
+                this.minCursorIndexCount &&
+                !ignoredCursorIndexes.includes(defaultMinCursorCountIndex)) {
+                break;
+            }
+        }
+        this.indexedHitObjects.forEach((indexedHitObject, i) => {
+            if (indexedHitObject.acceptedCursorIndex === -1 ||
+                indexedHitObject.actualCursorIndex === -1) {
+                indexedHitObject.acceptedCursorIndex = mainCursorIndex;
+                indexedHitObject.actualCursorIndex = mainCursorIndex;
+            }
+            if (ignoredCursorIndexes.includes(indexedHitObject.acceptedCursorIndex)) {
+                indexedHitObject.acceptedCursorIndex =
+                    defaultMinCursorCountIndex;
+            }
+            // For sliders, we need to consider two cases. The first case is when the player doesn't drag
+            // the slider. The second case is when the player drags the slider.
+            if (indexedHitObject.object.object instanceof osuBase.Slider) {
+                indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i], hitWindowOffset);
+            }
+        });
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            console.log("Index", i, "count:", this.indexedHitObjects.filter((v) => v.acceptedCursorIndex === i).length);
+        }
+    }
+    /**
+     * Gets the hit window offset to be applied to `getCursorIndex`.
+     */
+    getHitWindowOffset() {
+        const deltaTimes = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            for (let j = 0; j < c.occurrences.length; ++j) {
+                if (c.occurrences[j].time <
+                    this.calculator.beatmap.hitObjects.objects[0].startTime -
+                        this.hitWindow.hitWindowFor50()) {
+                    continue;
+                }
+                if (c.occurrences[j].id !== exports.movementType.MOVE) {
+                    continue;
+                }
+                const deltaTime = c.occurrences[j]?.time - c.occurrences[j - 1]?.time || 0;
+                if (deltaTime > 0) {
+                    deltaTimes.push(deltaTime);
+                }
+            }
+        }
+        return Math.min(...deltaTimes);
+    }
+    /**
+     * Gets the cursor index that hits the given object.
+     *
+     * @param index The index of the object to check.
+     * @param hitWindowOffset The offset for hit window to compensate for replay hit inaccuracies.
+     * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
+     */
+    getIndexedHitObject(index, hitWindowOffset) {
+        const object = this.calculator.objects[index];
+        const data = this.data.hitObjectData[index];
+        if (object.object instanceof osuBase.Spinner ||
+            data.result === exports.hitResult.RESULT_0) {
+            return new IndexedHitObject(object, -1, -1, -1);
+        }
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        // For sliders, automatically set hit window to be as lenient as possible.
+        let hitWindowLength = this.hitWindow.hitWindowFor50(isPrecise);
+        if (!(object.object instanceof osuBase.Slider)) {
+            switch (data.result) {
+                case exports.hitResult.RESULT_300:
+                    hitWindowLength = this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.hitResult.RESULT_100:
+                    hitWindowLength = this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+            }
+        }
+        const startTime = object.object.startTime;
+        const hitTime = startTime + data.accuracy;
+        const minimumHitTime = startTime - hitWindowLength - hitWindowOffset;
+        const maximumHitTime = startTime + hitWindowLength + hitWindowOffset;
+        const cursorInformations = [];
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const c = this.data.cursorMovement[i];
+            if (c.occurrences.length === 0) {
+                continue;
+            }
+            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.occurrences.findIndex((v) => v.time >= minimumHitTime), 1, c.occurrences.length - 1) - 1;
+            let hitTimeAfterIndex = c.occurrences.findIndex(
+            // There is a special case for sliders where the time leniency in droid is a lot bigger compared to PC.
+            // To prevent slider end time from ending earlier than hit window leniency, we use the maximum value between both.
+            (v) => v.time >= Math.max(object.object.endTime, maximumHitTime));
+            if (hitTimeAfterIndex === -1) {
+                // Maximum hit time or object end time may be out of bounds for every presses.
+                // We set the index to the latest cursor occurrence if that happens.
+                hitTimeAfterIndex = c.occurrences.length;
+            }
+            --hitTimeAfterIndex;
+            // Sometimes a `movementType.UP` instance occurs at the same time as a `movementType.MOVE`
+            // or a cursor is recorded twice in one time, therefore this check is required.
+            while (c.occurrences[hitTimeBeforeIndex]?.time ===
+                c.occurrences[hitTimeBeforeIndex - 1]?.time &&
+                hitTimeBeforeIndex > 0) {
+                --hitTimeBeforeIndex;
+            }
+            // We track the cursor movement along those indexes.
+            // Current cursor position is in `hitTimeBeforeIndex`.
+            let distance = Number.POSITIVE_INFINITY;
+            let j = hitTimeBeforeIndex;
+            for (j; j <= hitTimeAfterIndex; ++j) {
+                const occurrence = c.occurrences[j];
+                const nextOccurrence = c.occurrences[j + 1];
+                const cursorPosition = occurrence.position;
+                if (occurrence.time < minimumHitTime &&
+                    nextOccurrence?.id !== exports.movementType.MOVE) {
+                    continue;
+                }
+                if (occurrence.time > hitTime + hitWindowOffset) {
+                    // Set distance to minimum just for the last.
+                    if (occurrence.id !== exports.movementType.UP) {
+                        distance = Math.min(distance, object.object.stackedPosition.getDistance(cursorPosition));
+                    }
+                    break;
+                }
+                if (occurrence.id === exports.movementType.UP) {
+                    continue;
+                }
+                distance =
+                    object.object.stackedPosition.getDistance(cursorPosition);
+                if (nextOccurrence?.id === exports.movementType.MOVE &&
+                    occurrence.time !== nextOccurrence.time &&
+                    !occurrence.position.equals(nextOccurrence.position)) {
+                    // If next cursor is a `move` instance and it doesn't go out of time
+                    // range, we interpolate cursor position between two occurrences.
+                    const nextPosition = nextOccurrence.position;
+                    const displacement = nextPosition.subtract(cursorPosition);
+                    for (let mSecPassed = Math.max(minimumHitTime, occurrence.time); mSecPassed <= Math.min(hitTime, nextOccurrence.time); ++mSecPassed) {
+                        const progress = (mSecPassed - occurrence.time) /
+                            (nextOccurrence.time - occurrence.time);
+                        distance = object.object.stackedPosition.getDistance(cursorPosition.add(displacement.scale(progress)));
+                    }
+                }
+            }
+            if (distance > object.object.radius) {
+                continue;
+            }
+            // The case for a one-handed object is that there will be a slight movement in the cursor towards
+            // the next object in fast patterns. We should not be worried about slow patterns as they will only
+            // make a minimal difference and aim strain threshold should filter them out.
+            // In order to verify if the player does that, we check if the movement towards the next
+            // object is sufficient enough to be two-handed. This is done by checking if the movement
+            // from the current object to the next object and the movement from the current object
+            // to the significant move cursor occurrence produces an angle that is acute enough.
+            // let isAngleFulfilled: boolean = false;
+            // Aside of angles, we need to consider if the player dragged from the previous object to the current object.
+            let isDragged = false;
+            // Get the latest down or movement cursor occurrence.
+            while (c.occurrences[j]?.id === exports.movementType.UP &&
+                j > hitTimeBeforeIndex) {
+                --j;
+            }
+            if (object.object instanceof osuBase.Circle) {
+                // For circles, we only need to consider the actual press on the circle.
+                // Therefore, we need to get the latest down cursor occurrence instead.
+                while (c.occurrences[j]?.id !== exports.movementType.DOWN &&
+                    j > hitTimeBeforeIndex) {
+                    --j;
+                }
+            }
+            // Theoretically there can only be 1 up occurrence, but this is a
+            // consideration if the user manually adds cursor occurrences.
+            if (c.occurrences[j]?.id === exports.movementType.UP) {
+                ++j;
+            }
+            // Some move instances move in the exact same place. Not sure why, most likely
+            // because the position is recorded as int in the game and the movement is too small to
+            // convert into +1 or -1.
+            // let nextSignificantOccurrenceIndex: number = j + 1;
+            // while (
+            //     c.occurrences[j] &&
+            //     c.occurrences[nextSignificantOccurrenceIndex] &&
+            //     c.occurrences[j].position.equals(
+            //         c.occurrences[nextSignificantOccurrenceIndex].position
+            //     )
+            // ) {
+            //     ++nextSignificantOccurrenceIndex;
+            // }
+            // const nextSignificantOccurrence: CursorOccurrence =
+            //     c.occurrences[nextSignificantOccurrenceIndex];
+            // const next: DifficultyHitObject | RebalanceDifficultyHitObject =
+            //     this.map.objects[index + 1];
+            // Angle detection.
+            /* if (nextSignificantOccurrence?.id === movementType.MOVE && next) {
+                // Get the object's actual end position.
+                let actualEndPosition: Vector2 =
+                    object.object.stackedEndPosition;
+
+                if (
+                    object.object instanceof Slider &&
+                    object.object.lazyEndPosition
+                ) {
+                    // For sliders, we take the closest distance between the lazy end position
+                    // and stacked end position towards the next significant cursor occurrence.
+                    // This assumes that the player takes the simpler movement.
+                    const lazyEndDistance: number =
+                        object.object.lazyEndPosition.getDistance(
+                            nextSignificantOccurrence.position
+                        );
+                    const actualEndDistance: number =
+                        object.object.stackedEndPosition.getDistance(
+                            nextSignificantOccurrence.position
+                        );
+
+                    if (lazyEndDistance < actualEndDistance) {
+                        actualEndPosition = object.object.lazyEndPosition;
+                    }
+                }
+
+                // Get the movement vector towards the next cursor occurrence by subtracting
+                // the next cursor occurrence with the object's position.
+                const movementVec: Vector2 =
+                    nextSignificantOccurrence.position.subtract(
+                        actualEndPosition
+                    );
+
+                const currentToNext: Vector2 =
+                    next.object.stackedPosition.subtract(actualEndPosition);
+
+                const dot: number = currentToNext.dot(movementVec);
+                const det: number =
+                    currentToNext.x * movementVec.y -
+                    currentToNext.y * movementVec.x;
+
+                const movementToNextAngle: number = Math.abs(
+                    Math.atan2(det, dot)
+                );
+
+                isAngleFulfilled = movementToNextAngle < Math.PI / 6;
+            } */
+            // Dragging detection.
+            let dragTimeThreshold = 0;
+            const prev = this.calculator.objects[index - 1];
+            if (prev) {
+                // The previous object might be a slider, so we need to get
+                // the hit data of it to get an accurate time threshold.
+                const prevData = this.data.hitObjectData[index - 1];
+                dragTimeThreshold = prev.object.startTime;
+                if (!(prev.object instanceof osuBase.Spinner)) {
+                    dragTimeThreshold += prevData.accuracy;
+                }
+                if (prev.object instanceof osuBase.Slider) {
+                    dragTimeThreshold = Math.max(dragTimeThreshold, prev.object.endTime);
+                }
+            }
+            let occurrenceStartIndex = hitTimeAfterIndex;
+            while (c.occurrences[occurrenceStartIndex]?.time >=
+                dragTimeThreshold &&
+                occurrenceStartIndex > 0) {
+                --occurrenceStartIndex;
+            }
+            // The above loop will make the start index before or right when
+            // the previous object was hit or ended, but we want the index after it.
+            ++occurrenceStartIndex;
+            const dragOccurrences = c.occurrences.slice(occurrenceStartIndex, hitTimeAfterIndex);
+            isDragged =
+                dragOccurrences.length > 0 &&
+                    // We only care when the cursor approaches the current object. It doesn't
+                    // matter whether the previous object was pressed or dragged.
+                    dragOccurrences
+                        .at(-1)
+                        .position.getDistance(object.object.stackedPosition) <=
+                        object.object.radius &&
+                    dragOccurrences.every((v) => v.id === exports.movementType.MOVE);
+            cursorInformations.push({
+                // If the angle is fulfilled or the player dragged,
+                // we set the cursor index to the main cursor index.
+                acceptedCursorIndex: /* isAngleFulfilled ||  */ isDragged
+                    ? -1
+                    : i,
+                actualCursorIndex: i,
+                occurrenceIndex: j,
+                distanceDiff: distance,
+            });
+        }
+        // Cursors have been filtered to see which of them is inside the object.
+        // Now we look at which cursor is closest to the center of the object.
+        const minDistanceDiff = Math.min(...cursorInformations.map((v) => v.distanceDiff));
+        const acceptedCursorInformation = cursorInformations.find((c) => c.distanceDiff === minDistanceDiff);
+        return new IndexedHitObject(object, acceptedCursorInformation?.acceptedCursorIndex ?? -1, acceptedCursorInformation?.actualCursorIndex ?? -1, acceptedCursorInformation?.occurrenceIndex ?? -1);
+    }
+    /**
+     * Checks whether a slider was cheesed.
+     *
+     * This is done by checking if a cursor follows a slider all the way to its end position.
+     *
+     * @param indexedHitObject The indexed slider.
+     * @param hitData The hit data of the slider.
+     * @param actualCursorIndex The actual cursor index that hit the slider.
+     * @param hitWindowOffset The offset that was calculated by `getHitWindowOffset()`
+     * @returns Whether the slider was cheesed.
+     */
+    checkSliderCheesing(indexedHitObject, hitData, hitWindowOffset) {
+        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
+            hitData.result === exports.hitResult.RESULT_0) {
+            return false;
+        }
+        let cursorLoopIndex = Math.max(0, indexedHitObject.occurrenceIndex);
+        const c = this.data.cursorMovement[indexedHitObject.actualCursorIndex];
+        const acceptableRadius = indexedHitObject.object.object.radius * 2.4;
+        for (let i = 1; i < indexedHitObject.object.object.nestedHitObjects.length; ++i) {
+            const tickWasHit = hitData.tickset[i - 1];
+            if (!tickWasHit) {
+                continue;
+            }
+            const object = indexedHitObject.object.object.nestedHitObjects[i];
+            let j = cursorLoopIndex;
+            let cursorHitTick = false;
+            for (j; j < c.occurrences.length; ++j) {
+                if (c.occurrences[j].time <
+                    object.startTime - hitWindowOffset) {
+                    continue;
+                }
+                if (c.occurrences[j].time >
+                    object.startTime + hitWindowOffset) {
+                    break;
+                }
+                if (c.occurrences[j].position.getDistance(object.stackedPosition) <= acceptableRadius) {
+                    cursorHitTick = true;
+                    break;
+                }
+            }
+            if (!cursorHitTick) {
+                return true;
+            }
+            cursorLoopIndex = j;
+        }
+        return false;
+    }
+    /**
+     * Applies penalty to the original star rating instance.
+     */
+    applyPenalty() {
+        const beatmaps = new Array(this.data.cursorMovement.length);
+        this.indexedHitObjects.forEach((o) => {
+            if (!beatmaps[o.acceptedCursorIndex]) {
+                const map = osuBase.Utils.deepCopy(this.calculator.beatmap);
+                map.hitObjects.clear();
+                beatmaps[o.acceptedCursorIndex] = map;
+            }
+            beatmaps[o.acceptedCursorIndex].hitObjects.add(o.object.object);
+        });
+        // Preserve some values that aren't reasonable for them to be changed.
+        const preservedValues = this.calculator.objects.map((v) => {
+            return {
+                noteDensity: v.noteDensity,
+                overlappingFactor: v.overlappingFactor,
+                rhythmStrain: v.rhythmStrain,
+                rhythmMultiplier: v.rhythmMultiplier,
+            };
+        });
+        this.calculator.objects.length = 0;
+        beatmaps.forEach((beatmap) => {
+            if (!beatmap) {
+                return;
+            }
+            const difficultyCalculator = Object.assign(osuBase.Utils.deepCopy(this.calculator), { beatmap: beatmap });
+            difficultyCalculator.generateDifficultyHitObjects();
+            difficultyCalculator.objects[0].deltaTime =
+                difficultyCalculator.objects[0].startTime -
+                    this.indexedHitObjects[0].object.startTime;
+            difficultyCalculator.objects[0].strainTime = Math.max(25, difficultyCalculator.objects[0].deltaTime);
+            (this.calculator.objects).push(...difficultyCalculator.objects);
+        });
+        this.calculator.objects.sort((a, b) => a.startTime - b.startTime);
+        // Reassign preserved values before calculating.
+        for (let i = 0; i < this.calculator.objects.length; ++i) {
+            const diffObject = this.calculator.objects[i];
+            const indexedHitObject = this.indexedHitObjects[i];
+            const preservedValue = preservedValues[i];
+            diffObject.noteDensity = preservedValue.noteDensity;
+            diffObject.overlappingFactor = preservedValue.overlappingFactor;
+            diffObject.rhythmStrain = preservedValue.rhythmStrain;
+            diffObject.rhythmMultiplier = preservedValue.rhythmMultiplier;
+            // Set slider travel distance to 0 if the slider was cheesed.
+            if (indexedHitObject.sliderCheesed) {
+                diffObject.travelDistance = 0;
+            }
+        }
+        // Do not include rhythm skill.
+        this.calculator.calculateAim();
+        this.calculator.calculateTap();
+        this.calculator.calculateFlashlight();
+        this.calculator.calculateVisual();
+        this.calculator.calculateTotal();
+    }
 }
 
-/**
- * A replay analyzer that analyzes a replay from osu!droid.
- *
- * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
- *
- * Once analyzed, the result can be accessed via the `data` property.
- */
-class ReplayAnalyzer {
-    /**
-     * 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. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
-     */
-    beatmap;
-    /**
-     * 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;
-    /**
-     * Whether this replay has been checked against 3 finger usage.
-     */
-    hasBeenCheckedFor3Finger = false;
-    /**
-     * Whether this replay has been checked against 2 hand usage.
-     */
-    hasBeenCheckedFor2Hand = false;
-    /**
-     * The cursor indexes at which each object was hit.
-     *
-     * This is filled after 2 hand usage has been checked.
-     */
-    twoHandCursorIndexes = [];
-    // Sizes of primitive data types in Java (in bytes)
-    BYTE_LENGTH = 1;
-    SHORT_LENGTH = 2;
-    INT_LENGTH = 4;
-    FLOAT_LENGTH = 4;
-    LONG_LENGTH = 8;
-    constructor(values) {
-        this.scoreID = values.scoreID;
-        this.beatmap = values.map;
-    }
-    /**
-     * 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) {
-            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;
-    }
-    /**
-     * Decompresses a replay.
-     *
-     * The decompressed replay is in a form of Java object. This will be converted to a buffer and deserialized to read data from the replay.
-     */
-    decompress() {
-        return new Promise((resolve, reject) => {
-            const stream$1 = new stream.Readable();
-            stream$1.push(this.originalODR);
-            stream$1.push(null);
-            stream$1
-                .pipe(unzipper.Parse())
-                .on("entry", async (entry) => {
-                const fileName = entry.path;
-                if (fileName === "data") {
-                    return resolve(await entry.buffer());
-                }
-                else {
-                    entry.autodrain();
-                }
-            })
-                .on("error", (e) => {
-                setTimeout(() => reject(e), 2000);
-            });
-        });
-    }
-    /**
-     * Parses a replay after being downloaded and converted to a buffer.
-     */
-    parseReplay() {
-        // 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
-        let rawObject;
-        try {
-            rawObject = javaDeserialization__namespace.parse(this.fixedODR);
-        }
-        catch {
-            return;
-        }
-        const resultObject = {
-            replayVersion: rawObject[0].version,
-            folderName: rawObject[1],
-            fileName: rawObject[2],
-            hash: rawObject[3],
-            cursorMovement: [],
-            hitObjectData: [],
-        };
-        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 = this.convertMods(rawObject[6].elements);
-            // 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);
-            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";
-            }
-        }
-        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", ""));
-            }
-        }
-        let bufferIndex;
-        switch (true) {
-            // replay v4 and above
-            case resultObject.replayVersion >= 4:
-                bufferIndex = 8;
-                break;
-            // replay v3
-            case resultObject.replayVersion === 3:
-                bufferIndex = 7;
-                break;
-            // replay v1 and v2
-            default:
-                bufferIndex = 4;
-        }
-        const replayDataBufferArray = [];
-        while (bufferIndex < rawObject.length) {
-            replayDataBufferArray.push(rawObject[bufferIndex++]);
-        }
-        // Merge all cursor movement and hit object data section into one for better control when parsing
-        const replayDataBuffer = Buffer.concat(replayDataBufferArray);
-        let bufferCounter = 0;
-        const size = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
-        // Parse movement data
-        for (let x = 0; x < size; x++) {
-            const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
-            bufferCounter += this.INT_LENGTH;
-            const time = [];
-            const x = [];
-            const y = [];
-            const id = [];
-            for (let i = 0; i < moveSize; i++) {
-                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
-                bufferCounter += this.INT_LENGTH;
-                id[i] = time[i] & 3;
-                time[i] >>= 2;
-                if (id[i] !== exports.movementType.UP) {
-                    if (resultObject.replayVersion >= 5) {
-                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
-                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
-                        bufferCounter += this.FLOAT_LENGTH;
-                    }
-                    else {
-                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
-                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
-                        bufferCounter += this.SHORT_LENGTH;
-                    }
-                }
-                else {
-                    x[i] = -1;
-                    y[i] = -1;
-                }
-            }
-            resultObject.cursorMovement.push(new CursorData({
-                size: moveSize,
-                time: time,
-                x: x,
-                y: y,
-                id: id,
-            }));
-        }
-        const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
-        bufferCounter += this.INT_LENGTH;
-        // Parse result data
-        for (let i = 0; i < replayObjectLength; i++) {
-            const replayObjectData = {
-                accuracy: 0,
-                tickset: [],
-                result: 0,
-            };
-            replayObjectData.accuracy =
-                replayDataBuffer.readInt16BE(bufferCounter);
-            bufferCounter += this.SHORT_LENGTH;
-            const len = replayDataBuffer.readInt8(bufferCounter);
-            bufferCounter += this.BYTE_LENGTH;
-            if (len > 0) {
-                const bytes = [];
-                for (let j = 0; j < len; j++) {
-                    bytes.push(replayDataBuffer.readInt8(bufferCounter));
-                    bufferCounter += this.BYTE_LENGTH;
-                }
-                // Int/int division in Java; numbers must be truncated to get actual number
-                for (let j = 0; j < len * 8; j++) {
-                    replayObjectData.tickset[j] =
-                        (bytes[len - Math.trunc(j / 8) - 1] &
-                            (1 << Math.trunc(j % 8))) !==
-                            0;
-                }
-            }
-            if (resultObject.replayVersion >= 1) {
-                replayObjectData.result =
-                    replayDataBuffer.readInt8(bufferCounter);
-                bufferCounter += this.BYTE_LENGTH;
-            }
-            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 ||
-                this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-                ? this.beatmap.beatmap
-                : this.beatmap).hitObjects.objects;
-            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;
-                switch (hitObjectData.result) {
-                    case exports.hitResult.RESULT_0:
-                        ++hit0;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.hitResult.RESULT_50:
-                        ++hit50;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.hitResult.RESULT_100:
-                        ++hit100;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            ++hit100k;
-                        }
-                        break;
-                    case exports.hitResult.RESULT_300:
-                        ++hit300;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            ++hit300k;
-                        }
-                        break;
-                }
-                if (isNextNewCombo) {
-                    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";
-            }
-        }
-        this.data = new ReplayData(resultObject);
-    }
-    /**
-     * Gets hit error information of the replay.
-     *
-     * `analyze()` must be called before calling this.
-     */
-    calculateHitError() {
-        if (!this.data || !this.beatmap) {
-            return null;
-        }
-        const hitObjectData = this.data.hitObjectData;
-        let positiveCount = 0;
-        let negativeCount = 0;
-        let positiveTotal = 0;
-        let negativeTotal = 0;
-        const objects = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-            ? this.beatmap.beatmap
-            : this.beatmap).hitObjects.objects;
-        for (let i = 0; i < hitObjectData.length; ++i) {
-            const v = hitObjectData[i];
-            const o = objects[i];
-            if (o instanceof osuBase.Spinner || v.result === exports.hitResult.RESULT_0) {
-                continue;
-            }
-            const accuracy = v.accuracy;
-            if (accuracy >= 0) {
-                positiveTotal += accuracy;
-                ++positiveCount;
-            }
-            else {
-                negativeTotal += accuracy;
-                ++negativeCount;
-            }
-        }
-        return {
-            positiveAvg: positiveTotal / positiveCount || 0,
-            negativeAvg: negativeTotal / negativeCount || 0,
-            unstableRate: osuBase.MathUtils.calculateStandardDeviation(hitObjectData.map((v, i) => v.result !== exports.hitResult.RESULT_0 &&
-                !(objects[i] instanceof osuBase.Spinner)
-                ? v.accuracy
-                : 0)) * 10,
-        };
-    }
-    /**
-     * Converts replay mods to droid mod string.
-     */
-    convertDroidMods(replayMods) {
-        const replayModsConstants = {
-            MOD_NOFAIL: "n",
-            MOD_EASY: "e",
-            MOD_HIDDEN: "h",
-            MOD_HARDROCK: "r",
-            MOD_DOUBLETIME: "d",
-            MOD_HALFTIME: "t",
-            MOD_NIGHTCORE: "c",
-            MOD_PRECISE: "s",
-            MOD_SMALLCIRCLE: "m",
-            MOD_SPEEDUP: "b",
-            MOD_REALLYEASY: "l",
-            MOD_PERFECT: "f",
-            MOD_SUDDENDEATH: "u",
-            MOD_SCOREV2: "v",
-        };
-        let modString = "";
-        for (const mod of replayMods) {
-            for (const property in replayModsConstants) {
-                if (!(property in replayModsConstants)) {
-                    continue;
-                }
-                if (!mod.includes(property)) {
-                    continue;
-                }
-                modString +=
-                    replayModsConstants[property];
-                break;
-            }
-        }
-        return modString;
-    }
-    /**
-     * Converts replay mods to regular mod string.
-     */
-    convertMods(replayMods) {
-        return osuBase.ModUtil.droidStringToMods(this.convertDroidMods(replayMods));
-    }
-    /**
-     * Checks if a play is using 3 fingers.
-     *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
-     */
-    checkFor3Finger() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
-            return;
-        }
-        const threeFingerChecker = new ThreeFingerChecker(this.beatmap, this.data);
-        const result = threeFingerChecker.check();
-        this.is3Finger = result.is3Finger;
-        this.tapPenalty = result.penalty;
-        this.hasBeenCheckedFor3Finger = true;
-    }
-    /**
-     * Checks if a play is using 2 hands.
-     *
-     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
-     */
-    checkFor2Hand() {
-        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
-            !this.data) {
-            return;
-        }
-        const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
-        const result = twoHandChecker.check();
-        this.is2Hand = result.is2Hand;
-        this.twoHandCursorIndexes = result.cursorIndexes;
-        this.hasBeenCheckedFor2Hand = true;
-    }
+/**
+ * A replay analyzer that analyzes a replay from osu!droid.
+ *
+ * Created by reverse engineering the replay parser from the game itself, which can be found {@link https://github.com/osudroid/osu-droid/blob/master/src/ru/nsu/ccfit/zuev/osu/scoring/Replay.java here}.
+ *
+ * Once analyzed, the result can be accessed via the `data` property.
+ */
+class ReplayAnalyzer {
+    /**
+     * 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. `DroidStarRating` or `RebalanceDroidStarRating` is required for three finger or two hand analyzing.
+     */
+    beatmap;
+    /**
+     * 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;
+    /**
+     * Whether this replay has been checked against 3 finger usage.
+     */
+    hasBeenCheckedFor3Finger = false;
+    /**
+     * Whether this replay has been checked against 2 hand usage.
+     */
+    hasBeenCheckedFor2Hand = false;
+    /**
+     * The cursor indexes at which each object was hit.
+     *
+     * This is filled after 2 hand usage has been checked.
+     */
+    twoHandCursorIndexes = [];
+    // Sizes of primitive data types in Java (in bytes)
+    BYTE_LENGTH = 1;
+    SHORT_LENGTH = 2;
+    INT_LENGTH = 4;
+    FLOAT_LENGTH = 4;
+    LONG_LENGTH = 8;
+    constructor(values) {
+        this.scoreID = values.scoreID;
+        this.beatmap = values.map;
+    }
+    /**
+     * 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) {
+            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;
+    }
+    /**
+     * Decompresses a replay.
+     *
+     * The decompressed replay is in a form of Java object. This will be converted to a buffer and deserialized to read data from the replay.
+     */
+    decompress() {
+        return new Promise((resolve, reject) => {
+            const stream$1 = new stream.Readable();
+            stream$1.push(this.originalODR);
+            stream$1.push(null);
+            stream$1
+                .pipe(unzipper.Parse())
+                .on("entry", async (entry) => {
+                const fileName = entry.path;
+                if (fileName === "data") {
+                    return resolve(await entry.buffer());
+                }
+                else {
+                    entry.autodrain();
+                }
+            })
+                .on("error", (e) => {
+                setTimeout(() => reject(e), 2000);
+            });
+        });
+    }
+    /**
+     * Parses a replay after being downloaded and converted to a buffer.
+     */
+    parseReplay() {
+        // 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
+        let rawObject;
+        try {
+            rawObject = javaDeserialization__namespace.parse(this.fixedODR);
+        }
+        catch {
+            return;
+        }
+        const resultObject = {
+            replayVersion: rawObject[0].version,
+            folderName: rawObject[1],
+            fileName: rawObject[2],
+            hash: rawObject[3],
+            cursorMovement: [],
+            hitObjectData: [],
+        };
+        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 = this.convertMods(rawObject[6].elements);
+            // 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);
+            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";
+            }
+        }
+        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", ""));
+            }
+        }
+        let bufferIndex;
+        switch (true) {
+            // replay v4 and above
+            case resultObject.replayVersion >= 4:
+                bufferIndex = 8;
+                break;
+            // replay v3
+            case resultObject.replayVersion === 3:
+                bufferIndex = 7;
+                break;
+            // replay v1 and v2
+            default:
+                bufferIndex = 4;
+        }
+        const replayDataBufferArray = [];
+        while (bufferIndex < rawObject.length) {
+            replayDataBufferArray.push(rawObject[bufferIndex++]);
+        }
+        // Merge all cursor movement and hit object data section into one for better control when parsing
+        const replayDataBuffer = Buffer.concat(replayDataBufferArray);
+        let bufferCounter = 0;
+        const size = replayDataBuffer.readInt32BE(bufferCounter);
+        bufferCounter += this.INT_LENGTH;
+        // Parse movement data
+        for (let x = 0; x < size; x++) {
+            const moveSize = replayDataBuffer.readInt32BE(bufferCounter);
+            bufferCounter += this.INT_LENGTH;
+            const time = [];
+            const x = [];
+            const y = [];
+            const id = [];
+            for (let i = 0; i < moveSize; i++) {
+                time[i] = replayDataBuffer.readInt32BE(bufferCounter);
+                bufferCounter += this.INT_LENGTH;
+                id[i] = time[i] & 3;
+                time[i] >>= 2;
+                if (id[i] !== exports.movementType.UP) {
+                    if (resultObject.replayVersion >= 5) {
+                        x[i] = replayDataBuffer.readFloatBE(bufferCounter);
+                        bufferCounter += this.FLOAT_LENGTH;
+                        y[i] = replayDataBuffer.readFloatBE(bufferCounter);
+                        bufferCounter += this.FLOAT_LENGTH;
+                    }
+                    else {
+                        x[i] = replayDataBuffer.readInt16BE(bufferCounter);
+                        bufferCounter += this.SHORT_LENGTH;
+                        y[i] = replayDataBuffer.readInt16BE(bufferCounter);
+                        bufferCounter += this.SHORT_LENGTH;
+                    }
+                }
+                else {
+                    x[i] = -1;
+                    y[i] = -1;
+                }
+            }
+            resultObject.cursorMovement.push(new CursorData({
+                size: moveSize,
+                time: time,
+                x: x,
+                y: y,
+                id: id,
+            }));
+        }
+        const replayObjectLength = replayDataBuffer.readInt32BE(bufferCounter);
+        bufferCounter += this.INT_LENGTH;
+        // Parse result data
+        for (let i = 0; i < replayObjectLength; i++) {
+            const replayObjectData = {
+                accuracy: 0,
+                tickset: [],
+                result: 0,
+            };
+            replayObjectData.accuracy =
+                replayDataBuffer.readInt16BE(bufferCounter);
+            bufferCounter += this.SHORT_LENGTH;
+            const len = replayDataBuffer.readInt8(bufferCounter);
+            bufferCounter += this.BYTE_LENGTH;
+            if (len > 0) {
+                const bytes = [];
+                for (let j = 0; j < len; j++) {
+                    bytes.push(replayDataBuffer.readInt8(bufferCounter));
+                    bufferCounter += this.BYTE_LENGTH;
+                }
+                // Int/int division in Java; numbers must be truncated to get actual number
+                for (let j = 0; j < len * 8; j++) {
+                    replayObjectData.tickset[j] =
+                        (bytes[len - Math.trunc(j / 8) - 1] &
+                            (1 << Math.trunc(j % 8))) !==
+                            0;
+                }
+            }
+            if (resultObject.replayVersion >= 1) {
+                replayObjectData.result =
+                    replayDataBuffer.readInt8(bufferCounter);
+                bufferCounter += this.BYTE_LENGTH;
+            }
+            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 ||
+                this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
+                ? this.beatmap.beatmap
+                : this.beatmap).hitObjects.objects;
+            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;
+                switch (hitObjectData.result) {
+                    case exports.hitResult.RESULT_0:
+                        ++hit0;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.hitResult.RESULT_50:
+                        ++hit50;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.hitResult.RESULT_100:
+                        ++hit100;
+                        if (grantsGekiOrKatu && isNextNewCombo) {
+                            ++hit100k;
+                        }
+                        break;
+                    case exports.hitResult.RESULT_300:
+                        ++hit300;
+                        if (grantsGekiOrKatu && isNextNewCombo) {
+                            ++hit300k;
+                        }
+                        break;
+                }
+                if (isNextNewCombo) {
+                    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";
+            }
+        }
+        this.data = new ReplayData(resultObject);
+    }
+    /**
+     * Gets hit error information of the replay.
+     *
+     * `analyze()` must be called before calling this.
+     */
+    calculateHitError() {
+        if (!this.data || !this.beatmap) {
+            return null;
+        }
+        const hitObjectData = this.data.hitObjectData;
+        let positiveCount = 0;
+        let negativeCount = 0;
+        let positiveTotal = 0;
+        let negativeTotal = 0;
+        const objects = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
+            ? this.beatmap.beatmap
+            : this.beatmap).hitObjects.objects;
+        for (let i = 0; i < hitObjectData.length; ++i) {
+            const v = hitObjectData[i];
+            const o = objects[i];
+            if (o instanceof osuBase.Spinner || v.result === exports.hitResult.RESULT_0) {
+                continue;
+            }
+            const accuracy = v.accuracy;
+            if (accuracy >= 0) {
+                positiveTotal += accuracy;
+                ++positiveCount;
+            }
+            else {
+                negativeTotal += accuracy;
+                ++negativeCount;
+            }
+        }
+        return {
+            positiveAvg: positiveTotal / positiveCount || 0,
+            negativeAvg: negativeTotal / negativeCount || 0,
+            unstableRate: osuBase.MathUtils.calculateStandardDeviation(hitObjectData.map((v, i) => v.result !== exports.hitResult.RESULT_0 &&
+                !(objects[i] instanceof osuBase.Spinner)
+                ? v.accuracy
+                : 0)) * 10,
+        };
+    }
+    /**
+     * Converts replay mods to droid mod string.
+     */
+    convertDroidMods(replayMods) {
+        const replayModsConstants = {
+            MOD_NOFAIL: "n",
+            MOD_EASY: "e",
+            MOD_HIDDEN: "h",
+            MOD_HARDROCK: "r",
+            MOD_DOUBLETIME: "d",
+            MOD_HALFTIME: "t",
+            MOD_NIGHTCORE: "c",
+            MOD_PRECISE: "s",
+            MOD_SMALLCIRCLE: "m",
+            MOD_SPEEDUP: "b",
+            MOD_REALLYEASY: "l",
+            MOD_PERFECT: "f",
+            MOD_SUDDENDEATH: "u",
+            MOD_SCOREV2: "v",
+        };
+        let modString = "";
+        for (const mod of replayMods) {
+            for (const property in replayModsConstants) {
+                if (!(property in replayModsConstants)) {
+                    continue;
+                }
+                if (!mod.includes(property)) {
+                    continue;
+                }
+                modString +=
+                    replayModsConstants[property];
+                break;
+            }
+        }
+        return modString;
+    }
+    /**
+     * Converts replay mods to regular mod string.
+     */
+    convertMods(replayMods) {
+        return osuBase.ModUtil.droidStringToMods(this.convertDroidMods(replayMods));
+    }
+    /**
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor3Finger() {
+        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
+            !this.data) {
+            return;
+        }
+        const threeFingerChecker = new ThreeFingerChecker(this.beatmap, this.data);
+        const result = threeFingerChecker.check();
+        this.is3Finger = result.is3Finger;
+        this.tapPenalty = result.penalty;
+        this.hasBeenCheckedFor3Finger = true;
+    }
+    /**
+     * Checks if a play is using 2 hands.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidStarRating` or `RebalanceDroidStarRating`.
+     */
+    checkFor2Hand() {
+        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
+            !this.data) {
+            return;
+        }
+        const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
+        const result = twoHandChecker.check();
+        this.is2Hand = result.is2Hand;
+        this.twoHandCursorIndexes = result.cursorIndexes;
+        this.hasBeenCheckedFor2Hand = true;
+    }
 }
 
-/**
- * Represents a hitobject in an osu!droid replay.
- *
- * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class ReplayObjectData {
-    /**
-     * The offset of which the hitobject was hit in milliseconds.
-     */
-    accuracy;
-    /**
-     * The tickset of the hitobject.
-     *
-     * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
-     */
-    tickset;
-    /**
-     * The bitwise hit result of the hitobject.
-     */
-    result;
-    constructor(values) {
-        this.accuracy = values.accuracy;
-        this.tickset = values.tickset;
-        this.result = values.result;
-    }
+/**
+ * Represents a hitobject in an osu!droid replay.
+ *
+ * Stores information about hitobjects in an osu!droid replay such as hit offset, tickset, and hit result.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayObjectData {
+    /**
+     * The offset of which the hitobject was hit in milliseconds.
+     */
+    accuracy;
+    /**
+     * The tickset of the hitobject.
+     *
+     * This is used to determine whether or not a slider event (tick/repeat/end) is hit based on the order they appear.
+     */
+    tickset;
+    /**
+     * The bitwise hit result of the hitobject.
+     */
+    result;
+    constructor(values) {
+        this.accuracy = values.accuracy;
+        this.tickset = values.tickset;
+        this.result = values.result;
+    }
 }
 
 exports.CursorData = CursorData;