curvy 1.0.0 → 1.0.2

package/dist/polynomial/linear.d.ts

@@ -1,7 +1,7 @@
 import '../shared/curvy.BN-oFBsc.js';
 import '../interval.js';
 import '../vector/vector2.js';
-export { L as LinearPolynomial, O as antiderivative, P as domain, G as fromVector, E as isLinearPolynomial, S as length, F as make, N as monotonicity, R as range, M as root, H as solve, J as solveInverse, K as toInverseSolver, I as toSolver } from '../shared/curvy.CO0Wclt0.js';
-import '../shared/curvy.CT38g_II.js';
+export { L as LinearPolynomial, U as antiderivative, T as derivative, V as domain, J as fromPointSlope, K as fromPoints, I as fromVector, G as isLinearPolynomial, X as length, H as make, S as monotonicity, W as range, R as root, M as solve, O as solveInverse, P as toInverseSolver, N as toSolver } from '../shared/curvy.CkJRVnqj.js';
+import '../shared/curvy.Bf5TIk31.js';
 import '../vector/vector3.js';
 import '../vector/vector4.js';

package/dist/polynomial/linear.mjs

@@ -1,19 +1,22 @@
-import { i as isLinearPolynomial$1, a as make$1, f as fromVector$1, c as solve$1, t as toSolver$1, s as solveInverse$1, d as toInverseSolver$1, m as monotonicity$1, e as antiderivative$1, g as domain$1, r as range$1, l as length$1 } from '../shared/curvy.DgRsieUW.mjs';
-import '../shared/curvy.ChkqgKuv.mjs';
+import { i as isLinearPolynomial$1, a as make$1, f as fromVector$1, d as fromPointSlope$1, e as fromPoints$1, s as solve$1, t as toSolver$1, c as solveInverse$1, g as toInverseSolver$1, m as monotonicity$1, h as derivative$1, j as antiderivative$1, k as domain$1, r as range$1, l as length$1 } from '../shared/curvy.O57gIOmy.mjs';
+import '../shared/curvy.DLOeble8.mjs';
 import '../interval.mjs';
 
 const isLinearPolynomial = isLinearPolynomial$1;
 const make = make$1;
 const fromVector = fromVector$1;
+const fromPointSlope = fromPointSlope$1;
+const fromPoints = fromPoints$1;
 const solve = solve$1;
 const toSolver = toSolver$1;
 const solveInverse = solveInverse$1;
 const toInverseSolver = toInverseSolver$1;
 const root = (p) => solveInverse$1(p, 0);
 const monotonicity = monotonicity$1;
+const derivative = derivative$1;
 const antiderivative = antiderivative$1;
 const domain = domain$1;
 const range = range$1;
 const length = length$1;
 
-export { antiderivative, domain, fromVector, isLinearPolynomial, length, make, monotonicity, range, root, solve, solveInverse, toInverseSolver, toSolver };
+export { antiderivative, derivative, domain, fromPointSlope, fromPoints, fromVector, isLinearPolynomial, length, make, monotonicity, range, root, solve, solveInverse, toInverseSolver, toSolver };

package/dist/polynomial/quadratic.d.mts

@@ -1,7 +1,7 @@
 import '../shared/curvy.BN-oFBsc.mjs';
 import '../interval.mjs';
 import '../vector/vector3.mjs';
-export { Q as QuadraticPolynomial, z as antiderivative, v as derivative, A as domain, x as extreme, n as fromVector, j as isQuadraticPolynomial, D as length, k as make, y as monotonicity, B as range, w as roots, o as solve, q as solveInverse, u as toInverseSolver, p as toSolver } from '../shared/curvy.Bxxwly94.mjs';
-import '../shared/curvy.CT38g_II.mjs';
+export { Q as QuadraticPolynomial, A as antiderivative, F as curvature, w as derivative, B as domain, y as extreme, o as fromVector, k as isQuadraticPolynomial, E as length, n as make, z as monotonicity, D as range, x as roots, p as solve, u as solveInverse, v as toInverseSolver, q as toSolver } from '../shared/curvy.DwHW5Fqt.mjs';
+import '../shared/curvy.Bf5TIk31.mjs';
 import '../vector/vector2.mjs';
 import '../vector/vector4.mjs';

package/dist/polynomial/quadratic.d.ts

@@ -1,7 +1,7 @@
 import '../shared/curvy.BN-oFBsc.js';
 import '../interval.js';
 import '../vector/vector3.js';
