curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/rationalCubic2d-DlQfBURs.d.mts

@@ -0,0 +1,818 @@
+import { n as Weighted, t as Vector2, u as TwoDimensional } from "./vector2-DPUY3_eA.mjs";
+import { t as Pipeable } from "./utils-MCckigYk.mjs";
+import { n as Closed, r as Interval } from "./interval-Dy-RMEE3.mjs";
+import { n as AtMostThree, r as AtMostTwo, t as AtMostOne } from "./solution-sNQ-ZVhN.mjs";
+import { a as LinearPolynomial, c as Increasing, l as Monotonic, r as QuadraticPolynomial, s as Decreasing, t as CubicPolynomial } from "./cubic-BajUY0JT.mjs";
+import { t as Interval2d } from "./interval2d-C2id9u31.mjs";
+
+//#region src/curve/linear2d.internal.d.ts
+declare const LinearCurve2dTypeId: unique symbol;
+type LinearCurve2dTypeId = typeof LinearCurve2dTypeId;
+declare namespace linear2d_d_exports {
+  export { Decreasing, Increasing, LinearCurve2d, Monotonic, asDecreasing$2 as asDecreasing, asIncreasing$2 as asIncreasing, asMonotonic$2 as asMonotonic, boundingBox$2 as boundingBox, derivative$1 as derivative, fromBezierPoints$3 as fromBezierPoints, fromCoefficients$2 as fromCoefficients, fromPolynomials$3 as fromPolynomials, isDecreasing$2 as isDecreasing, isIncreasing$2 as isIncreasing, isLinearCurve2d, isMonotonic$2 as isMonotonic, length$2 as length, solve$3 as solve, solveAtX$3 as solveAtX, solveAtY$3 as solveAtY };
+}
+/**
+ * A linear curve in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The two type parameters carry the trait sets of the curve's per-axis
+ * polynomials. Refiners like `isMonotonic` lift each axis's monotonicity into
+ * the curve's combined trait set.
+ *
+ * @since 1.0.0
+ */
+interface LinearCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<LinearPolynomial<XTraits>, LinearPolynomial<YTraits>> {
+  readonly [LinearCurve2dTypeId]: LinearCurve2dTypeId;
+}
+/**
+ * Creates a new `LinearCurve2d` instance from polynomial parameters.
+ *
+ * @param x - The x polynomial.
+ * @param y - The y polynomial.
+ * @returns A new `LinearCurve2d` instance.
+ * @since 1.0.0
+ */
+declare const fromPolynomials$3: (x: LinearPolynomial, y: LinearPolynomial) => LinearCurve2d;
+/**
+ * Creates a new `LinearCurve2d` instance from monomial coefficient vectors.
+ *
+ * Each argument bundles the per-axis coefficient at the given power: `c0`
+ * holds the x⁰ term, `c1` holds the x¹ term. The resulting curve evaluates to
+ * `c0 + c1·t` per axis.
+ *
+ * @param c0 - The x⁰ coefficients (x and y).
+ * @param c1 - The x¹ coefficients (x and y).
+ * @returns A new `LinearCurve2d` instance.
+ * @since 2.0.0
+ */
+declare const fromCoefficients$2: (c0: Vector2, c1: Vector2) => LinearCurve2d;
+/**
+ * Creates a new `LinearCurve2d` instance from a pair of endpoints.
+ *
+ * `p0` is the curve at `t = 0`, `p1` is the curve at `t = 1`. The
+ * implementation converts to the curve's internal monomial form (slope-form
+ * polynomial in `t`) in closed form.
+ *
+ * @param p0 - The curve's start point.
+ * @param p1 - The curve's end point.
+ * @returns A new `LinearCurve2d` instance whose curve matches the line from `p0` to `p1`.
+ * @since 2.0.0
+ */
+declare const fromBezierPoints$3: (p0: Vector2, p1: Vector2) => LinearCurve2d;
+/**
+ * Checks if a value is a `LinearCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `LinearCurve2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isLinearCurve2d: (c: unknown) => c is LinearCurve2d;
+/**
+ * Gets the derivative of a linear curve as a vector
+ *
+ * @param c - The linear curve to get the derivative of.
+ * @returns The derivative of the linear curve as a vector.
+ * @since 1.0.0
+ */
+declare const derivative$1: (c: LinearCurve2d) => Vector2;
+declare const solve$3: {
+  /**
+   * Solves the linear curve for a given parameter t.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a linear curve and returns the point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (t: number): (c: LinearCurve2d) => Vector2;
+  /**
+   * Solves the linear curve for a given parameter t.
+   *
+   * @param c - The linear curve to solve.
+   * @param t - The parameter value.
+   * @returns The point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (c: LinearCurve2d, t: number): Vector2;
+};
+declare const length$2: {
+  /**
+   * Calculates (approximates) the length of a linear curve.
+   *
+   * @param c - The linear curve to calculate the length of.
+   * @param i - The interval to calculate the length over.
+   * @returns The length of the linear curve over the given interval.
+   * @since 1.0.0
+   */
+  (c: LinearCurve2d, i: Interval): number;
+  /**
+   * Calculates (approximates) the length of a linear curve.
+   *
+   * @param i - The interval to calculate the length over.
+   * @returns A function that takes a linear curve and returns the length of the linear curve over the given interval.
+   * @since 1.0.0
+   */
+  (i: Interval): (c: LinearCurve2d) => number;
+};
+/**
+ * Computes the axis-aligned bounding box of the curve over its parameter
+ * domain `[0, 1]`. For a linear curve this is the closed box enclosing the
+ * two endpoints.
+ *
+ * @param c - The linear curve.
+ * @returns A closed `Box2d` enclosing the curve.
+ * @since 2.1.0
+ */
+declare const boundingBox$2: (c: LinearCurve2d) => Interval2d<Closed, Closed>;
+declare const solveAtX$3: {
+  /**
+   * Evaluates the curve's y value at a given x. A linear curve crosses any
+   * vertical line at most once (within the curve's parameter domain `[0, 1]`),
+   * so the result is at most one y. Returns the empty tuple when x is outside
+   * the curve's range or when the curve's x polynomial is constant.
+   *
+   * @param c - The linear curve.
+   * @param x - The x coordinate.
+   * @returns The y value at x, or empty when x is undefined for this curve.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: LinearCurve2d<XT, YT>, x: number): AtMostOne<number>; /** @since 2.0.0 */
+  (x: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => AtMostOne<number>;
+};
+declare const solveAtY$3: {
+  /**
+   * Evaluates the curve's x value at a given y. A linear curve crosses any
+   * horizontal line at most once (within the curve's parameter domain
+   * `[0, 1]`), so the result is at most one x.
+   *
+   * @param c - The linear curve.
+   * @param y - The y coordinate.
+   * @returns The x value at y, or empty when y is undefined for this curve.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: LinearCurve2d<XT, YT>, y: number): AtMostOne<number>; /** @since 2.0.0 */
+  (y: number): <XT, YT>(c: LinearCurve2d<XT, YT>) => AtMostOne<number>;
+};
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both the x and y polynomials are strictly monotonic. When both axes
+ * are monotonic, the curve is invertible in either direction.
+ *
+ * For checking only one axis, call the polynomial-level refiner directly:
+ * `LinearPolynomial.isMonotonic(curve.x)`.
+ *
+ * @since 2.0.0
+ */
+declare const isMonotonic$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Increasing`.
+ *
+ * @since 2.0.0
+ */
+declare const isIncreasing$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+declare const isDecreasing$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => c is LinearCurve2d<XT & Decreasing, YT & Decreasing>;
+/**
+ * Asserts monotonicity in both axes, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asMonotonic$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Asserts that both axes are strictly increasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asIncreasing$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Asserts that both axes are strictly decreasing, throwing on failure.
+ *
+ * @since 2.0.0
+ */
+declare const asDecreasing$2: <XT, YT>(c: LinearCurve2d<XT, YT>) => LinearCurve2d<XT & Decreasing, YT & Decreasing>;
+//#endregion
+//#region src/curve/quadratic2d.internal.d.ts
+declare const QuadraticCurve2dTypeId: unique symbol;
+type QuadraticCurve2dTypeId = typeof QuadraticCurve2dTypeId;
+declare namespace quadratic2d_d_exports {
+  export { Decreasing, Increasing, Monotonic, QuadraticCurve2d, asDecreasing$1 as asDecreasing, asIncreasing$1 as asIncreasing, asMonotonic$1 as asMonotonic, boundingBox$1 as boundingBox, curvature$1 as curvature, derivative, fromBezierPoints$2 as fromBezierPoints, fromCoefficients$1 as fromCoefficients, fromPolynomials$2 as fromPolynomials, isDecreasing$1 as isDecreasing, isIncreasing$1 as isIncreasing, isMonotonic$1 as isMonotonic, isQuadraticCurve2d, length$1 as length, solve$2 as solve, solveAtX$2 as solveAtX, solveAtY$2 as solveAtY };
+}
+/**
+ * A quadratic curve in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The two type parameters carry the trait sets of the curve's per-axis
+ * polynomials. Refiners check monotonicity over the unit interval `[0, 1]` —
+ * the curve's natural parameter domain.
+ *
+ * @since 1.0.0
+ */
+interface QuadraticCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<QuadraticPolynomial<XTraits>, QuadraticPolynomial<YTraits>> {
+  readonly [QuadraticCurve2dTypeId]: QuadraticCurve2dTypeId;
+}
+/**
+ * Creates a new `QuadraticCurve2d` instance from polynomial parameters.
+ *
+ * @param c0 - The x polynomial.
+ * @param c1 - The y polynomial.
+ * @returns A new `QuadraticCurve2d` instance.
+ * @since 1.0.0
+ */
+declare const fromPolynomials$2: (c0: QuadraticPolynomial, c1: QuadraticPolynomial) => QuadraticCurve2d;
+/**
+ * Creates a new `QuadraticCurve2d` instance from monomial coefficient vectors.
+ *
+ * Each argument bundles the per-axis coefficient at the given power: `c0`
+ * holds the x⁰ term, `c1` holds the x¹ term, and so on. The resulting curve
+ * evaluates to `c0 + c1·t + c2·t²` per axis.
+ *
+ * @param c0 - The x⁰ coefficients (x and y).
+ * @param c1 - The x¹ coefficients (x and y).
+ * @param c2 - The x² coefficients (x and y).
+ * @returns A new `QuadraticCurve2d` instance.
+ * @since 2.0.0
+ */
+declare const fromCoefficients$1: (c0: Vector2, c1: Vector2, c2: Vector2) => QuadraticCurve2d;
+/**
+ * Creates a new `QuadraticCurve2d` instance from quadratic Bézier control
+ * points.
+ *
+ * The three arguments are the Bernstein-basis control points: `p0` and `p2`
+ * are the curve's endpoints and `p1` is the off-curve control handle. The
+ * implementation converts to the curve's internal monomial form in closed
+ * form.
+ *
+ * @param p0 - The first control point (curve start).
+ * @param p1 - The second control point (control handle).
+ * @param p2 - The third control point (curve end).
+ * @returns A new `QuadraticCurve2d` instance whose curve matches the given Bézier.
+ * @since 2.0.0
+ */
+declare const fromBezierPoints$2: (p0: Vector2, p1: Vector2, p2: Vector2) => QuadraticCurve2d;
+/**
+ * Checks if a value is a `QuadraticCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `QuadraticCurve2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isQuadraticCurve2d: (c: unknown) => c is QuadraticCurve2d;
+declare const solve$2: {
+  /**
+   * Solves the quadratic curve for a given parameter t.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a quadratic curve and returns the point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (t: number): (c: QuadraticCurve2d) => Vector2;
+  /**
+   * Solves the quadratic curve for a given parameter t.
+   *
+   * @param c - The quadratic curve to solve.
+   * @param t - The parameter value.
+   * @returns The point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (c: QuadraticCurve2d, t: number): Vector2;
+};
+declare const length$1: {
+  /**
+   * Computes the length of the quadratic curve over a given interval.
+   *
+   * @param c - The quadratic curve to compute the length of.
+   * @param i - The interval over which to compute the length.
+   * @returns The length of the quadratic curve over the interval.
+   * @since 1.0.0
+   */
+  (c: QuadraticCurve2d, i: Interval): number;
+  /**
+   * Computes the length of the quadratic curve over a given interval.
+   *
+   * @param i - The interval over which to compute the length.
+   * @returns A function that takes a quadratic curve and returns the length of the curve over the interval.
+   * @since 1.0.0
+   */
+  (i: Interval): (c: QuadraticCurve2d) => number;
+};
+declare const solveAtX$2: {
+  /**
+   * Evaluates the curve's y values at a given x. Because the x polynomial is
+   * `Monotonic`, the inverse has at most one solution — at most one y value.
+   *
+   * @param c - The quadratic curve.
+   * @param x - The x coordinate.
+   * @returns Zero or one y values, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT extends Monotonic, YT>(c: QuadraticCurve2d<XT, YT>, x: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's y values at a given x. The result is the y values
+   * the curve passes through where x(t) = the given x — up to two solutions
+   * for a quadratic curve.
+   *
+   * @param c - The quadratic curve.
+   * @param x - The x coordinate.
+   * @returns The y values at x, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: QuadraticCurve2d<XT, YT>, x: number): AtMostTwo<number>; /** @since 2.0.0 */
+  (x: number): {
+    <XT extends Monotonic, YT>(c: QuadraticCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: QuadraticCurve2d<XT, YT>): AtMostTwo<number>;
+  };
+};
+declare const solveAtY$2: {
+  /**
+   * Evaluates the curve's x values at a given y. Because the y polynomial is
+   * `Monotonic`, the inverse has at most one solution.
+   *
+   * @param c - The quadratic curve.
+   * @param y - The y coordinate.
+   * @returns Zero or one x values, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT extends Monotonic>(c: QuadraticCurve2d<XT, YT>, y: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's x values at a given y. The result is the x values
+   * the curve passes through where y(t) = the given y — up to two solutions
+   * for a quadratic curve.
+   *
+   * @param c - The quadratic curve.
+   * @param y - The y coordinate.
+   * @returns The x values at y, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: QuadraticCurve2d<XT, YT>, y: number): AtMostTwo<number>; /** @since 2.0.0 */
+  (y: number): {
+    <XT, YT extends Monotonic>(c: QuadraticCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: QuadraticCurve2d<XT, YT>): AtMostTwo<number>;
+  };
+};
+/**
+ * Computes the derivative of a quadratic curve.
+ *
+ * @param c - The quadratic curve to compute the derivative of.
+ * @returns The derivative of the quadratic curve as a linear curve.
+ * @since 1.0.0
+ */
+declare const derivative: (c: QuadraticCurve2d) => LinearCurve2d;
+declare const curvature$1: {
+  /**
+   * Computes the curvature of the quadratic curve at a given parameter t.
+   *
+   * @param c - The quadratic curve to compute the curvature for.
+   * @param t - The parameter value.
+   * @returns The curvature of the quadratic curve at parameter t.
+   * @since 1.0.0
+   */
+  (c: QuadraticCurve2d, t: number): number;
+  /**
+   * Computes the curvature of the quadratic curve at a given parameter t.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a quadratic curve and returns the curvature of the curve at parameter t.
+   * @since 1.0.0
+   */
+  (t: number): (c: QuadraticCurve2d) => number;
+};
+/**
+ * Computes the axis-aligned bounding box of the curve over its parameter
+ * domain `[0, 1]`. Accounts for interior extrema, so the box is tight against
+ * the curve and not just the control polygon.
+ *
+ * @param c - The quadratic curve.
+ * @returns A closed `Box2d` enclosing the curve.
+ * @since 2.1.0
+ */
+declare const boundingBox$1: (c: QuadraticCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+ *
+ * For checking only one axis, call the polynomial-level refiner directly:
+ * `QuadraticPolynomial.isMonotonic(curve.x, Interval.unit)`.
+ *
+ * @since 2.0.0
+ */
+declare const isMonotonic$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+declare const isIncreasing$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+declare const isDecreasing$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => c is QuadraticCurve2d<XT & Decreasing, YT & Decreasing>;
+/** @since 2.0.0 */
+declare const asMonotonic$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+declare const asIncreasing$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+declare const asDecreasing$1: <XT, YT>(c: QuadraticCurve2d<XT, YT>) => QuadraticCurve2d<XT & Decreasing, YT & Decreasing>;
+//#endregion
+//#region src/curve/cubic2d.internal.d.ts
+declare const CubicCurve2dTypeId: unique symbol;
+type CubicCurve2dTypeId = typeof CubicCurve2dTypeId;
+declare namespace cubic2d_d_exports {
+  export { CubicCurve2d, Decreasing, Increasing, Monotonic, asDecreasing, asIncreasing, asMonotonic, boundingBox, curvature, fromBezierPoints$1 as fromBezierPoints, fromCoefficients, fromPolynomials$1 as fromPolynomials, isCubicCurve2d, isDecreasing, isIncreasing, isMonotonic, length, solve$1 as solve, solveAtX$1 as solveAtX, solveAtY$1 as solveAtY };
+}
+/**
+ * A cubic curve in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * The two type parameters carry the trait sets of the curve's per-axis
+ * polynomials. Refiners check monotonicity over the unit interval `[0, 1]` —
+ * the curve's natural parameter domain.
+ *
+ * @since 1.0.0
+ */
+interface CubicCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable, TwoDimensional<CubicPolynomial<XTraits>, CubicPolynomial<YTraits>> {
+  readonly [CubicCurve2dTypeId]: CubicCurve2dTypeId;
+}
+/**
+ * Creates a new `CubicCurve2d` instance from polynomial parameters.
+ *
+ * @param x - The x polynomial.
+ * @param y - The y polynomial.
+ * @returns A new `CubicCurve2d` instance.
+ * @since 1.0.0
+ */
+declare const fromPolynomials$1: (x: CubicPolynomial, y: CubicPolynomial) => CubicCurve2d;
+/**
+ * Creates a new `CubicCurve2d` instance from monomial coefficient vectors.
+ *
+ * Each argument bundles the per-axis coefficient at the given power: `c0`
+ * holds the x⁰ term, `c1` holds the x¹ term, and so on. The resulting curve
+ * evaluates to `c0 + c1·t + c2·t² + c3·t³` per axis.
+ *
+ * @param c0 - The x⁰ coefficients (x and y).
+ * @param c1 - The x¹ coefficients (x and y).
+ * @param c2 - The x² coefficients (x and y).
+ * @param c3 - The x³ coefficients (x and y).
+ * @returns A new `CubicCurve2d` instance.
+ * @since 2.0.0
+ */
+declare const fromCoefficients: (c0: Vector2, c1: Vector2, c2: Vector2, c3: Vector2) => CubicCurve2d;
+/**
+ * Creates a new `CubicCurve2d` instance from cubic Bézier control points.
+ *
+ * The four arguments are the Bernstein-basis control points: `p0` and `p3` are
+ * the curve's endpoints and `p1` and `p2` are the off-curve control handles.
+ * The implementation converts to the curve's internal monomial form in closed
+ * form.
+ *
+ * @param p0 - The first control point (curve start).
+ * @param p1 - The second control point (start handle).
+ * @param p2 - The third control point (end handle).
+ * @param p3 - The fourth control point (curve end).
+ * @returns A new `CubicCurve2d` instance whose curve matches the given Bézier.
+ * @since 2.0.0
+ */
+declare const fromBezierPoints$1: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => CubicCurve2d;
+/**
+ * Checks if a value is a `CubicCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `CubicCurve2d`, `false` otherwise.
+ * @since 1.0.0
+ */
+declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
+declare const solve$1: {
+  /**
+   * Solves the cubic curve for a given parameter t.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a cubic curve and returns the point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (t: number): (c: CubicCurve2d) => Vector2;
+  /**
+   * Solves the cubic curve for a given parameter t.
+   *
+   * @param c - The cubic curve to solve.
+   * @param t - The parameter value.
+   * @returns The point on the curve at parameter t.
+   * @since 1.0.0
+   */
+  (c: CubicCurve2d, t: number): Vector2;
+};
+declare const length: {
+  /**
+   * Calculates (approximates) the length of a cubic curve.
+   *
+   * @param c - The cubic curve to calculate the length of.
+   * @param i - The interval over which to calculate the length.
+   * @returns The length of the cubic curve.
+   * @since 1.0.0
+   */
+  (c: CubicCurve2d, i: Interval): number;
+  /**
+   * Calculates (approximates) the length of a cubic curve.
+   *
+   * @param i - The interval over which to calculate the length.
+   * @returns A function that takes a cubic curve and returns the length of the cubic curve.
+   * @since 1.0.0
+   */
+  (i: Interval): (c: CubicCurve2d) => number;
+};
+declare const solveAtX$1: {
+  /**
+   * Evaluates the curve's y values at a given x. Because the x polynomial is
+   * `Monotonic`, the inverse has at most one solution — at most one y value.
+   *
+   * @param c - The cubic curve.
+   * @param x - The x coordinate.
+   * @returns Zero or one y values, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>, x: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's y values at a given x. The result is the y values
+   * the curve passes through where x(t) = the given x — up to three solutions
+   * for a cubic curve.
+   *
+   * @param c - The cubic curve.
+   * @param x - The x coordinate.
+   * @returns The y values at x, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: CubicCurve2d<XT, YT>, x: number): AtMostThree<number>; /** @since 2.0.0 */
+  (x: number): {
+    <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: CubicCurve2d<XT, YT>): AtMostThree<number>;
+  };
+};
+declare const solveAtY$1: {
+  /**
+   * Evaluates the curve's x values at a given y. Because the y polynomial is
+   * `Monotonic`, the inverse has at most one solution.
+   *
+   * @param c - The cubic curve.
+   * @param y - The y coordinate.
+   * @returns Zero or one x values, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>, y: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's x values at a given y. The result is the x values
+   * the curve passes through where y(t) = the given y — up to three solutions
+   * for a cubic curve.
+   *
+   * @param c - The cubic curve.
+   * @param y - The y coordinate.
+   * @returns The x values at y, in t-ascending order.
+   * @since 2.0.0
+   */
+  <XT, YT>(c: CubicCurve2d<XT, YT>, y: number): AtMostThree<number>; /** @since 2.0.0 */
+  (y: number): {
+    <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: CubicCurve2d<XT, YT>): AtMostThree<number>;
+  };
+};
+declare const curvature: {
+  /**
+   * Calculates the curvature of a cubic curve at a given parameter.
+   *
+   * @param c - The cubic curve to calculate the curvature for.
+   * @param t - The parameter value.
+   * @returns The curvature of the cubic curve at parameter t.
+   * @since 1.0.0
+   */
+  (c: CubicCurve2d, t: number): number;
+  /**
+   * Calculates the curvature of a cubic curve at a given parameter.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a cubic curve and returns the curvature of the cubic curve at parameter t.
+   * @since 1.0.0
+   */
+  (t: number): (c: CubicCurve2d) => number;
+};
+/**
+ * Computes the axis-aligned bounding box of the curve over its parameter
+ * domain `[0, 1]`. Accounts for up to two interior extrema per axis, so the
+ * box is tight against the curve and not just the control polygon.
+ *
+ * @param c - The cubic curve.
+ * @returns A closed `Box2d` enclosing the curve.
+ * @since 2.1.0
+ */
+declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+ *
+ * For checking only one axis, call the polynomial-level refiner directly:
+ * `CubicPolynomial.isMonotonic(curve.x, Interval.unit)`.
+ *
+ * @since 2.0.0
+ */
+declare const isMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+declare const isIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+declare const isDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT & Decreasing>;
+/** @since 2.0.0 */
+declare const asMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/** @since 2.0.0 */
+declare const asIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Increasing, YT & Increasing>;
+/** @since 2.0.0 */
+declare const asDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Decreasing, YT & Decreasing>;
+//#endregion
+//#region src/curve/rationalCubic2d.internal.d.ts
+declare const RationalCubicCurve2dTypeId: unique symbol;
+type RationalCubicCurve2dTypeId = typeof RationalCubicCurve2dTypeId;
+declare const RationalCurveTraits: unique symbol;
+type RationalCurveTraits = typeof RationalCurveTraits;
+declare namespace rationalCubic2d_d_exports {
+  export { Decreasing, Increasing, Monotonic, RationalCubicCurve2d, RationalCurveTraits, approximateAsCubicCurves, fromBezierPoints, fromPolynomials, isRationalCubicCurve2d, makeMonotonicEasing, solve, solveAtX, solveAtY };
+}
+/**
+ * A rational cubic curve in 2D space.
+ *
+ * Represented as three cubic polynomials in the parameter `t`: per-axis
+ * numerators `x`, `y`, and a shared denominator `w`. Evaluation is
+ * `(x(t)/w(t), y(t)/w(t))` — the projection from homogeneous coordinates
+ * back to the plane. With all weights equal at the source (e.g. produced
+ * from a non-rational Bézier with unit weights), `w` is constant and the
+ * curve coincides with a polynomial cubic.
+ *
+ * The two type parameters carry per-axis monotonicity trait brands attached
+ * to the rational functions `x(t)/w(t)` and `y(t)/w(t)`. Unlike
+ * `CubicCurve2d`, traits do not flow through to the underlying polynomials —
+ * monotonicity of a ratio of cubics is not the same property as monotonicity
+ * of either cubic alone, so the brand lives on the curve itself. Constructors
+ * with construction-time monotonicity guarantees (e.g. {@link makeMonotonicEasing})
+ * return curves with `Increasing` brands attached, narrowing downstream
+ * operations like {@link solveAtX} to single-solution returns.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 2.1.0
+ */
+interface RationalCubicCurve2d<out XTraits = unknown, out YTraits = unknown> extends Pipeable {
+  readonly [RationalCubicCurve2dTypeId]: RationalCubicCurve2dTypeId;
+  readonly [RationalCurveTraits]: [XTraits, YTraits];
+  readonly x: CubicPolynomial;
+  readonly y: CubicPolynomial;
+  readonly w: CubicPolynomial;
+}
+/**
+ * Checks if a value is a `RationalCubicCurve2d`.
+ *
+ * @param c - The value to check.
+ * @returns `true` if the value is a `RationalCubicCurve2d`, `false` otherwise.
+ * @since 2.1.0
+ */
+declare const isRationalCubicCurve2d: (c: unknown) => c is RationalCubicCurve2d;
+/**
+ * Creates a new `RationalCubicCurve2d` from per-axis numerator polynomials
+ * and a shared denominator polynomial.
+ *
+ * @param x - The x numerator polynomial.
+ * @param y - The y numerator polynomial.
+ * @param w - The shared denominator polynomial (must be non-zero on `[0, 1]`).
+ * @returns A new `RationalCubicCurve2d` instance.
+ * @since 2.1.0
+ */
+declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial, w: CubicPolynomial) => RationalCubicCurve2d;
+/**
+ * Creates a new `RationalCubicCurve2d` from four weighted cubic Bézier
+ * control points. The four control points are lifted to homogeneous form
+ * `(w·x, w·y, w)` and the cubic Bernstein basis is expanded into per-channel
+ * monomial coefficients, yielding the curve's `x`, `y`, and `w` polynomials.
+ *
+ * @param p0 - The first weighted control point (curve start).
+ * @param p1 - The second weighted control point (start handle).
+ * @param p2 - The third weighted control point (end handle).
+ * @param p3 - The fourth weighted control point (curve end).
+ * @returns A new `RationalCubicCurve2d` instance.
+ * @since 2.1.0
+ */
+declare const fromBezierPoints: (p0: Weighted, p1: Weighted, p2: Weighted, p3: Weighted) => RationalCubicCurve2d;
+/**
+ * Creates a guaranteed-monotonic rational cubic easing curve via Gregory-
+ * Delbourgo style construction. The result interpolates `(0, 0)` and
+ * `(1, 1)` with the given endpoint slopes, with `x(t) = t` pinned linearly
+ * and a rational cubic numerator for `y(t)`. Monotonicity of `y(t)` is
+ * verified rigorously at construction (degree-3 polynomial sign analysis);
+ * the returned curve is branded `<Increasing, Increasing>` so that
+ * {@link solveAtX} returns `Solution.AtMostOne<number>` without further
+ * trait refinement.
+ *
+ * For input slope combinations that the default Gregory-Delbourgo
+ * construction cannot accommodate (typically when one slope is large while
+ * the other is small), construction throws. Useful operating range is
+ * roughly `m₀, m₁ ∈ [0, 2]` with `m₀ + m₁ ≲ 3`; smoothstep (`0, 0`) and
+ * linear (`1, 1`) fall out as special cases.
+ *
+ * @param startSlope - The easing function's slope at the start (`dy/dx` at `x = 0`); must be finite and non-negative.
+ * @param endSlope - The easing function's slope at the end (`dy/dx` at `x = 1`); must be finite and non-negative.
+ * @returns A monotone-by-construction rational cubic easing curve.
+ * @throws When slopes are negative, non-finite, or produce a non-monotonic curve under the default construction.
+ * @since 2.1.0
+ */
+declare const makeMonotonicEasing: (startSlope: number, endSlope: number) => RationalCubicCurve2d<Increasing, Increasing>;
+declare const solve: {
+  /**
+   * Evaluates the rational cubic curve at parameter `t`. Returns
+   * `(x(t)/w(t), y(t)/w(t))` — three Horner evaluations and two divisions.
+   *
+   * @param c - The curve to evaluate.
+   * @param t - The parameter value.
+   * @returns The point on the curve at parameter `t`.
+   * @since 2.1.0
+   */
+  (c: RationalCubicCurve2d, t: number): Vector2;
+  /**
+   * Evaluates the rational cubic curve at parameter `t`.
+   *
+   * @param t - The parameter value.
+   * @returns A function that takes a curve and returns the point at `t`.
+   * @since 2.1.0
+   */
+  (t: number): (c: RationalCubicCurve2d) => Vector2;
+};
+declare const solveAtX: {
+  /**
+   * Evaluates the curve's y values at a given x. Because the curve's x axis
+   * carries the `Monotonic` brand, the inverse has at most one solution.
+   *
+   * @param c - The rational cubic curve with monotonic x.
+   * @param x - The x coordinate.
+   * @returns Zero or one y values.
+   * @since 2.1.0
+   */
+  <XT extends Monotonic, YT>(c: RationalCubicCurve2d<XT, YT>, x: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's y values at a given x. Up to three solutions —
+   * `(X(t) - x·W(t))` is a cubic polynomial in `t`.
+   *
+   * @param c - The rational cubic curve.
+   * @param x - The x coordinate.
+   * @returns The y values at x, in t-ascending order.
+   * @since 2.1.0
+   */
+  <XT, YT>(c: RationalCubicCurve2d<XT, YT>, x: number): AtMostThree<number>; /** @since 2.1.0 */
+  (x: number): {
+    <XT extends Monotonic, YT>(c: RationalCubicCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: RationalCubicCurve2d<XT, YT>): AtMostThree<number>;
+  };
+};
+declare const solveAtY: {
+  /**
+   * Evaluates the curve's x values at a given y. Because the curve's y axis
+   * carries the `Monotonic` brand, the inverse has at most one solution.
+   *
+   * @param c - The rational cubic curve with monotonic y.
+   * @param y - The y coordinate.
+   * @returns Zero or one x values.
+   * @since 2.1.0
+   */
+  <XT, YT extends Monotonic>(c: RationalCubicCurve2d<XT, YT>, y: number): AtMostOne<number>;
+  /**
+   * Evaluates the curve's x values at a given y. Up to three solutions.
+   *
+   * @param c - The rational cubic curve.
+   * @param y - The y coordinate.
+   * @returns The x values at y, in t-ascending order.
+   * @since 2.1.0
+   */
+  <XT, YT>(c: RationalCubicCurve2d<XT, YT>, y: number): AtMostThree<number>; /** @since 2.1.0 */
+  (y: number): {
+    <XT, YT extends Monotonic>(c: RationalCubicCurve2d<XT, YT>): AtMostOne<number>;
+    <XT, YT>(c: RationalCubicCurve2d<XT, YT>): AtMostThree<number>;
+  };
+};
+declare const approximateAsCubicCurves: {
+  /**
+   * Approximates the rational cubic as a sequence of polynomial cubic curves
+   * via recursive subdivision. At each level a candidate polynomial cubic is
+   * built by projecting the segment's homogeneous Bézier control points to
+   * 2D; if the candidate's midpoint deviates from the true rational midpoint
+   * by more than `tolerance`, the segment is split at `t = 0.5` and the
+   * procedure recurses on each half. Returns a non-empty array; for a curve
+   * that is already polynomial (uniform weights) the result is a single
+   * exact segment.
+   *
+   * @param c - The rational cubic curve to approximate.
+   * @param tolerance - Maximum allowed midpoint deviation; must be positive.
+   * @returns A sequence of polynomial cubic curves covering the input.
+   * @since 2.1.0
+   */
+  (c: RationalCubicCurve2d, tolerance: number): ReadonlyArray<CubicCurve2d>;
+  /**
+   * Approximates the rational cubic as a sequence of polynomial cubic curves.
+   *
+   * @param tolerance - Maximum allowed midpoint deviation; must be positive.
+   * @returns A function that takes a curve and returns its polynomial approximation.
+   * @since 2.1.0
+   */
+  (tolerance: number): (c: RationalCubicCurve2d) => ReadonlyArray<CubicCurve2d>;
+};
+//#endregion
+export { QuadraticCurve2d as a, linear2d_d_exports as c, cubic2d_d_exports as i, rationalCubic2d_d_exports as n, quadratic2d_d_exports as o, CubicCurve2d as r, LinearCurve2d as s, RationalCubicCurve2d as t };
+//# sourceMappingURL=rationalCubic2d-DlQfBURs.d.mts.map