@rian8337/osu-base 1.0.0

package/dist/beatmap/hitobjects/HitObject.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HitObject = void 0;
+const objectTypes_1 = require("../../constants/objectTypes");
+const Vector2_1 = require("../../mathutil/Vector2");
+/**
+ * Represents a hitobject in a beatmap.
+ */
+class HitObject {
+    constructor(values) {
+        /**
+         * The stack height of the hitobject.
+         */
+        this.stackHeight = 0;
+        /**
+         * The scale used to calculate stacked position and radius.
+         */
+        this.scale = 1;
+        this.startTime = values.startTime;
+        this.endTime = values.endTime ?? values.startTime;
+        this.type = values.type ?? objectTypes_1.objectTypes.circle;
+        this.position = values.position;
+        this.endPosition = values.endPosition ?? this.position;
+        this.isNewCombo = !!(this.type & (1 << 2));
+    }
+    /**
+     * The stacked position of the hitobject.
+     */
+    get stackedPosition() {
+        if (this.type & objectTypes_1.objectTypes.spinner) {
+            return this.position;
+        }
+        return this.position.add(this.stackOffset);
+    }
+    /**
+     * The stacked end position of the hitobject.
+     */
+    get stackedEndPosition() {
+        if (this.type & objectTypes_1.objectTypes.spinner) {
+            return this.position;
+        }
+        return this.endPosition.add(this.stackOffset);
+    }
+    /**
+     * The stack vector to calculate offset for stacked positions.
+     */
+    get stackOffset() {
+        const coordinate = this.stackHeight * this.scale * -6.4;
+        return new Vector2_1.Vector2(coordinate, coordinate);
+    }
+    /**
+     * The radius of the hitobject.
+     */
+    get radius() {
+        return 64 * this.scale;
+    }
+    /**
+     * Returns the hitobject type.
+     */
+    typeStr() {
+        let res = "";
+        if (this.type & objectTypes_1.objectTypes.circle) {
+            res += "circle | ";
+        }
+        if (this.type & objectTypes_1.objectTypes.slider) {
+            res += "slider | ";
+        }
+        if (this.type & objectTypes_1.objectTypes.spinner) {
+            res += "spinner | ";
+        }
+        return res.substring(0, Math.max(0, res.length - 3));
+    }
+}
+exports.HitObject = HitObject;

