curvy 2.0.0-alpha.12 → 2.0.0-alpha.13

package/dist/characteristic/index.mjs

@@ -1,2 +1,2 @@
-import { n as characteristic_exports } from "../shared/characteristic-Hb7F8SBw.mjs";
+import { n as characteristic_exports } from "../shared/characteristic-BkEr-rr8.mjs";
 export { characteristic_exports as Characteristic };

package/dist/curve/index.mjs

@@ -1,2 +1,2 @@
-import { C as linear2d_exports, g as quadratic2d_exports, o as cubic2d_exports, r as rationalCubic2d_exports } from "../shared/rationalCubic2d-D5g3_hTV.mjs";
+import { _ as quadratic2d_exports, i as rationalCubic2d_exports, s as cubic2d_exports, w as linear2d_exports } from "../shared/rationalCubic2d-CeHgpNht.mjs";
 export { cubic2d_exports as CubicCurve2d, linear2d_exports as LinearCurve2d, quadratic2d_exports as QuadraticCurve2d, rationalCubic2d_exports as RationalCubicCurve2d };

package/dist/curve/rationalCubic2d.d.ts

@@ -1,8 +1,9 @@
 import type { Closed } from '../interval/interval.ts';
 import type { Interval2d } from '../interval/interval2d.ts';
+import type { Monotonicity } from '../monotonicity/monotonicity.ts';
 import type { Pipeable } from '../utils.ts';
 import type { CubicPolynomial } from '../polynomial/cubic.ts';
-import type { Increasing, Monotonic } from '../polynomial/traits.ts';
+import type { Decreasing, Increasing, Monotonic } from '../polynomial/traits.ts';
 import type * as Solution from '../solution/solution.ts';
 import type { Vector2, Weighted } from '../vector/vector2.ts';
 import type { CubicCurve2d } from './cubic2d.ts';
@@ -191,22 +192,205 @@ export declare const subdivide: {
      */
     (t: number): (c: RationalCubicCurve2d) => [RationalCubicCurve2d, RationalCubicCurve2d];
 };
