@rian8337/osu-droid-replay-analyzer 4.0.0-beta.87 → 4.0.0-beta.89

package/dist/index.js

@@ -46,274 +46,217 @@ exports.MovementType = void 0;
 })(exports.MovementType || (exports.MovementType = {}));
 
 /**
- * Represents a cursor's occurrence.
- */
-class CursorOccurrence {
-    constructor(time, x, y, id) {
-        this.time = time;
-        this.position = new osuBase.Vector2(x, y);
-        this.id = id;
-    }
-    /**
-     * Returns a string representation of this `CursorOccurrence`.
-     */
-    toString() {
-        let str = `${this.time.toString()}ms `;
-        switch (this.id) {
-            case exports.MovementType.down:
-                str += "Down";
-                break;
-            case exports.MovementType.up:
-                str += "Up";
-                break;
-            case exports.MovementType.move:
-                str += "Move";
-                break;
-        }
-        if (this.id !== exports.MovementType.up) {
-            str += ` (${this.position.x.toFixed(2)}, ${this.position.y.toFixed(2)})`;
-        }
-        return str;
-    }
-}
-
-/**
- * Represents a group of cursor occurrences representing a cursor instance's
- * movement when a player places their finger on the screen.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
  */
-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() {
-        var _a, _b, _c, _d;
-        return (_d = (_b = (_a = this._up) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : (_c = this._moves.at(-1)) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : this._down.time;
-    }
+class RebalanceSliderCheeseChecker {
     /**
-     * The duration this cursor occurrence group is active for.
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    get duration() {
-        return this.endTime - this.startTime;
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
     }
     /**
-     * All cursor occurrences in this group.
-     *
-     * This iterates all occurrences and as such should be used sparingly or stored locally.
+     * Checks if relevant sliders in the given beatmap was cheesed.
      */
-    get allOccurrences() {
-        const cursors = [this._down, ...this._moves];
-        if (this._up) {
-            cursors.push(this._up);
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            this.difficultyAttributes.sliderFactor === 1) {
+            return {
+                aimPenalty: 1,
+                flashlightPenalty: 1,
+            };
         }
-        return cursors;
-    }
-    constructor(down, moves, up) {
-        this._down = down;
-        this._moves = moves;
-        // Re-set down cursor occurrence for checking.
-        this.down = down;
-        this.up = up;
-    }
-    /**
-     * Determines whether this cursor occurrence group is active at the specified time.
-     *
-     * @param time The time.
-     * @returns Whether this cursor occurrence group is active at the specified time.
-     */
-    isActiveAt(time) {
-        return time >= this.startTime && time <= this.endTime;
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
     }
     /**
-     * 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.
+     * Checks for sliders that were cheesed.
      */
-    cursorAt(time) {
-        var _a;
-        if (!this.isActiveAt(time)) {
-            return null;
-        }
-        if (this._down.time === time) {
-            return this._down;
-        }
-        if (((_a = this._up) === null || _a === void 0 ? void 0 : _a.time) === time) {
-            return this._up;
-        }
-        let l = 0;
-        let r = this._moves.length - 2;
-        while (l <= r) {
-            const pivot = l + ((r - l) >> 1);
-            if (this._moves[pivot].time < time) {
-                l = pivot + 1;
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
             }
-            else if (this._moves[pivot].time > time) {
-                r = pivot - 1;
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === osuBase.HitResult.miss ||
+                -this.hitWindow50 > objectData.accuracy ||
+                objectData.accuracy >
+                    Math.min(this.hitWindow50, object.duration)) {
+                continue;
             }
-            else {
-                return this._moves[pivot];
+            const objectStartPosition = object.stackedPosition;
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
             }
-        }
-        // 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];
-    }
-    /**
-     * Returns a string representation of this `CursorOccurrenceGroup`.
-     */
-    toString() {
-        return `Down: ${this.down.time.toString()}ms (${this.down.position.x.toFixed(2)}, ${this.down.position.y.toFixed(2)}) | Moves: ${this.moves.length.toString()} | Up: ${this.up ? `${this.up.time.toString()}ms` : "N/A"}`;
-    }
-}
-
-/**
- * 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 time at which the first occurrence of this cursor instance occurs.
-     *
-     * Will return `null` if there are no occurrences.
-     */
-    get earliestOccurrenceTime() {
-        var _a, _b;
-        return (_b = (_a = this.occurrenceGroups.at(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : null;
-    }
-    /**
-     * The time at which the latest occurrence of this cursor instance occurs.
-     *
-     * Will return `null` if there are no occurrences.
-     */
-    get latestOccurrenceTime() {
-        var _a, _b;
-        return (_b = (_a = this.occurrenceGroups.at(-1)) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : null;
-    }
-    /**
-     * The 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;
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
             }
-            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) {
-        /**
-         * The occurrence groups of this cursor instance.
-         */
-        this.occurrenceGroups = [];
-        let downOccurrence = null;
-        let moveOccurrences = [];
-        for (let i = 0; i < values.size; ++i) {
-            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
-            switch (occurrence.id) {
-                case exports.MovementType.down:
-                    downOccurrence = occurrence;
-                    break;
-                case exports.MovementType.move:
-                    moveOccurrences.push(occurrence);
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
                     break;
-                case exports.MovementType.up:
-                    if (downOccurrence) {
-                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
-                        downOccurrence = null;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.stackedPosition;
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
                     }
-                    moveOccurrences = [];
+                    case exports.MovementType.up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
             }
         }
-        // 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));
-        }
+        return cheesedDifficultyRatings;
     }
-}
-
-/**
- * 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).
+     * Calculates the slider cheese penalty.
      */
-    HitResult[HitResult["great"] = 4] = "great";
-})(exports.HitResult || (exports.HitResult = {}));
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return {
+            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.sliderFactor, 2)),
+            flashlightPenalty: 1,
+        };
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
 
 /**
  * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
@@ -399,7 +342,7 @@ class RebalanceThreeFingerChecker {
             const objectBeforeData = objectData[beforeIndex];
             let timeBefore = objectBefore.endTime;
             if (objectBefore instanceof osuBase.Circle) {
-                if (objectBeforeData.result !== exports.HitResult.miss) {
+                if (objectBeforeData.result !== osuBase.HitResult.miss) {
                     timeBefore += objectBeforeData.accuracy;
                 }
                 else {
@@ -411,7 +354,7 @@ class RebalanceThreeFingerChecker {
             const objectAfterData = objectData[afterIndex];
             let timeAfter = objectAfter.startTime;
             if (objectAfter instanceof osuBase.Circle &&
-                objectAfterData.result !== exports.HitResult.miss) {
+                objectAfterData.result !== osuBase.HitResult.miss) {
                 timeAfter += objectAfterData.accuracy;
             }
             this.breakPointAccurateTimes.push(new osuBase.BreakPoint(timeBefore, timeAfter));
@@ -433,10 +376,10 @@ class RebalanceThreeFingerChecker {
         let firstObjectHitWindow = this.hitWindow.mehWindow;
         if (firstObject instanceof osuBase.Circle) {
             switch (firstObjectResult) {
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     firstObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     firstObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
@@ -447,10 +390,10 @@ class RebalanceThreeFingerChecker {
         let lastObjectHitWindow = this.hitWindow.mehWindow;
         if (lastObject instanceof osuBase.Circle) {
             switch (lastObjectResult) {
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     lastObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     lastObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
@@ -519,7 +462,7 @@ class RebalanceThreeFingerChecker {
      * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
      */
     getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
