curvy 1.0.1 → 1.0.3

package/dist/shared/curvy.BZXFCKQe.mjs

@@ -0,0 +1,180 @@
+import { d as dual, P as Pipeable, i as invariant } from './curvy.DLOeble8.mjs';
+import { vectorProductLeft, make as make$3, solveSystem } from '../matrix/matrix4x4.mjs';
+import { fromCurves } from '../path/cubic2d.mjs';
+import { make as make$4 } from '../vector/vector2.mjs';
+import { make as make$2 } from '../vector/vector4.mjs';
+import { fromPolynomials } from '../curve/cubic2d.mjs';
+import { fromVector } from '../polynomial/cubic.mjs';
+
+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 [p0, p1, p2, p3] of toPointQuads(points, stride)) {
+    yield fromPolynomials(
+      fromVector(
+        vectorProductLeft(
+          matrix,
+          make$2(p0.x, p1.x, p2.x, p3.x)
+        )
+      ),
+      fromVector(
+        vectorProductLeft(
+          matrix,
+          make$2(p0.y, p1.y, p2.y, p3.y)
+        )
+      )
+    );
+  }
+}
+
+const characteristic$1 = make$3(
+  1,
+  0,
+  0,
+  0,
+  -3,
+  3,
+  0,
+  0,
+  3,
+  -6,
+  3,
+  0,
+  -1,
+  3,
+  -3,
+  1
+);
+const Bezier2dTypeId = Symbol("curvy/splines/bezier2d");
+class Bezier2dImpl 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$1 = (p0, p1, p2, p3) => new Bezier2dImpl([p0, p1, p2, p3]);
+const fromArray$1 = (points) => new Bezier2dImpl(points);
+const append$1 = dual(
+  4,
+  (p, p1, p2, p3) => new Bezier2dImpl(
+    (p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)
+  )
+);
+const fromSpline$1 = (p, matrix, stride) => {
+  const points = [];
+  let x;
+  let y;
+  for (const [p0, p1, p2, p3] of toPointQuads(p, stride)) {
+    x = solveSystem(
+      characteristic$1,
+      vectorProductLeft(matrix, make$2(p0.x, p1.x, p2.x, p3.x))
+    );
+    y = solveSystem(
+      characteristic$1,
+      vectorProductLeft(matrix, make$2(p0.y, p1.y, p2.y, p3.y))
+    );
+    points.push(
+      make$4(x.x, y.x),
+      make$4(x.y, y.y),
+      make$4(x.z, y.z)
+    );
+  }
+  if (x && y) {
+    points.push(make$4(x.w, y.w));
+  }
+  return fromArray$1(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];
+  const p4 = make$4(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
+  return append$1(p, p4, p5, p6);
+});
+const appendCurvatureAligned = 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];
+    const p4 = make$4(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
+    const p5 = make$4(
+      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
+    );
+    return append$1(p, p4, p5, 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];
+  const p4 = make$4(2 * p3.x - p2.x, 2 * p3.y - p2.y);
+  const p5 = make$4(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y));
+  return append$1(p, p4, p5, p6);
+});
+const toPath$1 = (p) => fromCurves(...toCurves(p, characteristic$1, 3));
+
+const characteristic = characteristic$1;
+const make = make$1;
+const fromArray = fromArray$1;
+const fromSpline = fromSpline$1;
+const isCubicBezier2d = isCubicBezier2d$1;
+const append = append$1;
+const appendTangentAligned = appendTangentAligned$1;
+const appendCurvatureMirrored = appendCurvatureAligned;
+const appendVelocityAligned = appendVelocityAligned$1;
+const appendAccelerationAligned = appendAccelerationAligned$1;
+const toPath = toPath$1;
+
+export { fromArray as a, append as b, characteristic as c, appendTangentAligned as d, appendCurvatureMirrored as e, fromSpline as f, appendVelocityAligned as g, appendAccelerationAligned as h, isCubicBezier2d as i, toPath as j, make as m, toCurves as t };

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.DM6AiKbn.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.DOSsf40r.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.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.bvP77ZZm.mjs → curvy.DTco5vku.mjs}

@@ -1,6 +1,6 @@
-import { o as toThreeDimensionalIndex, d as determinant$1, m as make$1 } from './curvy.DM6AiKbn.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.DB7nQmVs.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(

