curvy 2.0.0-alpha.15 → 2.0.0-alpha.17

package/dist/characteristic/characteristic.d.ts

@@ -4,10 +4,11 @@ import type * as Vector4 from '../vector/vector4.ts';
 /**
  * The cubic Bézier characteristic matrix.
  *
- * Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic
- * coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix
- * IS the Bézier spline family — combined with control points (via {@link apply}),
- * it produces the cubic polynomial that parameterizes the curve.
+ * Maps Bernstein-basis control points `(P0, P1, P2, P3)` to monomial cubic
+ * coefficients `(c0, c1, c2, c3)` for `c0 + c1*t + c2*t^2 + c3*t^3`. The
+ * matrix is the spline family's defining data. Combined with control
+ * points via `apply`, it produces the cubic polynomial that parameterizes
+ * the curve.
  *
  * @since 2.0.0
  */
@@ -15,8 +16,8 @@ export declare const cubicBezier: Matrix4x4.Matrix4x4;
 /**
  * The cubic Hermite characteristic matrix.
  *
- * Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two
- * tangent vectors — to monomial cubic coefficients.
+ * Maps Hermite control data `(P0, V0, P1, V1)`, two endpoints and two
+ * tangent vectors, to monomial cubic coefficients.
  *
  * @since 2.0.0
  */
@@ -26,7 +27,7 @@ export declare const cubicHermite: Matrix4x4.Matrix4x4;
  *
  * Maps a window of four control points to the monomial cubic coefficients
  * of one segment of the corresponding uniform cubic B-spline. Stride-1
- * application produces a C² piecewise spline; the curve does not generally
+ * application produces a C2 piecewise spline. The curve does not generally
  * pass through the control points.
  *
  * @since 2.0.0
@@ -36,24 +37,22 @@ export declare const cubicBasisSpline: Matrix4x4.Matrix4x4;
  * The cubic Cardinal spline characteristic matrix, parameterized by tension.
  *
  * Maps four control points to the monomial cubic coefficients of one
- * Cardinal segment. The tension `s` controls how tightly the curve hugs
- * the control points: `s = 0` produces straight-line segments between
- * adjacent points, `s = 0.5` is the Catmull-Rom variant (see
- * {@link cubicCatmullRom}), and higher values produce looser, more curved
- * shapes.
+ * Cardinal segment. The tension controls how tightly the curve hugs the
+ * control points. `0` produces straight-line segments between adjacent
+ * points, `0.5` is the Catmull-Rom variant (`cubicCatmullRom`), and
+ * higher values produce looser, more curved shapes.
  *
- * Cached per tension value — repeated calls with the same tension return
+ * Cached per tension value, so repeated calls with the same tension return
  * the same matrix instance.
  *
- * @param tension - The tension parameter.
+ * @param tension - How tightly the curve hugs the control points. `0` gives straight segments, `0.5` Catmull-Rom.
  * @returns The characteristic matrix for that tension.
  * @since 2.0.0
  */
 export declare const cubicCardinal: (tension: number) => Matrix4x4.Matrix4x4;
 /**
- * The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.
- * The most common Cardinal-family variant; reused widely enough to deserve
- * a constant.
+ * The cubic Catmull-Rom characteristic matrix: Cardinal with tension
+ * `0.5`, the most common Cardinal-family variant.
  *
  * @since 2.0.0
  */
@@ -63,14 +62,14 @@ export declare const cubicCatmullRom: Matrix4x4.Matrix4x4;
  * N cubic polynomials in monomial form.
  *
  * Each channel is a `Vector4` packing one axis's values across the four
- * control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity
+ * control points: `(v0, v1, v2, v3)`. The result tuple has the same arity
  * as the input.
  *
- * The polynomial 2D spline pipeline applies this with two channels (x, y);
- * the rational 2D pipeline uses three (x, y, w) where `w` is the projective
+ * The polynomial 2D spline pipeline applies this with two channels (x, y).
+ * The rational 2D pipeline uses three (x, y, w) where `w` is the projective
  * denominator. Higher channel counts generalize to 3D, rational 3D, and
- * beyond — the characteristic matrix doesn't care about the geometric
- * domain, only about how to combine four samples per channel.
+ * beyond, since the characteristic matrix reads nothing about the geometric
+ * domain, only how to combine four samples per channel.
  *
  * @param matrix - The characteristic matrix of the spline family.
  * @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic--7nC4Q_a.mjs";
