curvy 2.0.0-alpha.11 → 2.0.0-alpha.13

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

@@ -2,11 +2,383 @@ 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$4, p as unit } from "./interval-Dm35Xhy4.mjs";
-import { o as none, r as isNone, s as one } from "./solution-B6KY1E7M.mjs";
-import { a as isIncreasing, i as isDecreasing } from "./cubic-DHJrzZJN.mjs";
-import { a as union } from "./interval2d-DPmvk_Qe.mjs";
-import { _ as solve$5, a as boundingBox$2, d as solveAtX$2, f as solveAtY$2, i as solve$6, l as length$2, p as derivative, t as approximateAsCubicCurves, u as solve$4 } from "./rationalCubic2d-IroMR6AA.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;
+	curves;
+	constructor(curves) {
+		super();
+		this.curves = curves;
+	}
+	[Symbol.iterator]() {
+		return this.curves[Symbol.iterator]();
+	}
+};
+/** @internal */
+const isLinearPath2d$1 = (p) => typeof p === "object" && p !== null && LinearPath2dTypeId in p;
+/** @internal */
+const make$5 = (...curves) => new LinearPath2dImpl(curves);
+/** @internal */
+const fromArray$5 = (curves) => new LinearPath2dImpl(curves);
+/** @internal */
+const append$5 = dual(2, (p, c) => fromArray$5([...p, c]));
+/** @internal */
+const length$3 = (p) => {
+	let total = 0;
+	for (const curve of p) total += length$4(curve, unit);
+	return total;
+};
+/** @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);
+});
+/** @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);
+};
+/** @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;
+};
+/** @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;
+};
+/** @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;
+};
+/** @internal */
+const isMonotonicX$3 = (p) => isIncreasingX$3(p) || isDecreasingX$3(p);
+/** @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;
+};
+/** @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;
+};
+/** @internal */
+const isMonotonicY$3 = (p) => isIncreasingY$3(p) || isDecreasingY$3(p);
+/** @internal */
+const asIncreasingX$3 = (p) => {
+	invariant(isIncreasingX$3(p), "linear path is not increasing in x");
+	return p;
+};
+/** @internal */
+const asDecreasingX$3 = (p) => {
+	invariant(isDecreasingX$3(p), "linear path is not decreasing in x");
+	return p;
+};
+/** @internal */
+const asMonotonicX$3 = (p) => {
+	invariant(isMonotonicX$3(p), "linear path is not monotonic in x");
+	return p;
+};
+/** @internal */
+const asIncreasingY$3 = (p) => {
+	invariant(isIncreasingY$3(p), "linear path is not increasing in y");
+	return p;
+};
+/** @internal */
+const asDecreasingY$3 = (p) => {
+	invariant(isDecreasingY$3(p), "linear path is not decreasing in y");
+	return p;
+};
+/** @internal */
+const asMonotonicY$3 = (p) => {
+	invariant(isMonotonicY$3(p), "linear path is not monotonic in y");
+	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;
+});
+/** @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;
+});
+/** @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;
+};
+//#endregion
+//#region src/path/linear2d.ts
+var linear2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append$4,
+	asContinuous: () => asContinuous$2,
+	asDecreasingX: () => asDecreasingX$2,
+	asDecreasingY: () => asDecreasingY$2,
+	asIncreasingX: () => asIncreasingX$2,
+	asIncreasingY: () => asIncreasingY$2,
+	asMonotonicX: () => asMonotonicX$2,
+	asMonotonicY: () => asMonotonicY$2,
+	boundingBox: () => boundingBox$4,
+	fromArray: () => fromArray$4,
+	isContinuous: () => isContinuous$2,
+	isDecreasingX: () => isDecreasingX$2,
+	isDecreasingY: () => isDecreasingY$2,
+	isIncreasingX: () => isIncreasingX$2,
+	isIncreasingY: () => isIncreasingY$2,
+	isLinearPath2d: () => isLinearPath2d,
+	isMonotonicX: () => isMonotonicX$2,
+	isMonotonicY: () => isMonotonicY$2,
+	length: () => length$2,
+	make: () => make$4,
+	solve: () => solve$4,
+	solveAtX: () => solveAtX$2,
+	solveAtY: () => solveAtY$2,
+	toPathData: () => toPathData$2
+});
+/**
+* Creates a new `LinearPath2d` instance from a sequence of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `LinearPath2d` instance.
+* @since 2.0.0
+*/
+const make$4 = make$5;
+/**
+* Creates a new `LinearPath2d` instance from an array of curves.
+*
+* @param curves - The curves to create the path from.
+* @returns A new `LinearPath2d` instance.
+* @since 2.0.0
+*/
+const fromArray$4 = fromArray$5;
+/**
+* Checks if a value is a `LinearPath2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `LinearPath2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isLinearPath2d = isLinearPath2d$1;
+const append$4 = append$5;
+/**
+* Calculates the length of a linear path.
+*
+* @param p - The linear path to calculate the length of.
+* @returns The length of the linear path.
+* @since 1.0.0
+*/
+const length$2 = length$3;
+const solve$4 = solve$5;
+/**
+* Serializes a linear path as an SVG path data string (the value of a `<path>`
+* element's `d` attribute), using `M` and `L` commands. Discontinuities between
+* curves emit a fresh `M` command.
+*
+* @param p - The linear path to serialize.
+* @returns The SVG path data string.
+* @since 2.0.0
+*/
+const toPathData$2 = toPathData$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & Continuous>` when adjacent curves connect at their join
+* points.
+*
+* @param p - The linear path to check.
+* @returns `true` when the path is continuous (G⁰).
+* @since 2.0.0
+*/
+const isContinuous$2 = isContinuous$3;
+/**
+* Asserts that the linear path is continuous, throwing on failure.
+*
+* @param p - The linear path to assert against.
+* @returns The same path, typed with the `Continuous` brand.
+* @throws When the path has a discontinuity between adjacent curves.
+* @since 2.0.0
+*/
+const asContinuous$2 = asContinuous$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & IncreasingX>` when every segment's x-polynomial is
+* strictly increasing and adjacent segments' x-ranges don't overlap.
+*
+* @since 2.0.0
+*/
+const isIncreasingX$2 = isIncreasingX$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & DecreasingX>` when every segment's x-polynomial is
+* strictly decreasing and adjacent segments' x-ranges don't overlap.
+*
+* @since 2.0.0
+*/
+const isDecreasingX$2 = isDecreasingX$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & MonotonicX>` when the path is either increasing or
+* decreasing in x along its full parameter domain.
+*
+* @since 2.0.0
+*/
+const isMonotonicX$2 = isMonotonicX$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & IncreasingY>`. The y-axis analog of {@link isIncreasingX}.
+*
+* @since 2.0.0
+*/
+const isIncreasingY$2 = isIncreasingY$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & DecreasingY>`. The y-axis analog of {@link isDecreasingX}.
+*
+* @since 2.0.0
+*/
+const isDecreasingY$2 = isDecreasingY$3;
+/**
+* Type-narrowing predicate: refines `LinearPath2d<T>` to
+* `LinearPath2d<T & MonotonicY>`. The y-axis analog of {@link isMonotonicX}.
+*
+* @since 2.0.0
+*/
+const isMonotonicY$2 = isMonotonicY$3;
+/**
+* Asserts that the path is strictly increasing in x, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asIncreasingX$2 = asIncreasingX$3;
+/**
+* Asserts that the path is strictly decreasing in x, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asDecreasingX$2 = asDecreasingX$3;
+/**
+* Asserts that the path is monotonic in x, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asMonotonicX$2 = asMonotonicX$3;
+/**
+* Asserts that the path is strictly increasing in y, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asIncreasingY$2 = asIncreasingY$3;
+/**
+* Asserts that the path is strictly decreasing in y, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asDecreasingY$2 = asDecreasingY$3;
+/**
+* Asserts that the path is monotonic in y, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asMonotonicY$2 = asMonotonicY$3;
+const solveAtX$2 = solveAtX$3;
+const solveAtY$2 = solveAtY$3;
+/**
+* Computes the axis-aligned bounding box of the path — the smallest closed
+* `Box2d` enclosing every segment.
+*
+* @param p - The linear path.
+* @returns A closed `Box2d` enclosing the path.
+* @since 2.0.0
+*/
+const boundingBox$4 = boundingBox$5;
+//#endregion
 //#region src/path/cubic2d.internal.ts
 const CubicPath2dTypeId = Symbol("curvy/path/cubic2d");
 /** @internal */