-        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+        if (objectData.result === osuBase.HitResult.miss || object instanceof osuBase.Spinner) {
             return -1;
         }
         // Check for sliderbreaks and treat them as misses.
@@ -565,351 +508,138 @@ class RebalanceThreeFingerChecker {
                     const currentPosition = this.getCursorPosition(cursor);
                     const prevPosition = this.getCursorPosition(prevCursor);
                     switch (cursor.id) {
-                        case exports.MovementType.up:
-                            distance = prevPosition.getDistance(objectPosition);
-                            break;
-                        case exports.MovementType.move: {
-                            // Interpolate movement.
-                            const t = (hitTime - prevCursor.time) /
-                                (cursor.time - prevCursor.time);
-                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
-                            distance =
-                                objectPosition.getDistance(cursorPosition);
-                            break;
-                        }
-                        case exports.MovementType.down:
-                            continue;
-                    }
-                    if (closestDistance > distance) {
-                        closestDistance = distance;
-                        nearestCursorIndex = i;
-                    }
-                }
-                // Reset cursor index pointer on end of group.
-                if (cursorIndices[i] === cursors.length) {
-                    cursorIndices[i] = 1;
-                }
-                break;
-            }
-            // The previous object may still be hit with the same cursor group or cursor index.
-            cursorGroupIndices[i] = Math.max(0, cursorGroupIndices[i] - 1);
-            cursorIndices[i] = Math.max(1, cursorIndices[i] - 1);
-        }
-        return nearestCursorIndex;
-    }
-    /**
-     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
-     *
-     * @param object The object to obtain the index for.
-     * @param objectData The hit data of the object.
-     * @param cursorLookupIndices The cursor indices to start looking for the cursor from, to save computation time.
-     * @param excludedIndices The cursor indices that should not be checked.
-     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
-     */
-    getObjectPressIndex(object, objectData, cursorLookupIndices) {
-        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
-            return -1;
-        }
-        // Check for sliderbreaks and treat them as misses.
-        if (object instanceof osuBase.Slider &&
-            (-this.hitWindow.mehWindow > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow.mehWindow, object.duration))) {
-            return -1;
-        }
-        const hitTime = object.startTime + objectData.accuracy;
-        let nearestCursorInstanceIndex = -1;
-        let nearestTime = Number.POSITIVE_INFINITY;
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            const cursors = this.downCursorInstances[i];
-            let cursorNearestTime = Number.POSITIVE_INFINITY;
-            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
-                const cursor = cursors[j];
-                if (cursor.time > hitTime) {
-                    break;
-                }
-                cursorNearestTime = hitTime - cursor.time;
-            }
-            if (cursorNearestTime < nearestTime) {
-                nearestCursorInstanceIndex = i;
-                nearestTime = cursorNearestTime;
-            }
-        }
-        return nearestCursorInstanceIndex;
-    }
-    /**
-     * Creates nerf factors by scanning through objects.
-     */
-    calculateNerfFactors() {
-        for (const beatmapSection of this.beatmapSections) {
-            const threeFingerCursorCounts = osuBase.Utils.initializeArray(Math.max(0, this.downCursorInstances.length - 2), 0);
-            for (const object of beatmapSection.objects) {
-                if (object.pressingCursorInstanceIndex === -1) {
-                    continue;
-                }
-                if (object.aimingCursorInstanceIndex < 3) {
-                    // The aim cursor is in the first three cursors. They are counted as non-3 finger.
-                    switch (object.pressingCursorInstanceIndex) {
-                        case 0:
-                        case 1:
-                        case 2:
-                            break;
-                        default:
-                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 3];
-                            break;
-                    }
-                }
-                else {
-                    // The aim cursor is somewhere else. only count the first 2 cursors as non-3 finger.
-                    switch (object.pressingCursorInstanceIndex) {
-                        case 0:
-                        case 1:
-                            break;
-                        default:
-                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 2];
-                            break;
-                    }
-                }
-            }
-            const threeFingerCursorCount = threeFingerCursorCounts.reduce((a, v) => a + v, 0);
-            if (threeFingerCursorCount === 0) {
-                continue;
-            }
-            const sectionObjectCount = beatmapSection.objects.length;
-            const threeFingeredObjectRatio = threeFingerCursorCount / sectionObjectCount;
-            const strainFactor = Math.max(1, beatmapSection.sumStrain * threeFingeredObjectRatio);
-            // Finger factor applies more penalty if more fingers were used.
-            const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
-                Math.pow(((index + 1) * count) / sectionObjectCount, 0.9), 1);
-            // Length factor applies more penalty if there are more 3-fingered object.
-            const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 0.8);
-            this.nerfFactors.push({
-                strainFactor: strainFactor,
-                fingerFactor: fingerFactor,
-                lengthFactor: lengthFactor,
-            });
-        }
-    }
-    /**
-     * Calculates the final penalty.
-     */
-    calculateFinalPenalty() {
-        return this.nerfFactors.reduce((a, n) => a +
-            0.015 *
-                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
-    }
-    getCursorPosition(cursor) {
-        if (this.isHardRock) {
-            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
-        }
-        return cursor.position;
-    }
-}
-
-/**
- * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
- */
-class RebalanceSliderCheeseChecker {
-    /**
-     * @param beatmap The beatmap to analyze.
-     * @param data The data of the replay.
-     * @param difficultyAttributes The difficulty attributes of the beatmap.
-     */
-    constructor(beatmap, data, difficultyAttributes) {
-        this.beatmap = beatmap;
-        this.data = data;
-        this.difficultyAttributes = difficultyAttributes;
-        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
-            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
-            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
-        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
-    }
-    /**
-     * Checks if relevant sliders in the given beatmap was cheesed.
-     */
-    check() {
-        if (this.difficultyAttributes.difficultSliders.length === 0 ||
-            this.difficultyAttributes.sliderFactor === 1) {
-            return {
-                aimPenalty: 1,
-                flashlightPenalty: 1,
-            };
-        }
-        const cheesedDifficultyRatings = this.checkSliderCheesing();
-        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
-    }
-    /**
-     * Checks for sliders that were cheesed.
-     */
-    checkSliderCheesing() {
-        const { objects } = this.beatmap.hitObjects;
-        const cheesedDifficultyRatings = [];
-        // Current loop indices are stored for efficiency.
-        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
-        const acceptableRadius = objects[0].radius * 2;
-        // Sort difficult sliders by index so that cursor loop indices work properly.
-        for (const difficultSlider of this.difficultyAttributes.difficultSliders
-            .slice()
-            .sort((a, b) => a.index - b.index)) {
-            if (difficultSlider.index >= this.data.hitObjectData.length) {
-                continue;
-            }
-            const object = objects[difficultSlider.index];
-            const objectData = this.data.hitObjectData[difficultSlider.index];
-            // If a miss or slider break occurs, we disregard the check for that slider.
-            if (objectData.result === exports.HitResult.miss ||
-                -this.hitWindow50 > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow50, object.duration)) {
-                continue;
-            }
-            const objectStartPosition = object.stackedPosition;
-            // These time boundaries should consider the delta time between the previous and next
-            // object as well as their hit accuracy. However, they are somewhat complicated to
-            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
-            const minTimeLimit = object.startTime - this.hitWindow50;
-            const maxTimeLimit = object.startTime + this.hitWindow50;
-            // Get the closest tap distance across all cursors.
-            const closestDistances = [];
-            const closestGroupIndices = [];
-            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
-                let closestDistance = Number.POSITIVE_INFINITY;
-                let closestIndex = cursorGroups.length;
-                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
-                    const group = cursorGroups[j];
-                    if (group.endTime < minTimeLimit) {
-                        continue;
-                    }
-                    if (group.startTime > maxTimeLimit) {
-                        break;
-                    }
-                    if (group.startTime >= minTimeLimit) {
-                        const position = this.getCursorPosition(group.down);
-                        const distance = position.getDistance(objectStartPosition);
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
+                        case exports.MovementType.up:
+                            distance = prevPosition.getDistance(objectPosition);
                             break;
-                        }
-                    }
-                    // Normally, we check if there are cursor presses within the group's active time.
-                    // However, some funky workarounds are used throughout the game for replays, so
-                    // for the time being we only check for cursor distances across the group.
-                    const { allOccurrences } = group;
-                    for (let k = 1; k < allOccurrences.length; ++k) {
-                        const cursor = allOccurrences[k];
-                        const prevCursor = allOccurrences[k - 1];
-                        let distance = Number.POSITIVE_INFINITY;
-                        const currentPosition = this.getCursorPosition(cursor);
-                        const prevPosition = this.getCursorPosition(prevCursor);
-                        switch (cursor.id) {
-                            case exports.MovementType.up:
-                                distance =
-                                    prevPosition.getDistance(objectStartPosition);
-                                break;
-                            case exports.MovementType.move:
-                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
-                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
-                                    const t = (mSecPassed - prevCursor.time) /
-                                        (cursor.time - prevCursor.time);
-                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
-                                    distance =
-                                        cursorPosition.getDistance(objectStartPosition);
-                                    if (closestDistance > distance) {
-                                        closestDistance = distance;
-                                        closestIndex = j;
-                                    }
-                                    if (closestDistance <=
-                                        acceptableRadius / 2) {
-                                        break;
-                                    }
-                                }
-                        }
-                        if (closestDistance > distance) {
-                            closestDistance = distance;
-                            closestIndex = j;
-                        }
-                        if (closestDistance <= acceptableRadius / 2) {
+                        case exports.MovementType.move: {
+                            // Interpolate movement.
+                            const t = (hitTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                            distance =
+                                objectPosition.getDistance(cursorPosition);
                             break;
                         }
+                        case exports.MovementType.down:
+                            continue;
+                    }
+                    if (closestDistance > distance) {
+                        closestDistance = distance;
+                        nearestCursorIndex = i;
                     }
                 }
-                closestDistances.push(closestDistance);
-                closestGroupIndices.push(closestIndex);
-                if (cursorLoopIndices[i] > 0) {
-                    // Decrement the index. The previous group may also have a role on the next slider.
-                    --cursorLoopIndices[i];
+                // Reset cursor index pointer on end of group.
+                if (cursorIndices[i] === cursors.length) {
+                    cursorIndices[i] = 1;
                 }
+                break;
             }
-            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
-            const closestDistance = closestDistances[cursorIndex];
-            if (closestDistance > acceptableRadius / 2) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
-                continue;
-            }
-            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
-            let isCheesed = false;
-            // Track cursor movement to see if it lands on every tick.
-            let occurrenceLoopIndex = 1;
-            const { allOccurrences } = group;
-            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
-                if (isCheesed) {
+            // The previous object may still be hit with the same cursor group or cursor index.
+            cursorGroupIndices[i] = Math.max(0, cursorGroupIndices[i] - 1);
+            cursorIndices[i] = Math.max(1, cursorIndices[i] - 1);
+        }
+        return nearestCursorIndex;
+    }
+    /**
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     *
+     * @param object The object to obtain the index for.
+     * @param objectData The hit data of the object.
+     * @param cursorLookupIndices The cursor indices to start looking for the cursor from, to save computation time.
+     * @param excludedIndices The cursor indices that should not be checked.
+     * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
+     */
+    getObjectPressIndex(object, objectData, cursorLookupIndices) {
+        if (objectData.result === osuBase.HitResult.miss || object instanceof osuBase.Spinner) {
+            return -1;
+        }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            (-this.hitWindow.mehWindow > objectData.accuracy ||
+                objectData.accuracy >
+                    Math.min(this.hitWindow.mehWindow, object.duration))) {
+            return -1;
+        }
+        const hitTime = object.startTime + objectData.accuracy;
+        let nearestCursorInstanceIndex = -1;
+        let nearestTime = Number.POSITIVE_INFINITY;
+        for (let i = 0; i < this.downCursorInstances.length; ++i) {
+            const cursors = this.downCursorInstances[i];
+            let cursorNearestTime = Number.POSITIVE_INFINITY;
+            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
+                const cursor = cursors[j];
+                if (cursor.time > hitTime) {
                     break;
                 }
-                const tickWasHit = objectData.tickset[i - 1];
-                if (!tickWasHit) {
+                cursorNearestTime = hitTime - cursor.time;
+            }
+            if (cursorNearestTime < nearestTime) {
+                nearestCursorInstanceIndex = i;
+                nearestTime = cursorNearestTime;
+            }
+        }
+        return nearestCursorInstanceIndex;
+    }
+    /**
+     * Creates nerf factors by scanning through objects.
+     */
+    calculateNerfFactors() {
+        for (const beatmapSection of this.beatmapSections) {
+            const threeFingerCursorCounts = osuBase.Utils.initializeArray(Math.max(0, this.downCursorInstances.length - 2), 0);
+            for (const object of beatmapSection.objects) {
+                if (object.pressingCursorInstanceIndex === -1) {
                     continue;
                 }
-                const nestedObject = object.nestedHitObjects[i];
-                const nestedPosition = nestedObject.stackedPosition;
-                while (occurrenceLoopIndex < allOccurrences.length &&
-                    allOccurrences[occurrenceLoopIndex].time <
-                        nestedObject.startTime) {
-                    ++occurrenceLoopIndex;
-                }
-                if (occurrenceLoopIndex === allOccurrences.length) {
-                    continue;
+                if (object.aimingCursorInstanceIndex < 3) {
+                    // The aim cursor is in the first three cursors. They are counted as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                        case 2:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 3];
+                            break;
+                    }
                 }
-                const cursor = allOccurrences[occurrenceLoopIndex];
-                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
-                const currentPosition = this.getCursorPosition(cursor);
-                const prevPosition = this.getCursorPosition(prevCursor);
-                switch (cursor.id) {
-                    case exports.MovementType.move: {
-                        // Interpolate cursor position during nested object time.
-                        const t = (nestedObject.startTime - prevCursor.time) /
-                            (cursor.time - prevCursor.time);
-                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
-                        const distance = cursorPosition.getDistance(nestedPosition);
-                        isCheesed = distance > acceptableRadius;
-                        break;
+                else {
+                    // The aim cursor is somewhere else. only count the first 2 cursors as non-3 finger.
+                    switch (object.pressingCursorInstanceIndex) {
+                        case 0:
+                        case 1:
+                            break;
+                        default:
+                            ++threeFingerCursorCounts[object.pressingCursorInstanceIndex - 2];
+                            break;
                     }
-                    case exports.MovementType.up:
-                        isCheesed =
-                            prevPosition.getDistance(nestedPosition) >
-                                acceptableRadius;
                 }
             }
-            if (isCheesed) {
-                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            const threeFingerCursorCount = threeFingerCursorCounts.reduce((a, v) => a + v, 0);
+            if (threeFingerCursorCount === 0) {
+                continue;
             }
+            const sectionObjectCount = beatmapSection.objects.length;
+            const threeFingeredObjectRatio = threeFingerCursorCount / sectionObjectCount;
+            const strainFactor = Math.max(1, beatmapSection.sumStrain * threeFingeredObjectRatio);
+            // Finger factor applies more penalty if more fingers were used.
+            const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
+                Math.pow(((index + 1) * count) / sectionObjectCount, 0.9), 1);
+            // Length factor applies more penalty if there are more 3-fingered object.
+            const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 0.8);
+            this.nerfFactors.push({
+                strainFactor: strainFactor,
+                fingerFactor: fingerFactor,
+                lengthFactor: lengthFactor,
+            });
         }
-        return cheesedDifficultyRatings;
     }
     /**
-     * Calculates the slider cheese penalty.
+     * Calculates the final penalty.
      */
-    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
-        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
-        return {
-            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
-                summedDifficultyRating *
-                    this.difficultyAttributes.sliderFactor, 2)),
-            flashlightPenalty: 1,
-        };
+    calculateFinalPenalty() {
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
     }
     getCursorPosition(cursor) {
         if (this.isHardRock) {
@@ -919,38 +649,6 @@ class RebalanceSliderCheeseChecker {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /**
  * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
@@ -1003,10 +701,16 @@ class SliderCheeseChecker {
             const object = objects[difficultSlider.index];
             const objectData = this.data.hitObjectData[difficultSlider.index];
             // If a miss or slider break occurs, we disregard the check for that slider.
-            if (objectData.result === exports.HitResult.miss ||
-                -this.hitWindow50 > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow50, object.duration)) {
+            if (objectData.result === osuBase.HitResult.miss) {
+                continue;
+            }
+            let lateHitThreshold = this.hitWindow50;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow50 ||
+                objectData.accuracy > lateHitThreshold) {
                 continue;
             }
             const objectStartPosition = object.stackedPosition;
@@ -1251,7 +955,7 @@ class ThreeFingerChecker {
             const objectBeforeData = objectData[beforeIndex];
             let timeBefore = objectBefore.endTime;
             if (objectBefore instanceof osuBase.Circle) {
-                if (objectBeforeData.result !== exports.HitResult.miss) {
+                if (objectBeforeData.result !== osuBase.HitResult.miss) {
                     timeBefore += objectBeforeData.accuracy;
                 }
                 else {
@@ -1263,7 +967,7 @@ class ThreeFingerChecker {
             const objectAfterData = objectData[afterIndex];
             let timeAfter = objectAfter.startTime;
             if (objectAfter instanceof osuBase.Circle &&
-                objectAfterData.result !== exports.HitResult.miss) {
+                objectAfterData.result !== osuBase.HitResult.miss) {
                 timeAfter += objectAfterData.accuracy;
             }
             this.breakPointAccurateTimes.push(new osuBase.BreakPoint(timeBefore, timeAfter));
@@ -1285,10 +989,10 @@ class ThreeFingerChecker {
         let firstObjectHitWindow = this.hitWindow.mehWindow;
         if (firstObject instanceof osuBase.Circle) {
             switch (firstObjectResult) {
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     firstObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     firstObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
@@ -1299,10 +1003,10 @@ class ThreeFingerChecker {
         let lastObjectHitWindow = this.hitWindow.mehWindow;
         if (lastObject instanceof osuBase.Circle) {
             switch (lastObjectResult) {
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     lastObjectHitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     lastObjectHitWindow = this.hitWindow.okWindow;
                     break;
                 default:
@@ -1369,18 +1073,23 @@ class ThreeFingerChecker {
      * @param cursorGroupIndices The cursor indices to start looking for the cursor group from, to save computation time.
      * @param cursorIndices The cursor indices to start looking for the cursor from, to save computation time.
      * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
-     */
-    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
-        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
-            return -1;
-        }
-        // Check for sliderbreaks and treat them as misses.
-        if (object instanceof osuBase.Slider &&
-            (-this.hitWindow.mehWindow > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow.mehWindow, object.duration))) {
+     */
+    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
+        if (objectData.result === osuBase.HitResult.miss || object instanceof osuBase.Spinner) {
             return -1;
         }
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
+            }
+        }
         const hitTime = object.startTime + objectData.accuracy;
         const objectPosition = object.stackedPosition;
         // We are maintaining the closest distance to the object.