+import { n as characteristic_exports } from "../shared/characteristic-CL3bnjgJ.mjs";
 export { characteristic_exports as Characteristic };

package/dist/curve/cubic2d.d.ts

@@ -3,7 +3,7 @@ import type { TwoDimensional } from '../dimensions.ts';
 import type { Closed, Interval } from '../interval/interval.ts';
 import type { Pipeable } from '../utils.ts';
 import type { CubicPolynomial } from '../polynomial/cubic.ts';
-import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
+import type { Decreasing, Increasing, Monotonic, Reflected } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
 import type { Affine2d } from '../transform/affine2d.ts';
 import type { Vector2 } from '../vector/vector2.ts';
@@ -12,7 +12,7 @@ export type { Monotonic, Increasing, Decreasing } from '../polynomial/traits.ts'
 /**
  * A cubic curve in 2D space.
  *
- * All fields are readonly and immutable, and all operations create new instances.
+ * All fields are readonly. No operation mutates a curve.
  *
  * The two type parameters carry the trait sets of the curve's per-axis
  * polynomials. Refiners check monotonicity over the unit interval `[0, 1]` —
@@ -35,14 +35,14 @@ export declare const fromPolynomials: (x: CubicPolynomial, y: CubicPolynomial) =
 /**
  * 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.
+ * Each argument bundles the per-axis coefficient at the given power. `c0`
+ * holds the x^0 term, `c1` holds the x^1 term, and so on. The resulting curve
+ * evaluates to `c0 + c1*t + c2*t^2 + c3*t^3` 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).
+ * @param c0 - The x^0 coefficients (x and y).
+ * @param c1 - The x^1 coefficients (x and y).
+ * @param c2 - The x^2 coefficients (x and y).
+ * @param c3 - The x^3 coefficients (x and y).
  * @returns A new `CubicCurve2d` instance.
  * @since 2.0.0
  */