-export { Q as QuadraticPolynomial, z as antiderivative, v as derivative, A as domain, x as extreme, n as fromVector, j as isQuadraticPolynomial, D as length, k as make, y as monotonicity, B as range, w as roots, o as solve, q as solveInverse, u as toInverseSolver, p as toSolver } from '../shared/curvy.CO0Wclt0.js';
-import '../shared/curvy.CT38g_II.js';
+export { Q as QuadraticPolynomial, A as antiderivative, F as curvature, w as derivative, B as domain, y as extreme, o as fromVector, k as isQuadraticPolynomial, E as length, n as make, z as monotonicity, D as range, x as roots, p as solve, u as solveInverse, v as toInverseSolver, q as toSolver } from '../shared/curvy.CkJRVnqj.js';
+import '../shared/curvy.Bf5TIk31.js';
 import '../vector/vector2.js';
 import '../vector/vector4.js';

package/dist/polynomial/quadratic.mjs

@@ -1,7 +1,7 @@
-import { i as isQuadraticPolynomial$1, m as make$1, f as fromVector$1, c as solve$1, t as toSolver$1, s as solveInverse$1, d as toInverseSolver$1, e as derivative$1, r as roots$1, h as extreme$1, b as monotonicity$1, j as antiderivative$1, k as domain$1, n as range$1, l as length$1 } from '../shared/curvy.CLzGuqek.mjs';
-import '../shared/curvy.ChkqgKuv.mjs';
+import { i as isQuadraticPolynomial$1, m as make$1, f as fromVector$1, c as solve$1, t as toSolver$1, s as solveInverse$1, e as toInverseSolver$1, d as derivative$1, r as roots$1, h as extreme$1, b as monotonicity$1, j as antiderivative$1, k as domain$1, n as range$1, l as length$1, o as curvature$1 } from '../shared/curvy.ZjG-q57I.mjs';
+import '../shared/curvy.DLOeble8.mjs';
 import '../interval.mjs';
-import '../shared/curvy.DgRsieUW.mjs';
+import '../shared/curvy.O57gIOmy.mjs';
 
 const isQuadraticPolynomial = isQuadraticPolynomial$1;
 const make = make$1;
@@ -18,5 +18,6 @@ const antiderivative = antiderivative$1;
 const domain = domain$1;
 const range = range$1;
 const length = length$1;
+const curvature = curvature$1;
 
-export { antiderivative, derivative, domain, extreme, fromVector, isQuadraticPolynomial, length, make, monotonicity, range, roots, solve, solveInverse, toInverseSolver, toSolver };
+export { antiderivative, curvature, derivative, domain, extreme, fromVector, isQuadraticPolynomial, length, make, monotonicity, range, roots, solve, solveInverse, toInverseSolver, toSolver };

package/dist/shared/{curvy.Cty3LrOR.mjs → curvy.B1zfBfvf.mjs}

@@ -1,4 +1,4 @@
-import { d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { d as dual, r as round, P as Pipeable } from './curvy.DLOeble8.mjs';
 
 const Vector4TypeId = Symbol.for("curvy/vector4");
 class Vector4Impl extends Pipeable {
@@ -66,5 +66,9 @@ const hadamard = dual(
   2,
   (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w)
 );
+const scale = dual(
+  2,
+  (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s, v.w * s)
+);
 
-export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector4 as i, make as m, normalize as n, softmax as s };
+export { magnitude as a, add as b, components as c, dot as d, subtract as e, scale as f, hadamard as h, isVector4 as i, make as m, normalize as n, softmax as s };

package/dist/shared/{curvy.DOLqYbKE.mjs → curvy.BPOevbwG.mjs}

@@ -1,16 +1,14 @@
-import { d as dual, a as PRECISION, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { d as dual, r as round, P as Pipeable } from './curvy.DLOeble8.mjs';
 
 const Vector2TypeId = Symbol.for("curvy/vector2");
 class Vector2Impl extends Pipeable {
   [Vector2TypeId] = Vector2TypeId;
   x;
   y;
-  precision;
-  constructor(v0 = 0, v1 = 0, precision = PRECISION) {
+  constructor(v0 = 0, v1 = 0) {
     super();
-    this.x = round(v0, precision);
-    this.y = round(v1, precision);
-    this.precision = precision;
+    this.x = round(v0);
+    this.y = round(v1);
   }
   get [0]() {
     return this.x;
@@ -26,7 +24,7 @@ class Vector2Impl extends Pipeable {
   }
 }
 const isVector2 = (v) => typeof v === "object" && v !== null && Vector2TypeId in v;
-const make = (v0, v1 = v0, precision = PRECISION) => new Vector2Impl(v0, v1, precision);
+const make = (v0, v1 = v0) => new Vector2Impl(v0, v1);
 const components = (v) => [v.x, v.y];
 const magnitude = (vector) => round(Math.hypot(vector.x, vector.y));
 const normalize = (vector) => {
@@ -34,6 +32,7 @@ const normalize = (vector) => {
   return make(vector.x / m, vector.y / m);
 };
 const dot = dual(2, (a, b) => round(a.x * b.x + a.y * b.y));
+const cross = dual(2, (a, b) => round(a.x * b.y - a.y * b.x));
 const softmax = (v) => {
   const max = Math.max(v.x, v.y);
   const v0 = Math.exp(v.x - max);
@@ -44,5 +43,6 @@ const softmax = (v) => {
 const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y));
 const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y));
 const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y));
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s));
 
