curvy 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/shared/{rationalCubic2d-H1J2Fjyy.mjs → rationalCubic2d-CZiP8nIq.mjs}

@@ -1,131 +1,226 @@
 import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
-import { epsEquals } from "../number.mjs";
-import { i as magnitude } from "./vector2-CSkaMXvp.mjs";
-import { c as make$6, p as unit } from "./interval-Dm35Xhy4.mjs";
-import { o as none, r as isNone, s as one } from "./solution-B2JdOZpe.mjs";
-import { a as isIncreasing, i as isDecreasing } from "./cubic-BL6dpuHh.mjs";
-import { d as isIncreasing$1, u as isDecreasing$1 } from "./quadratic-DPrUsFCp.mjs";
-import { a as union } from "./interval2d-AtneyI45.mjs";
-import { C as length$4, D as solveAtY$4, E as solveAtX$4, T as solve$6, a as solve$9, d as solve$7, f as solveAtX$5, m as derivative, n as boundingBox$8, o as boundingBox$7, p as solveAtY$5, t as approximateAsCubicCurves, u as length$5, v as solve$8, x as boundingBox$6 } from "./rationalCubic2d-CeHgpNht.mjs";
-//#region src/path/linear2d.internal.ts
-const LinearPath2dTypeId = Symbol("curvy/path/linear2d");
-/** @internal */
-var LinearPath2dImpl = class extends Pipeable {
-	[LinearPath2dTypeId] = LinearPath2dTypeId;
+import { coincident } from "../number.mjs";
+import { a as magnitude } from "./vector2-DuA3EmfL.mjs";
+import { l as make$6, p as unit } from "./interval-Dcqpo73t.mjs";
+import { c as one, i as isNone, s as none } from "./solution-BW0BBMXI.mjs";
+import { a as union } from "./interval2d-C2Pk66-2.mjs";
+import { a as solve$8, d as solve$7, f as Ops$1, h as solve$6, n as boundingBox$6, o as transform$6, p as derivative, t as approximateAsCubicCurves, u as length$4, y as Ops } from "./rationalCubic2d-gM7VeiiT.mjs";
+//#region src/path/path2d.ts
+/**
+* Concrete implementation backing every `Path2d<C>`. The per-kind `TypeId`
+* symbol is stamped onto each instance as a dynamic property at the symbol
+* key it identifies, so the existing per-kind `is{Linear,Quadratic,Cubic}Path2d`
+* typeguards continue to work as `TypeId in p` checks.
+*
+* @internal
+*/
+var Path2dImpl = class extends Pipeable {
 	curves;
-	constructor(curves) {
+	constructor(typeId, curves) {
 		super();
+		this[typeId] = typeId;
 		this.curves = curves;
 	}
 	[Symbol.iterator]() {
 		return this.curves[Symbol.iterator]();
 	}
 };
+/**
+* Builds the bundle of generic path operations for a curve kind `C`, given
+* that curve's {@link Curve2dOps} and the per-kind `TypeId` symbol. Each
+* polynomial-degree path module calls this once and re-exports the returned
+* functions with curve-narrowed signatures.
+*
+* `ops` and `typeId` are captured by closure, so the returned operations
+* incur no per-call lookup overhead.
+*
+* @since 2.0.0
+*/
+const makeMethods = (typeId, ops) => {
+	const fromArray = (curves) => new Path2dImpl(typeId, curves);
+	const make = (...curves) => fromArray(curves);
+	const append = dual(2, (p, c) => fromArray([...p, c]));
+	const length = (p) => {
+		let total = 0;
+		for (const curve of p) total += ops.length(curve, unit);
+		return total;
+	};
+	const solve = dual(2, (p, u) => {
+		const curves = p instanceof Path2dImpl ? p.curves : [...p];
+		if (u === 1) return ops.solve(curves.at(-1), 1);
+		const t = u * curves.length;
+		const i = Math.floor(t);
+		return ops.solve(curves[i], t - i);
+	});
+	const toPathData = (p) => {
+		let result = "";
+		let prevEndX = NaN;
+		let prevEndY = NaN;
+		for (const curve of p) {
+			const start = ops.startPoint(curve);
+			const end = ops.endPoint(curve);
+			if (!coincident(start.x, prevEndX) || !coincident(start.y, prevEndY)) result += ` M ${start.x},${start.y}`;
+			result += ` ${ops.toPathDataSegment(curve)}`;
+			prevEndX = end.x;
+			prevEndY = end.y;
+		}
+		return result.slice(1);
+	};
+	const isContinuous = (p) => {
+		let prevEndX = NaN;
+		let prevEndY = NaN;
+		let first = true;
+		for (const curve of p) {
+			const start = ops.startPoint(curve);
+			if (!first && (!coincident(start.x, prevEndX) || !coincident(start.y, prevEndY))) return false;
+			const end = ops.endPoint(curve);
+			prevEndX = end.x;
+			prevEndY = end.y;
+			first = false;
+		}
+		return true;
+	};
+	const isIncreasingX = (p) => {
+		let prevEnd = Number.NEGATIVE_INFINITY;
+		for (const c of p) {
+			if (!ops.isIncreasingX(c)) return false;
+			const start = ops.startPoint(c).x;
+			if (start < prevEnd && !coincident(start, prevEnd)) return false;
+			prevEnd = ops.endPoint(c).x;
+		}
+		return true;
+	};
+	const isDecreasingX = (p) => {
+		let prevEnd = Number.POSITIVE_INFINITY;
+		for (const c of p) {
+			if (!ops.isDecreasingX(c)) return false;
+			const start = ops.startPoint(c).x;
+			if (start > prevEnd && !coincident(start, prevEnd)) return false;
+			prevEnd = ops.endPoint(c).x;
+		}
+		return true;
+	};
+	const isMonotonicX = (p) => isIncreasingX(p) || isDecreasingX(p);
+	const isIncreasingY = (p) => {
+		let prevEnd = Number.NEGATIVE_INFINITY;
+		for (const c of p) {
+			if (!ops.isIncreasingY(c)) return false;
+			const start = ops.startPoint(c).y;
+			if (start < prevEnd && !coincident(start, prevEnd)) return false;
+			prevEnd = ops.endPoint(c).y;
+		}
+		return true;
+	};
+	const isDecreasingY = (p) => {
+		let prevEnd = Number.POSITIVE_INFINITY;
+		for (const c of p) {
+			if (!ops.isDecreasingY(c)) return false;
+			const start = ops.startPoint(c).y;
+			if (start > prevEnd && !coincident(start, prevEnd)) return false;
+			prevEnd = ops.endPoint(c).y;
+		}
+		return true;
+	};
+	const isMonotonicY = (p) => isIncreasingY(p) || isDecreasingY(p);
+	const solveAtX = dual(2, (p, x) => {
+		for (const c of p) {
+			const start = ops.startPoint(c);
+			const end = ops.endPoint(c);
+			const lo = Math.min(start.x, end.x);
+			const hi = Math.max(start.x, end.x);
+			if (x >= lo && x <= hi || coincident(x, lo) || coincident(x, hi)) {
+				if (coincident(x, start.x)) return one(start.y);
+				if (coincident(x, end.x)) return one(end.y);
+				const sol = ops.solveAtX(c, x);
+				if (!isNone(sol)) return sol;
+			}
+		}
+		return none;
+	});
+	const solveAtY = dual(2, (p, y) => {
+		for (const c of p) {
+			const start = ops.startPoint(c);
+			const end = ops.endPoint(c);
+			const lo = Math.min(start.y, end.y);
+			const hi = Math.max(start.y, end.y);
+			if (y >= lo && y <= hi || coincident(y, lo) || coincident(y, hi)) {
+				if (coincident(y, start.y)) return one(start.x);
+				if (coincident(y, end.y)) return one(end.x);
+				const sol = ops.solveAtY(c, y);
+				if (!isNone(sol)) return sol;
+			}
+		}
+		return none;
+	});
+	const boundingBox = (p) => {
+		const iter = p[Symbol.iterator]();
+		const first = iter.next();
+		let acc = ops.boundingBox(first.value);
+		for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, ops.boundingBox(next.value));
+		return acc;
+	};
+	return {
+		fromArray,
+		make,
+		append,
+		length,
+		solve,
+		toPathData,
+		isContinuous,
+		isIncreasingX,
+		isDecreasingX,
+		isMonotonicX,
+		isIncreasingY,
+		isDecreasingY,
+		isMonotonicY,
+		solveAtX,
+		solveAtY,
+		boundingBox,
+		transform: dual(2, (p, a) => {
+			const curves = [];
+			for (const c of p) curves.push(ops.transform(c, a));
+			return fromArray(curves);
+		})
+	};
+};
+//#endregion
+//#region src/path/linear2d.internal.ts
+const LinearPath2dTypeId = Symbol("curvy/path/linear2d");
+const methods$1 = makeMethods(LinearPath2dTypeId, Ops);
 /** @internal */
 const isLinearPath2d$1 = (p) => typeof p === "object" && p !== null && LinearPath2dTypeId in p;
 /** @internal */
-const make$5 = (...curves) => new LinearPath2dImpl(curves);
+const make$5 = methods$1.make;
 /** @internal */
-const fromArray$5 = (curves) => new LinearPath2dImpl(curves);
+const fromArray$5 = methods$1.fromArray;
 /** @internal */
-const append$5 = dual(2, (p, c) => fromArray$5([...p, c]));
+const append$5 = methods$1.append;
 /** @internal */
-const length$3 = (p) => {
-	let total = 0;
-	for (const curve of p) total += length$4(curve, unit);
-	return total;
-};
+const length$3 = methods$1.length;
 /** @internal */
-const solve$5 = dual(2, (p, u) => {
-	const curves = p instanceof LinearPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$6(curves.at(-1), 1);
-	const t = u * curves.length;
-	const i = Math.floor(t);
-	const curve = curves[i];
-	return solve$6(curve, t - i);
-});
+const solve$5 = methods$1.solve;
 /** @internal */
-const toPathData$3 = (p) => {
-	let result = "";
-	let prevEndX = NaN;
-	let prevEndY = NaN;
-	for (const curve of p) {
-		const startX = curve.x.c0;
-		const startY = curve.y.c0;
-		const endX = curve.x.c0 + curve.x.c1;
-		const endY = curve.y.c0 + curve.y.c1;
-		if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) result += ` M ${startX},${startY}`;
-		result += ` L ${endX},${endY}`;
-		prevEndX = endX;
-		prevEndY = endY;
-	}
-	return result.slice(1);
-};
+const toPathData$3 = methods$1.toPathData;
 /** @internal */