+export declare const boundingBox: {
+    /**
+     * Computes a closed axis-aligned bounding box for a rational cubic curve,
+     * tight to within `tolerance` per side.
+     *
+     * Implemented as recursive subdivision: at each leaf the curve segment's
+     * loose hull AABB (cheap, always valid) is compared against the segment's
+     * endpoint AABB (which the curve provably visits). When the per-side gap
+     * between them is ≤ `tolerance`, the leaf returns its hull; otherwise the
+     * segment is split at `t = 0.5` and the procedure recurses, unioning the
+     * halves.
+     *
+     * The returned box is provably within `tolerance` of the true tight box on
+     * every side, and contains the curve since each leaf hull does. The
+     * polynomial cubic case (uniform weights) is handled by a fast path that
+     * computes the exact box from per-axis cubic extrema, with no subdivision.
+     *
+     * @param c - The rational cubic curve.
+     * @param tolerance - Maximum allowed slack per side; must be positive.
+     * @returns A closed `Interval2d` enclosing the curve, tight to within `tolerance`.
+     * @since 2.0.0
+     */
+    (c: RationalCubicCurve2d, tolerance: number): Interval2d<Closed, Closed>;
+    /**
+     * Computes a closed axis-aligned bounding box for a rational cubic curve.
+     *
+     * @param tolerance - Maximum allowed slack per side; must be positive.
+     * @returns A function that takes a curve and returns its bounding box.
+     * @since 2.0.0
+     */
+    (tolerance: number): (c: RationalCubicCurve2d) => Interval2d<Closed, Closed>;
+};
+/**
+ * Classifies the monotonicity of the curve's `x(t) = X(t)/W(t)` projection on
+ * the unit interval `[0, 1]`.
+ *
+ * Decided via Bernstein sign convexity on the derivative-numerator polynomial
+ * `q(t) = X'·W − X·W'`. Since `W² > 0` wherever the curve is well-defined,
+ * the sign of `dx/dt` equals the sign of `q`. Although `q` is a difference of
+ * degree-5 products, the leading terms cancel and `q` is in fact a quartic —
+ * its 5 Bernstein coefficients on `[0, 1]` are evaluated for uniform sign,
+ * with de Casteljau subdivision to resolve mixed-sign cases. The procedure is
+ * exact except at tangential zeros, where it conservatively reports `None`.
+ *
+ * Returning `Increasing` or `Decreasing` is the trigger for
+ * {@link asMonotonic} / {@link asIncreasing} / {@link asDecreasing}.
+ *
+ * @param c - The rational cubic curve.
+ * @returns The monotonicity of the curve's x projection on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const xMonotonicity: (c: RationalCubicCurve2d) => Monotonicity;
+/**
+ * Classifies the monotonicity of the curve's `y(t) = Y(t)/W(t)` projection on
+ * the unit interval `[0, 1]`. See {@link xMonotonicity} for the method.
+ *
+ * @param c - The rational cubic curve.
+ * @returns The monotonicity of the curve's y projection on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const yMonotonicity: (c: RationalCubicCurve2d) => Monotonicity;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Monotonic` when `x(t)/w(t)` is strictly monotonic on `[0, 1]`. The y-axis
+ * trait is unchanged.
+ *
+ * Use this when only x-axis monotonicity is required (e.g. to make {@link solveAtX}
+ * narrow to `AtMostOne` without also asserting y-axis monotonicity).
+ *
+ * @param c - The rational cubic curve.
+ * @returns `true` when the x projection is strictly monotonic on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const isMonotonicX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Monotonic, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Increasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's x-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Decreasing, YT>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Monotonic`. The x-axis trait is unchanged. y analog of {@link isMonotonicX}.
+ *
+ * @since 2.0.0
+ */
+export declare const isMonotonicY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasingY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines the curve's y-axis trait to include
+ * `Decreasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasingY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT, YT & Decreasing>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+ * when both `x(t)/w(t)` and `y(t)/w(t)` are strictly monotonic on `[0, 1]`.
+ *
+ * The constant case is excluded — `Monotonic` is the *strict* brand.
+ *
+ * @param c - The rational cubic curve.
+ * @returns `true` when both axes are strictly monotonic on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const isMonotonic: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Increasing`
+ * when both `x(t)/w(t)` and `y(t)/w(t)` are strictly increasing on `[0, 1]`.
+ *
+ * @since 2.0.0
+ */
+export declare const isIncreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Type-narrowing predicate: refines both axes' traits to include `Decreasing`
+ * when both `x(t)/w(t)` and `y(t)/w(t)` are strictly decreasing on `[0, 1]`.
+ *
+ * @since 2.0.0
+ */
+export declare const isDecreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => c is RationalCubicCurve2d<XT & Decreasing, YT & Decreasing>;
+/**
+ * Asserts that the curve is strictly monotonic in x on `[0, 1]`, returning
+ * the same curve with the x-axis trait branded `Monotonic`.
+ *
+ * @param c - The rational cubic curve.
+ * @returns The same curve, refined with the `Monotonic` brand on x.
+ * @throws When the x projection is not strictly monotonic on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const asMonotonicX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Monotonic, YT>;
+/**
+ * Asserts that the curve is strictly increasing in x on `[0, 1]`.
+ *
+ * @since 2.0.0
+ */
+export declare const asIncreasingX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Increasing, YT>;
+/**
+ * Asserts that the curve is strictly decreasing in x on `[0, 1]`.
+ *
+ * @since 2.0.0
+ */
+export declare const asDecreasingX: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Decreasing, YT>;
+/**
+ * Asserts that the curve is strictly monotonic in y on `[0, 1]`. y analog of
+ * {@link asMonotonicX}.
+ *
+ * @since 2.0.0
+ */
+export declare const asMonotonicY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT, YT & Monotonic>;
+/**
+ * Asserts that the curve is strictly increasing in y on `[0, 1]`.
+ *
+ * @since 2.0.0
+ */
+export declare const asIncreasingY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT, YT & Increasing>;
 /**
- * Computes a closed axis-aligned bounding box for a rational cubic curve from
- * its projected control polygon. Looser than the tight extrema-based box used
- * by `CubicCurve2d.boundingBox` — finding tight extrema of `x(t)/w(t)` and
- * `y(t)/w(t)` requires solving degree-5 polynomials — but always valid: a
- * positive-weight rational Bézier curve lies inside the convex hull of its
- * projected control points, so the AABB of those points contains the curve.
+ * Asserts that the curve is strictly decreasing in y on `[0, 1]`.
  *
- * Suitable for subdivision-based geometric queries, where bound looseness is
- * compensated by recursion depth.
+ * @since 2.0.0
+ */
+export declare const asDecreasingY: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT, YT & Decreasing>;
+/**
+ * Asserts that the curve is strictly monotonic in both axes on `[0, 1]`,
+ * returning the same curve with both axes branded `Monotonic`.
  *
  * @param c - The rational cubic curve.
- * @returns A closed `Interval2d` enclosing the curve.
+ * @returns The same curve, refined with the `Monotonic` brand on both axes.
+ * @throws When either axis is not strictly monotonic on `[0, 1]`.
+ * @since 2.0.0
+ */
+export declare const asMonotonic: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Monotonic, YT & Monotonic>;
+/**
+ * Asserts that the curve is strictly increasing in both axes on `[0, 1]`,
+ * returning the same curve with both axes branded `Increasing`.
+ *
+ * @since 2.0.0
+ */
+export declare const asIncreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Increasing, YT & Increasing>;
+/**
+ * Asserts that the curve is strictly decreasing in both axes on `[0, 1]`,
+ * returning the same curve with both axes branded `Decreasing`.
+ *
  * @since 2.0.0
  */
