@rian8337/osu-droid-replay-analyzer 3.0.0-beta.8 → 3.0.0

package/dist/index.js

@@ -29,2185 +29,2544 @@ function _interopNamespace(e) {
 
 var javaDeserialization__namespace = /*#__PURE__*/_interopNamespace(javaDeserialization);
 
-/**
- * Movement types of a cursor in an osu!droid replay.
- *
- * The cursor movement is represented as a player's action on the screen.
- */
-exports.movementType = void 0;
-(function (movementType) {
-    /**
-     * The player places their finger on the screen.
-     */
-    movementType[movementType["DOWN"] = 0] = "DOWN";
-    /**
-     * The player drags their finger on the screen.
-     */
-    movementType[movementType["MOVE"] = 1] = "MOVE";
-    /**
-     * The player releases their finger from the screen.
-     */
-    movementType[movementType["UP"] = 2] = "UP";
-})(exports.movementType || (exports.movementType = {}));
+/**
+ * Movement types of a cursor in an osu!droid replay.
+ *
+ * The cursor movement is represented as a player's action on the screen.
+ */
+exports.MovementType = void 0;
+(function (MovementType) {
+    /**
+     * The player places their finger on the screen.
+     */
+    MovementType[MovementType["down"] = 0] = "down";
+    /**
+     * The player drags their finger on the screen.
+     */
+    MovementType[MovementType["move"] = 1] = "move";
+    /**
+     * The player releases their finger from the screen.
+     */
+    MovementType[MovementType["up"] = 2] = "up";
+})(exports.MovementType || (exports.MovementType = {}));
 
-/**
- * Represents a cursor's occurrence.
- */
-class CursorOccurrence {
-    /**
-     * The time of this occurrence.
-     */
-    time;
-    /**
-     * The position of the occurrence.
-     */
-    position;
-    /**
-     * The movement ID of the occurrence.
-     */
-    id;
-    constructor(time, x, y, id) {
-        this.time = time;
-        this.position = new osuBase.Vector2(x, y);
-        this.id = id;
-    }
+/**
+ * Represents a cursor's occurrence.
+ */
+class CursorOccurrence {
+    /**
+     * The time of this occurrence.
+     */
+    time;
+    /**
+     * The position of the occurrence.
+     */
+    position;
+    /**
+     * The movement ID of the occurrence.
+     */
+    id;
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
 }
 
-/**
- * Represents a group of cursor occurrences representing a cursor instance's
- * movement when a player places their finger on the screen.
- */
-class CursorOccurrenceGroup {
-    /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
-     */
-    get down() {
-        return this._down;
-    }
-    /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
-     */
-    set down(value) {
-        if (value.id !== exports.movementType.DOWN) {
-            throw new TypeError("Attempting to set the down cursor occurrence to one with different movement type.");
-        }
-        this._down = value;
-    }
-    /**
-     * The cursor occurrences of movement type `movementType.MOVE`.
-     */
-    get moves() {
-        return this._moves;
-    }
-    /**
-     * The cursor occurrence of movement type `movementType.UP`.
-     *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
-     */
-    get up() {
-        return this._up;
-    }
-    /**
-     * The cursor occurrence of movement type `movementType.UP`.
-     *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
-     */
-    set up(value) {
-        if (value && value.id !== exports.movementType.UP) {
-            throw new TypeError("Attempting to set the up cursor occurrence to one with different movement type.");
-        }
-        this._up = value;
-    }
-    /**
-     * The time at which this cursor occurrence group starts.
-     */
-    get startTime() {
-        return this._down.time;
-    }
-    /**
-     * The time at which this cursor occurrence group ends.
-     */
-    get endTime() {
-        if (this._up) {
-            return this._up.time;
-        }
-        return this._moves.at(-1)?.time ?? this._down.time;
-    }
-    /**
-     * All cursor occurrences in this group.
-     *
-     * This iterates all occurrences and as such should be used sparingly or stored locally.
-     */
-    get allOccurrences() {
-        const cursors = [this._down, ...this._moves];
-        if (this._up) {
-            cursors.push(this._up);
-        }
-        return cursors;
-    }
-    /**
-     * The cursor occurrence of movement type `movementType.DOWN`.
-     */
-    _down;
-    /**
-     * The cursor occurrences of movement type `movementType.MOVE`.
-     */
-    _moves;
-    /**
-     * The cursor occurrence of movement type `movementType.UP`.
-     *
-     * May not exist, such as when the player holds their cursor until the end of a beatmap.
-     */
-    _up;
-    constructor(down, moves, up) {
-        this._down = down;
-        this._moves = moves;
-        // Re-set down cursor occurrence for checking.
-        this.down = down;
-        this.up = up;
-    }
-    /**
-     * Determines whether this cursor occurrence group is active at the specified time.
-     *
-     * @param time The time.
-     * @returns Whether this cursor occurrence group is active at the specified time.
-     */
-    isActiveAt(time) {
-        return time >= this.startTime && time <= this.endTime;
-    }
-    /**
-     * Finds the cursor occurrence that is active at a given time.
-     *
-     * @param time The time.
-     * @returns The cursor occurrence at the given time, `null` if not found.
-     */
-    cursorAt(time) {
-        if (!this.isActiveAt(time)) {
-            return null;
-        }
-        if (this._down.time === time) {
-            return this._down;
-        }
-        if (this._up?.time === time) {
-            return this._up;
-        }
-        let l = 0;
-        let r = this._moves.length - 2;
-        while (l <= r) {
-            const pivot = l + ((r - l) >> 1);
-            if (this._moves[pivot].time < time) {
-                l = pivot + 1;
-            }
-            else if (this._moves[pivot].time > time) {
-                r = pivot - 1;
-            }
-            else {
-                return this._moves[pivot];
-            }
-        }
-        // l will be the first cursor occurrence with time > this._moves[l].time, but we want the one before it
-        return this._moves[l - 1];
-    }
+/**
+ * Represents a group of cursor occurrences representing a cursor instance's
+ * movement when a player places their finger on the screen.
+ */
+class CursorOccurrenceGroup {
+    /**
+     * The cursor occurrence of movement type `movementType.DOWN`.
+     */
+    get down() {
+        return this._down;
+    }
+    /**
+     * The cursor occurrence of movement type `movementType.DOWN`.
+     */
+    set down(value) {
+        if (value.id !== exports.MovementType.down) {
+            throw new TypeError("Attempting to set the down cursor occurrence to one with different movement type.");
+        }
+        this._down = value;
+    }
+    /**
+     * The cursor occurrences of movement type `movementType.MOVE`.
+     */
+    get moves() {
+        return this._moves;
+    }
+    /**
+     * The cursor occurrence of movement type `movementType.UP`.
+     *
+     * May not exist, such as when the player holds their cursor until the end of a beatmap.
+     */
+    get up() {
+        return this._up;
+    }
+    /**
+     * The cursor occurrence of movement type `movementType.UP`.
+     *
+     * May not exist, such as when the player holds their cursor until the end of a beatmap.
+     */
+    set up(value) {
+        if (value && value.id !== exports.MovementType.up) {
+            throw new TypeError("Attempting to set the up cursor occurrence to one with different movement type.");
+        }
+        this._up = value;
+    }
+    /**
+     * The time at which this cursor occurrence group starts.
+     */
+    get startTime() {
+        return this._down.time;
+    }
+    /**
+     * The time at which this cursor occurrence group ends.
+     */
+    get endTime() {
+        return this._up?.time ?? this._moves.at(-1)?.time ?? this._down.time;
+    }
+    /**
+     * The duration this cursor occurrence group is active for.
+     */
+    get duration() {
+        return this.endTime - this.startTime;
+    }
+    /**
+     * All cursor occurrences in this group.
+     *
+     * This iterates all occurrences and as such should be used sparingly or stored locally.
+     */
+    get allOccurrences() {
+        const cursors = [this._down, ...this._moves];
+        if (this._up) {
+            cursors.push(this._up);
+        }
+        return cursors;
+    }
+    /**
+     * The cursor occurrence of movement type `movementType.DOWN`.
+     */
+    _down;
+    /**
+     * The cursor occurrences of movement type `movementType.MOVE`.
+     */
+    _moves;
+    /**
+     * The cursor occurrence of movement type `movementType.UP`.
+     *
+     * May not exist, such as when the player holds their cursor until the end of a beatmap.
+     */
+    _up;
+    constructor(down, moves, up) {
+        this._down = down;
+        this._moves = moves;
+        // Re-set down cursor occurrence for checking.
+        this.down = down;
+        this.up = up;
+    }
+    /**
+     * Determines whether this cursor occurrence group is active at the specified time.
+     *
+     * @param time The time.
+     * @returns Whether this cursor occurrence group is active at the specified time.
+     */
+    isActiveAt(time) {
+        return time >= this.startTime && time <= this.endTime;
+    }
+    /**
+     * Finds the cursor occurrence that is active at a given time.
+     *
+     * @param time The time.
+     * @returns The cursor occurrence at the given time, `null` if not found.
+     */
+    cursorAt(time) {
+        if (!this.isActiveAt(time)) {
+            return null;
+        }
+        if (this._down.time === time) {
+            return this._down;
+        }
+        if (this._up?.time === time) {
+            return this._up;
+        }
+        let l = 0;
+        let r = this._moves.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this._moves[pivot].time < time) {
+                l = pivot + 1;
+            }
+            else if (this._moves[pivot].time > time) {
+                r = pivot - 1;
+            }
+            else {
+                return this._moves[pivot];
+            }
+        }
+        // l will be the first cursor occurrence with time > this._moves[l].time, but we want the one before it
+        return this._moves[l - 1];
+    }
 }
 
-/**
- * Represents a cursor instance in an osu!droid replay.
- *
- * Stores cursor movement data in the form of `CursorOccurrenceGroup`s.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class CursorData {
-    /**
-     * The occurrence groups of this cursor instance.
-     */
-    occurrenceGroups = [];
-    /**
-     * The time at which the first occurrence of this cursor instance occurs.
-     *
-     * Will return `null` if there are no occurrences.
-     */
-    get earliestOccurrenceTime() {
-        return this.occurrenceGroups.at(0)?.startTime ?? null;
-    }
-    /**
-     * The time at which the latest occurrence of this cursor instance occurs.
-     *
-     * Will return `null` if there are no occurrences.
-     */
-    get latestOccurrenceTime() {
-        return this.occurrenceGroups.at(-1)?.endTime ?? null;
-    }
-    /**
-     * The amount of cursor occurrences of this cursor instance.
-     */
-    get totalOccurrences() {
-        return this.occurrenceGroups.reduce((a, v) => {
-            // Down cursor.
-            ++a;
-            // Move cursors.
-            a += v.moves.length;
-            if (v.up) {
-                // Up cursor.
-                ++a;
-            }
-            return a;
-        }, 0);
-    }
-    /**
-     * All cursor occurrences of this cursor instnace.
-     *
-     * This iterates all occurrence groups and as such should be used sparingly or stored locally.
-     */
-    get allOccurrences() {
-        return this.occurrenceGroups.flatMap((v) => v.allOccurrences);
-    }
-    constructor(values) {
-        let downOccurrence = null;
-        let moveOccurrences = [];
-        for (let i = 0; i < values.size; ++i) {
-            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
-            switch (occurrence.id) {
-                case exports.movementType.DOWN:
-                    downOccurrence = occurrence;
-                    break;
-                case exports.movementType.MOVE:
-                    moveOccurrences.push(occurrence);
-                    break;
-                case exports.movementType.UP:
-                    if (downOccurrence) {
-                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
-                        downOccurrence = null;
-                    }
-                    moveOccurrences = [];
-            }
-        }
-        // Add the final cursor occurrence group as the loop may not catch it for special cases.
-        if (downOccurrence && moveOccurrences.length > 0) {
-            this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences));
-        }
-    }
+/**
+ * Represents a cursor instance in an osu!droid replay.
+ *
+ * Stores cursor movement data in the form of `CursorOccurrenceGroup`s.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class CursorData {
+    /**
+     * The occurrence groups of this cursor instance.
+     */
+    occurrenceGroups = [];
+    /**
+     * The time at which the first occurrence of this cursor instance occurs.
+     *
+     * Will return `null` if there are no occurrences.
+     */
+    get earliestOccurrenceTime() {
+        return this.occurrenceGroups.at(0)?.startTime ?? null;
+    }
+    /**
+     * The time at which the latest occurrence of this cursor instance occurs.
+     *
+     * Will return `null` if there are no occurrences.
+     */
+    get latestOccurrenceTime() {
+        return this.occurrenceGroups.at(-1)?.endTime ?? null;
+    }
+    /**
+     * The amount of cursor occurrences of this cursor instance.
+     */
+    get totalOccurrences() {
+        return this.occurrenceGroups.reduce((a, v) => {
+            // Down cursor.
+            ++a;
+            // Move cursors.
+            a += v.moves.length;
+            if (v.up) {
+                // Up cursor.
+                ++a;
+            }
+            return a;
+        }, 0);
+    }
+    /**
+     * All cursor occurrences of this cursor instnace.
+     *
+     * This iterates all occurrence groups and as such should be used sparingly or stored locally.
+     */
+    get allOccurrences() {
+        return this.occurrenceGroups.flatMap((v) => v.allOccurrences);
+    }
+    constructor(values) {
+        let downOccurrence = null;
+        let moveOccurrences = [];
+        for (let i = 0; i < values.size; ++i) {
+            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
+            switch (occurrence.id) {
+                case exports.MovementType.down:
+                    downOccurrence = occurrence;
+                    break;
+                case exports.MovementType.move:
+                    moveOccurrences.push(occurrence);
+                    break;
+                case exports.MovementType.up:
+                    if (downOccurrence) {
+                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
+                        downOccurrence = null;
+                    }
+                    moveOccurrences = [];
+            }
+        }
+        // Add the final cursor occurrence group as the loop may not catch it for special cases.
+        if (downOccurrence && moveOccurrences.length > 0) {
+            this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences));
+        }
+    }
 }
 
