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

package/dist/shared/{rationalCubic2d-D5g3_hTV.mjs → rationalCubic2d-CeHgpNht.mjs}

@@ -3,11 +3,12 @@ import { Pipeable, dual, invariant } from "../utils.mjs";
 import { a as make, i as magnitude, n as cross } from "./vector2-CSkaMXvp.mjs";
 import { n as transpose } from "./vector4-PO_7EYd-.mjs";
 import { l as scaleShift, m as unitOpen, p as unit, t as biunit, u as size } from "./interval-Dm35Xhy4.mjs";
-import { a as match, i as map, o as none, s as one, t as clip } from "./solution-B6KY1E7M.mjs";
-import { A as GL32_X1, B as GL32_X5, C as GL32_W4, D as GL32_W8, E as GL32_W7, F as GL32_X14, H as GL32_X7, I as GL32_X15, L as GL32_X2, M as GL32_X11, N as GL32_X12, O as GL32_W9, P as GL32_X13, R as GL32_X3, S as GL32_W3, T as GL32_W6, U as GL32_X8, V as GL32_X6, W as GL32_X9, _ as GL32_W12, a as isIncreasing$6, b as GL32_W15, c as roots, d as subdivide$2, f as unitRange, g as GL32_W11, h as GL32_W10, i as isDecreasing$6, j as GL32_X10, k as GL32_X0, l as solve$8, m as GL32_W1, n as derivative$5, o as isMonotonic$6, p as GL32_W0, s as make$1, u as solveInverse, v as GL32_W13, w as GL32_W5, x as GL32_W2, y as GL32_W14, z as GL32_X4 } from "./cubic-DHJrzZJN.mjs";
-import { _ as unitRange$1, a as make$3, c as solveInverse$2, d as isIncreasing$7, f as isMonotonic$7, g as solveInverse$1, h as solve$9, i as isMonotonic$8, l as unitRange$2, m as make$2, n as isDecreasing$8, r as isIncreasing$8, s as solve$10, t as derivative$6, u as isDecreasing$7 } from "./quadratic-BZmfZE71.mjs";
-import { i as maxDistance, r as make$4, t as fromVectors } from "./interval2d-DPmvk_Qe.mjs";
-import { i as cubicBezier, t as apply } from "./characteristic-Hb7F8SBw.mjs";
+import { n as isStrict } from "./monotonicity-BdebFOtv.mjs";
+import { a as match, i as map, o as none, s as one, t as clip } from "./solution-B2JdOZpe.mjs";
+import { A as GL32_X1, B as GL32_X5, C as GL32_W4, D as GL32_W8, E as GL32_W7, F as GL32_X14, H as GL32_X7, I as GL32_X15, L as GL32_X2, M as GL32_X11, N as GL32_X12, O as GL32_W9, P as GL32_X13, R as GL32_X3, S as GL32_W3, T as GL32_W6, U as GL32_X8, V as GL32_X6, W as GL32_X9, _ as GL32_W12, a as isIncreasing$8, b as GL32_W15, c as roots, d as subdivide$2, f as unitRange, g as GL32_W11, h as GL32_W10, i as isDecreasing$8, j as GL32_X10, k as GL32_X0, l as solve$8, m as GL32_W1, n as derivative$5, o as isMonotonic$8, p as GL32_W0, s as make$1, u as solveInverse, v as GL32_W13, w as GL32_W5, x as GL32_W2, y as GL32_W14, z as GL32_X4 } from "./cubic-BL6dpuHh.mjs";
+import { _ as unitRange$1, a as make$3, c as solveInverse$2, d as isIncreasing$9, f as isMonotonic$9, g as solveInverse$1, h as solve$9, i as isMonotonic$10, l as unitRange$2, m as make$2, n as isDecreasing$10, r as isIncreasing$10, s as solve$10, t as derivative$6, u as isDecreasing$9 } from "./quadratic-DPrUsFCp.mjs";
+import { a as union, i as maxDistance, r as make$4, t as fromVectors } from "./interval2d-AtneyI45.mjs";
+import { i as cubicBezier, t as apply } from "./characteristic-BkEr-rr8.mjs";
 //#region src/curve/linear2d.internal.ts
 const LinearCurve2dTypeId = Symbol("curvy/curve/linear2d");
 /** @internal */