@@ -1459,15 +1168,20 @@ class ThreeFingerChecker {
      * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
      */
     getObjectPressIndex(object, objectData, cursorLookupIndices) {
-        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+        if (objectData.result === osuBase.HitResult.miss || object instanceof osuBase.Spinner) {
             return -1;
         }
         // Check for sliderbreaks and treat them as misses.
-        if (object instanceof osuBase.Slider &&
-            (-this.hitWindow.mehWindow > objectData.accuracy ||
-                objectData.accuracy >
-                    Math.min(this.hitWindow.mehWindow, object.duration))) {
-            return -1;
+        if (object instanceof osuBase.Slider) {
+            let lateHitThreshold = this.hitWindow.mehWindow;
+            // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+            if (this.data.replayVersion < 8) {
+                lateHitThreshold = Math.min(lateHitThreshold, object.duration);
+            }
+            if (objectData.accuracy < -this.hitWindow.mehWindow ||
+                objectData.accuracy > lateHitThreshold) {
+                return -1;
+            }
         }
         const hitTime = object.startTime + objectData.accuracy;
         let nearestCursorInstanceIndex = -1;
@@ -1778,7 +1492,7 @@ class TwoHandChecker {
         const prevObject = this.beatmap.hitObjects.objects[objectIndex - 1];
         const prevObjectData = this.data.hitObjectData[objectIndex - 1];
         if (prevObject instanceof osuBase.Spinner ||
-            prevObjectData.result === exports.HitResult.miss) {
+            prevObjectData.result === osuBase.HitResult.miss) {
             return new IndexedHitObject(object, -1, -1, -1, null, false);
         }
         const objectStartPosition = object.stackedPosition;
@@ -1933,10 +1647,10 @@ class TwoHandChecker {
         // For sliders, set the hit window to as lenient as possible.
         if (object instanceof osuBase.Circle) {
             switch (data.result) {
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     hitWindow = this.hitWindow.greatWindow;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     hitWindow = this.hitWindow.okWindow;
                     break;
             }
@@ -2080,119 +1794,366 @@ class TwoHandChecker {
         if (!(object instanceof osuBase.Slider)) {
             return this.getCursorPositionForObjectStart(objectIndex);
         }
-        const nextObject = this.beatmap.hitObjects.objects[objectIndex - 1];
-        let objectEndPosition = object.stackedEndPosition;
-        if (object.distance > 0 && nextObject) {
-            const endPosition = object.stackedEndPosition;
-            const nextStartPosition = nextObject.stackedPosition;
-            const lazyEndMovement = nextStartPosition.subtract(endPosition);
-            const actualEndMovement = nextStartPosition.subtract(objectEndPosition);
-            if (lazyEndMovement.length < actualEndMovement.length) {
-                objectEndPosition = endPosition;
-            }
+        const nextObject = this.beatmap.hitObjects.objects[objectIndex - 1];
+        let objectEndPosition = object.stackedEndPosition;
+        if (object.distance > 0 && nextObject) {
+            const endPosition = object.stackedEndPosition;
+            const nextStartPosition = nextObject.stackedPosition;
+            const lazyEndMovement = nextStartPosition.subtract(endPosition);
+            const actualEndMovement = nextStartPosition.subtract(objectEndPosition);
+            if (lazyEndMovement.length < actualEndMovement.length) {
+                objectEndPosition = endPosition;
+            }
+        }
+        else {
+            objectEndPosition = object.stackedPosition;
+        }
+        let nearestPosition = new osuBase.Vector2(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 = this.getCursorPosition(cursor);
+                            break;
+                        case exports.MovementType.up: {
+                            const prevCursor = cursors[k - 1];
+                            cursorPosition = this.getCursorPosition(prevCursor);
+                            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 = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), 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 instanceof osuBase.Slider) ||
+            hitData.result === osuBase.HitResult.miss ||
+            indexedHitObject.cursorIndex === -1) {
+            return false;
+        }
+        return false;
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
+
+/**
+ * Represents a cursor's occurrence.
+ */
+class CursorOccurrence {
+    constructor(time, x, y, id) {
+        this.time = time;
+        this.position = new osuBase.Vector2(x, y);
+        this.id = id;
+    }
+    /**
+     * Returns a string representation of this `CursorOccurrence`.
+     */
+    toString() {
+        let str = `${this.time.toString()}ms `;
+        switch (this.id) {
+            case exports.MovementType.down:
+                str += "Down";
+                break;
+            case exports.MovementType.up:
+                str += "Up";
+                break;
+            case exports.MovementType.move:
+                str += "Move";
+                break;
+        }
+        if (this.id !== exports.MovementType.up) {
+            str += ` (${this.position.x.toFixed(2)}, ${this.position.y.toFixed(2)})`;
+        }
+        return str;
+    }
+}
+
+/**
+ * Represents a group of cursor occurrences representing a cursor instance's
+ * movement when a player places their finger on the screen.
+ */
+class CursorOccurrenceGroup {
+    /**
+     * The 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() {
+        var _a, _b, _c, _d;
+        return (_d = (_b = (_a = this._up) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : (_c = this._moves.at(-1)) === null || _c === void 0 ? void 0 : _c.time) !== null && _d !== void 0 ? _d : this._down.time;
+    }
+    /**
+     * The duration this cursor occurrence group is active for.
+     */
+    get duration() {
+        return this.endTime - this.startTime;
+    }
+    /**
+     * All cursor occurrences in this group.
+     *
+     * This iterates all occurrences and as such should be used sparingly or stored locally.
+     */
+    get allOccurrences() {
+        const cursors = [this._down, ...this._moves];
+        if (this._up) {
+            cursors.push(this._up);
+        }
+        return cursors;
+    }
+    constructor(down, moves, up) {
+        this._down = down;
+        this._moves = moves;
+        // Re-set down cursor occurrence for checking.
+        this.down = down;
+        this.up = up;
+    }
+    /**
+     * Determines whether this cursor occurrence group is active at the specified time.
+     *
+     * @param time The time.
+     * @returns Whether this cursor occurrence group is active at the specified time.
+     */
+    isActiveAt(time) {
+        return time >= this.startTime && time <= this.endTime;
+    }
+    /**
+     * Finds the cursor occurrence that is active at a given time.
+     *
+     * @param time The time.
+     * @returns The cursor occurrence at the given time, `null` if not found.
+     */
+    cursorAt(time) {
+        var _a;
+        if (!this.isActiveAt(time)) {
+            return null;
+        }
+        if (this._down.time === time) {
+            return this._down;
         }
-        else {
-            objectEndPosition = object.stackedPosition;
+        if (((_a = this._up) === null || _a === void 0 ? void 0 : _a.time) === time) {
+            return this._up;
         }
-        let nearestPosition = new osuBase.Vector2(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 = this.getCursorPosition(cursor);
-                            break;
-                        case exports.MovementType.up: {
-                            const prevCursor = cursors[k - 1];
-                            cursorPosition = this.getCursorPosition(prevCursor);
-                            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 = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), 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;
-                        }
-                    }
-                }
+        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];
             }
         }
-        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,
-        };
+        // 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];
     }
     /**
-     * Checks whether a slider was cheesed.
+     * Returns a string representation of this `CursorOccurrenceGroup`.
+     */
+    toString() {
+        return `Down: ${this.down.time.toString()}ms (${this.down.position.x.toFixed(2)}, ${this.down.position.y.toFixed(2)}) | Moves: ${this.moves.length.toString()} | Up: ${this.up ? `${this.up.time.toString()}ms` : "N/A"}`;
+    }
+}
+
+/**
+ * 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 time at which the first occurrence of this cursor instance occurs.
      *
-     * This is done by checking if a cursor follows a slider all the way to its end position.
+     * Will return `null` if there are no occurrences.
+     */
+    get earliestOccurrenceTime() {
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(0)) === null || _a === void 0 ? void 0 : _a.startTime) !== null && _b !== void 0 ? _b : null;
+    }
+    /**
+     * The time at which the latest occurrence of this cursor instance occurs.
      *
-     * @param indexedHitObject The indexed slider.
-     * @param hitData The hit data of the slider.
-     * @returns Whether the slider was cheesed.
+     * Will return `null` if there are no occurrences.
      */
