@rian8337/osu-base 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/index.js

@@ -344,9 +344,7 @@ class APIRequestBuilder {
      * @param param The parameter to remove.
      */
     removeParameter(param) {
-        if (this.params.get(param)) {
-            this.params.delete(param);
-        }
+        this.params.delete(param);
         return this;
     }
 }
@@ -357,18 +355,6 @@ class DroidAPIRequestBuilder extends APIRequestBuilder {
     host = "https://osudroid.moe/api/";
     APIkey = process.env.DROID_API_KEY;
     APIkeyParam = `apiKey=${this.APIkey}&`;
-    setEndpoint(endpoint) {
-        // Compatibility with old API. Can be removed in v3.0.
-        switch (endpoint) {
-            case "banscore.php":
-                endpoint = "single_score_wipe.php";
-                break;
-            case "rename.php":
-                endpoint = "user_rename.php";
-                break;
-        }
-        return super.setEndpoint(endpoint);
-    }
 }
 /**
  * API request builder for osu!standard.
@@ -379,6 +365,15 @@ class OsuAPIRequestBuilder extends APIRequestBuilder {
     APIkeyParam = `k=${this.APIkey}&`;
 }
 
+/**
+ * Mode enum to switch things between osu!droid and osu!standard.
+ */
+exports.modes = void 0;
+(function (modes) {
+    modes["droid"] = "droid";
+    modes["osu"] = "osu";
+})(exports.modes || (exports.modes = {}));
+
 /**
  * Bitmask constant of object types. This is needed as osu! uses bits to determine object types.
  */