-/**
- * 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 = {}));
+/**
+ * The result of a hit in an osu!droid replay.
+ */
+exports.HitResult = void 0;
+(function (HitResult) {
+    /**
+     * Miss (0).
+     */
+    HitResult[HitResult["miss"] = 1] = "miss";
+    /**
+     * Meh (50).
+     */
+    HitResult[HitResult["meh"] = 2] = "meh";
+    /**
+     * Good (100).
+     */
+    HitResult[HitResult["good"] = 3] = "good";
+    /**
+     * Great (300).
+     */
+    HitResult[HitResult["great"] = 4] = "great";
+})(exports.HitResult || (exports.HitResult = {}));
 
-/**
- * Represents a replay data in an osu!droid replay.
- *
- * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
- *
- * This is used when analyzing replays using replay analyzer.
- */
-class ReplayData {
-    replayVersion;
-    folderName;
-    fileName;
-    hash;
-    time;
-    hit300k;
-    hit100k;
-    score;
-    maxCombo;
-    accuracy;
-    isFullCombo;
-    playerName;
-    rawMods;
-    rank;
-    convertedMods;
-    cursorMovement;
-    hitObjectData;
-    speedModification;
-    forcedAR;
-    constructor(values) {
-        this.replayVersion = values.replayVersion;
-        this.folderName = values.folderName;
-        this.fileName = values.fileName;
-        this.hash = values.hash;
-        this.time = new Date(values.time || 0);
-        this.hit300k = values.hit300k || 0;
-        this.hit100k = values.hit100k || 0;
-        this.score = values.score || 0;
-        this.maxCombo = values.maxCombo || 0;
-        this.accuracy = values.accuracy || new osuBase.Accuracy({});
-        this.isFullCombo = values.isFullCombo || false;
-        this.playerName = values.playerName || "";
-        this.rawMods = values.rawMods || "";
-        this.rank = values.rank || "";
-        this.convertedMods = values.convertedMods || [];
-        this.cursorMovement = values.cursorMovement;
-        this.hitObjectData = values.hitObjectData;
-        this.speedModification = values.speedModification || 1;
-        this.forcedAR = values.forcedAR;
-    }
+/**
+ * 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 occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    downCursorInstances = [];
-    /**
-     * All cursor occurrences in the replay.
-     *
-     * Each index represents the cursor index.
-     */
-    allCursorInstances;
-    /**
-     * 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;
-        this.allCursorInstances = data.cursorMovement.map((v) => v.allOccurrences);
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym) &&
-                !(m instanceof osuBase.ModPrecise)),
-        }).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.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
-        this.getBeatmapSections();
-        this.detectDragPlay();
-        this.getDetailedBeatmapSections();
-        this.preventAccidentalTaps();
-        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
-        this.calculateNerfFactors();
-        const finalPenalty = this.calculateFinalPenalty();
-        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
-    }
-    /**
-     * 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 validOccurrences = [];
-            for (let j = 0; j < cursorInstance.occurrenceGroups.length; ++j) {
-                const group = cursorInstance.occurrenceGroups[j];
-                if (group.startTime < firstObjectHitTime ||
-                    group.endTime > lastObjectHitTime) {
-                    continue;
-                }
-                if (this.breakPointAccurateTimes.some((v) => group.startTime >= v.startTime &&
-                    group.endTime <= v.endTime)) {
-                    continue;
-                }
-                validOccurrences.push(group.down);
-            }
-            this.downCursorInstances.push(validOccurrences);
-        }
-    }
-    /**
-     * Divides the beatmap into sections, which will be used to
-     * detect dragged sections and improve detection speed.
-     */
-    getBeatmapSections() {
-        const 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.occurrenceGroups.length === 0) {
-                continue;
-            }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
-                v.endTime <= lastObjectMaxHitTime).length === 0) {
-                continue;
-            }
-            // If this cursor instance doesn't move, it's not the cursor instance we want.
-            if (c.occurrenceGroups.filter((v) => v.moves.length > 0).length ===
-                0) {
-                continue;
-            }
-            cursorIndexes.push(i);
-        }
-        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
-    }
-    /**
-     * Finds the drag index of the section.
-     *
-     * @param sectionObjects The objects in the section.
-     * @param sectionReplayObjectData The hitobject data of all objects in the section.
-     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
-     */
-    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
-        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 cursorGroup = c.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
-                if (!cursorGroup) {
-                    continue;
-                }
-                const cursors = cursorGroup.allOccurrences;
-                const nextHitIndex = cursors.findIndex((v) => v.time >= hitTime);
-                const hitIndex = nextHitIndex - 1;
-                if (hitIndex <= -1) {
-                    cursorIndexes[j] = -1;
-                    continue;
-                }
-                const cursorPosition = new osuBase.Vector2(cursors[hitIndex].position.x, cursors[hitIndex].position.y);
-                let isInObject = false;
-                if (cursors[nextHitIndex].id === exports.movementType.MOVE) {
-                    // Try to interpolate movement between two movementType.MOVE cursor every 1ms.
-                    // This minimizes rounding error.
-                    for (let mSecPassed = cursors[hitIndex].time; mSecPassed <= cursors[nextHitIndex].time; ++mSecPassed) {
-                        const t = (mSecPassed - cursors[nextHitIndex].time) /
-                            (cursors[hitIndex].time -
-                                cursors[nextHitIndex].time);
-                        cursorPosition.x = osuBase.Interpolation.lerp(cursors[hitIndex].position.x, cursors[nextHitIndex].position.x, t);
-                        cursorPosition.y = osuBase.Interpolation.lerp(cursors[hitIndex].position.y, cursors[nextHitIndex].position.y, t);
-                        if (o.object
-                            .getStackedPosition(osuBase.modes.droid)
-                            .getDistance(cursorPosition) <=
-                            o.object.getRadius(osuBase.modes.droid)) {
-                            isInObject = true;
-                            break;
-                        }
-                    }
-                }
-                else {
-                    isInObject =
-                        o.object
-                            .getStackedPosition(osuBase.modes.droid)
-                            .getDistance(cursorPosition) <=
-                            o.object.getRadius(osuBase.modes.droid);
-                }
-                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.length > 0).length;
-        if (filledCursorAmount <= 3) {
-            return;
-        }
-        const objects = this.calculator.objects;
-        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.length, 0);
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (filledCursorAmount <= 3) {
-                break;
-            }
-            const cursorInstances = this.downCursorInstances[i];
-            // Use an estimation for accidental tap threshold.
-            if (cursorInstances.length <=
-                Math.ceil(objects.length / this.accidentalTapThreshold) &&
-                cursorInstances.length / totalCursorAmount <
-                    this.threeFingerRatioThreshold * 2) {
-                --filledCursorAmount;
-                cursorInstances.length = 0;
-            }
-            this.downCursorInstances[i] = cursorInstances;
-        }
-    }
-    /**
-     * 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.findIndex((t) => t.time >= startTime);
-                if (i !== -1) {
-                    c = c.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 cursors = this.downCursorInstances[i];
-                let amount = 0;
-                for (let j = 0; j < cursors.length; ++j) {
-                    if (cursors[j].time >= startTime &&
-                        cursors[j].time <= endTime) {
-                        ++amount;
-                        cursorVectorTimes.push({
-                            vector: new osuBase.Vector2(cursors[j].position.x, cursors[j].position.y),
-                            time: cursors[j].time,
-                        });
-                    }
-                }
-                cursorAmounts.push(amount);
-            }
-            // 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 occurrence nested array that only contains `movementType.DOWN` movement ID occurrences.
+     *
+     * Each index represents the cursor index.
+     */
+    downCursorInstances = [];
+    /**
+     * All cursor occurrences in the replay.
+     *
+     * Each index represents the cursor index.
+     */
+    allCursorInstances;
+    /**
+     * 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;
+        this.allCursorInstances = data.cursorMovement.map((v) => v.allOccurrences);
+        const stats = new osuBase.MapStats({
+            od: this.calculator.beatmap.difficulty.od,
+            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        const strainNotes = (calculator.objects).filter((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.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.getBeatmapSections();
+        this.detectDragPlay();
+        this.getDetailedBeatmapSections();
+        this.preventAccidentalTaps();
+        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
+            return { is3Finger: false, penalty: 1 };
+        }
+        this.calculateNerfFactors();
+        const finalPenalty = this.calculateFinalPenalty();
+        return { is3Finger: finalPenalty > 1, penalty: finalPenalty };
+    }
+    /**
+     * 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.great:
+                    beforeIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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.great:
+                    afterIndexHitWindowLength =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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.great:
+                    firstObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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.great:
+                    lastObjectHitWindow =
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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 validOccurrences = [];
+            for (let j = 0; j < cursorInstance.occurrenceGroups.length; ++j) {
+                const group = cursorInstance.occurrenceGroups[j];
+                if (group.startTime < firstObjectHitTime ||
+                    group.endTime > lastObjectHitTime) {
+                    continue;
+                }
+                if (this.breakPointAccurateTimes.some((v) => group.startTime >= v.startTime &&
+                    group.endTime <= v.endTime)) {
+                    continue;
+                }
+                validOccurrences.push(group.down);
+            }
+            this.downCursorInstances.push(validOccurrences);
+        }
+    }
+    /**
+     * Divides the beatmap into sections, which will be used to
+     * detect dragged sections and improve detection speed.
+     */
+    getBeatmapSections() {
+        const 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.great:
+                    firstObjectMinHitTime -=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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.great:
+                    lastObjectMaxHitTime +=
+                        this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    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.occurrenceGroups.length === 0) {
+                continue;
+            }
+            // Do not include cursors that don't have an occurence in this section
+            // this speeds up checking process.
+            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
+                v.endTime <= lastObjectMaxHitTime).length === 0) {
+                continue;
+            }
+            // If this cursor instance doesn't move, it's not the cursor instance we want.
+            if (c.occurrenceGroups.filter((v) => v.moves.length > 0).length ===
+                0) {
+                continue;
+            }
+            cursorIndexes.push(i);
+        }
+        return this.findDragIndex(objects.slice(section.firstObjectIndex, section.lastObjectIndex + 1), objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1), cursorIndexes);
+    }
+    /**
+     * Finds the drag index of the section.
+     *
+     * @param sectionObjects The objects in the section.
+     * @param sectionReplayObjectData The hitobject data of all objects in the section.
+     * @param cursorIndexes The indexes of the cursor instance that has at least an occurrence in the section.
+     */
+    findDragIndex(sectionObjects, sectionReplayObjectData, cursorIndexes) {
+        const isPrecise = this.calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        const hitWindow50 = this.hitWindow.hitWindowFor50(isPrecise);
+        for (let i = 0; i < sectionObjects.length && cursorIndexes.every((v) => v !== -1); ++i) {
+            const object = sectionObjects[i];
+            const objectData = sectionReplayObjectData[i];
+            if (object.object instanceof osuBase.Spinner ||
+                objectData.result === exports.HitResult.miss) {
+                continue;
+            }
+            // Exclude sliderbreaks.
+            if (object.object instanceof osuBase.Slider &&
+                objectData.accuracy === Math.floor(hitWindow50) + 13) {
+                continue;
+            }
+            const objectPosition = object.object.getStackedPosition(osuBase.Modes.droid);
+            const hitTime = object.object.startTime + objectData.accuracy;
+            // Observe the cursor position at the object's hit time.
+            for (let j = 0; j < cursorIndexes.length; ++j) {
+                if (cursorIndexes[j] === -1) {
+                    continue;
+                }
+                const cursorData = this.data.cursorMovement[cursorIndexes[j]];
+                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
+                if (!cursorGroup) {
+                    continue;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    if (prevCursor.time <
+                        object.object.startTime - hitWindow50) {
+                        continue;
+                    }
+                    if (prevCursor.time >
+                        object.object.startTime + hitWindow50) {
+                        break;
+                    }
+                    let isInObject = false;
+                    switch (cursor.id) {
+                        case exports.MovementType.up:
+                            isInObject =
+                                prevCursor.position.getDistance(objectPosition) <= object.object.getRadius(osuBase.Modes.droid);
+                            break;
+                        case exports.MovementType.move:
+                            // Interpolate movement.
+                            for (let mSecPassed = prevCursor.time; !isInObject &&
+                                mSecPassed <=
+                                    Math.min(cursor.time, object.object.startTime + hitWindow50); ++mSecPassed) {
+                                const t = (mSecPassed - prevCursor.time) /
+                                    (cursor.time - prevCursor.time);
+                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                                isInObject =
+                                    objectPosition.getDistance(cursorPosition) <= object.object.getRadius(osuBase.Modes.droid);
+                            }
+                    }
+                    if (!isInObject) {
+                        cursorIndexes[j] = -1;
+                    }
+                }
+            }
+        }
+        return cursorIndexes.find((v) => v !== -1) ?? -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.length > 0).length;
+        if (filledCursorAmount <= 3) {
+            return;
+        }
+        const objects = this.calculator.objects;
+        const totalCursorAmount = this.downCursorInstances.reduce((acc, value) => acc + value.length, 0);
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            if (filledCursorAmount <= 3) {
+                break;
+            }
+            const cursorInstances = this.downCursorInstances[i];
+            // Use an estimation for accidental tap threshold.
+            if (cursorInstances.length <=
+                Math.ceil(objects.length / this.accidentalTapThreshold) &&
+                cursorInstances.length / totalCursorAmount <
+                    this.threeFingerRatioThreshold * 2) {
+                --filledCursorAmount;
+                cursorInstances.length = 0;
+            }
+            this.downCursorInstances[i] = cursorInstances;
+        }
+    }
+    /**
+     * 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.miss
+                    ? objectData[beatmapSection.firstObjectIndex].accuracy
+                    : -this.hitWindow.hitWindowFor50(isPrecise));
+            const endTime = objects[beatmapSection.lastObjectIndex].object.endTime +
+                (objectData[beatmapSection.lastObjectIndex].result !==
+                    exports.HitResult.miss
+                    ? objectData[beatmapSection.lastObjectIndex].accuracy
+                    : this.hitWindow.hitWindowFor50(isPrecise));
+            const cursorAmounts = [];
+            const cursorVectorTimes = [];
+            for (let i = 0; i < this.downCursorInstances.length; ++i) {
+                // Do not include drag cursor instance.
+                if (i === dragIndex) {
+                    continue;
+                }
+                const cursors = this.downCursorInstances[i];
+                let amount = 0;
+                for (let j = 0; j < cursors.length; ++j) {
+                    if (cursors[j].time >= startTime &&
+                        cursors[j].time <= endTime) {
+                        ++amount;
+                        cursorVectorTimes.push({
+                            vector: new osuBase.Vector2(cursors[j].position.x, cursors[j].position.y),
+                            time: cursors[j].time,
+                        });
+                    }
+                }
+                cursorAmounts.push(amount);
+            }
+            // 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 >
+                    fingerSplitIndex) ||
+                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 cursor index that hits the hitobject.
+     *
+     * If -1, the detection was unable to find any cursor that attempted to hit
+     * the hitobject or it did not meet the criteria for detection.
+     */
+    cursorIndex;
+    /**
+     * The group index of the cursor within the cursor index that hits the hitobject.
+     *
+     * If -1, the detection was unable to find any cursor that attempted to hit
+     * the hitobject or it did not meet the criteria for detection.
+     */
+    groupIndex;
+    /**
+     * The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
+     *
+     * If -1, the detection was unable to find any cursor that attempted to hit
+     * the hitobject or it did not meet the criteria for detection.
+     */
+    occurrenceIndex;
+    /**
+     * The angle of the movement of the cursor towards the next hitobject.
+     */
+    angle;
+    /**
+     * If this is a slider, whether the slider was cheesed.
+     */
+    sliderCheesed = false;
+    /**
+     * The underlying difficulty hitobject.
+     */
+    object;
+    /**
+     * The position of the cursor at the end of this hitobject.
+     *
+     * Will be altered during detection.
+     */
+    endCursorPosition;
+    /**
+     * Whether the hitobject is likely two-handed.
+     */
+    is2Handed;
+    /**
+     * @param object The underlying difficulty hitobject.
+     * @param cursorIndex The cursor index that moves towards the hitobject.
+     * @param groupIndex The group index of the cursor within the cursor index that hits the hitobject.
+     * @param occurrenceIndex The occurrence index within the group of the cursor within the cursor index that hits the hitobject.
+     * @param angle The angle of the movement of the cursor that moves towards the hitobject.
+     */
+    constructor(object, cursorIndex, groupIndex, occurrenceIndex, angle, is2Handed) {
+        this.object = object;
+        this.cursorIndex = cursorIndex;
+        this.groupIndex = groupIndex;
+        this.occurrenceIndex = occurrenceIndex;
+        this.angle = angle;
+        this.is2Handed = is2Handed;
+        this.endCursorPosition = this.object.object.getStackedEndPosition(osuBase.Modes.droid);
+    }
 }
 