-    checkSliderCheesing(indexedHitObject, hitData) {
-        if (!(indexedHitObject.object instanceof osuBase.Slider) ||
-            hitData.result === exports.HitResult.miss ||
-            indexedHitObject.cursorIndex === -1) {
-            return false;
-        }
-        return false;
+    get latestOccurrenceTime() {
+        var _a, _b;
+        return (_b = (_a = this.occurrenceGroups.at(-1)) === null || _a === void 0 ? void 0 : _a.endTime) !== null && _b !== void 0 ? _b : null;
     }
-    getCursorPosition(cursor) {
-        if (this.isHardRock) {
-            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+    /**
+     * 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) {
+        /**
+         * The occurrence groups of this cursor instance.
+         */
+        this.occurrenceGroups = [];
+        let downOccurrence = null;
+        let moveOccurrences = [];
+        for (let i = 0; i < values.size; ++i) {
+            const occurrence = new CursorOccurrence(values.time[i], values.x[i], values.y[i], values.id[i]);
+            switch (occurrence.id) {
+                case exports.MovementType.down:
+                    downOccurrence = occurrence;
+                    break;
+                case exports.MovementType.move:
+                    moveOccurrences.push(occurrence);
+                    break;
+                case exports.MovementType.up:
+                    if (downOccurrence) {
+                        this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences, occurrence));
+                        downOccurrence = null;
+                    }
+                    moveOccurrences = [];
+            }
+        }
+        // Add the final cursor occurrence group as the loop may not catch it for special cases.
+        if (downOccurrence && moveOccurrences.length > 0) {
+            this.occurrenceGroups.push(new CursorOccurrenceGroup(downOccurrence, moveOccurrences));
         }
-        return cursor.position;
     }
 }
 