-const isContinuous$3 = (p) => {
-	let prevEndX = NaN;
-	let prevEndY = NaN;
-	let first = true;
-	for (const curve of p) {
-		const startX = curve.x.c0;
-		const startY = curve.y.c0;
-		if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) return false;
-		prevEndX = curve.x.c0 + curve.x.c1;
-		prevEndY = curve.y.c0 + curve.y.c1;
-		first = false;
-	}
-	return true;
-};
+const isContinuous$3 = methods$1.isContinuous;
 /** @internal */
 const asContinuous$3 = (p) => {
 	invariant(isContinuous$3(p), "linear path is not continuous");
 	return p;
 };
 /** @internal */
-const isIncreasingX$3 = (p) => {
-	let prevEnd = Number.NEGATIVE_INFINITY;
-	for (const c of p) {
-		if (!isIncreasing$1(c.x)) return false;
-		if (c.x.c0 < prevEnd - 1e-10) return false;
-		prevEnd = c.x.c0 + c.x.c1;
-	}
-	return true;
-};
+const isIncreasingX$3 = methods$1.isIncreasingX;
 /** @internal */
-const isDecreasingX$3 = (p) => {
-	let prevEnd = Number.POSITIVE_INFINITY;
-	for (const c of p) {
-		if (!isDecreasing$1(c.x)) return false;
-		if (c.x.c0 > prevEnd + 1e-10) return false;
-		prevEnd = c.x.c0 + c.x.c1;
-	}
-	return true;
-};
+const isDecreasingX$3 = methods$1.isDecreasingX;
 /** @internal */
