curvy 2.0.0-alpha.10 → 2.0.0-alpha.12

package/dist/characteristic/index.mjs

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

package/dist/curve/index.mjs

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

package/dist/interval/index.mjs

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

package/dist/interval/interval.d.ts

@@ -240,6 +240,20 @@ export declare const contains: {
      */
     (value: number): (interval: Interval) => boolean;
 };
+/**
+ * Float-tolerant containment: returns `true` if `value` is in the interval or
+ * within `eps` of either boundary. Endpoint inclusivity is ignored — at the
+ * `EPSILON` scale the open/closed distinction loses meaning, and the use case
+ * is "is this query approximately in this range, accounting for float drift?".
+ * Use {@link contains} if you need kind-strict semantics.
+ *
+ * @param interval - The interval to check against.
+ * @param value - The value to check.
+ * @param eps - The absolute tolerance. Defaults to {@link EPSILON}.
+ * @returns `true` when `interval.start - eps <= value <= interval.end + eps`.
+ * @since 2.0.0
+ */
+export declare const containsApprox: (interval: Interval, value: number, eps?: number) => boolean;
 export declare const containsInterval: {
     /**
      * Checks if `inner` is a subset of `outer` — every point of `inner` is also

package/dist/path/index.mjs

@@ -1,373 +1,12 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
 import { epsEquals } from "../number.mjs";
-import { p as unit } from "../shared/interval-CqC3ZIqj.mjs";
-import { o as none } from "../shared/solution-UKGK826h.mjs";
-import { d as isIncreasing, n as isDecreasing$1, r as isIncreasing$1, u as isDecreasing } from "../shared/quadratic-Dlxqo2V1.mjs";
-import { a as union } from "../shared/interval2d-C0eduE-V.mjs";
-import { C as solve$4, T as solveAtY$4, _ as solve$5, b as boundingBox$4, h as length$5, m as boundingBox$5, v as solveAtX$5, w as solveAtX$4, x as length$4, y as solveAtY$5 } from "../shared/rationalCubic2d-3S5K69Jy.mjs";
-import { n as rationalCubic2d_exports, r as cubic2d_exports } from "../shared/rationalCubic2d-CJY-feGw.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$3 = (...curves) => new LinearPath2dImpl(curves);
-/** @internal */
-const fromArray$3 = (curves) => new LinearPath2dImpl(curves);
-/** @internal */
-const append$3 = dual(2, (p, c) => fromArray$3([...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$3 = dual(2, (p, u) => {
-	const curves = p instanceof LinearPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$4(curves.at(-1), 1);
-	const t = u * curves.length;
-	const i = Math.floor(t);
-	const curve = curves[i];
-	return solve$4(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(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(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(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(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) return solveAtX$4(c, x);
-	}
-	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) return solveAtY$4(c, y);
-	}
-	return none;
-});
-/** @internal */
-const boundingBox$3 = (p) => {
-	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$4(iter.next().value);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$4(next.value));
-	return acc;
-};
-//#endregion
-//#region src/path/linear2d.ts
-var linear2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append$2,
-	asContinuous: () => asContinuous$2,
-	asDecreasingX: () => asDecreasingX$2,
-	asDecreasingY: () => asDecreasingY$2,
-	asIncreasingX: () => asIncreasingX$2,
-	asIncreasingY: () => asIncreasingY$2,
-	asMonotonicX: () => asMonotonicX$2,
-	asMonotonicY: () => asMonotonicY$2,
-	boundingBox: () => boundingBox$2,
-	fromArray: () => fromArray$2,
-	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$2,
-	solve: () => solve$2,
-	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$2 = make$3;
-/**
-* 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$2 = fromArray$3;
-/**
-* 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$2 = append$3;
-/**
-* 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$2 = solve$3;
-/**
-* 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$2 = boundingBox$3;
-//#endregion
+import { p as unit } from "../shared/interval-Dm35Xhy4.mjs";
+import { o as none, r as isNone, s as one } from "../shared/solution-B6KY1E7M.mjs";
+import { n as isDecreasing, r as isIncreasing } from "../shared/quadratic-BZmfZE71.mjs";
+import { a as union } from "../shared/interval2d-DPmvk_Qe.mjs";
+import { _ as solve$2, h as length$2, m as boundingBox$2, v as solveAtX$2, y as solveAtY$2 } from "../shared/rationalCubic2d-D5g3_hTV.mjs";
+import { n as rationalCubic2d_exports, o as linear2d_exports, r as cubic2d_exports } from "../shared/rationalCubic2d-MojACId0.mjs";
 //#region src/path/quadratic2d.internal.ts
 const QuadraticPath2dTypeId = Symbol("curvy/path/quadratic2d");
 /** @internal */
@@ -393,17 +32,17 @@ const append$1 = dual(2, (p, c) => fromArray$1([...p, c]));
 /** @internal */
 const length$1 = (p) => {
 	let total = 0;
-	for (const curve of p) total += length$5(curve, unit);
+	for (const curve of p) total += length$2(curve, unit);
 	return total;
 };
 /** @internal */
 const solve$1 = dual(2, (p, u) => {
 	const curves = p instanceof QuadraticPath2dImpl ? p.curves : [...p];
-	if (u === 1) return solve$5(curves.at(-1), 1);
+	if (u === 1) return solve$2(curves.at(-1), 1);
 	const t = u * curves.length;
 	const i = Math.floor(t);
 	const curve = curves[i];
-	return solve$5(curve, t - i);
+	return solve$2(curve, t - i);
 });
 /** @internal */
 const toPathData$1 = (p) => {
@@ -454,7 +93,7 @@ const asContinuous$1 = (p) => {
 const isIncreasingX$1 = (p) => {
 	let prevEnd = Number.NEGATIVE_INFINITY;
 	for (const c of p) {
-		if (!isIncreasing$1(c.x, unit)) return false;
+		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;
 	}
@@ -464,7 +103,7 @@ const isIncreasingX$1 = (p) => {
 const isDecreasingX$1 = (p) => {
 	let prevEnd = Number.POSITIVE_INFINITY;
 	for (const c of p) {
-		if (!isDecreasing$1(c.x, unit)) return false;
+		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;
 	}
@@ -476,7 +115,7 @@ const isMonotonicX$1 = (p) => isIncreasingX$1(p) || isDecreasingX$1(p);
 const isIncreasingY$1 = (p) => {
 	let prevEnd = Number.NEGATIVE_INFINITY;
 	for (const c of p) {
-		if (!isIncreasing$1(c.y, unit)) return false;
+		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;
 	}
@@ -486,7 +125,7 @@ const isIncreasingY$1 = (p) => {
 const isDecreasingY$1 = (p) => {
 	let prevEnd = Number.POSITIVE_INFINITY;
 	for (const c of p) {
-		if (!isDecreasing$1(c.y, unit)) return false;
+		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;
 	}
@@ -531,7 +170,12 @@ const solveAtX$1 = dual(2, (p, x) => {
 		const ex = c.x.c0 + c.x.c1 + c.x.c2;
 		const lo = Math.min(sx, ex);
 		const hi = Math.max(sx, ex);
-		if (x >= lo - 1e-10 && x <= hi + 1e-10) return solveAtX$5(c, 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);
+			const sol = solveAtX$2(c, x);
+			if (!isNone(sol)) return sol;
+		}
 	}
 	return none;
 });
@@ -542,15 +186,20 @@ const solveAtY$1 = dual(2, (p, y) => {
 		const ey = c.y.c0 + c.y.c1 + c.y.c2;
 		const lo = Math.min(sy, ey);
 		const hi = Math.max(sy, ey);
-		if (y >= lo - 1e-10 && y <= hi + 1e-10) return solveAtY$5(c, 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);
+			const sol = solveAtY$2(c, y);
+			if (!isNone(sol)) return sol;
+		}
 	}
 	return none;
 });
 /** @internal */
 const boundingBox$1 = (p) => {
 	const iter = p[Symbol.iterator]();
-	let acc = boundingBox$5(iter.next().value);
-	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$5(next.value));
+	let acc = boundingBox$2(iter.next().value);
+	for (let next = iter.next(); !next.done; next = iter.next()) acc = union(acc, boundingBox$2(next.value));
 	return acc;
 };
 //#endregion