@@ -50,7 +50,7 @@ export declare const fromCoefficients: (c0: Vector2, c1: Vector2, c2: Vector2, c
 /**
  * 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 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.
@@ -73,38 +73,43 @@ export declare const fromBezierPoints: (p0: Vector2, p1: Vector2, p2: Vector2, p
 export declare const isCubicCurve2d: (c: unknown) => c is CubicCurve2d;
 export declare const solve: {
     /**
-     * Solves the cubic curve for a given parameter t.
+     * Evaluates the curve at 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.
+     * @param t - The curve parameter, conventionally in `[0, 1]`.
+     * @returns A function that takes a cubic curve and returns the point at `t`.
      * @since 1.0.0
      */
     (t: number): (c: CubicCurve2d) => Vector2;
     /**
-     * Solves the cubic curve for a given parameter t.
+     * Evaluates the curve at parameter `t`.
      *
-     * @param c - The cubic curve to solve.
-     * @param t - The parameter value.
-     * @returns The point on the curve at parameter t.
+     * `t` is not clamped. Values outside `[0, 1]` extrapolate the curve's
+     * polynomials.
+     *
+     * @param c - The cubic curve to evaluate.
+     * @param t - The curve parameter, conventionally in `[0, 1]`.
+     * @returns The point on the curve at parameter `t`.
      * @since 1.0.0
      */
     (c: CubicCurve2d, t: number): Vector2;
 };
 export declare const length: {
     /**
-     * Calculates (approximates) the length of a cubic curve.
+     * Calculates the arc length of a cubic curve over an interval of its
+     * parameter domain, approximated by numerical quadrature.
      *
-     * @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.
+     * @param c - The cubic curve to measure.
+     * @param i - The parameter interval to measure over.
+     * @returns The arc length over the interval, to quadrature accuracy.
      * @since 1.0.0
      */
     (c: CubicCurve2d, i: Interval): number;
     /**
-     * Calculates (approximates) the length of a cubic curve.
+     * Calculates the arc length of a cubic curve over an interval of its
+     * parameter domain, approximated by numerical quadrature.
      *
-     * @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.
+     * @param i - The parameter interval to measure over.
+     * @returns A function that takes a cubic curve and returns the arc length.
      * @since 1.0.0
      */
     (i: Interval): (c: CubicCurve2d) => number;
@@ -112,7 +117,7 @@ export declare const length: {
 export declare const solveAtX: {
     /**
      * 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.
+     * `Monotonic`, the inverse has at most one solution, at most one y value.
      *
      * @param c - The cubic curve.
      * @param x - The x coordinate.
@@ -122,7 +127,7 @@ export declare const solveAtX: {
     <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>, x: number): Solution.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
+     * the curve passes through where x(t) = the given x, up to three solutions
      * for a cubic curve.
      *
      * @param c - The cubic curve.
@@ -131,7 +136,13 @@ export declare const solveAtX: {
      * @since 2.0.0
      */
     <XT, YT>(c: CubicCurve2d<XT, YT>, x: number): Solution.AtMostThree<number>;
-    /** @since 2.0.0 */
+    /**
+     * Evaluates the curve's y values at a given x.
+     *
+     * @param x - The x coordinate.
+     * @returns A function that takes a cubic curve and returns the y values at `x`.
+     * @since 2.0.0
+     */
     (x: number): {
         <XT extends Monotonic, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostOne<number>;
         <XT, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostThree<number>;
@@ -150,7 +161,7 @@ export declare const solveAtY: {
     <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>, y: number): Solution.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
+     * the curve passes through where y(t) = the given y, up to three solutions
      * for a cubic curve.
      *
      * @param c - The cubic curve.
@@ -159,7 +170,13 @@ export declare const solveAtY: {
      * @since 2.0.0
      */
     <XT, YT>(c: CubicCurve2d<XT, YT>, y: number): Solution.AtMostThree<number>;
-    /** @since 2.0.0 */
+    /**
+     * Evaluates the curve's x values at a given y.
+     *
+     * @param y - The y coordinate.
+     * @returns A function that takes a cubic curve and returns the x values at `y`.
+     * @since 2.0.0
+     */
     (y: number): {
         <XT, YT extends Monotonic>(c: CubicCurve2d<XT, YT>): Solution.AtMostOne<number>;
         <XT, YT>(c: CubicCurve2d<XT, YT>): Solution.AtMostThree<number>;
@@ -190,12 +207,12 @@ export declare const curvature: {
  * box is tight against the curve and not just the control polygon.
  *
  * @param c - The cubic curve.
- * @returns A closed `Box2d` enclosing the curve.
+ * @returns A closed `Interval2d` enclosing the curve.
  * @since 2.0.0
  */
 export declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed>;
 /**
- * Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+ * Evaluates the curve at `t = 0` in closed form: `(c.x.c0, c.y.c0)`.
  *
  * @param c - The cubic curve.
  * @returns The point at the start of the curve's parameter domain.
@@ -203,7 +220,7 @@ export declare const boundingBox: (c: CubicCurve2d) => Interval2d<Closed, Closed
  */
 export declare const startPoint: (c: CubicCurve2d) => Vector2;
 /**
- * Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+ * Evaluates the curve at `t = 1` in closed form, the sum of the per-axis
  * monomial coefficients.
  *
  * @param c - The cubic curve.
@@ -230,7 +247,7 @@ export declare const xRange: (c: CubicCurve2d) => Closed;
  */
 export declare const yRange: (c: CubicCurve2d) => Closed;
 /**
- * Renders the curve as a single SVG path-data drawing command — for a cubic
+ * Renders the curve as a single SVG path-data drawing command. For a cubic
  * curve, `C ctrl1X,ctrl1Y ctrl2X,ctrl2Y endX,endY`. Bernstein control points
  * are recovered from the monomial coefficients in closed form. Does not
  * include a leading `M`.
@@ -241,50 +258,127 @@ export declare const yRange: (c: CubicCurve2d) => Closed;
  */
 export declare const toPathDataSegment: (c: CubicCurve2d) => string;
 /**
- * Type-narrowing predicate: refines the curve's x-axis trait to include
- * `Monotonic` when the x polynomial is strictly monotonic on the unit
- * interval `[0, 1]`. The y-axis trait is unchanged.
+ * Checks if the curve's x polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`, adding `Monotonic` to the x-axis trait. The y-axis
+ * trait is unchanged.
  *
+ * @param c - The cubic curve to check.
+ * @returns `true` when x is strictly monotonic on `[0, 1]`, narrowing the x-axis trait.
  * @since 2.0.0
  */
 export declare const isMonotonicX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT>;
-/** @since 2.0.0 */
+/**
+ * Checks if the curve's x polynomial is strictly increasing on the
+ * unit interval `[0, 1]`, adding `Increasing` to the x-axis trait.
+ * The y-axis trait is unchanged.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when x is strictly increasing on `[0, 1]`, narrowing the x-axis trait.
+ * @since 2.0.0
+ */
 export declare const isIncreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT>;
-/** @since 2.0.0 */
+/**
+ * Checks if the curve's x polynomial is strictly decreasing on the
+ * unit interval `[0, 1]`, adding `Decreasing` to the x-axis trait.
+ * The y-axis trait is unchanged.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when x is strictly decreasing on `[0, 1]`, narrowing the x-axis trait.
+ * @since 2.0.0
+ */
 export declare const isDecreasingX: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT>;
 /**
- * Type-narrowing predicate: refines the curve's y-axis trait to include
- * `Monotonic`. The x-axis trait is unchanged.
+ * Checks if the curve's y polynomial is strictly monotonic on the unit
+ * interval `[0, 1]`, adding `Monotonic` to the y-axis trait. The x-axis
+ * trait is unchanged.
  *
+ * @param c - The cubic curve to check.
+ * @returns `true` when y is strictly monotonic on `[0, 1]`, narrowing the y-axis trait.
  * @since 2.0.0
  */
 export declare const isMonotonicY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Monotonic>;
-/** @since 2.0.0 */
+/**
+ * Checks if the curve's y polynomial is strictly increasing on the
+ * unit interval `[0, 1]`, adding `Increasing` to the y-axis trait.
+ * The x-axis trait is unchanged.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when y is strictly increasing on `[0, 1]`, narrowing the y-axis trait.
+ * @since 2.0.0
+ */
 export declare const isIncreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Increasing>;
-/** @since 2.0.0 */
+/**
+ * Checks if the curve's y polynomial is strictly decreasing on the
+ * unit interval `[0, 1]`, adding `Decreasing` to the y-axis trait.
+ * The x-axis trait is unchanged.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when y is strictly decreasing on `[0, 1]`, narrowing the y-axis trait.
+ * @since 2.0.0
+ */
 export declare const isDecreasingY: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT, YT & Decreasing>;
 /**
- * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
- * when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+ * Checks if both the x and y polynomials are strictly monotonic on the
+ * unit interval `[0, 1]`, adding `Monotonic` to both axes' traits.
  *
+ * @param c - The cubic curve to check.
+ * @returns `true` when both axes are strictly monotonic on `[0, 1]`, narrowing both traits.
  * @since 2.0.0
  */
 export declare const isMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Monotonic, YT & Monotonic>;
-/** @since 2.0.0 */
+/**
+ * Checks if both the x and y polynomials are strictly increasing on
+ * the unit interval `[0, 1]`, adding `Increasing` to both axes' traits.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when both axes are strictly increasing on `[0, 1]`, narrowing both traits.
+ * @since 2.0.0
+ */
 export declare const isIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Increasing, YT & Increasing>;
-/** @since 2.0.0 */
+/**
+ * Checks if both the x and y polynomials are strictly decreasing on
+ * the unit interval `[0, 1]`, adding `Decreasing` to both axes' traits.
+ *
+ * @param c - The cubic curve to check.
+ * @returns `true` when both axes are strictly decreasing on `[0, 1]`, narrowing both traits.
+ * @since 2.0.0
+ */
 export declare const isDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => c is CubicCurve2d<XT & Decreasing, YT & Decreasing>;
-/** @since 2.0.0 */
+/**
+ * Asserts that both axes are strictly monotonic on the unit interval
+ * `[0, 1]`, throwing on failure.
+ *
+ * @param c - The cubic curve to assert against.
+ * @returns The same curve, with `Monotonic` on both axes' traits.
+ * @throws `Error` when either axis fails the check.
+ * @since 2.0.0
+ */
 export declare const asMonotonic: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Monotonic, YT & Monotonic>;
-/** @since 2.0.0 */
+/**
+ * Asserts that both axes are strictly increasing on the unit interval
+ * `[0, 1]`, throwing on failure.
+ *
+ * @param c - The cubic curve to assert against.
+ * @returns The same curve, with `Increasing` on both axes' traits.
+ * @throws `Error` when either axis fails the check.
+ * @since 2.0.0
+ */
 export declare const asIncreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Increasing, YT & Increasing>;
-/** @since 2.0.0 */
+/**
+ * Asserts that both axes are strictly decreasing on the unit interval
+ * `[0, 1]`, throwing on failure.
+ *
+ * @param c - The cubic curve to assert against.
+ * @returns The same curve, with `Decreasing` on both axes' traits.
+ * @throws `Error` when either axis fails the check.
+ * @since 2.0.0
+ */
 export declare const asDecreasing: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<XT & Decreasing, YT & Decreasing>;
 export declare const transform: {
     /**
      * Applies an `Affine2d` transform to a `CubicCurve2d`, returning a new
      * curve whose image is the affine image of the original. Internally the
-     * transformation works directly on monomial coefficients — `c0` receives
+     * transformation works directly on monomial coefficients. `c0` receives
      * the full affine, `c1`/`c2`/`c3` receive only the linear part.
      *
      * @param c - The cubic curve.
@@ -302,3 +396,17 @@ export declare const transform: {
      */
     (a: Affine2d): (c: CubicCurve2d) => CubicCurve2d;
 };
+/**
+ * Reverses the curve's parameter direction, returning the curve traced from
+ * `t = 1` back to `t = 0`. The geometric image is identical — the same points
+ * in the same places — but the start and end swap and each axis's monotonic
+ * sense inverts: an `Increasing` axis becomes `Decreasing` and vice versa
+ * (`Reflected`), a bare `Monotonic` axis stays monotonic. Per component this
+ * reflects each coordinate polynomial about its domain midpoint
+ * (`CubicPolynomial.reflectDomain`).
+ *
+ * @param c - The cubic curve to reverse.
+ * @returns The reversed curve, its per-axis direction brands flipped.
+ * @since 2.0.0
+ */
+export declare const reverse: <XT, YT>(c: CubicCurve2d<XT, YT>) => CubicCurve2d<Reflected<XT>, Reflected<YT>>;

package/dist/curve/curve2d.d.ts

@@ -10,14 +10,14 @@ import type { Vector2 } from '../vector/vector2.ts';
  * instance which the corresponding path module passes to
  * `Path2d.make(ops)` to derive its operation surface.
  *
- * The interface is intentionally small — anything that isn't shared
- * structurally across curve degrees stays on the per-degree module.
+ * The interface stays small. Anything that isn't shared structurally
+ * across curve degrees stays on the per-degree module.
  *
  * @since 2.0.0
  */
 export interface Curve2dOps<C> {
     /**
-     * Evaluate the curve at parameter `t ∈ [0, 1]`.
+     * Evaluate the curve at parameter `t in [0, 1]`.
      */
     solve(c: C, t: number): Vector2;
     /**
@@ -42,11 +42,11 @@ export interface Curve2dOps<C> {
      */
     solveAtX(c: C, x: number): Solution.AtMostOne<number>;
     /**
-     * y-axis analog of {@link solveAtX}.
+     * y-axis analog of `solveAtX`.
      */
     solveAtY(c: C, y: number): Solution.AtMostOne<number>;
     /**
-     * SVG path-data drawing command for one segment (`L …`, `Q …`, `C …`),
+     * SVG path-data drawing command for one segment (`L ...`, `Q ...`, `C ...`),
      * without a leading `M`. Move-insertion is decided by the path-level
      * `toPathData` based on continuity with the previous segment.
      */
@@ -71,11 +71,19 @@ export interface Curve2dOps<C> {
      * Apply an affine transform to the curve, returning a new curve whose
      * geometric image is the affine image of the original.
      *
-     * For non-rational coefficient-form curves this is per-coefficient: the
+     * For non-rational coefficient-form curves this is per-coefficient. The
      * constant coefficient receives the full affine, and all higher-degree
      * coefficients receive only the linear part. For rational curves the
      * translation is folded into the numerator polynomials weighted by the
      * denominator. Path-level callers route through this op per curve.
      */
     transform(c: C, a: Affine2d): C;
+    /**
+     * Reverse the curve's parameter direction, returning the curve traced from
+     * t = 1 to t = 0. The geometric image is unchanged — start and end swap and
+     * any monotonic axis inverts — since per component this reflects each
+     * coordinate polynomial about its domain midpoint (`p(1 - u)`). Path-level
+     * `reverse` routes through this op per curve.
+     */
+    reverse(c: C): C;
 }

package/dist/curve/index.mjs

@@ -1,2 +1,3 @@
-import { i as rationalCubic2d_exports, m as quadratic2d_exports, s as cubic2d_exports, v as linear2d_exports } from "../shared/rationalCubic2d-gM7VeiiT.mjs";
+import { n as cubic2d_exports, p as quadratic2d_exports, y as linear2d_exports } from "../shared/cubic2d-CI82mN9o.mjs";
+import { i as rationalCubic2d_exports } from "../shared/rationalCubic2d-aT1o6oCm.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };