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

package/dist/splines/index.mjs

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
 import { epsEquals } from "../number.mjs";
-import { a as make$10, c as subtract, i as magnitude, o as makeWeighted, r as isVector2, s as scale, t as add } from "../shared/vector2-CSkaMXvp.mjs";
-import { t as make$11 } from "../shared/vector3-CR2LPV03.mjs";
-import { n as transpose, t as make$12 } from "../shared/vector4-PO_7EYd-.mjs";
+import { a as make$12, c as subtract, i as magnitude, o as makeWeighted, r as isVector2, s as scale, t as add } from "../shared/vector2-CSkaMXvp.mjs";
+import { t as make$13 } from "../shared/vector3-CR2LPV03.mjs";
+import { n as transpose, t as make$14 } from "../shared/vector4-PO_7EYd-.mjs";
 import { a as vectorProductLeft, i as multiply, t as inverse } from "../shared/matrix4x4-BWmf4lZM.mjs";
-import { o as none, s as one } from "../shared/solution-B6KY1E7M.mjs";
-import { c as fromPolynomials, n as fromBezierPoints, s as fromCoefficients } from "../shared/rationalCubic2d-IroMR6AA.mjs";
-import { a as cubicHermite, i as cubicBezier, r as cubicBasisSpline, t as apply } from "../shared/characteristic-Hb7F8SBw.mjs";
-import { i as make$13, t as fromArray$10 } from "../shared/rationalCubic2d-nN-oSrLr.mjs";
+import { o as none, s as one } from "../shared/solution-B2JdOZpe.mjs";
+import { S as fromEndpoints, c as fromCoefficients, l as fromPolynomials, r as fromBezierPoints } from "../shared/rationalCubic2d-CeHgpNht.mjs";
+import { a as cubicHermite, i as cubicBezier, r as cubicBasisSpline, t as apply } from "../shared/characteristic-BkEr-rr8.mjs";
+import { a as fromArray$13, i as make$15, t as fromArray$12 } from "../shared/rationalCubic2d-H1J2Fjyy.mjs";
 //#region src/splines/rationalBezier2d.internal.ts
 const RationalBezier2dTypeId = Symbol("curvy/splines/rationalBezier2d");
 var RationalBezier2dImpl = class extends Pipeable {
@@ -26,34 +26,34 @@ var RationalBezier2dImpl = class extends Pipeable {
 };
 /** @internal */
 const isRationalBezier2d$1 = (p) => typeof p === "object" && p !== null && RationalBezier2dTypeId in p;
-const lift = (p) => make$11(p.x * p.weight, p.y * p.weight, p.weight);
+const lift = (p) => make$13(p.x * p.weight, p.y * p.weight, p.weight);
 /** @internal */
-const make$9 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
+const make$11 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
 	lift(p0),
 	lift(p1),
 	lift(p2),
 	lift(p3)
 ]);
 /** @internal */
-const fromArray$9 = (points) => new RationalBezier2dImpl(points.map(lift));
+const fromArray$11 = (points) => new RationalBezier2dImpl(points.map(lift));
 /** @internal */
-const fromTuples$9 = (tuples) => new RationalBezier2dImpl(tuples.map(([x, y, weight]) => make$11(x * weight, y * weight, weight)));
+const fromTuples$11 = (tuples) => new RationalBezier2dImpl(tuples.map(([x, y, weight]) => make$13(x * weight, y * weight, weight)));
 /** @internal */
 const fromPoints$1 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
-	make$11(p0.x, p0.y, 1),
-	make$11(p1.x, p1.y, 1),
-	make$11(p2.x, p2.y, 1),
-	make$11(p3.x, p3.y, 1)
+	make$13(p0.x, p0.y, 1),
+	make$13(p1.x, p1.y, 1),
+	make$13(p2.x, p2.y, 1),
+	make$13(p3.x, p3.y, 1)
 ]);
 /** @internal */
 const fromBezier$1 = (b) => {
 	const homogeneous = [];
-	for (const p of b) homogeneous.push(make$11(p.x, p.y, 1));
+	for (const p of b) homogeneous.push(make$13(p.x, p.y, 1));
 	return new RationalBezier2dImpl(homogeneous);
 };
 const homogeneousOf = (r) => r instanceof RationalBezier2dImpl ? r.homogeneous : Array.from(r, lift);
 /** @internal */