@@ -33,17 +405,17 @@ const append$3 = dual(2, (p, c) => fromArray$3([...p, c]));
 /** @internal */
 const length$1 = (p) => {
 	let total = 0;
-	for (const curve of p) total += length$2(curve, unit);
+	for (const curve of p) total += length$5(curve, unit);
 	return total;
 };
 /** @internal */
 const solve$3 = dual(2, (p, u) => {
 	const curves = p instanceof CubicPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$4(curves.at(-1), 1);
+	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$4(curve, t - i);
+	return solve$7(curve, t - i);
 });
 const cumulativeLengthCache = /* @__PURE__ */ new WeakMap();
 const getCumulativeLengths = (p) => {
@@ -52,7 +424,7 @@ const getCumulativeLengths = (p) => {
 		const lengths = [];
 		let total = 0;
 		for (const curve of p) {
-			total += length$2(curve, unit);
+			total += length$5(curve, unit);
 			lengths.push(total);
 		}
 		cached = lengths;
@@ -68,11 +440,11 @@ const solveCurveByDistance = (curve, target, segmentLength) => {
 	let lo = 0;
 	let hi = 1;
 	for (let iter = 0; iter < 16; iter++) {
-		const error = length$2(curve, make$4(0, t)) - target;
+		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$5(derivative$1, t));
+		const speed = magnitude(solve$8(derivative$1, t));
 		if (speed === 0) {
 			t = (lo + hi) / 2;
 			continue;
@@ -215,7 +587,7 @@ const solveAtX$1 = dual(2, (p, x) => {
 		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$2(c, x);
+			const sol = solveAtX$5(c, x);
 			if (!isNone(sol)) return sol;
 		}
 	}
@@ -231,7 +603,7 @@ const solveAtY$1 = dual(2, (p, y) => {
 		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$2(c, y);
+			const sol = solveAtY$5(c, y);
 			if (!isNone(sol)) return sol;
 		}
 	}
@@ -249,13 +621,13 @@ const solveByDistance$1 = dual(2, (p, s) => {
 	const segmentLength = lengths[k] - segmentStart;
 	const segmentTarget = target - segmentStart;
 	const curve = (p instanceof CubicPath2dImpl ? p.curves : [...p])[k];
-	return solve$4(curve, solveCurveByDistance(curve, segmentTarget, segmentLength));
+	return solve$7(curve, solveCurveByDistance(curve, segmentTarget, segmentLength));
 });
 /** @internal */
-const boundingBox$1 = (p) => {
+const boundingBox$3 = (p) => {
 	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$2(iter.next().value);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$2(next.value));
+	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
@@ -269,7 +641,7 @@ var cubic2d_exports = /* @__PURE__ */ __exportAll({
 	asIncreasingY: () => asIncreasingY,
 	asMonotonicX: () => asMonotonicX,
 	asMonotonicY: () => asMonotonicY,
-	boundingBox: () => boundingBox,
+	boundingBox: () => boundingBox$2,
 	fromArray: () => fromArray$2,
 	isContinuous: () => isContinuous,
 	isCubicPath2d: () => isCubicPath2d,
@@ -435,7 +807,7 @@ const solveByDistance = solveByDistance$1;
 * @returns A closed `Box2d` enclosing the path.
 * @since 2.0.0
 */
-const boundingBox = boundingBox$1;
+const boundingBox$2 = boundingBox$3;
 //#endregion
 //#region src/path/rationalCubic2d.internal.ts
 const RationalCubicPath2dTypeId = Symbol("curvy/path/rationalCubic2d");
@@ -463,11 +835,18 @@ 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$6(curves.at(-1), 1);
+	if (u === 1) return solve$9(curves.at(-1), 1);
 	const t = u * curves.length;
 	const i = Math.floor(t);
 	const curve = curves[i];
-	return solve$6(curve, t - i);
+	return solve$9(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));
+	return acc;
 });
 /** @internal */
 const approximateAsCubicPath$1 = dual(2, (p, tolerance) => {
@@ -480,6 +859,7 @@ const approximateAsCubicPath$1 = dual(2, (p, tolerance) => {
 var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append,
 	approximateAsCubicPath: () => approximateAsCubicPath,
+	boundingBox: () => boundingBox,
 	fromArray: () => fromArray,
 	isRationalCubicPath2d: () => isRationalCubicPath2d,
 	make: () => make,
@@ -511,8 +891,9 @@ const make = make$1;
 const fromArray = fromArray$1;
 const append = append$1;
 const solve = solve$1;
+const boundingBox = boundingBox$1;
 const approximateAsCubicPath = approximateAsCubicPath$1;
 //#endregion
-export { make$2 as i, rationalCubic2d_exports as n, 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, fromArray as t };
 
-//# sourceMappingURL=rationalCubic2d-nN-oSrLr.mjs.map
+//# sourceMappingURL=rationalCubic2d-H1J2Fjyy.mjs.map