curvy 1.0.1 → 1.0.2

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,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 };

package/dist/splines/bezier2d.d.mts

@@ -2,7 +2,7 @@ import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
 import { CubicPath2d } from '../path/cubic2d.mjs';
 import { Vector2 } from '../vector/vector2.mjs';
 import '../curve/cubic2d.mjs';
-import '../shared/curvy.CT38g_II.mjs';
+import '../shared/curvy.Bf5TIk31.mjs';
 import '../interval.mjs';
 import '../shared/curvy.DwHW5Fqt.mjs';
 import '../vector/vector3.mjs';

package/dist/splines/bezier2d.d.ts

@@ -2,7 +2,7 @@ import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
 import { CubicPath2d } from '../path/cubic2d.js';
 import { Vector2 } from '../vector/vector2.js';
 import '../curve/cubic2d.js';
-import '../shared/curvy.CT38g_II.js';
+import '../shared/curvy.Bf5TIk31.js';
 import '../interval.js';
 import '../shared/curvy.CkJRVnqj.js';
 import '../vector/vector3.js';

package/dist/splines/bezier2d.mjs

@@ -1,23 +1,24 @@
-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 { 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 { fromVector } from '../polynomial/cubic.mjs';
 import { make as make$3 } from '../vector/vector2.mjs';
-import { make as make$4 } from '../vector/vector4.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 '../shared/curvy.D7MEXd5g.mjs';
-import '../shared/curvy.DB7nQmVs.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';
+import '../vector/vector4.mjs';
 
 const characteristic = make$2(
   1,
@@ -37,7 +38,7 @@ const characteristic = make$2(
   -3,
   1
 );
-const Bezier2dTypeId = Symbol("curvy/splines/points");
+const Bezier2dTypeId = Symbol("curvy/splines/bezier2d");
 class Bezier2dImpl extends Pipeable {
   [Bezier2dTypeId] = Bezier2dTypeId;
   points;
@@ -98,42 +99,7 @@ const appendAccelerationAligned$1 = dual(2, (p, p6) => {
   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 toPath$1 = (p) => fromCurves(...toCurves(p, characteristic, 3));
 
 const make = make$1;
 const fromArray = fromArray$1;

package/dist/splines/cardinal2d.d.mts

@@ -0,0 +1,44 @@
+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 Cardinal2dTypeId: unique symbol;
+type Cardinal2dTypeId = typeof Cardinal2dTypeId;
+
+interface Cardinal2d extends Pipeable {
+    readonly [Cardinal2dTypeId]: Cardinal2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const characteristic: (scale: number) => Matrix4x4;
+declare const catRomCharacteristic: Matrix4x4;
+declare const isCardinal2d: (p: unknown) => p is Cardinal2d;
+declare const make: (p0: Vector2, p1: Vector2, ...points: ReadonlyArray<Vector2>) => Cardinal2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Cardinal2d;
+declare const append: {
+    (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+declare const prepend: {
+    (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+declare const withDuplicatedEndpoints: (c: Cardinal2d) => Cardinal2d;
+declare const withReflectedEndpoints: {
+    (scale: number): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, scale?: number): Cardinal2d;
+};
+declare const toPath: {
+    (scale: number): (c: Cardinal2d) => CubicPath2d;
+    (c: Cardinal2d, scale?: number): CubicPath2d;
+};
+
+export { type Cardinal2d, append, catRomCharacteristic, characteristic, fromArray, isCardinal2d, make, prepend, toPath, withDuplicatedEndpoints, withReflectedEndpoints };

package/dist/splines/cardinal2d.d.ts

@@ -0,0 +1,44 @@
+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 Cardinal2dTypeId: unique symbol;
+type Cardinal2dTypeId = typeof Cardinal2dTypeId;
+
+interface Cardinal2d extends Pipeable {
+    readonly [Cardinal2dTypeId]: Cardinal2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const characteristic: (scale: number) => Matrix4x4;
+declare const catRomCharacteristic: Matrix4x4;
+declare const isCardinal2d: (p: unknown) => p is Cardinal2d;
+declare const make: (p0: Vector2, p1: Vector2, ...points: ReadonlyArray<Vector2>) => Cardinal2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Cardinal2d;
+declare const append: {
+    (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+declare const prepend: {
+    (...points: ReadonlyArray<Vector2>): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, ...points: ReadonlyArray<Vector2>): Cardinal2d;
+};
+declare const withDuplicatedEndpoints: (c: Cardinal2d) => Cardinal2d;
+declare const withReflectedEndpoints: {
+    (scale: number): (c: Cardinal2d) => Cardinal2d;
+    (c: Cardinal2d, scale?: number): Cardinal2d;
+};
+declare const toPath: {
+    (scale: number): (c: Cardinal2d) => CubicPath2d;
+    (c: Cardinal2d, scale?: number): CubicPath2d;
+};
+
+export { type Cardinal2d, append, catRomCharacteristic, characteristic, fromArray, isCardinal2d, make, prepend, toPath, withDuplicatedEndpoints, withReflectedEndpoints };

package/dist/splines/cardinal2d.mjs

@@ -0,0 +1,116 @@
+import { 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 { subtract, scale, add } from '../vector/vector2.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 '../curve/linear2d.mjs';
+import '../polynomial/linear.mjs';
+import '../curve/quadratic2d.mjs';
+import '../vector/vector4.mjs';
+
+const characteristic$1 = (scale) => make$2(
+  0,
+  1,
+  0,
+  0,
+  -scale,
+  0,
+  scale,
+  0,
+  2 * scale,
+  scale - 3,
+  3 - 2 * scale,
+  -scale,
+  -scale,
+  2 - scale,
+  scale - 2,
+  scale
+);
+const catRomCharacteristic$1 = characteristic$1(0.5);
+const Cardinal2dTypeId = Symbol.for(
+  "curvy/splines/cardinal2d"
+);
+class Cardinal2dImpl extends Pipeable {
+  [Cardinal2dTypeId] = Cardinal2dTypeId;
+  points;
+  constructor(points) {
+    invariant(points.length >= 2, "cardinal splines requires 2 or more points");
+    super();
+    this.points = points;
+  }
+  [Symbol.iterator]() {
+    return this.points[Symbol.iterator]();
+  }
+}
+const isCardinal2d$1 = (p) => typeof p === "object" && p !== null && Cardinal2dTypeId in p;
+const make$1 = (...points) => new Cardinal2dImpl(points);
+const fromArray$1 = (points) => new Cardinal2dImpl(points);
+const append$1 = dual(
+  (args) => isCardinal2d$1(args[0]),
+  (p, ...points) => new Cardinal2dImpl([...p, ...points])
+);
+const prepend$1 = dual(
+  (args) => isCardinal2d$1(args[0]),
+  (p, ...points) => new Cardinal2dImpl([...points, ...p])
+);
+const withDuplicatedEndpoints$1 = (p) => {
+  const points = p instanceof Cardinal2dImpl ? p.points : [...p];
+  return new Cardinal2dImpl([
+    points[0],
+    ...points,
+    points[points.length - 1]
+  ]);
+};
+const withReflectedEndpoints$1 = dual(
+  (args) => isCardinal2d$1(args[0]),
+  (p, scale$1 = 1) => {
+    if (scale$1 === 0) {
+      return withDuplicatedEndpoints$1(p);
+    }
+    const points = p instanceof Cardinal2dImpl ? p.points : [...p];
+    const p0 = points[0];
+    const p1 = points[1];
+    const p2 = points[points.length - 2];
+    const p3 = points[points.length - 1];
+    return new Cardinal2dImpl([
+      subtract(p1, p0).pipe(scale(scale$1), add(p0)),
+      ...points,
+      subtract(p2, p3).pipe(scale(scale$1), add(p3))
+    ]);
+  }
+);
+const toPath$1 = dual(
+  (args) => isCardinal2d$1(args[0]),
+  (p, scale = 0.5) => fromCurves(
+    ...toCurves(
+      p,
+      scale === 0.5 ? catRomCharacteristic$1 : characteristic$1(scale),
+      1
+    )
+  )
+);
+
+const characteristic = characteristic$1;
+const catRomCharacteristic = catRomCharacteristic$1;
+const isCardinal2d = isCardinal2d$1;
+const make = make$1;
+const fromArray = fromArray$1;
+const append = append$1;
+const prepend = prepend$1;
+const withDuplicatedEndpoints = withDuplicatedEndpoints$1;
+const withReflectedEndpoints = withReflectedEndpoints$1;
+const toPath = toPath$1;
+
+export { append, catRomCharacteristic, characteristic, fromArray, isCardinal2d, make, prepend, toPath, withDuplicatedEndpoints, withReflectedEndpoints };

package/dist/splines/hermite2d.d.mts

@@ -0,0 +1,31 @@
+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 Hermite2dTypeId: unique symbol;
+type Hermite2dTypeId = typeof Hermite2dTypeId;
+
+interface Hermite2d extends Pipeable {
+    readonly [Hermite2dTypeId]: Hermite2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const characteristic: Matrix4x4;
+declare const make: (p0: Vector2, v0: Vector2, p1: Vector2, v1: Vector2) => Hermite2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Hermite2d;
+declare const isHermite2d: (p: unknown) => p is Hermite2d;
+declare const append: {
+    (p1: Vector2, v1: Vector2): (p: Hermite2d) => Hermite2d;
+    (p: Hermite2d, p1: Vector2, v1: Vector2): Hermite2d;
+};
+declare const toPath: (p: Hermite2d) => CubicPath2d;
+
+export { type Hermite2d, append, characteristic, fromArray, isHermite2d, make, toPath };

package/dist/splines/hermite2d.d.ts

@@ -0,0 +1,31 @@
+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 Hermite2dTypeId: unique symbol;
+type Hermite2dTypeId = typeof Hermite2dTypeId;
+
+interface Hermite2d extends Pipeable {
+    readonly [Hermite2dTypeId]: Hermite2dTypeId;
+    [Symbol.iterator](): IterableIterator<Vector2>;
+}
+declare const characteristic: Matrix4x4;
+declare const make: (p0: Vector2, v0: Vector2, p1: Vector2, v1: Vector2) => Hermite2d;
+declare const fromArray: (points: ReadonlyArray<Vector2>) => Hermite2d;
+declare const isHermite2d: (p: unknown) => p is Hermite2d;
+declare const append: {
+    (p1: Vector2, v1: Vector2): (p: Hermite2d) => Hermite2d;
+    (p: Hermite2d, p1: Vector2, v1: Vector2): Hermite2d;
+};
+declare const toPath: (p: Hermite2d) => CubicPath2d;
+
+export { type Hermite2d, append, characteristic, fromArray, isHermite2d, make, toPath };

package/dist/splines/hermite2d.mjs

@@ -0,0 +1,74 @@
+import { 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,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  -3,
+  -2,
+  3,
+  -1,
+  2,
+  1,
+  -2,
+  1
+);
+const Hermite2dTypeId = Symbol("curvy/splines/hermite2d");
+class Hermite2dImpl extends Pipeable {
+  [Hermite2dTypeId] = Hermite2dTypeId;
+  points;
+  constructor(points) {
+    invariant(points.length >= 4, "hermite splines requires 4 or more points");
+    invariant(
+      points.length % 2 === 0,
+      "hermite splines requires (n * 2) points"
+    );
+    super();
+    this.points = points;
+  }
+  [Symbol.iterator]() {
+    return this.points[Symbol.iterator]();
+  }
+}
+const isHermite2d$1 = (p) => typeof p === "object" && p !== null && Hermite2dTypeId in p;
+const make$1 = (p0, v0, p1, v1) => new Hermite2dImpl([p0, v0, p1, v1]);
+const fromArray$1 = (points) => new Hermite2dImpl(points);
+const append$1 = dual(3, (p, p1, v1) => {
+  const points = p instanceof Hermite2dImpl ? p.points : Array.from(p);
+  return new Hermite2dImpl(points.concat(p1, v1));
+});
+const toPath$1 = (p) => fromCurves(...toCurves(p, characteristic$1, 2));
+
+const characteristic = characteristic$1;
+const make = make$1;
+const fromArray = fromArray$1;
+const isHermite2d = isHermite2d$1;
+const append = append$1;
+const toPath = toPath$1;
+
+export { append, characteristic, fromArray, isHermite2d, make, toPath };

package/dist/vector/vector2.d.mts

@@ -1,4 +1,4 @@
-import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { T as TwoDimensional } from '../shared/curvy.Bf5TIk31.mjs';
 import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
 
 declare const Vector2TypeId: unique symbol;
@@ -37,5 +37,9 @@ declare const hadamard: {
     (a: Vector2, b: Vector2): Vector2;
     (b: Vector2): (a: Vector2) => Vector2;
 };
+declare const scale: {
+    (s: number): (v: Vector2) => Vector2;
+    (v: Vector2, s: number): Vector2;
+};
 
-export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };
+export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, scale, softmax, subtract, zero };

package/dist/vector/vector2.d.ts

@@ -1,4 +1,4 @@
-import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { T as TwoDimensional } from '../shared/curvy.Bf5TIk31.js';
 import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
 
 declare const Vector2TypeId: unique symbol;
@@ -37,5 +37,9 @@ declare const hadamard: {
     (a: Vector2, b: Vector2): Vector2;
     (b: Vector2): (a: Vector2) => Vector2;
 };
+declare const scale: {
+    (s: number): (v: Vector2) => Vector2;
+    (v: Vector2, s: number): Vector2;
+};
 
-export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };
+export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, scale, softmax, subtract, zero };