-export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector2 as i, make as m, normalize as n, softmax as s };
+export { magnitude as a, components as b, cross as c, dot as d, add as e, subtract as f, scale as g, hadamard as h, isVector2 as i, make as m, normalize as n, softmax as s };

package/dist/shared/{curvy.CT38g_II.d.mts → curvy.Bf5TIk31.d.mts}

@@ -19,4 +19,4 @@ interface FourDimensional<T> extends ThreeDimensional<T> {
     readonly 3: T;
 }
 
-export type { FourDimensionalIndex as F, ThreeDimensionalIndex as T, FourDimensionalComponent as a, ThreeDimensionalComponent as b, TwoDimensionalIndex as c, TwoDimensionalComponent as d, TwoDimensional as e, FourDimensional as f, ThreeDimensional as g };
+export type { FourDimensionalIndex as F, TwoDimensional as T, FourDimensionalComponent as a, ThreeDimensionalIndex as b, ThreeDimensionalComponent as c, TwoDimensionalIndex as d, TwoDimensionalComponent as e, FourDimensional as f, ThreeDimensional as g };

package/dist/shared/{curvy.CT38g_II.d.ts → curvy.Bf5TIk31.d.ts}

@@ -19,4 +19,4 @@ interface FourDimensional<T> extends ThreeDimensional<T> {
     readonly 3: T;
 }
 
-export type { FourDimensionalIndex as F, ThreeDimensionalIndex as T, FourDimensionalComponent as a, ThreeDimensionalComponent as b, TwoDimensionalIndex as c, TwoDimensionalComponent as d, TwoDimensional as e, FourDimensional as f, ThreeDimensional as g };
+export type { FourDimensionalIndex as F, TwoDimensional as T, FourDimensionalComponent as a, ThreeDimensionalIndex as b, ThreeDimensionalComponent as c, TwoDimensionalIndex as d, TwoDimensionalComponent as e, FourDimensional as f, ThreeDimensional as g };

package/dist/shared/{curvy.C-sUk7ux.mjs → curvy.BrrC9QVB.mjs}