package/dist/beatmap/hitobjects/Slider.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Slider = void 0;
+const HitObject_1 = require("./HitObject");
+const HeadCircle_1 = require("./sliderObjects/HeadCircle");
+const RepeatPoint_1 = require("./sliderObjects/RepeatPoint");
+const SliderTick_1 = require("./sliderObjects/SliderTick");
+const TailCircle_1 = require("./sliderObjects/TailCircle");
+/**
+ * Represents a slider in a beatmap.
+ */
+class Slider extends HitObject_1.HitObject {
+    constructor(values) {
+        super({
+            endPosition: values.position.add(values.path.positionAt(values.repetitions % 2)),
+            ...values,
+        });
+        /**
+         * The nested hitobjects of the slider. Consists of headcircle (sliderhead), slider ticks, repeat points, and tailcircle (sliderend).
+         */
+        this.nestedHitObjects = [];
+        /**
+         * The distance travelled by the cursor upon completion of this slider if it was hit
+         * with as few movements as possible. This is set and used by difficulty calculation.
+         */
+        this.lazyTravelDistance = 0;
+        /**
+         * The time taken by the cursor upon completion of this slider if it was hit with
+         * as few movements as possible. This is set and used by difficulty calculation.
+         */
+        this.lazyTravelTime = 0;
+        // Basically equal to span count
+        this.repetitions = values.repetitions;
+        this.path = values.path;
+        const scoringDistance = 100 * values.mapSliderVelocity * values.speedMultiplier;
+        this.velocity = scoringDistance / values.msPerBeat;
+        this.tickDistance =
+            (scoringDistance / values.mapTickRate) *
+                values.tickDistanceMultiplier;
+        this.endTime =
+            this.startTime +
+                (this.repetitions * this.path.expectedDistance) / this.velocity;
+        this.spanDuration = this.duration / this.repetitions;
+        // Creating nested hit objects
+        // Slider start
+        this.headCircle = new HeadCircle_1.HeadCircle({
+            position: this.position,
+            startTime: this.startTime,
+            type: 0,
+        });
+        this.nestedHitObjects.push(this.headCircle);
+        // Slider ticks and repeat points
+        // A very lenient maximum length of a slider for ticks to be generated.
+        // This exists for edge cases such as /b/1573664 where the beatmap has been edited by the user, and should never be reached in normal usage.
+        const maxLength = 100000;
+        const length = Math.min(maxLength, this.path.expectedDistance);
+        const tickDistance = Math.min(Math.max(this.tickDistance, 0), length);
+        if (tickDistance !== 0) {
+            const minDistanceFromEnd = this.velocity * 10;
+            for (let span = 0; span < this.repetitions; ++span) {
+                const spanStartTime = this.startTime + span * this.spanDuration;
+                const reversed = span % 2 === 1;
+                const sliderTicks = [];
+                for (let d = tickDistance; d <= length; d += tickDistance) {
+                    if (d >= length - minDistanceFromEnd) {
+                        break;
+                    }
+                    // Always generate ticks from the start of the path rather than the span to ensure that ticks in repeat spans are positioned identically to those in non-repeat spans
+                    const distanceProgress = d / length;
+                    const timeProgress = reversed
+                        ? 1 - distanceProgress
+                        : distanceProgress;
+                    const sliderTickPosition = this.position.add(this.path.positionAt(distanceProgress));
+                    const sliderTick = new SliderTick_1.SliderTick({
+                        startTime: spanStartTime + timeProgress * this.spanDuration,
+                        position: sliderTickPosition,
+                        spanIndex: span,
+                        spanStartTime: spanStartTime,
+                    });
+                    sliderTicks.push(sliderTick);
+                }
+                // For repeat spans, ticks are returned in reverse-StartTime order.
+                if (reversed) {
+                    sliderTicks.reverse();
+                }
+                this.nestedHitObjects.push(...sliderTicks);
+                if (span < this.repetitions - 1) {
+                    const repeatPosition = this.position.add(this.path.positionAt((span + 1) % 2));
+                    const repeatPoint = new RepeatPoint_1.RepeatPoint({
+                        position: repeatPosition,
+                        startTime: spanStartTime + this.spanDuration,
+                        repeatIndex: span,
+                        spanDuration: this.spanDuration,
+                    });
+                    this.nestedHitObjects.push(repeatPoint);
+                }
+            }
+        }
+        // Okay, I'll level with you. I made a mistake. It was 2007.
+        // Times were simpler. osu! was but in its infancy and sliders were a new concept.
+        // A hack was made, which has unfortunately lived through until this day.
+        //
+        // This legacy tick is used for some calculations and judgements where audio output is not required.
+        // Generally we are keeping this around just for difficulty compatibility.
+        // Optimistically we do not want to ever use this for anything user-facing going forwards.
+        const finalSpanIndex = this.repeatPoints;
+        const finalSpanStartTime = this.startTime + finalSpanIndex * this.spanDuration;
+        const finalSpanEndTime = Math.max(this.startTime + this.duration / 2, finalSpanStartTime + this.spanDuration - Slider.legacyLastTickOffset);
+        // Slider end
+        this.tailCircle = new TailCircle_1.TailCircle({
+            position: this.endPosition,
+            startTime: finalSpanEndTime,
+        });
+        this.nestedHitObjects.push(this.tailCircle);
+        this.nestedHitObjects.sort((a, b) => {
+            return a.startTime - b.startTime;
+        });
+    }
+    /**
+     * The duration of this slider.
+     */
+    get duration() {
+        return this.endTime - this.startTime;
+    }
+    /**
+     * The amount of slider ticks in this slider.
+     */
+    get ticks() {
+        return this.nestedHitObjects.filter((v) => v instanceof SliderTick_1.SliderTick)
+            .length;
+    }
+    /**
+     * The amount of repeat points in this slider.
+     */
+    get repeatPoints() {
+        return this.repetitions - 1;
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}], distance: ${this.path.expectedDistance}, repetitions: ${this.repetitions}, slider ticks: ${this.nestedHitObjects.filter((v) => v instanceof SliderTick_1.SliderTick).length}`;
+    }
+}
+exports.Slider = Slider;
+Slider.legacyLastTickOffset = 36;

package/dist/beatmap/hitobjects/Spinner.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+const Vector2_1 = require("../../mathutil/Vector2");
+const HitObject_1 = require("./HitObject");
+/**
+ * Represents a spinner in a beatmap.
+ *
+ * All we need from spinners is their duration. The
+ * position of a spinner is always at 256x192.
+ */
+class Spinner extends HitObject_1.HitObject {
+    constructor(values) {
+        super({
+            startTime: values.startTime,
+            endTime: values.startTime + values.duration,
+            type: values.type | (1 << 2),
+            position: new Vector2_1.Vector2(256, 192),
+        });
+        this.duration = values.duration;
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}], duration: ${this.duration}`;
+    }
+}
+exports.Spinner = Spinner;

