@rian8337/osu-droid-replay-analyzer 4.0.0-beta.24 → 4.0.0-beta.26

package/dist/index.js

@@ -294,19 +294,15 @@ exports.HitResult = void 0;
  * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
  */
 class RebalanceThreeFingerChecker {
+    get hitWindow50() {
+        return this.hitWindow.hitWindowFor50(this.isPrecise);
+    }
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
-        /**
-         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-         *
-         * Increasing this number will increase detection accuracy, however
-         * it also increases the chance of falsely flagged plays.
-         */
-        this.threeFingerRatioThreshold = 0.01;
         /**
          * Extended sections of the beatmap for drag detection.
          */
@@ -331,17 +327,9 @@ class RebalanceThreeFingerChecker {
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const od = osuBase.calculateDroidDifficultyStatistics({
-            overallDifficulty: beatmap.difficulty.od,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
-            convertOverallDifficulty: false,
-        }).overallDifficulty;
-        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
-        this.hitWindow = new osuBase.DroidHitWindow(od);
-        this.hitObjects = beatmap.hitObjects.objects;
-        this.objectRadiusThreshold = this.hitObjects[0].radius;
-        // Only allow object radius threshold to deviate slightly from actual object radius.
-        this.maximumObjectRadiusThreshold = this.objectRadiusThreshold * 1.05;
+        this.isPrecise = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        this.isHardRock = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHardRock);
+        this.hitWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od);
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -362,7 +350,8 @@ class RebalanceThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
+        if (!RebalanceThreeFingerChecker.isEligibleToDetect(this.difficultyAttributes) ||
+            this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 3) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getAccurateBreakPoints();
@@ -382,10 +371,11 @@ class RebalanceThreeFingerChecker {
      * end of the hitobject before it and do not end right at the first hitobject after it.
      */
     getAccurateBreakPoints() {
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         for (const breakPoint of this.beatmap.events.breaks) {
-            const beforeIndex = osuBase.MathUtils.clamp(this.hitObjects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, this.hitObjects.length - 2);
-            const objectBefore = this.hitObjects[beforeIndex];
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            const objectBefore = objects[beforeIndex];
             const objectBeforeData = objectData[beforeIndex];
             let timeBefore = objectBefore.endTime;
             if (objectBefore instanceof osuBase.Circle) {
@@ -397,9 +387,9 @@ class RebalanceThreeFingerChecker {
                 }
             }
             const afterIndex = beforeIndex + 1;
-            const objectAfter = this.hitObjects[afterIndex];
+            const objectAfter = objects[afterIndex];
             const objectAfterData = objectData[afterIndex];
-            let timeAfter = this.hitObjects[afterIndex].startTime;
+            let timeAfter = objectAfter.startTime;
             if (objectAfter instanceof osuBase.Circle &&
                 objectAfterData.result !== exports.HitResult.miss) {
                 timeAfter += objectAfterData.accuracy;
@@ -416,11 +406,12 @@ class RebalanceThreeFingerChecker {
      * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
     filterCursorInstances() {
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
-        const firstObject = this.hitObjects[0];
-        const lastObject = this.hitObjects.at(-1);
+        const firstObject = objects[0];
+        const lastObject = objects.at(-1);
         // For sliders, automatically set hit window length to be as lenient as possible.
         let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
         if (firstObject instanceof osuBase.Circle) {
@@ -480,289 +471,202 @@ class RebalanceThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
-        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        const beatmapObjects = this.beatmap.hitObjects.objects;
+        const aimCursorGroupLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        // This intentionally starts from 1 because we need to look at the previous cursor.
+        const aimCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 1);
+        const pressCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            const dragFingerIndex = this.findDragIndex(section);
             const objects = [];
             for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
-                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
+                const object = beatmapObjects[i];
+                const objectData = this.data.hitObjectData[i];
+                objects.push({
+                    object: object,
+                    aimingCursorInstanceIndex: this.getObjectAimIndex(object, objectData, aimCursorGroupLookupIndices, aimCursorLookupIndices),
+                    pressingCursorInstanceIndex: this.getObjectPressIndex(object, objectData, pressCursorLookupIndices),
+                });
             }
-            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { objects: objects }));
         }
     }
     /**
-     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     * Obtains the index of the cursor that aimed the object at the nearest 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.
+     * @param cursorInstanceIndices The cursor indices to start looking for the cursor instance from, to save computation time.
+     * @param cursorGroupIndices The cursor indices to start looking for the cursor group from, to save computation time.
+     * @param cursorIndices The cursor indices to start looking for the cursor from, to save computation time.
      * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
      */
-    getObjectPressIndex(object, objectData, cursorLookupIndices, ...excludedCursorIndices) {
+    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
         if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
-            return {
-                pressingCursorInstanceIndex: -1,
-                pressingCursorIndex: -1,
-            };
+            return -1;
         }
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         // Check for sliderbreaks and treat them as misses.
         if (object instanceof osuBase.Slider &&
-            objectData.accuracy === Math.floor(hitWindow50) + 13) {
-            return {
-                pressingCursorInstanceIndex: -1,
-                pressingCursorIndex: -1,
-            };
-        }
-        // We are not directly using hit time to determine which cursor pressed the object
-        // to account for time difference between hit registration and object judgement.
-        let minHitTime = object.startTime;
-        let maxHitTime = object.startTime;
-        if (object instanceof osuBase.Circle) {
-            let hitWindowGap = hitWindow50;
-            switch (objectData.result) {
-                case exports.HitResult.great:
-                    hitWindowGap = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    hitWindowGap = this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-            }
-            minHitTime -= hitWindowGap;
-            maxHitTime += hitWindowGap;
-        }
-        else if (object instanceof osuBase.Slider) {
-            minHitTime -= hitWindow50;
-            maxHitTime += Math.min(hitWindow50, object.spanDuration);
+            objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+            return -1;
         }
         const hitTime = object.startTime + objectData.accuracy;
-        let nearestCursorInstanceIndex = null;
-        let nearestCursorIndex = null;
-        let nearestTime = Number.POSITIVE_INFINITY;
-        for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (excludedCursorIndices.includes(i)) {
-                continue;
-            }
-            const cursors = this.downCursorInstances[i];
-            for (let j = cursorLookupIndices[i]; j < cursors.length; cursorLookupIndices[i] = ++j) {
-                const cursor = cursors[j];
-                if (cursor.time < minHitTime) {
+        const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+        // We are maintaining the closest distance to the object.
+        // This is because the radius that is calculated is using an estimation.
+        // As such, it does not reflect the actual object radius in gameplay.
+        let closestDistance = Number.POSITIVE_INFINITY;
+        let nearestCursorIndex = -1;
+        // Observe the cursor position at the object's hit time.
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = cursorGroupIndices[i]; j < cursorData.occurrenceGroups.length; cursorGroupIndices[i] = ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < hitTime) {
+                    // Reset cursor index pointer.
+                    cursorIndices[i] = 1;
                     continue;
                 }
-                if (cursor.time > maxHitTime) {
+                if (cursorGroup.startTime > hitTime) {
                     break;
                 }
-                const deltaTime = Math.abs(hitTime - cursor.time);
-                if (deltaTime > nearestTime) {
-                    break;
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = cursorIndices[i]; k < cursors.length; cursorIndices[i] = ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    // Cursor is past the object's hit time.
+                    if (prevCursor.time > hitTime) {
+                        break;
+                    }
+                    // Cursor is before the object's hit time.
+                    if (hitTime > cursor.time) {
+                        continue;
+                    }
+                    let distance;
+                    const currentPosition = this.getCursorPosition(cursor);
+                    const prevPosition = this.getCursorPosition(prevCursor);
+                    switch (cursor.id) {
+                        case exports.MovementType.up:
+                            distance = prevPosition.getDistance(objectPosition);
+                            break;
+                        case exports.MovementType.move: {
+                            // Interpolate movement.
+                            const t = (hitTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                            distance =
+                                objectPosition.getDistance(cursorPosition);
+                            break;
+                        }
+                        case exports.MovementType.down:
+                            continue;
+                    }
+                    if (closestDistance > distance) {
+                        closestDistance = distance;
+                        nearestCursorIndex = i;
+                    }
                 }
-                nearestCursorInstanceIndex = i;
-                nearestCursorIndex = j;
-                nearestTime = deltaTime;
+                // 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 {
-            pressingCursorInstanceIndex: nearestCursorInstanceIndex !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
-            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
-        };
+        return nearestCursorIndex;
     }
     /**
-     * Checks if a section is dragged and returns the index of the drag finger.
-     *
-     * If the section is not dragged, -1 will be returned.
+     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
      *
-     * @param section The section to check.
+     * @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.
      */
-    findDragIndex(section) {
-        var _a;
-        const objectData = this.data.hitObjectData;
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
-        const firstObject = this.hitObjects[section.firstObjectIndex];
-        const firstObjectData = objectData[section.firstObjectIndex];
-        const lastObject = this.hitObjects[section.lastObjectIndex];
-        const lastObjectData = objectData[section.lastObjectIndex];
-        let firstObjectHitTime = firstObject.startTime;
-        let lastObjectHitTime = lastObject.startTime;
-        // Check for slider breaks.
-        if (firstObject instanceof osuBase.Slider &&
-            firstObjectData.accuracy === Math.floor(hitWindow50) + 13) {
-            firstObjectHitTime -= hitWindow50;
-        }
-        else {
-            firstObjectHitTime += firstObjectData.accuracy;
-        }
-        if (lastObject instanceof osuBase.Slider &&
-            lastObjectData.accuracy === Math.floor(hitWindow50) + 13) {
-            lastObjectHitTime += Math.min(hitWindow50, lastObject.nestedHitObjects[1].startTime - lastObject.startTime);
+    getObjectPressIndex(object, objectData, cursorLookupIndices) {
+        if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
+            return -1;
         }
-        else {
-            lastObjectHitTime += lastObjectData.accuracy;
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+            return -1;
         }
-        // Since there may be more than 1 cursor instance index,
-        // we check which cursor instance follows hitobjects all over.
-        const cursorInstanceIndices = [];
-        const cursorGroupIndices = [];
-        const cursorIndices = [];
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.occurrenceGroups.length === 0) {
-                continue;
-            }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.occurrenceGroups.filter((v) => v.startTime <= firstObjectHitTime &&
-                v.endTime >= lastObjectHitTime).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;
-            }
-            cursorInstanceIndices.push(i);
-            cursorGroupIndices.push(0);
-            // Start checking from the second cursor.
-            cursorIndices.push(1);
-        }
-        const sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
-        const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
-        for (let i = 0; i < sectionObjects.length &&
-            cursorInstanceIndices.some((v) => v !== -1); ++i) {
-            const object = sectionObjects[i];
-            const objectData = sectionReplayObjectData[i];
-            if (object instanceof osuBase.Spinner ||
-                objectData.result === exports.HitResult.miss) {
-                continue;
-            }
-            // Exclude sliderbreaks.
-            if (object instanceof osuBase.Slider &&
-                objectData.accuracy === Math.floor(hitWindow50) + 13) {
-                continue;
-            }
-            const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
-            const hitTime = object.startTime + objectData.accuracy;
-            // Observe the cursor position at the object's hit time.
-            for (let j = 0; j < cursorInstanceIndices.length; ++j) {
-                if (cursorInstanceIndices[j] === -1) {
-                    continue;
-                }
-                const cursorData = this.data.cursorMovement[cursorInstanceIndices[j]];
-                for (let k = cursorGroupIndices[j]; k < cursorData.occurrenceGroups.length; cursorGroupIndices[j] = ++k) {
-                    const cursorGroup = cursorData.occurrenceGroups[k];
-                    if (!cursorGroup.isActiveAt(hitTime)) {
-                        continue;
-                    }
-                    const cursors = cursorGroup.allOccurrences;
-                    // We are maintaining the closest distance of cursors to the object.
-                    // This is because the radius that is calculated is using an estimation. As such,
-                    // it does not perfectly reflect the actual object radius in gameplay.
-                    let closestDistance = this.maximumObjectRadiusThreshold;
-                    for (let l = cursorIndices[j]; l < cursors.length; cursorIndices[j] = ++l) {
-                        const cursor = cursors[l];
-                        const prevCursor = cursors[l - 1];
-                        // Cursor is past the object's hit time.
-                        if (prevCursor.time > hitTime) {
-                            break;
-                        }
-                        // Cursor is before the object's hit time.
-                        if (hitTime > cursor.time) {
-                            continue;
-                        }
-                        let distance;
-                        switch (cursor.id) {
-                            case exports.MovementType.up:
-                                distance =
-                                    prevCursor.position.getDistance(objectPosition);
-                                break;
-                            case exports.MovementType.move: {
-                                // Interpolate movement.
-                                const t = (hitTime - prevCursor.time) /
-                                    (cursor.time - prevCursor.time);
-                                const cursorPosition = osuBase.Interpolation.lerp(prevCursor.position, cursor.position, t);
-                                distance =
-                                    objectPosition.getDistance(cursorPosition);
-                                break;
-                            }
-                            case exports.MovementType.down:
-                                continue;
-                        }
-                        closestDistance = Math.min(closestDistance, distance);
-                    }
-                    // At this point, the object is guaranteed to be hit, but the distance may not reach the threshold
-                    // due to radius estimation. In order to work around this, we store the farthest distance from all
-                    // processed cursors so far and use it as threshold rather than the actual object radius.
-                    if (closestDistance <= this.maximumObjectRadiusThreshold &&
-                        closestDistance > this.objectRadiusThreshold) {
-                        this.objectRadiusThreshold = closestDistance;
-                    }
-                    if (closestDistance > this.objectRadiusThreshold) {
-                        cursorInstanceIndices[j] = -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;
                 }
-                // The previous object may still be hit with the same cursor group or cursor index.
-                cursorGroupIndices[j] = Math.max(0, cursorGroupIndices[j] - 1);
-                cursorIndices[j] = Math.max(1, cursorIndices[j] - 1);
+                cursorNearestTime = hitTime - cursor.time;
+            }
+            if (cursorNearestTime < nearestTime) {
+                nearestCursorInstanceIndex = i;
+                nearestTime = cursorNearestTime;
             }
         }
-        return (_a = cursorInstanceIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
+        return nearestCursorInstanceIndex;
     }
     /**
      * Creates nerf factors by scanning through objects.
      */
     calculateNerfFactors() {
         for (const beatmapSection of this.beatmapSections) {
-            const cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+            const threeFingerCursorCounts = osuBase.Utils.initializeArray(Math.max(0, this.downCursorInstances.length - 2), 0);
             for (const object of beatmapSection.objects) {
-                if (object.pressingCursorIndex === -1 ||
-                    object.pressingCursorInstanceIndex ===
-                        beatmapSection.dragFingerIndex) {
+                if (object.pressingCursorInstanceIndex === -1) {
                     continue;
                 }
-                ++cursorCounts[object.pressingCursorInstanceIndex];
-            }
-            if (beatmapSection.dragFingerIndex !== -1) {
-                // Remove the drag index to prevent it from being picked up into the detection.
-                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
+                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;
+                    }
+                }
             }
-            // This index will be used to detect if a section is 3-fingered.
-            // If the section is dragged, the dragged instance will be ignored,
-            // hence why the index is 1 less than nondragged section.
-            const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
-            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
-            // to check if the section is 3-fingered.
-            const threeFingerRatio = cursorCounts
-                .slice(fingerSplitIndex)
-                .reduce((acc, value) => acc + value, 0) /
-                Math.max(cursorCounts
-                    .slice(0, fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0), 1);
-            if (threeFingerRatio > this.threeFingerRatioThreshold) {
-                const threeFingeredObjectCount = cursorCounts
-                    .slice(fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0);
-                const sectionObjectCount = beatmapSection.lastObjectIndex -
-                    beatmapSection.firstObjectIndex +
-                    1;
-                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
-                // We can ignore the first 3 (2 for drag) filled cursor instances
-                // since they are guaranteed not 3 finger.
-                const threeFingerCursorCounts = cursorCounts
-                    .slice(fingerSplitIndex)
-                    .filter((amount) => amount > 0);
-                // Finger factor applies more penalty if more fingers were used.
-                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
-                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
-                // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
-                this.nerfFactors.push({
-                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
-                    fingerFactor: fingerFactor,
-                    lengthFactor: lengthFactor,
-                });
+            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,
+            });
         }
     }
     /**
@@ -773,6 +677,12 @@ class RebalanceThreeFingerChecker {
             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;
+    }
 }
 
 /******************************************************************************
@@ -808,9 +718,9 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Represents a replay data in an osu!droid replay.
+ * Represents a replay data in an osu!droid replay version 1 and 2.
  *
- * Stores generic information about an osu!droid replay such as player name, MD5 hash, time set, etc.
+ * Stores generic information about an osu!droid replay.
  *
  * This is used when analyzing replays using replay analyzer.
  */