@@ -1,5 +1,5 @@
-import { i as invariant, d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
-import { m as make$1, d as dot } from './curvy.DOLqYbKE.mjs';
+import { i as invariant, d as dual, r as round, P as Pipeable } from './curvy.DLOeble8.mjs';
+import { m as make$1, d as dot } from './curvy.BPOevbwG.mjs';
 
 function toIndex(input) {
   if (typeof input === "number") {

package/dist/shared/{curvy.CO0Wclt0.d.ts → curvy.CkJRVnqj.d.ts}

@@ -35,7 +35,7 @@ declare const solveInverse$2: {
     (y: number): (p: CubicPolynomial) => ZeroToThreeSolutions;
 };
 declare const toInverseSolver$2: (p: CubicPolynomial) => (y: number) => ZeroToThreeSolutions;
-declare const derivative$1: (p: CubicPolynomial) => QuadraticPolynomial;
+declare const derivative$2: (p: CubicPolynomial) => QuadraticPolynomial;
 declare const roots$1: (p: CubicPolynomial) => ZeroToThreeSolutions;
 declare const extrema: (p: CubicPolynomial) => ZeroToTwoSolutions;
 declare const monotonicity$2: {
@@ -54,6 +54,10 @@ declare const length$2: {
     (p: CubicPolynomial, domain: Interval): number;
     (domain: Interval): (p: CubicPolynomial) => number;
 };
+declare const curvature$1: {
+    (p: CubicPolynomial, x: number): number;
+    (x: number): (p: CubicPolynomial) => number;
+};
 
 declare const QuadraticPolynomialTypeId: unique symbol;
 type QuadraticPolynomialTypeId = typeof QuadraticPolynomialTypeId;
@@ -77,7 +81,7 @@ declare const solveInverse$1: {
     (y: number): (p: QuadraticPolynomial) => ZeroToTwoSolutions;
 };
 declare const toInverseSolver$1: (p: QuadraticPolynomial) => (y: number) => ZeroToTwoSolutions;
-declare const derivative: (p: QuadraticPolynomial) => LinearPolynomial;
+declare const derivative$1: (p: QuadraticPolynomial) => LinearPolynomial;
 declare const roots: (p: QuadraticPolynomial) => ZeroToTwoSolutions;
 declare const extreme: (p: QuadraticPolynomial) => ZeroOrOneSolution;
 declare const monotonicity$1: {
@@ -100,6 +104,10 @@ declare const length$1: {
     (p: QuadraticPolynomial, i: Interval): number;
     (i: Interval): (p: QuadraticPolynomial) => number;
 };
+declare const curvature: {
+    (p: QuadraticPolynomial, x: number): number;
+    (x: number): (p: QuadraticPolynomial) => number;
+};
 
 declare const LinearPolynomialTypeId: unique symbol;
 type LinearPolynomialTypeId = typeof LinearPolynomialTypeId;
@@ -112,6 +120,8 @@ interface LinearPolynomial extends Pipeable {
 declare const isLinearPolynomial: (v: unknown) => v is LinearPolynomial;
 declare const make: (c0?: number, c1?: number) => LinearPolynomial;
 declare const fromVector: (v: Vector2) => LinearPolynomial;
+declare const fromPointSlope: (p: Vector2, slope: number) => LinearPolynomial;
+declare const fromPoints: (p1: Vector2, p2: Vector2) => LinearPolynomial;
 declare const solve: {
     (p: LinearPolynomial, x: number): number;
     (x: number): (p: LinearPolynomial) => number;
@@ -124,6 +134,7 @@ declare const solveInverse: {
 declare const toInverseSolver: (p: LinearPolynomial) => (y: number) => ZeroOrOneSolution;
 declare const root: (p: LinearPolynomial) => ZeroOrOneSolution;
 declare const monotonicity: (p: LinearPolynomial) => GuaranteedMonotonicity;
+declare const derivative: (p: LinearPolynomial) => number;
 declare const antiderivative: {
     (p: LinearPolynomial, constant?: number): QuadraticPolynomial;
     (constant: number): (p: LinearPolynomial) => QuadraticPolynomial;
@@ -141,4 +152,4 @@ declare const length: {
     (domain: Interval): (p: LinearPolynomial) => number;
 };
 
-export { domain$1 as A, range$1 as B, type CubicPolynomial as C, length$1 as D, isLinearPolynomial as E, make as F, fromVector as G, solve as H, toSolver as I, solveInverse as J, toInverseSolver as K, type LinearPolynomial as L, root as M, monotonicity as N, antiderivative as O, domain as P, type QuadraticPolynomial as Q, range as R, length as S, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$1 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, isQuadraticPolynomial as j, make$1 as k, length$2 as l, make$2 as m, fromVector$1 as n, solve$1 as o, toSolver$1 as p, solveInverse$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, toInverseSolver$1 as u, derivative as v, roots as w, extreme as x, monotonicity$1 as y, antiderivative$1 as z };
+export { antiderivative$1 as A, domain$1 as B, type CubicPolynomial as C, range$1 as D, length$1 as E, curvature as F, isLinearPolynomial as G, make as H, fromVector as I, fromPointSlope as J, fromPoints as K, type LinearPolynomial as L, solve as M, toSolver as N, solveInverse as O, toInverseSolver as P, type QuadraticPolynomial as Q, root as R, monotonicity as S, derivative as T, antiderivative as U, domain as V, range as W, length as X, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$2 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, curvature$1 as j, isQuadraticPolynomial as k, length$2 as l, make$2 as m, make$1 as n, fromVector$1 as o, solve$1 as p, toSolver$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, solveInverse$1 as u, toInverseSolver$1 as v, derivative$1 as w, roots as x, extreme as y, monotonicity$1 as z };

package/dist/shared/{curvy.ChkqgKuv.mjs → curvy.DLOeble8.mjs}

@@ -98,6 +98,14 @@ function round(value, precision = PRECISION) {
   }
   return result;
 }
+function roundDown(value, precision = PRECISION) {
+  const scale = 10 ** precision;
+  const result = Math.floor(value * scale) / scale;
+  if (result === 0) {
+    return 0;
+  }
+  return result;
+}
 dual(
   5,
   (x, x1, x2, y1, y2) => {
@@ -116,4 +124,4 @@ function invariant(condition, message) {
   }
 }
 
-export { Pipeable as P, PRECISION as a, dual as d, invariant as i, round as r };
+export { Pipeable as P, roundDown as a, dual as d, invariant as i, round as r };

package/dist/shared/curvy.DN9ptodP.mjs

@@ -0,0 +1,55 @@
+import { fromPolynomials } from '../curve/cubic2d.mjs';
+import { vectorProductLeft } from '../matrix/matrix4x4.mjs';
+import { fromVector } from '../polynomial/cubic.mjs';
+import { make } from '../vector/vector4.mjs';
+
+function* toCurves(points, matrix, 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 fromPolynomials(
+      fromVector(
+        vectorProductLeft(
+          matrix,
+          make(p0.x, p1.x, p2.x, p3.x)
+        )
+      ),
+      fromVector(
+        vectorProductLeft(
+          matrix,
+          make(p0.y, p1.y, p2.y, p3.y)
+        )
+      )
+    );
+    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;
+    }
+  }
+}
+
+export { toCurves as t };

package/dist/shared/{curvy.BAW_cKLu.mjs → curvy.DTco5vku.mjs}

@@ -1,6 +1,6 @@
-import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.C-sUk7ux.mjs';
-import { d as dual, r as round, i as invariant, P as Pipeable } from './curvy.ChkqgKuv.mjs';
-import { c as components, m as make$2, d as dot } from './curvy.D7bhnwZy.mjs';
+import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.BrrC9QVB.mjs';
+import { d as dual, r as round, i as invariant, P as Pipeable } from './curvy.DLOeble8.mjs';
+import { c as components, m as make$2, d as dot } from './curvy.DV4S13Cq.mjs';
 
 const Matrix3x3TypeId = Symbol.for("curvy/matrix3x3");
 class Matrix3x3Impl extends Pipeable {

package/dist/shared/{curvy.D7bhnwZy.mjs → curvy.DV4S13Cq.mjs}

@@ -1,4 +1,4 @@
-import { d as dual, r as round, P as Pipeable } from './curvy.ChkqgKuv.mjs';
+import { d as dual, r as round, P as Pipeable } from './curvy.DLOeble8.mjs';
 
 const Vector3TypeId = Symbol.for("curvy/vector3");
 class Vector3Impl extends Pipeable {
@@ -48,5 +48,6 @@ const make = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
 const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z));
 const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z));
 const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z));
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s));
 
-export { magnitude as a, add as b, components as c, dot as d, subtract as e, hadamard as h, isVector3 as i, make as m, normalize as n, softmax as s };
+export { magnitude as a, add as b, components as c, dot as d, subtract as e, scale as f, hadamard as h, isVector3 as i, make as m, normalize as n, softmax as s };

package/dist/shared/{curvy.Bxxwly94.d.mts → curvy.DwHW5Fqt.d.mts}

@@ -35,7 +35,7 @@ declare const solveInverse$2: {
     (y: number): (p: CubicPolynomial) => ZeroToThreeSolutions;
 };
 declare const toInverseSolver$2: (p: CubicPolynomial) => (y: number) => ZeroToThreeSolutions;
-declare const derivative$1: (p: CubicPolynomial) => QuadraticPolynomial;
+declare const derivative$2: (p: CubicPolynomial) => QuadraticPolynomial;
 declare const roots$1: (p: CubicPolynomial) => ZeroToThreeSolutions;
 declare const extrema: (p: CubicPolynomial) => ZeroToTwoSolutions;
 declare const monotonicity$2: {
@@ -54,6 +54,10 @@ declare const length$2: {
     (p: CubicPolynomial, domain: Interval): number;
     (domain: Interval): (p: CubicPolynomial) => number;
 };
+declare const curvature$1: {
+    (p: CubicPolynomial, x: number): number;
+    (x: number): (p: CubicPolynomial) => number;
+};
 
 declare const QuadraticPolynomialTypeId: unique symbol;
 type QuadraticPolynomialTypeId = typeof QuadraticPolynomialTypeId;
@@ -77,7 +81,7 @@ declare const solveInverse$1: {
     (y: number): (p: QuadraticPolynomial) => ZeroToTwoSolutions;
 };
 declare const toInverseSolver$1: (p: QuadraticPolynomial) => (y: number) => ZeroToTwoSolutions;
-declare const derivative: (p: QuadraticPolynomial) => LinearPolynomial;
+declare const derivative$1: (p: QuadraticPolynomial) => LinearPolynomial;
 declare const roots: (p: QuadraticPolynomial) => ZeroToTwoSolutions;
 declare const extreme: (p: QuadraticPolynomial) => ZeroOrOneSolution;
 declare const monotonicity$1: {
@@ -100,6 +104,10 @@ declare const length$1: {
     (p: QuadraticPolynomial, i: Interval): number;
     (i: Interval): (p: QuadraticPolynomial) => number;
 };
+declare const curvature: {
+    (p: QuadraticPolynomial, x: number): number;
+    (x: number): (p: QuadraticPolynomial) => number;
+};
 
 declare const LinearPolynomialTypeId: unique symbol;
 type LinearPolynomialTypeId = typeof LinearPolynomialTypeId;
@@ -112,6 +120,8 @@ interface LinearPolynomial extends Pipeable {
 declare const isLinearPolynomial: (v: unknown) => v is LinearPolynomial;
 declare const make: (c0?: number, c1?: number) => LinearPolynomial;
 declare const fromVector: (v: Vector2) => LinearPolynomial;
+declare const fromPointSlope: (p: Vector2, slope: number) => LinearPolynomial;
+declare const fromPoints: (p1: Vector2, p2: Vector2) => LinearPolynomial;
 declare const solve: {
     (p: LinearPolynomial, x: number): number;
     (x: number): (p: LinearPolynomial) => number;
@@ -124,6 +134,7 @@ declare const solveInverse: {
 declare const toInverseSolver: (p: LinearPolynomial) => (y: number) => ZeroOrOneSolution;
 declare const root: (p: LinearPolynomial) => ZeroOrOneSolution;
 declare const monotonicity: (p: LinearPolynomial) => GuaranteedMonotonicity;
+declare const derivative: (p: LinearPolynomial) => number;
 declare const antiderivative: {
     (p: LinearPolynomial, constant?: number): QuadraticPolynomial;
     (constant: number): (p: LinearPolynomial) => QuadraticPolynomial;
@@ -141,4 +152,4 @@ declare const length: {
     (domain: Interval): (p: LinearPolynomial) => number;
 };
 
-export { domain$1 as A, range$1 as B, type CubicPolynomial as C, length$1 as D, isLinearPolynomial as E, make as F, fromVector as G, solve as H, toSolver as I, solveInverse as J, toInverseSolver as K, type LinearPolynomial as L, root as M, monotonicity as N, antiderivative as O, domain as P, type QuadraticPolynomial as Q, range as R, length as S, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$1 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, isQuadraticPolynomial as j, make$1 as k, length$2 as l, make$2 as m, fromVector$1 as n, solve$1 as o, toSolver$1 as p, solveInverse$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, toInverseSolver$1 as u, derivative as v, roots as w, extreme as x, monotonicity$1 as y, antiderivative$1 as z };
+export { antiderivative$1 as A, domain$1 as B, type CubicPolynomial as C, range$1 as D, length$1 as E, curvature as F, isLinearPolynomial as G, make as H, fromVector as I, fromPointSlope as J, fromPoints as K, type LinearPolynomial as L, solve as M, toSolver as N, solveInverse as O, toInverseSolver as P, type QuadraticPolynomial as Q, root as R, monotonicity as S, derivative as T, antiderivative as U, domain as V, range as W, length as X, solveInverse$2 as a, toInverseSolver$2 as b, monotonicity$2 as c, derivative$2 as d, extrema as e, fromVector$2 as f, domain$2 as g, range$2 as h, isCubicPolynomial as i, curvature$1 as j, isQuadraticPolynomial as k, length$2 as l, make$2 as m, make$1 as n, fromVector$1 as o, solve$1 as p, toSolver$1 as q, roots$1 as r, solve$2 as s, toSolver$2 as t, solveInverse$1 as u, toInverseSolver$1 as v, derivative$1 as w, roots as x, extreme as y, monotonicity$1 as z };

package/dist/shared/{curvy.DgRsieUW.mjs → curvy.O57gIOmy.mjs}

@@ -1,4 +1,4 @@
-import { P as Pipeable, r as round, d as dual } from './curvy.ChkqgKuv.mjs';
+import { P as Pipeable, r as round, d as dual } from './curvy.DLOeble8.mjs';
 import { make as make$1, size } from '../interval.mjs';
 
 const QuadraticPolynomialTypeId = Symbol.for(
@@ -31,6 +31,8 @@ class LinearPolynomialImpl extends Pipeable {
 const isLinearPolynomial = (v) => typeof v === "object" && v !== null && LinearPolynomialTypeId in v;
 const make = (c0 = 0, c1 = 0) => new LinearPolynomialImpl(c0, c1);
 const fromVector = (v) => new LinearPolynomialImpl(v.x, v.y);
+const fromPointSlope = (p, slope) => new LinearPolynomialImpl(p.y - slope * p.x, slope);
+const fromPoints = (p1, p2) => fromPointSlope(p1, (p2.y - p1.y) / (p2.x - p1.x));
 const solve = dual(2, (p, x) => round(p.c0 + x * p.c1));
 const toSolver = (p) => (x) => solve(p, x);
 const solveInverse = dual(2, (p, y) => {
@@ -41,6 +43,7 @@ const solveInverse = dual(2, (p, y) => {
 });
 const toInverseSolver = (p) => (y) => solveInverse(p, y);
 const monotonicity = (p) => p.c1 === 0 ? "constant" : p.c1 > 0 ? "increasing" : "decreasing";
+const derivative = (p) => p.c1;
 const antiderivative = dual(
   (args) => isLinearPolynomial(args[0]),
   (p, integrationConstant = 0) => new QuadraticPolynomialImpl(integrationConstant, p.c0, p.c1 / 2)
@@ -73,4 +76,4 @@ const length = dual(2, (p, domain2) => {
   return round(Math.sqrt(1 + p.c1 ** 2) * size(domain2));
 });
 
-export { QuadraticPolynomialImpl as Q, make as a, QuadraticPolynomialTypeId as b, solve as c, toInverseSolver as d, antiderivative as e, fromVector as f, domain as g, isLinearPolynomial as i, length as l, monotonicity as m, range as r, solveInverse as s, toSolver as t };
+export { QuadraticPolynomialImpl as Q, make as a, QuadraticPolynomialTypeId as b, solveInverse as c, fromPointSlope as d, fromPoints as e, fromVector as f, toInverseSolver as g, derivative as h, isLinearPolynomial as i, antiderivative as j, domain as k, length as l, monotonicity as m, range as r, solve as s, toSolver as t };

package/dist/shared/{curvy.CLzGuqek.mjs → curvy.ZjG-q57I.mjs}

@@ -1,6 +1,6 @@
-import { P as Pipeable, r as round, d as dual } from './curvy.ChkqgKuv.mjs';
+import { P as Pipeable, r as round, d as dual } from './curvy.DLOeble8.mjs';
 import { size, contains, fromMinMax } from '../interval.mjs';
-import { Q as QuadraticPolynomialImpl, b as QuadraticPolynomialTypeId, a as make$1, s as solveInverse$1, m as monotonicity$1, r as range$1, l as length$1, c as solve$1 } from './curvy.DgRsieUW.mjs';
+import { Q as QuadraticPolynomialImpl, b as QuadraticPolynomialTypeId, a as make$1, c as solveInverse$1, m as monotonicity$1, r as range$1, l as length$1, s as solve$1 } from './curvy.O57gIOmy.mjs';
 
 const CubicPolynomialTypeId = Symbol.for(
   "curvy/polynomial/cubic"
@@ -120,5 +120,11 @@ const length = dual(2, (p, domain2) => {
   const evalEnd = (derivativeEnd * sqrtEnd + Math.log(Math.abs(derivativeEnd + sqrtEnd))) / (4 * p.c2);
   return round(evalEnd - evalStart);
 });
+const curvature = dual(
+  2,
+  (p, x) => round(
+    Math.abs(2 * p.c2) / (1 + (solve$1(derivative(p), x) ** 2) ** 1.5)
+  )
+);
 
-export { CubicPolynomialImpl as C, CubicPolynomialTypeId as a, monotonicity as b, solve as c, toInverseSolver as d, derivative as e, fromVector as f, guaranteedMonotonicityFromComparison as g, extreme as h, isQuadraticPolynomial as i, antiderivative as j, domain as k, length as l, make as m, range as n, roots as r, solveInverse as s, toSolver as t };
+export { CubicPolynomialImpl as C, CubicPolynomialTypeId as a, monotonicity as b, solve as c, derivative as d, toInverseSolver as e, fromVector as f, guaranteedMonotonicityFromComparison as g, extreme as h, isQuadraticPolynomial as i, antiderivative as j, domain as k, length as l, make as m, range as n, curvature as o, roots as r, solveInverse as s, toSolver as t };

package/dist/splines/basis2d.d.mts

@@ -0,0 +1,36 @@
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+import { Matrix4x4 } from '../matrix/matrix4x4.mjs';
+import { CubicPath2d } from '../path/cubic2d.mjs';
+import { Vector2 } from '../vector/vector2.mjs';
+import '../shared/curvy.Bf5TIk31.mjs';
+import '../vector/vector4.mjs';
+import '../matrix/matrix3x3.mjs';
+import '../vector/vector3.mjs';
+import '../matrix/matrix2x2.mjs';
+import '../curve/cubic2d.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DwHW5Fqt.mjs';
+
+declare const Basis2dTypeId: unique symbol;
+type Basis2dTypeId = typeof Basis2dTypeId;
+
+declare const characteristic: Matrix4x4;
+interface Basis2d extends Pipeable {
+    readonly [Basis2dTypeId]: Basis2dTypeId;
+    [Symbol.iterator](): Iterator<Vector2>;
+}
+declare const isBasis2d: (p: unknown) => p is Basis2d;
+declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Basis2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Basis2d;
+declare const append: {
+    (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+    (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+declare const prepend: {
+    (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+    (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+declare const withTriplicatedEndpoints: (p: Basis2d) => Basis2d;
+declare const toPath: (p: Basis2d) => CubicPath2d;
+
+export { type Basis2d, append, characteristic, fromArray, isBasis2d, make, prepend, toPath, withTriplicatedEndpoints };

package/dist/splines/basis2d.d.ts

@@ -0,0 +1,36 @@
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+import { Matrix4x4 } from '../matrix/matrix4x4.js';
+import { CubicPath2d } from '../path/cubic2d.js';
+import { Vector2 } from '../vector/vector2.js';
+import '../shared/curvy.Bf5TIk31.js';
+import '../vector/vector4.js';
+import '../matrix/matrix3x3.js';
+import '../vector/vector3.js';
+import '../matrix/matrix2x2.js';
+import '../curve/cubic2d.js';
+import '../interval.js';
+import '../shared/curvy.CkJRVnqj.js';
+
+declare const Basis2dTypeId: unique symbol;
+type Basis2dTypeId = typeof Basis2dTypeId;
+
+declare const characteristic: Matrix4x4;
+interface Basis2d extends Pipeable {
+    readonly [Basis2dTypeId]: Basis2dTypeId;
+    [Symbol.iterator](): Iterator<Vector2>;
+}
+declare const isBasis2d: (p: unknown) => p is Basis2d;
+declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Basis2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Basis2d;
+declare const append: {
+    (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+    (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+declare const prepend: {
+    (...points: ReadonlyArray<Vector2>): (p: Basis2d) => Basis2d;
+    (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
+};
+declare const withTriplicatedEndpoints: (p: Basis2d) => Basis2d;
+declare const toPath: (p: Basis2d) => CubicPath2d;
+
+export { type Basis2d, append, characteristic, fromArray, isBasis2d, make, prepend, toPath, withTriplicatedEndpoints };

package/dist/splines/basis2d.mjs

@@ -0,0 +1,86 @@
+import { a as roundDown, d as dual, P as Pipeable, i as invariant } from '../shared/curvy.DLOeble8.mjs';
+import { make as make$2 } from '../matrix/matrix4x4.mjs';
+import { fromCurves } from '../path/cubic2d.mjs';
+import { t as toCurves } from '../shared/curvy.DN9ptodP.mjs';
+import '../shared/curvy.BrrC9QVB.mjs';
+import '../shared/curvy.BPOevbwG.mjs';
+import '../shared/curvy.B1zfBfvf.mjs';
+import '../shared/curvy.DTco5vku.mjs';
+import '../shared/curvy.DV4S13Cq.mjs';
+import '../curve/cubic2d.mjs';
+import '../interval.mjs';
+import '../shared/curvy.DmVFTi0N.mjs';
+import '../polynomial/cubic.mjs';
+import '../shared/curvy.ZjG-q57I.mjs';
+import '../shared/curvy.O57gIOmy.mjs';
+import '../polynomial/quadratic.mjs';
+import '../vector/vector2.mjs';
+import '../curve/linear2d.mjs';
+import '../polynomial/linear.mjs';
+import '../curve/quadratic2d.mjs';
+import '../vector/vector4.mjs';
+
+const characteristic$1 = make$2(
+  1 / 6,
+  4 / 6,
+  roundDown(1 / 6),
+  0,
+  -0.5,
+  0,
+  0.5,
+  0,
+  0.5,
+  -1,
+  0.5,
+  0,
+  -1 / 6,
+  0.5,
+  -0.5,
+  1 / 6
+);
+const Basis2dTypeId = Symbol("curvy/splines/basis2d");
+class Basis2dImpl 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$1 = (p0, p1, p2, p3) => new Basis2dImpl([p0, p1, p2, p3]);
+const fromArray$1 = (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$1 = (p) => fromCurves(...toCurves(p, characteristic$1, 1));
+
+const characteristic = characteristic$1;
+const isBasis2d = isBasis2d$1;
+const make = make$1;
+const fromArray = fromArray$1;
+const append = append$1;
+const prepend = prepend$1;
+const withTriplicatedEndpoints = withTriplicatedEndpoints$1;
+const toPath = toPath$1;
+
+export { append, characteristic, fromArray, isBasis2d, make, prepend, toPath, withTriplicatedEndpoints };