package/dist/beatmap/hitobjects/sliderObjects/HeadCircle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadCircle = void 0;
+const Circle_1 = require("../Circle");
+/**
+ * Represents the headcircle of a slider (sliderhead).
+ */
+class HeadCircle extends Circle_1.Circle {
+}
+exports.HeadCircle = HeadCircle;

package/dist/beatmap/hitobjects/sliderObjects/RepeatPoint.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatPoint = void 0;
+const HitObject_1 = require("../HitObject");
+/**
+ * Represents a repeat point in a slider.
+ */
+class RepeatPoint extends HitObject_1.HitObject {
+    constructor(values) {
+        super({
+            startTime: values.startTime,
+            position: values.position,
+        });
+        this.repeatIndex = values.repeatIndex;
+        this.spanDuration = values.spanDuration;
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}], repeat index: ${this.repeatIndex}, span duration: ${this.spanDuration}`;
+    }
+}
+exports.RepeatPoint = RepeatPoint;

package/dist/beatmap/hitobjects/sliderObjects/SliderTick.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliderTick = void 0;
+const HitObject_1 = require("../HitObject");
+/**
+ * Represents a slider tick in a slider.
+ */
+class SliderTick extends HitObject_1.HitObject {
+    constructor(values) {
+        super({
+            startTime: values.startTime,
+            position: values.position,
+        });
+        this.spanIndex = values.spanIndex;
+        this.spanStartTime = values.spanStartTime;
+    }
+    toString() {
+        return `Position: [${this.position.x}, ${this.position.y}], span index: ${this.spanIndex}, span start time: ${this.spanStartTime}`;
+    }
+}
+exports.SliderTick = SliderTick;

package/dist/beatmap/hitobjects/sliderObjects/TailCircle.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TailCircle = void 0;
+const Circle_1 = require("../Circle");
+/**
+ * Represents the tailcircle of a slider (sliderend).
+ */
+class TailCircle extends Circle_1.Circle {
+}
+exports.TailCircle = TailCircle;

package/dist/beatmap/timings/BreakPoint.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BreakPoint = void 0;
+/**
+ * Represents a break period in a beatmap.
+ */
+class BreakPoint {
+    constructor(values) {
+        this.startTime = values.startTime;
+        this.endTime = values.endTime;
+        this.duration = this.endTime - this.startTime;
+    }
+    /**
+     * Returns a string representation of the class.
+     */
+    toString() {
+        return `Start time: ${this.startTime}, end time: ${this.endTime}, duration: ${this.duration}`;
+    }
+    /**
+     * Whether this break period contains a specified time.
+     *
+     * @param time The time to check in milliseconds.
+     * @returns Whether the time falls within this break period.
+     */
+    contains(time) {
+        return (time >= this.startTime &&
+            time <= this.endTime - BreakPoint.MIN_BREAK_DURATION / 2);
+    }
+}
+exports.BreakPoint = BreakPoint;
+/**
+ * The minimum duration required for a break to have any effect.
+ */
+BreakPoint.MIN_BREAK_DURATION = 650;

package/dist/beatmap/timings/DifficultyControlPoint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DifficultyControlPoint = void 0;
+const TimingPoint_1 = require("./TimingPoint");
+/**
+ * Represents a timing point that changes speed multiplier.
+ */
+class DifficultyControlPoint extends TimingPoint_1.TimingPoint {
+    constructor(values) {
+        super(values);
+        this.speedMultiplier = values.speedMultiplier;
+    }
+    toString() {
+        return ("{ time: " +
+            this.time.toFixed(2) +
+            ", " +
+            "speed multiplier: " +
+            this.speedMultiplier.toFixed(2) +
+            " }");
+    }
+}
+exports.DifficultyControlPoint = DifficultyControlPoint;

package/dist/beatmap/timings/TimingControlPoint.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimingControlPoint = void 0;
+const TimingPoint_1 = require("./TimingPoint");
+/**
+ * Represents a timing point that changes the beatmap's BPM.
+ */
+class TimingControlPoint extends TimingPoint_1.TimingPoint {
+    constructor(values) {
+        super(values);
+        this.msPerBeat = values.msPerBeat;
+    }
+    toString() {
+        return ("{ time: " +
+            this.time.toFixed(2) +
+            ", " +
+            "ms_per_beat: " +
+            this.msPerBeat.toFixed(2) +
+            " }");
+    }
+}
+exports.TimingControlPoint = TimingControlPoint;

package/dist/beatmap/timings/TimingPoint.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimingPoint = void 0;
+/**
+ * Represents a timing point in a beatmap.
+ */
+class TimingPoint {
+    constructor(values) {
+        this.time = values.time;
+    }
+}
+exports.TimingPoint = TimingPoint;

package/dist/constants/ParserConstants.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserConstants = void 0;
+/**
+ * Constants for beatmap parser.
+ */
+var ParserConstants;
+(function (ParserConstants) {
+    ParserConstants[ParserConstants["MAX_PARSE_VALUE"] = 2147483647] = "MAX_PARSE_VALUE";
+    ParserConstants[ParserConstants["MAX_COORDINATE_VALUE"] = 131072] = "MAX_COORDINATE_VALUE";
+    ParserConstants[ParserConstants["MIN_REPETITIONS_VALUE"] = 0] = "MIN_REPETITIONS_VALUE";
+    ParserConstants[ParserConstants["MAX_REPETITIONS_VALUE"] = 9000] = "MAX_REPETITIONS_VALUE";
+    ParserConstants[ParserConstants["MIN_DISTANCE_VALUE"] = 0] = "MIN_DISTANCE_VALUE";
+    ParserConstants[ParserConstants["MAX_DISTANCE_VALUE"] = 131072] = "MAX_DISTANCE_VALUE";
+    ParserConstants[ParserConstants["MIN_SPEEDMULTIPLIER_VALUE"] = 0.1] = "MIN_SPEEDMULTIPLIER_VALUE";
+    ParserConstants[ParserConstants["MAX_SPEEDMULTIPLIER_VALUE"] = 10] = "MAX_SPEEDMULTIPLIER_VALUE";
+    ParserConstants[ParserConstants["MIN_MSPERBEAT_VALUE"] = 6] = "MIN_MSPERBEAT_VALUE";
+    ParserConstants[ParserConstants["MAX_MSPERBEAT_VALUE"] = 60000] = "MAX_MSPERBEAT_VALUE";
+})(ParserConstants = exports.ParserConstants || (exports.ParserConstants = {}));

package/dist/constants/PathType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathType = void 0;
+/**
+ * Types of slider paths.
+ */
+var PathType;
+(function (PathType) {
+    PathType[PathType["Catmull"] = 0] = "Catmull";
+    PathType[PathType["Bezier"] = 1] = "Bezier";
+    PathType[PathType["Linear"] = 2] = "Linear";
+    PathType[PathType["PerfectCurve"] = 3] = "PerfectCurve";
+})(PathType = exports.PathType || (exports.PathType = {}));

package/dist/constants/modes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modes = void 0;
+/**
+ * Mode enum to switch things between osu!droid and osu!standard.
+ */
+var modes;
+(function (modes) {
+    modes["droid"] = "droid";
+    modes["osu"] = "osu";
+})(modes = exports.modes || (exports.modes = {}));

package/dist/constants/objectTypes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectTypes = void 0;
+/**
+ * Bitmask constant of object types. This is needed as osu! uses bits to determine object types.
+ */
+var objectTypes;
+(function (objectTypes) {
+    objectTypes[objectTypes["circle"] = 1] = "circle";
+    objectTypes[objectTypes["slider"] = 2] = "slider";
+    objectTypes[objectTypes["spinner"] = 8] = "spinner";
+})(objectTypes = exports.objectTypes || (exports.objectTypes = {}));

package/dist/constants/rankedStatus.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rankedStatus = void 0;
+/**
+ * Ranking status of a beatmap.
+ */
+var rankedStatus;
+(function (rankedStatus) {
+    rankedStatus[rankedStatus["GRAVEYARD"] = -2] = "GRAVEYARD";
+    rankedStatus[rankedStatus["WIP"] = -1] = "WIP";
+    rankedStatus[rankedStatus["PENDING"] = 0] = "PENDING";
+    rankedStatus[rankedStatus["RANKED"] = 1] = "RANKED";
+    rankedStatus[rankedStatus["APPROVED"] = 2] = "APPROVED";
+    rankedStatus[rankedStatus["QUALIFIED"] = 3] = "QUALIFIED";
+    rankedStatus[rankedStatus["LOVED"] = 4] = "LOVED";
+})(rankedStatus = exports.rankedStatus || (exports.rankedStatus = {}));

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils/Accuracy"), exports);
+__exportStar(require("./beatmap/Beatmap"), exports);
+__exportStar(require("./beatmap/timings/BreakPoint"), exports);
+__exportStar(require("./beatmap/hitobjects/Circle"), exports);
+__exportStar(require("./beatmap/timings/DifficultyControlPoint"), exports);
+__exportStar(require("./utils/APIRequestBuilder"), exports);
+__exportStar(require("./utils/HitWindow"), exports);
+__exportStar(require("./beatmap/hitobjects/sliderObjects/HeadCircle"), exports);
+__exportStar(require("./beatmap/hitobjects/HitObject"), exports);
+__exportStar(require("./mathutil/Interpolation"), exports);
+__exportStar(require("./tools/MapInfo"), exports);
+__exportStar(require("./utils/MapStats"), exports);
+__exportStar(require("./mathutil/MathUtils"), exports);
+__exportStar(require("./mods/Mod"), exports);
+__exportStar(require("./mods/ModAuto"), exports);
+__exportStar(require("./mods/ModAutopilot"), exports);
+__exportStar(require("./mods/ModDoubleTime"), exports);
+__exportStar(require("./mods/ModEasy"), exports);
+__exportStar(require("./mods/ModFlashlight"), exports);
+__exportStar(require("./mods/ModHalfTime"), exports);
+__exportStar(require("./mods/ModHardRock"), exports);
+__exportStar(require("./mods/ModHidden"), exports);
+__exportStar(require("./mods/ModNightCore"), exports);
+__exportStar(require("./mods/ModNoFail"), exports);
+__exportStar(require("./mods/ModPerfect"), exports);
+__exportStar(require("./mods/ModPrecise"), exports);
+__exportStar(require("./mods/ModReallyEasy"), exports);
+__exportStar(require("./mods/ModRelax"), exports);
+__exportStar(require("./mods/ModScoreV2"), exports);
+__exportStar(require("./mods/ModSmallCircle"), exports);
+__exportStar(require("./mods/ModSpunOut"), exports);
+__exportStar(require("./mods/ModSuddenDeath"), exports);
+__exportStar(require("./mods/ModTouchDevice"), exports);
+__exportStar(require("./utils/ModUtil"), exports);
+__exportStar(require("./constants/modes"), exports);
+__exportStar(require("./constants/objectTypes"), exports);
+__exportStar(require("./beatmap/Parser"), exports);
+__exportStar(require("./utils/PathApproximator"), exports);
+__exportStar(require("./constants/PathType"), exports);
+__exportStar(require("./utils/Precision"), exports);
+__exportStar(require("./beatmap/hitobjects/sliderObjects/RepeatPoint"), exports);
+__exportStar(require("./constants/rankedStatus"), exports);
+__exportStar(require("./beatmap/hitobjects/Slider"), exports);
+__exportStar(require("./utils/SliderPath"), exports);
+__exportStar(require("./beatmap/hitobjects/sliderObjects/SliderTick"), exports);
+__exportStar(require("./beatmap/hitobjects/Spinner"), exports);
+__exportStar(require("./beatmap/hitobjects/sliderObjects/TailCircle"), exports);
+__exportStar(require("./beatmap/timings/TimingControlPoint"), exports);
+__exportStar(require("./utils/Utils"), exports);
+__exportStar(require("./mathutil/Vector2"), exports);
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();

package/dist/mathutil/Interpolation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interpolation = void 0;
+class Interpolation {
+    static lerp(start, final, amount) {
+        return start + (final - start) * amount;
+    }
+}
+exports.Interpolation = Interpolation;

package/dist/mathutil/MathUtils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+/**
+ * Some math utility functions.
+ */
+class MathUtils {
+    /**
+     * Rounds a specified number with specified amount of fractional digits.
+     *
+     * @param num The number to round.
+     * @param fractionalDigits The amount of fractional digits.
+     */
+    static round(num, fractionalDigits) {
+        return parseFloat(num.toFixed(fractionalDigits));
+    }
+    /**
+     * Limits the specified number on range `[min, max]`.
+     *
+     * @param num The number to limit.
+     * @param min The minimum range.
+     * @param max The maximum range.
+     */
+    static clamp(num, min, max) {
+        return Math.max(min, Math.min(num, max));
+    }
+    /**
+     * Calculates the standard deviation of given data.
+     *
+     * @param data The data to calculate.
+     */
+    static calculateStandardDeviation(data) {
+        if (data.length === 0) {
+            return 0;
+        }
+        const mean = data.reduce((acc, value) => acc + value) / data.length;
+        return Math.sqrt(data.reduce((acc, value) => acc + Math.pow(value - mean, 2), 0) /
+            data.length);
+    }
+}
+exports.MathUtils = MathUtils;