@@ -54,35 +55,35 @@ const length$5 = dual(2, (c, i) => Math.sqrt(c.x.c1 ** 2 + c.y.c1 ** 2) * Math.a
 /** @internal */
 const boundingBox$7 = (c) => make$4(unitRange$1(c.x), unitRange$1(c.y));
 /** @internal */
-const isMonotonic$5 = (c) => isMonotonic$7(c.x) && isMonotonic$7(c.y);
+const isMonotonic$7 = (c) => isMonotonic$9(c.x) && isMonotonic$9(c.y);
 /** @internal */
-const isIncreasing$5 = (c) => isIncreasing$7(c.x) && isIncreasing$7(c.y);
+const isIncreasing$7 = (c) => isIncreasing$9(c.x) && isIncreasing$9(c.y);
 /** @internal */
-const isDecreasing$5 = (c) => isDecreasing$7(c.x) && isDecreasing$7(c.y);
-const fail$2 = (m) => {
+const isDecreasing$7 = (c) => isDecreasing$9(c.x) && isDecreasing$9(c.y);
+const fail$3 = (m) => {
 	throw new Error(m);
 };
 /** @internal */
-const asMonotonic$5 = (c) => isMonotonic$5(c) ? c : fail$2("linear curve is not monotonic in both axes");
+const asMonotonic$7 = (c) => isMonotonic$7(c) ? c : fail$3("linear curve is not monotonic in both axes");
 /** @internal */
-const asIncreasing$5 = (c) => isIncreasing$5(c) ? c : fail$2("linear curve is not increasing in both axes");
+const asIncreasing$7 = (c) => isIncreasing$7(c) ? c : fail$3("linear curve is not increasing in both axes");
 /** @internal */
-const asDecreasing$5 = (c) => isDecreasing$5(c) ? c : fail$2("linear curve is not decreasing in both axes");
+const asDecreasing$7 = (c) => isDecreasing$7(c) ? c : fail$3("linear curve is not decreasing in both axes");
 //#endregion
 //#region src/curve/linear2d.ts
 var linear2d_exports = /* @__PURE__ */ __exportAll({
-	asDecreasing: () => asDecreasing$4,
-	asIncreasing: () => asIncreasing$4,
-	asMonotonic: () => asMonotonic$4,
+	asDecreasing: () => asDecreasing$6,
+	asIncreasing: () => asIncreasing$6,
+	asMonotonic: () => asMonotonic$6,
 	boundingBox: () => boundingBox$6,
 	derivative: () => derivative$3,
 	fromCoefficients: () => fromCoefficients$4,
 	fromEndpoints: () => fromEndpoints,
 	fromPolynomials: () => fromPolynomials$6,
-	isDecreasing: () => isDecreasing$4,
-	isIncreasing: () => isIncreasing$4,
+	isDecreasing: () => isDecreasing$6,
+	isIncreasing: () => isIncreasing$6,
 	isLinearCurve2d: () => isLinearCurve2d,
-	isMonotonic: () => isMonotonic$4,
+	isMonotonic: () => isMonotonic$6,
 	length: () => length$4,
 	solve: () => solve$6,
 	solveAtX: () => solveAtX$6,
@@ -163,37 +164,37 @@ const solveAtY$6 = solveAtY$7;
 *
 * @since 2.0.0
 */
-const isMonotonic$4 = isMonotonic$5;
+const isMonotonic$6 = isMonotonic$7;
 /**
 * Type-narrowing predicate: refines both axes' traits to include `Increasing`.
 *
 * @since 2.0.0
 */
-const isIncreasing$4 = isIncreasing$5;
+const isIncreasing$6 = isIncreasing$7;
 /**
 * Type-narrowing predicate: refines both axes' traits to include `Decreasing`.
 *
 * @since 2.0.0
 */
-const isDecreasing$4 = isDecreasing$5;
+const isDecreasing$6 = isDecreasing$7;
 /**
 * Asserts monotonicity in both axes, throwing on failure.
 *
 * @since 2.0.0
 */
-const asMonotonic$4 = asMonotonic$5;
+const asMonotonic$6 = asMonotonic$7;
 /**
 * Asserts that both axes are strictly increasing, throwing on failure.
 *
 * @since 2.0.0
 */
-const asIncreasing$4 = asIncreasing$5;
+const asIncreasing$6 = asIncreasing$7;
 /**
 * Asserts that both axes are strictly decreasing, throwing on failure.
 *
 * @since 2.0.0
 */
-const asDecreasing$4 = asDecreasing$5;
+const asDecreasing$6 = asDecreasing$7;
 //#endregion
 //#region src/curve/quadratic2d.internal.ts
 const QuadraticCurve2dTypeId = Symbol("curvy/curve/quadratic2d");
@@ -254,35 +255,35 @@ const curvature$3 = dual(2, (c, t) => {
 /** @internal */
 const boundingBox$5 = (c) => make$4(unitRange$2(c.x), unitRange$2(c.y));
 /** @internal */
-const isMonotonic$3 = (c) => isMonotonic$8(c.x, unit) && isMonotonic$8(c.y, unit);
+const isMonotonic$5 = (c) => isMonotonic$10(c.x, unit) && isMonotonic$10(c.y, unit);
 /** @internal */
-const isIncreasing$3 = (c) => isIncreasing$8(c.x, unit) && isIncreasing$8(c.y, unit);
+const isIncreasing$5 = (c) => isIncreasing$10(c.x, unit) && isIncreasing$10(c.y, unit);
 /** @internal */
-const isDecreasing$3 = (c) => isDecreasing$8(c.x, unit) && isDecreasing$8(c.y, unit);
-const fail$1 = (m) => {
+const isDecreasing$5 = (c) => isDecreasing$10(c.x, unit) && isDecreasing$10(c.y, unit);
+const fail$2 = (m) => {
 	throw new Error(m);
 };
 /** @internal */
-const asMonotonic$3 = (c) => isMonotonic$3(c) ? c : fail$1("quadratic curve is not monotonic in both axes");
+const asMonotonic$5 = (c) => isMonotonic$5(c) ? c : fail$2("quadratic curve is not monotonic in both axes");
 /** @internal */
-const asIncreasing$3 = (c) => isIncreasing$3(c) ? c : fail$1("quadratic curve is not increasing in both axes");
+const asIncreasing$5 = (c) => isIncreasing$5(c) ? c : fail$2("quadratic curve is not increasing in both axes");
 /** @internal */
-const asDecreasing$3 = (c) => isDecreasing$3(c) ? c : fail$1("quadratic curve is not decreasing in both axes");
+const asDecreasing$5 = (c) => isDecreasing$5(c) ? c : fail$2("quadratic curve is not decreasing in both axes");
 //#endregion
 //#region src/curve/quadratic2d.ts
 var quadratic2d_exports = /* @__PURE__ */ __exportAll({
-	asDecreasing: () => asDecreasing$2,
-	asIncreasing: () => asIncreasing$2,
-	asMonotonic: () => asMonotonic$2,
+	asDecreasing: () => asDecreasing$4,
+	asIncreasing: () => asIncreasing$4,
+	asMonotonic: () => asMonotonic$4,
 	boundingBox: () => boundingBox$4,
 	curvature: () => curvature$2,
 	derivative: () => derivative$1,
 	fromBezierPoints: () => fromBezierPoints$4,
 	fromCoefficients: () => fromCoefficients$2,
 	fromPolynomials: () => fromPolynomials$4,
-	isDecreasing: () => isDecreasing$2,
-	isIncreasing: () => isIncreasing$2,
-	isMonotonic: () => isMonotonic$2,
+	isDecreasing: () => isDecreasing$4,
+	isIncreasing: () => isIncreasing$4,
+	isMonotonic: () => isMonotonic$4,
 	isQuadraticCurve2d: () => isQuadraticCurve2d,
 	length: () => length$2,
 	solve: () => solve$4,
@@ -368,17 +369,17 @@ const boundingBox$4 = boundingBox$5;
 *
 * @since 2.0.0
 */
-const isMonotonic$2 = isMonotonic$3;
+const isMonotonic$4 = isMonotonic$5;
 /** @since 2.0.0 */
-const isIncreasing$2 = isIncreasing$3;
+const isIncreasing$4 = isIncreasing$5;
 /** @since 2.0.0 */
-const isDecreasing$2 = isDecreasing$3;
+const isDecreasing$4 = isDecreasing$5;
 /** @since 2.0.0 */
-const asMonotonic$2 = asMonotonic$3;
+const asMonotonic$4 = asMonotonic$5;
 /** @since 2.0.0 */
-const asIncreasing$2 = asIncreasing$3;
+const asIncreasing$4 = asIncreasing$5;
 /** @since 2.0.0 */
-const asDecreasing$2 = asDecreasing$3;
+const asDecreasing$4 = asDecreasing$5;
 //#endregion
 //#region src/curve/cubic2d.internal.ts
 const CubicCurve2dTypeId = Symbol("curvy/curve/cubic2d");
@@ -446,35 +447,35 @@ const curvature$1 = dual(2, (c, t) => {
 /** @internal */
 const boundingBox$3 = (c) => make$4(unitRange(c.x), unitRange(c.y));
 /** @internal */
-const isMonotonic$1 = (c) => isMonotonic$6(c.x, unit) && isMonotonic$6(c.y, unit);
+const isMonotonic$3 = (c) => isMonotonic$8(c.x, unit) && isMonotonic$8(c.y, unit);
 /** @internal */
-const isIncreasing$1 = (c) => isIncreasing$6(c.x, unit) && isIncreasing$6(c.y, unit);
+const isIncreasing$3 = (c) => isIncreasing$8(c.x, unit) && isIncreasing$8(c.y, unit);
 /** @internal */
-const isDecreasing$1 = (c) => isDecreasing$6(c.x, unit) && isDecreasing$6(c.y, unit);
-const fail = (m) => {
+const isDecreasing$3 = (c) => isDecreasing$8(c.x, unit) && isDecreasing$8(c.y, unit);
+const fail$1 = (m) => {
 	throw new Error(m);
 };
 /** @internal */
-const asMonotonic$1 = (c) => isMonotonic$1(c) ? c : fail("cubic curve is not monotonic in both axes");
+const asMonotonic$3 = (c) => isMonotonic$3(c) ? c : fail$1("cubic curve is not monotonic in both axes");
 /** @internal */
-const asIncreasing$1 = (c) => isIncreasing$1(c) ? c : fail("cubic curve is not increasing in both axes");
+const asIncreasing$3 = (c) => isIncreasing$3(c) ? c : fail$1("cubic curve is not increasing in both axes");
 /** @internal */
-const asDecreasing$1 = (c) => isDecreasing$1(c) ? c : fail("cubic curve is not decreasing in both axes");
+const asDecreasing$3 = (c) => isDecreasing$3(c) ? c : fail$1("cubic curve is not decreasing in both axes");
 //#endregion
 //#region src/curve/cubic2d.ts
 var cubic2d_exports = /* @__PURE__ */ __exportAll({
-	asDecreasing: () => asDecreasing,
-	asIncreasing: () => asIncreasing,
-	asMonotonic: () => asMonotonic,
+	asDecreasing: () => asDecreasing$2,
+	asIncreasing: () => asIncreasing$2,
+	asMonotonic: () => asMonotonic$2,
 	boundingBox: () => boundingBox$2,
 	curvature: () => curvature,
 	fromBezierPoints: () => fromBezierPoints$2,
 	fromCoefficients: () => fromCoefficients,
 	fromPolynomials: () => fromPolynomials$2,
 	isCubicCurve2d: () => isCubicCurve2d,
-	isDecreasing: () => isDecreasing,
-	isIncreasing: () => isIncreasing,
-	isMonotonic: () => isMonotonic,
+	isDecreasing: () => isDecreasing$2,
+	isIncreasing: () => isIncreasing$2,
+	isMonotonic: () => isMonotonic$2,
 	length: () => length,
 	solve: () => solve$2,
 	solveAtX: () => solveAtX$2,
@@ -552,17 +553,17 @@ const boundingBox$2 = boundingBox$3;
 *
 * @since 2.0.0
 */
-const isMonotonic = isMonotonic$1;
+const isMonotonic$2 = isMonotonic$3;
 /** @since 2.0.0 */
-const isIncreasing = isIncreasing$1;
+const isIncreasing$2 = isIncreasing$3;
 /** @since 2.0.0 */
-const isDecreasing = isDecreasing$1;
+const isDecreasing$2 = isDecreasing$3;
 /** @since 2.0.0 */
-const asMonotonic = asMonotonic$1;
+const asMonotonic$2 = asMonotonic$3;
 /** @since 2.0.0 */
-const asIncreasing = asIncreasing$1;
+const asIncreasing$2 = asIncreasing$3;
 /** @since 2.0.0 */
-const asDecreasing = asDecreasing$1;
+const asDecreasing$2 = asDecreasing$3;
 //#endregion
 //#region src/curve/rationalCubic2d.internal.ts
 const RationalCubicCurve2dTypeId = Symbol("curvy/curve/rationalCubic2d");
@@ -632,6 +633,128 @@ const solve$1 = dual(2, (c, t) => {
 const solveAtX$1 = dual(2, (c, x) => make$1(c.x.c0 - x * c.w.c0, c.x.c1 - x * c.w.c1, c.x.c2 - x * c.w.c2, c.x.c3 - x * c.w.c3).pipe(roots, clip(unit), map((t) => solve$8(c.y, t) / solve$8(c.w, t))));
 /** @internal */
 const solveAtY$1 = dual(2, (c, y) => make$1(c.y.c0 - y * c.w.c0, c.y.c1 - y * c.w.c1, c.y.c2 - y * c.w.c2, c.y.c3 - y * c.w.c3).pipe(roots, clip(unit), map((t) => solve$8(c.x, t) / solve$8(c.w, t))));
+const derivativeNumeratorQuartic = (n, d) => [
+	n.c1 * d.c0 - n.c0 * d.c1,
+	2 * (n.c2 * d.c0 - n.c0 * d.c2),
+	n.c2 * d.c1 - n.c1 * d.c2 + 3 * (n.c3 * d.c0 - n.c0 * d.c3),
+	2 * (n.c3 * d.c1 - n.c1 * d.c3),
+	n.c3 * d.c2 - n.c2 * d.c3
+];
+const bernsteinFromQuarticMonomial = (c0, c1, c2, c3, c4) => [
+	c0,
+	c0 + c1 / 4,
+	c0 + c1 / 2 + c2 / 6,
+	c0 + 3 * c1 / 4 + c2 / 2 + c3 / 4,
+	c0 + c1 + c2 + c3 + c4
+];
+const BERNSTEIN_SIGN_MAX_DEPTH = 32;
+const certifyBernsteinSign = (bs, depth = 0) => {
+	let m = 0;
+	for (let i = 0; i < 5; i++) {
+		const b = bs[i];
+		if (b > 0) m = m | 1;
+		else if (b < 0) m = m | 2;
+	}
+	if (m !== 3) return m;
+	if (depth >= BERNSTEIN_SIGN_MAX_DEPTH) return 3;
+	const [b0, b1, b2, b3, b4] = bs;
+	const c0 = (b0 + b1) * .5;
+	const c1 = (b1 + b2) * .5;
+	const c2 = (b2 + b3) * .5;
+	const c3 = (b3 + b4) * .5;
+	const d0 = (c0 + c1) * .5;
+	const d1 = (c1 + c2) * .5;
+	const d2 = (c2 + c3) * .5;
+	const e0 = (d0 + d1) * .5;
+	const e1 = (d1 + d2) * .5;
+	const f = (e0 + e1) * .5;
+	return certifyBernsteinSign([
+		b0,
+		c0,
+		d0,
+		e0,
+		f
+	], depth + 1) | certifyBernsteinSign([
+		f,
+		e1,
+		d2,
+		c3,
+		b4
+	], depth + 1);
+};
+const axisMonotonicity = (numerator, denominator) => {
+	const [q0, q1, q2, q3, q4] = derivativeNumeratorQuartic(numerator, denominator);
+	return certifyBernsteinSign(bernsteinFromQuarticMonomial(q0, q1, q2, q3, q4));
+};
+/** @internal */
+const xMonotonicity$1 = (c) => axisMonotonicity(c.x, c.w);
+/** @internal */
+const yMonotonicity$1 = (c) => axisMonotonicity(c.y, c.w);
+/** @internal */
+const isMonotonicX$1 = (c) => isStrict(xMonotonicity$1(c));
+/** @internal */
+const isIncreasingX$1 = (c) => xMonotonicity$1(c) === 1;
+/** @internal */
+const isDecreasingX$1 = (c) => xMonotonicity$1(c) === 2;
+/** @internal */
+const isMonotonicY$1 = (c) => isStrict(yMonotonicity$1(c));
+/** @internal */
+const isIncreasingY$1 = (c) => yMonotonicity$1(c) === 1;
+/** @internal */
+const isDecreasingY$1 = (c) => yMonotonicity$1(c) === 2;
+/** @internal */
+const isMonotonic$1 = (c) => isMonotonicX$1(c) && isMonotonicY$1(c);
+/** @internal */
+const isIncreasing$1 = (c) => isIncreasingX$1(c) && isIncreasingY$1(c);
+/** @internal */
+const isDecreasing$1 = (c) => isDecreasingX$1(c) && isDecreasingY$1(c);
+const fail = (m) => {
+	throw new Error(m);
+};
+/** @internal */
+const asMonotonicX$1 = (c) => isMonotonicX$1(c) ? c : fail("rational cubic curve is not monotonic in x");
+/** @internal */
+const asIncreasingX$1 = (c) => isIncreasingX$1(c) ? c : fail("rational cubic curve is not increasing in x");
+/** @internal */
+const asDecreasingX$1 = (c) => isDecreasingX$1(c) ? c : fail("rational cubic curve is not decreasing in x");
+/** @internal */
+const asMonotonicY$1 = (c) => isMonotonicY$1(c) ? c : fail("rational cubic curve is not monotonic in y");
+/** @internal */
+const asIncreasingY$1 = (c) => isIncreasingY$1(c) ? c : fail("rational cubic curve is not increasing in y");
+/** @internal */
+const asDecreasingY$1 = (c) => isDecreasingY$1(c) ? c : fail("rational cubic curve is not decreasing in y");
+/** @internal */
+const asMonotonic$1 = (c) => isMonotonic$1(c) ? c : fail("rational cubic curve is not monotonic in both axes");
+/** @internal */
+const asIncreasing$1 = (c) => isIncreasing$1(c) ? c : fail("rational cubic curve is not increasing in both axes");
+/** @internal */
+const asDecreasing$1 = (c) => isDecreasing$1(c) ? c : fail("rational cubic curve is not decreasing in both axes");
+const MAX_BBOX_DEPTH = 20;
+/** @internal */
+const boundingBox$1 = dual(2, (c, tolerance) => {
+	invariant(Number.isFinite(tolerance) && tolerance > 0, "boundingBox: tolerance must be finite and > 0");
+	if (c.w.c1 === 0 && c.w.c2 === 0 && c.w.c3 === 0) {
+		const w = c.w.c0;
+		return make$4(unitRange(make$1(c.x.c0 / w, c.x.c1 / w, c.x.c2 / w, c.x.c3 / w)), unitRange(make$1(c.y.c0 / w, c.y.c1 / w, c.y.c2 / w, c.y.c3 / w)));
+	}
+	const recurse = (curr, depth) => {
+		const hull = hullBoundingBox(curr);
+		const w0 = curr.w.c0;
+		const x0 = curr.x.c0 / w0;
+		const y0 = curr.y.c0 / w0;
+		const w1 = curr.w.c0 + curr.w.c1 + curr.w.c2 + curr.w.c3;
+		const x1 = (curr.x.c0 + curr.x.c1 + curr.x.c2 + curr.x.c3) / w1;
+		const y1 = (curr.y.c0 + curr.y.c1 + curr.y.c2 + curr.y.c3) / w1;
+		const lowX = Math.min(x0, x1);
+		const highX = Math.max(x0, x1);
+		const lowY = Math.min(y0, y1);
+		const highY = Math.max(y0, y1);
+		if (Math.max(lowX - hull.x.start, hull.x.end - highX, lowY - hull.y.start, hull.y.end - highY) <= tolerance || depth >= MAX_BBOX_DEPTH) return hull;
+		const [left, right] = subdivide$1(curr, .5);
+		return union(recurse(left, depth + 1), recurse(right, depth + 1));
+	};
+	return recurse(c, 0);
+});
 const MAX_APPROX_DEPTH = 20;
 const buildCubicCandidate = (c) => {
 	const x0 = c.x.c0;
@@ -655,8 +778,7 @@ const subdivide$1 = dual(2, (c, t) => {
 	const [leftW, rightW] = subdivide$2(c.w, t);
 	return [new RationalCubicCurve2dImpl(leftX, leftY, leftW), new RationalCubicCurve2dImpl(rightX, rightY, rightW)];
 });
-/** @internal */
-const boundingBox$1 = (c) => {
+const hullBoundingBox = (c) => {
 	const x0 = c.x.c0;
 	const x1 = c.x.c0 + c.x.c1 / 3;
 	const x2 = c.x.c0 + 2 * c.x.c1 / 3 + c.x.c2 / 3;
@@ -747,7 +869,7 @@ const rationalPiece = (c, depth = 0) => {
 	const witnessX = solve$8(c.x, .5) / wMid;
 	const witnessY = solve$8(c.y, .5) / wMid;
 	return {
-		box: boundingBox$1(c),
+		box: hullBoundingBox(c),
 		witnessX,
 		witnessY,
 		depth,
@@ -791,7 +913,7 @@ const hausdorffWithinTolerance = (rational, candidate, tolerance) => {
 	if (rational.w.c1 === 0 && rational.w.c2 === 0 && rational.w.c3 === 0) return true;
 	const candidateBox = boundingBox$2(candidate);
 	if (!oneSidedWithinTolerance(rationalPiece(rational), candidateBox, (qx, qy) => closestSquaredDistance((s) => polynomialEval(candidate, s), qx, qy), tolerance)) return false;
-	const rationalBox = boundingBox$1(rational);
+	const rationalBox = hullBoundingBox(rational);
 	return oneSidedWithinTolerance(polynomialPiece(candidate), rationalBox, (qx, qy) => closestSquaredDistance((s) => rationalEval(rational, s), qx, qy), tolerance);
 };
 /** @internal */
@@ -816,15 +938,35 @@ const approximateAsCubicCurves$1 = dual(2, (c, tolerance) => {
 var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
 	RationalCurveTraits: () => RationalCurveTraits,
 	approximateAsCubicCurves: () => approximateAsCubicCurves,
+	asDecreasing: () => asDecreasing,
+	asDecreasingX: () => asDecreasingX,
+	asDecreasingY: () => asDecreasingY,
+	asIncreasing: () => asIncreasing,
+	asIncreasingX: () => asIncreasingX,
+	asIncreasingY: () => asIncreasingY,
+	asMonotonic: () => asMonotonic,
+	asMonotonicX: () => asMonotonicX,
+	asMonotonicY: () => asMonotonicY,
 	boundingBox: () => boundingBox,
 	fromBezierPoints: () => fromBezierPoints,
 	fromPolynomials: () => fromPolynomials,
+	isDecreasing: () => isDecreasing,
+	isDecreasingX: () => isDecreasingX,
+	isDecreasingY: () => isDecreasingY,
+	isIncreasing: () => isIncreasing,
+	isIncreasingX: () => isIncreasingX,
+	isIncreasingY: () => isIncreasingY,
+	isMonotonic: () => isMonotonic,
+	isMonotonicX: () => isMonotonicX,
+	isMonotonicY: () => isMonotonicY,
 	isRationalCubicCurve2d: () => isRationalCubicCurve2d,
 	makeMonotonicEasing: () => makeMonotonicEasing,
 	solve: () => solve,
 	solveAtX: () => solveAtX,
 	solveAtY: () => solveAtY,
-	subdivide: () => subdivide
+	subdivide: () => subdivide,
+	xMonotonicity: () => xMonotonicity,
+	yMonotonicity: () => yMonotonicity
 });
 /**
 * Checks if a value is a `RationalCubicCurve2d`.
@@ -886,24 +1028,176 @@ const solve = solve$1;
 const solveAtX = solveAtX$1;
 const solveAtY = solveAtY$1;
 const subdivide = subdivide$1;
+const boundingBox = boundingBox$1;
 /**
-* 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.
+* 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`.
 *
-* Suitable for subdivision-based geometric queries, where bound looseness is
-* compensated by recursion depth.
+* Returning `Increasing` or `Decreasing` is the trigger for
+* {@link asMonotonic} / {@link asIncreasing} / {@link asDecreasing}.
 *
 * @param c - The rational cubic curve.
-* @returns A closed `Interval2d` enclosing the curve.
+* @returns The monotonicity of the curve's x projection on `[0, 1]`.
 * @since 2.0.0
 */
-const boundingBox = boundingBox$1;
+const xMonotonicity = xMonotonicity$1;
+/**
+* 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
+*/
+const yMonotonicity = yMonotonicity$1;
+/**
+* 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
+*/
+const isMonotonicX = isMonotonicX$1;
+/**
+* Type-narrowing predicate: refines the curve's x-axis trait to include
+* `Increasing`.
+*
+* @since 2.0.0
+*/
+const isIncreasingX = isIncreasingX$1;
+/**
+* Type-narrowing predicate: refines the curve's x-axis trait to include
+* `Decreasing`.
+*
+* @since 2.0.0
+*/
+const isDecreasingX = isDecreasingX$1;
+/**
+* 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
+*/
+const isMonotonicY = isMonotonicY$1;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Increasing`.
+*
+* @since 2.0.0
+*/
+const isIncreasingY = isIncreasingY$1;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Decreasing`.
+*
+* @since 2.0.0
+*/
+const isDecreasingY = isDecreasingY$1;
+/**
+* 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
+*/
+const isMonotonic = isMonotonic$1;
+/**
+* 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
+*/
+const isIncreasing = isIncreasing$1;
+/**
+* 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
+*/
+const isDecreasing = isDecreasing$1;
+/**
+* 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
+*/
+const asMonotonicX = asMonotonicX$1;
+/**
+* Asserts that the curve is strictly increasing in x on `[0, 1]`.
+*
+* @since 2.0.0
+*/
+const asIncreasingX = asIncreasingX$1;
+/**
+* Asserts that the curve is strictly decreasing in x on `[0, 1]`.
+*
+* @since 2.0.0
+*/
+const asDecreasingX = asDecreasingX$1;
+/**
+* Asserts that the curve is strictly monotonic in y on `[0, 1]`. y analog of
+* {@link asMonotonicX}.
+*
+* @since 2.0.0
+*/
+const asMonotonicY = asMonotonicY$1;
+/**
+* Asserts that the curve is strictly increasing in y on `[0, 1]`.
+*
+* @since 2.0.0
+*/
+const asIncreasingY = asIncreasingY$1;
+/**
+* Asserts that the curve is strictly decreasing in y on `[0, 1]`.
+*
+* @since 2.0.0
+*/
+const asDecreasingY = asDecreasingY$1;
+/**
+* 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 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
+*/
+const asMonotonic = asMonotonic$1;
+/**
+* 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
+*/
+const asIncreasing = asIncreasing$1;
+/**
+* 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
+*/
+const asDecreasing = asDecreasing$1;
 const approximateAsCubicCurves = approximateAsCubicCurves$1;
 //#endregion
-export { linear2d_exports as C, solveAtY$6 as E, length$4 as S, solveAtX$6 as T, solve$4 as _, boundingBox$2 as a, boundingBox$6 as b, fromPolynomials$2 as c, solveAtX$2 as d, solveAtY$2 as f, quadratic2d_exports as g, length$2 as h, solve as i, length as l, boundingBox$4 as m, fromBezierPoints as n, cubic2d_exports as o, derivative as p, rationalCubic2d_exports as r, fromCoefficients as s, approximateAsCubicCurves as t, solve$2 as u, solveAtX$4 as v, solve$6 as w, fromEndpoints as x, solveAtY$4 as y };
+export { length$4 as C, solveAtY$6 as D, solveAtX$6 as E, fromEndpoints as S, solve$6 as T, quadratic2d_exports as _, solve as a, solveAtY$4 as b, fromCoefficients as c, solve$2 as d, solveAtX$2 as f, length$2 as g, boundingBox$4 as h, rationalCubic2d_exports as i, fromPolynomials$2 as l, derivative as m, boundingBox as n, boundingBox$2 as o, solveAtY$2 as p, fromBezierPoints as r, cubic2d_exports as s, approximateAsCubicCurves as t, length as u, solve$4 as v, linear2d_exports as w, boundingBox$6 as x, solveAtX$4 as y };
 
-//# sourceMappingURL=rationalCubic2d-D5g3_hTV.mjs.map
+//# sourceMappingURL=rationalCubic2d-CeHgpNht.mjs.map