-const toPath$9 = (r) => {
+const toPath$11 = (r) => {
 	const homogeneous = homogeneousOf(r);
 	const segmentCount = (homogeneous.length - 1) / 3;
 	const curves = [];
@@ -65,7 +65,7 @@ const toPath$9 = (r) => {
 		const h3 = homogeneous[base + 3];
 		curves.push(fromBezierPoints(makeWeighted(h0.x / h0.z, h0.y / h0.z, h0.z), makeWeighted(h1.x / h1.z, h1.y / h1.z, h1.z), makeWeighted(h2.x / h2.z, h2.y / h2.z, h2.z), makeWeighted(h3.x / h3.z, h3.y / h3.z, h3.z)));
 	}
-	return fromArray$10(curves);
+	return fromArray$12(curves);
 };
 /** @internal */
 const subdivide$3 = dual(2, (r, u) => {
@@ -97,12 +97,12 @@ const subdivide$3 = dual(2, (r, u) => {
 	const sx = r0x + (r1x - r0x) * localT;
 	const sy = r0y + (r1y - r0y) * localT;
 	const sw = r0w + (r1w - r0w) * localT;
-	const q0 = make$11(q0x, q0y, q0w);
-	const r0 = make$11(r0x, r0y, r0w);
-	const sLeft = make$11(sx, sy, sw);
-	const sRight = make$11(sx, sy, sw);
-	const r1 = make$11(r1x, r1y, r1w);
-	const q2 = make$11(q2x, q2y, q2w);
+	const q0 = make$13(q0x, q0y, q0w);
+	const r0 = make$13(r0x, r0y, r0w);
+	const sLeft = make$13(sx, sy, sw);
+	const sRight = make$13(sx, sy, sw);
+	const r1 = make$13(r1x, r1y, r1w);
+	const q2 = make$13(q2x, q2y, q2w);
 	const leftPoints = [
 		...homogeneous.slice(0, i * 3 + 1),
 		q0,
@@ -124,7 +124,7 @@ const toBezierPoints = (r) => {
 	const points = [];
 	for (const h of homogeneous) {
 		if (!epsEquals(h.z, w0)) return none;
-		points.push(make$10(h.x / h.z, h.y / h.z));
+		points.push(make$12(h.x / h.z, h.y / h.z));
 	}
 	return one(points);
 };
@@ -202,18 +202,18 @@ var Bezier2dImpl = class extends Pipeable {
 /** @internal */
 const isCubicBezier2d$1 = (p) => typeof p === "object" && p !== null && Bezier2dTypeId in p;
 /** @internal */
-const make$8 = (p0, p1, p2, p3) => new Bezier2dImpl([
+const make$10 = (p0, p1, p2, p3) => new Bezier2dImpl([
 	p0,
 	p1,
 	p2,
 	p3
 ]);
 /** @internal */
-const fromArray$8 = (points) => new Bezier2dImpl(points);
+const fromArray$10 = (points) => new Bezier2dImpl(points);
 /** @internal */
-const fromTuples$8 = (tuples) => new Bezier2dImpl(tuples.map(([x, y]) => make$10(x, y)));
+const fromTuples$10 = (tuples) => new Bezier2dImpl(tuples.map(([x, y]) => make$12(x, y)));
 /** @internal */
-const append$7 = dual(4, (p, p1, p2, p3) => new Bezier2dImpl((p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)));
+const append$9 = dual(4, (p, p1, p2, p3) => new Bezier2dImpl((p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)));
 /** @internal */
 const fromBasis = (p, matrix, stride) => {
 	const conversion = getConversionMatrix(matrix);
@@ -221,19 +221,19 @@ const fromBasis = (p, matrix, stride) => {
 	let x;
 	let y;
 	for (const [p0, p1, p2, p3] of toPointQuads(p, stride)) {
-		x = vectorProductLeft(conversion, make$12(p0.x, p1.x, p2.x, p3.x));
-		y = vectorProductLeft(conversion, make$12(p0.y, p1.y, p2.y, p3.y));
-		points.push(make$10(x.x, y.x), make$10(x.y, y.y), make$10(x.z, y.z));
+		x = vectorProductLeft(conversion, make$14(p0.x, p1.x, p2.x, p3.x));
+		y = vectorProductLeft(conversion, make$14(p0.y, p1.y, p2.y, p3.y));
+		points.push(make$12(x.x, y.x), make$12(x.y, y.y), make$12(x.z, y.z));
 	}
-	if (x && y) points.push(make$10(x.w, y.w));
-	return fromArray$8(points);
+	if (x && y) points.push(make$12(x.w, y.w));
+	return fromArray$10(points);
 };
 /** @internal */
 const appendTangentAligned$1 = dual(4, (p, a, p5, p6) => {
 	const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
 	const p2 = points[points.length - 2];
 	const p3 = points[points.length - 1];
-	return append$7(p, make$10(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a), p5, p6);
+	return append$9(p, make$12(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a), p5, p6);
 });
 /** @internal */
 const appendCurvatureAligned$1 = dual(4, (p, a, b, p6) => {
@@ -241,7 +241,7 @@ const appendCurvatureAligned$1 = dual(4, (p, a, b, p6) => {
 	const p1 = points[points.length - 3];
 	const p2 = points[points.length - 2];
 	const p3 = points[points.length - 1];
-	return append$7(p, make$10(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a), make$10(p3.x + (p3.x - p2.x) * (2 * a + a ** 2 + b / 2) + (p1.x - p2.x) * a ** 2, p3.y + (p3.y - p2.y) * (2 * a + a ** 2 + b / 2) + (p1.y - p2.y) * a ** 2), p6);
+	return append$9(p, make$12(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a), make$12(p3.x + (p3.x - p2.x) * (2 * a + a ** 2 + b / 2) + (p1.x - p2.x) * a ** 2, p3.y + (p3.y - p2.y) * (2 * a + a ** 2 + b / 2) + (p1.y - p2.y) * a ** 2), p6);
 });
 /** @internal */
 const appendVelocityAligned$1 = dual(3, (p, p5, p6) => appendTangentAligned$1(p, 1, p5, p6));
@@ -251,10 +251,10 @@ const appendAccelerationAligned$1 = dual(2, (p, p6) => {
 	const p1 = points[points.length - 3];
 	const p2 = points[points.length - 2];
 	const p3 = points[points.length - 1];
-	return append$7(p, make$10(2 * p3.x - p2.x, 2 * p3.y - p2.y), make$10(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y)), p6);
+	return append$9(p, make$12(2 * p3.x - p2.x, 2 * p3.y - p2.y), make$12(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y)), p6);
 });
 /** @internal */
-const toPath$8 = (p) => make$13(...toCurves(p, cubicBezier, 3));
+const toPath$10 = (p) => make$15(...toCurves(p, cubicBezier, 3));
 /** @internal */
 const fromRational$1 = (r) => {
 	const points = toBezierPoints(r);
@@ -285,12 +285,12 @@ const subdivide$2 = dual(2, (b, u) => {
 	const r1y = q1y + (q2y - q1y) * localT;
 	const sx = r0x + (r1x - r0x) * localT;
 	const sy = r0y + (r1y - r0y) * localT;
-	const q0 = make$10(q0x, q0y);
-	const r0 = make$10(r0x, r0y);
-	const sLeft = make$10(sx, sy);
-	const sRight = make$10(sx, sy);
-	const r1 = make$10(r1x, r1y);
-	const q2 = make$10(q2x, q2y);
+	const q0 = make$12(q0x, q0y);
+	const r0 = make$12(r0x, r0y);
+	const sLeft = make$12(sx, sy);
+	const sRight = make$12(sx, sy);
+	const r1 = make$12(r1x, r1y);
+	const q2 = make$12(q2x, q2y);
 	const leftPoints = [
 		...points.slice(0, i * 3 + 1),
 		q0,
@@ -308,18 +308,18 @@ const subdivide$2 = dual(2, (b, u) => {
 //#endregion
 //#region src/splines/bezier2d.ts
 var bezier2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append$6,
+	append: () => append$8,
 	appendAccelerationAligned: () => appendAccelerationAligned,
 	appendCurvatureAligned: () => appendCurvatureAligned,
 	appendTangentAligned: () => appendTangentAligned,
 	appendVelocityAligned: () => appendVelocityAligned,
-	fromArray: () => fromArray$7,
+	fromArray: () => fromArray$9,
 	fromRational: () => fromRational,
-	fromTuples: () => fromTuples$7,
+	fromTuples: () => fromTuples$9,
 	isCubicBezier2d: () => isCubicBezier2d,
-	make: () => make$7,
+	make: () => make$9,
 	subdivide: () => subdivide$1,
-	toPath: () => toPath$7
+	toPath: () => toPath$9
 });
 /**
 * Creates a new `Bezier2d` instance.
@@ -331,7 +331,7 @@ var bezier2d_exports = /* @__PURE__ */ __exportAll({
 * @returns A new `Bezier2d` instance.
 * @since 1.0.0
 */
-const make$7 = make$8;
+const make$9 = make$10;
 /**
 * Creates a new `Bezier2d` instance from an array of control points.
 *
@@ -339,7 +339,7 @@ const make$7 = make$8;
 * @returns A new `Bezier2d` instance.
 * @since 1.0.0
 */
-const fromArray$7 = fromArray$8;
+const fromArray$9 = fromArray$10;
 /**
 * Creates a new `Bezier2d` from an array of `[x, y]` tuples. Convenient for
 * data sourced from JSON, CSV, or other tuple-shaped formats.
@@ -348,7 +348,7 @@ const fromArray$7 = fromArray$8;
 * @returns A new `Bezier2d` instance.
 * @since 2.0.0
 */
-const fromTuples$7 = fromTuples$8;
+const fromTuples$9 = fromTuples$10;
 /**
 * Checks if a value is a `Bezier2d`.
 *
@@ -357,7 +357,7 @@ const fromTuples$7 = fromTuples$8;
 * @since 1.0.0
 */
 const isCubicBezier2d = isCubicBezier2d$1;
-const append$6 = append$7;
+const append$8 = append$9;
 const appendTangentAligned = appendTangentAligned$1;
 const appendCurvatureAligned = appendCurvatureAligned$1;
 const appendVelocityAligned = appendVelocityAligned$1;
@@ -369,7 +369,7 @@ const appendAccelerationAligned = appendAccelerationAligned$1;
 * @returns A new `CubicPath2d` instance representing the same curve as the `Bezier2d`.
 * @since 1.0.0
 */
-const toPath$7 = toPath$8;
+const toPath$9 = toPath$10;
 /**
 * Attempts to lower a `RationalBezier2d` to a non-rational `Bezier2d`.
 *
@@ -413,26 +413,26 @@ const resolveOptions = (options) => ({
 	alpha: options?.alpha ?? DEFAULT_ALPHA
 });
 /** @internal */
-const make$6 = (...args) => {
+const make$8 = (...args) => {
 	if (isVector2(args[0])) return new Cardinal2dImpl(args, DEFAULT_TENSION, DEFAULT_ALPHA);
 	const [options, ...points] = args;
 	const { tension, alpha } = resolveOptions(options);
 	return new Cardinal2dImpl(points, tension, alpha);
 };
 /** @internal */
-const fromArray$6 = (points, options) => {
+const fromArray$8 = (points, options) => {
 	const { tension, alpha } = resolveOptions(options);
 	return new Cardinal2dImpl(points, tension, alpha);
 };
 /** @internal */
-const fromTuples$6 = (tuples, options) => {
+const fromTuples$8 = (tuples, options) => {
 	const { tension, alpha } = resolveOptions(options);
-	return new Cardinal2dImpl(tuples.map(([x, y]) => make$10(x, y)), tension, alpha);
+	return new Cardinal2dImpl(tuples.map(([x, y]) => make$12(x, y)), tension, alpha);
 };
 /** @internal */
-const append$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...p, ...points], p.tension, p.alpha));
+const append$7 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...p, ...points], p.tension, p.alpha));
 /** @internal */
-const prepend$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...points, ...p], p.tension, p.alpha));
+const prepend$7 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...points, ...p], p.tension, p.alpha));
 /** @internal */
 const withDuplicatedEndpoints$1 = (p) => {
 	const points = p instanceof Cardinal2dImpl ? p.points : [...p];
@@ -480,13 +480,13 @@ const buildCardinalSegment = (p0, p1, p2, p3, tension, alpha) => {
 	const v2y = factor * (p2.y - p1.y - (p3.y - p1.y) * mid23 + (p3.y - p2.y) * trail);
 	const dx = p2.x - p1.x;
 	const dy = p2.y - p1.y;
-	return fromCoefficients(make$10(p1.x, p1.y), make$10(v1x, v1y), make$10(3 * dx - 2 * v1x - v2x, 3 * dy - 2 * v1y - v2y), make$10(-2 * dx + v1x + v2x, -2 * dy + v1y + v2y));
+	return fromCoefficients(make$12(p1.x, p1.y), make$12(v1x, v1y), make$12(3 * dx - 2 * v1x - v2x, 3 * dy - 2 * v1y - v2y), make$12(-2 * dx + v1x + v2x, -2 * dy + v1y + v2y));
 };
 function* cardinalCurves(p) {
 	for (const [p0, p1, p2, p3] of toPointQuads(p, 1)) yield buildCardinalSegment(p0, p1, p2, p3, p.tension, p.alpha);
 }
 /** @internal */
-const toPath$6 = (p) => make$13(...cardinalCurves(p));
+const toPath$8 = (p) => make$15(...cardinalCurves(p));
 /** @internal */
 const toBezier$5 = (p) => {
 	const points = [];
@@ -501,26 +501,26 @@ const toBezier$5 = (p) => {
 		const c3x = curve.x.c3;
 		const c3y = curve.y.c3;
 		if (first) {
-			points.push(make$10(c0x, c0y));
+			points.push(make$12(c0x, c0y));
 			first = false;
 		}
-		points.push(make$10(c0x + c1x / 3, c0y + c1y / 3));
-		points.push(make$10(c0x + 2 * c1x / 3 + c2x / 3, c0y + 2 * c1y / 3 + c2y / 3));
-		points.push(make$10(c0x + c1x + c2x + c3x, c0y + c1y + c2y + c3y));
+		points.push(make$12(c0x + c1x / 3, c0y + c1y / 3));
+		points.push(make$12(c0x + 2 * c1x / 3 + c2x / 3, c0y + 2 * c1y / 3 + c2y / 3));
+		points.push(make$12(c0x + c1x + c2x + c3x, c0y + c1y + c2y + c3y));
 	}
-	return fromArray$8(points);
+	return fromArray$10(points);
 };
 //#endregion
 //#region src/splines/cardinal2d.ts
 var cardinal2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append$4,
-	fromArray: () => fromArray$5,
-	fromTuples: () => fromTuples$5,
+	append: () => append$6,
+	fromArray: () => fromArray$7,
+	fromTuples: () => fromTuples$7,
 	isCardinal2d: () => isCardinal2d,
-	make: () => make$5,
-	prepend: () => prepend$4,
+	make: () => make$7,
+	prepend: () => prepend$6,
 	toBezier: () => toBezier$4,
-	toPath: () => toPath$5,
+	toPath: () => toPath$7,
 	withAlpha: () => withAlpha,
 	withDuplicatedEndpoints: () => withDuplicatedEndpoints,
 	withInterpolatedEndpoints: () => withInterpolatedEndpoints,
@@ -536,7 +536,7 @@ var cardinal2d_exports = /* @__PURE__ */ __exportAll({
 * @since 1.0.0
 */
 const isCardinal2d = isCardinal2d$1;
-const make$5 = make$6;
+const make$7 = make$8;
 /**
 * Creates a new `Cardinal2d` from an array of control points.
 *
@@ -545,7 +545,7 @@ const make$5 = make$6;
 * @returns A new `Cardinal2d` instance.
 * @since 1.0.0
 */
-const fromArray$5 = fromArray$6;
+const fromArray$7 = fromArray$8;
 /**
 * Creates a new `Cardinal2d` from an array of `[x, y]` tuples.
 *
@@ -554,9 +554,9 @@ const fromArray$5 = fromArray$6;
 * @returns A new `Cardinal2d` instance.
 * @since 2.0.0
 */
-const fromTuples$5 = fromTuples$6;
-const append$4 = append$5;
-const prepend$4 = prepend$5;
+const fromTuples$7 = fromTuples$8;
+const append$6 = append$7;
+const prepend$6 = prepend$7;
 /**
 * Doubles the endpoints of a `Cardinal2d` spline. Tension and alpha are
 * preserved.
@@ -595,7 +595,7 @@ const withOptions = withOptions$1;
 * @returns A new `CubicPath2d` representing the spline.
 * @since 1.0.0
 */
-const toPath$5 = toPath$6;
+const toPath$7 = toPath$8;
 /**
 * Converts a `Cardinal2d` to a `Bezier2d`. Equivalent to {@link toPath}
 * followed by per-segment monomial-to-Bernstein conversion — same underlying
@@ -626,40 +626,40 @@ var Hermite2dImpl = class extends Pipeable {
 /** @internal */
 const isHermite2d$1 = (p) => typeof p === "object" && p !== null && Hermite2dTypeId in p;
 /** @internal */
-const make$4 = (p0, v0, p1, v1) => new Hermite2dImpl([
+const make$6 = (p0, v0, p1, v1) => new Hermite2dImpl([
 	p0,
 	v0,
 	p1,
 	v1
 ]);
 /** @internal */
-const fromArray$4 = (points) => new Hermite2dImpl(points);
+const fromArray$6 = (points) => new Hermite2dImpl(points);
 /** @internal */
-const fromTuples$4 = (tuples) => new Hermite2dImpl(tuples.map(([x, y]) => make$10(x, y)));
+const fromTuples$6 = (tuples) => new Hermite2dImpl(tuples.map(([x, y]) => make$12(x, y)));
 /** @internal */
-const append$3 = dual(3, (p, p1, v1) => {
+const append$5 = dual(3, (p, p1, v1) => {
 	return new Hermite2dImpl((p instanceof Hermite2dImpl ? p.points : Array.from(p)).concat(p1, v1));
 });
 /** @internal */
-const prepend$3 = dual(3, (p, p0, v0) => {
+const prepend$5 = dual(3, (p, p0, v0) => {
 	const points = p instanceof Hermite2dImpl ? p.points : Array.from(p);
 	return new Hermite2dImpl([p0, v0].concat(points));
 });
 /** @internal */
-const toPath$4 = (p) => make$13(...toCurves(p, cubicHermite, 2));
+const toPath$6 = (p) => make$15(...toCurves(p, cubicHermite, 2));
 /** @internal */
 const toBezier$3 = (p) => fromBasis(p, cubicHermite, 2);
 //#endregion
 //#region src/splines/hermite2d.ts
 var hermite2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append$2,
-	fromArray: () => fromArray$3,
-	fromTuples: () => fromTuples$3,
+	append: () => append$4,
+	fromArray: () => fromArray$5,
+	fromTuples: () => fromTuples$5,
 	isHermite2d: () => isHermite2d,
-	make: () => make$3,
-	prepend: () => prepend$2,
+	make: () => make$5,
+	prepend: () => prepend$4,
 	toBezier: () => toBezier$2,
-	toPath: () => toPath$3
+	toPath: () => toPath$5
 });
 /**
 * Checks if a value is a `Hermite2d`.
@@ -679,7 +679,7 @@ const isHermite2d = isHermite2d$1;
 * @returns A new `Hermite2d` instance.
 * @since 1.0.0
 */
-const make$3 = make$4;
+const make$5 = make$6;
 /**
 * Creates a new `Hermite2d` instance from an array of control points.
 *
@@ -687,7 +687,7 @@ const make$3 = make$4;
 * @returns A new `Hermite2d` instance.
 * @since 1.0.0
 */
-const fromArray$3 = fromArray$4;
+const fromArray$5 = fromArray$6;
 /**
 * Creates a new `Hermite2d` from an array of `[x, y]` tuples, alternating
 * `[position, velocity]` pairs.
@@ -696,9 +696,9 @@ const fromArray$3 = fromArray$4;
 * @returns A new `Hermite2d` instance.
 * @since 2.0.0
 */
-const fromTuples$3 = fromTuples$4;
-const append$2 = append$3;
-const prepend$2 = prepend$3;
+const fromTuples$5 = fromTuples$6;
+const append$4 = append$5;
+const prepend$4 = prepend$5;
 /**
 * Creates a new `CubicPath2d` instance from a `Hermite2d`.
 *
@@ -706,7 +706,7 @@ const prepend$2 = prepend$3;
 * @returns A new `CubicPath2d` instance.
 * @since 1.0.0
 */
-const toPath$3 = toPath$4;
+const toPath$5 = toPath$6;
 /**
 * Converts a `Hermite2d` to a `Bezier2d`.
 *
@@ -733,20 +733,20 @@ var Basis2dImpl = class extends Pipeable {
 /** @internal */
 const isBasis2d$1 = (p) => typeof p === "object" && p !== null && Basis2dTypeId in p;
 /** @internal */
-const make$2 = (p0, p1, p2, p3) => new Basis2dImpl([
+const make$4 = (p0, p1, p2, p3) => new Basis2dImpl([
 	p0,
 	p1,
 	p2,
 	p3
 ]);
 /** @internal */
-const fromArray$2 = (points) => new Basis2dImpl(points);
+const fromArray$4 = (points) => new Basis2dImpl(points);
 /** @internal */
-const fromTuples$2 = (tuples) => new Basis2dImpl(tuples.map(([x, y]) => make$10(x, y)));
+const fromTuples$4 = (tuples) => new Basis2dImpl(tuples.map(([x, y]) => make$12(x, y)));
 /** @internal */
-const append$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...p, ...points]));
+const append$3 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...p, ...points]));
 /** @internal */
-const prepend$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...points, ...p]));
+const prepend$3 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...points, ...p]));
 /** @internal */
 const withTriplicatedEndpoints$1 = (p) => {
 	const points = p instanceof Basis2dImpl ? p.points : [...p];
@@ -759,20 +759,20 @@ const withTriplicatedEndpoints$1 = (p) => {
 	]);
 };
 /** @internal */
-const toPath$2 = (p) => make$13(...toCurves(p, cubicBasisSpline, 1));
+const toPath$4 = (p) => make$15(...toCurves(p, cubicBasisSpline, 1));
 /** @internal */
 const toBezier$1 = (p) => fromBasis(p, cubicBasisSpline, 1);
 //#endregion
 //#region src/splines/basis2d.ts
 var basis2d_exports = /* @__PURE__ */ __exportAll({
-	append: () => append,
-	fromArray: () => fromArray$1,
-	fromTuples: () => fromTuples$1,
+	append: () => append$2,
+	fromArray: () => fromArray$3,
+	fromTuples: () => fromTuples$3,
 	isBasis2d: () => isBasis2d,
-	make: () => make$1,
-	prepend: () => prepend,
+	make: () => make$3,
+	prepend: () => prepend$2,
 	toBezier: () => toBezier,
-	toPath: () => toPath$1,
+	toPath: () => toPath$3,
 	withTriplicatedEndpoints: () => withTriplicatedEndpoints
 });
 /**
@@ -793,7 +793,7 @@ const isBasis2d = isBasis2d$1;
 * @returns A new `Basis2d` instance.
 * @since 1.0.0
 */
-const make$1 = make$2;
+const make$3 = make$4;
 /**
 * Creates a new `Basis2d` instance from an array of control points.
 *
@@ -801,7 +801,7 @@ const make$1 = make$2;
 * @returns A new `Basis2d` instance.
 * @since 1.0.0
 */
-const fromArray$1 = fromArray$2;
+const fromArray$3 = fromArray$4;
 /**
 * Creates a new `Basis2d` from an array of `[x, y]` tuples.
 *
@@ -809,9 +809,9 @@ const fromArray$1 = fromArray$2;
 * @returns A new `Basis2d` instance.
 * @since 2.0.0
 */
-const fromTuples$1 = fromTuples$2;
-const append = append$1;
-const prepend = prepend$1;
+const fromTuples$3 = fromTuples$4;
+const append$2 = append$3;
+const prepend$2 = prepend$3;
 /**
 * Triplicates the endpoints of a `Basis2d`.
 *
@@ -829,7 +829,7 @@ const withTriplicatedEndpoints = withTriplicatedEndpoints$1;
 * @returns A new `Path2d` instance.
 * @since 1.0.0
 */
-const toPath$1 = toPath$2;
+const toPath$3 = toPath$4;
 /**
 * Converts a `Basis2d` to a `Bezier2d`.
 *
@@ -839,6 +839,104 @@ const toPath$1 = toPath$2;
 */
 const toBezier = toBezier$1;
 //#endregion
+//#region src/splines/linear2d.internal.ts
+const Linear2dTypeId = Symbol("curvy/splines/linear2d");
+var Linear2dImpl = class extends Pipeable {
+	[Linear2dTypeId] = Linear2dTypeId;
+	points;
+	constructor(points) {
+		invariant(points.length >= 2, "linear spline requires 2 or more points");
+		super();
+		this.points = points;
+	}
+	[Symbol.iterator]() {
+		return this.points[Symbol.iterator]();
+	}
+};
+/** @internal */
+const isLinear2d$1 = (p) => typeof p === "object" && p !== null && Linear2dTypeId in p;
+/** @internal */
+const make$2 = (p0, p1, ...rest) => new Linear2dImpl([
+	p0,
+	p1,
+	...rest
+]);
+/** @internal */
+const fromArray$2 = (points) => new Linear2dImpl(points);
+/** @internal */
+const fromTuples$2 = (tuples) => new Linear2dImpl(tuples.map(([x, y]) => make$12(x, y)));
+/** @internal */
+const append$1 = dual((args) => isLinear2d$1(args[0]), (p, ...points) => new Linear2dImpl([...p, ...points]));
+/** @internal */
+const prepend$1 = dual((args) => isLinear2d$1(args[0]), (p, ...points) => new Linear2dImpl([...points, ...p]));
+/** @internal */
+const toPath$2 = (p) => {
+	const points = p instanceof Linear2dImpl ? p.points : [...p];
+	const segments = [];
+	for (let i = 1; i < points.length; i++) segments.push(fromEndpoints(points[i - 1], points[i]));
+	return fromArray$13(segments);
+};
+//#endregion
+//#region src/splines/linear2d.ts
+var linear2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append,
+	fromArray: () => fromArray$1,
+	fromTuples: () => fromTuples$1,
+	isLinear2d: () => isLinear2d,
+	make: () => make$1,
+	prepend: () => prepend,
+	toPath: () => toPath$1
+});
+/**
+* Checks if a value is a `Linear2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `Linear2d`, `false` otherwise.
+* @since 2.0.0
+*/
+const isLinear2d = isLinear2d$1;
+/**
+* Creates a new `Linear2d` from 2 or more points.
+*
+* @param p0 - The first point.
+* @param p1 - The second point.
+* @param rest - Additional points.
+* @returns A new `Linear2d` instance.
+* @since 2.0.0
+*/
+const make$1 = make$2;
+/**
+* Creates a new `Linear2d` from an array of points. Requires at least 2
+* points.
+*
+* @param points - The points.
+* @returns A new `Linear2d` instance.
+* @since 2.0.0
+*/
+const fromArray$1 = fromArray$2;
+/**
+* Creates a new `Linear2d` from an array of `[x, y]` tuples. Requires at
+* least 2 tuples.
+*
+* @param tuples - The points as `[x, y]` tuples.
+* @returns A new `Linear2d` instance.
+* @since 2.0.0
+*/
+const fromTuples$1 = fromTuples$2;
+const append = append$1;
+const prepend = prepend$1;
+/**
+* Converts a `Linear2d` to a `LinearPath2d` by joining consecutive points
+* with straight segments. The result is unbranded; assert
+* `LinearPath2d.asMonotonicX` / `asMonotonicY` afterward if the underlying
+* points warrant it.
+*
+* @param p - The `Linear2d` to convert.
+* @returns A new `LinearPath2d` with one segment per consecutive point pair.
+* @since 2.0.0
+*/
+const toPath$1 = toPath$2;
+//#endregion
 //#region src/splines/rationalBezier2d.ts
 var rationalBezier2d_exports = /* @__PURE__ */ __exportAll({
 	fromArray: () => fromArray,
@@ -872,7 +970,7 @@ const isRationalBezier2d = isRationalBezier2d$1;
 * @returns A new `RationalBezier2d` instance.
 * @since 2.0.0
 */
-const make = make$9;
+const make = make$11;
 /**
 * Creates a new `RationalBezier2d` from an array of weighted control points.
 *
@@ -883,7 +981,7 @@ const make = make$9;
 * @returns A new `RationalBezier2d` instance.
 * @since 2.0.0
 */
-const fromArray = fromArray$9;
+const fromArray = fromArray$11;
 /**
 * Creates a new `RationalBezier2d` from an array of `[x, y, weight]` tuples.
 * Weight is the projective denominator at each control point — `1` everywhere
@@ -894,7 +992,7 @@ const fromArray = fromArray$9;
 * @returns A new `RationalBezier2d` instance.
 * @since 2.0.0
 */
-const fromTuples = fromTuples$9;
+const fromTuples = fromTuples$11;
 /**
 * Creates a new single-segment `RationalBezier2d` from four points with all
 * weights equal to one.
@@ -938,9 +1036,9 @@ const fromBezier = fromBezier$1;
 * @returns A new `RationalCubicPath2d` instance representing the same curve.
 * @since 2.0.0
 */
-const toPath = toPath$9;
+const toPath = toPath$11;
 const subdivide = subdivide$3;
 //#endregion
-export { basis2d_exports as Basis2d, bezier2d_exports as Bezier2d, cardinal2d_exports as Cardinal2d, hermite2d_exports as Hermite2d, rationalBezier2d_exports as RationalBezier2d };
+export { basis2d_exports as Basis2d, bezier2d_exports as Bezier2d, cardinal2d_exports as Cardinal2d, hermite2d_exports as Hermite2d, linear2d_exports as Linear2d, rationalBezier2d_exports as RationalBezier2d };
 
 //# sourceMappingURL=index.mjs.map