-/**
- * 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;
-    /**
-     * A cursor occurrence nested array containing all cursor occurrences.
-     *
-     * Each index represents the cursor index.
-     */
-    // TODO: replace with group at some point
-    allCursorOccurrences = [];
-    /**
-     * @param calculator The difficulty calculator to analyze.
-     * @param data The data of the replay.
-     */
-    constructor(calculator, data) {
-        this.calculator = calculator;
-        this.data = data;
-        this.allCursorOccurrences = data.cursorMovement.map((v) => v.allOccurrences);
-        const stats = new osuBase.MapStats({
-            od: this.calculator.beatmap.difficulty.od,
-            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
-                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym) &&
-                !(m instanceof osuBase.ModPrecise)),
-        }).calculate();
-        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
-    }
-    /**
-     * Checks if a beatmap is two-handed.
-     */
-    check() {
-        if (this.data.cursorMovement.filter((v) => v.occurrenceGroups.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.occurrenceGroups.length; ++j) {
-                const group = c.occurrenceGroups[j];
-                const previousGroup = c.occurrenceGroups[j - 1];
-                if (group.startTime <
-                    this.calculator.beatmap.hitObjects.objects[0].startTime -
-                        this.hitWindow.hitWindowFor50()) {
-                    continue;
-                }
-                const deltaTime = group.startTime - previousGroup.endTime;
-                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.allCursorOccurrences.length; ++i) {
-            const c = this.allCursorOccurrences[i];
-            if (c.length === 0) {
-                continue;
-            }
-            let hitTimeBeforeIndex = osuBase.MathUtils.clamp(c.findIndex((v) => v.time >= minimumHitTime), 1, c.length - 1) - 1;
-            let hitTimeAfterIndex = c.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.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[hitTimeBeforeIndex]?.time ===
-                c[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[j];
-                const nextOccurrence = c[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
-                            .getStackedPosition(osuBase.modes.droid)
-                            .getDistance(cursorPosition));
-                    }
-                    break;
-                }
-                if (occurrence.id === exports.movementType.UP) {
-                    continue;
-                }
-                distance = object.object
-                    .getStackedPosition(osuBase.modes.droid)
-                    .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
-                            .getStackedPosition(osuBase.modes.droid)
-                            .getDistance(cursorPosition.add(displacement.scale(progress)));
-                    }
-                }
-            }
-            if (distance > object.object.getRadius(osuBase.modes.droid)) {
-                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[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[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[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[j] &&
-            //     c[nextSignificantOccurrenceIndex] &&
-            //     c[j].position.equals(
-            //         c[nextSignificantOccurrenceIndex].position
-            //     )
-            // ) {
-            //     ++nextSignificantOccurrenceIndex;
-            // }
-            // const nextSignificantOccurrence: CursorOccurrence =
-            //     c[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.getStackedPosition(modes.droid).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[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.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.getStackedPosition(osuBase.modes.droid)) <= object.object.getRadius(osuBase.modes.droid) &&
-                    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.allCursorOccurrences[indexedHitObject.actualCursorIndex];
-        const acceptableRadius = indexedHitObject.object.object.getRadius(osuBase.modes.droid) * 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.length; ++j) {
-                if (c[j].time < object.startTime - hitWindowOffset) {
-                    continue;
-                }
-                if (c[j].time > object.startTime + hitWindowOffset) {
-                    break;
-                }
-                if (c[j].position.getDistance(object.getStackedPosition(osuBase.modes.droid)) <= 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();
-    }
+// import { writeFileSync } from "fs";
+/**
+ * Utility to check whether or not a beatmap is two-handed.
+ */
+class TwoHandChecker {
+    /**
+     * The difficulty calculator that is being analyzed.
+     */
+    calculator;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The hitobjects of the beatmap that have been assigned with their respective cursor index.
+     */
+    indexedHitObjects = [];
+    /**
+     * The osu!droid hitwindow of the analyzed beatmap.
+     */
+    hitWindow;
+    /**
+     * The 50 osu!droid hit window of the analyzed beatmap.
+     */
+    hitWindow50;
+    // private csvString: string;
+    /**
+     * @param calculator The difficulty calculator to analyze.
+     * @param data The data of the replay.
+     */
+    constructor(calculator, data) {
+        this.calculator = calculator;
+        this.data = data;
+        const stats = new osuBase.MapStats({
+            od: this.calculator.beatmap.difficulty.od,
+            mods: this.calculator.mods.filter((m) => m.isApplicableToDroid() &&
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+        // this.csvString = `Mods,${
+        //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
+        // }\nCombo,${data.maxCombo}\nAccuracy,"${(
+        //     data.accuracy.value() * 100
+        // ).toFixed(2)}% [${data.accuracy.n300}/${data.accuracy.n100}/${
+        //     data.accuracy.n50
+        // }/${
+        //     data.accuracy.nmiss
+        // }]"\n\nIndex,Type,StartTime,EndTime,DeltaTime,CursorIndex,GroupIndex,CursorDuration\n`;
+    }
+    /**
+     * Checks if a beatmap is two-handed.
+     */
+    check() {
+        if (this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 1) {
+            return { is2Hand: false, twoHandedNoteCount: 0 };
+        }
+        this.indexHitObjects();
+        // this.applyPenalty();
+        // for (let i = 0; i < this.calculator.objects.length; ++i) {
+        //     const object: PlaceableHitObject =
+        //         this.calculator.objects[i].object;
+        //     if (object instanceof Spinner) {
+        //         continue;
+        //     }
+        //     let deltaTime: number = 0;
+        //     if (i > 0) {
+        //         const prevObject: PlaceableHitObject =
+        //             this.calculator.objects[i - 1].object;
+        //         deltaTime = Math.max(
+        //             object.startTime - prevObject.startTime,
+        //             25
+        //         );
+        //         if (prevObject instanceof Slider) {
+        //             deltaTime = Math.max(
+        //                 deltaTime - prevObject.lazyTravelTime,
+        //                 25
+        //             );
+        //         }
+        //     }
+        //     const objectInfo = this.getCursorPositionForObjectStart(i);
+        //     this.csvString += `${i},${object.typeStr()},${object.startTime},${
+        //         object instanceof Slider
+        //             ? object.startTime + object.lazyTravelTime
+        //             : object.endTime
+        //     },${deltaTime},${objectInfo.cursorIndex},${objectInfo.groupIndex},${
+        //         this.data.cursorMovement[objectInfo.cursorIndex]
+        //             ?.occurrenceGroups[objectInfo.groupIndex]?.duration ??
+        //         Number.POSITIVE_INFINITY
+        //     }\n`;
+        // }
+        // writeFileSync(
+        //     join(
+        //         process.cwd(),
+        //         "files",
+        //         `${this.data.playerName} - ${this.calculator.beatmap.metadata.fullTitle}.csv`
+        //     ),
+        //     this.csvString
+        // );
+        let twoHandedNoteCount = 0;
+        const maxStrain = Math.max(...this.calculator.objects.map((v) => v.aimStrainWithSliders));
+        if (maxStrain) {
+            twoHandedNoteCount = this.indexedHitObjects.reduce((total, object) => {
+                if (!object.is2Handed) {
+                    return total;
+                }
+                return (total +
+                    1 /
+                        (1 +
+                            Math.exp(-((object.object.aimStrainWithSliders /
+                                maxStrain) *
+                                12 -
+                                6))));
+            }, 0);
+        }
+        return {
+            is2Hand: twoHandedNoteCount >
+                this.calculator.attributes.aimNoteCount * 0.15,
+            twoHandedNoteCount: twoHandedNoteCount,
+        };
+    }
+    /**
+     * Converts hitobjects into indexed hit objects.
+     */
+    indexHitObjects() {
+        const indexes = [];
+        for (let i = 0; i < this.calculator.objects.length; ++i) {
+            const indexedHitObject = this.getIndexedHitObject(i);
+            indexedHitObject.sliderCheesed = this.checkSliderCheesing(indexedHitObject, this.data.hitObjectData[i]);
+            indexes.push(indexedHitObject.cursorIndex);
+            this.indexedHitObjects.push(indexedHitObject);
+        }
+        // console.log("Aim note count:", this.calculator.attributes.aimNoteCount);
+        // console.log(
+        //     this.indexedHitObjects.filter((v) => v.cursorIndex !== -1).length +
+        //         1,
+        //     "indexes found,",
+        //     this.indexedHitObjects.filter((v) => v.cursorIndex === -1).length -
+        //         1,
+        //     "not found,",
+        //     this.indexedHitObjects.filter((v) => v.is2Handed).length,
+        //     "2 handed,",
+        //     this.indexedHitObjects.filter((v) => !v.is2Handed).length,
+        //     "not 2 handed"
+        // );
+        // for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+        //     console.log(
+        //         "Index",
+        //         i,
+        //         "count:",
+        //         this.indexedHitObjects.filter((v) => v.cursorIndex === i).length
+        //     );
+        // }
+        // TODO: solve -1 cursor indexes
+        // console.table(
+        //     this.indexedHitObjects
+        //         .filter(
+        //             (v) =>
+        //                 // v.cursorIndex === -1 &&
+        //                 // v.object.aimStrainWithSliders > 200 &&
+        //                 v.object.deltaTime > 75 && v.is2Handed
+        //         )
+        //         .map((v) => {
+        //             return {
+        //                 startTime: v.object.object.startTime,
+        //                 type: v.object.object.typeStr(),
+        //                 strain: v.object.aimStrainWithSliders,
+        //                 hitAngle:
+        //                     v.angle !== null
+        //                         ? MathUtils.radiansToDegrees(v.angle)
+        //                         : null,
+        //                 objectAngle:
+        //                     v.object.angle !== null
+        //                         ? MathUtils.radiansToDegrees(v.object.angle)
+        //                         : null,
+        //                 cursorIndex: v.cursorIndex,
+        //             };
+        //         })
+        // );
+    }
+    /**
+     * Gets the cursor index that hits the given object.
+     *
+     * @param objectIndex The index of the object to check.
+     * @returns The cursor index that hits the given object, -1 if the index is not found, the object is a spinner, or the object was missed.
+     */
+    getIndexedHitObject(objectIndex) {
+        const diffObject = this.calculator.objects[objectIndex];
+        const { object } = diffObject;
+        // We don't care about the first object and spinners.
+        if (objectIndex === 0 || object instanceof osuBase.Spinner) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        // We don't care if the aim strain is too low.
+        // if (diffObject.aimStrainWithSliders < 200) {
+        //     return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        // }
+        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        const prevObjectData = this.data.hitObjectData[objectIndex - 1];
+        if (prevObject instanceof osuBase.Spinner ||
+            prevObjectData.result === exports.HitResult.miss) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
+        let prevObjectEndPosition = prevObject.getStackedEndPosition(osuBase.Modes.droid);
+        if (prevObject instanceof osuBase.Slider) {
+            if (prevObject.lazyTravelDistance > 0) {
+                const lazyEndMovement = objectStartPosition.subtract(prevObject.lazyEndPosition);
+                const actualEndMovement = objectStartPosition.subtract(prevObjectEndPosition);
+                if (lazyEndMovement.length < actualEndMovement.length) {
+                    prevObjectEndPosition = prevObject.lazyEndPosition;
+                }
+            }
+            else {
+                prevObjectEndPosition = prevObject.getStackedPosition(osuBase.Modes.droid);
+            }
+        }
+        const prevToCurrentMovement = object
+            .getStackedPosition(osuBase.Modes.droid)
+            .subtract(prevObjectEndPosition);
+        const radius = object.getRadius(osuBase.Modes.droid);
+        // Don't consider objects that are too close to each other.
+        if (prevToCurrentMovement.length <= radius) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        // The case for a one-handed object is that there will be a slight movement in the cursor towards
+        // 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 current
+        // object is sufficient enough to be two-handed. This is done by first gathering info about two cursor positions:
+        // 1. The cursor position at the end of the previous object
+        // 2. The cursor position that presses the current object
+        // and then get the movement vector between both positions, then see if the cursor movement after the previous object
+        // was pressed produces an angle that is acute enough with respect to the aforementioned movement vector.
+        // If the angle isn't fulfilled, check for the "initial velocity", which is the movement velocity from the
+        // previous object's end time to the current object's start time and the "air velocity", which is the
+        // velocity from the previous object's cursor release time to the next object's cursor press time. If the velocity
+        // during the held tap is significantly less than the estimated velocity, it's considered two hand.
+        const objectInformation = this.getCursorPositionForObjectStart(objectIndex);
+        const prevObjectInformation = this.getCursorPositionForObjectEnd(objectIndex - 1);
+        this.indexedHitObjects[objectIndex - 1].endCursorPosition =
+            prevObjectInformation.position;
+        if (prevObjectInformation.position.x === Number.POSITIVE_INFINITY) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        if (prevObjectInformation.cursorIndex ===
+            objectInformation.cursorIndex &&
+            prevObjectInformation.groupIndex === objectInformation.groupIndex) {
+            return new IndexedHitObject(diffObject, objectInformation.cursorIndex, objectInformation.groupIndex, prevObjectInformation.occurrenceIndex, 0, false);
+        }
+        const cursorData = this.data.cursorMovement[prevObjectInformation.cursorIndex];
+        // There can be multiple angles to which the cursor moves towards the next object.
+        // For this, we take the smallest angle.
+        let finalAngle = Number.POSITIVE_INFINITY;
+        const cursorGroup = cursorData.occurrenceGroups[prevObjectInformation.groupIndex];
+        const cursors = cursorGroup.allOccurrences;
+        const prevToCurrentCursorMovement = objectInformation.position.subtract(prevObjectInformation.position);
+        for (let i = prevObjectInformation.occurrenceIndex + 1; i < cursors.length; ++i) {
+            const cursor = cursors[i];
+            const prevCursor = cursors[i - 1];
+            if (cursor.position.equals(prevCursor.position)) {
+                continue;
+            }
+            if (cursor.id === exports.MovementType.up) {
+                break;
+            }
+            const currentMovement = cursor.position.subtract(prevCursor.position);
+            const dot = prevToCurrentCursorMovement.dot(currentMovement);
+            const det = prevToCurrentCursorMovement.x * currentMovement.y -
+                prevToCurrentCursorMovement.y * currentMovement.x;
+            const movementAngle = Math.abs(Math.atan2(det, dot));
+            finalAngle = Math.min(finalAngle, movementAngle);
+        }
+        const is2Handed = finalAngle >= Math.PI / 6;
+        // if (is2Handed) {
+        //     // If angle isn't fulfilled, check for cursor velocity.
+        //     let deltaTime: number = Math.max(
+        //         object.startTime - prevObject.startTime,
+        //         25
+        //     );
+        //     if (prevObject instanceof Slider) {
+        //         deltaTime = Math.max(deltaTime - prevObject.lazyTravelTime, 25);
+        //     }
+        //     // "Initial velocity" is the movement velocity from the previous object's end time to the current object's start time.
+        //     const initialVelocity: number =
+        //         objectStartPosition.getDistance(prevObjectEndPosition) /
+        //         deltaTime;
+        //     // const finalCursor: CursorOccurrence =
+        //     //     cursorGroup.moves.at(-1) ?? cursorGroup.down;
+        //     const currentCursorGroup: CursorOccurrenceGroup =
+        //         this.data.cursorMovement[objectInformation.cursorIndex]
+        //             .occurrenceGroups[objectInformation.groupIndex];
+        //     // const cursorDistance: number = currentCursorGroup.down.position.getDistance(
+        //     //     finalCursor.position
+        //     // );
+        //     const cursorDuration: number = Math.max(
+        //         0,
+        //         currentCursorGroup.startTime - cursorGroup.endTime
+        //     );
+        //     // "Air velocity" is the cursor velocity from the moment the previous cursor release action to the next cursor press action.
+        //     // const airVelocity: number = cursorDistance / cursorDuration;
+        //     is2Handed =
+        //         // airVelocity / initialVelocity < 0.8 &&
+        //         cursorDuration / deltaTime > 0.2;
+        //     for (
+        //         let i = prevObjectInformation.occurrenceIndex + 1;
+        //         i < cursors.length && is2Handed;
+        //         ++i
+        //     ) {
+        //         const cursor: CursorOccurrence = cursors[i];
+        //         const prevCursor: CursorOccurrence = cursors[i - 1];
+        //         if (
+        //             cursor.position.equals(prevCursor.position) ||
+        //             cursor.time === prevCursor.time
+        //         ) {
+        //             continue;
+        //         }
+        //         if (cursor.id === MovementType.up) {
+        //             break;
+        //         }
+        //         // "Cursor velocity" is the velocity from the previous object's cursor release time to the current object's press time.
+        //         const cursorVelocity: number =
+        //             cursor.position.getDistance(prevCursor.position) /
+        //             (cursor.time - prevCursor.time);
+        //         is2Handed = cursorVelocity / initialVelocity < 0.8;
+        //     }
+        // }
+        if (!Number.isFinite(finalAngle)) {
+            return new IndexedHitObject(diffObject, -1, -1, -1, null, false);
+        }
+        return new IndexedHitObject(diffObject, prevObjectInformation.cursorIndex, prevObjectInformation.groupIndex, prevObjectInformation.occurrenceIndex, finalAngle, is2Handed);
+    }
+    /**
+     * Gets the position of the cursor that presses an object.
+     *
+     * @param objectIndex THe index of the object.
+     * @returns The position of the cursor that presses the object.
+     */
+    getCursorPositionForObjectStart(objectIndex) {
+        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        const data = this.data.hitObjectData[objectIndex];
+        const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+        if (object instanceof osuBase.Spinner) {
+            return {
+                position: objectPosition,
+                cursorIndex: 0,
+                groupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.startTime,
+            };
+        }
+        const radius = object.getRadius(osuBase.Modes.droid);
+        let hitWindow = this.hitWindow50;
+        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        // For sliders, set the hit window to as lenient as possible.
+        if (object instanceof osuBase.Circle) {
+            switch (data.result) {
+                case exports.HitResult.great:
+                    hitWindow = this.hitWindow.hitWindowFor300(isPrecise);
+                    break;
+                case exports.HitResult.good:
+                    hitWindow = this.hitWindow.hitWindowFor100(isPrecise);
+                    break;
+            }
+        }
+        // TODO: what to do for head sliderbreaks?
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestCursorIndex = 0;
+        let nearestGroupIndex = 0;
+        let nearestCursorGroupIndex = 0;
+        let nearestCursorTime = 0;
+        const minimumActiveTime = object.startTime - hitWindow;
+        const maximumActiveTime = object.startTime + hitWindow;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            if (nearestPosition.getDistance(objectPosition) <= radius) {
+                break;
+            }
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
+                if (nearestPosition.getDistance(objectPosition) <= radius) {
+                    break;
+                }
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < minimumActiveTime) {
+                    continue;
+                }
+                if (cursorGroup.startTime > maximumActiveTime) {
+                    break;
+                }
+                // Validate the down press first.
+                const { down } = cursorGroup;
+                if (down.position.getDistance(objectPosition) <= radius &&
+                    Math.abs(down.time - object.startTime) <= hitWindow) {
+                    if (objectIndex > 0) {
+                        const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+                        if (down.time > prevObject.endTime) {
+                            return {
+                                position: down.position,
+                                cursorIndex: i,
+                                groupIndex: j,
+                                occurrenceIndex: 0,
+                                cursorTime: down.time,
+                            };
+                        }
+                    }
+                    else {
+                        return {
+                            position: down.position,
+                            cursorIndex: i,
+                            groupIndex: j,
+                            occurrenceIndex: 0,
+                            cursorTime: down.time,
+                        };
+                    }
+                }
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 1; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    if (cursor.time < minimumActiveTime) {
+                        continue;
+                    }
+                    if (prevCursor.time > maximumActiveTime) {
+                        break;
+                    }
+                    let cursorPosition;
+                    if (cursor.id === exports.MovementType.up) {
+                        cursorPosition = prevCursor.position;
+                        const distance = cursorPosition.getDistance(objectPosition);
+                        if (distance <
+                            nearestPosition.getDistance(objectPosition)) {
+                            nearestPosition = cursorPosition;
+                            nearestCursorIndex = i;
+                            nearestGroupIndex = j;
+                            nearestCursorGroupIndex = k;
+                            nearestCursorTime = prevCursor.time;
+                        }
+                    }
+                    else {
+                        // Check for cursor presses inbetween occurrences.
+                        for (let k = 0; k < this.data.cursorMovement.length; ++k) {
+                            // Skip the current cursor index.
+                            if (k === i) {
+                                continue;
+                            }
+                            const cursorGroup = this.data.cursorMovement[k].occurrenceGroups.find((v) => v.down.time >= prevCursor.time &&
+                                v.down.time <= cursor.time);
+                            if (!cursorGroup) {
+                                continue;
+                            }
+                            const t = (cursorGroup.down.time - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            const distance = cursorPosition.getDistance(objectPosition);
+                            if (distance <
+                                nearestPosition.getDistance(objectPosition)) {
+                                nearestPosition = cursorPosition;
+                                nearestCursorIndex = i;
+                                nearestGroupIndex = j;
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = cursorGroup.down.time;
+                            }
+                            if (distance <= radius) {
+                                break;
+                            }
+                        }
+                    }
+                    if (nearestPosition.getDistance(objectPosition) <= radius) {
+                        break;
+                    }
+                }
+            }
+        }
+        if (nearestPosition.getDistance(objectPosition) ===
+            Number.POSITIVE_INFINITY) {
+            return {
+                position: nearestPosition,
+                cursorIndex: Number.POSITIVE_INFINITY,
+                groupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.startTime,
+            };
+        }
+        return {
+            position: nearestPosition,
+            cursorIndex: nearestCursorIndex,
+            groupIndex: nearestGroupIndex,
+            occurrenceIndex: nearestCursorGroupIndex,
+            cursorTime: nearestCursorTime,
+        };
+    }
+    /**
+     * Gets the position of the cursor that at an object's end position.
+     *
+     * @param objectIndex THe index of the object.
+     * @returns The position of the cursor at the object's end position.
+     */
+    getCursorPositionForObjectEnd(objectIndex) {
+        const object = this.calculator.beatmap.hitObjects.objects[objectIndex];
+        if (!(object instanceof osuBase.Slider)) {
+            return this.getCursorPositionForObjectStart(objectIndex);
+        }
+        const nextObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
+        let objectEndPosition = object.getStackedEndPosition(osuBase.Modes.droid);
+        if (object.lazyTravelDistance > 0 && nextObject) {
+            const nextStartPosition = nextObject.getStackedPosition(osuBase.Modes.droid);
+            const lazyEndMovement = nextStartPosition.subtract(object.lazyEndPosition);
+            const actualEndMovement = nextStartPosition.subtract(objectEndPosition);
+            if (lazyEndMovement.length < actualEndMovement.length) {
+                objectEndPosition = object.lazyEndPosition;
+            }
+        }
+        else {
+            objectEndPosition = object.getStackedPosition(osuBase.Modes.droid);
+        }
+        let nearestPosition = new osuBase.Vector2(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        let nearestCursorIndex = 0;
+        let nearestGroupIndex = 0;
+        let nearestCursorGroupIndex = 0;
+        let nearestCursorTime = 0;
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = 0; j < cursorData.occurrenceGroups.length; ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < object.startTime) {
+                    continue;
+                }
+                if (cursorGroup.startTime > object.endTime) {
+                    break;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = 0; k < cursors.length; ++k) {
+                    const cursor = cursors[k];
+                    let cursorPosition;
+                    switch (cursor.id) {
+                        case exports.MovementType.down:
+                            cursorPosition = cursor.position;
+                            break;
+                        case exports.MovementType.up: {
+                            const prevCursor = cursors[k - 1];
+                            cursorPosition = prevCursor.position;
+                            break;
+                        }
+                        case exports.MovementType.move: {
+                            const prevCursor = cursors[k - 1];
+                            const t = osuBase.MathUtils.clamp((object.endTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time), 0, 1);
+                            cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
+                            break;
+                        }
+                    }
+                    if (cursorPosition.getDistance(objectEndPosition) <
+                        nearestPosition.getDistance(objectEndPosition)) {
+                        nearestPosition = cursorPosition;
+                        nearestCursorIndex = i;
+                        nearestGroupIndex = j;
+                        switch (cursor.id) {
+                            case exports.MovementType.down:
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = cursor.time;
+                                break;
+                            case exports.MovementType.up:
+                                nearestCursorGroupIndex = k - 1;
+                                nearestCursorTime = cursors[k - 1].time;
+                                break;
+                            case exports.MovementType.move:
+                                nearestCursorGroupIndex = k;
+                                nearestCursorTime = object.endTime;
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+        if (nearestPosition.getDistance(objectEndPosition) ===
+            Number.POSITIVE_INFINITY) {
+            return {
+                position: nearestPosition,
+                cursorIndex: Number.POSITIVE_INFINITY,
+                groupIndex: Number.POSITIVE_INFINITY,
+                occurrenceIndex: Number.POSITIVE_INFINITY,
+                cursorTime: object.endTime,
+            };
+        }
+        return {
+            position: nearestPosition,
+            cursorIndex: nearestCursorIndex,
+            groupIndex: nearestGroupIndex,
+            occurrenceIndex: nearestCursorGroupIndex,
+            cursorTime: nearestCursorTime,
+        };
+    }
+    /**
+     * 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.
+     * @returns Whether the slider was cheesed.
+     */
+    checkSliderCheesing(indexedHitObject, hitData) {
+        if (!(indexedHitObject.object.object instanceof osuBase.Slider) ||
+            hitData.result === exports.HitResult.miss ||
+            indexedHitObject.cursorIndex === -1) {
+            return false;
+        }
+        return false;
+    }
 }
 
-/**
- * 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 = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(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;
-    }
-    /**
-     * 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;
-    }
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed.
+ */
+class SliderCheeseChecker {
+    /**
+     * The difficulty calculator that is being analyzed.
+     */
+    calculator;
+    /**
+     * The data of the replay.
+     */
+    data;
+    /**
+     * The osu!droid hitwindow of the analyzed beatmap.
+     */
+    hitWindow;
+    /**
+     * The 50 osu!droid hit window of the analyzed beatmap.
+     */
+    hitWindow50;
+    /**
+     * The indexes of objects that were cheesed.
+     */
+    cheesedObjectIndexes = [];
+    /**
+     * @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) => m.isApplicableToDroid() &&
+                !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+        }).calculate();
+        this.hitWindow = new osuBase.DroidHitWindow(stats.od);
+        this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+    }
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     *
+     * Returns a number that can be passed to a `DroidPerformanceCalculator`
+     * to alter the aim performance value.
+     */
+    check() {
+        if (this.calculator.attributes.sliderCount === 0) {
+            return {
+                aimPenalty: 1,
+                flashlightPenalty: 1,
+                visualPenalty: 1,
+            };
+        }
+        this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty();
+    }
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    checkSliderCheesing() {
+        // Current loop indexes are stored for efficiency.
+        const cursorLoopIndexes = osuBase.Utils.initializeArray(10, 0);
+        const acceptableRadius = this.calculator.objects[0].object.getRadius(osuBase.Modes.droid) * 2;
+        for (let i = 0; i < this.calculator.objects.length; ++i) {
+            const diffObject = this.calculator.objects[i];
+            const { object } = diffObject;
+            if (diffObject.travelDistance === 0 ||
+                !(object instanceof osuBase.Slider)) {
+                continue;
+            }
+            const objectStartPosition = object.getStackedPosition(osuBase.Modes.droid);
+            const objectData = this.data.hitObjectData[i];
+            // If a slider break occurs, we disregard the check for that slider.
+            if (objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+                continue;
+            }
+            let isCheesed = false;
+            for (let j = 0; j < this.data.cursorMovement.length; ++j) {
+                if (isCheesed) {
+                    break;
+                }
+                const cursorGroups = this.data.cursorMovement[j].occurrenceGroups;
+                for (let k = cursorLoopIndexes[j]; k < cursorGroups.length; k = ++cursorLoopIndexes[j]) {
+                    const group = cursorGroups[k];
+                    if (group.startTime < object.startTime - this.hitWindow50) {
+                        continue;
+                    }
+                    if (group.startTime > object.startTime + this.hitWindow50) {
+                        break;
+                    }
+                    if (group.down.position.getDistance(objectStartPosition) >
+                        acceptableRadius) {
+                        continue;
+                    }
+                    // Track cursor movement to see if it lands on every tick.
+                    let occurrenceLoopIndex = 1;
+                    let isSliderFulfilled = true;
+                    const { allOccurrences } = group;
+                    for (let l = 1; l < object.nestedHitObjects.length; ++l) {
+                        if (!isSliderFulfilled) {
+                            break;
+                        }
+                        const tickWasHit = objectData.tickset[l - 1];
+                        if (!tickWasHit) {
+                            continue;
+                        }
+                        const nestedObject = object.nestedHitObjects[l];
+                        const nestedPosition = nestedObject.getStackedPosition(osuBase.Modes.droid);
+                        while (occurrenceLoopIndex < allOccurrences.length &&
+                            allOccurrences[occurrenceLoopIndex].time <
+                                nestedObject.startTime) {
+                            ++occurrenceLoopIndex;
+                        }
+                        if (occurrenceLoopIndex === allOccurrences.length) {
+                            continue;
+                        }
+                        const occurrence = allOccurrences[occurrenceLoopIndex];
+                        const prevOccurrence = allOccurrences[occurrenceLoopIndex - 1];
+                        switch (occurrence.id) {
+                            case exports.MovementType.move: {
+                                // Interpolate cursor position during nested object time.
+                                const t = (nestedObject.startTime -
+                                    prevOccurrence.time) /
+                                    (occurrence.time - prevOccurrence.time);
+                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevOccurrence.position.x, occurrence.position.x, t), osuBase.Interpolation.lerp(prevOccurrence.position.y, occurrence.position.y, t));
+                                const distance = cursorPosition.getDistance(nestedPosition);
+                                if (distance > acceptableRadius) {
+                                    isSliderFulfilled = false;
+                                }
+                                break;
+                            }
+                            case exports.MovementType.up:
+                                if (prevOccurrence.position.getDistance(nestedPosition) > acceptableRadius) {
+                                    isSliderFulfilled = false;
+                                    break;
+                                }
+                        }
+                    }
+                    if (!isSliderFulfilled) {
+                        isCheesed = true;
+                        break;
+                    }
+                }
+            }
+            if (isCheesed) {
+                this.cheesedObjectIndexes.push(i);
+            }
+        }
+    }
+    /**
+     * Calculates the slider cheese penalty.
+     */
+    calculateSliderCheesePenalty() {
+        let calculator;
+        if (this.calculator instanceof osuDifficultyCalculator.DroidDifficultyCalculator) {
+            calculator = new osuDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
+        }
+        else {
+            calculator = new osuRebalanceDifficultyCalculator.DroidDifficultyCalculator(this.calculator.beatmap);
+        }
+        Object.assign(calculator.attributes, this.calculator.attributes);
+        calculator.stats = this.calculator.stats;
+        calculator.generateDifficultyHitObjects();
+        for (const index of this.cheesedObjectIndexes) {
+            calculator.objects[index].travelDistance = 0;
+        }
+        calculator.calculateAll();
+        return {
+            aimPenalty: this.calculator.aim / calculator.aim,
+            flashlightPenalty: this.calculator.flashlight / calculator.flashlight,
+            visualPenalty: this.calculator.visual / calculator.visual,
+        };
+    }
+}
+
+/**
+ * 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. `DroidDifficultyCalculator` or `RebalanceDroidDifficultyCalculator` 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;
+    /**
+     * Penalty values used to penalize dpp for slider cheesing.
+     */
+    sliderCheesePenalty = {
+        aimPenalty: 1,
+        flashlightPenalty: 1,
+        visualPenalty: 1,
+    };
+    /**
+     * Whether this replay has been checked against 3 finger usage.
+     */
+    hasBeenCheckedFor3Finger = false;
+    /**
+     * Whether this replay has been checked against 2 hand usage.
+     */
+    hasBeenCheckedFor2Hand = false;
+    /**
+     * Whether this repla has been checked against slider cheesing.
+     */
+    hasBeenCheckedForSliderCheesing = false;
+    /**
+     * The amount of two-handed objects.
+     */
+    twoHandedNoteCount = 0;
+    // Sizes of primitive data types in Java (in bytes)
+    BYTE_LENGTH = 1;
+    SHORT_LENGTH = 2;
+    INT_LENGTH = 4;
+    FLOAT_LENGTH = 4;
+    LONG_LENGTH = 8;
+    constructor(values) {
+        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 = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(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.push((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.miss:
+                        ++hit0;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.HitResult.meh:
+                        ++hit50;
+                        grantsGekiOrKatu = false;
+                        break;
+                    case exports.HitResult.good:
+                        ++hit100;
+                        if (grantsGekiOrKatu && isNextNewCombo) {
+                            ++hit100k;
+                        }
+                        break;
+                    case exports.HitResult.great:
+                        ++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 beatmap = this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
+            ? this.beatmap.beatmap
+            : this.beatmap;
+        const objects = beatmap.hitObjects.objects;
+        const stats = new osuBase.MapStats({
+            od: beatmap.difficulty.od,
+            mods: this.data.convertedMods.filter((m) => !osuBase.ModUtil.speedChangingMods.some((v) => v.acronym === m.acronym)),
+        }).calculate();
+        const hitWindow50 = new osuBase.DroidHitWindow(stats.od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
+        // The accuracy of sliders is set to (50 hit window)ms + 13ms if their head was not hit:
+        // https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821
+        //
+        // In such cases, the slider is skipped.
+        const sliderbreakHitOffset = Math.floor(hitWindow50) + 13;
+        const accuracies = [];
+        for (let i = 0; i < hitObjectData.length; ++i) {
+            const v = hitObjectData[i];
+            const o = objects[i];
+            if (o instanceof osuBase.Spinner || v.result === exports.HitResult.miss) {
+                accuracies.push(0);
+                continue;
+            }
+            const accuracy = v.accuracy;
+            if (o instanceof osuBase.Slider && v.accuracy === sliderbreakHitOffset) {
+                accuracies.push(0);
+                continue;
+            }
+            accuracies.push(accuracy);
+            if (accuracy >= 0) {
+                positiveTotal += accuracy;
+                ++positiveCount;
+            }
+            else {
+                negativeTotal += accuracy;
+                ++negativeCount;
+            }
+        }
+        return {
+            positiveAvg: positiveTotal / positiveCount || 0,
+            negativeAvg: negativeTotal / negativeCount || 0,
+            unstableRate: osuBase.MathUtils.calculateStandardDeviation(accuracies) * 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;
+    }
+    /**
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     */
+    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 `DroidDifficultyCalculator`.
+     */
+    checkFor2Hand() {
+        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
+            !this.data) {
+            return;
+        }
+        const twoHandChecker = new TwoHandChecker(this.beatmap, this.data);
+        const result = twoHandChecker.check();
+        this.is2Hand = result.is2Hand;
+        this.twoHandedNoteCount = result.twoHandedNoteCount;
+        this.hasBeenCheckedFor2Hand = true;
+    }
+    /**
+     * Checks if a play has cheesed sliders.
+     *
+     * Requires `analyze()` to be called first and `map` to be defined as `DroidDifficultyCalculator`.
+     */
+    checkForSliderCheesing() {
+        if (!(this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator) ||
+            !this.data) {
+            return;
+        }
+        const sliderCheeseChecker = new SliderCheeseChecker(this.beatmap, this.data);
+        this.sliderCheesePenalty = sliderCheeseChecker.check();
+        this.hasBeenCheckedForSliderCheesing = 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 {
+    /**
+     * For circles, this is the offset at which the circle was hit. If the hit accuracy is 10000, it means the circle was tapped too late ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/HitCircle.java#L298-L306)).
+     *
+     * For sliders, this is the offset at which the slider head was hit. For
+     * sliderbreaks, the accuracy would be `Math.floor(<hit window 50>ms) + 13ms` ([game source code](https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821)).
+     *
+     * For spinners, this is the total amount at which the spinner was spinned:
+     * ```js
+     * const rotations = Math.floor(data.accuracy / 4);
+     * ```
+     * The remainder of the division denotes the hit result of the spinner:
+     * - `HitResult.great`: 3
+     * - `HitResult.good`: 2
+     * - `HitResult.meh`: 1
+     * - `HitResult.miss`: 0
+     */
+    accuracy;
+    /**
+     * The tickset of the hitobject.
+     *
+     * This is used to determine whether or not a slider event (tick, repeat, and end) is hit based on the order they appear.
+     */
+    tickset;
+    /**
+     * The bitwise hit result of the hitobject.
+     */
+    result;
+    constructor(values) {
+        this.accuracy = values.accuracy;
+        this.tickset = values.tickset;
+        this.result = values.result;
+    }
 }
 
 exports.CursorData = CursorData;
@@ -2216,5 +2575,7 @@ exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;
+exports.SliderCheeseChecker = SliderCheeseChecker;
 exports.ThreeFingerChecker = ThreeFingerChecker;
+exports.TwoHandChecker = TwoHandChecker;
 //# sourceMappingURL=index.js.map