package/dist/shared/{curvy.D7MEXd5g.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, c as solveInverse$1, m as monotonicity$1, r as range$1, l as length$1, s as solve$1 } from './curvy.DB7nQmVs.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"

package/dist/splines/basis2d.d.mts

@@ -0,0 +1,38 @@
+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 { Bezier2d } from './bezier2d.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;
+declare const toBezier: (p: Basis2d) => Bezier2d;
+
+export { type Basis2d, append, characteristic, fromArray, isBasis2d, make, prepend, toBezier, toPath, withTriplicatedEndpoints };

package/dist/splines/basis2d.d.ts

@@ -0,0 +1,38 @@
+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 { Bezier2d } from './bezier2d.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;
+declare const toBezier: (p: Basis2d) => Bezier2d;
+
+export { type Basis2d, append, characteristic, fromArray, isBasis2d, make, prepend, toBezier, toPath, withTriplicatedEndpoints };

package/dist/splines/basis2d.mjs

@@ -0,0 +1,88 @@
+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, f as fromSpline } from '../shared/curvy.BZXFCKQe.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 toBezier$1 = (p) => fromSpline(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;
+const toBezier = toBezier$1;
+
+export { append, characteristic, fromArray, isBasis2d, make, prepend, toBezier, toPath, withTriplicatedEndpoints };

package/dist/splines/bezier2d.d.mts

@@ -1,12 +1,15 @@
 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 '../shared/curvy.CT38g_II.mjs';
 import '../interval.mjs';
 import '../shared/curvy.DwHW5Fqt.mjs';
-import '../vector/vector3.mjs';
-import '../vector/vector4.mjs';
 
 declare const Bezier2dTypeId: unique symbol;
 type Bezier2dTypeId = typeof Bezier2dTypeId;
@@ -15,8 +18,10 @@ interface Bezier2d extends Pipeable {
     readonly [Bezier2dTypeId]: Bezier2dTypeId;
     [Symbol.iterator](): IterableIterator<Vector2>;
 }
+declare const characteristic: Matrix4x4;
 declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Bezier2d;
 declare const fromArray: (points: ReadonlyArray<Vector2>) => Bezier2d;
+declare const fromSpline: (points: Iterable<Vector2>, matrix: Matrix4x4, stride: 1 | 2 | 3) => Bezier2d;
 declare const isCubicBezier2d: (p: unknown) => p is Bezier2d;
 declare const append: {
     (p1: Vector2, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
@@ -40,4 +45,4 @@ declare const appendAccelerationAligned: {
 };
 declare const toPath: (p: Bezier2d) => CubicPath2d;
 
-export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, fromArray, isCubicBezier2d, make, toPath };
+export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, characteristic, fromArray, fromSpline, isCubicBezier2d, make, toPath };

package/dist/splines/bezier2d.d.ts

@@ -1,12 +1,15 @@
 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 '../shared/curvy.CT38g_II.js';
 import '../interval.js';
 import '../shared/curvy.CkJRVnqj.js';
-import '../vector/vector3.js';
-import '../vector/vector4.js';
 
 declare const Bezier2dTypeId: unique symbol;
 type Bezier2dTypeId = typeof Bezier2dTypeId;
@@ -15,8 +18,10 @@ interface Bezier2d extends Pipeable {
     readonly [Bezier2dTypeId]: Bezier2dTypeId;
     [Symbol.iterator](): IterableIterator<Vector2>;
 }
+declare const characteristic: Matrix4x4;
 declare const make: (p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2) => Bezier2d;
 declare const fromArray: (points: ReadonlyArray<Vector2>) => Bezier2d;
+declare const fromSpline: (points: Iterable<Vector2>, matrix: Matrix4x4, stride: 1 | 2 | 3) => Bezier2d;
 declare const isCubicBezier2d: (p: unknown) => p is Bezier2d;
 declare const append: {
     (p1: Vector2, p2: Vector2, p3: Vector2): (p: Bezier2d) => Bezier2d;
@@ -40,4 +45,4 @@ declare const appendAccelerationAligned: {
 };
 declare const toPath: (p: Bezier2d) => CubicPath2d;
 
-export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, fromArray, isCubicBezier2d, make, toPath };
+export { type Bezier2d, append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, characteristic, fromArray, fromSpline, isCubicBezier2d, make, toPath };

package/dist/splines/bezier2d.mjs