-const isMonotonicX$3 = (p) => isIncreasingX$3(p) || isDecreasingX$3(p);
+const isMonotonicX$3 = methods$1.isMonotonicX;
 /** @internal */
-const isIncreasingY$3 = (p) => {
-	let prevEnd = Number.NEGATIVE_INFINITY;
-	for (const c of p) {
-		if (!isIncreasing$1(c.y)) return false;
-		if (c.y.c0 < prevEnd - 1e-10) return false;
-		prevEnd = c.y.c0 + c.y.c1;
-	}
-	return true;
-};
+const isIncreasingY$3 = methods$1.isIncreasingY;
 /** @internal */
-const isDecreasingY$3 = (p) => {
-	let prevEnd = Number.POSITIVE_INFINITY;
-	for (const c of p) {
-		if (!isDecreasing$1(c.y)) return false;
-		if (c.y.c0 > prevEnd + 1e-10) return false;
-		prevEnd = c.y.c0 + c.y.c1;
-	}
-	return true;
-};
+const isDecreasingY$3 = methods$1.isDecreasingY;
 /** @internal */
-const isMonotonicY$3 = (p) => isIncreasingY$3(p) || isDecreasingY$3(p);
+const isMonotonicY$3 = methods$1.isMonotonicY;
 /** @internal */
 const asIncreasingX$3 = (p) => {
 	invariant(isIncreasingX$3(p), "linear path is not increasing in x");
@@ -157,44 +252,13 @@ const asMonotonicY$3 = (p) => {
 	return p;
 };
 /** @internal */
-const solveAtX$3 = dual(2, (p, x) => {
-	for (const c of p) {
-		const sx = c.x.c0;
-		const ex = c.x.c0 + c.x.c1;
-		const lo = Math.min(sx, ex);
-		const hi = Math.max(sx, ex);
-		if (x >= lo - 1e-10 && x <= hi + 1e-10) {
-			if (epsEquals(x, sx)) return one(c.y.c0);
-			if (epsEquals(x, ex)) return one(c.y.c0 + c.y.c1);
-			const sol = solveAtX$4(c, x);
-			if (!isNone(sol)) return sol;
-		}
-	}
-	return none;
-});
+const solveAtX$3 = methods$1.solveAtX;
 /** @internal */
-const solveAtY$3 = dual(2, (p, y) => {
-	for (const c of p) {
-		const sy = c.y.c0;
-		const ey = c.y.c0 + c.y.c1;
-		const lo = Math.min(sy, ey);
-		const hi = Math.max(sy, ey);
-		if (y >= lo - 1e-10 && y <= hi + 1e-10) {
-			if (epsEquals(y, sy)) return one(c.x.c0);
-			if (epsEquals(y, ey)) return one(c.x.c0 + c.x.c1);
-			const sol = solveAtY$4(c, y);
-			if (!isNone(sol)) return sol;
-		}
-	}
-	return none;
-});
+const solveAtY$3 = methods$1.solveAtY;
 /** @internal */
-const boundingBox$5 = (p) => {
-	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$6(iter.next().value);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$6(next.value));
-	return acc;
-};
+const boundingBox$5 = methods$1.boundingBox;
+/** @internal */
+const transform$5 = methods$1.transform;
 //#endregion
 //#region src/path/linear2d.ts
 var linear2d_exports = /* @__PURE__ */ __exportAll({
@@ -221,7 +285,8 @@ var linear2d_exports = /* @__PURE__ */ __exportAll({
 	solve: () => solve$4,
 	solveAtX: () => solveAtX$2,
 	solveAtY: () => solveAtY$2,
-	toPathData: () => toPathData$2
+	toPathData: () => toPathData$2,
+	transform: () => transform$4
 });
 /**
 * Creates a new `LinearPath2d` instance from a sequence of curves.
@@ -378,175 +443,50 @@ const solveAtY$2 = solveAtY$3;
 * @since 2.0.0
 */
 const boundingBox$4 = boundingBox$5;
+const transform$4 = transform$5;
 //#endregion
 //#region src/path/cubic2d.internal.ts
 const CubicPath2dTypeId = Symbol("curvy/path/cubic2d");
-/** @internal */
-var CubicPath2dImpl = class extends Pipeable {
-	[CubicPath2dTypeId] = CubicPath2dTypeId;
-	curves;
-	constructor(curves) {
-		invariant(curves.length > 0, "cubic path requires at least one curve");
-		super();
-		this.curves = curves;
-	}
-	[Symbol.iterator]() {
-		return this.curves[Symbol.iterator]();
-	}
-};
+const methods = makeMethods(CubicPath2dTypeId, Ops$1);
 /** @internal */
 const isCubicPath2d$1 = (p) => typeof p === "object" && p !== null && CubicPath2dTypeId in p;
 /** @internal */
-const make$3 = (...curves) => new CubicPath2dImpl(curves);
+const make$3 = (...curves) => {
+	invariant(curves.length > 0, "cubic path requires at least one curve");
+	return methods.make(...curves);
+};
 /** @internal */
-const fromArray$3 = (curves) => new CubicPath2dImpl(curves);
+const fromArray$3 = (curves) => {
+	invariant(curves.length > 0, "cubic path requires at least one curve");
+	return methods.fromArray(curves);
+};
 /** @internal */
-const append$3 = dual(2, (p, c) => fromArray$3([...p, c]));
+const append$3 = methods.append;
 /** @internal */
-const length$1 = (p) => {
-	let total = 0;
-	for (const curve of p) total += length$5(curve, unit);
-	return total;
-};
+const length$1 = methods.length;
 /** @internal */
-const solve$3 = dual(2, (p, u) => {
-	const curves = p instanceof CubicPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$7(curves.at(-1), 1);
-	const t = u * curves.length;
-	const i = Math.floor(t);
-	const curve = curves[i];
-	return solve$7(curve, t - i);
-});
-const cumulativeLengthCache = /* @__PURE__ */ new WeakMap();
-const getCumulativeLengths = (p) => {
-	let cached = cumulativeLengthCache.get(p);
-	if (cached === void 0) {
-		const lengths = [];
-		let total = 0;
-		for (const curve of p) {
-			total += length$5(curve, unit);
-			lengths.push(total);
-		}
-		cached = lengths;
-		cumulativeLengthCache.set(p, cached);
-	}
-	return cached;
-};
-const solveCurveByDistance = (curve, target, segmentLength) => {
-	if (target <= 0) return 0;
-	if (target >= segmentLength) return 1;
-	const derivative$1 = derivative(curve);
-	let t = target / segmentLength;
-	let lo = 0;
-	let hi = 1;
-	for (let iter = 0; iter < 16; iter++) {
-		const error = length$5(curve, make$6(0, t)) - target;
-		if (Math.abs(error) < 1e-10) return t;
-		if (error > 0) hi = t;
-		else lo = t;
-		const speed = magnitude(solve$8(derivative$1, t));
-		if (speed === 0) {
-			t = (lo + hi) / 2;
-			continue;
-		}
-		const next = t - error / speed;
-		t = next > lo && next < hi ? next : (lo + hi) / 2;
-	}
-	return t;
-};
+const solve$3 = methods.solve;
 /** @internal */
-const toPathData$1 = (p) => {
-	let result = "";
-	let prevEndX = NaN;
-	let prevEndY = NaN;
-	for (const curve of p) {
-		const c0x = curve.x.c0;
-		const c0y = curve.y.c0;
-		const c1x = curve.x.c1;
-		const c1y = curve.y.c1;
-		const c2x = curve.x.c2;
-		const c2y = curve.y.c2;
-		const c3x = curve.x.c3;
-		const c3y = curve.y.c3;
-		const startX = c0x;
-		const startY = c0y;
-		const ctrl1X = c0x + c1x / 3;
-		const ctrl1Y = c0y + c1y / 3;
-		const ctrl2X = c0x + 2 * c1x / 3 + c2x / 3;
-		const ctrl2Y = c0y + 2 * c1y / 3 + c2y / 3;
-		const endX = c0x + c1x + c2x + c3x;
-		const endY = c0y + c1y + c2y + c3y;
-		if (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY)) result += ` M ${startX},${startY}`;
-		result += ` C ${ctrl1X},${ctrl1Y} ${ctrl2X},${ctrl2Y} ${endX},${endY}`;
-		prevEndX = endX;
-		prevEndY = endY;
-	}
-	return result.slice(1);
-};
+const toPathData$1 = methods.toPathData;
 /** @internal */
-const isContinuous$1 = (p) => {
-	let prevEndX = NaN;
-	let prevEndY = NaN;
-	let first = true;
-	for (const curve of p) {
-		const startX = curve.x.c0;
-		const startY = curve.y.c0;
-		if (!first && (!epsEquals(startX, prevEndX) || !epsEquals(startY, prevEndY))) return false;
-		prevEndX = curve.x.c0 + curve.x.c1 + curve.x.c2 + curve.x.c3;
-		prevEndY = curve.y.c0 + curve.y.c1 + curve.y.c2 + curve.y.c3;
-		first = false;
-	}
-	return true;
-};
+const isContinuous$1 = methods.isContinuous;
 /** @internal */
 const asContinuous$1 = (p) => {
 	invariant(isContinuous$1(p), "cubic path is not continuous");
 	return p;
 };
 /** @internal */
-const isIncreasingX$1 = (p) => {
-	let prevEnd = Number.NEGATIVE_INFINITY;
-	for (const c of p) {
-		if (!isIncreasing(c.x, unit)) return false;
-		if (c.x.c0 < prevEnd - 1e-10) return false;
-		prevEnd = c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3;
-	}
-	return true;
-};
+const isIncreasingX$1 = methods.isIncreasingX;
 /** @internal */
-const isDecreasingX$1 = (p) => {
-	let prevEnd = Number.POSITIVE_INFINITY;
-	for (const c of p) {
-		if (!isDecreasing(c.x, unit)) return false;
-		if (c.x.c0 > prevEnd + 1e-10) return false;
-		prevEnd = c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3;
-	}
-	return true;
-};
+const isDecreasingX$1 = methods.isDecreasingX;
 /** @internal */
-const isMonotonicX$1 = (p) => isIncreasingX$1(p) || isDecreasingX$1(p);
+const isMonotonicX$1 = methods.isMonotonicX;
 /** @internal */
-const isIncreasingY$1 = (p) => {
-	let prevEnd = Number.NEGATIVE_INFINITY;
-	for (const c of p) {
-		if (!isIncreasing(c.y, unit)) return false;
-		if (c.y.c0 < prevEnd - 1e-10) return false;
-		prevEnd = c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3;
-	}
-	return true;
-};
+const isIncreasingY$1 = methods.isIncreasingY;
 /** @internal */
-const isDecreasingY$1 = (p) => {
-	let prevEnd = Number.POSITIVE_INFINITY;
-	for (const c of p) {
-		if (!isDecreasing(c.y, unit)) return false;
-		if (c.y.c0 > prevEnd + 1e-10) return false;
-		prevEnd = c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3;
-	}
-	return true;
-};
+const isDecreasingY$1 = methods.isDecreasingY;
 /** @internal */
-const isMonotonicY$1 = (p) => isIncreasingY$1(p) || isDecreasingY$1(p);
+const isMonotonicY$1 = methods.isMonotonicY;
 /** @internal */
 const asIncreasingX$1 = (p) => {
 	invariant(isIncreasingX$1(p), "cubic path is not increasing in x");
@@ -578,41 +518,54 @@ const asMonotonicY$1 = (p) => {
 	return p;
 };
 /** @internal */
-const solveAtX$1 = dual(2, (p, x) => {
-	for (const c of p) {
-		const sx = c.x.c0;
-		const ex = c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3;
-		const lo = Math.min(sx, ex);
-		const hi = Math.max(sx, ex);
-		if (x >= lo - 1e-10 && x <= hi + 1e-10) {
-			if (epsEquals(x, sx)) return one(c.y.c0);
-			if (epsEquals(x, ex)) return one(c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3);
-			const sol = solveAtX$5(c, x);
-			if (!isNone(sol)) return sol;
+const solveAtX$1 = methods.solveAtX;
+/** @internal */
+const solveAtY$1 = methods.solveAtY;
+/** @internal */
+const boundingBox$3 = methods.boundingBox;
+/** @internal */
+const transform$3 = methods.transform;
+const cumulativeLengthCache = /* @__PURE__ */ new WeakMap();
+const getCumulativeLengths = (p) => {
+	let cached = cumulativeLengthCache.get(p);
+	if (cached === void 0) {
+		const lengths = [];
+		let total = 0;
+		for (const curve of p) {
+			total += length$4(curve, unit);
+			lengths.push(total);
 		}
+		cached = lengths;
+		cumulativeLengthCache.set(p, cached);
 	}
-	return none;
-});
-/** @internal */
-const solveAtY$1 = dual(2, (p, y) => {
-	for (const c of p) {
-		const sy = c.y.c0;
-		const ey = c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3;
-		const lo = Math.min(sy, ey);
-		const hi = Math.max(sy, ey);
-		if (y >= lo - 1e-10 && y <= hi + 1e-10) {
-			if (epsEquals(y, sy)) return one(c.x.c0);
-			if (epsEquals(y, ey)) return one(c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3);
-			const sol = solveAtY$5(c, y);
-			if (!isNone(sol)) return sol;
+	return cached;
+};
+const solveCurveByDistance = (curve, target, segmentLength) => {
+	if (target <= 0) return 0;
+	if (target >= segmentLength) return 1;
+	const derivative$1 = derivative(curve);
+	let t = target / segmentLength;
+	let lo = 0;
+	let hi = 1;
+	for (let iter = 0; iter < 16; iter++) {
+		const error = length$4(curve, make$6(0, t)) - target;
+		if (Math.abs(error) <= 1e-12 * segmentLength) return t;
+		if (error > 0) hi = t;
+		else lo = t;
+		const speed = magnitude(solve$6(derivative$1, t));
+		if (speed === 0) {
+			t = (lo + hi) / 2;
+			continue;
 		}
+		const next = t - error / speed;
+		t = next > lo && next < hi ? next : (lo + hi) / 2;
 	}
-	return none;
-});
+	return t;
+};
 /** @internal */
 const solveByDistance$1 = dual(2, (p, s) => {
-	if (s <= 0) return solve$3(p, 0);
-	if (s >= 1) return solve$3(p, 1);
+	if (s <= 0) return methods.solve(p, 0);
+	if (s >= 1) return methods.solve(p, 1);
 	const lengths = getCumulativeLengths(p);
 	const target = s * lengths[lengths.length - 1];
 	let k = 0;
@@ -620,16 +573,9 @@ const solveByDistance$1 = dual(2, (p, s) => {
 	const segmentStart = k === 0 ? 0 : lengths[k - 1];
 	const segmentLength = lengths[k] - segmentStart;
 	const segmentTarget = target - segmentStart;
-	const curve = (p instanceof CubicPath2dImpl ? p.curves : [...p])[k];
+	const curve = (p instanceof Path2dImpl ? p.curves : [...p])[k];
 	return solve$7(curve, solveCurveByDistance(curve, segmentTarget, segmentLength));
 });
-/** @internal */
-const boundingBox$3 = (p) => {
-	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$7(iter.next().value);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$7(next.value));
-	return acc;
-};
 //#endregion
 //#region src/path/cubic2d.ts
 var cubic2d_exports = /* @__PURE__ */ __exportAll({
@@ -657,7 +603,8 @@ var cubic2d_exports = /* @__PURE__ */ __exportAll({
 	solveAtX: () => solveAtX,
 	solveAtY: () => solveAtY,
 	solveByDistance: () => solveByDistance,
-	toPathData: () => toPathData
+	toPathData: () => toPathData,
+	transform: () => transform$2
 });
 /**
 * Creates a new `CubicPath2d` instance from a sequence of curves.
@@ -808,6 +755,7 @@ const solveByDistance = solveByDistance$1;
 * @since 2.0.0
 */
 const boundingBox$2 = boundingBox$3;
+const transform$2 = transform$3;
 //#endregion
 //#region src/path/rationalCubic2d.internal.ts
 const RationalCubicPath2dTypeId = Symbol("curvy/path/rationalCubic2d");
@@ -835,17 +783,17 @@ const append$1 = dual(2, (p, c) => fromArray$1([...p, c]));
 /** @internal */
 const solve$1 = dual(2, (p, u) => {
 	const curves = p instanceof RationalCubicPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$9(curves.at(-1), 1);
+	if (u === 1) return solve$8(curves.at(-1), 1);
 	const t = u * curves.length;
 	const i = Math.floor(t);
 	const curve = curves[i];
-	return solve$9(curve, t - i);
+	return solve$8(curve, t - i);
 });
 /** @internal */
 const boundingBox$1 = dual(2, (p, tolerance) => {
 	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$8(iter.next().value, tolerance);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$8(next.value, tolerance));
+	let acc = boundingBox$6(iter.next().value, tolerance);
+	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$6(next.value, tolerance));
 	return acc;
 });
 /** @internal */
@@ -854,6 +802,12 @@ const approximateAsCubicPath$1 = dual(2, (p, tolerance) => {
 	for (const segment of p) for (const approx of approximateAsCubicCurves(segment, tolerance)) curves.push(approx);
 	return fromArray$2(curves);
 });
+/** @internal */
+const transform$1 = dual(2, (p, a) => {
+	const curves = [];
+	for (const segment of p) curves.push(transform$6(segment, a));
+	return fromArray$1(curves);
+});
 //#endregion
 //#region src/path/rationalCubic2d.ts
 var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
@@ -863,7 +817,8 @@ var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
 	fromArray: () => fromArray,
 	isRationalCubicPath2d: () => isRationalCubicPath2d,
 	make: () => make,
-	solve: () => solve
+	solve: () => solve,
+	transform: () => transform
 });
 /**
 * Checks if a value is a `RationalCubicPath2d`.
@@ -893,7 +848,8 @@ const append = append$1;
 const solve = solve$1;
 const boundingBox = boundingBox$1;
 const approximateAsCubicPath = approximateAsCubicPath$1;
+const transform = transform$1;
 //#endregion
-export { fromArray$4 as a, make$2 as i, rationalCubic2d_exports as n, linear2d_exports as o, cubic2d_exports as r, fromArray as t };
+export { fromArray$4 as a, make$2 as i, rationalCubic2d_exports as n, linear2d_exports as o, cubic2d_exports as r, makeMethods as s, fromArray as t };
 
-//# sourceMappingURL=rationalCubic2d-H1J2Fjyy.mjs.map
+//# sourceMappingURL=rationalCubic2d-CZiP8nIq.mjs.map