-export declare const boundingBox: (c: RationalCubicCurve2d) => Interval2d<Closed, Closed>;
+export declare const asDecreasing: <XT, YT>(c: RationalCubicCurve2d<XT, YT>) => RationalCubicCurve2d<XT & Decreasing, YT & Decreasing>;
 export declare const approximateAsCubicCurves: {
     /**
      * Approximates the rational cubic as a sequence of polynomial cubic curves

package/dist/interval/index.mjs

@@ -1,3 +1,3 @@
 import { s as interval_exports } from "../shared/interval-Dm35Xhy4.mjs";
-import { n as interval2d_exports } from "../shared/interval2d-DPmvk_Qe.mjs";
+import { n as interval2d_exports } from "../shared/interval2d-AtneyI45.mjs";
 export { interval_exports as Interval, interval2d_exports as Interval2d };

package/dist/monotonicity/index.d.ts

@@ -0,0 +1,4 @@
+import * as MonotonicityNs from './monotonicity.ts';
+export type Monotonicity = MonotonicityNs.Monotonicity;
+export type GuaranteedMonotonicity = MonotonicityNs.GuaranteedMonotonicity;
+export { MonotonicityNs as Monotonicity };

package/dist/monotonicity/index.mjs

@@ -0,0 +1,2 @@
+import { r as monotonicity_exports } from "../shared/monotonicity-BdebFOtv.mjs";
+export { monotonicity_exports as Monotonicity };

package/dist/monotonicity/monotonicity.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Classification of a function's monotonicity on an interval.
+ *
+ * Encoded as a 2-bit sign-coverage bitmask of the function's derivative:
+ *   - bit 0 (`Increasing`) — derivative takes positive values
+ *   - bit 1 (`Decreasing`) — derivative takes negative values
+ *
+ * The four states fall out of the encoding:
+ *
+ *   | value | name         | derivative on the interval        |
+ *   |-------|--------------|-----------------------------------|
+ *   |   `0` | `Constant`   | ≡ 0                               |
+ *   |   `1` | `Increasing` | ≥ 0, with at least one `> 0`      |
+ *   |   `2` | `Decreasing` | ≤ 0, with at least one `< 0`      |
+ *   |   `3` | `None`       | crosses zero                      |
+ *
+ * The numeric encoding is principled, not arbitrary: the bitwise OR of two
+ * adjacent subintervals' classifications gives the classification of their
+ * union, which lets monotonicity be computed by recursive subdivision
+ * without any custom combine logic.
+ *
+ * @since 2.0.0
+ */
+export type Monotonicity = 0 | 1 | 2 | 3;
+/**
+ * Subset of {@link Monotonicity} excluding the indeterminate `None` state.
+ * Returned by classifiers operating on functions whose derivative cannot
+ * change sign on the interval (e.g. linear polynomials, whose derivative is
+ * constant).
+ *
+ * @since 2.0.0
+ */
+export type GuaranteedMonotonicity = 0 | 1 | 2;
+/**
+ * Derivative is identically zero on the interval. The function is constant.
+ *
+ * @since 2.0.0
+ */
+export declare const Constant: 0;
+/**
+ * Derivative is non-negative on the interval with at least one strictly
+ * positive sample. The function is strictly increasing.
+ *
+ * @since 2.0.0
+ */
+export declare const Increasing: 1;
+/**
+ * Derivative is non-positive on the interval with at least one strictly
+ * negative sample. The function is strictly decreasing.
+ *
+ * @since 2.0.0
+ */
+export declare const Decreasing: 2;
+/**
+ * Derivative crosses zero on the interval. The function has at least one
+ * interior extremum and is not monotonic in either direction.
+ *
+ * @since 2.0.0
+ */
+export declare const None: 3;
+/**
+ * Type-narrowing predicate: refines a `Monotonicity` to `Increasing |
+ * Decreasing` — the strict cases that admit a unique inverse.
+ *
+ * @param m - The monotonicity classification.
+ * @returns `true` when `m` is `Increasing` or `Decreasing`.
+ * @since 2.0.0
+ */
+export declare const isStrict: (m: Monotonicity) => m is 1 | 2;
+/**
+ * Classifies the monotonicity of a function given its values at two interval
+ * endpoints, when the function is known a priori to be monotonic on the
+ * spanning interval (e.g. a linear polynomial).
+ *
+ * @param s0 - The function value at the start of the interval.
+ * @param s1 - The function value at the end of the interval.
+ * @returns The classification — `Increasing`, `Decreasing`, or `Constant`.
+ * @since 2.0.0
+ */
+export declare const fromComparison: (s0: number, s1: number) => GuaranteedMonotonicity;

package/dist/path/index.mjs

@@ -2,11 +2,11 @@ import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
 import { epsEquals } from "../number.mjs";
 import { p as unit } from "../shared/interval-Dm35Xhy4.mjs";
-import { o as none, r as isNone, s as one } from "../shared/solution-B6KY1E7M.mjs";
-import { n as isDecreasing, r as isIncreasing } from "../shared/quadratic-BZmfZE71.mjs";
-import { a as union } from "../shared/interval2d-DPmvk_Qe.mjs";
-import { _ as solve$2, h as length$2, m as boundingBox$2, v as solveAtX$2, y as solveAtY$2 } from "../shared/rationalCubic2d-D5g3_hTV.mjs";
-import { n as rationalCubic2d_exports, o as linear2d_exports, r as cubic2d_exports } from "../shared/rationalCubic2d-MojACId0.mjs";
+import { o as none, r as isNone, s as one } from "../shared/solution-B2JdOZpe.mjs";
+import { n as isDecreasing, r as isIncreasing } from "../shared/quadratic-DPrUsFCp.mjs";
+import { a as union } from "../shared/interval2d-AtneyI45.mjs";
+import { b as solveAtY$2, g as length$2, h as boundingBox$2, v as solve$2, y as solveAtX$2 } from "../shared/rationalCubic2d-CeHgpNht.mjs";
+import { n as rationalCubic2d_exports, o as linear2d_exports, r as cubic2d_exports } from "../shared/rationalCubic2d-H1J2Fjyy.mjs";
 //#region src/path/quadratic2d.internal.ts
 const QuadraticPath2dTypeId = Symbol("curvy/path/quadratic2d");
 /** @internal */

package/dist/path/rationalCubic2d.d.ts

@@ -1,4 +1,6 @@
 import type { RationalCubicCurve2d } from '../curve/rationalCubic2d.ts';
+import type { Closed } from '../interval/interval.ts';
+import type { Interval2d } from '../interval/interval2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { CubicPath2d } from './cubic2d.ts';
@@ -88,6 +90,31 @@ export declare const solve: {
      */
     (u: number): (p: RationalCubicPath2d) => Vector2;
 };
+export declare const boundingBox: {
+    /**
+     * Computes a closed axis-aligned bounding box for a rational cubic path,
+     * tight to within `tolerance` per side.
+     *
+     * Per-segment delegates to `RationalCubicCurve2d.boundingBox(c, tolerance)`
+     * — recursive subdivision producing a hull-AABB union tight to within
+     * `tolerance` per side. The path box is the union of segment boxes; since
+     * each segment box has slack ≤ tolerance per side, so does the union.
+     *
+     * @param p - The rational cubic path.
+     * @param tolerance - Maximum allowed slack per side; must be positive.
+     * @returns A closed `Interval2d` enclosing the path, tight to within `tolerance`.
+     * @since 2.0.0
+     */
+    (p: RationalCubicPath2d, tolerance: number): Interval2d<Closed, Closed>;
+    /**
+     * Computes a closed axis-aligned bounding box for a rational cubic path.
+     *
+     * @param tolerance - Maximum allowed slack per side; must be positive.
+     * @returns A function that takes a path and returns its bounding box.
+     * @since 2.0.0
+     */
+    (tolerance: number): (p: RationalCubicPath2d) => Interval2d<Closed, Closed>;
+};
 export declare const approximateAsCubicPath: {
     /**
      * Approximates the rational cubic path as a `CubicPath2d` via per-segment

package/dist/polynomial/cubic.d.ts

@@ -4,7 +4,7 @@ import type * as Solution from '../solution/solution.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Vector4 } from '../vector/vector4.ts';
 import type { CubicPolynomialTypeId } from './cubic.internal.circular.ts';
-import type { Monotonicity } from './monotonicity.ts';
+import type { Monotonicity } from '../monotonicity/monotonicity.ts';
 import type { QuadraticPolynomial } from './quadratic.ts';
 import type { Decreasing, Increasing, Monotonic, PolynomialTraits } from './traits.ts';
 export type { Monotonic, Increasing, Decreasing } from './traits.ts';
@@ -252,7 +252,7 @@ export declare const monotonicity: {
  *
  * @param p - The cubic polynomial to check.
  * @param i - Optional interval over which to check monotonicity.
- * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+ * @returns `true` when monotonicity is `Increasing` or `Decreasing`.
  * @since 2.0.0
  */
 export declare const isMonotonic: {

package/dist/polynomial/index.mjs

@@ -1,3 +1,3 @@
-import { t as cubic_exports } from "../shared/cubic-DHJrzZJN.mjs";
-import { o as quadratic_exports, p as linear_exports } from "../shared/quadratic-BZmfZE71.mjs";
+import { t as cubic_exports } from "../shared/cubic-BL6dpuHh.mjs";
+import { o as quadratic_exports, p as linear_exports } from "../shared/quadratic-DPrUsFCp.mjs";
 export { cubic_exports as CubicPolynomial, linear_exports as LinearPolynomial, quadratic_exports as QuadraticPolynomial };

package/dist/polynomial/linear.d.ts

@@ -3,7 +3,7 @@ import type { Pipeable } from '../utils.ts';
 import type * as Solution from '../solution/solution.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { LinearPolynomialTypeId } from './linear.internal.ts';
-import type { GuaranteedMonotonicity } from './monotonicity.ts';
+import type { GuaranteedMonotonicity } from '../monotonicity/monotonicity.ts';
 import type { QuadraticPolynomial } from './quadratic.ts';
 import type { Decreasing, Increasing, Monotonic, PolynomialTraits } from './traits.ts';
 export type { Monotonic, Increasing, Decreasing } from './traits.ts';
@@ -176,7 +176,7 @@ export declare const monotonicity: (p: LinearPolynomial) => GuaranteedMonotonici
  * `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'`.
+ * @returns `true` when `monotonicity(p)` is `Increasing` or `Decreasing`.
  * @since 2.0.0
  */
 export declare const isMonotonic: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Monotonic>;
@@ -184,7 +184,7 @@ export declare const isMonotonic: <T>(p: LinearPolynomial<T>) => p is LinearPoly
  * Type-narrowing predicate: refines to `LinearPolynomial<T & Increasing>`.
  *
  * @param p - The linear polynomial to check.
- * @returns `true` when `monotonicity(p)` is `'increasing'`.
+ * @returns `true` when `monotonicity(p)` is `Increasing`.
  * @since 2.0.0
  */
 export declare const isIncreasing: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Increasing>;
@@ -192,7 +192,7 @@ export declare const isIncreasing: <T>(p: LinearPolynomial<T>) => p is LinearPol
  * Type-narrowing predicate: refines to `LinearPolynomial<T & Decreasing>`.
  *
  * @param p - The linear polynomial to check.
- * @returns `true` when `monotonicity(p)` is `'decreasing'`.
+ * @returns `true` when `monotonicity(p)` is `Decreasing`.
  * @since 2.0.0
  */
 export declare const isDecreasing: <T>(p: LinearPolynomial<T>) => p is LinearPolynomial<T & Decreasing>;
@@ -201,7 +201,7 @@ export declare const isDecreasing: <T>(p: LinearPolynomial<T>) => p is LinearPol
  *
  * @param p - The linear polynomial to assert against.
  * @returns The same polynomial, typed with the `Monotonic` brand.
- * @throws When `monotonicity(p)` is `'constant'`.
+ * @throws When `monotonicity(p)` is `Constant`.
  * @since 2.0.0
  */
 export declare const asMonotonic: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Monotonic>;
@@ -210,7 +210,7 @@ export declare const asMonotonic: <T>(p: LinearPolynomial<T>) => LinearPolynomia
  *
  * @param p - The linear polynomial to assert against.
  * @returns The same polynomial, typed with the `Increasing` brand.
- * @throws When `monotonicity(p)` is not `'increasing'`.
+ * @throws When `monotonicity(p)` is not `Increasing`.
  * @since 2.0.0
  */
 export declare const asIncreasing: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Increasing>;
@@ -219,7 +219,7 @@ export declare const asIncreasing: <T>(p: LinearPolynomial<T>) => LinearPolynomi
  *
  * @param p - The linear polynomial to assert against.
  * @returns The same polynomial, typed with the `Decreasing` brand.
- * @throws When `monotonicity(p)` is not `'decreasing'`.
+ * @throws When `monotonicity(p)` is not `Decreasing`.
  * @since 2.0.0
  */
 export declare const asDecreasing: <T>(p: LinearPolynomial<T>) => LinearPolynomial<T & Decreasing>;

package/dist/polynomial/quadratic.d.ts

@@ -5,7 +5,7 @@ import type { Vector2 } from '../vector/vector2.ts';
 import type { Vector3 } from '../vector/vector3.ts';
 import type { CubicPolynomial } from './cubic.ts';
 import type { LinearPolynomial } from './linear.ts';
-import type { Monotonicity } from './monotonicity.ts';
+import type { Monotonicity } from '../monotonicity/monotonicity.ts';
 import type { QuadraticPolynomialTypeId } from './quadratic.internal.circular.ts';
 import type { Decreasing, Increasing, Monotonic, PolynomialTraits } from './traits.ts';
 export type { Monotonic, Increasing, Decreasing } from './traits.ts';
@@ -227,7 +227,7 @@ export declare const monotonicity: {
  *
  * @param p - The quadratic polynomial to check.
  * @param i - Optional interval over which to check monotonicity.
- * @returns `true` when monotonicity is `'increasing'` or `'decreasing'`.
+ * @returns `true` when monotonicity is `Increasing` or `Decreasing`.
  * @since 2.0.0
  */
 export declare const isMonotonic: {

package/dist/shared/{characteristic-Hb7F8SBw.mjs → characteristic-BkEr-rr8.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
 import { roundDown } from "../number.mjs";
 import { a as vectorProductLeft, n as make } from "./matrix4x4-BWmf4lZM.mjs";
-import { r as fromVector } from "./cubic-DHJrzZJN.mjs";
+import { r as fromVector } from "./cubic-BL6dpuHh.mjs";
 //#region src/characteristic/characteristic.ts
 var characteristic_exports = /* @__PURE__ */ __exportAll({
 	apply: () => apply,
@@ -101,4 +101,4 @@ const apply = (matrix, ...channels) => {
 //#endregion
 export { cubicHermite as a, cubicBezier as i, characteristic_exports as n, cubicBasisSpline as r, apply as t };
 
-//# sourceMappingURL=characteristic-Hb7F8SBw.mjs.map
+//# sourceMappingURL=characteristic-BkEr-rr8.mjs.map

package/dist/shared/{characteristic-Hb7F8SBw.mjs.map → characteristic-BkEr-rr8.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"characteristic-Hb7F8SBw.mjs","names":["Matrix4x4.make","CubicPolynomial.fromVector","Matrix4x4.vectorProductLeft"],"sources":["../../src/characteristic/characteristic.ts"],"sourcesContent":["import * as Matrix4x4 from '../matrix/matrix4x4.ts'\nimport * as CubicPolynomial from '../polynomial/cubic.ts'\nimport { roundDown } from '../number.ts'\nimport type * as Vector4 from '../vector/vector4.ts'\n\n/**\n * The cubic Bézier characteristic matrix.\n *\n * Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic\n * coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix\n * IS the Bézier spline family — combined with control points (via {@link apply}),\n * it produces the cubic polynomial that parameterizes the curve.\n *\n * @since 2.0.0\n */\nexport const cubicBezier: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  -3,\n  3,\n  0,\n  0,\n  3,\n  -6,\n  3,\n  0,\n  -1,\n  3,\n  -3,\n  1,\n)\n\n/**\n * The cubic Hermite characteristic matrix.\n *\n * Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two\n * tangent vectors — to monomial cubic coefficients.\n *\n * @since 2.0.0\n */\nexport const cubicHermite: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  0,\n  1,\n  0,\n  0,\n  -3,\n  -2,\n  3,\n  -1,\n  2,\n  1,\n  -2,\n  1,\n)\n\n/**\n * The uniform cubic B-spline (basis spline) characteristic matrix.\n *\n * Maps a window of four control points to the monomial cubic coefficients\n * of one segment of the corresponding uniform cubic B-spline. Stride-1\n * application produces a C² piecewise spline; the curve does not generally\n * pass through the control points.\n *\n * @since 2.0.0\n */\nexport const cubicBasisSpline: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1 / 6,\n  4 / 6,\n  roundDown(1 / 6),\n  0,\n  -0.5,\n  0,\n  0.5,\n  0,\n  0.5,\n  -1,\n  0.5,\n  0,\n  -1 / 6,\n  0.5,\n  -0.5,\n  1 / 6,\n)\n\nconst cardinalCache = new Map<number, Matrix4x4.Matrix4x4>()\n\n/**\n * The cubic Cardinal spline characteristic matrix, parameterized by tension.\n *\n * Maps four control points to the monomial cubic coefficients of one\n * Cardinal segment. The tension `s` controls how tightly the curve hugs\n * the control points: `s = 0` produces straight-line segments between\n * adjacent points, `s = 0.5` is the Catmull-Rom variant (see\n * {@link cubicCatmullRom}), and higher values produce looser, more curved\n * shapes.\n *\n * Cached per tension value — repeated calls with the same tension return\n * the same matrix instance.\n *\n * @param tension - The tension parameter.\n * @returns The characteristic matrix for that tension.\n * @since 2.0.0\n */\nexport const cubicCardinal = (tension: number): Matrix4x4.Matrix4x4 => {\n  let m = cardinalCache.get(tension)\n  if (m === undefined) {\n    m = Matrix4x4.make(\n      0,\n      1,\n      0,\n      0,\n      -tension,\n      0,\n      tension,\n      0,\n      2 * tension,\n      tension - 3,\n      3 - 2 * tension,\n      -tension,\n      -tension,\n      2 - tension,\n      tension - 2,\n      tension,\n    )\n    cardinalCache.set(tension, m)\n  }\n  return m\n}\n\n/**\n * The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.\n * The most common Cardinal-family variant; reused widely enough to deserve\n * a constant.\n *\n * @since 2.0.0\n */\nexport const cubicCatmullRom: Matrix4x4.Matrix4x4 = cubicCardinal(0.5)\n\n/**\n * Applies a characteristic matrix to N channels of control values, producing\n * N cubic polynomials in monomial form.\n *\n * Each channel is a `Vector4` packing one axis's values across the four\n * control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity\n * as the input.\n *\n * The polynomial 2D spline pipeline applies this with two channels (x, y);\n * the rational 2D pipeline uses three (x, y, w) where `w` is the projective\n * denominator. Higher channel counts generalize to 3D, rational 3D, and\n * beyond — the characteristic matrix doesn't care about the geometric\n * domain, only about how to combine four samples per channel.\n *\n * @param matrix - The characteristic matrix of the spline family.\n * @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.\n * @returns A tuple of cubic polynomials, one per input channel.\n * @since 2.0.0\n */\nexport const apply = <const Channels extends ReadonlyArray<Vector4.Vector4>>(\n  matrix: Matrix4x4.Matrix4x4,\n  ...channels: Channels\n): { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial } => {\n  const result = channels.map((c) =>\n    CubicPolynomial.fromVector(Matrix4x4.vectorProductLeft(matrix, c)),\n  )\n  return result as { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,cAAmCA,KAC9C,GACA,GACA,GACA,GACA,IACA,GACA,GACA,GACA,GACA,IACA,GACA,GACA,IACA,GACA,IACA,EACD;;;;;;;;;AAUD,MAAa,eAAoCA,KAC/C,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,GACA,IACA,GACA,GACA,IACA,EACD;;;;;;;;;;;AAYD,MAAa,mBAAwCA,KACnD,IAAI,GACJ,IAAI,GACJ,UAAU,IAAI,EAAE,EAChB,GACA,KACA,GACA,IACA,GACA,IACA,IACA,IACA,GACA,KAAK,GACL,IACA,KACA,IAAI,EACL;AAED,MAAM,gCAAgB,IAAI,KAAkC;;;;;;;;;;;;;;;;;;AAmB5D,MAAa,iBAAiB,YAAyC;CACrE,IAAI,IAAI,cAAc,IAAI,QAAQ;CAClC,IAAI,MAAM,KAAA,GAAW;EACnB,IAAIA,KACF,GACA,GACA,GACA,GACA,CAAC,SACD,GACA,SACA,GACA,IAAI,SACJ,UAAU,GACV,IAAI,IAAI,SACR,CAAC,SACD,CAAC,SACD,IAAI,SACJ,UAAU,GACV,QACD;EACD,cAAc,IAAI,SAAS,EAAE;;CAE/B,OAAO;;;;;;;;;AAUT,MAAa,kBAAuC,cAAc,GAAI;;;;;;;;;;;;;;;;;;;;AAqBtE,MAAa,SACX,QACA,GAAG,aACqE;CAIxE,OAHe,SAAS,KAAK,MAC3BC,WAA2BC,kBAA4B,QAAQ,EAAE,CAAC,CAEvD"}
+{"version":3,"file":"characteristic-BkEr-rr8.mjs","names":["Matrix4x4.make","CubicPolynomial.fromVector","Matrix4x4.vectorProductLeft"],"sources":["../../src/characteristic/characteristic.ts"],"sourcesContent":["import * as Matrix4x4 from '../matrix/matrix4x4.ts'\nimport * as CubicPolynomial from '../polynomial/cubic.ts'\nimport { roundDown } from '../number.ts'\nimport type * as Vector4 from '../vector/vector4.ts'\n\n/**\n * The cubic Bézier characteristic matrix.\n *\n * Maps Bernstein-basis control points `(P₀, P₁, P₂, P₃)` to monomial cubic\n * coefficients `(c₀, c₁, c₂, c₃)` for `c₀ + c₁·t + c₂·t² + c₃·t³`. The matrix\n * IS the Bézier spline family — combined with control points (via {@link apply}),\n * it produces the cubic polynomial that parameterizes the curve.\n *\n * @since 2.0.0\n */\nexport const cubicBezier: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  -3,\n  3,\n  0,\n  0,\n  3,\n  -6,\n  3,\n  0,\n  -1,\n  3,\n  -3,\n  1,\n)\n\n/**\n * The cubic Hermite characteristic matrix.\n *\n * Maps Hermite control data `(P₀, V₀, P₁, V₁)` — two endpoints and two\n * tangent vectors — to monomial cubic coefficients.\n *\n * @since 2.0.0\n */\nexport const cubicHermite: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1,\n  0,\n  0,\n  0,\n  0,\n  1,\n  0,\n  0,\n  -3,\n  -2,\n  3,\n  -1,\n  2,\n  1,\n  -2,\n  1,\n)\n\n/**\n * The uniform cubic B-spline (basis spline) characteristic matrix.\n *\n * Maps a window of four control points to the monomial cubic coefficients\n * of one segment of the corresponding uniform cubic B-spline. Stride-1\n * application produces a C² piecewise spline; the curve does not generally\n * pass through the control points.\n *\n * @since 2.0.0\n */\nexport const cubicBasisSpline: Matrix4x4.Matrix4x4 = Matrix4x4.make(\n  1 / 6,\n  4 / 6,\n  roundDown(1 / 6),\n  0,\n  -0.5,\n  0,\n  0.5,\n  0,\n  0.5,\n  -1,\n  0.5,\n  0,\n  -1 / 6,\n  0.5,\n  -0.5,\n  1 / 6,\n)\n\nconst cardinalCache = new Map<number, Matrix4x4.Matrix4x4>()\n\n/**\n * The cubic Cardinal spline characteristic matrix, parameterized by tension.\n *\n * Maps four control points to the monomial cubic coefficients of one\n * Cardinal segment. The tension `s` controls how tightly the curve hugs\n * the control points: `s = 0` produces straight-line segments between\n * adjacent points, `s = 0.5` is the Catmull-Rom variant (see\n * {@link cubicCatmullRom}), and higher values produce looser, more curved\n * shapes.\n *\n * Cached per tension value — repeated calls with the same tension return\n * the same matrix instance.\n *\n * @param tension - The tension parameter.\n * @returns The characteristic matrix for that tension.\n * @since 2.0.0\n */\nexport const cubicCardinal = (tension: number): Matrix4x4.Matrix4x4 => {\n  let m = cardinalCache.get(tension)\n  if (m === undefined) {\n    m = Matrix4x4.make(\n      0,\n      1,\n      0,\n      0,\n      -tension,\n      0,\n      tension,\n      0,\n      2 * tension,\n      tension - 3,\n      3 - 2 * tension,\n      -tension,\n      -tension,\n      2 - tension,\n      tension - 2,\n      tension,\n    )\n    cardinalCache.set(tension, m)\n  }\n  return m\n}\n\n/**\n * The cubic Catmull-Rom characteristic matrix — Cardinal with tension `0.5`.\n * The most common Cardinal-family variant; reused widely enough to deserve\n * a constant.\n *\n * @since 2.0.0\n */\nexport const cubicCatmullRom: Matrix4x4.Matrix4x4 = cubicCardinal(0.5)\n\n/**\n * Applies a characteristic matrix to N channels of control values, producing\n * N cubic polynomials in monomial form.\n *\n * Each channel is a `Vector4` packing one axis's values across the four\n * control points: `(v₀, v₁, v₂, v₃)`. The result tuple has the same arity\n * as the input.\n *\n * The polynomial 2D spline pipeline applies this with two channels (x, y);\n * the rational 2D pipeline uses three (x, y, w) where `w` is the projective\n * denominator. Higher channel counts generalize to 3D, rational 3D, and\n * beyond — the characteristic matrix doesn't care about the geometric\n * domain, only about how to combine four samples per channel.\n *\n * @param matrix - The characteristic matrix of the spline family.\n * @param channels - One `Vector4` per output polynomial, packing the four control values for that channel.\n * @returns A tuple of cubic polynomials, one per input channel.\n * @since 2.0.0\n */\nexport const apply = <const Channels extends ReadonlyArray<Vector4.Vector4>>(\n  matrix: Matrix4x4.Matrix4x4,\n  ...channels: Channels\n): { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial } => {\n  const result = channels.map((c) =>\n    CubicPolynomial.fromVector(Matrix4x4.vectorProductLeft(matrix, c)),\n  )\n  return result as { readonly [K in keyof Channels]: CubicPolynomial.CubicPolynomial }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAeA,MAAa,cAAmCA,KAC9C,GACA,GACA,GACA,GACA,IACA,GACA,GACA,GACA,GACA,IACA,GACA,GACA,IACA,GACA,IACA,EACD;;;;;;;;;AAUD,MAAa,eAAoCA,KAC/C,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,IACA,IACA,GACA,IACA,GACA,GACA,IACA,EACD;;;;;;;;;;;AAYD,MAAa,mBAAwCA,KACnD,IAAI,GACJ,IAAI,GACJ,UAAU,IAAI,EAAE,EAChB,GACA,KACA,GACA,IACA,GACA,IACA,IACA,IACA,GACA,KAAK,GACL,IACA,KACA,IAAI,EACL;AAED,MAAM,gCAAgB,IAAI,KAAkC;;;;;;;;;;;;;;;;;;AAmB5D,MAAa,iBAAiB,YAAyC;CACrE,IAAI,IAAI,cAAc,IAAI,QAAQ;CAClC,IAAI,MAAM,KAAA,GAAW;EACnB,IAAIA,KACF,GACA,GACA,GACA,GACA,CAAC,SACD,GACA,SACA,GACA,IAAI,SACJ,UAAU,GACV,IAAI,IAAI,SACR,CAAC,SACD,CAAC,SACD,IAAI,SACJ,UAAU,GACV,QACD;EACD,cAAc,IAAI,SAAS,EAAE;;CAE/B,OAAO;;;;;;;;;AAUT,MAAa,kBAAuC,cAAc,GAAI;;;;;;;;;;;;;;;;;;;;AAqBtE,MAAa,SACX,QACA,GAAG,aACqE;CAIxE,OAHe,SAAS,KAAK,MAC3BC,WAA2BC,kBAA4B,QAAQ,EAAE,CAAC,CAEvD"}