@@ -2225,13 +2186,24 @@ class ReplayData {
 }
 
 /**
- * Represents a replay data for replay version 3.
+ * Represents a replay data for replay version 3 and later.
  *
  * Stores generic information about an osu!droid replay.
  *
  * This is used when analyzing replays using replay analyzer.
  */
 class ReplayV3Data extends ReplayData {
+    /**
+     * The total score achieved in the play, after applying score multiplier from mods.
+     */
+    get totalScore() {
+        var _a;
+        if (this.replayVersion < 8) {
+            return this.score;
+        }
+        (_a = this.scoreMultiplier) !== null && _a !== void 0 ? _a : (this.scoreMultiplier = osuBase.ModUtil.calculateScoreMultiplier(this.convertedMods.values(), osuBase.Modes.droid));
+        return Math.round(Math.fround(this.score * this.scoreMultiplier));
+    }
     constructor(values) {
         super(values);
         this.time = values.time;
@@ -2243,6 +2215,38 @@ class ReplayV3Data extends ReplayData {
     }
 }
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 /**
  * A replay analyzer that analyzes a replay from osu!droid.
  *
@@ -2351,15 +2355,20 @@ class ReplayAnalyzer {
         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) {
+            if (o instanceof osuBase.Spinner || v.result === osuBase.HitResult.miss) {
                 continue;
             }
             const { accuracy } = v;
-            if (o instanceof osuBase.Slider &&
-                // Do not include slider breaks.
-                (-mehWindow > accuracy ||
-                    accuracy > Math.min(mehWindow, o.duration))) {
-                continue;
+            // Do not include slider breaks.
+            if (o instanceof osuBase.Slider) {
+                let lateHitThreshold = mehWindow;
+                // Before replay version 8, the slider head's hit window is capped to the duration of the slider.
+                if (this.data.replayVersion < 8) {
+                    lateHitThreshold = Math.min(mehWindow, o.duration);
+                }
+                if (-mehWindow > accuracy || accuracy > lateHitThreshold) {
+                    continue;
+                }
             }
             accuracies.push(accuracy);
             if (accuracy >= 0) {
@@ -2396,7 +2405,7 @@ class ReplayAnalyzer {
         for (let i = 0; i < data.hitObjectData.length; ++i) {
             const object = beatmap.hitObjects.objects[i];
             const objectData = data.hitObjectData[i];
-            if (objectData.result === exports.HitResult.miss ||
+            if (objectData.result === osuBase.HitResult.miss ||
                 !(object instanceof osuBase.Slider)) {
                 continue;
             }
@@ -2439,16 +2448,16 @@ class ReplayAnalyzer {
             let { result } = objectData;
             if (object instanceof osuBase.Circle) {
                 if (hitAccuracy <= hitWindow.greatWindow) {
-                    result = exports.HitResult.great;
+                    result = osuBase.HitResult.great;
                 }
                 else if (hitAccuracy <= hitWindow.okWindow) {
-                    result = exports.HitResult.good;
+                    result = osuBase.HitResult.good;
                 }
                 else if (hitAccuracy <= hitWindow.mehWindow) {
-                    result = exports.HitResult.meh;
+                    result = osuBase.HitResult.meh;
                 }
                 else {
-                    result = exports.HitResult.miss;
+                    result = osuBase.HitResult.miss;
                 }
             }
             else if (object instanceof osuBase.Slider) {
@@ -2461,34 +2470,34 @@ class ReplayAnalyzer {
                         }
                     }
                     if (ticksObtained === object.nestedHitObjects.length) {
-                        result = exports.HitResult.great;
+                        result = osuBase.HitResult.great;
                     }
                     else if (ticksObtained >=
                         Math.trunc(object.nestedHitObjects.length / 2)) {
-                        result = exports.HitResult.good;
+                        result = osuBase.HitResult.good;
                     }
                     else if (ticksObtained > 0) {
-                        result = exports.HitResult.meh;
+                        result = osuBase.HitResult.meh;
                     }
                     else {
-                        result = exports.HitResult.miss;
+                        result = osuBase.HitResult.miss;
                     }
                 }
                 else {
-                    result = exports.HitResult.miss;
+                    result = osuBase.HitResult.miss;
                 }
             }
             switch (result) {
-                case exports.HitResult.miss:
+                case osuBase.HitResult.miss:
                     ++accuracy.nmiss;
                     break;
-                case exports.HitResult.meh:
+                case osuBase.HitResult.meh:
                     ++accuracy.n50;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     ++accuracy.n100;
                     break;
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     ++accuracy.n300;
                     break;
             }
@@ -2666,6 +2675,7 @@ class ReplayAnalyzer {
                 break;
             case 3:
             case 7:
+            case 8:
                 bufferIndex = 7;
                 break;
             case 4:
@@ -2782,7 +2792,7 @@ class ReplayAnalyzer {
             const replayObjectData = {
                 accuracy: 0,
                 tickset: [],
-                result: exports.HitResult.miss,
+                result: osuBase.HitResult.miss,
             };
             replayObjectData.accuracy = this.readShort(replayDataBuffer);
             const len = this.readByte(replayDataBuffer);
@@ -2823,21 +2833,21 @@ class ReplayAnalyzer {
                     : true
                 : false;
             switch (hitObjectData.result) {
-                case exports.HitResult.miss:
+                case osuBase.HitResult.miss:
                     ++resultObject.accuracy.nmiss;
                     grantsGekiOrKatu = false;
                     break;
-                case exports.HitResult.meh:
+                case osuBase.HitResult.meh:
                     ++resultObject.accuracy.n50;
                     grantsGekiOrKatu = false;
                     break;
-                case exports.HitResult.good:
+                case osuBase.HitResult.good:
                     ++resultObject.accuracy.n100;
                     if (grantsGekiOrKatu && isNextNewCombo) {
                         ++resultObject.hit100k;
                     }
                     break;
-                case exports.HitResult.great:
+                case osuBase.HitResult.great:
                     ++resultObject.accuracy.n300;
                     if (grantsGekiOrKatu && isNextNewCombo) {
                         ++resultObject.hit300k;
@@ -2912,21 +2922,6 @@ class ReplayAnalyzer {
     }
 }
 
-/**
- * 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 {
-    constructor(values) {
-        this.accuracy = values.accuracy;
-        this.tickset = values.tickset;
-        this.result = values.result;
-    }
-}
-
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
@@ -2934,7 +2929,6 @@ exports.RebalanceSliderCheeseChecker = RebalanceSliderCheeseChecker;
 exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
-exports.ReplayObjectData = ReplayObjectData;
 exports.ReplayV3Data = ReplayV3Data;
 exports.SliderCheeseChecker = SliderCheeseChecker;
 exports.ThreeFingerChecker = ThreeFingerChecker;