@@ -1,148 +1,21 @@
-import { fromPolynomials } from '../curve/cubic2d.mjs';
-import { d as dual, P as Pipeable, i as invariant } from '../shared/curvy.ChkqgKuv.mjs';
-import { make as make$2, vectorProductLeft } from '../matrix/matrix4x4.mjs';
-import { fromCurves } from '../path/cubic2d.mjs';
-import { fromVector } from '../polynomial/cubic.mjs';
-import { make as make$3 } from '../vector/vector2.mjs';
-import { make as make$4 } from '../vector/vector4.mjs';
+export { b as append, h as appendAccelerationAligned, e as appendCurvatureMirrored, d as appendTangentAligned, g as appendVelocityAligned, c as characteristic, a as fromArray, f as fromSpline, i as isCubicBezier2d, m as make, j as toPath } from '../shared/curvy.BZXFCKQe.mjs';
+import '../shared/curvy.DLOeble8.mjs';
+import '../matrix/matrix4x4.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 '../path/cubic2d.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 '../shared/curvy.D7MEXd5g.mjs';
-import '../shared/curvy.DB7nQmVs.mjs';
+import '../vector/vector2.mjs';
 import '../curve/linear2d.mjs';
 import '../polynomial/linear.mjs';
 import '../curve/quadratic2d.mjs';
-import '../shared/curvy.DM6AiKbn.mjs';
-import '../shared/curvy.DOSsf40r.mjs';
-import '../shared/curvy.Cty3LrOR.mjs';
-import '../shared/curvy.bvP77ZZm.mjs';
-import '../shared/curvy.D7bhnwZy.mjs';
-
-const characteristic = make$2(
-  1,
-  0,
-  0,
-  0,
-  -3,
-  3,
-  0,
-  0,
-  3,
-  -6,
-  3,
-  0,
-  -1,
-  3,
-  -3,
-  1
-);
-const Bezier2dTypeId = Symbol("curvy/splines/points");
-class Bezier2dImpl 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$1 = (p0, p1, p2, p3) => new Bezier2dImpl([p0, p1, p2, p3]);
-const fromArray$1 = (points) => new Bezier2dImpl(points);
-const append$1 = dual(
-  4,
-  (p, p1, p2, p3) => new Bezier2dImpl(
-    (p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)
-  )
-);
-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];
-  const p4 = make$3(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
-  return append$1(p, p4, p5, p6);
-});
-const appendCurvatureAligned = 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];
-    const p4 = make$3(p3.x + (p3.x - p2.x) * a, p3.y + (p3.y - p2.y) * a);
-    const p5 = make$3(
-      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
-    );
-    return append$1(p, p4, p5, 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];
-  const p4 = make$3(2 * p3.x - p2.x, 2 * p3.y - p2.y);
-  const p5 = make$3(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y));
-  return append$1(p, p4, p5, p6);
-});
-function* toCurves(points) {
-  let p0;
-  let p1;
-  let p2;
-  let p3;
-  for (const point of points) {
-    if (p0 === void 0) {
-      p0 = point;
-    } else if (p1 === void 0) {
-      p1 = point;
-    } else if (p2 === void 0) {
-      p2 = point;
-    } else if (p3 === void 0) {
-      p3 = point;
-      yield fromPolynomials(
-        fromVector(
-          vectorProductLeft(
-            characteristic,
-            make$4(p0.x, p1.x, p2.x, p3.x)
-          )
-        ),
-        fromVector(
-          vectorProductLeft(
-            characteristic,
-            make$4(p0.y, p1.y, p2.y, p3.y)
-          )
-        )
-      );
-      p0 = p3;
-      p1 = void 0;
-      p2 = void 0;
-      p3 = void 0;
-    }
-  }
-}
-const toPath$1 = (p) => fromCurves(...toCurves(p));
-
-const make = make$1;
-const fromArray = fromArray$1;
-const isCubicBezier2d = isCubicBezier2d$1;
-const append = append$1;
-const appendTangentAligned = appendTangentAligned$1;
-const appendCurvatureMirrored = appendCurvatureAligned;
-const appendVelocityAligned = appendVelocityAligned$1;
-const appendAccelerationAligned = appendAccelerationAligned$1;
-const toPath = toPath$1;
-
-export { append, appendAccelerationAligned, appendCurvatureMirrored, appendTangentAligned, appendVelocityAligned, fromArray, isCubicBezier2d, make, toPath };
+import '../vector/vector4.mjs';