@rian8337/osu-droid-replay-analyzer 4.0.0-beta.75 → 4.0.0-beta.77

package/dist/index.js

@@ -709,6 +709,224 @@ class RebalanceThreeFingerChecker {
     }
 }
 
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
+ */
+class RebalanceSliderCheeseChecker {
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap, data, difficultyAttributes) {
+        this.beatmap = beatmap;
+        this.data = data;
+        this.difficultyAttributes = difficultyAttributes;
+        this.hitWindow50 = difficultyAttributes.mods.has(osuBase.ModPrecise)
+            ? new osuBase.PreciseDroidHitWindow(beatmap.difficulty.od).mehWindow
+            : new osuBase.DroidHitWindow(beatmap.difficulty.od).mehWindow;
+        this.isHardRock = difficultyAttributes.mods.has(osuBase.ModHardRock);
+    }
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     */
+    check() {
+        if (this.difficultyAttributes.difficultSliders.length === 0 ||
+            (this.difficultyAttributes.sliderFactor === 1 &&
+                this.difficultyAttributes.flashlightSliderFactor === 1)) {
+            return {
+                aimPenalty: 1,
+                flashlightPenalty: 1,
+                visualPenalty: 1,
+            };
+        }
+        const cheesedDifficultyRatings = this.checkSliderCheesing();
+        return this.calculateSliderCheesePenalty(cheesedDifficultyRatings);
+    }
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    checkSliderCheesing() {
+        const { objects } = this.beatmap.hitObjects;
+        const cheesedDifficultyRatings = [];
+        // Current loop indices are stored for efficiency.
+        const cursorLoopIndices = osuBase.Utils.initializeArray(this.data.cursorMovement.length, 0);
+        const acceptableRadius = objects[0].radius * 2;
+        // Sort difficult sliders by index so that cursor loop indices work properly.
+        for (const difficultSlider of this.difficultyAttributes.difficultSliders
+            .slice()
+            .sort((a, b) => a.index - b.index)) {
+            if (difficultSlider.index >= this.data.hitObjectData.length) {
+                continue;
+            }
+            const object = objects[difficultSlider.index];
+            const objectData = this.data.hitObjectData[difficultSlider.index];
+            // If a miss or slider break occurs, we disregard the check for that slider.
+            if (objectData.result === exports.HitResult.miss ||
+                -this.hitWindow50 > objectData.accuracy ||
+                objectData.accuracy >
+                    Math.min(this.hitWindow50, object.duration)) {
+                continue;
+            }
+            const objectStartPosition = object.stackedPosition;
+            // These time boundaries should consider the delta time between the previous and next
+            // object as well as their hit accuracy. However, they are somewhat complicated to
+            // compute and the accuracy gain is small. As such, let's settle with 50 hit window.
+            const minTimeLimit = object.startTime - this.hitWindow50;
+            const maxTimeLimit = object.startTime + this.hitWindow50;
+            // Get the closest tap distance across all cursors.
+            const closestDistances = [];
+            const closestGroupIndices = [];
+            for (let i = 0; i < this.data.cursorMovement.length; ++i) {
+                const cursorGroups = this.data.cursorMovement[i].occurrenceGroups;
+                let closestDistance = Number.POSITIVE_INFINITY;
+                let closestIndex = cursorGroups.length;
+                for (let j = cursorLoopIndices[i]; j < cursorGroups.length; j = ++cursorLoopIndices[i]) {
+                    const group = cursorGroups[j];
+                    if (group.endTime < minTimeLimit) {
+                        continue;
+                    }
+                    if (group.startTime > maxTimeLimit) {
+                        break;
+                    }
+                    if (group.startTime >= minTimeLimit) {
+                        const position = this.getCursorPosition(group.down);
+                        const distance = position.getDistance(objectStartPosition);
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                    // Normally, we check if there are cursor presses within the group's active time.
+                    // However, some funky workarounds are used throughout the game for replays, so
+                    // for the time being we only check for cursor distances across the group.
+                    const { allOccurrences } = group;
+                    for (let k = 1; k < allOccurrences.length; ++k) {
+                        const cursor = allOccurrences[k];
+                        const prevCursor = allOccurrences[k - 1];
+                        let distance = Number.POSITIVE_INFINITY;
+                        const currentPosition = this.getCursorPosition(cursor);
+                        const prevPosition = this.getCursorPosition(prevCursor);
+                        switch (cursor.id) {
+                            case exports.MovementType.up:
+                                distance =
+                                    prevPosition.getDistance(objectStartPosition);
+                                break;
+                            case exports.MovementType.move:
+                                for (let mSecPassed = Math.max(prevCursor.time, minTimeLimit); mSecPassed <=
+                                    Math.min(cursor.time, maxTimeLimit); ++mSecPassed) {
+                                    const t = (mSecPassed - prevCursor.time) /
+                                        (cursor.time - prevCursor.time);
+                                    const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                                    distance =
+                                        cursorPosition.getDistance(objectStartPosition);
+                                    if (closestDistance > distance) {
+                                        closestDistance = distance;
+                                        closestIndex = j;
+                                    }
+                                    if (closestDistance <=
+                                        acceptableRadius / 2) {
+                                        break;
+                                    }
+                                }
+                        }
+                        if (closestDistance > distance) {
+                            closestDistance = distance;
+                            closestIndex = j;
+                        }
+                        if (closestDistance <= acceptableRadius / 2) {
+                            break;
+                        }
+                    }
+                }
+                closestDistances.push(closestDistance);
+                closestGroupIndices.push(closestIndex);
+                if (cursorLoopIndices[i] > 0) {
+                    // Decrement the index. The previous group may also have a role on the next slider.
+                    --cursorLoopIndices[i];
+                }
+            }
+            const cursorIndex = closestDistances.indexOf(Math.min(...closestDistances));
+            const closestDistance = closestDistances[cursorIndex];
+            if (closestDistance > acceptableRadius / 2) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+                continue;
+            }
+            const group = this.data.cursorMovement[cursorIndex].occurrenceGroups[closestGroupIndices[cursorIndex]];
+            let isCheesed = false;
+            // Track cursor movement to see if it lands on every tick.
+            let occurrenceLoopIndex = 1;
+            const { allOccurrences } = group;
+            for (let i = 1; i < object.nestedHitObjects.length; ++i) {
+                if (isCheesed) {
+                    break;
+                }
+                const tickWasHit = objectData.tickset[i - 1];
+                if (!tickWasHit) {
+                    continue;
+                }
+                const nestedObject = object.nestedHitObjects[i];
+                const nestedPosition = nestedObject.stackedPosition;
+                while (occurrenceLoopIndex < allOccurrences.length &&
+                    allOccurrences[occurrenceLoopIndex].time <
+                        nestedObject.startTime) {
+                    ++occurrenceLoopIndex;
+                }
+                if (occurrenceLoopIndex === allOccurrences.length) {
+                    continue;
+                }
+                const cursor = allOccurrences[occurrenceLoopIndex];
+                const prevCursor = allOccurrences[occurrenceLoopIndex - 1];
+                const currentPosition = this.getCursorPosition(cursor);
+                const prevPosition = this.getCursorPosition(prevCursor);
+                switch (cursor.id) {
+                    case exports.MovementType.move: {
+                        // Interpolate cursor position during nested object time.
+                        const t = (nestedObject.startTime - prevCursor.time) /
+                            (cursor.time - prevCursor.time);
+                        const cursorPosition = osuBase.Interpolation.lerp(prevPosition, currentPosition, t);
+                        const distance = cursorPosition.getDistance(nestedPosition);
+                        isCheesed = distance > acceptableRadius;
+                        break;
+                    }
+                    case exports.MovementType.up:
+                        isCheesed =
+                            prevPosition.getDistance(nestedPosition) >
+                                acceptableRadius;
+                }
+            }
+            if (isCheesed) {
+                cheesedDifficultyRatings.push(difficultSlider.difficultyRating);
+            }
+        }
+        return cheesedDifficultyRatings;
+    }
+    /**
+     * Calculates the slider cheese penalty.
+     */
+    calculateSliderCheesePenalty(cheesedDifficultyRatings) {
+        const summedDifficultyRating = Math.min(1, cheesedDifficultyRatings.reduce((a, v) => a + v, 0));
+        return {
+            aimPenalty: Math.max(this.difficultyAttributes.sliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.sliderFactor, 2)),
+            flashlightPenalty: Math.max(this.difficultyAttributes.flashlightSliderFactor, Math.pow(1 -
+                summedDifficultyRating *
+                    this.difficultyAttributes.flashlightSliderFactor, 2)),
+            visualPenalty: 1,
+        };
+    }
+    getCursorPosition(cursor) {
+        if (this.isHardRock) {
+            return new osuBase.Vector2(cursor.position.x, osuBase.Playfield.baseSize.y - cursor.position.y);
+        }
+        return cursor.position;
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -742,7 +960,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
 class SliderCheeseChecker {
     /**
@@ -963,7 +1181,7 @@ class SliderCheeseChecker {
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ * Utility to check whether or not a beatmap is three-fingered for live scores.
  */
 class ThreeFingerChecker {
     /**
@@ -1026,9 +1244,6 @@ class ThreeFingerChecker {
         }
         this.getAccurateBreakPoints();
         this.filterCursorInstances();
-        if (this.downCursorInstances.filter((v) => v.length > 0).length <= 3) {
-            return { is3Finger: false, penalty: 1 };
-        }
         this.getBeatmapSections();
         this.calculateNerfFactors();
         const finalPenalty = this.calculateFinalPenalty();
@@ -2129,7 +2344,7 @@ class ReplayAnalyzer {
     /**
      * Gets hit error information of the replay.
      *
-     * `analyze()` must be called before calling this.
+     * `analyze()` must be called before calling this, and `beatmap` must be defined.
      */
     calculateHitError() {
         var _a, _b;
@@ -2180,6 +2395,124 @@ class ReplayAnalyzer {
             unstableRate: osuBase.MathUtils.calculateStandardDeviation(accuracies) * 10,
         };
     }
+    /**
+     * Obtains the amount of slider ticks and ends hit in the replay.
+     *
+     * This requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @returns Slider hit information or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    obtainSliderHitInformation() {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const sliderInformation = {
+            tick: { obtained: 0, total: beatmap.hitObjects.sliderTicks },
+            end: { obtained: 0, total: beatmap.hitObjects.sliders },
+        };
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            if (objectData.result === exports.HitResult.miss ||
+                !(object instanceof osuBase.Slider)) {
+                continue;
+            }
+            // Exclude the head circle.
+            for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                const nested = object.nestedHitObjects[j];
+                if (!objectData.tickset[j - 1]) {
+                    continue;
+                }
+                if (nested instanceof osuBase.SliderTick) {
+                    ++sliderInformation.tick.obtained;
+                }
+                else if (nested instanceof osuBase.SliderTail) {
+                    ++sliderInformation.end.obtained;
+                }
+            }
+        }
+        return sliderInformation;
+    }
+    /**
+     * Simulates a hit window for the replay.
+     *
+     * This does not account for required spins in a spinner.
+     *
+     * Requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @param hitWindow The hit window to simulate.
+     * @returns The accuracy of the replay based on the hit window, or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    simulateHitWindow(hitWindow) {
+        const { data, beatmap } = this;
+        if (!data || !beatmap) {
+            return null;
+        }
+        const accuracy = new osuBase.Accuracy({ n300: 0, n100: 0, n50: 0, nmiss: 0 });
+        for (let i = 0; i < data.hitObjectData.length; ++i) {
+            const object = beatmap.hitObjects.objects[i];
+            const objectData = data.hitObjectData[i];
+            const hitAccuracy = Math.abs(objectData.accuracy);
+            let { result } = objectData;
+            if (object instanceof osuBase.Circle) {
+                if (hitAccuracy <= hitWindow.greatWindow) {
+                    result = exports.HitResult.great;
+                }
+                else if (hitAccuracy <= hitWindow.okWindow) {
+                    result = exports.HitResult.good;
+                }
+                else if (hitAccuracy <= hitWindow.mehWindow) {
+                    result = exports.HitResult.meh;
+                }
+                else {
+                    result = exports.HitResult.miss;
+                }
+            }
+            else if (object instanceof osuBase.Slider) {
+                if (hitAccuracy <=
+                    Math.min(hitWindow.mehWindow, object.duration)) {
+                    let ticksObtained = 1;
+                    for (let j = 1; j < object.nestedHitObjects.length; ++j) {
+                        if (objectData.tickset[j - 1]) {
+                            ++ticksObtained;
+                        }
+                    }
+                    if (ticksObtained === object.nestedHitObjects.length) {
+                        result = exports.HitResult.great;
+                    }
+                    else if (ticksObtained >=
+                        Math.trunc(object.nestedHitObjects.length / 2)) {
+                        result = exports.HitResult.good;
+                    }
+                    else if (ticksObtained > 0) {
+                        result = exports.HitResult.meh;
+                    }
+                    else {
+                        result = exports.HitResult.miss;
+                    }
+                }
+                else {
+                    result = exports.HitResult.miss;
+                }
+            }
+            switch (result) {
+                case exports.HitResult.miss:
+                    ++accuracy.nmiss;
+                    break;
+                case exports.HitResult.meh:
+                    ++accuracy.n50;
+                    break;
+                case exports.HitResult.good:
+                    ++accuracy.n100;
+                    break;
+                case exports.HitResult.great:
+                    ++accuracy.n300;
+                    break;
+            }
+        }
+        return accuracy;
+    }
     /**
      * Checks if a play is using 3 fingers.
      *
@@ -2227,7 +2560,9 @@ class ReplayAnalyzer {
             return;
         }
         (_a = this.playableBeatmap) !== null && _a !== void 0 ? _a : (this.playableBeatmap = this.constructPlayableBeatmap());
-        const sliderCheeseChecker = new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
+        const sliderCheeseChecker = this.difficultyAttributes.mode === "rebalance"
+            ? new RebalanceSliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes)
+            : new SliderCheeseChecker(this.playableBeatmap, this.data, this.difficultyAttributes);
         this.sliderCheesePenalty = sliderCheeseChecker.check();
         this.hasBeenCheckedForSliderCheesing = true;
     }
@@ -2610,6 +2945,7 @@ class ReplayObjectData {
 exports.CursorData = CursorData;
 exports.CursorOccurrence = CursorOccurrence;
 exports.CursorOccurrenceGroup = CursorOccurrenceGroup;
+exports.RebalanceSliderCheeseChecker = RebalanceSliderCheeseChecker;
 exports.RebalanceThreeFingerChecker = RebalanceThreeFingerChecker;
 exports.ReplayAnalyzer = ReplayAnalyzer;
 exports.ReplayData = ReplayData;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rian8337/osu-droid-replay-analyzer",
-    "version": "4.0.0-beta.75",
+    "version": "4.0.0-beta.77",
     "description": "A replay analyzer for analyzing osu!droid replay files.",
     "keywords": [
         "osu",
@@ -34,9 +34,9 @@
         "url": "https://github.com/Rian8337/osu-droid-module/issues"
     },
     "dependencies": {
-        "@rian8337/osu-base": "^4.0.0-beta.74",
-        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.75",
-        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.75",
+        "@rian8337/osu-base": "^4.0.0-beta.77",
+        "@rian8337/osu-difficulty-calculator": "^4.0.0-beta.77",
+        "@rian8337/osu-rebalance-difficulty-calculator": "^4.0.0-beta.77",
         "java-deserialization": "^0.1.0",
         "unzipper": "^0.10.11"
     },
@@ -46,5 +46,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "1e8a43d98546e5071bebe45b3ca40dd496aa7b21"
+    "gitHead": "13ad454ea657dbd5821d0857c4da6dc7ab0fe965"
 }

package/typings/index.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Accuracy, ScoreRank, ModMap, DroidPlayableBeatmap, Beatmap } from '@rian8337/osu-base';
+import { Vector2, Accuracy, ScoreRank, ModMap, DroidPlayableBeatmap, Beatmap, HitWindow } from '@rian8337/osu-base';
 import { IExtendedDroidDifficultyAttributes as IExtendedDroidDifficultyAttributes$1 } from '@rian8337/osu-difficulty-calculator';
 import { IExtendedDroidDifficultyAttributes } from '@rian8337/osu-rebalance-difficulty-calculator';
 
@@ -726,6 +726,75 @@ interface SliderCheeseInformation {
     visualPenalty: number;
 }
 
+/**
+ * Utility to check whether relevant sliders in a beatmap are cheesed for rebalance scores..
+ */
+declare class RebalanceSliderCheeseChecker {
+    /**
+     * The beatmap that is being analyzed.
+     */
+    readonly beatmap: DroidPlayableBeatmap;
+    /**
+     * The data of the replay.
+     */
+    readonly data: ReplayData;
+    /**
+     * The difficulty attributes of the beatmap.
+     */
+    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes;
+    /**
+     * The 50 osu!droid hit window of the analyzed beatmap.
+     */
+    private readonly hitWindow50;
+    private readonly isHardRock;
+    /**
+     * @param beatmap The beatmap to analyze.
+     * @param data The data of the replay.
+     * @param difficultyAttributes The difficulty attributes of the beatmap.
+     */
+    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes);
+    /**
+     * Checks if relevant sliders in the given beatmap was cheesed.
+     */
+    check(): SliderCheeseInformation;
+    /**
+     * Checks for sliders that were cheesed.
+     */
+    private checkSliderCheesing;
+    /**
+     * Calculates the slider cheese penalty.
+     */
+    private calculateSliderCheesePenalty;
+    private getCursorPosition;
+}
+
+/**
+ * Represents hit information about sliders in a beatmap.
+ */
+interface SliderHitInformation {
+    /**
+     * Hit information of slider ticks.
+     */
+    readonly tick: SliderNestedHitObjectInformation;
+    /**
+     * hit information of slider ends.
+     */
+    readonly end: SliderNestedHitObjectInformation;
+}
+/**
+ * Hit information of a specific nested hit object.
+ */
+interface SliderNestedHitObjectInformation {
+    /**
+     * The amount of the nested hit objects that were obtained.
+     */
+    obtained: number;
+    /**
+     * The amount of the nested hit objects in the beatmap.
+     */
+    readonly total: number;
+}
+
 interface HitErrorInformation {
     negativeAvg: number;
     positiveAvg: number;
@@ -822,9 +891,28 @@ declare class ReplayAnalyzer {
     /**
      * Gets hit error information of the replay.
      *
-     * `analyze()` must be called before calling this.
+     * `analyze()` must be called before calling this, and `beatmap` must be defined.
      */
     calculateHitError(): HitErrorInformation | null;
+    /**
+     * Obtains the amount of slider ticks and ends hit in the replay.
+     *
+     * This requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @returns Slider hit information or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    obtainSliderHitInformation(): SliderHitInformation | null;
+    /**
+     * Simulates a hit window for the replay.
+     *
+     * This does not account for required spins in a spinner.
+     *
+     * Requires `analyze()` to be called first and `beatmap` to be defined.
+     *
+     * @param hitWindow The hit window to simulate.
+     * @returns The accuracy of the replay based on the hit window, or `null` if the replay has not been analyzed or the beatmap is not defined.
+     */
+    simulateHitWindow(hitWindow: HitWindow): Accuracy | null;
     /**
      * Checks if a play is using 3 fingers.
      *
@@ -873,7 +961,7 @@ declare class ReplayAnalyzer {
 }
 
 /**
- * Utility to check whether relevant sliders in a beatmap are cheesed.
+ * Utility to check whether relevant sliders in a beatmap are cheesed for live scores.
  */
 declare class SliderCheeseChecker {
     /**
@@ -887,7 +975,7 @@ declare class SliderCheeseChecker {
     /**
      * The difficulty attributes of the beatmap.
      */
-    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes$1 | IExtendedDroidDifficultyAttributes;
+    readonly difficultyAttributes: IExtendedDroidDifficultyAttributes$1;
     /**
      * The 50 osu!droid hit window of the analyzed beatmap.
      */
@@ -898,7 +986,7 @@ declare class SliderCheeseChecker {
      * @param data The data of the replay.
      * @param difficultyAttributes The difficulty attributes of the beatmap.
      */
-    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes$1 | IExtendedDroidDifficultyAttributes);
+    constructor(beatmap: DroidPlayableBeatmap, data: ReplayData, difficultyAttributes: IExtendedDroidDifficultyAttributes$1);
     /**
      * Checks if relevant sliders in the given beatmap was cheesed.
      */
@@ -915,7 +1003,7 @@ declare class SliderCheeseChecker {
 }
 
 /**
- * Utility to check whether or not a beatmap is three-fingered for rebalance scores.
+ * Utility to check whether or not a beatmap is three-fingered for live scores.
  */
 declare class ThreeFingerChecker {
     /**
@@ -1115,4 +1203,4 @@ declare class TwoHandChecker {
     private getCursorPosition;
 }
 
-export { CursorData, type CursorInformation, CursorOccurrence, CursorOccurrenceGroup, type ExportedReplayJSON, type ExportedReplayJSONDataV1, type ExportedReplayJSONDataV2, type ExportedReplayJSONDataV3, type ExportedReplayJSONV1, type ExportedReplayJSONV2, type ExportedReplayJSONV3, type HitErrorInformation, HitResult, MovementType, RebalanceThreeFingerChecker, ReplayAnalyzer, ReplayData, ReplayObjectData, ReplayV3Data, SliderCheeseChecker, type SliderCheeseInformation, ThreeFingerChecker, type ThreeFingerInformation, TwoHandChecker, type TwoHandInformation };
+export { CursorData, type CursorInformation, CursorOccurrence, CursorOccurrenceGroup, type ExportedReplayJSON, type ExportedReplayJSONDataV1, type ExportedReplayJSONDataV2, type ExportedReplayJSONDataV3, type ExportedReplayJSONV1, type ExportedReplayJSONV2, type ExportedReplayJSONV3, type HitErrorInformation, HitResult, MovementType, RebalanceSliderCheeseChecker, RebalanceThreeFingerChecker, ReplayAnalyzer, ReplayData, ReplayObjectData, ReplayV3Data, SliderCheeseChecker, type SliderCheeseInformation, type SliderHitInformation, type SliderNestedHitObjectInformation, ThreeFingerChecker, type ThreeFingerInformation, TwoHandChecker, type TwoHandInformation };