curvy 1.0.9 → 2.0.0-alpha.2

package/dist/shared/rationalCubic2d-Bys2Uory.mjs

@@ -0,0 +1,695 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { i as make, n as cross, r as magnitude } from "./vector2-CL1HDdPr.mjs";
+import { n as transpose } from "./vector4-5KbjoHVj.mjs";
+import { l as scaleShift, m as unitOpen, p as unit, t as biunit, u as size } from "./interval-05CR6eBf.mjs";
+import { a as match, i as map, o as none, s as one, t as clip } from "./solution-CrtLfqEq.mjs";
+import { A as GL32_X1, B as GL32_X5, C as GL32_W4, D as GL32_W8, E as GL32_W7, F as GL32_X14, H as GL32_X7, I as GL32_X15, L as GL32_X2, M as GL32_X11, N as GL32_X12, O as GL32_W9, P as GL32_X13, R as GL32_X3, S as GL32_W3, T as GL32_W6, U as GL32_X8, V as GL32_X6, W as GL32_X9, _ as GL32_W12, a as isIncreasing$6, b as GL32_W15, c as range, d as solveInverse, f as subdivide, g as GL32_W11, h as GL32_W10, i as isDecreasing$6, j as GL32_X10, k as GL32_X0, l as roots, m as GL32_W1, n as derivative$5, o as isMonotonic$6, p as GL32_W0, s as make$1, u as solve$8, v as GL32_W13, w as GL32_W5, x as GL32_W2, y as GL32_W14, z as GL32_X4 } from "./cubic-CpHAx8cC.mjs";
+import { _ as solveInverse$1, a as make$3, c as solve$10, d as isIncreasing$7, f as isMonotonic$7, g as solve$9, h as range$1, i as isMonotonic$8, l as solveInverse$2, m as make$2, n as isDecreasing$8, r as isIncreasing$8, s as range$2, t as derivative$6, u as isDecreasing$7 } from "./quadratic-CamozcFc.mjs";
+import { n as make$4 } from "./interval2d-8IBZnUOq.mjs";
+import { i as cubicBezier, t as apply } from "./characteristic-B9nCh_cx.mjs";
+//#region src/curve/linear2d.internal.ts
+const LinearCurve2dTypeId = Symbol("curvy/curve/linear2d");
+var LinearCurve2dImpl = class extends Pipeable {
+	[LinearCurve2dTypeId] = LinearCurve2dTypeId;
+	x;
+	y;
+	constructor(c0, c1) {
+		super();
+		this.x = c0;
+		this.y = c1;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+};
+const fromPolynomials$7 = (c0, c1) => new LinearCurve2dImpl(c0, c1);
+const fromCoefficients$5 = (c0, c1) => new LinearCurve2dImpl(make$2(c0.x, c1.x), make$2(c0.y, c1.y));
+const fromBezierPoints$7 = (p0, p1) => new LinearCurve2dImpl(make$2(p0.x, p1.x - p0.x), make$2(p0.y, p1.y - p0.y));
+const isLinearCurve2d$1 = (c) => typeof c === "object" && c !== null && LinearCurve2dTypeId in c;
+const derivative$4 = (c) => make(c.x.c1, c.y.c1);
+const solve$7 = dual(2, (c, t) => make(solve$9(c.x, t), solve$9(c.y, t)));
+const solveAtX$7 = dual(2, (c, x) => match(solveInverse$1(c.x, x), {
+	onNone: () => none,
+	onSome: ({ value: t }) => t < 0 || t > 1 ? none : one(solve$9(c.y, t))
+}));
+const solveAtY$7 = dual(2, (c, y) => match(solveInverse$1(c.y, y), {
+	onNone: () => none,
+	onSome: ({ value: t }) => t < 0 || t > 1 ? none : one(solve$9(c.x, t))
+}));
+const length$5 = dual(2, (c, i) => Math.sqrt(c.x.c1 ** 2 + c.y.c1 ** 2) * Math.abs(i.end - i.start));
+const boundingBox$5 = (c) => make$4(range$1(c.x, unit), range$1(c.y, unit));
+const isMonotonic$5 = (c) => isMonotonic$7(c.x) && isMonotonic$7(c.y);
+const isIncreasing$5 = (c) => isIncreasing$7(c.x) && isIncreasing$7(c.y);
+const isDecreasing$5 = (c) => isDecreasing$7(c.x) && isDecreasing$7(c.y);
+const fail$2 = (m) => {
+	throw new Error(m);
+};
+const asMonotonic$5 = (c) => isMonotonic$5(c) ? c : fail$2("linear curve is not monotonic in both axes");
+const asIncreasing$5 = (c) => isIncreasing$5(c) ? c : fail$2("linear curve is not increasing in both axes");
+const asDecreasing$5 = (c) => isDecreasing$5(c) ? c : fail$2("linear curve is not decreasing in both axes");
+//#endregion
+//#region src/curve/linear2d.ts
+var linear2d_exports = /* @__PURE__ */ __exportAll({
+	asDecreasing: () => asDecreasing$4,
+	asIncreasing: () => asIncreasing$4,
+	asMonotonic: () => asMonotonic$4,
+	boundingBox: () => boundingBox$4,
+	derivative: () => derivative$3,
+	fromBezierPoints: () => fromBezierPoints$6,
+	fromCoefficients: () => fromCoefficients$4,
+	fromPolynomials: () => fromPolynomials$6,
+	isDecreasing: () => isDecreasing$4,
+	isIncreasing: () => isIncreasing$4,
+	isLinearCurve2d: () => isLinearCurve2d,
+	isMonotonic: () => isMonotonic$4,
+	length: () => length$4,
+	solve: () => solve$6,
+	solveAtX: () => solveAtX$6,
+	solveAtY: () => solveAtY$6
+});
+/**
+* Creates a new `LinearCurve2d` instance from polynomial parameters.
+*
+* @param x - The x polynomial.
+* @param y - The y polynomial.
+* @returns A new `LinearCurve2d` instance.
+* @since 1.0.0
+*/
+const fromPolynomials$6 = fromPolynomials$7;
+/**
+* Creates a new `LinearCurve2d` instance from monomial coefficient vectors.
+*
+* Each argument bundles the per-axis coefficient at the given power: `c0`
+* holds the x⁰ term, `c1` holds the x¹ term. The resulting curve evaluates to
+* `c0 + c1·t` per axis.
+*
+* @param c0 - The x⁰ coefficients (x and y).
+* @param c1 - The x¹ coefficients (x and y).
+* @returns A new `LinearCurve2d` instance.
+* @since 2.0.0
+*/
+const fromCoefficients$4 = fromCoefficients$5;
+/**
+* Creates a new `LinearCurve2d` instance from a pair of endpoints.
+*
+* `p0` is the curve at `t = 0`, `p1` is the curve at `t = 1`. The
+* implementation converts to the curve's internal monomial form (slope-form
+* polynomial in `t`) in closed form.
+*
+* @param p0 - The curve's start point.
+* @param p1 - The curve's end point.
+* @returns A new `LinearCurve2d` instance whose curve matches the line from `p0` to `p1`.
+* @since 2.0.0
+*/
+const fromBezierPoints$6 = fromBezierPoints$7;
+/**
+* Checks if a value is a `LinearCurve2d`.
+*
+* @param c - The value to check.
+* @returns `true` if the value is a `LinearCurve2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isLinearCurve2d = isLinearCurve2d$1;
+/**
+* Gets the derivative of a linear curve as a vector
+*
+* @param c - The linear curve to get the derivative of.
+* @returns The derivative of the linear curve as a vector.
+* @since 1.0.0
+*/
+const derivative$3 = derivative$4;
+const solve$6 = solve$7;
+const length$4 = length$5;
+/**
+* Computes the axis-aligned bounding box of the curve over its parameter
+* domain `[0, 1]`. For a linear curve this is the closed box enclosing the
+* two endpoints.
+*
+* @param c - The linear curve.
+* @returns A closed `Box2d` enclosing the curve.
+* @since 2.1.0
+*/
+const boundingBox$4 = boundingBox$5;
+const solveAtX$6 = solveAtX$7;
+const solveAtY$6 = solveAtY$7;
+/**
+* Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+* when both the x and y polynomials are strictly monotonic. When both axes
+* are monotonic, the curve is invertible in either direction.
+*
+* For checking only one axis, call the polynomial-level refiner directly:
+* `LinearPolynomial.isMonotonic(curve.x)`.
+*
+* @since 2.0.0
+*/
+const isMonotonic$4 = isMonotonic$5;
+/**
+* Type-narrowing predicate: refines both axes' traits to include `Increasing`.
+*
+* @since 2.0.0
+*/
+const isIncreasing$4 = isIncreasing$5;
+/**
+* Type-narrowing predicate: refines both axes' traits to include `Decreasing`.
+*
+* @since 2.0.0
+*/
+const isDecreasing$4 = isDecreasing$5;
+/**
+* Asserts monotonicity in both axes, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asMonotonic$4 = asMonotonic$5;
+/**
+* Asserts that both axes are strictly increasing, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asIncreasing$4 = asIncreasing$5;
+/**
+* Asserts that both axes are strictly decreasing, throwing on failure.
+*
+* @since 2.0.0
+*/
+const asDecreasing$4 = asDecreasing$5;
+//#endregion
+//#region src/curve/quadratic2d.internal.ts
+const QuadraticCurve2dTypeId = Symbol("curvy/curve/quadratic2d");
+var QuadraticCurve2dImpl = class extends Pipeable {
+	[QuadraticCurve2dTypeId] = QuadraticCurve2dTypeId;
+	x;
+	y;
+	constructor(c0, c1) {
+		super();
+		this.x = c0;
+		this.y = c1;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+};
+const fromPolynomials$5 = (c0, c1) => new QuadraticCurve2dImpl(c0, c1);
+const fromCoefficients$3 = (c0, c1, c2) => new QuadraticCurve2dImpl(make$3(c0.x, c1.x, c2.x), make$3(c0.y, c1.y, c2.y));
+const fromBezierPoints$5 = (p0, p1, p2) => new QuadraticCurve2dImpl(make$3(p0.x, -2 * p0.x + 2 * p1.x, p0.x - 2 * p1.x + p2.x), make$3(p0.y, -2 * p0.y + 2 * p1.y, p0.y - 2 * p1.y + p2.y));
+const isQuadraticCurve2d$1 = (c) => typeof c === "object" && c !== null && QuadraticCurve2dTypeId in c;
+const solve$5 = dual(2, (c, t) => make(solve$10(c.x, t), solve$10(c.y, t)));
+const solveAtX$5 = dual(2, (c, x) => {
+	return map(clip(solveInverse$2(c.x, x), unit), (t) => solve$10(c.y, t));
+});
+const solveAtY$5 = dual(2, (c, y) => {
+	return map(clip(solveInverse$2(c.y, y), unit), (t) => solve$10(c.x, t));
+});
+const derivative$2 = (c) => fromPolynomials$6(derivative$6(c.x), derivative$6(c.y));
+const length$3 = dual(2, (c, i) => {
+	if (size(i) === 0) return 0;
+	if (c.x.c2 === 0 && c.y.c2 === 0) return length$4(fromPolynomials$6(make$2(c.x.c0, c.x.c1), make$2(c.y.c0, c.y.c1)), i);
+	const d = derivative$2(c);
+	const { scale, shift } = scaleShift(biunit, i);
+	return (GL32_W0 * magnitude(solve$6(d, shift + scale * -GL32_X0)) + GL32_W0 * magnitude(solve$6(d, shift + scale * GL32_X0)) + GL32_W1 * magnitude(solve$6(d, shift + scale * -GL32_X1)) + GL32_W1 * magnitude(solve$6(d, shift + scale * GL32_X1)) + GL32_W2 * magnitude(solve$6(d, shift + scale * -GL32_X2)) + GL32_W2 * magnitude(solve$6(d, shift + scale * GL32_X2)) + GL32_W3 * magnitude(solve$6(d, shift + scale * -GL32_X3)) + GL32_W3 * magnitude(solve$6(d, shift + scale * GL32_X3)) + GL32_W4 * magnitude(solve$6(d, shift + scale * -GL32_X4)) + GL32_W4 * magnitude(solve$6(d, shift + scale * GL32_X4)) + GL32_W5 * magnitude(solve$6(d, shift + scale * -GL32_X5)) + GL32_W5 * magnitude(solve$6(d, shift + scale * GL32_X5)) + GL32_W6 * magnitude(solve$6(d, shift + scale * -GL32_X6)) + GL32_W6 * magnitude(solve$6(d, shift + scale * GL32_X6)) + GL32_W7 * magnitude(solve$6(d, shift + scale * -GL32_X7)) + GL32_W7 * magnitude(solve$6(d, shift + scale * GL32_X7)) + GL32_W8 * magnitude(solve$6(d, shift + scale * -GL32_X8)) + GL32_W8 * magnitude(solve$6(d, shift + scale * GL32_X8)) + GL32_W9 * magnitude(solve$6(d, shift + scale * -GL32_X9)) + GL32_W9 * magnitude(solve$6(d, shift + scale * GL32_X9)) + GL32_W10 * magnitude(solve$6(d, shift + scale * -GL32_X10)) + GL32_W10 * magnitude(solve$6(d, shift + scale * GL32_X10)) + GL32_W11 * magnitude(solve$6(d, shift + scale * -GL32_X11)) + GL32_W11 * magnitude(solve$6(d, shift + scale * GL32_X11)) + GL32_W12 * magnitude(solve$6(d, shift + scale * -GL32_X12)) + GL32_W12 * magnitude(solve$6(d, shift + scale * GL32_X12)) + GL32_W13 * magnitude(solve$6(d, shift + scale * -GL32_X13)) + GL32_W13 * magnitude(solve$6(d, shift + scale * GL32_X13)) + GL32_W14 * magnitude(solve$6(d, shift + scale * -GL32_X14)) + GL32_W14 * magnitude(solve$6(d, shift + scale * GL32_X14)) + GL32_W15 * magnitude(solve$6(d, shift + scale * -GL32_X15)) + GL32_W15 * magnitude(solve$6(d, shift + scale * GL32_X15))) * scale;
+});
+const curvature$3 = dual(2, (c, t) => {
+	const d = derivative$2(c);
+	const v = solve$6(d, t);
+	const a = derivative$3(d);
+	const vMag = magnitude(v);
+	if (vMag === 0) return 0;
+	return Math.abs(cross(v, a)) / vMag ** 3;
+});
+const boundingBox$3 = (c) => make$4(range$2(c.x, unit), range$2(c.y, unit));
+const isMonotonic$3 = (c) => isMonotonic$8(c.x, unit) && isMonotonic$8(c.y, unit);
+const isIncreasing$3 = (c) => isIncreasing$8(c.x, unit) && isIncreasing$8(c.y, unit);
+const isDecreasing$3 = (c) => isDecreasing$8(c.x, unit) && isDecreasing$8(c.y, unit);
+const fail$1 = (m) => {
+	throw new Error(m);
+};
+const asMonotonic$3 = (c) => isMonotonic$3(c) ? c : fail$1("quadratic curve is not monotonic in both axes");
+const asIncreasing$3 = (c) => isIncreasing$3(c) ? c : fail$1("quadratic curve is not increasing in both axes");
+const asDecreasing$3 = (c) => isDecreasing$3(c) ? c : fail$1("quadratic curve is not decreasing in both axes");
+//#endregion
+//#region src/curve/quadratic2d.ts
+var quadratic2d_exports = /* @__PURE__ */ __exportAll({
+	asDecreasing: () => asDecreasing$2,
+	asIncreasing: () => asIncreasing$2,
+	asMonotonic: () => asMonotonic$2,
+	boundingBox: () => boundingBox$2,
+	curvature: () => curvature$2,
+	derivative: () => derivative$1,
+	fromBezierPoints: () => fromBezierPoints$4,
+	fromCoefficients: () => fromCoefficients$2,
+	fromPolynomials: () => fromPolynomials$4,
+	isDecreasing: () => isDecreasing$2,
+	isIncreasing: () => isIncreasing$2,
+	isMonotonic: () => isMonotonic$2,
+	isQuadraticCurve2d: () => isQuadraticCurve2d,
+	length: () => length$2,
+	solve: () => solve$4,
+	solveAtX: () => solveAtX$4,
+	solveAtY: () => solveAtY$4
+});
+/**
+* Creates a new `QuadraticCurve2d` instance from polynomial parameters.
+*
+* @param c0 - The x polynomial.
+* @param c1 - The y polynomial.
+* @returns A new `QuadraticCurve2d` instance.
+* @since 1.0.0
+*/
+const fromPolynomials$4 = fromPolynomials$5;
+/**
+* Creates a new `QuadraticCurve2d` instance from monomial coefficient vectors.
+*
+* Each argument bundles the per-axis coefficient at the given power: `c0`
+* holds the x⁰ term, `c1` holds the x¹ term, and so on. The resulting curve
+* evaluates to `c0 + c1·t + c2·t²` per axis.
+*
+* @param c0 - The x⁰ coefficients (x and y).
+* @param c1 - The x¹ coefficients (x and y).
+* @param c2 - The x² coefficients (x and y).
+* @returns A new `QuadraticCurve2d` instance.
+* @since 2.0.0
+*/
+const fromCoefficients$2 = fromCoefficients$3;
+/**
+* Creates a new `QuadraticCurve2d` instance from quadratic Bézier control
+* points.
+*
+* The three arguments are the Bernstein-basis control points: `p0` and `p2`
+* are the curve's endpoints and `p1` is the off-curve control handle. The
+* implementation converts to the curve's internal monomial form in closed
+* form.
+*
+* @param p0 - The first control point (curve start).
+* @param p1 - The second control point (control handle).
+* @param p2 - The third control point (curve end).
+* @returns A new `QuadraticCurve2d` instance whose curve matches the given Bézier.
+* @since 2.0.0
+*/
+const fromBezierPoints$4 = fromBezierPoints$5;
+/**
+* Checks if a value is a `QuadraticCurve2d`.
+*
+* @param c - The value to check.
+* @returns `true` if the value is a `QuadraticCurve2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isQuadraticCurve2d = isQuadraticCurve2d$1;
+const solve$4 = solve$5;
+const length$2 = length$3;
+const solveAtX$4 = solveAtX$5;
+const solveAtY$4 = solveAtY$5;
+/**
+* Computes the derivative of a quadratic curve.
+*
+* @param c - The quadratic curve to compute the derivative of.
+* @returns The derivative of the quadratic curve as a linear curve.
+* @since 1.0.0
+*/
+const derivative$1 = derivative$2;
+const curvature$2 = curvature$3;
+/**
+* Computes the axis-aligned bounding box of the curve over its parameter
+* domain `[0, 1]`. Accounts for interior extrema, so the box is tight against
+* the curve and not just the control polygon.
+*
+* @param c - The quadratic curve.
+* @returns A closed `Box2d` enclosing the curve.
+* @since 2.1.0
+*/
+const boundingBox$2 = boundingBox$3;
+/**
+* Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+* when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+*
+* For checking only one axis, call the polynomial-level refiner directly:
+* `QuadraticPolynomial.isMonotonic(curve.x, Interval.unit)`.
+*
+* @since 2.0.0
+*/
+const isMonotonic$2 = isMonotonic$3;
+/** @since 2.0.0 */
+const isIncreasing$2 = isIncreasing$3;
+/** @since 2.0.0 */
+const isDecreasing$2 = isDecreasing$3;
+/** @since 2.0.0 */
+const asMonotonic$2 = asMonotonic$3;
+/** @since 2.0.0 */
+const asIncreasing$2 = asIncreasing$3;
+/** @since 2.0.0 */
+const asDecreasing$2 = asDecreasing$3;
+//#endregion
+//#region src/curve/cubic2d.internal.ts
+const CubicCurve2dTypeId = Symbol("curvy/curve/cubic2d");
+var CubicCurve2dImpl = class extends Pipeable {
+	[CubicCurve2dTypeId] = CubicCurve2dTypeId;
+	x;
+	y;
+	constructor(c0, c1) {
+		super();
+		this.x = c0;
+		this.y = c1;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+};
+const fromPolynomials$3 = (c0, c1) => new CubicCurve2dImpl(c0, c1);
+const fromCoefficients$1 = (c0, c1, c2, c3) => new CubicCurve2dImpl(make$1(c0.x, c1.x, c2.x, c3.x), make$1(c0.y, c1.y, c2.y, c3.y));
+const fromBezierPoints$3 = (p0, p1, p2, p3) => {
+	return new CubicCurve2dImpl(...apply(cubicBezier, ...transpose([
+		p0,
+		p1,
+		p2,
+		p3
+	], (p) => [p.x, p.y])));
+};
+const isCubicCurve2d$1 = (c) => typeof c === "object" && c !== null && CubicCurve2dTypeId in c;
+const solve$3 = dual(2, (c, t) => make(solve$8(c.x, t), solve$8(c.y, t)));
+const solveAtX$3 = dual(2, (c, x) => {
+	return map(clip(solveInverse(c.x, x), unit), (t) => solve$8(c.y, t));
+});
+const solveAtY$3 = dual(2, (c, y) => {
+	return map(clip(solveInverse(c.y, y), unit), (t) => solve$8(c.x, t));
+});
+const derivative = (c) => fromPolynomials$4(derivative$5(c.x), derivative$5(c.y));
+const length$1 = dual(2, (c, i) => {
+	if (size(i) === 0) return 0;
+	if (c.x.c3 === 0 && c.y.c3 === 0) return length$2(fromPolynomials$4(make$3(c.x.c0, c.x.c1, c.x.c2), make$3(c.y.c0, c.y.c1, c.y.c2)), i);
+	const d = derivative(c);
+	const { scale, shift } = scaleShift(biunit, i);
+	return (GL32_W0 * magnitude(solve$4(d, shift + scale * -GL32_X0)) + GL32_W0 * magnitude(solve$4(d, shift + scale * GL32_X0)) + GL32_W1 * magnitude(solve$4(d, shift + scale * -GL32_X1)) + GL32_W1 * magnitude(solve$4(d, shift + scale * GL32_X1)) + GL32_W2 * magnitude(solve$4(d, shift + scale * -GL32_X2)) + GL32_W2 * magnitude(solve$4(d, shift + scale * GL32_X2)) + GL32_W3 * magnitude(solve$4(d, shift + scale * -GL32_X3)) + GL32_W3 * magnitude(solve$4(d, shift + scale * GL32_X3)) + GL32_W4 * magnitude(solve$4(d, shift + scale * -GL32_X4)) + GL32_W4 * magnitude(solve$4(d, shift + scale * GL32_X4)) + GL32_W5 * magnitude(solve$4(d, shift + scale * -GL32_X5)) + GL32_W5 * magnitude(solve$4(d, shift + scale * GL32_X5)) + GL32_W6 * magnitude(solve$4(d, shift + scale * -GL32_X6)) + GL32_W6 * magnitude(solve$4(d, shift + scale * GL32_X6)) + GL32_W7 * magnitude(solve$4(d, shift + scale * -GL32_X7)) + GL32_W7 * magnitude(solve$4(d, shift + scale * GL32_X7)) + GL32_W8 * magnitude(solve$4(d, shift + scale * -GL32_X8)) + GL32_W8 * magnitude(solve$4(d, shift + scale * GL32_X8)) + GL32_W9 * magnitude(solve$4(d, shift + scale * -GL32_X9)) + GL32_W9 * magnitude(solve$4(d, shift + scale * GL32_X9)) + GL32_W10 * magnitude(solve$4(d, shift + scale * -GL32_X10)) + GL32_W10 * magnitude(solve$4(d, shift + scale * GL32_X10)) + GL32_W11 * magnitude(solve$4(d, shift + scale * -GL32_X11)) + GL32_W11 * magnitude(solve$4(d, shift + scale * GL32_X11)) + GL32_W12 * magnitude(solve$4(d, shift + scale * -GL32_X12)) + GL32_W12 * magnitude(solve$4(d, shift + scale * GL32_X12)) + GL32_W13 * magnitude(solve$4(d, shift + scale * -GL32_X13)) + GL32_W13 * magnitude(solve$4(d, shift + scale * GL32_X13)) + GL32_W14 * magnitude(solve$4(d, shift + scale * -GL32_X14)) + GL32_W14 * magnitude(solve$4(d, shift + scale * GL32_X14)) + GL32_W15 * magnitude(solve$4(d, shift + scale * -GL32_X15)) + GL32_W15 * magnitude(solve$4(d, shift + scale * GL32_X15))) * scale;
+});
+const curvature$1 = dual(2, (c, t) => {
+	const d = derivative(c);
+	const v = solve$4(d, t);
+	const a = solve$6(derivative$1(d), t);
+	const vMag = magnitude(v);
+	if (vMag === 0) return 0;
+	return Math.abs(cross(v, a)) / vMag ** 3;
+});
+const boundingBox$1 = (c) => make$4(range(c.x, unit), range(c.y, unit));
+const isMonotonic$1 = (c) => isMonotonic$6(c.x, unit) && isMonotonic$6(c.y, unit);
+const isIncreasing$1 = (c) => isIncreasing$6(c.x, unit) && isIncreasing$6(c.y, unit);
+const isDecreasing$1 = (c) => isDecreasing$6(c.x, unit) && isDecreasing$6(c.y, unit);
+const fail = (m) => {
+	throw new Error(m);
+};
+const asMonotonic$1 = (c) => isMonotonic$1(c) ? c : fail("cubic curve is not monotonic in both axes");
+const asIncreasing$1 = (c) => isIncreasing$1(c) ? c : fail("cubic curve is not increasing in both axes");
+const asDecreasing$1 = (c) => isDecreasing$1(c) ? c : fail("cubic curve is not decreasing in both axes");
+//#endregion
+//#region src/curve/cubic2d.ts
+var cubic2d_exports = /* @__PURE__ */ __exportAll({
+	asDecreasing: () => asDecreasing,
+	asIncreasing: () => asIncreasing,
+	asMonotonic: () => asMonotonic,
+	boundingBox: () => boundingBox,
+	curvature: () => curvature,
+	fromBezierPoints: () => fromBezierPoints$2,
+	fromCoefficients: () => fromCoefficients,
+	fromPolynomials: () => fromPolynomials$2,
+	isCubicCurve2d: () => isCubicCurve2d,
+	isDecreasing: () => isDecreasing,
+	isIncreasing: () => isIncreasing,
+	isMonotonic: () => isMonotonic,
+	length: () => length,
+	solve: () => solve$2,
+	solveAtX: () => solveAtX$2,
+	solveAtY: () => solveAtY$2
+});
+/**
+* Creates a new `CubicCurve2d` instance from polynomial parameters.
+*
+* @param x - The x polynomial.
+* @param y - The y polynomial.
+* @returns A new `CubicCurve2d` instance.
+* @since 1.0.0
+*/
+const fromPolynomials$2 = fromPolynomials$3;
+/**
+* Creates a new `CubicCurve2d` instance from monomial coefficient vectors.
+*
+* Each argument bundles the per-axis coefficient at the given power: `c0`
+* holds the x⁰ term, `c1` holds the x¹ term, and so on. The resulting curve
+* evaluates to `c0 + c1·t + c2·t² + c3·t³` per axis.
+*
+* @param c0 - The x⁰ coefficients (x and y).
+* @param c1 - The x¹ coefficients (x and y).
+* @param c2 - The x² coefficients (x and y).
+* @param c3 - The x³ coefficients (x and y).
+* @returns A new `CubicCurve2d` instance.
+* @since 2.0.0
+*/
+const fromCoefficients = fromCoefficients$1;
+/**
+* Creates a new `CubicCurve2d` instance from cubic Bézier control points.
+*
+* The four arguments are the Bernstein-basis control points: `p0` and `p3` are
+* the curve's endpoints and `p1` and `p2` are the off-curve control handles.
+* The implementation converts to the curve's internal monomial form in closed
+* form.
+*
+* @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 `CubicCurve2d` instance whose curve matches the given Bézier.
+* @since 2.0.0
+*/
+const fromBezierPoints$2 = fromBezierPoints$3;
+/**
+* Checks if a value is a `CubicCurve2d`.
+*
+* @param c - The value to check.
+* @returns `true` if the value is a `CubicCurve2d`, `false` otherwise.
+* @since 1.0.0
+*/
+const isCubicCurve2d = isCubicCurve2d$1;
+const solve$2 = solve$3;
+const length = length$1;
+const solveAtX$2 = solveAtX$3;
+const solveAtY$2 = solveAtY$3;
+const curvature = curvature$1;
+/**
+* Computes the axis-aligned bounding box of the curve over its parameter
+* domain `[0, 1]`. Accounts for up to two interior extrema per axis, so the
+* box is tight against the curve and not just the control polygon.
+*
+* @param c - The cubic curve.
+* @returns A closed `Box2d` enclosing the curve.
+* @since 2.1.0
+*/
+const boundingBox = boundingBox$1;
+/**
+* Type-narrowing predicate: refines both axes' traits to include `Monotonic`
+* when both x and y polynomials are monotonic over the unit interval `[0, 1]`.
+*
+* For checking only one axis, call the polynomial-level refiner directly:
+* `CubicPolynomial.isMonotonic(curve.x, Interval.unit)`.
+*
+* @since 2.0.0
+*/
+const isMonotonic = isMonotonic$1;
+/** @since 2.0.0 */
+const isIncreasing = isIncreasing$1;
+/** @since 2.0.0 */
+const isDecreasing = isDecreasing$1;
+/** @since 2.0.0 */
+const asMonotonic = asMonotonic$1;
+/** @since 2.0.0 */
+const asIncreasing = asIncreasing$1;
+/** @since 2.0.0 */
+const asDecreasing = asDecreasing$1;
+//#endregion
+//#region src/curve/rationalCubic2d.internal.ts
+const RationalCubicCurve2dTypeId = Symbol("curvy/curve/rationalCubic2d");
+const RationalCurveTraits = Symbol.for("curvy/curve/rationalCubic2d/traits");
+var RationalCubicCurve2dImpl = class extends Pipeable {
+	[RationalCubicCurve2dTypeId] = RationalCubicCurve2dTypeId;
+	x;
+	y;
+	w;
+	constructor(x, y, w) {
+		super();
+		this.x = x;
+		this.y = y;
+		this.w = w;
+	}
+};
+const isRationalCubicCurve2d$1 = (c) => typeof c === "object" && c !== null && RationalCubicCurve2dTypeId in c;
+const fromPolynomials$1 = (x, y, w) => new RationalCubicCurve2dImpl(x, y, w);
+const fromBezierPoints$1 = (p0, p1, p2, p3) => new RationalCubicCurve2dImpl(...apply(cubicBezier, ...transpose([
+	p0,
+	p1,
+	p2,
+	p3
+], (p) => [
+	p.x * p.weight,
+	p.y * p.weight,
+	p.weight
+])));
+const makeMonotonicEasing$1 = (startSlope, endSlope) => {
+	invariant(Number.isFinite(startSlope) && startSlope >= 0, "makeMonotonicEasing: startSlope must be finite and ≥ 0");
+	invariant(Number.isFinite(endSlope) && endSlope >= 0, "makeMonotonicEasing: endSlope must be finite and ≥ 0");
+	const m0 = startSlope;
+	const m1 = endSlope;
+	const alpha = m0 + 1;
+	const beta = m1 + 1;
+	const pC0 = 0;
+	const pC1 = m0 * alpha;
+	const pC2 = beta * (2 - m1) + alpha * (1 - 2 * m0);
+	const pC3 = beta * (m1 - 1) + alpha * (m0 - 1);
+	const qC0 = alpha;
+	const qC1 = beta - alpha;
+	const xPoly = make$1(0, alpha, beta - alpha, 0);
+	const yPoly = make$1(pC0, pC1, pC2, pC3);
+	const wPoly = make$1(qC0, qC1, 0, 0);
+	const monoQ = make$1(m0 * alpha * alpha, 2 * alpha * pC2, 3 * alpha * pC3 + pC2 * (beta - alpha), 2 * pC3 * (beta - alpha));
+	const interiorRoots = monoQ.pipe(roots, clip(unitOpen));
+	for (const t of interiorRoots) {
+		const epsilon = 1e-6;
+		const lo = Math.max(0, t - epsilon);
+		const hi = Math.min(1, t + epsilon);
+		invariant(Math.sign(solve$8(monoQ, lo)) * Math.sign(solve$8(monoQ, hi)) >= 0, `makeMonotonicEasing: slopes (${m0}, ${m1}) produce a non-monotonic curve with the default Gregory-Delbourgo construction. Try smaller slopes or use a different easing form.`);
+	}
+	return new RationalCubicCurve2dImpl(xPoly, yPoly, wPoly);
+};
+const solve$1 = dual(2, (c, t) => {
+	const w = solve$8(c.w, t);
+	return make(solve$8(c.x, t) / w, solve$8(c.y, t) / w);
+});
+const solveAtX$1 = dual(2, (c, x) => make$1(c.x.c0 - x * c.w.c0, c.x.c1 - x * c.w.c1, c.x.c2 - x * c.w.c2, c.x.c3 - x * c.w.c3).pipe(roots, clip(unit), map((t) => solve$8(c.y, t) / solve$8(c.w, t))));
+const solveAtY$1 = dual(2, (c, y) => make$1(c.y.c0 - y * c.w.c0, c.y.c1 - y * c.w.c1, c.y.c2 - y * c.w.c2, c.y.c3 - y * c.w.c3).pipe(roots, clip(unit), map((t) => solve$8(c.x, t) / solve$8(c.w, t))));
+const MAX_APPROX_DEPTH = 20;
+const buildCubicCandidate = (c) => {
+	const x0 = c.x.c0;
+	const x1 = c.x.c0 + c.x.c1 / 3;
+	const x2 = c.x.c0 + 2 * c.x.c1 / 3 + c.x.c2 / 3;
+	const x3 = c.x.c0 + c.x.c1 + c.x.c2 + c.x.c3;
+	const y0 = c.y.c0;
+	const y1 = c.y.c0 + c.y.c1 / 3;
+	const y2 = c.y.c0 + 2 * c.y.c1 / 3 + c.y.c2 / 3;
+	const y3 = c.y.c0 + c.y.c1 + c.y.c2 + c.y.c3;
+	const w0 = c.w.c0;
+	const w1 = c.w.c0 + c.w.c1 / 3;
+	const w2 = c.w.c0 + 2 * c.w.c1 / 3 + c.w.c2 / 3;
+	const w3 = c.w.c0 + c.w.c1 + c.w.c2 + c.w.c3;
+	return fromBezierPoints$2(make(x0 / w0, y0 / w0), make(x1 / w1, y1 / w1), make(x2 / w2, y2 / w2), make(x3 / w3, y3 / w3));
+};
+const splitAtHalf = (c) => {
+	const [leftX, rightX] = subdivide(c.x, .5);
+	const [leftY, rightY] = subdivide(c.y, .5);
+	const [leftW, rightW] = subdivide(c.w, .5);
+	return [new RationalCubicCurve2dImpl(leftX, leftY, leftW), new RationalCubicCurve2dImpl(rightX, rightY, rightW)];
+};
+const midpointError = (c, candidate) => {
+	const w = solve$8(c.w, .5);
+	const trueX = solve$8(c.x, .5) / w;
+	const trueY = solve$8(c.y, .5) / w;
+	const candX = solve$8(candidate.x, .5);
+	const candY = solve$8(candidate.y, .5);
+	return Math.hypot(trueX - candX, trueY - candY);
+};
+const approximateAsCubicCurves$1 = dual(2, (c, tolerance) => {
+	invariant(Number.isFinite(tolerance) && tolerance > 0, "approximateAsCubicCurves: tolerance must be finite and > 0");
+	const out = [];
+	const recurse = (curr, depth) => {
+		const candidate = buildCubicCandidate(curr);
+		if (depth >= MAX_APPROX_DEPTH || midpointError(curr, candidate) <= tolerance) {
+			out.push(candidate);
+			return;
+		}
+		const [left, right] = splitAtHalf(curr);
+		recurse(left, depth + 1);
+		recurse(right, depth + 1);
+	};
+	recurse(c, 0);
+	return out;
+});
+//#endregion
+//#region src/curve/rationalCubic2d.ts
+var rationalCubic2d_exports = /* @__PURE__ */ __exportAll({
+	RationalCurveTraits: () => RationalCurveTraits,
+	approximateAsCubicCurves: () => approximateAsCubicCurves,
+	fromBezierPoints: () => fromBezierPoints,
+	fromPolynomials: () => fromPolynomials,
+	isRationalCubicCurve2d: () => isRationalCubicCurve2d,
+	makeMonotonicEasing: () => makeMonotonicEasing,
+	solve: () => solve,
+	solveAtX: () => solveAtX,
+	solveAtY: () => solveAtY
+});
+/**
+* Checks if a value is a `RationalCubicCurve2d`.
+*
+* @param c - The value to check.
+* @returns `true` if the value is a `RationalCubicCurve2d`, `false` otherwise.
+* @since 2.1.0
+*/
+const isRationalCubicCurve2d = isRationalCubicCurve2d$1;
+/**
+* Creates a new `RationalCubicCurve2d` from per-axis numerator polynomials
+* and a shared denominator polynomial.
+*
+* @param x - The x numerator polynomial.
+* @param y - The y numerator polynomial.
+* @param w - The shared denominator polynomial (must be non-zero on `[0, 1]`).
+* @returns A new `RationalCubicCurve2d` instance.
+* @since 2.1.0
+*/
+const fromPolynomials = fromPolynomials$1;
+/**
+* Creates a new `RationalCubicCurve2d` from four weighted cubic Bézier
+* control points. The four control points are lifted to homogeneous form
+* `(w·x, w·y, w)` and the cubic Bernstein basis is expanded into per-channel
+* monomial coefficients, yielding the curve's `x`, `y`, and `w` polynomials.
+*
+* @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 `RationalCubicCurve2d` instance.
+* @since 2.1.0
+*/
+const fromBezierPoints = fromBezierPoints$1;
+/**
+* Creates a guaranteed-monotonic rational cubic easing curve via Gregory-
+* Delbourgo style construction. The result interpolates `(0, 0)` and
+* `(1, 1)` with the given endpoint slopes, with `x(t) = t` pinned linearly
+* and a rational cubic numerator for `y(t)`. Monotonicity of `y(t)` is
+* verified rigorously at construction (degree-3 polynomial sign analysis);
+* the returned curve is branded `<Increasing, Increasing>` so that
+* {@link solveAtX} returns `Solution.AtMostOne<number>` without further
+* trait refinement.
+*
+* For input slope combinations that the default Gregory-Delbourgo
+* construction cannot accommodate (typically when one slope is large while
+* the other is small), construction throws. Useful operating range is
+* roughly `m₀, m₁ ∈ [0, 2]` with `m₀ + m₁ ≲ 3`; smoothstep (`0, 0`) and
+* linear (`1, 1`) fall out as special cases.
+*
+* @param startSlope - The easing function's slope at the start (`dy/dx` at `x = 0`); must be finite and non-negative.
+* @param endSlope - The easing function's slope at the end (`dy/dx` at `x = 1`); must be finite and non-negative.
+* @returns A monotone-by-construction rational cubic easing curve.
+* @throws When slopes are negative, non-finite, or produce a non-monotonic curve under the default construction.
+* @since 2.1.0
+*/
+const makeMonotonicEasing = makeMonotonicEasing$1;
+const solve = solve$1;
+const solveAtX = solveAtX$1;
+const solveAtY = solveAtY$1;
+const approximateAsCubicCurves = approximateAsCubicCurves$1;
+//#endregion
+export { linear2d_exports as _, boundingBox as a, length as c, boundingBox$2 as d, length$2 as f, length$4 as g, boundingBox$4 as h, solve as i, solve$2 as l, solve$4 as m, fromBezierPoints as n, cubic2d_exports as o, quadratic2d_exports as p, rationalCubic2d_exports as r, fromPolynomials$2 as s, approximateAsCubicCurves as t, derivative as u, solve$6 as v };
+
+//# sourceMappingURL=rationalCubic2d-Bys2Uory.mjs.map