@@ -396,11 +391,11 @@ exports.objectTypes = void 0;
  */
 class Vector2 {
     /**
-     * The x position of the vector.
+     * The x position of this vector.
      */
     x;
     /**
-     * The y position of the vector.
+     * The y position of this vector.
      */
     y;
     constructor(x, y) {
@@ -408,11 +403,22 @@ class Vector2 {
         this.y = y;
     }
     /**
-     * Multiplies the vector with another vector.
+     * Multiplies this vector with another vector.
+     *
+     * @param vec The other vector.
+     * @returns The multiplied vector.
      */
     multiply(vec) {
         return new Vector2(this.x * vec.x, this.y * vec.y);
     }
+    /**
+     * Divides this vector with a scalar.
+     *
+     * Attempting to divide by 0 will throw an error.
+     *
+     * @param divideFactor The factor to divide the vector by.
+     * @returns The divided vector.
+     */
     divide(divideFactor) {
         if (divideFactor === 0) {
             throw new Error("Division by 0");
@@ -420,37 +426,52 @@ class Vector2 {
         return new Vector2(this.x / divideFactor, this.y / divideFactor);
     }
     /**
-     * Adds the vector with another vector.
+     * Adds this vector with another vector.
+     *
+     * @param vec The other vector.
+     * @returns The added vector.
      */
     add(vec) {
         return new Vector2(this.x + vec.x, this.y + vec.y);
     }
     /**
-     * Subtracts the vector with another vector.
+     * Subtracts this vector with another vector.
+     *
+     * @param vec The other vector.
+     * @returns The subtracted vector.
      */
     subtract(vec) {
         return new Vector2(this.x - vec.x, this.y - vec.y);
     }
     /**
-     * The length of the vector.
+     * The length of this vector.
      */
     get length() {
         return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
     }
     /**
      * Performs a dot multiplication with another vector.
+     *
+     * @param vec The other vector.
+     * @returns The dot product of both vectors.
      */
     dot(vec) {
         return this.x * vec.x + this.y * vec.y;
     }
     /**
-     * Scales the vector.
+     * Scales this vector.
+     *
+     * @param scaleFactor The factor to scale the vector by.
+     * @returns The scaled vector.
      */
     scale(scaleFactor) {
         return new Vector2(this.x * scaleFactor, this.y * scaleFactor);
     }
     /**
      * Gets the distance between this vector and another vector.
+     *
+     * @param vec The other vector.
+     * @returns The distance between this vector and the other vector.
      */
     getDistance(vec) {
         const x = this.x - vec.x;
@@ -469,6 +490,7 @@ class Vector2 {
      * Checks whether this vector is equal to another vector.
      *
      * @param other The other vector.
+     * @returns Whether this vector is equal to the other vector.
      */
     equals(other) {
         return this.x === other.x && this.y === other.y;
@@ -511,31 +533,6 @@ class HitObject {
     get duration() {
         return this.endTime - this.startTime;
     }
-    /**
-     * The stacked position of the hitobject.
-     */
-    get stackedPosition() {
-        if (this.type & exports.objectTypes.spinner) {
-            return this.position;
-        }
-        return this.position.add(this.stackOffset);
-    }
-    /**
-     * The stacked end position of the hitobject.
-     */
-    get stackedEndPosition() {
-        if (this.type & exports.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(coordinate, coordinate);
-    }
     /**
      * Whether this hit object represents a new combo.
      */
@@ -556,15 +553,13 @@ class HitObject {
      */
     stackHeight = 0;
     /**
-     * The scale used to calculate stacked position and radius.
+     * The osu!droid scale used to calculate stacked position and radius.
      */
-    scale = 1;
+    droidScale = 1;
     /**
-     * The radius of the hitobject.
+     * The osu!standard scale used to calculate stacked position and radius.
      */
-    get radius() {
-        return 64 * this.scale;
-    }
+    osuScale = 1;
     constructor(values) {
         this.startTime = values.startTime;
         this.endTime = values.endTime ?? values.startTime;
@@ -574,6 +569,62 @@ class HitObject {
         this.isNewCombo = values.newCombo ?? false;
         this.comboOffset = values.comboOffset ?? 0;
     }
+    /**
+     * Evaluates the radius of the hitobject.
+     *
+     * @param mode The gamemode to evaluate for.
+     * @returns The radius of the hitobject with respect to the gamemode.
+     */
+    getRadius(mode) {
+        let radius = 64;
+        switch (mode) {
+            case exports.modes.droid:
+                radius *= this.droidScale;
+                break;
+            case exports.modes.osu:
+                radius *= this.osuScale;
+                break;
+        }
+        return radius;
+    }
+    /**
+     * Evaluates the stack offset vector of the hitobject.
+     *
+     * This is used to calculate offset for stacked positions.
+     *
+     * @param mode The gamemode to evaluate for.
+     * @returns The stack offset with respect to the gamemode.
+     */
+    getStackOffset(mode) {
+        let coordinate = this.stackHeight * -6.4;
+        switch (mode) {
+            case exports.modes.droid:
+                coordinate *= this.droidScale;
+                break;
+            case exports.modes.osu:
+                coordinate *= this.osuScale;
+                break;
+        }
+        return new Vector2(coordinate, coordinate);
+    }
+    /**
+     * Evaluates the stacked position of the hitobject.
+     *
+     * @param mode The gamemode to evaluate for.
+     * @returns The stacked position with respect to the gamemode.
+     */
+    getStackedPosition(mode) {
+        return this.evaluateStackedPosition(this.position, mode);
+    }
+    /**
+     * Evaluates the stacked end position of the hitobject.
+     *
+     * @param mode The gamemode to evaluate for.
+     * @returns The stacked end position with respect to the gamemode.
+     */
+    getStackedEndPosition(mode) {
+        return this.evaluateStackedPosition(this.endPosition, mode);
+    }
     /**
      * Returns the hitobject type.
      */
@@ -590,6 +641,19 @@ class HitObject {
         }
         return res.substring(0, Math.max(0, res.length - 3));
     }
+    /**
+     * Evaluates the stacked position of the specified position.
+     *
+     * @param position The position to evaluate.
+     * @param mode The gamemode to evaluate for.
+     * @returns The stacked position.
+     */
+    evaluateStackedPosition(position, mode) {
+        if (this.type & exports.objectTypes.spinner) {
+            return position;
+        }
+        return position.add(this.getStackOffset(mode));
+    }
 }
 
 /**
@@ -1193,15 +1257,7 @@ class ControlPointManager {
             }
             existing = this.controlPointAt(controlPoint.time);
         }
-        // Get the index at which to add the control point.
-        for (let i = 0; i < this._points.length; ++i) {
-            if (this._points[i].time >= controlPoint.time) {
-                this._points.splice(i - 1, 0, controlPoint);
-                return true;
-            }
-        }
-        // Append the control point if it hasn't been added yet.
-        this._points.push(controlPoint);
+        this._points.splice(this.findInsertionIndex(controlPoint.time), 0, controlPoint);
         return true;
     }
     /**
@@ -1235,6 +1291,12 @@ class ControlPointManager {
     removeAt(index) {
         return this._points.splice(index, 1)[0];
     }
+    /**
+     * Clears all control points of this type.
+     */
+    clear() {
+        this._points.length = 0;
+    }
     /**
      * Binary searches one of the control point lists to find the active control point at the given time.
      *
@@ -1274,9 +1336,37 @@ class ControlPointManager {
                 return this._points[pivot];
             }
         }
-        // l will be the first control point with time > this.controlPoints[l].time, but we want the one before it
+        // l will be the first control point with time > this._points[l].time, but we want the one before it
         return this._points[l - 1];
     }
+    /**
+     * Finds the insertion index of a control point in a given time.
+     *
+     * @param time The start time of the control point.
+     */
+    findInsertionIndex(time) {
+        if (this._points.length === 0 || time < this._points[0].time) {
+            return 0;
+        }
+        if (time >= this._points.at(-1).time) {
+            return this._points.length;
+        }
+        let l = 0;
+        let r = this._points.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this._points[pivot].time < time) {
+                l = pivot + 1;
+            }
+            else if (this._points[pivot].time > time) {
+                r = pivot - 1;
+            }
+            else {
+                return pivot;
+            }
+        }
+        return l;
+    }
 }
 
 /**
@@ -1437,7 +1527,7 @@ class SampleControlPointManager extends ControlPointManager {
 }
 
 /**
- * Contains information about timing and control points of a beatmap.
+ * Contains information about timing (control) points of a beatmap.
  */
 class BeatmapControlPoints {
     /**
@@ -1456,6 +1546,15 @@ class BeatmapControlPoints {
      * The manager for sample control points of the beatmap.
      */
     sample = new SampleControlPointManager();
+    /**
+     * Clears all control points in the beatmap.
+     */
+    clear() {
+        this.timing.clear();
+        this.difficulty.clear();
+        this.effect.clear();
+        this.sample.clear();
+    }
 }
 
 /**
@@ -1573,7 +1672,7 @@ class BeatmapHitObjects {
                     }
                 }
             }
-            else if (object instanceof Spinner) {
+            else {
                 ++this._spinners;
             }
         }
@@ -1622,12 +1721,28 @@ class BeatmapHitObjects {
      * @param startTime The start time of the hitobject.
      */
     findInsertionIndex(startTime) {
-        for (let i = 0; i < this.objects.length; ++i) {
-            if (this.objects[i].startTime > startTime) {
-                return i;
+        if (this._objects.length === 0 ||
+            startTime < this._objects[0].startTime) {
+            return 0;
+        }
+        if (startTime >= this._objects.at(-1).startTime) {
+            return this._objects.length;
+        }
+        let l = 0;
+        let r = this._objects.length - 2;
+        while (l <= r) {
+            const pivot = l + ((r - l) >> 1);
+            if (this._objects[pivot].startTime < startTime) {
+                l = pivot + 1;
+            }
+            else if (this._objects[pivot].startTime > startTime) {
+                r = pivot - 1;
+            }
+            else {
+                return pivot;
             }
         }
-        return this.objects.length;
+        return l;
     }
 }
 
@@ -1893,15 +2008,6 @@ class BeatmapBackground {
     }
 }
 
-/**
- * Mode enum to switch things between osu!droid and osu!standard.
- */
-exports.modes = void 0;
-(function (modes) {
-    modes["droid"] = "droid";
-    modes["osu"] = "osu";
-})(exports.modes || (exports.modes = {}));
-
 class HitWindow {
     /**
      * The overall difficulty of this hit window.
@@ -2373,7 +2479,7 @@ class ModUtil {
      * @param options Options for parsing behavior.
      */
     static pcModbitsToMods(modbits, options) {
-        return this.processParsingOptions(this.allMods.filter((m) => m.isApplicableToOsu() && (m.bitwise & modbits)), options);
+        return this.processParsingOptions(this.allMods.filter((m) => m.isApplicableToOsu() && m.bitwise & modbits), options);
     }
     /**
      * Gets a list of mods from a PC mod string, such as "HDHR".
@@ -2416,8 +2522,7 @@ class ModUtil {
         for (const incompatibleMod of this.incompatibleMods) {
             const fulfilledMods = mods.filter((m) => incompatibleMod.some((v) => m.acronym === v.acronym));
             if (fulfilledMods.length > 1) {
-                mods = mods.filter((m) => incompatibleMod
-                    .every((v) => m.acronym !== v.acronym));
+                mods = mods.filter((m) => incompatibleMod.every((v) => m.acronym !== v.acronym));
                 // Keep the first selected mod
                 mods.push(fulfilledMods[0]);
             }
@@ -2743,6 +2848,49 @@ class Precision {
         return (this.almostEqualsNumber(vec1.x, vec2.x, acceptableDifference) &&
             this.almostEqualsNumber(vec1.y, vec2.y, acceptableDifference));
     }
+    /**
+     * Checks whether two real numbers are almost equal.
+     *
+     * @param a The first number.
+     * @param b The second number.
+     * @param maximumError The accuracy required for being almost equal. Defaults to `10 * 2^(-53)`.
+     * @returns Whether the two values differ by no more than 10 * 2^(-52).
+     */
+    static almostEqualRelative(a, b, maximumError = 10 * Math.pow(2, -53)) {
+        return this.almostEqualNormRelative(a, b, a - b, maximumError);
+    }
+    /**
+     * Compares two numbers and determines if they are equal within the specified maximum error.
+     *
+     * @param a The norm of the first value (can be negative).
+     * @param b The norm of the second value (can be negative).
+     * @param diff The norm of the difference of the two values (can be negative).
+     * @param maximumError The accuracy required for being almost equal.
+     * @returns Whether both numbers are almost equal up to the specified maximum error.
+     */
+    static almostEqualNormRelative(a, b, diff, maximumError) {
+        // If A or B are infinity (positive or negative) then
+        // only return true if they are exactly equal to each other -
+        // that is, if they are both infinities of the same sign.
+        if (!Number.isFinite(a) || !Number.isFinite(b)) {
+            return a === b;
+        }
+        // If A or B are a NAN, return false. NANs are equal to nothing,
+        // not even themselves.
+        if (Number.isNaN(a) || Number.isNaN(b)) {
+            return false;
+        }
+        // If one is almost zero, fall back to absolute equality.
+        const doublePrecision = Math.pow(2, -53);
+        if (Math.abs(a) < doublePrecision || Math.abs(b) < doublePrecision) {
+            return Math.abs(diff) < maximumError;
+        }
+        if ((a === 0 && Math.abs(b) < maximumError) ||
+            (b === 0 && Math.abs(a) < maximumError)) {
+            return true;
+        }
+        return (Math.abs(diff) < maximumError * Math.max(Math.abs(a), Math.abs(b)));
+    }
 }
 
 /**
@@ -4302,7 +4450,12 @@ class RGBColor {
      * Returns a string representation of the color.
      */
     toString() {
-        return `${this.r},${this.g},${this.b}`;
+        if (this.a === 1) {
+            return `${this.r},${this.g},${this.b}`;
+        }
+        else {
+            return `${this.r},${this.g},${this.b},${this.a}`;
+        }
     }
     /**
      * Checks whether this color is equal to another color.
@@ -4310,7 +4463,10 @@ class RGBColor {
      * @param other The other color.
      */
     equals(other) {
-        return this.r === other.r && this.g === other.g && this.b === other.b;
+        return (this.r === other.r &&
+            this.g === other.g &&
+            this.b === other.b &&
+            this.a === other.a);
     }
 }
 
@@ -4664,21 +4820,11 @@ class CommandTimelineGroup {
         this.flipHorizontal,
         this.flipVertical,
     ];
-    /**
-     * The earliest visible time. Will be `null` unless this group's first alpha command has a start value of zero.
-     */
-    get earliestDisplayedTime() {
-        const first = this.alpha.commands.at(0);
-        return first?.startValue === 0 ? first.startTime : null;
-    }
     /**
      * The start time of commands.
      */
     get commandsStartTime() {
-        // If the first alpha command starts at zero it should be given priority over anything else.
-        // This is due to it creating a state where the target is not present before that time, causing any other events to not be visible.
-        return (this.earliestDisplayedTime ??
-            Math.min(...this.timelines.map((t) => t.startTime)));
+        return Math.min(...this.timelines.map((t) => t.startTime));
     }
     /**
      * The end time of commands.
@@ -4719,7 +4865,7 @@ class CommandTimelineGroup {
     /**
      * Gets the commands from a command timeline.
      *
-     * @param timelineSelector A function that returns a command timeline.
+     * @param timelineSelector A function to select the command timeline to retrieve commands from.
      * @param offset The offset to apply to all commands.
      */
     getCommands(timelineSelector, offset = 0) {
@@ -4831,20 +4977,14 @@ class StoryboardElement {
  * Represents a storyboard sprite.
  */
 class StoryboardSprite extends StoryboardElement {
-    _loops = [];
-    _triggers = [];
     /**
      * The loop commands of the sprite.
      */
-    get loops() {
-        return this._loops;
-    }
+    loops = [];
     /**
      * The trigger commands of the sprite.
      */
-    get triggers() {
-        return this._triggers;
-    }
+    triggers = [];
     /**
      * The origin of the sprite.
      */
@@ -4858,28 +4998,57 @@ class StoryboardSprite extends StoryboardElement {
      */
     timelineGroup = new CommandTimelineGroup();
     get startTime() {
-        // Check for presence affecting commands as an initial pass.
-        let earliestStartTime = this.timelineGroup.earliestDisplayedTime ??
-            Number.POSITIVE_INFINITY;
-        for (const l of this._loops) {
-            const { earliestDisplayedTime: loopEarliestDisplayTime } = l;
-            if (loopEarliestDisplayTime !== null) {
-                earliestStartTime = Math.min(earliestStartTime, l.loopStartTime + loopEarliestDisplayTime);
+        // To get the initial start time, we need to check whether the first alpha command to exist (across all loops) has a start value of zero.
+        // A start value of zero governs, above all else, the first valid display time of a sprite.
+        //
+        // You can imagine that the first command of each type decides that type's start value, so if the initial alpha is zero,
+        // anything before that point can be ignored (the sprite is not visible after all).
+        const alphaCommands = [];
+        let command = this.timelineGroup.alpha.commands[0];
+        if (command) {
+            alphaCommands.push({
+                startTime: command.startTime,
+                isZeroStartValue: command.startValue === 0,
+            });
+        }
+        for (const l of this.loops) {
+            command = l.alpha.commands[0];
+            if (command) {
+                alphaCommands.push({
+                    startTime: command.startTime + l.loopStartTime,
+                    isZeroStartValue: command.startValue === 0,
+                });
             }
         }
-        return earliestStartTime !== Number.POSITIVE_INFINITY
-            ? earliestStartTime
-            : Math.min(this.timelineGroup.startTime, ...this._loops.map((l) => l.startTime));
+        if (alphaCommands.length > 0) {
+            const firstAlpha = alphaCommands.sort((a, b) => a.startTime - b.startTime)[0];
+            if (firstAlpha.isZeroStartValue) {
+                return firstAlpha.startTime;
+            }
+        }
+        return this.earliestTransformTime;
+    }
+    /**
+     * The time at which the first transformation occurs.
+     */
+    get earliestTransformTime() {
+        // If we got to this point, either no alpha commands were present, or the earliest had a non-zero start value.
+        // The sprite's start time will be determined by the earliest command, regardless of type.
+        let earliestStartTime = this.timelineGroup.startTime;
+        for (const l of this.loops) {
+            earliestStartTime = Math.min(earliestStartTime, l.startTime);
+        }
+        return earliestStartTime;
     }
     get endTime() {
-        return Math.max(this.timelineGroup.endTime, ...this._loops.map((l) => l.endTime));
+        return Math.max(this.timelineGroup.endTime, ...this.loops.map((l) => l.endTime));
     }
     /**
      * Whether this sprite has at least one command.
      */
     get hasCommands() {
         return (this.timelineGroup.hasCommands ||
-            this._loops.some((l) => l.hasCommands));
+            this.loops.some((l) => l.hasCommands));
     }
     constructor(path, origin, initialPosition) {
         super(path);
@@ -4895,7 +5064,7 @@ class StoryboardSprite extends StoryboardElement {
      */
     addLoop(startTime, repeatCount) {
         const loop = new CommandLoop(startTime, repeatCount);
-        this._loops.push(loop);
+        this.loops.push(loop);
         return loop;
     }
     /**
@@ -4909,7 +5078,7 @@ class StoryboardSprite extends StoryboardElement {
      */
     addTrigger(triggerName, startTime, endTime, groupNumber) {
         const trigger = new CommandTrigger(triggerName, startTime, endTime, groupNumber);
-        this._triggers.push(trigger);
+        this.triggers.push(trigger);
         return trigger;
     }
     toString() {
@@ -5349,16 +5518,23 @@ class BeatmapDecoder extends Decoder {
         else {
             hitObjectsDecoder.applyStackingOld();
         }
-        const circleSize = new MapStats({
+        const droidCircleSize = new MapStats({
+            cs: this.finalResult.difficulty.cs,
+            mods,
+        }).calculate({ mode: exports.modes.droid }).cs;
+        const droidScale = (1 - (0.7 * (droidCircleSize - 5)) / 5) / 2;
+        const osuCircleSize = new MapStats({
             cs: this.finalResult.difficulty.cs,
             mods,
-        }).calculate().cs;
-        const scale = (1 - (0.7 * (circleSize - 5)) / 5) / 2;
+        }).calculate({ mode: exports.modes.osu }).cs;
+        const osuScale = (1 - (0.7 * (osuCircleSize - 5)) / 5) / 2;
         this.finalResult.hitObjects.objects.forEach((h) => {
-            h.scale = scale;
+            h.droidScale = droidScale;
+            h.osuScale = osuScale;
             if (h instanceof Slider) {
                 h.nestedHitObjects.forEach((n) => {
-                    n.scale = scale;
+                    n.droidScale = droidScale;
+                    n.osuScale = osuScale;
                 });
             }
         });
@@ -6118,6 +6294,236 @@ class BeatmapEncoder extends Encoder {
     }
 }
 
+class ZeroCrossingBracketing {
+    /**
+     * Detect a range containing at least one root.
+     *
+     * This iterative method stops when two values with opposite signs are found.
+     *
+     * @param f The function to detect roots from.
+     * @param bounds The upper and lower value of the range.
+     * @param factor The growing factor of research. Defaults to 1.6.
+     * @param maxIterations Maximum number of iterations. Defaults to 50.
+     * @returns Whether the bracketing operation succeeded.
+     */
+    static expand(f, bounds, factor = 1.6, maxIterations = 50) {
+        const originalUpperBound = bounds.upperBound;
+        const originalLowerBound = bounds.lowerBound;
+        if (originalLowerBound >= originalUpperBound) {
+            throw new RangeError("Upper bound must be greater than lower bound.");
+        }
+        let fmin = f(originalLowerBound);
+        let fmax = f(originalUpperBound);
+        for (let i = 0; i < maxIterations; ++i) {
+            if (Math.sign(fmin) !== Math.sign(fmax)) {
+                return true;
+            }
+            if (Math.abs(fmin) < Math.abs(fmax)) {
+                bounds.lowerBound +=
+                    factor * (bounds.lowerBound - bounds.upperBound);
+                fmin = f(bounds.lowerBound);
+            }
+            else {
+                bounds.upperBound +=
+                    factor * (bounds.upperBound - bounds.lowerBound);
+                fmax = f(bounds.upperBound);
+            }
+        }
+        bounds.lowerBound = originalLowerBound;
+        bounds.upperBound = originalUpperBound;
+        return false;
+    }
+    static reduce(f, bounds, subdivisions = 1000) {
+        const originalUpperBound = bounds.upperBound;
+        const originalLowerBound = bounds.lowerBound;
+        if (originalLowerBound >= originalUpperBound) {
+            throw new RangeError("Upper bound must be greater than lower bound.");
+        }
+        // TODO: Consider binary-style search instead of linear scan
+        const fmin = f(bounds.lowerBound);
+        const fmax = f(bounds.upperBound);
+        if (Math.sign(fmin) != Math.sign(fmax)) {
+            return true;
+        }
+        const subdiv = (bounds.upperBound - bounds.lowerBound) / subdivisions;
+        let smin = bounds.lowerBound;
+        const sign = Math.sign(fmin);
+        for (let i = 0; i < subdivisions; ++i) {
+            const smax = smin + subdiv;
+            const sfmax = f(smax);
+            if (!Number.isFinite(sfmax)) {
+                // expand interval to include pole
+                smin = smax;
+                continue;
+            }
+            if (Math.sign(sfmax) != sign) {
+                bounds.upperBound = smax;
+                bounds.lowerBound = smin;
+                return true;
+            }
+            smin = smax;
+        }
+        bounds.lowerBound = originalLowerBound;
+        bounds.upperBound = originalUpperBound;
+        return false;
+    }
+    static expandReduce(f, bounds, expansionFactor = 1.6, expansionMaxIterations = 50, reduceSubdivisions = 100) {
+        return (this.expand(f, bounds, expansionFactor, expansionMaxIterations) ||
+            this.reduce(f, bounds, reduceSubdivisions));
+    }
+}
+
+/**
+ * Algorithm by Brent, Van Wijngaarden, Dekker et al.
+ *
+ * Implementation inspired by Press, Teukolsky, Vetterling, and Flannery, "Numerical Recipes in C", 2nd edition, Cambridge University Press.
+ */
+class Brent {
+    /**
+     * Finds a solution to the equation f(x) = 0.
+     *
+     * @param f The function to find roots from.
+     * @param bounds The upper and lower root bounds.
+     * @param accuracy The desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Defaults to 1e-8. Must be greater than 0.
+     * @param maxIterations The maximum number of iterations. Defaults to 100.
+     * @param expandFactor The factor at which to expand the bounds, if needed. Defaults to 1.6.
+     * @param maxExpandIterations The maximum number of expand iterations. Defaults to 100.
+     * @returns The root with the specified accuracy. Throws an error if the algorithm failed to converge.
+     */
+    static findRootExpand(f, bounds, accuracy = 1e-8, maxIterations = 100, expandFactor = 1.6, maxExpandIterations = 100) {
+        ZeroCrossingBracketing.expandReduce(f, bounds, expandFactor, maxExpandIterations, maxExpandIterations * 10);
+        return this.findRoot(f, bounds, accuracy, maxIterations);
+    }
+    /**
+     * Finds a solution to the equation f(x) = 0.
+     *
+     * @param f The function to find roots from.
+     * @param bounds The upper and lower root bounds.
+     * @param accuracy The desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Defaults to 1e-8. Must be greater than 0.
+     * @param maxIterations The maximum number of iterations. Defaults to 100.
+     * @returns The root with the specified accuracy. Throws an error if the algorithm failed to converge.
+     */
+    static findRoot(f, bounds, accuracy = 1e-8, maxIterations = 100) {
+        const root = this.tryFindRoot(f, bounds, accuracy, maxIterations);
+        if (root === null) {
+            throw new Error("The algorithm has failed, exceeded the number of iterations allowed or there is no root within the provided bounds.");
+        }
+        return root;
+    }
+    /**
+     * Finds a solution to the equation f(x) = 0.
+     *
+     * @param f The function to find roots from.
+     * @param bounds The upper and lower root bounds.
+     * @param accuracy The desired accuracy. The root will be refined until the accuracy or the maximum number of iterations is reached. Must be greater than 0.
+     * @param maxIterations The maximum number of iterations. Usually 100.
+     * @returns The root with the specified accuracy, `null` if not found.
+     */
+    static tryFindRoot(f, bounds, accuracy, maxIterations) {
+        if (accuracy <= 0) {
+            throw new RangeError("Accuracy must be greater than 0.");
+        }
+        let { lowerBound, upperBound } = bounds;
+        let fmin = f(lowerBound);
+        let fmax = f(upperBound);
+        let froot = fmax;
+        let d = 0;
+        let e = 0;
+        let root = upperBound;
+        let xMid = Number.NaN;
+        // Root must be bracketed.
+        if (Math.sign(fmin) === Math.sign(fmax)) {
+            return null;
+        }
+        for (let i = 0; i <= maxIterations; ++i) {
+            // Adjust bounds.
+            if (Math.sign(froot) === Math.sign(fmax)) {
+                upperBound = lowerBound;
+                fmax = fmin;
+                e = d = root - lowerBound;
+            }
+            if (Math.abs(fmax) < Math.abs(froot)) {
+                lowerBound = root;
+                root = upperBound;
+                upperBound = lowerBound;
+                fmin = froot;
+                froot = fmax;
+                fmax = fmin;
+            }
+            // Convergence check
+            const xAcc1 = 2 * Math.pow(2, -53) * Math.abs(root) + accuracy / 2;
+            const xMidOld = xMid;
+            xMid = (upperBound - root) / 2;
+            if (Math.abs(xMid) <= xAcc1 ||
+                Precision.almostEqualNormRelative(froot, 0, froot, accuracy)) {
+                return root;
+            }
+            if (xMid === xMidOld) {
+                // accuracy not sufficient, but cannot be improved further
+                return null;
+            }
+            if (Math.abs(e) >= xAcc1 && Math.abs(fmin) > Math.abs(froot)) {
+                // Attempt inverse quadratic interpolation
+                const s = froot / fmin;
+                let p;
+                let q;
+                if (Precision.almostEqualRelative(lowerBound, upperBound)) {
+                    p = 2 * xMid * s;
+                    q = 1 - s;
+                }
+                else {
+                    q = fmin / fmax;
+                    const r = froot / fmax;
+                    p =
+                        s *
+                            (2 * xMid * q * (q - r) -
+                                (root - lowerBound) * (r - 1));
+                    q = (q - 1) * (r - 1) * (s - 1);
+                }
+                if (p > 0) {
+                    // Check whether in bounds
+                    q = -q;
+                }
+                p = Math.abs(p);
+                if (2 * p <
+                    Math.min(3 * xMid * q - Math.abs(xAcc1 * q), Math.abs(e * q))) {
+                    // Accept interpolation
+                    e = d;
+                    d = p / q;
+                }
+                else {
+                    // Interpolation failed, use bisection
+                    d = xMid;
+                    e = d;
+                }
+            }
+            else {
+                // Bounds decreasing too slowly, use bisection
+                d = xMid;
+                e = d;
+            }
+            lowerBound = root;
+            fmin = froot;
+            if (Math.abs(d) > xAcc1) {
+                root += d;
+            }
+            else {
+                root += this.sign(xAcc1, xMid);
+            }
+            froot = f(root);
+        }
+        return null;
+    }
+    /**
+     * Helper method useful for preventing rounding errors.
+     *
+     * @returns a * sign(b)
+     */
+    static sign(a, b) {
+        return b >= 0 ? (a >= 0 ? a : -a) : a >= 0 ? -a : a;
+    }
+}
+
 /**
  * Types of easing.
  *
@@ -6583,6 +6989,29 @@ class ErrorFunction {
         }
         return this.erfImp(x, false);
     }
+    /**
+     * Calculates the complementary error function.
+     *
+     * @param x The value to evaluate.
+     * @returns The complementary error function evaluated at given value, or:
+     * - 0 if `x === Number.POSITIVE_INFINITY`;
+     * - 2 if `x === Number.NEGATIVE_INFINITY`.
+     */
+    static erfc(x) {
+        if (x === 0) {
+            return 1;
+        }
+        if (x === Number.POSITIVE_INFINITY) {
+            return 0;
+        }
+        if (x === Number.NEGATIVE_INFINITY) {
+            return 2;
+        }
+        if (Number.isNaN(x)) {
+            return Number.NaN;
+        }
+        return this.erfImp(x, true);
+    }
     /**
      * Calculates the inverse error function evaluated at z.
      *
@@ -7426,6 +7855,16 @@ class MapInfo {
     }
 }
 
+/**
+ * Represents the osu! playfield.
+ */
+class Playfield {
+    /**
+     * The size of the playfield, which is 512x384.
+     */
+    static baseSize = new Vector2(512, 384);
+}
+
 dotenv.config();
 
 exports.Accuracy = Accuracy;
@@ -7444,6 +7883,7 @@ exports.BeatmapMetadata = BeatmapMetadata;
 exports.BeatmapVideo = BeatmapVideo;
 exports.BlendingParameters = BlendingParameters;
 exports.BreakPoint = BreakPoint;
+exports.Brent = Brent;
 exports.Circle = Circle;
 exports.Command = Command;
 exports.CommandLoop = CommandLoop;
@@ -7488,6 +7928,7 @@ exports.ModUtil = ModUtil;
 exports.OsuAPIRequestBuilder = OsuAPIRequestBuilder;
 exports.OsuHitWindow = OsuHitWindow;
 exports.PathApproximator = PathApproximator;
+exports.Playfield = Playfield;
 exports.Polynomial = Polynomial;
 exports.Precision = Precision;
 exports.RGBColor = RGBColor;
@@ -7513,4 +7954,5 @@ exports.TimingControlPoint = TimingControlPoint;
 exports.TimingControlPointManager = TimingControlPointManager;
 exports.Utils = Utils;
 exports.Vector2 = Vector2;
+exports.ZeroCrossingBracketing = ZeroCrossingBracketing;
 //# sourceMappingURL=index.js.map