curvy 1.0.9 → 2.0.0-alpha.2

package/dist/splines/index.mjs

@@ -0,0 +1,734 @@
+import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { epsEquals } from "../number.mjs";
+import { a as makeWeighted, i as make$10, o as scale, s as subtract, t as add } from "../shared/vector2-CL1HDdPr.mjs";
+import { t as make$11 } from "../shared/vector3-D-tv_aKL.mjs";
+import { n as transpose, t as make$12 } from "../shared/vector4-5KbjoHVj.mjs";
+import { a as vectorProductLeft, i as multiply, t as inverse } from "../shared/matrix4x4-Ck2WROK-.mjs";
+import { o as none, s as one } from "../shared/solution-CrtLfqEq.mjs";
+import { n as fromBezierPoints, s as fromPolynomials } from "../shared/rationalCubic2d-Bys2Uory.mjs";
+import { a as cubicCardinal, i as cubicBezier, o as cubicHermite, r as cubicBasisSpline, t as apply } from "../shared/characteristic-B9nCh_cx.mjs";
+import { i as make$13, t as fromArray$10 } from "../shared/rationalCubic2d-BEgUGSFf.mjs";
+//#region src/splines/rationalBezier2d.internal.ts
+const RationalBezier2dTypeId = Symbol("curvy/splines/rationalBezier2d");
+var RationalBezier2dImpl = class extends Pipeable {
+	[RationalBezier2dTypeId] = RationalBezier2dTypeId;
+	homogeneous;
+	constructor(homogeneous) {
+		invariant(homogeneous.length >= 4, "rational cubic splines require 4 or more points");
+		invariant(homogeneous.length % 3 === 1, "rational cubic splines require (n * 3) + 1 points");
+		super();
+		this.homogeneous = homogeneous;
+	}
+	*[Symbol.iterator]() {
+		for (const h of this.homogeneous) yield makeWeighted(h.x / h.z, h.y / h.z, h.z);
+	}
+};
+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 make$9 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
+	lift(p0),
+	lift(p1),
+	lift(p2),
+	lift(p3)
+]);
+const fromArray$9 = (points) => new RationalBezier2dImpl(points.map(lift));
+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)
+]);
+const fromBezier$1 = (b) => {
+	const homogeneous = [];
+	for (const p of b) homogeneous.push(make$11(p.x, p.y, 1));
+	return new RationalBezier2dImpl(homogeneous);
+};
+const homogeneousOf = (r) => r instanceof RationalBezier2dImpl ? r.homogeneous : Array.from(r, lift);
+const toPath$9 = (r) => {
+	const homogeneous = homogeneousOf(r);
+	const segmentCount = (homogeneous.length - 1) / 3;
+	const curves = [];
+	for (let i = 0; i < segmentCount; i++) {
+		const base = i * 3;
+		const h0 = homogeneous[base];
+		const h1 = homogeneous[base + 1];
+		const h2 = homogeneous[base + 2];
+		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);
+};
+const subdivide$3 = dual(2, (r, u) => {
+	invariant(u > 0 && u < 1, "subdivide parameter u must be in the open interval (0, 1)");
+	const homogeneous = homogeneousOf(r);
+	const t = u * ((homogeneous.length - 1) / 3);
+	const i = Math.floor(t);
+	const localT = t - i;
+	if (localT === 0) return [new RationalBezier2dImpl(homogeneous.slice(0, i * 3 + 1)), new RationalBezier2dImpl(homogeneous.slice(i * 3))];
+	const p0 = homogeneous[i * 3];
+	const p1 = homogeneous[i * 3 + 1];
+	const p2 = homogeneous[i * 3 + 2];
+	const p3 = homogeneous[i * 3 + 3];
+	const q0x = p0.x + (p1.x - p0.x) * localT;
+	const q0y = p0.y + (p1.y - p0.y) * localT;
+	const q0w = p0.z + (p1.z - p0.z) * localT;
+	const q1x = p1.x + (p2.x - p1.x) * localT;
+	const q1y = p1.y + (p2.y - p1.y) * localT;
+	const q1w = p1.z + (p2.z - p1.z) * localT;
+	const q2x = p2.x + (p3.x - p2.x) * localT;
+	const q2y = p2.y + (p3.y - p2.y) * localT;
+	const q2w = p2.z + (p3.z - p2.z) * localT;
+	const r0x = q0x + (q1x - q0x) * localT;
+	const r0y = q0y + (q1y - q0y) * localT;
+	const r0w = q0w + (q1w - q0w) * localT;
+	const r1x = q1x + (q2x - q1x) * localT;
+	const r1y = q1y + (q2y - q1y) * localT;
+	const r1w = q1w + (q2w - q1w) * localT;
+	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 leftPoints = [
+		...homogeneous.slice(0, i * 3 + 1),
+		q0,
+		r0,
+		sLeft
+	];
+	const rightPoints = [
+		sRight,
+		r1,
+		q2,
+		...homogeneous.slice(i * 3 + 3)
+	];
+	return [new RationalBezier2dImpl(leftPoints), new RationalBezier2dImpl(rightPoints)];
+});
+const toBezierPoints = (r) => {
+	const homogeneous = homogeneousOf(r);
+	const w0 = homogeneous[0].z;
+	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));
+	}
+	return one(points);
+};
+//#endregion
+//#region src/splines/util.ts
+function* toPointQuads(points, stride) {
+	let p0;
+	let p1;
+	let p2;
+	let p3;
+	for (const point of points) {
+		if (p0 === void 0) {
+			p0 = point;
+			continue;
+		}
+		if (p1 === void 0) {
+			p1 = point;
+			continue;
+		}
+		if (p2 === void 0) {
+			p2 = point;
+			continue;
+		}
+		p3 = point;
+		yield [
+			p0,
+			p1,
+			p2,
+			p3
+		];
+		if (stride === 1) {
+			p0 = p1;
+			p1 = p2;
+			p2 = p3;
+		} else if (stride === 2) {
+			p0 = p2;
+			p1 = p3;
+			p2 = void 0;
+		} else if (stride === 3) {
+			p0 = p3;
+			p1 = void 0;
+			p2 = void 0;
+		}
+	}
+}
+function* toCurves(points, matrix, stride) {
+	for (const quad of toPointQuads(points, stride)) yield fromPolynomials(...apply(matrix, ...transpose(quad, (p) => [p.x, p.y])));
+}
+//#endregion
+//#region src/splines/bezier2d.internal.ts
+const characteristicInverse = inverse(cubicBezier);
+const conversionCache = /* @__PURE__ */ new WeakMap();
+const getConversionMatrix = (source) => {
+	let combined = conversionCache.get(source);
+	if (combined === void 0) {
+		combined = multiply(characteristicInverse, source);
+		conversionCache.set(source, combined);
+	}
+	return combined;
+};
+const Bezier2dTypeId = Symbol("curvy/splines/bezier2d");
+var Bezier2dImpl = class extends Pipeable {
+	[Bezier2dTypeId] = Bezier2dTypeId;
+	points;
+	constructor(points) {
+		invariant(points.length >= 4, "cubic splines requires 4 or more points");
+		invariant(points.length % 3 === 1, "cubic splines requires (n * 3) + 1 points");
+		super();
+		this.points = points;
+	}
+	[Symbol.iterator]() {
+		return this.points[Symbol.iterator]();
+	}
+};
+const isCubicBezier2d$1 = (p) => typeof p === "object" && p !== null && Bezier2dTypeId in p;
+const make$8 = (p0, p1, p2, p3) => new Bezier2dImpl([
+	p0,
+	p1,
+	p2,
+	p3
+]);
+const fromArray$8 = (points) => new Bezier2dImpl(points);
+const append$7 = dual(4, (p, p1, p2, p3) => new Bezier2dImpl((p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)));
+const fromBasis = (p, matrix, stride) => {
+	const conversion = getConversionMatrix(matrix);
+	const points = [];
+	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));
+	}
+	if (x && y) points.push(make$10(x.w, y.w));
+	return fromArray$8(points);
+};
+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);
+});
+const appendCurvatureAligned$1 = dual(4, (p, a, b, p6) => {
+	const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
+	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);
+});
+const appendVelocityAligned$1 = dual(3, (p, p5, p6) => appendTangentAligned$1(p, 1, p5, p6));
+const appendAccelerationAligned$1 = dual(2, (p, p6) => {
+	const points = p instanceof Bezier2dImpl ? p.points : Array.from(p);
+	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);
+});
+const toPath$8 = (p) => make$13(...toCurves(p, cubicBezier, 3));
+const fromRational$1 = (r) => {
+	const points = toBezierPoints(r);
+	if (points._tag === "none") return points;
+	return one(new Bezier2dImpl(points.value));
+};
+const subdivide$2 = dual(2, (b, u) => {
+	invariant(u > 0 && u < 1, "subdivide parameter u must be in the open interval (0, 1)");
+	const points = b instanceof Bezier2dImpl ? b.points : Array.from(b);
+	const t = u * ((points.length - 1) / 3);
+	const i = Math.floor(t);
+	const localT = t - i;
+	if (localT === 0) return [new Bezier2dImpl(points.slice(0, i * 3 + 1)), new Bezier2dImpl(points.slice(i * 3))];
+	const p0 = points[i * 3];
+	const p1 = points[i * 3 + 1];
+	const p2 = points[i * 3 + 2];
+	const p3 = points[i * 3 + 3];
+	const q0x = p0.x + (p1.x - p0.x) * localT;
+	const q0y = p0.y + (p1.y - p0.y) * localT;
+	const q1x = p1.x + (p2.x - p1.x) * localT;
+	const q1y = p1.y + (p2.y - p1.y) * localT;
+	const q2x = p2.x + (p3.x - p2.x) * localT;
+	const q2y = p2.y + (p3.y - p2.y) * localT;
+	const r0x = q0x + (q1x - q0x) * localT;
+	const r0y = q0y + (q1y - q0y) * localT;
+	const r1x = q1x + (q2x - q1x) * localT;
+	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 leftPoints = [
+		...points.slice(0, i * 3 + 1),
+		q0,
+		r0,
+		sLeft
+	];
+	const rightPoints = [
+		sRight,
+		r1,
+		q2,
+		...points.slice(i * 3 + 3)
+	];
+	return [new Bezier2dImpl(leftPoints), new Bezier2dImpl(rightPoints)];
+});
+//#endregion
+//#region src/splines/bezier2d.ts
+var bezier2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append$6,
+	appendAccelerationAligned: () => appendAccelerationAligned,
+	appendCurvatureAligned: () => appendCurvatureAligned,
+	appendTangentAligned: () => appendTangentAligned,
+	appendVelocityAligned: () => appendVelocityAligned,
+	fromArray: () => fromArray$7,
+	fromRational: () => fromRational,
+	isCubicBezier2d: () => isCubicBezier2d,
+	make: () => make$7,
+	subdivide: () => subdivide$1,
+	toPath: () => toPath$7
+});
+/**
+* Creates a new `Bezier2d` instance.
+*
+* @param p0 - The first control point.
+* @param p1 - The second control point.
+* @param p2 - The third control point.
+* @param p3 - The fourth control point.
+* @returns A new `Bezier2d` instance.
+* @since 1.0.0
+*/
+const make$7 = make$8;
+/**
+* Creates a new `Bezier2d` instance from an array of control points.
+*
+* @param points - The control points.
+* @returns A new `Bezier2d` instance.
+* @since 1.0.0
+*/
+const fromArray$7 = fromArray$8;
+/**
+* Checks if a value is a `Bezier2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `Bezier2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isCubicBezier2d = isCubicBezier2d$1;
+const append$6 = append$7;
+const appendTangentAligned = appendTangentAligned$1;
+const appendCurvatureAligned = appendCurvatureAligned$1;
+const appendVelocityAligned = appendVelocityAligned$1;
+const appendAccelerationAligned = appendAccelerationAligned$1;
+/**
+* Converts a `Bezier2d` to a `CubicPath2d`.
+*
+* @param p - The `Bezier2d` to convert.
+* @returns A new `CubicPath2d` instance representing the same curve as the `Bezier2d`.
+* @since 1.0.0
+*/
+const toPath$7 = toPath$8;
+/**
+* Attempts to lower a `RationalBezier2d` to a non-rational `Bezier2d`.
+*
+* Succeeds with `Solution.one(bezier)` when the rational curve's weights are
+* uniform (the curve is mathematically a polynomial Bézier) and returns
+* `Solution.none` otherwise — the rational curve cannot be represented
+* exactly by a non-rational cubic Bézier.
+*
+* @param r - The rational bezier to convert.
+* @returns Either a `Bezier2d` instance or `Solution.none`.
+* @since 2.1.0
+*/
+const fromRational = fromRational$1;
+const subdivide$1 = subdivide$2;
+//#endregion
+//#region src/splines/cardinal2d.internal.ts
+const Cardinal2dTypeId = Symbol.for("curvy/splines/cardinal2d");
+var Cardinal2dImpl = class extends Pipeable {
+	[Cardinal2dTypeId] = Cardinal2dTypeId;
+	points;
+	constructor(points) {
+		invariant(points.length >= 2, "cardinal splines requires 2 or more points");
+		super();
+		this.points = points;
+	}
+	[Symbol.iterator]() {
+		return this.points[Symbol.iterator]();
+	}
+};
+const isCardinal2d$1 = (p) => typeof p === "object" && p !== null && Cardinal2dTypeId in p;
+const make$6 = (...points) => new Cardinal2dImpl(points);
+const fromArray$6 = (points) => new Cardinal2dImpl(points);
+const append$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...p, ...points]));
+const prepend$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...points, ...p]));
+const withDuplicatedEndpoints$1 = (p) => {
+	const points = p instanceof Cardinal2dImpl ? p.points : [...p];
+	return new Cardinal2dImpl([
+		points[0],
+		...points,
+		points[points.length - 1]
+	]);
+};
+const withReflectedEndpoints$1 = dual((args) => isCardinal2d$1(args[0]), (p, scale$1 = 1) => {
+	if (scale$1 === 0) return withDuplicatedEndpoints$1(p);
+	const points = p instanceof Cardinal2dImpl ? p.points : [...p];
+	const p0 = points[0];
+	const p1 = points[1];
+	const p2 = points[points.length - 2];
+	const p3 = points[points.length - 1];
+	return new Cardinal2dImpl([
+		subtract(p1, p0).pipe(scale(scale$1), add(p0)),
+		...points,
+		subtract(p2, p3).pipe(scale(scale$1), add(p3))
+	]);
+});
+const toPath$6 = dual((args) => isCardinal2d$1(args[0]), (p, scale = .5) => make$13(...toCurves(p, cubicCardinal(scale), 1)));
+const toBezier$5 = (p, scale = .5) => fromBasis(p, cubicCardinal(scale), 1);
+//#endregion
+//#region src/splines/cardinal2d.ts
+var cardinal2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append$4,
+	fromArray: () => fromArray$5,
+	isCardinal2d: () => isCardinal2d,
+	make: () => make$5,
+	prepend: () => prepend$4,
+	toBezier: () => toBezier$4,
+	toPath: () => toPath$5,
+	withDuplicatedEndpoints: () => withDuplicatedEndpoints,
+	withReflectedEndpoints: () => withReflectedEndpoints
+});
+/**
+* Checks if a value is a `Cardinal2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `Cardinal2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isCardinal2d = isCardinal2d$1;
+/**
+* Creates a new `Cardinal2d` instance.
+*
+* @param p0 - The first control point.
+* @param p1 - The second control point.
+* @param points - The remaining control points.
+* @returns A new `Cardinal2d` instance.
+* @since 1.0.0
+*/
+const make$5 = make$6;
+/**
+* Creates a new `Cardinal2d` instance from an array of control points.
+*
+* @param points - The control points.
+* @returns A new `Cardinal2d` instance.
+* @since 1.0.0
+*/
+const fromArray$5 = fromArray$6;
+const append$4 = append$5;
+const prepend$4 = prepend$5;
+/**
+* Doubles the endpoints of a `Cardinal2d` spline.
+*
+* @param c - The `Cardinal2d` to duplicate the endpoints of.
+* @returns A new `Cardinal2d` instance with the duplicated endpoints.
+* @since 1.0.0
+*/
+const withDuplicatedEndpoints = withDuplicatedEndpoints$1;
+const withReflectedEndpoints = withReflectedEndpoints$1;
+const toPath$5 = toPath$6;
+const toBezier$4 = toBezier$5;
+//#endregion
+//#region src/splines/hermite2d.internal.ts
+const Hermite2dTypeId = Symbol("curvy/splines/hermite2d");
+var Hermite2dImpl = class extends Pipeable {
+	[Hermite2dTypeId] = Hermite2dTypeId;
+	points;
+	constructor(points) {
+		invariant(points.length >= 4, "hermite splines requires 4 or more points");
+		invariant(points.length % 2 === 0, "hermite splines requires (n * 2) points");
+		super();
+		this.points = points;
+	}
+	[Symbol.iterator]() {
+		return this.points[Symbol.iterator]();
+	}
+};
+const isHermite2d$1 = (p) => typeof p === "object" && p !== null && Hermite2dTypeId in p;
+const make$4 = (p0, v0, p1, v1) => new Hermite2dImpl([
+	p0,
+	v0,
+	p1,
+	v1
+]);
+const fromArray$4 = (points) => new Hermite2dImpl(points);
+const append$3 = dual(3, (p, p1, v1) => {
+	return new Hermite2dImpl((p instanceof Hermite2dImpl ? p.points : Array.from(p)).concat(p1, v1));
+});
+const prepend$3 = dual(3, (p, p0, v0) => {
+	const points = p instanceof Hermite2dImpl ? p.points : Array.from(p);
+	return new Hermite2dImpl([p0, v0].concat(points));
+});
+const toPath$4 = (p) => make$13(...toCurves(p, cubicHermite, 2));
+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,
+	isHermite2d: () => isHermite2d,
+	make: () => make$3,
+	prepend: () => prepend$2,
+	toBezier: () => toBezier$2,
+	toPath: () => toPath$3
+});
+/**
+* Checks if a value is a `Hermite2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `Hermite2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isHermite2d = isHermite2d$1;
+/**
+* Creates a new `Hermite2d` instance.
+*
+* @param p0 - The first control point.
+* @param v0 - The first tangent vector.
+* @param p1 - The second control point.
+* @param v1 - The second tangent vector.
+* @returns A new `Hermite2d` instance.
+* @since 1.0.0
+*/
+const make$3 = make$4;
+/**
+* Creates a new `Hermite2d` instance from an array of control points.
+*
+* @param points - The control points.
+* @returns A new `Hermite2d` instance.
+* @since 1.0.0
+*/
+const fromArray$3 = fromArray$4;
+const append$2 = append$3;
+const prepend$2 = prepend$3;
+/**
+* Creates a new `CubicPath2d` instance from a `Hermite2d`.
+*
+* @param p - The `Hermite2d` to convert.
+* @returns A new `CubicPath2d` instance.
+* @since 1.0.0
+*/
+const toPath$3 = toPath$4;
+/**
+* Converts a `Hermite2d` to a `Bezier2d`.
+*
+* @param p - The `Hermite2d` to convert.
+* @returns A new `Bezier2d` instance.
+* @since 1.0.0
+*/
+const toBezier$2 = toBezier$3;
+//#endregion
+//#region src/splines/basis2d.internal.ts
+const Basis2dTypeId = Symbol("curvy/splines/basis2d");
+var Basis2dImpl = class extends Pipeable {
+	[Basis2dTypeId] = Basis2dTypeId;
+	points;
+	constructor(points) {
+		invariant(points.length >= 4, "basis splines requires 4 or more points");
+		super();
+		this.points = points;
+	}
+	[Symbol.iterator]() {
+		return this.points[Symbol.iterator]();
+	}
+};
+const isBasis2d$1 = (p) => typeof p === "object" && p !== null && Basis2dTypeId in p;
+const make$2 = (p0, p1, p2, p3) => new Basis2dImpl([
+	p0,
+	p1,
+	p2,
+	p3
+]);
+const fromArray$2 = (points) => new Basis2dImpl(points);
+const append$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...p, ...points]));
+const prepend$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...points, ...p]));
+const withTriplicatedEndpoints$1 = (p) => {
+	const points = p instanceof Basis2dImpl ? p.points : [...p];
+	return new Basis2dImpl([
+		points[0],
+		points[0],
+		...points,
+		points[points.length - 1],
+		points[points.length - 1]
+	]);
+};
+const toPath$2 = (p) => make$13(...toCurves(p, cubicBasisSpline, 1));
+const toBezier$1 = (p) => fromBasis(p, cubicBasisSpline, 1);
+//#endregion
+//#region src/splines/basis2d.ts
+var basis2d_exports = /* @__PURE__ */ __exportAll({
+	append: () => append,
+	fromArray: () => fromArray$1,
+	isBasis2d: () => isBasis2d,
+	make: () => make$1,
+	prepend: () => prepend,
+	toBezier: () => toBezier,
+	toPath: () => toPath$1,
+	withTriplicatedEndpoints: () => withTriplicatedEndpoints
+});
+/**
+* Checks if a value is a `Basis2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `Basis2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isBasis2d = isBasis2d$1;
+/**
+* Creates a new `Basis2d` instance.
+*
+* @param p0 - The first control point.
+* @param p1 - The second control point.
+* @param p2 - The third control point.
+* @param p3 - The fourth control point.
+* @returns A new `Basis2d` instance.
+* @since 1.0.0
+*/
+const make$1 = make$2;
+/**
+* Creates a new `Basis2d` instance from an array of control points.
+*
+* @param points - The control points.
+* @returns A new `Basis2d` instance.
+* @since 1.0.0
+*/
+const fromArray$1 = fromArray$2;
+const append = append$1;
+const prepend = prepend$1;
+/**
+* Triplicates the endpoints of a `Basis2d`.
+*
+* This is useful for creating a closed loop spline.
+*
+* @param p - The `Basis2d` to triplicate the endpoints of.
+* @returns A new `Basis2d` instance with the triplicated endpoints.
+* @since 1.0.0
+*/
+const withTriplicatedEndpoints = withTriplicatedEndpoints$1;
+/**
+* Creates a new `Path2d` from a `Basis2d`.
+*
+* @param p - The `Basis2d` to convert to a `Path2d`.
+* @returns A new `Path2d` instance.
+* @since 1.0.0
+*/
+const toPath$1 = toPath$2;
+/**
+* Converts a `Basis2d` to a `Bezier2d`.
+*
+* @param p - The `Basis2d` to convert.
+* @returns A new `Bezier2d` instance.
+* @since 1.0.0
+*/
+const toBezier = toBezier$1;
+//#endregion
+//#region src/splines/rationalBezier2d.ts
+var rationalBezier2d_exports = /* @__PURE__ */ __exportAll({
+	fromArray: () => fromArray,
+	fromBezier: () => fromBezier,
+	fromPoints: () => fromPoints,
+	isRationalBezier2d: () => isRationalBezier2d,
+	make: () => make,
+	subdivide: () => subdivide,
+	toPath: () => toPath
+});
+/**
+* Checks if a value is a `RationalBezier2d`.
+*
+* @param p - The value to check.
+* @returns `true` if the value is a `RationalBezier2d`, `false` otherwise.
+* @since 2.1.0
+*/
+const isRationalBezier2d = isRationalBezier2d$1;
+/**
+* Creates a new single-segment `RationalBezier2d` from four weighted control points.
+*
+* Equal weights produce a curve coincident with the corresponding polynomial
+* cubic Bézier; unequal weights produce a true rational curve capable of
+* representing conics exactly.
+*
+* @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 `RationalBezier2d` instance.
+* @since 2.1.0
+*/
+const make = make$9;
+/**
+* Creates a new `RationalBezier2d` from an array of weighted control points.
+*
+* The array must contain `(n * 3) + 1` entries to describe `n` joined cubic
+* segments.
+*
+* @param points - The weighted control points.
+* @returns A new `RationalBezier2d` instance.
+* @since 2.1.0
+*/
+const fromArray = fromArray$9;
+/**
+* Creates a new single-segment `RationalBezier2d` from four points with all
+* weights equal to one.
+*
+* Convenience constructor for callers who want the rational evaluator but
+* don't yet have non-unit weights — the resulting curve is mathematically
+* equivalent to the corresponding `Bezier2d.make(p0, p1, p2, p3)` and can
+* later be subdivided or recombined using the rational machinery without
+* conversion overhead.
+*
+* @param p0 - The first control point (curve start).
+* @param p1 - The second control point (start handle).
+* @param p2 - The third control point (end handle).
+* @param p3 - The fourth control point (curve end).
+* @returns A new `RationalBezier2d` with unit weights.
+* @since 2.1.0
+*/
+const fromPoints = fromPoints$1;
+/**
+* Lifts a non-rational `Bezier2d` into a `RationalBezier2d` by assigning
+* unit weight to every control point. The two curves trace the same path.
+*
+* @param b - The non-rational bezier to lift.
+* @returns A new `RationalBezier2d` with unit weights.
+* @since 2.1.0
+*/
+const fromBezier = fromBezier$1;
+/**
+* Converts a `RationalBezier2d` to a `RationalCubicPath2d`.
+*
+* Each segment's four homogeneous control points are expanded into three
+* per-segment monomial cubic polynomials — `x`, `y`, and the shared
+* denominator `w` — yielding a path whose evaluator is three Horner passes
+* plus two divisions per call.
+*
+* Mirrors `Bezier2d.toPath`: spline construction is converted to path
+* evaluation form, and forward evaluation thereafter routes through the
+* path's `solve`.
+*
+* @param r - The rational bezier to convert.
+* @returns A new `RationalCubicPath2d` instance representing the same curve.
+* @since 2.1.0
+*/
+const toPath = toPath$9;
+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 };
+
+//# sourceMappingURL=index.mjs.map