curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/cubic-BajUY0JT.d.mts

@@ -0,0 +1,1100 @@
+import { t as Vector2 } from "./vector2-DPUY3_eA.mjs";
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+import { r as Vector4, t as Vector3 } from "./vector3-DqeOZtOB.mjs";
+import { n as Closed, r as Interval } from "./interval-Dy-RMEE3.mjs";
+import { i as One, n as AtMostThree, r as AtMostTwo, t as AtMostOne } from "./solution-sNQ-ZVhN.mjs";
+
+//#region src/polynomial/traits.d.ts
+/**
+ * Trait brands for polynomials.
+ *
+ * Brands are phantom types — they exist only at the type level and carry no
+ * runtime data. A polynomial value at runtime is identical regardless of the
+ * traits attached to its type. Refiners (`isMonotonic`, `isIncreasing`, …) and
+ * assertions (`asMonotonic`, …) on each polynomial module attach these brands
+ * to the polynomial's `Traits` parameter at the type level.
+ *
+ * The intersection model is "trait accumulation": a polynomial typed as
+ * `LinearPolynomial<Increasing>` carries both the `Monotonic` and `Increasing`
+ * brands, since `Increasing` extends `Monotonic`.
+ *
+ * @since 2.0.0
+ */
+declare const MonotonicId: unique symbol;
+/**
+ * Brand for *strictly* monotonic polynomials — `monotonicity()` returns
+ * `'increasing'` or `'decreasing'`. The constant case is excluded; constants
+ * have no useful inverse refinement.
+ *
+ * @since 2.0.0
+ */
+type Monotonic = {
+  readonly [MonotonicId]: 'monotonic';
+};
+declare const IncreasingId: unique symbol;
+/**
+ * Brand for strictly increasing polynomials. Implies `Monotonic`.
+ *
+ * @since 2.0.0
+ */
+type Increasing = Monotonic & {
+  readonly [IncreasingId]: 'increasing';
+};
+declare const DecreasingId: unique symbol;
+/**
+ * Brand for strictly decreasing polynomials. Implies `Monotonic`.
+ *
+ * @since 2.0.0
+ */
+type Decreasing = Monotonic & {
+  readonly [DecreasingId]: 'decreasing';
+};
+/**
+ * Phantom property key used by polynomial interfaces to hold their `Traits`
+ * type parameter. The runtime object never has a value at this key — the
+ * `declare` modifier on the impl class makes the property type-visible only.
+ * The symbol itself is exported as a real value so that bundlers can resolve
+ * the computed key reference even though the property is never assigned.
+ *
+ * @since 2.0.0
+ */
+declare const PolynomialTraits: unique symbol;
+type PolynomialTraits = typeof PolynomialTraits;
+//#endregion
+//#region src/polynomial/cubic.internal.circular.d.ts
+declare const CubicPolynomialTypeId: unique symbol;
+type CubicPolynomialTypeId = typeof CubicPolynomialTypeId;
+//#endregion
+//#region src/polynomial/monotonicity.d.ts
+type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
+type GuaranteedMonotonicity = 'increasing' | 'decreasing' | 'constant';
+//#endregion
+//#region src/polynomial/linear.internal.d.ts
+declare const LinearPolynomialTypeId: unique symbol;
+type LinearPolynomialTypeId = typeof LinearPolynomialTypeId;
+declare namespace linear_d_exports {
+  export { Decreasing, Increasing, LinearPolynomial, Monotonic, antiderivative$1 as antiderivative, asDecreasing$2 as asDecreasing, asIncreasing$2 as asIncreasing, asMonotonic$2 as asMonotonic, derivative$2 as derivative, domain$2 as domain, equals$2 as equals, fromPointSlope, fromPoints$2 as fromPoints, fromVector$2 as fromVector, isDecreasing$2 as isDecreasing, isIncreasing$2 as isIncreasing, isLinearPolynomial, isMonotonic$2 as isMonotonic, length$2 as length, make$2 as make, monotonicity$2 as monotonicity, range$2 as range, root, solve$2 as solve, solveInverse$2 as solveInverse, toInverseSolver$2 as toInverseSolver, toSolver$2 as toSolver };
+}
+/**
+ * A linear polynomial.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Traits` type parameter is a phantom marker that accumulates trait
+ * brands as the polynomial is refined via `isMonotonic` / `asMonotonic` and
+ * friends. The runtime value carries no trait data — `Traits` only flows
+ * through the type system to enable tighter return types on operations like
+ * `solveInverse`.
+ *
+ * @since 1.0.0
+ */
+interface LinearPolynomial<out Traits = unknown> extends Pipeable {
+  readonly [LinearPolynomialTypeId]: LinearPolynomialTypeId;
+  readonly [PolynomialTraits]: Traits;
+  /**
+   * The coefficient of the x^0 term.
+   */
+  readonly c0: number;
+  /**
+   * The coefficient of the x^1 term.
+   */
+  readonly c1: number;
+}
+/**
+ * Checks if a value is a `LinearPolynomial`.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is a `LinearPolynomial`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isLinearPolynomial: (v: unknown) => v is LinearPolynomial;
+declare const equals$2: {
+  /**
+   * Checks if two `LinearPolynomial` instances are approximately equal within
+   * the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param a - The first polynomial.
+   * @param b - The second polynomial.
+   * @returns `true` when each pair of coefficients is within tolerance.
+   * @since 1.1.0
+   */
+  (a: LinearPolynomial, b: LinearPolynomial): boolean;
+  /**
+   * Checks if two `LinearPolynomial` instances are approximately equal within
+   * the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param b - The second polynomial.
+   * @returns A function that takes the first polynomial and returns the comparison result.
+   * @since 1.1.0
+   */
+  (b: LinearPolynomial): (a: LinearPolynomial) => boolean;
+};
+/**
+ * Creates a new `LinearPolynomial` instance.
+ *
+ * @param c0 - The coefficient of the x^0 term. Defaults to 0.
+ * @param c1 - The coefficient of the x^1 term. Defaults to 0.
+ * @returns A new `LinearPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const make$2: (c0?: number, c1?: number) => LinearPolynomial;
+/**
+ * Creates a new `LinearPolynomial` instance from a vector.
+ *
+ * @param v - The vector to create the polynomial from.
+ * @returns A new `LinearPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const fromVector$2: (v: Vector2) => LinearPolynomial;
+/**
+ * Creates a new `LinearPolynomial` instance from a point and slope.
+ *
+ * @param p - The point on the line.
+ * @param slope - The slope of the line.
+ * @returns A new `LinearPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const fromPointSlope: (p: Vector2, slope: number) => LinearPolynomial;
+/**
+ * Creates a new `LinearPolynomial` instance from two points.
+ *
+ * @param p1 - The first point.
+ * @param p2 - The second point.
+ * @returns A new `LinearPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const fromPoints$2: (p1: Vector2, p2: Vector2) => LinearPolynomial;
+declare const solve$2: {
+  /**
+   * Solves a linear polynomial for a given value of x.
+   *
+   * @param p - The linear polynomial to solve.
+   * @param x - The value of x to solve for.
+   * @returns The result of the polynomial evaluated at x.
+   * @since 1.0.0
+   */
+  (p: LinearPolynomial, x: number): number;
+  /**
+   * Solves a linear polynomial for a given value of x.
+   *
+   * @param x - The value of x to solve for.
+   * @returns A function that takes a `LinearPolynomial` and returns the result of the polynomial evaluated at x.
+   * @since 1.0.0
+   */
+  (x: number): (p: LinearPolynomial) => number;
+};
+/**
+ * Converts a linear polynomial to a solver function.
+ *
+ * @param p - The linear polynomial to convert.
+ * @returns A function that takes a value of x and returns the result of the polynomial evaluated at x.
+ * @since 1.0.0
+ */
+declare const toSolver$2: (p: LinearPolynomial) => (x: number) => number;
+declare const solveInverse$2: {
+  /**
+   * Solves a monotonic linear polynomial for a given value of y. Because the
+   * polynomial is strictly monotonic, the inverse always has exactly one
+   * solution — wrapped in `Solution.One`.
+   *
+   * @param p - The monotonic linear polynomial to solve.
+   * @param y - The value of y to solve for.
+   * @since 2.0.0
+   */
+  <T extends Monotonic>(p: LinearPolynomial<T>, y: number): One<number>;
+  /**
+   * Solves a linear polynomial for a given value of y. Returns `Solution.none`
+   * for constant polynomials (no inverse).
+   *
+   * @param p - The linear polynomial to solve.
+   * @param y - The value of y to solve for.
+   * @since 1.0.0
+   */
+  <T>(p: LinearPolynomial<T>, y: number): AtMostOne<number>; /** @since 1.0.0 */
+  (y: number): {
+    <T extends Monotonic>(p: LinearPolynomial<T>): One<number>;
+    <T>(p: LinearPolynomial<T>): AtMostOne<number>;
+  };
+};
+/**
+ * Converts a linear polynomial to an inverse solver function.
+ *
+ * @param p - The linear polynomial to convert.
+ * @since 1.0.0
+ */
+declare const toInverseSolver$2: (p: LinearPolynomial) => (y: number) => AtMostOne<number>;
+/**
+ * Finds the roots of a linear polynomial.
+ *
+ * @param p - The linear polynomial to find the roots of.
+ * @since 1.0.0
+ */
+declare const root: (p: LinearPolynomial) => AtMostOne<number>;
+/**
+ * Calculates the monotonicity of a linear polynomial.
+ *
+ * @param p - The linear polynomial to check.
+ * @returns The guaranteed monotonicity of the polynomial.
+ * @since 1.0.0
+ */
+declare const monotonicity$2: (p: LinearPolynomial) => GuaranteedMonotonicity;
+/**
+ * Type-narrowing predicate: refines a `LinearPolynomial<T>` to
+ * `LinearPolynomial<T & Monotonic>` when the polynomial is strictly monotonic.
+ *
+ * @param p - The linear polynomial to check.
+ * @returns `true` when `monotonicity(p)` is `'increasing'` or `'decreasing'`.
+ * @since 2.0.0
+ */
+declare const isMonotonic$2: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Monotonic>;
+/**
+ * Type-narrowing predicate: refines to `LinearPolynomial<T & Increasing>`.
+ *
+ * @param p - The linear polynomial to check.
+ * @returns `true` when `monotonicity(p)` is `'increasing'`.
+ * @since 2.0.0
+ */
+declare const isIncreasing$2: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Increasing>;
+/**
+ * Type-narrowing predicate: refines to `LinearPolynomial<T & Decreasing>`.
+ *
+ * @param p - The linear polynomial to check.
+ * @returns `true` when `monotonicity(p)` is `'decreasing'`.
+ * @since 2.0.0
+ */
+declare const isDecreasing$2: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Decreasing>;
+/**
+ * Asserts that the linear polynomial is monotonic, throwing on failure.
+ *
+ * @param p - The linear polynomial to assert against.
+ * @returns The same polynomial, typed with the `Monotonic` brand.
+ * @throws When `monotonicity(p)` is `'constant'`.
+ * @since 2.0.0
+ */
+declare const asMonotonic$2: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Monotonic>;
+/**
+ * Asserts that the linear polynomial is increasing, throwing on failure.
+ *
+ * @param p - The linear polynomial to assert against.
+ * @returns The same polynomial, typed with the `Increasing` brand.
+ * @throws When `monotonicity(p)` is not `'increasing'`.
+ * @since 2.0.0
+ */
+declare const asIncreasing$2: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Increasing>;
+/**
+ * Asserts that the linear polynomial is decreasing, throwing on failure.
+ *
+ * @param p - The linear polynomial to assert against.
+ * @returns The same polynomial, typed with the `Decreasing` brand.
+ * @throws When `monotonicity(p)` is not `'decreasing'`.
+ * @since 2.0.0
+ */
+declare const asDecreasing$2: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Decreasing>;
+/**
+ * Calculates the derivative of a linear polynomial.
+ *
+ * @param p - The linear polynomial to differentiate.
+ * @returns The derivative of the linear polynomial.
+ * @since 1.0.0
+ */
+declare const derivative$2: (p: LinearPolynomial) => number;
+declare const antiderivative$1: {
+  /**
+   * Calculates the antiderivative of a linear polynomial.
+   *
+   * @param p - The linear polynomial to integrate.
+   * @param constant - The constant of integration. Defaults to 0.
+   * @returns The antiderivative of the linear polynomial.
+   * @since 1.0.0
+   */
+  (p: LinearPolynomial, constant?: number): QuadraticPolynomial;
+  /**
+   * Calculates the antiderivative of a linear polynomial.
+   *
+   * @param constant - The constant of integration. Defaults to 0.
+   * @returns A function that takes a `LinearPolynomial` and returns the antiderivative of the polynomial.
+   * @since 1.0.0
+   */
+  (constant: number): (p: LinearPolynomial) => QuadraticPolynomial;
+};
+declare const domain$2: {
+  /**
+   * Calculates the domain of a linear polynomial.
+   *
+   * @param p - The linear polynomial to check.
+   * @param range - The range to check against.
+   * @returns The domain of the polynomial within the given range.
+   * @since 1.0.0
+   */
+  (p: LinearPolynomial, range: Interval): AtMostOne<Interval>;
+  /**
+   * Calculates the domain of a linear polynomial.
+   *
+   * @param range - The range to check against.
+   * @returns A function that takes a `LinearPolynomial` and returns the domain of the polynomial within the given range.
+   * @since 1.0.0
+   */
+  (range: Interval): (p: LinearPolynomial) => AtMostOne<Interval>;
+};
+declare const range$2: {
+  /**
+   * Calculates the range of a linear polynomial.
+   *
+   * @param p - The linear polynomial to check.
+   * @param domain - The domain to check against.
+   * @returns The range of the polynomial within the given domain.
+   * @since 1.0.0
+   */
+  (p: LinearPolynomial, domain: Interval): Closed;
+  /**
+   * Calculates the range of a linear polynomial.
+   *
+   * @param domain - The domain to check against.
+   * @returns A function that takes a `LinearPolynomial` and returns the range of the polynomial within the given domain.
+   * @since 1.0.0
+   */
+  (domain: Interval): (p: LinearPolynomial) => Closed;
+};
+declare const length$2: {
+  /**
+   * Calculates the length of a linear polynomial within a particular domain `Interval`.
+   *
+   * @param p - The linear polynomial to analyze.
+   * @param domain - The domain to restrict the analysis to.
+   * @returns The length of the linear polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (p: LinearPolynomial, domain: Interval): number;
+  /**
+   * Calculates the length of a linear polynomial within a particular domain `Interval`.
+   *
+   * @param domain - The domain to restrict the analysis to.
+   * @returns A function that takes a `LinearPolynomial` and returns the length of the polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (domain: Interval): (p: LinearPolynomial) => number;
+};
+//#endregion
+//#region src/polynomial/quadratic.internal.circular.d.ts
+declare const QuadraticPolynomialTypeId: unique symbol;
+type QuadraticPolynomialTypeId = typeof QuadraticPolynomialTypeId;
+declare namespace quadratic_d_exports {
+  export { Decreasing, Increasing, Monotonic, QuadraticPolynomial, antiderivative, asDecreasing$1 as asDecreasing, asIncreasing$1 as asIncreasing, asMonotonic$1 as asMonotonic, curvature$1 as curvature, derivative$1 as derivative, domain$1 as domain, equals$1 as equals, extreme, fromPoints$1 as fromPoints, fromVector$1 as fromVector, isDecreasing$1 as isDecreasing, isIncreasing$1 as isIncreasing, isMonotonic$1 as isMonotonic, isQuadraticPolynomial, length$1 as length, make$1 as make, monotonicity$1 as monotonicity, range$1 as range, roots$1 as roots, solve$1 as solve, solveInverse$1 as solveInverse, toInverseSolver$1 as toInverseSolver, toSolver$1 as toSolver };
+}
+/**
+ * A quadratic polynomial.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Traits` type parameter is a phantom marker that accumulates trait
+ * brands as the polynomial is refined via `isMonotonic` / `asMonotonic` and
+ * friends. Refinements may be parameterized by an `Interval` — a quadratic is
+ * monotonic on an interval that avoids its extremum, even though it is not
+ * monotonic globally.
+ *
+ * @since 1.0.0
+ */
+interface QuadraticPolynomial<out Traits = unknown> extends Pipeable {
+  readonly [QuadraticPolynomialTypeId]: QuadraticPolynomialTypeId;
+  readonly [PolynomialTraits]: Traits;
+  /**
+   * The coefficient of the x^0 term.
+   */
+  readonly c0: number;
+  /**
+   * The coefficient of the x^1 term.
+   */
+  readonly c1: number;
+  /**
+   * The coefficient of the x^2 term.
+   */
+  readonly c2: number;
+}
+/**
+ * Checks if a value is a `QuadraticPolynomial`.
+ *
+ * @param v - The value to check.
+ * @returns `true` if the value is a `QuadraticPolynomial`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isQuadraticPolynomial: (v: unknown) => v is QuadraticPolynomial;
+declare const equals$1: {
+  /**
+   * Checks if two `QuadraticPolynomial` instances are approximately equal
+   * within the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param a - The first polynomial.
+   * @param b - The second polynomial.
+   * @returns `true` when each pair of coefficients is within tolerance.
+   * @since 1.1.0
+   */
+  (a: QuadraticPolynomial, b: QuadraticPolynomial): boolean;
+  /**
+   * Checks if two `QuadraticPolynomial` instances are approximately equal
+   * within the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param b - The second polynomial.
+   * @returns A function that takes the first polynomial and returns the comparison result.
+   * @since 1.1.0
+   */
+  (b: QuadraticPolynomial): (a: QuadraticPolynomial) => boolean;
+};
+/**
+ * Creates a new `QuadraticPolynomial` instance.
+ *
+ * @param c0 - The coefficient of the x^0 term. Defaults to 0.
+ * @param c1 - The coefficient of the x^1 term. Defaults to 0.
+ * @param c2 - The coefficient of the x^2 term. Defaults to 1.
+ * @returns A new `QuadraticPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const make$1: (c0?: number, c1?: number, c2?: number) => QuadraticPolynomial;
+/**
+ * Creates a new `QuadraticPolynomial` instance from a vector.
+ *
+ * @param v - The vector to create the polynomial from.
+ * @returns A new `QuadraticPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const fromVector$1: (v: Vector3) => QuadraticPolynomial;
+/**
+ * Creates a new `QuadraticPolynomial` that interpolates the three given
+ * points, treating each `Vector2` as an `(x, y)` pair. The three input `x`
+ * values must be distinct.
+ *
+ * @param p0 - The first point.
+ * @param p1 - The second point.
+ * @param p2 - The third point.
+ * @returns The unique quadratic polynomial passing through the three points.
+ * @since 2.0.0
+ */
+declare const fromPoints$1: (p0: Vector2, p1: Vector2, p2: Vector2) => QuadraticPolynomial;
+declare const solve$1: {
+  /**
+   * Solves the quadratic polynomial for a given x value.
+   *
+   * @param p - The quadratic polynomial.
+   * @param x - The x value to solve for.
+   * @returns The result of the polynomial at the given x value.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, x: number): number;
+  /**
+   * Solves the quadratic polynomial for a given x value.
+   *
+   * @param x - The x value to solve for.
+   * @returns A function that takes a quadratic polynomial and returns the result of the polynomial at the given x value.
+   * @since 1.0.0
+   */
+  (x: number): (p: QuadraticPolynomial) => number;
+};
+/**
+ * Creates a solver function for the quadratic polynomial.
+ *
+ * @param p - The quadratic polynomial.
+ * @returns A function that takes an x value and returns the result of the polynomial at that x value.
+ */
+declare const toSolver$1: (p: QuadraticPolynomial) => (x: number) => number;
+declare const solveInverse$1: {
+  /**
+   * Solves a monotonic quadratic polynomial for a given y value. Because the
+   * polynomial is strictly monotonic (either globally, or over the interval
+   * the `Monotonic` brand was attached for), the inverse has at most one
+   * solution.
+   *
+   * @param p - The monotonic quadratic polynomial.
+   * @param y - The y value to solve for.
+   * @returns Zero or one solutions.
+   * @since 2.0.0
+   */
+  <T extends Monotonic>(p: QuadraticPolynomial<T>, y: number): AtMostOne<number>;
+  /**
+   * Solves the quadratic polynomial for a given y value.
+   *
+   * @param p - The quadratic polynomial.
+   * @param y - The y value to solve for.
+   * @returns The solutions to the polynomial at the given y value.
+   * @since 1.0.0
+   */
+  <T>(p: QuadraticPolynomial<T>, y: number): AtMostTwo<number>;
+  /**
+   * Solves the quadratic polynomial for a given y value.
+   *
+   * @param y - The y value to solve for.
+   * @returns A function that takes a quadratic polynomial and returns the
+   *   solutions. Tightens to `Solution.AtMostOne<number>` for monotonic inputs.
+   * @since 1.0.0
+   */
+  (y: number): {
+    <T extends Monotonic>(p: QuadraticPolynomial<T>): AtMostOne<number>;
+    <T>(p: QuadraticPolynomial<T>): AtMostTwo<number>;
+  };
+};
+/**
+ * Creates an inverse solver function for the quadratic polynomial.
+ *
+ * @param p - The quadratic polynomial.
+ * @returns A function that takes a y value and returns the solutions to the polynomial at that y value.
+ */
+declare const toInverseSolver$1: (p: QuadraticPolynomial) => (y: number) => AtMostTwo<number>;
+/**
+ * Computes the derivative of the quadratic polynomial.
+ *
+ * @param p - The quadratic polynomial.
+ * @returns The derivative of the polynomial as a linear polynomial.
+ * @since 1.0.0
+ */
+declare const derivative$1: (p: QuadraticPolynomial) => LinearPolynomial;
+/**
+ * Finds the roots of the quadratic polynomial.
+ *
+ * @param p - The quadratic polynomial.
+ * @returns The roots of the polynomial as a tuple of solutions.
+ * @since 1.0.0
+ */
+declare const roots$1: (p: QuadraticPolynomial) => AtMostTwo<number>;
+/**
+ * Finds the extreme point of the quadratic polynomial.
+ *
+ * @param p - The quadratic polynomial.
+ * @returns The extreme point of the polynomial as a solution.
+ * @since 1.0.0
+ */
+declare const extreme: (p: QuadraticPolynomial) => Vector2 | null;
+declare const monotonicity$1: {
+  /**
+   * Computes the monotonicity of the quadratic polynomial over a given
+   * interval. Throws when the interval has zero width — the question is
+   * undefined at a single point.
+   *
+   * @param p - The quadratic polynomial.
+   * @param i - The interval to compute the monotonicity over.
+   * @returns The monotonicity of the polynomial over the interval.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, i?: Interval): Monotonicity;
+  /**
+   * Computes the monotonicity of the quadratic polynomial over a given
+   * interval. Throws when the interval has zero width.
+   *
+   * @param i - The interval to compute the monotonicity over.
+   * @returns A function that takes a quadratic polynomial and returns the
+   *   monotonicity of the polynomial over the interval.
+   * @since 1.0.0
+   */
+  (i: Interval): (p: QuadraticPolynomial) => Monotonicity;
+};
+/**
+ * Type-narrowing predicate: refines a `QuadraticPolynomial<T>` to
+ * `QuadraticPolynomial<T & Monotonic>` when the polynomial is strictly
+ * monotonic over the given interval (or globally, when no interval is given).
+ *
+ * @param p - The quadratic polynomial to check.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+ * @since 2.0.0
+ */
+declare const isMonotonic$1: {
+  <T>(p: QuadraticPolynomial<T>, i?: Interval): p is QuadraticPolynomial<T & Monotonic>;
+  (i: Interval): <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Monotonic>;
+};
+/**
+ * Type-narrowing predicate: refines to `QuadraticPolynomial<T & Increasing>`.
+ *
+ * @since 2.0.0
+ */
+declare const isIncreasing$1: {
+  <T>(p: QuadraticPolynomial<T>, i?: Interval): p is QuadraticPolynomial<T & Increasing>;
+  (i: Interval): <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Increasing>;
+};
+/**
+ * Type-narrowing predicate: refines to `QuadraticPolynomial<T & Decreasing>`.
+ *
+ * @since 2.0.0
+ */
+declare const isDecreasing$1: {
+  <T>(p: QuadraticPolynomial<T>, i?: Interval): p is QuadraticPolynomial<T & Decreasing>;
+  (i: Interval): <T>(p: QuadraticPolynomial<T>) => p is QuadraticPolynomial<T & Decreasing>;
+};
+/**
+ * Asserts that the quadratic polynomial is monotonic, throwing on failure.
+ *
+ * @param p - The quadratic polynomial to assert against.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns The same polynomial, typed with the `Monotonic` brand.
+ * @throws When the polynomial is not monotonic over the given (or global) interval.
+ * @since 2.0.0
+ */
+declare const asMonotonic$1: <T>(p: QuadraticPolynomial<T>, i?: Interval) => QuadraticPolynomial<T & Monotonic>;
+/**
+ * Asserts that the quadratic polynomial is increasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asIncreasing$1: <T>(p: QuadraticPolynomial<T>, i?: Interval) => QuadraticPolynomial<T & Increasing>;
+/**
+ * Asserts that the quadratic polynomial is decreasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asDecreasing$1: <T>(p: QuadraticPolynomial<T>, i?: Interval) => QuadraticPolynomial<T & Decreasing>;
+declare const antiderivative: {
+  /**
+   * Computes the antiderivative of the quadratic polynomial.
+   *
+   * @param p - The quadratic polynomial.
+   * @param constant - The constant of integration. Defaults to 0.
+   * @returns The antiderivative of the polynomial as a cubic polynomial.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, constant?: number): CubicPolynomial;
+  /**
+   * Computes the antiderivative of the quadratic polynomial.
+   *
+   * @param constant - The constant of integration. Defaults to 0.
+   * @returns A function that takes a quadratic polynomial and returns the antiderivative of the polynomial as a cubic polynomial.
+   * @since 1.0.0
+   */
+  (constant: number): (p: QuadraticPolynomial) => CubicPolynomial;
+};
+declare const domain$1: {
+  /**
+   * Computes the domain of the quadratic polynomial over a given range.
+   *
+   * @param p - The quadratic polynomial.
+   * @param range - The range to compute the domain over.
+   * @returns The domain of the polynomial over the range.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, range: Interval): AtMostOne<Interval>;
+  /**
+   * Computes the domain of the quadratic polynomial over a given range.
+   *
+   * @param range - The range to compute the domain over.
+   * @returns A function that takes a quadratic polynomial and returns the domain of the polynomial over the range.
+   * @since 1.0.0
+   */
+  (range: Interval): (p: QuadraticPolynomial) => AtMostOne<Interval>;
+};
+declare const range$1: {
+  /**
+   * Computes the range of the quadratic polynomial over a given domain.
+   *
+   * @param p - The quadratic polynomial.
+   * @param domain - The domain to compute the range over.
+   * @returns The range of the polynomial over the domain.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, domain: Interval): Closed;
+  /**
+   * Computes the range of the quadratic polynomial over a given domain.
+   *
+   * @param domain - The domain to compute the range over.
+   * @returns A function that takes a quadratic polynomial and returns the range of the polynomial over the domain.
+   * @since 1.0.0
+   */
+  (domain: Interval): (p: QuadraticPolynomial) => Closed;
+};
+declare const length$1: {
+  /**
+   * Computes the length of the quadratic polynomial over a given interval.
+   *
+   * @param p - The quadratic polynomial.
+   * @param i - The interval to compute the length over.
+   * @returns The length of the polynomial over the interval.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, i: Interval): number;
+  /**
+   * Computes the length of the quadratic polynomial over a given interval.
+   *
+   * @param i - The interval to compute the length over.
+   * @returns A function that takes a quadratic polynomial and returns the length of the polynomial over the interval.
+   * @since 1.0.0
+   */
+  (i: Interval): (p: QuadraticPolynomial) => number;
+};
+declare const curvature$1: {
+  /**
+   * Computes the curvature of the quadratic polynomial at a given x value.
+   *
+   * @param p - The quadratic polynomial.
+   * @param x - The x value to compute the curvature at.
+   * @returns The curvature of the polynomial at the given x value.
+   * @since 1.0.0
+   */
+  (p: QuadraticPolynomial, x: number): number;
+  /**
+   * Computes the curvature of the quadratic polynomial at a given x value.
+   *
+   * @param x - The x value to compute the curvature at.
+   * @returns A function that takes a quadratic polynomial and returns the curvature of the polynomial at the given x value.
+   * @since 1.0.0
+   */
+  (x: number): (p: QuadraticPolynomial) => number;
+};
+declare namespace cubic_d_exports {
+  export { CubicPolynomial, Decreasing, Increasing, Monotonic, asDecreasing, asIncreasing, asMonotonic, curvature, derivative, domain, equals, extrema, fromPoints, fromVector, isCubicPolynomial, isDecreasing, isIncreasing, isMonotonic, length, make, monotonicity, range, roots, solve, solveInverse, subdivide, toInverseSolver, toSolver };
+}
+/**
+ * A cubic polynomial.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The `Traits` type parameter is a phantom marker that accumulates trait
+ * brands as the polynomial is refined via `isMonotonic` / `asMonotonic` and
+ * friends. A cubic is monotonic only over an interval that avoids both of its
+ * extrema (or globally, when c2 = c3 = 0 and c1 ≠ 0).
+ *
+ * @since 1.0.0
+ */
+interface CubicPolynomial<out Traits = unknown> extends Pipeable {
+  readonly [CubicPolynomialTypeId]: CubicPolynomialTypeId;
+  readonly [PolynomialTraits]: Traits;
+  /**
+   * The coefficient of the x^0 term.
+   */
+  readonly c0: number;
+  /**
+   * The coefficient of the x^1 term.
+   */
+  readonly c1: number;
+  /**
+   * The coefficient of the x^2 term.
+   */
+  readonly c2: number;
+  /**
+   * The coefficient of the x^3 term.
+   */
+  readonly c3: number;
+}
+/**
+ * Checks if a value is a `CubicPolynomial`.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a `CubicPolynomial`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isCubicPolynomial: (value: unknown) => value is CubicPolynomial;
+declare const equals: {
+  /**
+   * Checks if two `CubicPolynomial` instances are approximately equal within
+   * the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param a - The first polynomial.
+   * @param b - The second polynomial.
+   * @returns `true` when each pair of coefficients is within tolerance.
+   * @since 1.1.0
+   */
+  (a: CubicPolynomial, b: CubicPolynomial): boolean;
+  /**
+   * Checks if two `CubicPolynomial` instances are approximately equal within
+   * the default absolute tolerance ({@link EPSILON}).
+   *
+   * @param b - The second polynomial.
+   * @returns A function that takes the first polynomial and returns the comparison result.
+   * @since 1.1.0
+   */
+  (b: CubicPolynomial): (a: CubicPolynomial) => boolean;
+};
+/**
+ * Creates a new `CubicPolynomial` instance.
+ *
+ * @param c0 - The coefficient of the x^0 term.
+ * @param c1 - The coefficient of the x^1 term.
+ * @param c2 - The coefficient of the x^2 term.
+ * @param c3 - The coefficient of the x^3 term.
+ */
+declare const make: (c0: number, c1: number, c2: number, c3: number) => CubicPolynomial;
+/**
+ * Creates a new `CubicPolynomial` instance from a vector.
+ *
+ * @param v - The vector to convert.
+ * @returns A new `CubicPolynomial` instance.
+ * @since 1.0.0
+ */
+declare const fromVector: (v: Vector4) => CubicPolynomial;
+/**
+ * Creates a new `CubicPolynomial` that interpolates the four given points,
+ * treating each `Vector2` as an `(x, y)` pair. The four input `x` values must
+ * be distinct.
+ *
+ * @param p0 - The first point.
+ * @param p1 - The second point.
+ * @param p2 - The third point.
+ * @param p3 - The fourth point.
+ * @returns The unique cubic polynomial passing through the four points.
+ * @since 2.0.0
+ */
+declare const fromPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicPolynomial;
+declare const solve: {
+  /**
+   * Solves a cubic polynomial for a given value of x.
+   *
+   * @param p - The cubic polynomial to solve.
+   * @param x - The value of x to solve for.
+   * @returns The result of the polynomial evaluation at x.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, x: number): number;
+  /**
+   * Solves a cubic polynomial for a given value of x.
+   *
+   * @param x - The value of x to solve for.
+   * @returns A function that takes a cubic polynomial and returns the result of the polynomial evaluation at x.
+   * @since 1.0.0
+   */
+  (x: number): (p: CubicPolynomial) => number;
+};
+/**
+ * Converts a cubic polynomial to a solver function.
+ *
+ * @param p - The cubic polynomial to convert.
+ * @returns A function that takes a value of x and returns the result of the polynomial evaluation at x.
+ * @since 1.0.0
+ */
+declare const toSolver: (p: CubicPolynomial) => (x: number) => number;
+declare const solveInverse: {
+  /**
+   * Solves a monotonic cubic polynomial for a given value of y. Because the
+   * polynomial is strictly monotonic, the inverse has at most one solution.
+   *
+   * @param p - The monotonic cubic polynomial.
+   * @param y - The value of y to solve for.
+   * @returns Zero or one solutions.
+   * @since 2.0.0
+   */
+  <T extends Monotonic>(p: CubicPolynomial<T>, y: number): AtMostOne<number>;
+  /**
+   * Solves a cubic polynomial for a given value of y.
+   *
+   * @param p - The cubic polynomial to solve.
+   * @param y - The value of y to solve for.
+   * @returns The roots of the polynomial equation p(x) = y.
+   * @since 1.0.0
+   */
+  <T>(p: CubicPolynomial<T>, y: number): AtMostThree<number>;
+  /**
+   * Solves a cubic polynomial for a given value of y.
+   *
+   * @param y - The value of y to solve for.
+   * @returns A function that takes a cubic polynomial and returns the roots
+   *   of the polynomial equation p(x) = y. Tightens to `Solution.AtMostOne<number>` for
+   *   monotonic inputs.
+   * @since 1.0.0
+   */
+  (y: number): {
+    <T extends Monotonic>(p: CubicPolynomial<T>): AtMostOne<number>;
+    <T>(p: CubicPolynomial<T>): AtMostThree<number>;
+  };
+};
+/**
+ * Converts a cubic polynomial to an inverse solver function.
+ *
+ * @param p - The cubic polynomial to convert.
+ * @returns A function that takes a value of y and returns the roots of the polynomial equation p(x) = y.
+ * @since 1.0.0
+ */
+declare const toInverseSolver: (p: CubicPolynomial) => (y: number) => AtMostThree<number>;
+/**
+ * Calculates the derivative of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to differentiate.
+ * @returns The derivative of the cubic polynomial.
+ * @since 1.0.0
+ */
+declare const derivative: (p: CubicPolynomial) => QuadraticPolynomial;
+declare const subdivide: {
+  /**
+   * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)` into two new
+   * cubic polynomials. The first polynomial's evaluation on `[0, 1]` matches
+   * the original's on `[0, t]`; the second matches the original's on
+   * `[t, 1]`. Equivalent to de Casteljau subdivision in Bernstein form,
+   * performed directly in monomial form.
+   *
+   * @param p - The cubic polynomial to subdivide.
+   * @param t - The split parameter; must be in the open interval `(0, 1)`.
+   * @returns A `[left, right]` tuple of cubic polynomials.
+   * @since 2.1.0
+   */
+  (p: CubicPolynomial, t: number): [CubicPolynomial, CubicPolynomial];
+  /**
+   * Subdivides a cubic polynomial at parameter `t ∈ (0, 1)`.
+   *
+   * @param t - The split parameter; must be in the open interval `(0, 1)`.
+   * @returns A function that takes a polynomial and returns its `[left, right]` halves.
+   * @since 2.1.0
+   */
+  (t: number): (p: CubicPolynomial) => [CubicPolynomial, CubicPolynomial];
+};
+/**
+ * Calculates the roots of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to find the roots of.
+ * @returns The roots of the cubic polynomial.
+ * @since 1.0.0
+ */
+declare const roots: (p: CubicPolynomial) => AtMostThree<number>;
+/**
+ * Calculates the extrema of a cubic polynomial.
+ *
+ * @param p - The cubic polynomial to find the extrema of.
+ * @returns The extrema of the cubic polynomial.
+ * @since 1.0.0
+ */
+declare const extrema: (p: CubicPolynomial) => AtMostTwo<number>;
+declare const monotonicity: {
+  /**
+   * Calculates the monotonicity of a cubic polynomial. Throws when the
+   * interval has zero width — the question is undefined at a single point.
+   *
+   * @param p - The cubic polynomial to analyze.
+   * @param i - The interval to restrict the analysis to.
+   * @returns The monotonicity of the cubic polynomial in the specified interval.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, i?: Interval): Monotonicity;
+  /**
+   * Calculates the monotonicity of a cubic polynomial. Throws when the
+   * interval has zero width.
+   *
+   * @param i - The interval to restrict the analysis to.
+   * @returns A function that takes a cubic polynomial and returns the
+   *   monotonicity of the cubic polynomial in the specified interval.
+   * @since 1.0.0
+   */
+  (i: Interval): (p: CubicPolynomial) => Monotonicity;
+};
+/**
+ * Type-narrowing predicate: refines a `CubicPolynomial<T>` to
+ * `CubicPolynomial<T & Monotonic>` when the polynomial is strictly monotonic
+ * over the given interval (or globally, when no interval is given).
+ *
+ * @param p - The cubic polynomial to check.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+ * @since 2.0.0
+ */
+declare const isMonotonic: {
+  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Monotonic>;
+  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Monotonic>;
+};
+/**
+ * Type-narrowing predicate: refines to `CubicPolynomial<T & Increasing>`.
+ *
+ * @since 2.0.0
+ */
+declare const isIncreasing: {
+  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Increasing>;
+  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Increasing>;
+};
+/**
+ * Type-narrowing predicate: refines to `CubicPolynomial<T & Decreasing>`.
+ *
+ * @since 2.0.0
+ */
+declare const isDecreasing: {
+  <T>(p: CubicPolynomial<T>, i?: Interval): p is CubicPolynomial<T & Decreasing>;
+  (i: Interval): <T>(p: CubicPolynomial<T>) => p is CubicPolynomial<T & Decreasing>;
+};
+/**
+ * Asserts that the cubic polynomial is monotonic, throwing on failure.
+ *
+ * @param p - The cubic polynomial to assert against.
+ * @param i - Optional interval over which to check monotonicity.
+ * @returns The same polynomial, typed with the `Monotonic` brand.
+ * @throws When the polynomial is not monotonic over the given (or global) interval.
+ * @since 2.0.0
+ */
+declare const asMonotonic: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Monotonic>;
+/**
+ * Asserts that the cubic polynomial is increasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asIncreasing: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Increasing>;
+/**
+ * Asserts that the cubic polynomial is decreasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asDecreasing: <T>(p: CubicPolynomial<T>, i?: Interval) => CubicPolynomial<T & Decreasing>;
+declare const domain: {
+  /**
+   * Calculates the domain of a cubic polynomial.
+   *
+   * @param p - The cubic polynomial to analyze.
+   * @param range - The range to restrict the analysis to.
+   * @returns The domain of the cubic polynomial in the specified range.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, range: Interval): Interval;
+  /**
+   * Calculates the domain of a cubic polynomial.
+   *
+   * @param range - The range to restrict the analysis to.
+   * @returns A function that takes a cubic polynomial and returns the domain of the cubic polynomial in the specified range.
+   * @since 1.0.0
+   */
+  (range: Interval): (p: CubicPolynomial) => Interval;
+};
+declare const range: {
+  /**
+   * Calculates the range of a cubic polynomial.
+   *
+   * @param p - The cubic polynomial to analyze.
+   * @param domain - The domain to restrict the analysis to.
+   * @returns The range of the cubic polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, domain: Interval): Closed;
+  /**
+   * Calculates the range of a cubic polynomial.
+   *
+   * @param domain - The domain to restrict the analysis to.
+   * @returns A function that takes a cubic polynomial and returns the range of the cubic polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (domain: Interval): (p: CubicPolynomial) => Closed;
+};
+declare const length: {
+  /**
+   * Calculates the length of a cubic polynomial.
+   *
+   * @param p - The cubic polynomial to analyze.
+   * @param domain - The domain to restrict the analysis to.
+   * @returns The length of the cubic polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, domain: Interval): number;
+  /**
+   * Calculates the length of a cubic polynomial.
+   *
+   * @param domain - The domain to restrict the analysis to.
+   * @returns A function that takes a cubic polynomial and returns the length of the cubic polynomial in the specified domain.
+   * @since 1.0.0
+   */
+  (domain: Interval): (p: CubicPolynomial) => number;
+};
+declare const curvature: {
+  /**
+   * Calculates the curvature of a cubic polynomial.
+   *
+   * @param p - The cubic polynomial to analyze.
+   * @param x - The value of x to calculate the curvature at.
+   * @returns The curvature of the cubic polynomial at the specified value of x.
+   * @since 1.0.0
+   */
+  (p: CubicPolynomial, x: number): number;
+  /**
+   * Calculates the curvature of a cubic polynomial.
+   *
+   * @param x - The value of x to calculate the curvature at.
+   * @returns A function that takes a cubic polynomial and returns the curvature of the cubic polynomial at the specified value of x.
+   * @since 1.0.0
+   */
+  (x: number): (p: CubicPolynomial) => number;
+};
+//#endregion
+export { LinearPolynomial as a, Increasing as c, quadratic_d_exports as i, Monotonic as l, cubic_d_exports as n, linear_d_exports as o, QuadraticPolynomial as r, Decreasing as s, CubicPolynomial as t };
+//# sourceMappingURL=cubic-BajUY0JT.d.mts.map