@@ -820,45 +730,46 @@ class ReplayData {
         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.accuracy = values.accuracy;
+        this.rank = values.rank;
+        this.hit300k = values.hit300k;
+        this.hit100k = values.hit100k;
         this.cursorMovement = values.cursorMovement;
         this.hitObjectData = values.hitObjectData;
-        this.speedMultiplier = values.speedMultiplier || 1;
-        this.forceCS = values.forceCS;
-        this.forceAR = values.forceAR;
-        this.forceOD = values.forceOD;
-        this.forceHP = values.forceHP;
-        this.flashlightFollowDelay = values.flashlightFollowDelay;
+    }
+    /**
+     * Whether the replay's version is 3 or later.
+     */
+    isReplayV3() {
+        return this.replayVersion >= 3;
+    }
+    /**
+     * Whether the replay's version is 4 or later.
+     */
+    isReplayV4() {
+        return this.replayVersion >= 4;
+    }
+    /**
+     * Whether the replay's version is 5 or later.
+     */
+    isReplayV5() {
+        return this.replayVersion >= 5;
     }
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered.
+ * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
  */
 class ThreeFingerChecker {
+    get hitWindow50() {
+        return this.hitWindow.hitWindowFor50(this.isPrecise);
+    }
     /**
      * @param beatmap The beatmap to analyze.
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
     constructor(beatmap, data, difficultyAttributes) {
-        /**
-         * The ratio threshold between non-3 finger cursors and 3-finger cursors.
-         *
-         * Increasing this number will increase detection accuracy, however
-         * it also increases the chance of falsely flagged plays.
-         */
-        this.threeFingerRatioThreshold = 0.01;
         /**
          * Extended sections of the beatmap for drag detection.
          */
@@ -883,14 +794,9 @@ class ThreeFingerChecker {
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const od = osuBase.calculateDroidDifficultyStatistics({
-            overallDifficulty: beatmap.difficulty.od,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
-            convertOverallDifficulty: false,
-        }).overallDifficulty;
-        this.isPrecise = this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
-        this.hitWindow = new osuBase.DroidHitWindow(od);
-        this.hitObjects = beatmap.hitObjects.objects;
+        this.isPrecise = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise);
+        this.isHardRock = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHardRock);
+        this.hitWindow = new osuBase.DroidHitWindow(beatmap.difficulty.od);
     }
     /**
      * Checks whether a beatmap is eligible to be detected for 3-finger.
@@ -911,7 +817,8 @@ class ThreeFingerChecker {
      * nerf factor, taking beatmap difficulty into account.
      */
     check() {
-        if (this.difficultyAttributes.possibleThreeFingeredSections.length === 0) {
+        if (!ThreeFingerChecker.isEligibleToDetect(this.difficultyAttributes) ||
+            this.data.cursorMovement.filter((v) => v.occurrenceGroups.length > 0).length <= 3) {
             return { is3Finger: false, penalty: 1 };
         }
         this.getAccurateBreakPoints();
@@ -931,10 +838,11 @@ class ThreeFingerChecker {
      * end of the hitobject before it and do not end right at the first hitobject after it.
      */
     getAccurateBreakPoints() {
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         for (const breakPoint of this.beatmap.events.breaks) {
-            const beforeIndex = osuBase.MathUtils.clamp(this.hitObjects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, this.hitObjects.length - 2);
-            const objectBefore = this.hitObjects[beforeIndex];
+            const beforeIndex = osuBase.MathUtils.clamp(objects.findIndex((o) => o.endTime >= breakPoint.startTime) - 1, 0, objects.length - 2);
+            const objectBefore = objects[beforeIndex];
             const objectBeforeData = objectData[beforeIndex];
             let timeBefore = objectBefore.endTime;
             if (objectBefore instanceof osuBase.Circle) {
@@ -946,9 +854,9 @@ class ThreeFingerChecker {
                 }
             }
             const afterIndex = beforeIndex + 1;
-            const objectAfter = this.hitObjects[afterIndex];
+            const objectAfter = objects[afterIndex];
             const objectAfterData = objectData[afterIndex];
-            let timeAfter = this.hitObjects[afterIndex].startTime;
+            let timeAfter = objectAfter.startTime;
             if (objectAfter instanceof osuBase.Circle &&
                 objectAfterData.result !== exports.HitResult.miss) {
                 timeAfter += objectAfterData.accuracy;
@@ -965,11 +873,12 @@ class ThreeFingerChecker {
      * This also filters cursors that are in break period or happen before start/after end of the beatmap.
      */
     filterCursorInstances() {
+        const objects = this.beatmap.hitObjects.objects;
         const objectData = this.data.hitObjectData;
         const firstObjectResult = objectData[0].result;
         const lastObjectResult = objectData.at(-1).result;
-        const firstObject = this.hitObjects[0];
-        const lastObject = this.hitObjects.at(-1);
+        const firstObject = objects[0];
+        const lastObject = objects.at(-1);
         // For sliders, automatically set hit window length to be as lenient as possible.
         let firstObjectHitWindow = this.hitWindow.hitWindowFor50(this.isPrecise);
         if (firstObject instanceof osuBase.Circle) {
@@ -1029,280 +938,217 @@ class ThreeFingerChecker {
      * detect dragged sections and improve detection speed.
      */
     getBeatmapSections() {
-        const cursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        const beatmapObjects = this.beatmap.hitObjects.objects;
+        const aimCursorGroupLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
+        // This intentionally starts from 1 because we need to look at the previous cursor.
+        const aimCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 1);
+        const pressCursorLookupIndices = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
         for (const section of this.difficultyAttributes
             .possibleThreeFingeredSections) {
-            const dragFingerIndex = this.findDragIndex(section);
             const objects = [];
             for (let i = section.firstObjectIndex; i <= section.lastObjectIndex; ++i) {
-                objects.push(Object.assign({ object: this.hitObjects[i] }, this.getObjectPressIndex(this.hitObjects[i], this.data.hitObjectData[i], cursorLookupIndices, dragFingerIndex)));
+                const object = beatmapObjects[i];
+                const objectData = this.data.hitObjectData[i];
+                objects.push({
+                    object: object,
+                    aimingCursorInstanceIndex: this.getObjectAimIndex(object, objectData, aimCursorGroupLookupIndices, aimCursorLookupIndices),
+                    pressingCursorInstanceIndex: this.getObjectPressIndex(object, objectData, pressCursorLookupIndices),
+                });
             }
-            this.beatmapSections.push(Object.assign(Object.assign({}, section), { dragFingerIndex: dragFingerIndex, objects: objects }));
+            this.beatmapSections.push(Object.assign(Object.assign({}, section), { objects: objects }));
         }
     }
     /**
-     * Obtains the index of the nearest cursor of which an object was pressed in terms of time.
+     * Obtains the index of the cursor that aimed the object at the nearest 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.
+     * @param cursorInstanceIndices The cursor indices to start looking for the cursor instance from, to save computation time.
+     * @param cursorGroupIndices The cursor indices to start looking for the cursor group from, to save computation time.
+     * @param cursorIndices The cursor indices to start looking for the cursor from, to save computation time.
      * @returns The index of the cursor, -1 if the object was missed or it's a spinner.
      */
-    getObjectPressIndex(object, objectData, cursorLookupIndices, ...excludedCursorIndices) {
+    getObjectAimIndex(object, objectData, cursorGroupIndices, cursorIndices) {
         if (objectData.result === exports.HitResult.miss || object instanceof osuBase.Spinner) {
-            return {
-                pressingCursorInstanceIndex: -1,
-                pressingCursorIndex: -1,
-            };
+            return -1;
         }
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
         // Check for sliderbreaks and treat them as misses.
         if (object instanceof osuBase.Slider &&
-            objectData.accuracy === Math.floor(hitWindow50) + 13) {
-            return {
-                pressingCursorInstanceIndex: -1,
-                pressingCursorIndex: -1,
-            };
+            objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+            return -1;
         }
-        // We are not directly using hit time to determine which cursor pressed the object
-        // to account for time difference between hit registration and object judgement.
-        let minHitTime = object.startTime;
-        let maxHitTime = object.startTime;
-        if (object instanceof osuBase.Circle) {
-            let hitWindowGap = hitWindow50;
-            switch (objectData.result) {
-                case exports.HitResult.great:
-                    hitWindowGap = this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    hitWindowGap = this.hitWindow.hitWindowFor100(this.isPrecise);
+        const hitTime = object.startTime + objectData.accuracy;
+        const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
+        // We are maintaining the closest distance to the object.
+        // This is because the radius that is calculated is using an estimation.
+        // As such, it does not reflect the actual object radius in gameplay.
+        let closestDistance = Number.POSITIVE_INFINITY;
+        let nearestCursorIndex = -1;
+        // Observe the cursor position at the object's hit time.
+        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+            const cursorData = this.data.cursorMovement[i];
+            for (let j = cursorGroupIndices[i]; j < cursorData.occurrenceGroups.length; cursorGroupIndices[i] = ++j) {
+                const cursorGroup = cursorData.occurrenceGroups[j];
+                if (cursorGroup.endTime < hitTime) {
+                    // Reset cursor index pointer.
+                    cursorIndices[i] = 1;
+                    continue;
+                }
+                if (cursorGroup.startTime > hitTime) {
                     break;
+                }
+                const cursors = cursorGroup.allOccurrences;
+                for (let k = cursorIndices[i]; k < cursors.length; cursorIndices[i] = ++k) {
+                    const cursor = cursors[k];
+                    const prevCursor = cursors[k - 1];
+                    // Cursor is past the object's hit time.
+                    if (prevCursor.time > hitTime) {
+                        break;
+                    }
+                    // Cursor is before the object's hit time.
+                    if (hitTime > cursor.time) {
+                        continue;
+                    }
+                    let distance;
+                    const currentPosition = this.getCursorPosition(cursor);
+                    const prevPosition = this.getCursorPosition(prevCursor);
+                    switch (cursor.id) {
+                        case exports.MovementType.up:
+                            distance = prevPosition.getDistance(objectPosition);
+                            break;
+                        case exports.MovementType.move: {
+                            // Interpolate movement.
+                            const t = (hitTime - prevCursor.time) /
+                                (cursor.time - prevCursor.time);
+                            const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                            distance =
+                                objectPosition.getDistance(cursorPosition);
+                            break;
+                        }
+                        case exports.MovementType.down:
+                            continue;
+                    }
+                    if (closestDistance > distance) {
+                        closestDistance = distance;
+                        nearestCursorIndex = i;
+                    }
+                }
+                // Reset cursor index pointer on end of group.
+                if (cursorIndices[i] === cursors.length) {
+                    cursorIndices[i] = 1;
+                }
+                break;
             }
-            minHitTime -= hitWindowGap;
-            maxHitTime += hitWindowGap;
+            // 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;
         }
-        else if (object instanceof osuBase.Slider) {
-            minHitTime -= hitWindow50;
-            maxHitTime += Math.min(hitWindow50, object.spanDuration);
+        // Check for sliderbreaks and treat them as misses.
+        if (object instanceof osuBase.Slider &&
+            objectData.accuracy === Math.floor(this.hitWindow50) + 13) {
+            return -1;
         }
         const hitTime = object.startTime + objectData.accuracy;
-        let nearestCursorInstanceIndex = null;
-        let nearestCursorIndex = null;
+        let nearestCursorInstanceIndex = -1;
         let nearestTime = Number.POSITIVE_INFINITY;
         for (let i = 0; i < this.downCursorInstances.length; ++i) {
-            if (excludedCursorIndices.includes(i)) {
-                continue;
-            }
             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 < minHitTime) {
-                    continue;
-                }
-                if (cursor.time > maxHitTime) {
-                    break;
-                }
-                const deltaTime = Math.abs(hitTime - cursor.time);
-                if (deltaTime > nearestTime) {
+                if (cursor.time > hitTime) {
                     break;
                 }
+                cursorNearestTime = hitTime - cursor.time;
+            }
+            if (cursorNearestTime < nearestTime) {
                 nearestCursorInstanceIndex = i;
-                nearestCursorIndex = j;
-                nearestTime = deltaTime;
+                nearestTime = cursorNearestTime;
             }
         }
-        return {
-            pressingCursorInstanceIndex: nearestCursorInstanceIndex !== null && nearestCursorInstanceIndex !== void 0 ? nearestCursorInstanceIndex : -1,
-            pressingCursorIndex: nearestCursorIndex !== null && nearestCursorIndex !== void 0 ? nearestCursorIndex : -1,
-        };
+        return nearestCursorInstanceIndex;
     }
     /**
-     * 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.
+     * Creates nerf factors by scanning through objects.
      */
-    findDragIndex(section) {
-        var _a;
-        const objectData = this.data.hitObjectData;
-        const firstObject = this.hitObjects[section.firstObjectIndex];
-        const lastObject = this.hitObjects[section.lastObjectIndex];
-        let firstObjectMinHitTime = firstObject.startTime;
-        if (firstObject instanceof osuBase.Circle) {
-            switch (objectData[section.firstObjectIndex].result) {
-                case exports.HitResult.great:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
+    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;
+                    }
+                }
             }
-        }
-        else if (firstObject instanceof osuBase.Slider) {
-            firstObjectMinHitTime -= this.hitWindow.hitWindowFor50(this.isPrecise);
-        }
-        let lastObjectMaxHitTime = lastObject.startTime;
-        if (lastObject instanceof osuBase.Circle) {
-            switch (objectData[section.lastObjectIndex].result) {
-                case exports.HitResult.great:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor300(this.isPrecise);
-                    break;
-                case exports.HitResult.good:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor100(this.isPrecise);
-                    break;
-                default:
-                    lastObjectMaxHitTime += this.hitWindow.hitWindowFor50(this.isPrecise);
+            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,
+            });
         }
-        else if (lastObject instanceof osuBase.Slider) {
-            lastObjectMaxHitTime += Math.min(this.hitWindow.hitWindowFor50(this.isPrecise), lastObject.spanDuration);
-        }
-        // Since there may be more than 1 cursor instance index,
-        // we check which cursor instance follows hitobjects all over.
-        const cursorIndices = [];
-        for (let i = 0; i < this.data.cursorMovement.length; ++i) {
-            const c = this.data.cursorMovement[i];
-            if (c.occurrenceGroups.length === 0) {
-                continue;
-            }
-            // Do not include cursors that don't have an occurence in this section
-            // this speeds up checking process.
-            if (c.occurrenceGroups.filter((v) => v.startTime >= firstObjectMinHitTime &&
-                v.endTime <= lastObjectMaxHitTime).length === 0) {
-                continue;
-            }
-            // If this cursor instance doesn't move, it's not the cursor instance we want.
-            if (c.occurrenceGroups.filter((v) => v.moves.length > 0).length ===
-                0) {
-                continue;
-            }
-            cursorIndices.push(i);
-        }
-        const sectionObjects = this.hitObjects.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
-        const sectionReplayObjectData = objectData.slice(section.firstObjectIndex, section.lastObjectIndex + 1);
-        const hitWindow50 = this.hitWindow.hitWindowFor50(this.isPrecise);
-        for (let i = 0; i < sectionObjects.length && cursorIndices.some((v) => v !== -1); ++i) {
-            const object = sectionObjects[i];
-            const objectData = sectionReplayObjectData[i];
-            if (object instanceof osuBase.Spinner ||
-                objectData.result === exports.HitResult.miss) {
-                continue;
-            }
-            // Exclude sliderbreaks.
-            if (object instanceof osuBase.Slider &&
-                objectData.accuracy === Math.floor(hitWindow50) + 13) {
-                continue;
-            }
-            const objectPosition = object.getStackedPosition(osuBase.Modes.droid);
-            const hitTime = object.startTime + objectData.accuracy;
-            // Observe the cursor position at the object's hit time.
-            for (let j = 0; j < cursorIndices.length; ++j) {
-                if (cursorIndices[j] === -1) {
-                    continue;
-                }
-                const cursorData = this.data.cursorMovement[cursorIndices[j]];
-                const cursorGroup = cursorData.occurrenceGroups.find((v) => v.isActiveAt(hitTime));
-                if (!cursorGroup) {
-                    continue;
-                }
-                const cursors = cursorGroup.allOccurrences;
-                let isInObject = false;
-                for (let k = 1; k < cursors.length; ++k) {
-                    const cursor = cursors[k];
-                    const prevCursor = cursors[k - 1];
-                    // Only consider cursor at interval prev.time <= hitTime <= current.time.
-                    if (prevCursor.time <= hitTime && cursor.time >= hitTime) {
-                        switch (cursor.id) {
-                            case exports.MovementType.up:
-                                isInObject =
-                                    prevCursor.position.getDistance(objectPosition) <= object.radius;
-                                break;
-                            case exports.MovementType.move: {
-                                // Interpolate movement.
-                                const t = (hitTime - prevCursor.time) /
-                                    (cursor.time - prevCursor.time);
-                                const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevCursor.position.x, cursor.position.x, t), osuBase.Interpolation.lerp(prevCursor.position.y, cursor.position.y, t));
-                                isInObject =
-                                    objectPosition.getDistance(cursorPosition) <= object.radius;
-                            }
-                        }
-                        break;
-                    }
-                }
-                if (!isInObject) {
-                    cursorIndices[j] = -1;
-                }
-            }
-        }
-        return (_a = cursorIndices.find((v) => v !== -1)) !== null && _a !== void 0 ? _a : -1;
-    }
-    /**
-     * Creates nerf factors by scanning through objects.
-     */
-    calculateNerfFactors() {
-        for (const beatmapSection of this.beatmapSections) {
-            const cursorCounts = osuBase.Utils.initializeArray(this.downCursorInstances.length, 0);
-            for (const object of beatmapSection.objects) {
-                if (object.pressingCursorIndex === -1 ||
-                    object.pressingCursorInstanceIndex ===
-                        beatmapSection.dragFingerIndex) {
-                    continue;
-                }
-                ++cursorCounts[object.pressingCursorInstanceIndex];
-            }
-            if (beatmapSection.dragFingerIndex !== -1) {
-                // Remove the drag index to prevent it from being picked up into the detection.
-                cursorCounts.splice(beatmapSection.dragFingerIndex, 1);
-            }
-            // This index will be used to detect if a section is 3-fingered.
-            // If the section is dragged, the dragged instance will be ignored,
-            // hence why the index is 1 less than nondragged section.
-            const fingerSplitIndex = beatmapSection.dragFingerIndex !== -1 ? 2 : 3;
-            // Divide >=4th (3rd for drag) cursor instances with 1st + 2nd (+ 3rd for nondrag)
-            // to check if the section is 3-fingered.
-            const threeFingerRatio = cursorCounts
-                .slice(fingerSplitIndex)
-                .reduce((acc, value) => acc + value, 0) /
-                Math.max(cursorCounts
-                    .slice(0, fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0), 1);
-            if (threeFingerRatio > this.threeFingerRatioThreshold) {
-                const threeFingeredObjectCount = cursorCounts
-                    .slice(fingerSplitIndex)
-                    .reduce((acc, value) => acc + value, 0);
-                const sectionObjectCount = beatmapSection.lastObjectIndex -
-                    beatmapSection.firstObjectIndex +
-                    1;
-                const threeFingeredObjectRatio = threeFingeredObjectCount / sectionObjectCount;
-                // We can ignore the first 3 (2 for drag) filled cursor instances
-                // since they are guaranteed not 3 finger.
-                const threeFingerCursorCounts = cursorCounts
-                    .slice(fingerSplitIndex)
-                    .filter((amount) => amount > 0);
-                // Finger factor applies more penalty if more fingers were used.
-                const fingerFactor = threeFingerCursorCounts.reduce((acc, count, index) => acc +
-                    Math.pow((index + 1) * count * threeFingeredObjectRatio, 0.9), 1);
-                // Length factor applies more penalty if there are more 3-fingered object.
-                const lengthFactor = 1 + Math.pow(threeFingeredObjectRatio, 1.2);
-                this.nerfFactors.push({
-                    strainFactor: beatmapSection.sumStrain * threeFingeredObjectRatio,
-                    fingerFactor: fingerFactor,
-                    lengthFactor: lengthFactor,
-                });
-            }
+    }
+    /**
+     * Calculates the final penalty.
+     */
+    calculateFinalPenalty() {
+        return this.nerfFactors.reduce((a, n) => a +
+            0.015 *
+                Math.pow(n.strainFactor * n.fingerFactor * n.lengthFactor, 1.05), 1);
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
         }
-    }
-    /**
-     * 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);
+        return cursor.position;
     }
 }
 
@@ -1349,13 +1195,11 @@ class TwoHandChecker {
         this.indexedHitObjects = [];
         this.calculator = calculator;
         this.data = data;
-        const od = osuBase.calculateDroidDifficultyStatistics({
-            overallDifficulty: calculator.beatmap.difficulty.od,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
-            convertOverallDifficulty: false,
-        }).overallDifficulty;
-        this.hitWindow = new osuBase.DroidHitWindow(od);
+        const greatWindow = new osuBase.OsuHitWindow(calculator.attributes.overallDifficulty).hitWindowFor300() * calculator.attributes.clockRate;
+        const isPrecise = calculator.mods.some((m) => m instanceof osuBase.ModPrecise);
+        this.hitWindow = new osuBase.DroidHitWindow(osuBase.DroidHitWindow.hitWindow300ToOD(greatWindow, isPrecise));
         this.hitWindow50 = this.hitWindow.hitWindowFor50(calculator.mods.some((m) => m instanceof osuBase.ModPrecise));
+        this.isHardRock = calculator.mods.some((m) => m instanceof osuBase.ModHardRock);
         // this.csvString = `Mods,${
         //     data.convertedMods.reduce((a, m) => a + m.acronym, "") || "NM"
         // }\nCombo,${data.maxCombo}\nAccuracy,"${(
@@ -1576,13 +1420,15 @@ class TwoHandChecker {
         for (let i = prevObjectInformation.occurrenceIndex + 1; i < cursors.length; ++i) {
             const cursor = cursors[i];
             const prevCursor = cursors[i - 1];
-            if (cursor.position.equals(prevCursor.position)) {
+            const currentPosition = this.getCursorPosition(cursor);
+            const prevPosition = this.getCursorPosition(prevCursor);
+            if (currentPosition.equals(prevPosition)) {
                 continue;
             }
             if (cursor.id === exports.MovementType.up) {
                 break;
             }
-            const currentMovement = cursor.position.subtract(prevCursor.position);
+            const currentMovement = currentPosition.subtract(prevPosition);
             const dot = prevToCurrentCursorMovement.dot(currentMovement);
             const det = prevToCurrentCursorMovement.x * currentMovement.y -
                 prevToCurrentCursorMovement.y * currentMovement.x;
@@ -1668,7 +1514,7 @@ class TwoHandChecker {
             };
         }
         let hitWindow = this.hitWindow50;
-        const isPrecise = this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise);
+        const isPrecise = this.calculator.mods.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) {
@@ -1706,14 +1552,14 @@ class TwoHandChecker {
                 }
                 // Validate the down press first.
                 const { down } = cursorGroup;
-                if (down.position.getDistance(objectPosition) <=
-                    object.radius &&
+                const downPosition = this.getCursorPosition(down);
+                if (downPosition.getDistance(objectPosition) <= object.radius &&
                     Math.abs(down.time - object.startTime) <= hitWindow) {
                     if (objectIndex > 0) {
                         const prevObject = this.calculator.beatmap.hitObjects.objects[objectIndex - 1];
                         if (down.time > prevObject.endTime) {
                             return {
-                                position: down.position,
+                                position: downPosition,
                                 cursorIndex: i,
                                 groupIndex: j,
                                 occurrenceIndex: 0,
@@ -1723,7 +1569,7 @@ class TwoHandChecker {
                     }
                     else {
                         return {
-                            position: down.position,
+                            position: downPosition,
                             cursorIndex: i,
                             groupIndex: j,
                             occurrenceIndex: 0,
@@ -1743,7 +1589,7 @@ class TwoHandChecker {
                     }
                     let cursorPosition;
                     if (cursor.id === exports.MovementType.up) {
-                        cursorPosition = prevCursor.position;
+                        cursorPosition = this.getCursorPosition(prevCursor);
                         const distance = cursorPosition.getDistance(objectPosition);
                         if (distance <
                             nearestPosition.getDistance(objectPosition)) {
@@ -1768,7 +1614,7 @@ class TwoHandChecker {
                             }
                             const t = (cursorGroup.down.time - prevCursor.time) /
                                 (cursor.time - prevCursor.time);
-                            cursorPosition = osuBase.Interpolation.lerp(prevCursor.position, cursor.position, t);
+                            cursorPosition = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), t);
                             const distance = cursorPosition.getDistance(objectPosition);
                             if (distance <
                                 nearestPosition.getDistance(objectPosition)) {
@@ -1853,18 +1699,18 @@ class TwoHandChecker {
                     let cursorPosition;
                     switch (cursor.id) {
                         case exports.MovementType.down:
-                            cursorPosition = cursor.position;
+                            cursorPosition = this.getCursorPosition(cursor);
                             break;
                         case exports.MovementType.up: {
                             const prevCursor = cursors[k - 1];
-                            cursorPosition = prevCursor.position;
+                            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(prevCursor.position, cursor.position, t);
+                            cursorPosition = osuBase.Interpolation.lerp(this.getCursorPosition(prevCursor), this.getCursorPosition(cursor), t);
                             break;
                         }
                     }
@@ -1926,6 +1772,12 @@ class TwoHandChecker {
         }
         return false;
     }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
 }
 
 /**
@@ -1941,12 +1793,8 @@ class SliderCheeseChecker {
         this.beatmap = beatmap;
         this.data = data;
         this.difficultyAttributes = difficultyAttributes;
-        const od = osuBase.calculateDroidDifficultyStatistics({
-            overallDifficulty: beatmap.difficulty.od,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
-            convertOverallDifficulty: false,
-        }).overallDifficulty;
-        this.hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
+        this.hitWindow50 = new osuBase.DroidHitWindow(beatmap.difficulty.od).hitWindowFor50(difficultyAttributes.mods.some((m) => m instanceof osuBase.ModPrecise));
+        this.isHardRock = difficultyAttributes.mods.some((m) => m instanceof osuBase.ModHardRock);
     }
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
@@ -1972,7 +1820,7 @@ class SliderCheeseChecker {
         const { objects } = this.beatmap.hitObjects;
         const cheesedDifficultyRatings = [];
         // Current loop indices are stored for efficiency.
-        const cursorLoopIndices = osuBase.Utils.initializeArray(10, 0);
+        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
@@ -2010,7 +1858,8 @@ class SliderCheeseChecker {
                         break;
                     }
                     if (group.startTime >= minTimeLimit) {
-                        const distance = group.down.position.getDistance(objectStartPosition);
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
                         if (closestDistance > distance) {
                             closestDistance = distance;
                             closestIndex = j;
@@ -2024,20 +1873,22 @@ class SliderCheeseChecker {
                     // for the time being we only check for cursor distances across the group.
                     const { allOccurrences } = group;
                     for (let k = 1; k < allOccurrences.length; ++k) {
-                        const occurrence = allOccurrences[k];
-                        const prevOccurrence = allOccurrences[k - 1];
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
                         let distance = Number.POSITIVE_INFINITY;
-                        switch (occurrence.id) {
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
                             case exports.MovementType.up:
                                 distance =
-                                    prevOccurrence.position.getDistance(objectStartPosition);
+                                    prevPosition.getDistance(objectStartPosition);
                                 break;
                             case exports.MovementType.move:
-                                for (let mSecPassed = Math.max(prevOccurrence.time, minTimeLimit); mSecPassed <=
-                                    Math.min(occurrence.time, maxTimeLimit); ++mSecPassed) {
-                                    const t = (mSecPassed - prevOccurrence.time) /
-                                        (occurrence.time - prevOccurrence.time);
-                                    const cursorPosition = new osuBase.Vector2(osuBase.Interpolation.lerp(prevOccurrence.position.x, occurrence.position.x, t), osuBase.Interpolation.lerp(prevOccurrence.position.y, occurrence.position.y, t));
+                                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) {
@@ -2095,21 +1946,24 @@ class SliderCheeseChecker {
                 if (occurrenceLoopIndex === allOccurrences.length) {
                     continue;
                 }
-                const occurrence = allOccurrences[occurrenceLoopIndex];
-                const prevOccurrence = allOccurrences[occurrenceLoopIndex - 1];
-                switch (occurrence.id) {
+                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 - 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 t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
                         const distance = cursorPosition.getDistance(nestedPosition);
                         isCheesed = distance > acceptableRadius;
                         break;
                     }
                     case exports.MovementType.up:
                         isCheesed =
-                            prevOccurrence.position.getDistance(nestedPosition) > acceptableRadius;
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
                 }
             }
             if (isCheesed) {
@@ -2135,6 +1989,65 @@ class SliderCheeseChecker {
                     this.difficultyAttributes.visualSliderFactor, 2)),
         };
     }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
+
+/**
+ * Represents a replay data for replay version 3.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayV3Data extends ReplayData {
+    constructor(values) {
+        super(values);
+        this.time = values.time;
+        this.score = values.score;
+        this.maxCombo = values.maxCombo;
+        this.isFullCombo = values.isFullCombo;
+        this.playerName = values.playerName;
+        this.rawMods = values.rawMods;
+        this.convertedMods = values.convertedMods;
+    }
+}
+
+/**
+ * Represents a replay data for replay version 4.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayV4Data extends ReplayV3Data {
+    constructor(values) {
+        var _a, _b;
+        super(values);
+        this.forceAR = values.forceAR;
+        this.speedMultiplier = (_a = values.speedMultiplier) !== null && _a !== void 0 ? _a : 1;
+        this.flashlightFollowDelay = (_b = values.flashlightFollowDelay) !== null && _b !== void 0 ? _b : 0.12;
+    }
+}
+
+/**
+ * Represents a replay data for replay version 5.
+ *
+ * Stores generic information about an osu!droid replay.
+ *
+ * This is used when analyzing replays using replay analyzer.
+ */
+class ReplayV5Data extends ReplayV4Data {
+    constructor(values) {
+        super(values);
+        this.forceCS = values.forceCS;
+        this.forceOD = values.forceOD;
+        this.forceHP = values.forceHP;
+    }
 }
 
 /**
@@ -2190,6 +2103,7 @@ class ReplayAnalyzer {
          * The amount of two-handed objects.
          */
         this.twoHandedNoteCount = 0;
+        this.bufferOffset = 0;
         this.scoreID = values.scoreID;
         this.beatmap = values.map;
         this.difficultyAttributes = values.difficultyAttributes;
@@ -2218,6 +2132,117 @@ class ReplayAnalyzer {
             return this;
         });
     }
+    /**
+     * Gets hit error information of the replay.
+     *
+     * `analyze()` must be called before calling this.
+     */
+    calculateHitError() {
+        var _a, _b;
+        if (!this.data || !this.beatmap) {
+            return null;
+        }
+        const hitObjectData = this.data.hitObjectData;
+        let positiveCount = 0;
+        let negativeCount = 0;
+        let positiveTotal = 0;
+        let negativeTotal = 0;
+        const beatmap = this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+            this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
+            ? this.beatmap.beatmap
+            : this.beatmap;
+        const { objects } = beatmap.hitObjects;
+        const mods = this.data.isReplayV3()
+            ? this.data.convertedMods
+            : (_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods.filter((m) => m.isApplicableToDroid())) !== null && _b !== void 0 ? _b : [];
+        const adjustedDifficulty = new osuBase.BeatmapDifficulty(beatmap.difficulty);
+        osuBase.ModUtil.applyModsToBeatmapDifficulty(adjustedDifficulty, osuBase.Modes.droid, mods, this.data.isReplayV4() ? this.data.speedMultiplier : 1);
+        const hitWindow50 = new osuBase.DroidHitWindow(adjustedDifficulty.od).hitWindowFor50(mods.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;
+            if (o instanceof osuBase.Slider && 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,
+        };
+    }
+    /**
+     * Checks if a play is using 3 fingers.
+     *
+     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
+     */
+    checkFor3Finger() {
+        var _a;
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
+            return;
+        }
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceThreeFingerChecker(this.playableBeatmap, this.data, this.difficultyAttributes)
+            : new ThreeFingerChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        const result = threeFingerChecker.check();
+        this.is3Finger = result.is3Finger;
+        this.tapPenalty = result.penalty;
+        this.hasBeenCheckedFor3Finger = true;
+    }
+    /**
+     * 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` and `difficultyAttributes` to be defined.
+     */
+    checkForSliderCheesing() {
+        var _a;
+        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
+            return;
+        }
+        (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
+        const sliderCheeseChecker = new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        this.sliderCheesePenalty = sliderCheeseChecker.check();
+        this.hasBeenCheckedForSliderCheesing = true;
+    }
     /**
      * Downloads the given score ID's replay.
      */
@@ -2264,7 +2289,6 @@ class ReplayAnalyzer {
      * Parses a replay after being downloaded and converted to a buffer.
      */
     parseReplay() {
-        var _a, _b, _c;
         if (!this.fixedODR) {
             return;
         }
@@ -2275,7 +2299,7 @@ class ReplayAnalyzer {
         try {
             rawObject = javaDeserialization__namespace.parse(this.fixedODR);
         }
-        catch (_d) {
+        catch (_a) {
             return;
         }
         const resultObject = {
@@ -2286,67 +2310,32 @@ class ReplayAnalyzer {
             cursorMovement: [],
             hitObjectData: [],
             accuracy: new osuBase.Accuracy({ n300: 0 }),
-            rank: "",
-        };
-        const determineRank = () => {
-            var _a, _b;
-            const totalHits = resultObject.accuracy.n300 +
-                resultObject.accuracy.n100 +
-                resultObject.accuracy.n50 +
-                resultObject.accuracy.nmiss;
-            const isHidden = (_b = (_a = resultObject.convertedMods) === null || _a === void 0 ? void 0 : _a.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight)) !== null && _b !== void 0 ? _b : false;
-            const hit300Ratio = resultObject.accuracy.n300 / totalHits;
-            switch (true) {
-                case resultObject.accuracy.value() === 1:
-                    if (isHidden) {
-                        resultObject.rank = "XH";
-                    }
-                    else {
-                        resultObject.rank = "X";
-                    }
-                    break;
-                case hit300Ratio > 0.9 &&
-                    resultObject.accuracy.n50 / totalHits < 0.01 &&
-                    !resultObject.accuracy.nmiss:
-                    if (isHidden) {
-                        resultObject.rank = "SH";
-                    }
-                    else {
-                        resultObject.rank = "S";
-                    }
-                    break;
-                case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
-                    hit300Ratio > 0.9:
-                    resultObject.rank = "A";
-                    break;
-                case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
-                    hit300Ratio > 0.8:
-                    resultObject.rank = "B";
-                    break;
-                case hit300Ratio > 0.6:
-                    resultObject.rank = "C";
-                    break;
-                default:
-                    resultObject.rank = "D";
-            }
+            rank: "D",
+            convertedMods: [],
+            hit100k: 0,
+            hit300k: 0,
+            isFullCombo: false,
+            maxCombo: 0,
+            playerName: "",
+            rawMods: [],
+            score: 0,
+            time: new Date(0),
         };
         if (resultObject.replayVersion >= 3) {
-            resultObject.time = new Date(Number(rawObject[4].readBigUInt64BE(0)));
+            resultObject.time.setTime(Number(rawObject[4].readBigUInt64BE(0)));
             resultObject.hit300k = rawObject[4].readInt32BE(8);
+            resultObject.accuracy.n300 = rawObject[4].readInt32BE(12);
             resultObject.hit100k = rawObject[4].readInt32BE(16);
+            resultObject.accuracy.n100 = rawObject[4].readInt32BE(20);
+            resultObject.accuracy.n50 = rawObject[4].readInt32BE(24);
+            resultObject.accuracy.nmiss = rawObject[4].readInt32BE(28);
             resultObject.score = rawObject[4].readInt32BE(32);
             resultObject.maxCombo = rawObject[4].readInt32BE(36);
-            resultObject.accuracy = new osuBase.Accuracy({
-                n300: rawObject[4].readInt32BE(12),
-                n100: rawObject[4].readInt32BE(20),
-                n50: rawObject[4].readInt32BE(24),
-                nmiss: rawObject[4].readInt32BE(28),
-            });
             resultObject.isFullCombo = !!rawObject[4][44];
             resultObject.playerName = rawObject[5];
-            resultObject.rawMods = rawObject[6].elements;
-            resultObject.convertedMods = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(rawObject[6].elements));
-            determineRank();
+            resultObject.rawMods = Object.values(rawObject[6].elements);
+            resultObject.convertedMods = osuBase.ModUtil.droidStringToMods(this.convertDroidMods(resultObject.rawMods));
+            resultObject.rank = this.calculateRank(resultObject);
         }
         if (resultObject.replayVersion >= 4) {
             const str = rawObject[7].split("|");
@@ -2398,32 +2387,87 @@ class ReplayAnalyzer {
         }
         // Merge all cursor movement and hit object data section into one for better control when parsing
         const replayDataBuffer = Buffer.concat(replayDataBufferArray);
-        const bufferCounter = { counter: 0 };
-        const size = this.readInt(replayDataBuffer, bufferCounter);
-        // Parse movement data
-        for (let x = 0; x < size; x++) {
-            const moveSize = this.readInt(replayDataBuffer, bufferCounter);
+        this.bufferOffset = 0;
+        this.parseMovementData(resultObject, replayDataBuffer);
+        this.parseHitObjectData(resultObject, replayDataBuffer);
+        this.parseOldReplayInformation(resultObject);
+        switch (resultObject.replayVersion) {
+            case 3:
+                this.data = new ReplayV3Data(resultObject);
+                break;
+            case 4:
+                this.data = new ReplayV4Data(resultObject);
+                break;
+            case 5:
+                this.data = new ReplayV5Data(resultObject);
+                break;
+            default:
+                this.data = new ReplayData(resultObject);
+        }
+    }
+    /**
+     * Converts replay mods to droid mod string.
+     */
+    convertDroidMods(replayMods) {
+        const replayModsConstants = {
+            MOD_AUTO: new osuBase.ModAuto().droidString,
+            MOD_AUTOPILOT: new osuBase.ModAutopilot().droidString,
+            MOD_NOFAIL: new osuBase.ModNoFail().droidString,
+            MOD_EASY: new osuBase.ModEasy().droidString,
+            MOD_HIDDEN: new osuBase.ModHidden().droidString,
+            MOD_HARDROCK: new osuBase.ModHardRock().droidString,
+            MOD_DOUBLETIME: new osuBase.ModDoubleTime().droidString,
+            MOD_HALFTIME: new osuBase.ModHalfTime().droidString,
+            MOD_NIGHTCORE: new osuBase.ModNightCore().droidString,
+            MOD_PRECISE: new osuBase.ModPrecise().droidString,
+            MOD_SMALLCIRCLE: new osuBase.ModSmallCircle().droidString,
+            MOD_SPEEDUP: new osuBase.ModSpeedUp().droidString,
+            MOD_REALLYEASY: new osuBase.ModReallyEasy().droidString,
+            MOD_RELAX: new osuBase.ModRelax().droidString,
+            MOD_PERFECT: new osuBase.ModPerfect().droidString,
+            MOD_SUDDENDEATH: new osuBase.ModSuddenDeath().droidString,
+            MOD_SCOREV2: new osuBase.ModScoreV2().droidString,
+            MOD_FLASHLIGHT: new osuBase.ModFlashlight().droidString,
+        };
+        let modString = "";
+        for (const mod of replayMods) {
+            for (const property in replayModsConstants) {
+                if (!mod.includes(property)) {
+                    continue;
+                }
+                modString +=
+                    replayModsConstants[property];
+                break;
+            }
+        }
+        return modString;
+    }
+    parseMovementData(resultObject, replayDataBuffer) {
+        resultObject.cursorMovement.length = 0;
+        const size = this.readInt(replayDataBuffer);
+        for (let i = 0; i < size; i++) {
+            const moveSize = this.readInt(replayDataBuffer);
             const time = [];
             const x = [];
             const y = [];
             const id = [];
-            for (let i = 0; i < moveSize; i++) {
-                time[i] = this.readInt(replayDataBuffer, bufferCounter);
-                id[i] = time[i] & 3;
-                time[i] >>= 2;
-                if (id[i] !== exports.MovementType.up) {
+            for (let j = 0; j < moveSize; j++) {
+                time[j] = this.readInt(replayDataBuffer);
+                id[j] = time[j] & 3;
+                time[j] >>= 2;
+                if (id[j] !== exports.MovementType.up) {
                     if (resultObject.replayVersion >= 5) {
-                        x[i] = this.readFloat(replayDataBuffer, bufferCounter);
-                        y[i] = this.readFloat(replayDataBuffer, bufferCounter);
+                        x[j] = this.readFloat(replayDataBuffer);
+                        y[j] = this.readFloat(replayDataBuffer);
                     }
                     else {
-                        x[i] = this.readShort(replayDataBuffer, bufferCounter);
-                        y[i] = this.readShort(replayDataBuffer, bufferCounter);
+                        x[j] = this.readShort(replayDataBuffer);
+                        y[j] = this.readShort(replayDataBuffer);
                     }
                 }
                 else {
-                    x[i] = -1;
-                    y[i] = -1;
+                    x[j] = -1;
+                    y[j] = -1;
                 }
             }
             resultObject.cursorMovement.push(new CursorData({
@@ -2434,7 +2478,10 @@ class ReplayAnalyzer {
                 id: id,
             }));
         }
-        const replayObjectLength = this.readInt(replayDataBuffer, bufferCounter);
+    }
+    parseHitObjectData(resultObject, replayDataBuffer) {
+        resultObject.hitObjectData.length = 0;
+        const replayObjectLength = this.readInt(replayDataBuffer);
         // Parse result data
         for (let i = 0; i < replayObjectLength; i++) {
             const replayObjectData = {
@@ -2442,12 +2489,12 @@ class ReplayAnalyzer {
                 tickset: [],
                 result: exports.HitResult.miss,
             };
-            replayObjectData.accuracy = this.readShort(replayDataBuffer, bufferCounter);
-            const len = this.readByte(replayDataBuffer, bufferCounter);
+            replayObjectData.accuracy = this.readShort(replayDataBuffer);
+            const len = this.readByte(replayDataBuffer);
             if (len > 0) {
                 const bytes = [];
                 for (let j = 0; j < len; j++) {
-                    bytes.push(this.readByte(replayDataBuffer, bufferCounter));
+                    bytes.push(this.readByte(replayDataBuffer));
                 }
                 // Int/int division in Java; numbers must be truncated to get actual number
                 for (let j = 0; j < len * 8; j++) {
@@ -2457,265 +2504,137 @@ class ReplayAnalyzer {
                 }
             }
             if (resultObject.replayVersion >= 1) {
-                replayObjectData.result = this.readByte(replayDataBuffer, bufferCounter);
+                replayObjectData.result = this.readByte(replayDataBuffer);
             }
             resultObject.hitObjectData.push(replayObjectData);
         }
-        // Parse max combo, hit results, and accuracy in old replay version
-        if (resultObject.replayVersion < 3) {
-            const objects = (_a = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
-                this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
-                ? this.beatmap.beatmap
-                : this.beatmap)) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
-            let grantsGekiOrKatu = true;
-            for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
-                // Hit result
-                const hitObjectData = resultObject.hitObjectData[i];
-                const isNextNewCombo = objects
-                    ? i + 1 !== objects.length
-                        ? objects[i + 1].isNewCombo
-                        : true
-                    : false;
-                switch (hitObjectData.result) {
-                    case exports.HitResult.miss:
-                        ++resultObject.accuracy.nmiss;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.HitResult.meh:
-                        ++resultObject.accuracy.n50;
-                        grantsGekiOrKatu = false;
-                        break;
-                    case exports.HitResult.good:
-                        ++resultObject.accuracy.n100;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            (_b = resultObject.hit100k) !== null && _b !== void 0 ? _b : (resultObject.hit100k = 0);
-                            ++resultObject.hit100k;
-                        }
-                        break;
-                    case exports.HitResult.great:
-                        ++resultObject.accuracy.n300;
-                        if (grantsGekiOrKatu && isNextNewCombo) {
-                            (_c = resultObject.hit300k) !== null && _c !== void 0 ? _c : (resultObject.hit300k = 0);
-                            ++resultObject.hit300k;
-                        }
-                        break;
-                }
-                if (isNextNewCombo) {
-                    grantsGekiOrKatu = true;
-                }
-            }
-            determineRank();
-        }
-        this.data = new ReplayData(resultObject);
     }
-    /**
-     * Gets hit error information of the replay.
-     *
-     * `analyze()` must be called before calling this.
-     */
-    calculateHitError() {
-        if (!this.data || !this.beatmap) {
-            return null;
+    parseOldReplayInformation(resultObject) {
+        var _a, _b, _c;
+        // Parse max combo, hit results, and accuracy in old replay version
+        if (resultObject.replayVersion >= 3) {
+            return;
         }
-        const hitObjectData = this.data.hitObjectData;
-        let positiveCount = 0;
-        let negativeCount = 0;
-        let positiveTotal = 0;
-        let negativeTotal = 0;
-        const beatmap = this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
+        const objects = (_a = (this.beatmap instanceof osuDifficultyCalculator.DroidDifficultyCalculator ||
             this.beatmap instanceof osuRebalanceDifficultyCalculator.DroidDifficultyCalculator
             ? this.beatmap.beatmap
-            : this.beatmap;
-        const { objects } = beatmap.hitObjects;
-        const od = osuBase.calculateDroidDifficultyStatistics({
-            overallDifficulty: beatmap.difficulty.od,
-            mods: osuBase.ModUtil.removeSpeedChangingMods(this.data.convertedMods),
-        }).overallDifficulty;
-        const hitWindow50 = new osuBase.DroidHitWindow(od).hitWindowFor50(this.data.convertedMods.some((m) => m instanceof osuBase.ModPrecise));
-        // The accuracy of sliders is set to (50 hit window)ms + 13ms if their head was not hit:
-        // https://github.com/osudroid/osu-droid/blob/6306c68e3ffaf671eac794bf45cc95c0f3313a82/src/ru/nsu/ccfit/zuev/osu/game/Slider.java#L821
-        //
-        // 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;
-            if (o instanceof osuBase.Slider && 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_AUTO: new osuBase.ModAuto().droidString,
-            MOD_AUTOPILOT: new osuBase.ModAutopilot().droidString,
-            MOD_NOFAIL: new osuBase.ModNoFail().droidString,
-            MOD_EASY: new osuBase.ModEasy().droidString,
-            MOD_HIDDEN: new osuBase.ModHidden().droidString,
-            MOD_HARDROCK: new osuBase.ModHardRock().droidString,
-            MOD_DOUBLETIME: new osuBase.ModDoubleTime().droidString,
-            MOD_HALFTIME: new osuBase.ModHalfTime().droidString,
-            MOD_NIGHTCORE: new osuBase.ModNightCore().droidString,
-            MOD_PRECISE: new osuBase.ModPrecise().droidString,
-            MOD_SMALLCIRCLE: new osuBase.ModSmallCircle().droidString,
-            MOD_SPEEDUP: new osuBase.ModSpeedUp().droidString,
-            MOD_REALLYEASY: new osuBase.ModReallyEasy().droidString,
-            MOD_RELAX: new osuBase.ModRelax().droidString,
-            MOD_PERFECT: new osuBase.ModPerfect().droidString,
-            MOD_SUDDENDEATH: new osuBase.ModSuddenDeath().droidString,
-            MOD_SCOREV2: new osuBase.ModScoreV2().droidString,
-            MOD_FLASHLIGHT: new osuBase.ModFlashlight().droidString,
-        };
-        let modString = "";
-        for (const mod of replayMods) {
-            for (const property in replayModsConstants) {
-                if (!mod.includes(property)) {
-                    continue;
-                }
-                modString +=
-                    replayModsConstants[property];
-                break;
+            : this.beatmap)) === null || _a === void 0 ? void 0 : _a.hitObjects.objects;
+        let grantsGekiOrKatu = true;
+        for (let i = 0; i < resultObject.hitObjectData.length; ++i) {
+            // Hit result
+            const hitObjectData = resultObject.hitObjectData[i];
+            const isNextNewCombo = objects
+                ? i + 1 !== objects.length
+                    ? objects[i + 1].isNewCombo
+                    : true
+                : false;
+            switch (hitObjectData.result) {
+                case exports.HitResult.miss:
+                    ++resultObject.accuracy.nmiss;
+                    grantsGekiOrKatu = false;
+                    break;
+                case exports.HitResult.meh:
+                    ++resultObject.accuracy.n50;
+                    grantsGekiOrKatu = false;
+                    break;
+                case exports.HitResult.good:
+                    ++resultObject.accuracy.n100;
+                    if (grantsGekiOrKatu && isNextNewCombo) {
+                        (_b = resultObject.hit100k) !== null && _b !== void 0 ? _b : (resultObject.hit100k = 0);
+                        ++resultObject.hit100k;
+                    }
+                    break;
+                case exports.HitResult.great:
+                    ++resultObject.accuracy.n300;
+                    if (grantsGekiOrKatu && isNextNewCombo) {
+                        (_c = resultObject.hit300k) !== null && _c !== void 0 ? _c : (resultObject.hit300k = 0);
+                        ++resultObject.hit300k;
+                    }
+                    break;
             }
-        }
-        return modString;
-    }
-    /**
-     * Checks if a play is using 3 fingers.
-     *
-     * Requires `analyze()` to be called first and `map` and `difficultyAttributes` to be defined.
-     */
-    checkFor3Finger() {
-        var _a;
-        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
-            return;
-        }
-        if (!this.convertedBeatmap) {
-            const mods = this.data.convertedMods.slice();
-            if ([
-                this.data.forceCS,
-                this.data.forceAR,
-                this.data.forceOD,
-                this.data.forceHP,
-            ].some((v) => v !== undefined)) {
-                mods.push(new osuBase.ModDifficultyAdjust({
-                    cs: this.data.forceCS,
-                    ar: this.data.forceAR,
-                    od: this.data.forceOD,
-                    hp: this.data.forceHP,
-                }));
+            if (isNextNewCombo) {
+                grantsGekiOrKatu = true;
             }
-            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
-                ? this.beatmap
-                : this.beatmap.beatmap).convert({
-                mode: osuBase.Modes.droid,
-                mods: mods,
-                customSpeedMultiplier: this.data.speedMultiplier,
-            }));
         }
-        const threeFingerChecker = this.difficultyAttributes.mode === "rebalance"
-            ? new RebalanceThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes)
-            : new ThreeFingerChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
-        const result = threeFingerChecker.check();
-        this.is3Finger = result.is3Finger;
-        this.tapPenalty = result.penalty;
-        this.hasBeenCheckedFor3Finger = true;
+        resultObject.rank = this.calculateRank(resultObject);
     }
-    /**
-     * 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;
+    calculateRank(resultObject) {
+        var _a, _b;
+        const totalHits = resultObject.accuracy.n300 +
+            resultObject.accuracy.n100 +
+            resultObject.accuracy.n50 +
+            resultObject.accuracy.nmiss;
+        const isHidden = (_b = (_a = resultObject.convertedMods) === null || _a === void 0 ? void 0 : _a.some((m) => m instanceof osuBase.ModHidden || m instanceof osuBase.ModFlashlight)) !== null && _b !== void 0 ? _b : false;
+        const hit300Ratio = resultObject.accuracy.n300 / totalHits;
+        switch (true) {
+            case resultObject.accuracy.value() === 1:
+                return isHidden ? "XH" : "X";
+            case hit300Ratio > 0.9 &&
+                resultObject.accuracy.n50 / totalHits < 0.01 &&
+                !resultObject.accuracy.nmiss:
+                return isHidden ? "SH" : "S";
+            case (hit300Ratio > 0.8 && !resultObject.accuracy.nmiss) ||
+                hit300Ratio > 0.9:
+                return "A";
+            case (hit300Ratio > 0.7 && !resultObject.accuracy.nmiss) ||
+                hit300Ratio > 0.8:
+                return "B";
+            case hit300Ratio > 0.6:
+                return "C";
+            default:
+                return "D";
         }
-        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` and `difficultyAttributes` to be defined.
-     */
-    checkForSliderCheesing() {
-        var _a;
-        if (!this.beatmap || !this.data || !this.difficultyAttributes) {
-            return;
-        }
-        if (!this.convertedBeatmap) {
-            const mods = this.data.convertedMods.slice();
-            if ([
+    constructPlayableBeatmap() {
+        var _a, _b;
+        if (!this.beatmap || !this.data) {
+            throw new Error("Beatmap and replay data must be defined.");
+        }
+        const mods = this.data.isReplayV3()
+            ? this.data.convertedMods.slice()
+            : (_b = (_a = this.difficultyAttributes) === null || _a === void 0 ? void 0 : _a.mods.slice()) !== null && _b !== void 0 ? _b : [];
+        if (this.data.isReplayV5() &&
+            [
                 this.data.forceCS,
                 this.data.forceAR,
                 this.data.forceOD,
                 this.data.forceHP,
             ].some((v) => v !== undefined)) {
-                mods.push(new osuBase.ModDifficultyAdjust({
-                    cs: this.data.forceCS,
-                    ar: this.data.forceAR,
-                    od: this.data.forceOD,
-                    hp: this.data.forceHP,
-                }));
-            }
-            (_a = this.convertedBeatmap) !== null && _a !== void 0 ? _a : (this.convertedBeatmap = new osuBase.BeatmapConverter(this.beatmap instanceof osuBase.Beatmap
-                ? this.beatmap
-                : this.beatmap.beatmap).convert({
-                mode: osuBase.Modes.droid,
-                mods: mods,
-                customSpeedMultiplier: this.data.speedMultiplier,
+            mods.push(new osuBase.ModDifficultyAdjust({
+                cs: this.data.forceCS,
+                ar: this.data.forceAR,
+                od: this.data.forceOD,
+                hp: this.data.forceHP,
             }));
         }
-        const sliderCheeseChecker = new SliderCheeseChecker(this.convertedBeatmap, this.data, this.difficultyAttributes);
-        this.sliderCheesePenalty = sliderCheeseChecker.check();
-        this.hasBeenCheckedForSliderCheesing = true;
+        return (this.beatmap instanceof osuBase.Beatmap
+            ? this.beatmap
+            : this.beatmap.beatmap).createPlayableBeatmap({
+            mode: osuBase.Modes.droid,
+            mods: mods,
+            customSpeedMultiplier: this.data.isReplayV4()
+                ? this.data.speedMultiplier
+                : 1,
+        });
     }
-    readByte(buffer, counter) {
-        const num = buffer.readInt8(counter.counter);
-        counter.counter += 1;
+    readByte(buffer) {
+        const num = buffer.readInt8(this.bufferOffset);
+        this.bufferOffset += 1;
         return num;
     }
-    readShort(buffer, counter) {
-        const num = buffer.readInt16BE(counter.counter);
-        counter.counter += 2;
+    readShort(buffer) {
+        const num = buffer.readInt16BE(this.bufferOffset);
+        this.bufferOffset += 2;
         return num;
     }
-    readInt(buffer, counter) {
-        const num = buffer.readInt32BE(counter.counter);
-        counter.counter += 4;
+    readInt(buffer) {
+        const num = buffer.readInt32BE(this.bufferOffset);
+        this.bufferOffset += 4;
         return num;
     }
-    readFloat(buffer, counter) {
-        const num = buffer.readFloatBE(counter.counter);
-        counter.counter += 4;
+    readFloat(buffer) {
+        const num = buffer.readFloatBE(this.bufferOffset);
+        this.bufferOffset += 4;
         return num;
     }
 }
@@ -2742,6 +2661,9 @@ exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;
 exports.ReplayObjectData = ReplayObjectData;
+exports.ReplayV3Data = ReplayV3Data;
+exports.ReplayV4Data = ReplayV4Data;
+exports.ReplayV5Data = ReplayV5Data;
 exports.SliderCheeseChecker = SliderCheeseChecker;
 exports.ThreeFingerChecker = ThreeFingerChecker;
 exports.TwoHandChecker = TwoHandChecker;