curvy 2.0.0-alpha.13 → 2.0.0-alpha.14

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

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
 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 { 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";
+import { a as magnitude, n as cross, o as make, s as makeWeighted } from "./vector2-DuA3EmfL.mjs";
+import { n as transpose } from "./vector4-DGHuCvTV.mjs";
+import { d as size, p as unit, t as biunit, u as scaleShift } from "./interval-Dcqpo73t.mjs";
+import { a as map, n as clipApprox, t as clip } from "./solution-BW0BBMXI.mjs";
+import { n as isStrict } from "./monotonicity-DNxBoC7F.mjs";
+import { A as GL32_X0, B as GL32_X4, C as GL32_W3, D as GL32_W7, E as GL32_W6, F as GL32_X13, G as GL32_X9, H as GL32_X6, I as GL32_X14, L as GL32_X15, M as GL32_X10, N as GL32_X11, O as GL32_W8, P as GL32_X12, R as GL32_X2, S as GL32_W2, T as GL32_W5, U as GL32_X7, V as GL32_X5, W as GL32_X8, _ as GL32_W11, a as isIncreasing$8, b as GL32_W14, c as roots, d as subdivide$2, f as toSolver, g as GL32_W10, h as GL32_W1, i as isDecreasing$8, j as GL32_X1, k as GL32_W9, l as solve$8, m as GL32_W0, n as derivative$5, o as isMonotonic$8, p as unitRange, s as make$1, u as solveInverse, v as GL32_W12, w as GL32_W4, x as GL32_W15, y as GL32_W13, z as GL32_X3 } from "./cubic-BiGuAnZ0.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-BmMqkvxx.mjs";
+import { a as union, i as maxDistance, r as make$4, t as fromVectors } from "./interval2d-C2Pk66-2.mjs";
+import { i as cubicBezier, t as apply } from "./characteristic--7nC4Q_a.mjs";
 //#region src/curve/linear2d.internal.ts
 const LinearCurve2dTypeId = Symbol("curvy/curve/linear2d");
 /** @internal */
@@ -41,25 +41,43 @@ const derivative$4 = (c) => make(c.x.c1, c.y.c1);
 /** @internal */
 const solve$7 = dual(2, (c, t) => make(solve$9(c.x, t), solve$9(c.y, t)));
 /** @internal */
-const solveAtX$7 = dual(2, (c, x) => match(solveInverse$1(c.x, x), {
-	onNone: () => none,
-	onSome: ({ value: t }) => t < 0 || t > 1 ? none : one(solve$9(c.y, t))
-}));
+const solveAtX$7 = dual(2, (c, x) => solveInverse$1(c.x, x).pipe(clip(unit), map((t) => solve$9(c.y, t))));
 /** @internal */
-const solveAtY$7 = dual(2, (c, y) => match(solveInverse$1(c.y, y), {
-	onNone: () => none,
-	onSome: ({ value: t }) => t < 0 || t > 1 ? none : one(solve$9(c.x, t))
-}));
+const solveAtY$7 = dual(2, (c, y) => solveInverse$1(c.y, y).pipe(clip(unit), map((t) => solve$9(c.x, t))));
 /** @internal */
 const length$5 = dual(2, (c, i) => Math.sqrt(c.x.c1 ** 2 + c.y.c1 ** 2) * Math.abs(i.end - i.start));
 /** @internal */
 const boundingBox$7 = (c) => make$4(unitRange$1(c.x), unitRange$1(c.y));
 /** @internal */
-const isMonotonic$7 = (c) => isMonotonic$9(c.x) && isMonotonic$9(c.y);
+const startPoint$7 = (c) => make(c.x.c0, c.y.c0);
 /** @internal */
-const isIncreasing$7 = (c) => isIncreasing$9(c.x) && isIncreasing$9(c.y);
+const endPoint$7 = (c) => make(c.x.c0 + c.x.c1, c.y.c0 + c.y.c1);
 /** @internal */
-const isDecreasing$7 = (c) => isDecreasing$9(c.x) && isDecreasing$9(c.y);
+const xRange$5 = (c) => unitRange$1(c.x);
+/** @internal */
+const yRange$5 = (c) => unitRange$1(c.y);
+/** @internal */
+const toPathDataSegment$5 = (c) => {
+	return `L ${c.x.c0 + c.x.c1},${c.y.c0 + c.y.c1}`;
+};
+/** @internal */
+const isMonotonicX$7 = (c) => isMonotonic$9(c.x);
+/** @internal */
+const isIncreasingX$7 = (c) => isIncreasing$9(c.x);
+/** @internal */
+const isDecreasingX$7 = (c) => isDecreasing$9(c.x);
+/** @internal */
+const isMonotonicY$7 = (c) => isMonotonic$9(c.y);
+/** @internal */
+const isIncreasingY$7 = (c) => isIncreasing$9(c.y);
+/** @internal */
+const isDecreasingY$7 = (c) => isDecreasing$9(c.y);
+/** @internal */
+const isMonotonic$7 = (c) => isMonotonicX$7(c) && isMonotonicY$7(c);
+/** @internal */
+const isIncreasing$7 = (c) => isIncreasingX$7(c) && isIncreasingY$7(c);
+/** @internal */
+const isDecreasing$7 = (c) => isDecreasingX$7(c) && isDecreasingY$7(c);
 const fail$3 = (m) => {
 	throw new Error(m);
 };
@@ -69,25 +87,43 @@ const asMonotonic$7 = (c) => isMonotonic$7(c) ? c : fail$3("linear curve is not
 const asIncreasing$7 = (c) => isIncreasing$7(c) ? c : fail$3("linear curve is not increasing in both axes");
 /** @internal */
 const asDecreasing$7 = (c) => isDecreasing$7(c) ? c : fail$3("linear curve is not decreasing in both axes");
+/** @internal */
+const transform$7 = dual(2, (c, a) => {
+	const m = a.matrix;
+	return new LinearCurve2dImpl(make$2(m.m00 * c.x.c0 + m.m01 * c.y.c0 + m.m02, m.m00 * c.x.c1 + m.m01 * c.y.c1), make$2(m.m10 * c.x.c0 + m.m11 * c.y.c0 + m.m12, m.m10 * c.x.c1 + m.m11 * c.y.c1));
+});
 //#endregion
 //#region src/curve/linear2d.ts
 var linear2d_exports = /* @__PURE__ */ __exportAll({
+	Ops: () => Ops$2,
 	asDecreasing: () => asDecreasing$6,
 	asIncreasing: () => asIncreasing$6,
 	asMonotonic: () => asMonotonic$6,
 	boundingBox: () => boundingBox$6,
 	derivative: () => derivative$3,
+	endPoint: () => endPoint$6,
 	fromCoefficients: () => fromCoefficients$4,
 	fromEndpoints: () => fromEndpoints,
 	fromPolynomials: () => fromPolynomials$6,
 	isDecreasing: () => isDecreasing$6,
+	isDecreasingX: () => isDecreasingX$6,
+	isDecreasingY: () => isDecreasingY$6,
 	isIncreasing: () => isIncreasing$6,
+	isIncreasingX: () => isIncreasingX$6,
+	isIncreasingY: () => isIncreasingY$6,
 	isLinearCurve2d: () => isLinearCurve2d,
 	isMonotonic: () => isMonotonic$6,
+	isMonotonicX: () => isMonotonicX$6,
+	isMonotonicY: () => isMonotonicY$6,
 	length: () => length$4,
 	solve: () => solve$6,
 	solveAtX: () => solveAtX$6,
-	solveAtY: () => solveAtY$6
+	solveAtY: () => solveAtY$6,
+	startPoint: () => startPoint$6,
+	toPathDataSegment: () => toPathDataSegment$4,
+	transform: () => transform$6,
+	xRange: () => xRange$4,
+	yRange: () => yRange$4
 });
 /**
 * Creates a new `LinearCurve2d` instance from polynomial parameters.
@@ -152,16 +188,103 @@ const length$4 = length$5;
 * @since 2.0.0
 */
 const boundingBox$6 = boundingBox$7;
+/**
+* Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+*
+* @param c - The linear curve.
+* @returns The point at the start of the curve's parameter domain.
+* @since 2.0.0
+*/
+const startPoint$6 = startPoint$7;
+/**
+* Evaluates the curve at `t = 1` in closed form — `(c.x.c0 + c.x.c1, c.y.c0 + c.y.c1)`.
+*
+* @param c - The linear curve.
+* @returns The point at the end of the curve's parameter domain.
+* @since 2.0.0
+*/
+const endPoint$6 = endPoint$7;
+/**
+* The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`.
+* For a linear curve this is the closed interval bounded by the two endpoints'
+* x coordinates.
+*
+* @param c - The linear curve.
+* @returns The closed range of x over `[0, 1]`.
+* @since 2.0.0
+*/
+const xRange$4 = xRange$5;
+/**
+* The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`.
+* For a linear curve this is the closed interval bounded by the two endpoints'
+* y coordinates.
+*
+* @param c - The linear curve.
+* @returns The closed range of y over `[0, 1]`.
+* @since 2.0.0
+*/
+const yRange$4 = yRange$5;
+/**
+* Renders the curve as a single SVG path-data drawing command — for a linear
+* curve, `L endX,endY`. Does not include a leading `M`; callers (typically a
+* path-level `toPathData`) decide whether to emit a move based on continuity
+* with the previous segment.
+*
+* @param c - The linear curve.
+* @returns The SVG drawing command for this segment, without a leading `M`.
+* @since 2.0.0
+*/
+const toPathDataSegment$4 = toPathDataSegment$5;
 const solveAtX$6 = solveAtX$7;
 const solveAtY$6 = solveAtY$7;
 /**
+* Type-narrowing predicate: refines the curve's x-axis trait to include
+* `Monotonic` when the x polynomial is strictly monotonic. The y-axis trait
+* is unchanged.
+*
+* @since 2.0.0
+*/
+const isMonotonicX$6 = isMonotonicX$7;
+/**
+* Type-narrowing predicate: refines the curve's x-axis trait to include
+* `Increasing`.
+*
+* @since 2.0.0
+*/
+const isIncreasingX$6 = isIncreasingX$7;
+/**
+* Type-narrowing predicate: refines the curve's x-axis trait to include
+* `Decreasing`.
+*
+* @since 2.0.0
+*/
+const isDecreasingX$6 = isDecreasingX$7;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Monotonic`. The x-axis trait is unchanged.
+*
+* @since 2.0.0
+*/
+const isMonotonicY$6 = isMonotonicY$7;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Increasing`.
+*
+* @since 2.0.0
+*/
+const isIncreasingY$6 = isIncreasingY$7;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Decreasing`.
+*
+* @since 2.0.0
+*/
+const isDecreasingY$6 = isDecreasingY$7;
+/**
 * 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
 */
 const isMonotonic$6 = isMonotonic$7;
@@ -195,6 +318,29 @@ const asIncreasing$6 = asIncreasing$7;
 * @since 2.0.0
 */
 const asDecreasing$6 = asDecreasing$7;
+const transform$6 = transform$7;
+/**
+* The {@link Curve2dOps} bundle for `LinearCurve2d`. Used by
+* `LinearPath2d` (and any user code building a generic `Path2d` over linear
+* curves) to wire up the path-level operation surface.
+*
+* @since 2.0.0
+*/
+const Ops$2 = {
+	solve: solve$6,
+	startPoint: startPoint$6,
+	endPoint: endPoint$6,
+	length: length$4,
+	boundingBox: boundingBox$6,
+	solveAtX: solveAtX$6,
+	solveAtY: solveAtY$6,
+	toPathDataSegment: toPathDataSegment$4,
+	isIncreasingX: isIncreasingX$6,
+	isDecreasingX: isDecreasingX$6,
+	isIncreasingY: isIncreasingY$6,
+	isDecreasingY: isDecreasingY$6,
+	transform: transform$6
+};
 //#endregion
 //#region src/curve/quadratic2d.internal.ts
 const QuadraticCurve2dTypeId = Symbol("curvy/curve/quadratic2d");
@@ -226,13 +372,9 @@ const isQuadraticCurve2d$1 = (c) => typeof c === "object" && c !== null && Quadr
 /** @internal */
 const solve$5 = dual(2, (c, t) => make(solve$10(c.x, t), solve$10(c.y, t)));
 /** @internal */
-const solveAtX$5 = dual(2, (c, x) => {
-	return map(clip(solveInverse$2(c.x, x), unit), (t) => solve$10(c.y, t));
-});
+const solveAtX$5 = dual(2, (c, x) => solveInverse$2(c.x, x).pipe(clipApprox(unit), map((t) => solve$10(c.y, t))));
 /** @internal */
-const solveAtY$5 = dual(2, (c, y) => {
-	return map(clip(solveInverse$2(c.y, y), unit), (t) => solve$10(c.x, t));
-});
+const solveAtY$5 = dual(2, (c, y) => solveInverse$2(c.y, y).pipe(clipApprox(unit), map((t) => solve$10(c.x, t))));
 /** @internal */
 const derivative$2 = (c) => fromPolynomials$6(derivative$6(c.x), derivative$6(c.y));
 /** @internal */
@@ -255,11 +397,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$5 = (c) => isMonotonic$10(c.x, unit) && isMonotonic$10(c.y, unit);
+const startPoint$5 = (c) => make(c.x.c0, c.y.c0);
+/** @internal */
+const endPoint$5 = (c) => make(c.x.c0 + c.x.c1 + c.x.c2, c.y.c0 + c.y.c1 + c.y.c2);
+/** @internal */
+const xRange$3 = (c) => unitRange$2(c.x);
+/** @internal */
+const yRange$3 = (c) => unitRange$2(c.y);
+/** @internal */
+const toPathDataSegment$3 = (c) => {
+	return `Q ${c.x.c0 + c.x.c1 / 2},${c.y.c0 + c.y.c1 / 2} ${c.x.c0 + c.x.c1 + c.x.c2},${c.y.c0 + c.y.c1 + c.y.c2}`;
+};
+/** @internal */
+const isMonotonicX$5 = (c) => isMonotonic$10(c.x, unit);
+/** @internal */
+const isIncreasingX$5 = (c) => isIncreasing$10(c.x, unit);
+/** @internal */
+const isDecreasingX$5 = (c) => isDecreasing$10(c.x, unit);
+/** @internal */
+const isMonotonicY$5 = (c) => isMonotonic$10(c.y, unit);
 /** @internal */
-const isIncreasing$5 = (c) => isIncreasing$10(c.x, unit) && isIncreasing$10(c.y, unit);
+const isIncreasingY$5 = (c) => isIncreasing$10(c.y, unit);
 /** @internal */
-const isDecreasing$5 = (c) => isDecreasing$10(c.x, unit) && isDecreasing$10(c.y, unit);
+const isDecreasingY$5 = (c) => isDecreasing$10(c.y, unit);
+/** @internal */
+const isMonotonic$5 = (c) => isMonotonicX$5(c) && isMonotonicY$5(c);
+/** @internal */
+const isIncreasing$5 = (c) => isIncreasingX$5(c) && isIncreasingY$5(c);
+/** @internal */
+const isDecreasing$5 = (c) => isDecreasingX$5(c) && isDecreasingY$5(c);
 const fail$2 = (m) => {
 	throw new Error(m);
 };
@@ -269,26 +435,44 @@ const asMonotonic$5 = (c) => isMonotonic$5(c) ? c : fail$2("quadratic curve is n
 const asIncreasing$5 = (c) => isIncreasing$5(c) ? c : fail$2("quadratic curve is not increasing in both axes");
 /** @internal */
 const asDecreasing$5 = (c) => isDecreasing$5(c) ? c : fail$2("quadratic curve is not decreasing in both axes");
+/** @internal */
+const transform$5 = dual(2, (c, a) => {
+	const m = a.matrix;
+	return new QuadraticCurve2dImpl(make$3(m.m00 * c.x.c0 + m.m01 * c.y.c0 + m.m02, m.m00 * c.x.c1 + m.m01 * c.y.c1, m.m00 * c.x.c2 + m.m01 * c.y.c2), make$3(m.m10 * c.x.c0 + m.m11 * c.y.c0 + m.m12, m.m10 * c.x.c1 + m.m11 * c.y.c1, m.m10 * c.x.c2 + m.m11 * c.y.c2));
+});
 //#endregion
 //#region src/curve/quadratic2d.ts
 var quadratic2d_exports = /* @__PURE__ */ __exportAll({
+	Ops: () => Ops$1,
 	asDecreasing: () => asDecreasing$4,
 	asIncreasing: () => asIncreasing$4,
 	asMonotonic: () => asMonotonic$4,
 	boundingBox: () => boundingBox$4,
 	curvature: () => curvature$2,
 	derivative: () => derivative$1,
+	endPoint: () => endPoint$4,
 	fromBezierPoints: () => fromBezierPoints$4,
 	fromCoefficients: () => fromCoefficients$2,
 	fromPolynomials: () => fromPolynomials$4,
 	isDecreasing: () => isDecreasing$4,
+	isDecreasingX: () => isDecreasingX$4,
+	isDecreasingY: () => isDecreasingY$4,
 	isIncreasing: () => isIncreasing$4,
+	isIncreasingX: () => isIncreasingX$4,
+	isIncreasingY: () => isIncreasingY$4,
 	isMonotonic: () => isMonotonic$4,
+	isMonotonicX: () => isMonotonicX$4,
+	isMonotonicY: () => isMonotonicY$4,
 	isQuadraticCurve2d: () => isQuadraticCurve2d,
 	length: () => length$2,
 	solve: () => solve$4,
 	solveAtX: () => solveAtX$4,
-	solveAtY: () => solveAtY$4
+	solveAtY: () => solveAtY$4,
+	startPoint: () => startPoint$4,
+	toPathDataSegment: () => toPathDataSegment$2,
+	transform: () => transform$4,
+	xRange: () => xRange$2,
+	yRange: () => yRange$2
 });
 /**
 * Creates a new `QuadraticCurve2d` instance from polynomial parameters.
@@ -361,12 +545,78 @@ const curvature$2 = curvature$3;
 */
 const boundingBox$4 = boundingBox$5;
 /**
+* Evaluates the curve at `t = 0` in closed form — `(c.x.c0, c.y.c0)`.
+*
+* @param c - The quadratic curve.
+* @returns The point at the start of the curve's parameter domain.
+* @since 2.0.0
+*/
+const startPoint$4 = startPoint$5;
+/**
+* Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+* monomial coefficients.
+*
+* @param c - The quadratic curve.
+* @returns The point at the end of the curve's parameter domain.
+* @since 2.0.0
+*/
+const endPoint$4 = endPoint$5;
+/**
+* The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+* accounting for an interior extremum if one exists.
+*
+* @param c - The quadratic curve.
+* @returns The closed range of x over `[0, 1]`.
+* @since 2.0.0
+*/
+const xRange$2 = xRange$3;
+/**
+* The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+* accounting for an interior extremum if one exists.
+*
+* @param c - The quadratic curve.
+* @returns The closed range of y over `[0, 1]`.
+* @since 2.0.0
+*/
+const yRange$2 = yRange$3;
+/**
+* Renders the curve as a single SVG path-data drawing command — for a
+* quadratic curve, `Q ctrlX,ctrlY endX,endY`, where the control point is
+* recovered from the monomial coefficients via the inverse Bernstein
+* expansion. Does not include a leading `M`.
+*
+* @param c - The quadratic curve.
+* @returns The SVG drawing command for this segment, without a leading `M`.
+* @since 2.0.0
+*/
+const toPathDataSegment$2 = toPathDataSegment$3;
+/**
+* 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.
+*
+* @since 2.0.0
+*/
+const isMonotonicX$4 = isMonotonicX$5;
+/** @since 2.0.0 */
+const isIncreasingX$4 = isIncreasingX$5;
+/** @since 2.0.0 */
+const isDecreasingX$4 = isDecreasingX$5;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Monotonic`. The x-axis trait is unchanged.
+*
+* @since 2.0.0
+*/
+const isMonotonicY$4 = isMonotonicY$5;
+/** @since 2.0.0 */
+const isIncreasingY$4 = isIncreasingY$5;
+/** @since 2.0.0 */
+const isDecreasingY$4 = isDecreasingY$5;
+/**
 * 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
 */
 const isMonotonic$4 = isMonotonic$5;
@@ -380,6 +630,31 @@ const asMonotonic$4 = asMonotonic$5;
 const asIncreasing$4 = asIncreasing$5;
 /** @since 2.0.0 */
 const asDecreasing$4 = asDecreasing$5;
+const transform$4 = transform$5;
+/**
+* The {@link Curve2dOps} bundle for `QuadraticCurve2d`. Used by
+* `QuadraticPath2d` to wire up the path-level operation surface. The
+* `solveAtX` / `solveAtY` entries narrow the curve's potentially-2-element
+* result to `AtMostOne` — path callers enforce that via the path's
+* `MonotonicX`/`MonotonicY` brand.
+*
+* @since 2.0.0
+*/
+const Ops$1 = {
+	solve: solve$4,
+	startPoint: startPoint$4,
+	endPoint: endPoint$4,
+	length: length$2,
+	boundingBox: boundingBox$4,
+	solveAtX: (c, x) => solveAtX$5(c, x),
+	solveAtY: (c, y) => solveAtY$5(c, y),
+	toPathDataSegment: toPathDataSegment$2,
+	isIncreasingX: isIncreasingX$4,
+	isDecreasingX: isDecreasingX$4,
+	isIncreasingY: isIncreasingY$4,
+	isDecreasingY: isDecreasingY$4,
+	transform: transform$4
+};
 //#endregion
 //#region src/curve/cubic2d.internal.ts
 const CubicCurve2dTypeId = Symbol("curvy/curve/cubic2d");
@@ -405,26 +680,20 @@ const fromPolynomials$3 = (c0, c1) => new CubicCurve2dImpl(c0, c1);
 /** @internal */
 const fromCoefficients$1 = (c0, c1, c2, c3) => new CubicCurve2dImpl(make$1(c0.x, c1.x, c2.x, c3.x), make$1(c0.y, c1.y, c2.y, c3.y));
 /** @internal */
-const fromBezierPoints$3 = (p0, p1, p2, p3) => {
-	return new CubicCurve2dImpl(...apply(cubicBezier, ...transpose([
-		p0,
-		p1,
-		p2,
-		p3
-	], (p) => [p.x, p.y])));
-};
+const fromBezierPoints$3 = (p0, p1, p2, p3) => new CubicCurve2dImpl(...apply(cubicBezier, ...transpose([
+	p0,
+	p1,
+	p2,
+	p3
+], (p) => [p.x, p.y])));
 /** @internal */
 const isCubicCurve2d$1 = (c) => typeof c === "object" && c !== null && CubicCurve2dTypeId in c;
 /** @internal */
 const solve$3 = dual(2, (c, t) => make(solve$8(c.x, t), solve$8(c.y, t)));
 /** @internal */
-const solveAtX$3 = dual(2, (c, x) => {
-	return map(clip(solveInverse(c.x, x), unit), (t) => solve$8(c.y, t));
-});
+const solveAtX$3 = dual(2, (c, x) => solveInverse(c.x, x).pipe(clipApprox(unit), map(toSolver(c.y))));
 /** @internal */
-const solveAtY$3 = dual(2, (c, y) => {
-	return map(clip(solveInverse(c.y, y), unit), (t) => solve$8(c.x, t));
-});
+const solveAtY$3 = dual(2, (c, y) => solveInverse(c.y, y).pipe(clipApprox(unit), map(toSolver(c.x))));
 /** @internal */
 const derivative = (c) => fromPolynomials$4(derivative$5(c.x), derivative$5(c.y));
 /** @internal */
@@ -447,11 +716,43 @@ const curvature$1 = dual(2, (c, t) => {
 /** @internal */
 const boundingBox$3 = (c) => make$4(unitRange(c.x), unitRange(c.y));
 /** @internal */
-const isMonotonic$3 = (c) => isMonotonic$8(c.x, unit) && isMonotonic$8(c.y, unit);
+const startPoint$3 = (c) => make(c.x.c0, c.y.c0);
+/** @internal */
+const endPoint$3 = (c) => make(c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3, c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3);
+/** @internal */
+const xRange$1 = (c) => unitRange(c.x);
+/** @internal */
+const yRange$1 = (c) => unitRange(c.y);
+/** @internal */
+const toPathDataSegment$1 = (c) => {
+	const c0x = c.x.c0;
+	const c0y = c.y.c0;
+	const c1x = c.x.c1;
+	const c1y = c.y.c1;
+	const c2x = c.x.c2;
+	const c2y = c.y.c2;
+	const c3x = c.x.c3;
+	const c3y = c.y.c3;
+	return `C ${c0x + c1x / 3},${c0y + c1y / 3} ${c0x + 2 * c1x / 3 + c2x / 3},${c0y + 2 * c1y / 3 + c2y / 3} ${c0x + c1x + c2x + c3x},${c0y + c1y + c2y + c3y}`;
+};
+/** @internal */
+const isMonotonicX$3 = (c) => isMonotonic$8(c.x, unit);
 /** @internal */
-const isIncreasing$3 = (c) => isIncreasing$8(c.x, unit) && isIncreasing$8(c.y, unit);
+const isIncreasingX$3 = (c) => isIncreasing$8(c.x, unit);
 /** @internal */
-const isDecreasing$3 = (c) => isDecreasing$8(c.x, unit) && isDecreasing$8(c.y, unit);
+const isDecreasingX$3 = (c) => isDecreasing$8(c.x, unit);
+/** @internal */
+const isMonotonicY$3 = (c) => isMonotonic$8(c.y, unit);
+/** @internal */
+const isIncreasingY$3 = (c) => isIncreasing$8(c.y, unit);
+/** @internal */
+const isDecreasingY$3 = (c) => isDecreasing$8(c.y, unit);
+/** @internal */
+const isMonotonic$3 = (c) => isMonotonicX$3(c) && isMonotonicY$3(c);
+/** @internal */
+const isIncreasing$3 = (c) => isIncreasingX$3(c) && isIncreasingY$3(c);
+/** @internal */
+const isDecreasing$3 = (c) => isDecreasingX$3(c) && isDecreasingY$3(c);
 const fail$1 = (m) => {
 	throw new Error(m);
 };
@@ -461,25 +762,43 @@ const asMonotonic$3 = (c) => isMonotonic$3(c) ? c : fail$1("cubic curve is not m
 const asIncreasing$3 = (c) => isIncreasing$3(c) ? c : fail$1("cubic curve is not increasing in both axes");
 /** @internal */
 const asDecreasing$3 = (c) => isDecreasing$3(c) ? c : fail$1("cubic curve is not decreasing in both axes");
+/** @internal */
+const transform$3 = dual(2, (c, a) => {
+	const m = a.matrix;
+	return new CubicCurve2dImpl(make$1(m.m00 * c.x.c0 + m.m01 * c.y.c0 + m.m02, m.m00 * c.x.c1 + m.m01 * c.y.c1, m.m00 * c.x.c2 + m.m01 * c.y.c2, m.m00 * c.x.c3 + m.m01 * c.y.c3), make$1(m.m10 * c.x.c0 + m.m11 * c.y.c0 + m.m12, m.m10 * c.x.c1 + m.m11 * c.y.c1, m.m10 * c.x.c2 + m.m11 * c.y.c2, m.m10 * c.x.c3 + m.m11 * c.y.c3));
+});
 //#endregion
 //#region src/curve/cubic2d.ts
 var cubic2d_exports = /* @__PURE__ */ __exportAll({
+	Ops: () => Ops,
 	asDecreasing: () => asDecreasing$2,
 	asIncreasing: () => asIncreasing$2,
 	asMonotonic: () => asMonotonic$2,
 	boundingBox: () => boundingBox$2,
 	curvature: () => curvature,
+	endPoint: () => endPoint$2,
 	fromBezierPoints: () => fromBezierPoints$2,
 	fromCoefficients: () => fromCoefficients,
 	fromPolynomials: () => fromPolynomials$2,
 	isCubicCurve2d: () => isCubicCurve2d,
 	isDecreasing: () => isDecreasing$2,
+	isDecreasingX: () => isDecreasingX$2,
+	isDecreasingY: () => isDecreasingY$2,
 	isIncreasing: () => isIncreasing$2,
+	isIncreasingX: () => isIncreasingX$2,
+	isIncreasingY: () => isIncreasingY$2,
 	isMonotonic: () => isMonotonic$2,
+	isMonotonicX: () => isMonotonicX$2,
+	isMonotonicY: () => isMonotonicY$2,
 	length: () => length,
 	solve: () => solve$2,
 	solveAtX: () => solveAtX$2,
-	solveAtY: () => solveAtY$2
+	solveAtY: () => solveAtY$2,
+	startPoint: () => startPoint$2,
+	toPathDataSegment: () => toPathDataSegment,
+	transform: () => transform$2,
+	xRange: () => xRange,
+	yRange: () => yRange
 });
 /**
 * Creates a new `CubicCurve2d` instance from polynomial parameters.
@@ -545,12 +864,78 @@ const curvature = curvature$1;
 */
 const boundingBox$2 = boundingBox$3;
 /**
+* 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.
+* @since 2.0.0
+*/
+const startPoint$2 = startPoint$3;
+/**
+* Evaluates the curve at `t = 1` in closed form — the sum of the per-axis
+* monomial coefficients.
+*
+* @param c - The cubic curve.
+* @returns The point at the end of the curve's parameter domain.
+* @since 2.0.0
+*/
+const endPoint$2 = endPoint$3;
+/**
+* The tight `[min, max]` range of x over the curve's parameter domain `[0, 1]`,
+* accounting for up to two interior extrema.
+*
+* @param c - The cubic curve.
+* @returns The closed range of x over `[0, 1]`.
+* @since 2.0.0
+*/
+const xRange = xRange$1;
+/**
+* The tight `[min, max]` range of y over the curve's parameter domain `[0, 1]`,
+* accounting for up to two interior extrema.
+*
+* @param c - The cubic curve.
+* @returns The closed range of y over `[0, 1]`.
+* @since 2.0.0
+*/
+const yRange = yRange$1;
+/**
+* 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`.
+*
+* @param c - The cubic curve.
+* @returns The SVG drawing command for this segment, without a leading `M`.
+* @since 2.0.0
+*/
+const toPathDataSegment = toPathDataSegment$1;
+/**
+* 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.
+*
+* @since 2.0.0
+*/
+const isMonotonicX$2 = isMonotonicX$3;
+/** @since 2.0.0 */
+const isIncreasingX$2 = isIncreasingX$3;
+/** @since 2.0.0 */
+const isDecreasingX$2 = isDecreasingX$3;
+/**
+* Type-narrowing predicate: refines the curve's y-axis trait to include
+* `Monotonic`. The x-axis trait is unchanged.
+*
+* @since 2.0.0
+*/
+const isMonotonicY$2 = isMonotonicY$3;
+/** @since 2.0.0 */
+const isIncreasingY$2 = isIncreasingY$3;
+/** @since 2.0.0 */
+const isDecreasingY$2 = isDecreasingY$3;
+/**
 * 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
 */
 const isMonotonic$2 = isMonotonic$3;
@@ -564,6 +949,30 @@ const asMonotonic$2 = asMonotonic$3;
 const asIncreasing$2 = asIncreasing$3;
 /** @since 2.0.0 */
 const asDecreasing$2 = asDecreasing$3;
+const transform$2 = transform$3;
+/**
+* The {@link Curve2dOps} bundle for `CubicCurve2d`. Used by `CubicPath2d`
+* to wire up the path-level operation surface. The `solveAtX` / `solveAtY`
+* entries narrow the curve's potentially-3-element result to `AtMostOne` —
+* path callers enforce that via the path's `MonotonicX`/`MonotonicY` brand.
+*
+* @since 2.0.0
+*/
+const Ops = {
+	solve: solve$2,
+	startPoint: startPoint$2,
+	endPoint: endPoint$2,
+	length,
+	boundingBox: boundingBox$2,
+	solveAtX: (c, x) => solveAtX$3(c, x),
+	solveAtY: (c, y) => solveAtY$3(c, y),
+	toPathDataSegment,
+	isIncreasingX: isIncreasingX$2,
+	isDecreasingX: isDecreasingX$2,
+	isIncreasingY: isIncreasingY$2,
+	isDecreasingY: isDecreasingY$2,
+	transform: transform$2
+};
 //#endregion
 //#region src/curve/rationalCubic2d.internal.ts
 const RationalCubicCurve2dTypeId = Symbol("curvy/curve/rationalCubic2d");
@@ -586,43 +995,76 @@ var RationalCubicCurve2dImpl = class extends Pipeable {
 const isRationalCubicCurve2d$1 = (c) => typeof c === "object" && c !== null && RationalCubicCurve2dTypeId in c;
 /** @internal */
 const fromPolynomials$1 = (x, y, w) => new RationalCubicCurve2dImpl(x, y, w);
+const EASING_P0 = makeWeighted(0, 0, 1);
+const EASING_P3 = makeWeighted(1, 1, 1);
+/** @internal */
+const fromBezierPoints$1 = (...args) => {
+	const [p0, p1, p2, p3] = args.length === 2 ? [
+		EASING_P0,
+		args[0],
+		args[1],
+		EASING_P3
+	] : args;
+	return new RationalCubicCurve2dImpl(...apply(cubicBezier, ...transpose([
+		p0,
+		p1,
+		p2,
+		p3
+	], (p) => [
+		p.x * p.weight,
+		p.y * p.weight,
+		p.weight
+	])));
+};
 /** @internal */
-const fromBezierPoints$1 = (p0, p1, p2, p3) => new RationalCubicCurve2dImpl(...apply(cubicBezier, ...transpose([
-	p0,
-	p1,
-	p2,
-	p3
-], (p) => [
-	p.x * p.weight,
-	p.y * p.weight,
-	p.weight
-])));
-/** @internal */
-const makeMonotonicEasing$1 = (startSlope, endSlope) => {
-	invariant(Number.isFinite(startSlope) && startSlope >= 0, "makeMonotonicEasing: startSlope must be finite and ≥ 0");
-	invariant(Number.isFinite(endSlope) && endSlope >= 0, "makeMonotonicEasing: endSlope must be finite and ≥ 0");
+const fromSlopesAndCurvatures$1 = (startSlope, endSlope, startCurvature, endCurvature) => {
+	invariant(Number.isFinite(startSlope), "fromSlopesAndCurvatures: startSlope must be finite");
+	invariant(Number.isFinite(endSlope), "fromSlopesAndCurvatures: endSlope must be finite");
+	invariant(Number.isFinite(startCurvature), "fromSlopesAndCurvatures: startCurvature must be finite");
+	invariant(Number.isFinite(endCurvature), "fromSlopesAndCurvatures: endCurvature must be finite");
 	const m0 = startSlope;
 	const m1 = endSlope;
-	const alpha = m0 + 1;
-	const beta = m1 + 1;
-	const pC0 = 0;
-	const pC1 = m0 * alpha;
-	const pC2 = beta * (2 - m1) + alpha * (1 - 2 * m0);
-	const pC3 = beta * (m1 - 1) + alpha * (m0 - 1);
-	const qC0 = alpha;
-	const qC1 = beta - alpha;
-	const xPoly = make$1(0, alpha, beta - alpha, 0);
-	const yPoly = make$1(pC0, pC1, pC2, pC3);
-	const wPoly = make$1(qC0, qC1, 0, 0);
-	const monoQ = make$1(m0 * alpha * alpha, 2 * alpha * pC2, 3 * alpha * pC3 + pC2 * (beta - alpha), 2 * pC3 * (beta - alpha));
-	const interiorRoots = monoQ.pipe(roots, clip(unitOpen));
-	for (const t of interiorRoots) {
-		const epsilon = 1e-6;
-		const lo = Math.max(0, t - epsilon);
-		const hi = Math.min(1, t + epsilon);
-		invariant(Math.sign(solve$8(monoQ, lo)) * Math.sign(solve$8(monoQ, hi)) >= 0, `makeMonotonicEasing: slopes (${m0}, ${m1}) produce a non-monotonic curve with the default Gregory-Delbourgo construction. Try smaller slopes or use a different easing form.`);
+	const d0 = startCurvature * Math.pow(1 + m0 * m0, 1.5);
+	const d1 = endCurvature * Math.pow(1 + m1 * m1, 1.5);
+	const u = 1 - m0;
+	const v = 1 - m1;
+	const det = 4 * u * d1 - 8 * v * v;
+	const detScale = Math.max(Math.abs(4 * u * d1), Math.abs(8 * v * v), 1);
+	const SINGULAR_TOLERANCE = 1e-12;
+	let w0;
+	let w1;
+	let w2;
+	if (Math.abs(det) > SINGULAR_TOLERANCE * detScale) {
+		w0 = 1;
+		w1 = (d0 * d1 + 4 * u * v) / det;
+		w2 = (-8 * u * u - 4 * d0 * v) / det;
+	} else if (u === 0 && v === 0) {
+		invariant(d0 === 0 && d1 === 0, `fromSlopesAndCurvatures: inputs (m₀=${m0}, m₁=${m1}, κ₀=${startCurvature}, κ₁=${endCurvature}) yield an inconsistent constraint system`);
+		return new RationalCubicCurve2dImpl(make$1(0, 1, 0, 0), make$1(0, 1, 0, 0), make$1(1, 0, 0, 0));
+	} else {
+		const residual = -8 * u * u - 4 * v * d0;
+		invariant(Math.abs(residual) <= SINGULAR_TOLERANCE * detScale, `fromSlopesAndCurvatures: inputs (m₀=${m0}, m₁=${m1}, κ₀=${startCurvature}, κ₁=${endCurvature}) yield an inconsistent constraint system`);
+		w0 = 1;
+		w2 = 1;
+		w1 = u !== 0 ? (d0 - 2 * v) / (4 * u) : -(2 * u + d1) / (4 * v);
+	}
+	invariant(w2 > 0, `fromSlopesAndCurvatures: inputs (m₀=${m0}, m₁=${m1}, κ₀=${startCurvature}, κ₁=${endCurvature}) yield denominator ≤ 0 at t = 1`);
+	const a = w0 - 2 * w1 + w2;
+	const b = 2 * (w1 - w0);
+	if (a > 0) {
+		const tStar = -b / (2 * a);
+		if (tStar > 0 && tStar < 1) invariant(w0 + tStar * (b + a * tStar) > 0, `fromSlopesAndCurvatures: inputs (m₀=${m0}, m₁=${m1}, κ₀=${startCurvature}, κ₁=${endCurvature}) yield denominator ≤ 0 in (0, 1)`);
 	}
-	return new RationalCubicCurve2dImpl(xPoly, yPoly, wPoly);
+	const p1 = m0 * w0 / 3;
+	const p2 = (v * w2 + 2 * w1) / 3;
+	const p3 = w2;
+	const yC1 = 3 * p1;
+	const yC2 = 3 * (p2 - 2 * p1);
+	const yC3 = p3 - 3 * p2 + 3 * p1;
+	const wC0 = w0;
+	const wC1 = b;
+	const wC2 = a;
+	return new RationalCubicCurve2dImpl(make$1(0, wC0, wC1, wC2), make$1(0, yC1, yC2, yC3), make$1(wC0, wC1, wC2, 0));
 };
 /** @internal */
 const solve$1 = dual(2, (c, t) => {
@@ -630,9 +1072,16 @@ const solve$1 = dual(2, (c, t) => {
 	return make(solve$8(c.x, t) / w, solve$8(c.y, t) / w);
 });
 /** @internal */
-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))));
+const startPoint$1 = (c) => make(c.x.c0 / c.w.c0, c.y.c0 / c.w.c0);
+/** @internal */
+const endPoint$1 = (c) => {
+	const w = c.w.c0 + c.w.c1 + c.w.c2 + c.w.c3;
+	return make((c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3) / w, (c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3) / w);
+};
+/** @internal */
+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, clipApprox(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 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, clipApprox(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),
@@ -729,6 +1178,11 @@ const asMonotonic$1 = (c) => isMonotonic$1(c) ? c : fail("rational cubic curve i
 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");
+/** @internal */
+const transform$1 = dual(2, (c, a) => {
+	const m = a.matrix;
+	return new RationalCubicCurve2dImpl(make$1(m.m00 * c.x.c0 + m.m01 * c.y.c0 + m.m02 * c.w.c0, m.m00 * c.x.c1 + m.m01 * c.y.c1 + m.m02 * c.w.c1, m.m00 * c.x.c2 + m.m01 * c.y.c2 + m.m02 * c.w.c2, m.m00 * c.x.c3 + m.m01 * c.y.c3 + m.m02 * c.w.c3), make$1(m.m10 * c.x.c0 + m.m11 * c.y.c0 + m.m12 * c.w.c0, m.m10 * c.x.c1 + m.m11 * c.y.c1 + m.m12 * c.w.c1, m.m10 * c.x.c2 + m.m11 * c.y.c2 + m.m12 * c.w.c2, m.m10 * c.x.c3 + m.m11 * c.y.c3 + m.m12 * c.w.c3), c.w);
+});
 const MAX_BBOX_DEPTH = 20;
 /** @internal */
 const boundingBox$1 = dual(2, (c, tolerance) => {
@@ -948,8 +1402,10 @@ var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
 	asMonotonicX: () => asMonotonicX,
 	asMonotonicY: () => asMonotonicY,
 	boundingBox: () => boundingBox,
+	endPoint: () => endPoint,
 	fromBezierPoints: () => fromBezierPoints,
 	fromPolynomials: () => fromPolynomials,
+	fromSlopesAndCurvatures: () => fromSlopesAndCurvatures,
 	isDecreasing: () => isDecreasing,
 	isDecreasingX: () => isDecreasingX,
 	isDecreasingY: () => isDecreasingY,
@@ -960,11 +1416,12 @@ var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
 	isMonotonicX: () => isMonotonicX,
 	isMonotonicY: () => isMonotonicY,
 	isRationalCubicCurve2d: () => isRationalCubicCurve2d,
-	makeMonotonicEasing: () => makeMonotonicEasing,
 	solve: () => solve,
 	solveAtX: () => solveAtX,
 	solveAtY: () => solveAtY,
+	startPoint: () => startPoint,
 	subdivide: () => subdivide,
+	transform: () => transform,
 	xMonotonicity: () => xMonotonicity,
 	yMonotonicity: () => yMonotonicity
 });
@@ -987,44 +1444,52 @@ const isRationalCubicCurve2d = isRationalCubicCurve2d$1;
 * @since 2.0.0
 */
 const fromPolynomials = fromPolynomials$1;
+const fromBezierPoints = fromBezierPoints$1;
 /**
-* 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.
+* Creates a rational cubic easing curve from endpoint slopes and signed
+* curvatures. The result interpolates `(0, 0)` and `(1, 1)` with `x(t) = t`
+* pinned linearly; the y-axis projection `y(t) = Y(t)/W(t)` uses a cubic
+* numerator over a quadratic denominator, giving six free parameters that
+* exactly match the six endpoint constraints (two values, two slopes, two
+* curvatures).
 *
-* @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.
+* Curvatures are the signed differential-geometric curvatures `κ = y''(x) /
+* (1 + y'(x)²)^(3/2)` — the parameterization-invariant "bend" of the easing
+* graph. Positive κ is concave-up. Smoothstep is `(0, 0, 6, -6)`; linear is
+* `(1, 1, 0, 0)` (taken as a redundant-system special case).
+*
+* Monotonicity is not enforced. Callers needing the `Increasing` brand for
+* narrowed inverse-solve returns should follow construction with
+* {@link asIncreasing}, which verifies monotonicity rigorously.
+*
+* @param startSlope - The easing function's slope at the start (`dy/dx` at `x = 0`).
+* @param endSlope - The easing function's slope at the end (`dy/dx` at `x = 1`).
+* @param startCurvature - The signed differential curvature at the start.
+* @param endCurvature - The signed differential curvature at the end.
+* @returns A rational cubic easing curve.
+* @throws When inputs are non-finite, the constraint system is singular, or the resulting denominator vanishes on `[0, 1]`.
 * @since 2.0.0
 */
-const fromBezierPoints = fromBezierPoints$1;
+const fromSlopesAndCurvatures = fromSlopesAndCurvatures$1;
+const solve = solve$1;
 /**
-* 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.
+* Evaluates the curve at `t = 0` in closed form — `(c.x.c0 / c.w.c0, c.y.c0 / c.w.c0)`.
 *
-* 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 c - The rational cubic curve.
+* @returns The point at the start of the curve's parameter domain.
+* @since 2.0.0
+*/
+const startPoint = startPoint$1;
+/**
+* Evaluates the curve at `t = 1` in closed form. Both numerator and denominator
+* Horner evaluations at `t = 1` collapse to the sum of their monomial
+* coefficients, so the projection is `(Σxᵢ / Σwᵢ, Σyᵢ / Σwᵢ)`.
 *
-* @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.
+* @param c - The rational cubic curve.
+* @returns The point at the end of the curve's parameter domain.
 * @since 2.0.0
 */
-const makeMonotonicEasing = makeMonotonicEasing$1;
-const solve = solve$1;
+const endPoint = endPoint$1;
 const solveAtX = solveAtX$1;
 const solveAtY = solveAtY$1;
 const subdivide = subdivide$1;
@@ -1196,8 +1661,9 @@ const asIncreasing = asIncreasing$1;
 * @since 2.0.0
 */
 const asDecreasing = asDecreasing$1;
+const transform = transform$1;
 const approximateAsCubicCurves = approximateAsCubicCurves$1;
 //#endregion
-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 };
+export { Ops$2 as _, solve as a, cubic2d_exports as c, length as d, solve$2 as f, solve$4 as g, quadratic2d_exports as h, rationalCubic2d_exports as i, fromCoefficients as l, Ops$1 as m, boundingBox as n, transform as o, derivative as p, fromBezierPoints as r, Ops as s, approximateAsCubicCurves as t, fromPolynomials$2 as u, fromEndpoints as v, linear2d_exports as y };
 
-//# sourceMappingURL=rationalCubic2d-CeHgpNht.mjs.map
+//# sourceMappingURL=rationalCubic2d-CZSwwKtS.mjs.map