curvy 0.3.3 → 1.0.1

package/dist/splines/bezier2d.mjs

@@ -0,0 +1,148 @@
+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';
+import '../interval.mjs';
+import '../shared/curvy.DmVFTi0N.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';
+
+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 };

package/dist/vector/vector2.d.mts

@@ -0,0 +1,41 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+
+declare const Vector2TypeId: unique symbol;
+type Vector2TypeId = typeof Vector2TypeId;
+
+interface Vector2 extends Pipeable, TwoDimensional<number> {
+    readonly [Vector2TypeId]: Vector2TypeId;
+}
+declare const isVector2: (v: unknown) => v is Vector2;
+declare const make: {
+    (xy: number): Vector2;
+    (x: number, y: number): Vector2;
+};
+declare const magnitude: (vector: Vector2) => number;
+declare const normalize: (vector: Vector2) => Vector2;
+declare const dot: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const cross: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const components: (v: Vector2) => [number, number];
+declare const softmax: (v: Vector2) => Vector2;
+declare const zero: Vector2;
+declare const add: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const subtract: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const hadamard: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+
+export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector2.d.ts

@@ -0,0 +1,41 @@
+import { e as TwoDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+
+declare const Vector2TypeId: unique symbol;
+type Vector2TypeId = typeof Vector2TypeId;
+
+interface Vector2 extends Pipeable, TwoDimensional<number> {
+    readonly [Vector2TypeId]: Vector2TypeId;
+}
+declare const isVector2: (v: unknown) => v is Vector2;
+declare const make: {
+    (xy: number): Vector2;
+    (x: number, y: number): Vector2;
+};
+declare const magnitude: (vector: Vector2) => number;
+declare const normalize: (vector: Vector2) => Vector2;
+declare const dot: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const cross: {
+    (a: Vector2, b: Vector2): number;
+    (b: Vector2): (a: Vector2) => number;
+};
+declare const components: (v: Vector2) => [number, number];
+declare const softmax: (v: Vector2) => Vector2;
+declare const zero: Vector2;
+declare const add: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const subtract: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+declare const hadamard: {
+    (a: Vector2, b: Vector2): Vector2;
+    (b: Vector2): (a: Vector2) => Vector2;
+};
+
+export { type Vector2, add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector2.mjs

@@ -0,0 +1,17 @@
+import { i as isVector2$1, m as make$1, a as magnitude$1, n as normalize$1, d as dot$1, c as cross$1, b as components$1, s as softmax$1, e as add$1, f as subtract$1, h as hadamard$1 } from '../shared/curvy.DOSsf40r.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+
+const isVector2 = isVector2$1;
+const make = make$1;
+const magnitude = magnitude$1;
+const normalize = normalize$1;
+const dot = dot$1;
+const cross = cross$1;
+const components = components$1;
+const softmax = softmax$1;
+const zero = make(0);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+
+export { add, components, cross, dot, hadamard, isVector2, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector3.d.mts

@@ -0,0 +1,38 @@
+import { g as ThreeDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+
+declare const Vector3TypeId: unique symbol;
+type Vector3TypeId = typeof Vector3TypeId;
+
+interface Vector3 extends Pipeable, ThreeDimensional<number> {
+    readonly [Vector3TypeId]: Vector3TypeId;
+}
+declare const isVector3: (v: unknown) => v is Vector3;
+declare const make: {
+    (xyz: number): Vector3;
+    (x: number, yz: number): Vector3;
+    (x: number, y: number, z: number): Vector3;
+};
+declare const magnitude: (vector: Vector3) => number;
+declare const normalize: (vector: Vector3) => Vector3;
+declare const dot: {
+    (a: Vector3, b: Vector3): number;
+    (b: Vector3): (a: Vector3) => number;
+};
+declare const components: (v: Vector3) => [number, number, number];
+declare const softmax: (v: Vector3) => Vector3;
+declare const zero: Vector3;
+declare const add: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+declare const subtract: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+declare const hadamard: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+
+export { type Vector3, add, components, dot, hadamard, isVector3, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector3.d.ts

@@ -0,0 +1,38 @@
+import { g as ThreeDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+
+declare const Vector3TypeId: unique symbol;
+type Vector3TypeId = typeof Vector3TypeId;
+
+interface Vector3 extends Pipeable, ThreeDimensional<number> {
+    readonly [Vector3TypeId]: Vector3TypeId;
+}
+declare const isVector3: (v: unknown) => v is Vector3;
+declare const make: {
+    (xyz: number): Vector3;
+    (x: number, yz: number): Vector3;
+    (x: number, y: number, z: number): Vector3;
+};
+declare const magnitude: (vector: Vector3) => number;
+declare const normalize: (vector: Vector3) => Vector3;
+declare const dot: {
+    (a: Vector3, b: Vector3): number;
+    (b: Vector3): (a: Vector3) => number;
+};
+declare const components: (v: Vector3) => [number, number, number];
+declare const softmax: (v: Vector3) => Vector3;
+declare const zero: Vector3;
+declare const add: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+declare const subtract: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+declare const hadamard: {
+    (a: Vector3, b: Vector3): Vector3;
+    (b: Vector3): (a: Vector3) => Vector3;
+};
+
+export { type Vector3, add, components, dot, hadamard, isVector3, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector3.mjs

@@ -0,0 +1,16 @@
+import { i as isVector3$1, m as make$1, a as magnitude$1, n as normalize$1, d as dot$1, c as components$1, s as softmax$1, b as add$1, e as subtract$1, h as hadamard$1 } from '../shared/curvy.D7bhnwZy.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+
+const isVector3 = isVector3$1;
+const make = make$1;
+const magnitude = magnitude$1;
+const normalize = normalize$1;
+const dot = dot$1;
+const components = components$1;
+const softmax = softmax$1;
+const zero = make(0);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+
+export { add, components, dot, hadamard, isVector3, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector4.d.mts

@@ -0,0 +1,39 @@
+import { f as FourDimensional } from '../shared/curvy.CT38g_II.mjs';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.mjs';
+
+declare const Vector4TypeId: unique symbol;
+type Vector4TypeId = typeof Vector4TypeId;
+
+interface Vector4 extends Pipeable, FourDimensional<number> {
+    readonly [Vector4TypeId]: Vector4TypeId;
+}
+declare const isVector4: (v: unknown) => v is Vector4;
+declare const make: {
+    (xyzw: number): Vector4;
+    (x: number, yzw: number): Vector4;
+    (x: number, y: number, zw: number): Vector4;
+    (x: number, y: number, z: number, w: number): Vector4;
+};
+declare const magnitude: (vector: Vector4) => number;
+declare const normalize: (vector: Vector4) => Vector4;
+declare const dot: {
+    (a: Vector4, b: Vector4): number;
+    (b: Vector4): (a: Vector4) => number;
+};
+declare const components: (v: Vector4) => [number, number, number, number];
+declare const softmax: (v: Vector4) => Vector4;
+declare const zero: Vector4;
+declare const add: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+declare const subtract: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+declare const hadamard: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+
+export { type Vector4, add, components, dot, hadamard, isVector4, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector4.d.ts

@@ -0,0 +1,39 @@
+import { f as FourDimensional } from '../shared/curvy.CT38g_II.js';
+import { P as Pipeable } from '../shared/curvy.BN-oFBsc.js';
+
+declare const Vector4TypeId: unique symbol;
+type Vector4TypeId = typeof Vector4TypeId;
+
+interface Vector4 extends Pipeable, FourDimensional<number> {
+    readonly [Vector4TypeId]: Vector4TypeId;
+}
+declare const isVector4: (v: unknown) => v is Vector4;
+declare const make: {
+    (xyzw: number): Vector4;
+    (x: number, yzw: number): Vector4;
+    (x: number, y: number, zw: number): Vector4;
+    (x: number, y: number, z: number, w: number): Vector4;
+};
+declare const magnitude: (vector: Vector4) => number;
+declare const normalize: (vector: Vector4) => Vector4;
+declare const dot: {
+    (a: Vector4, b: Vector4): number;
+    (b: Vector4): (a: Vector4) => number;
+};
+declare const components: (v: Vector4) => [number, number, number, number];
+declare const softmax: (v: Vector4) => Vector4;
+declare const zero: Vector4;
+declare const add: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+declare const subtract: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+declare const hadamard: {
+    (a: Vector4, b: Vector4): Vector4;
+    (b: Vector4): (a: Vector4) => Vector4;
+};
+
+export { type Vector4, add, components, dot, hadamard, isVector4, magnitude, make, normalize, softmax, subtract, zero };

package/dist/vector/vector4.mjs

@@ -0,0 +1,16 @@
+import { i as isVector4$1, m as make$1, a as magnitude$1, n as normalize$1, d as dot$1, c as components$1, s as softmax$1, b as add$1, e as subtract$1, h as hadamard$1 } from '../shared/curvy.Cty3LrOR.mjs';
+import '../shared/curvy.ChkqgKuv.mjs';
+
+const isVector4 = isVector4$1;
+const make = make$1;
+const magnitude = magnitude$1;
+const normalize = normalize$1;
+const dot = dot$1;
+const components = components$1;
+const softmax = softmax$1;
+const zero = make(0);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+
+export { add, components, dot, hadamard, isVector4, magnitude, make, normalize, softmax, subtract, zero };

package/package.json

@@ -1,35 +1,80 @@
 {
   "name": "curvy",
-  "version": "0.3.3",
+  "version": "1.0.1",
   "description": "Spline and Curve utilities",
   "author": "Tim Morris <timthewebguy@gmail.com>",
   "homepage": "https://github.com/tkofh/curvy#readme",
   "license": "MIT",
   "sideEffects": false,
   "type": "module",
-  "main": "./dist/curve.cjs",
-  "module": "./dist/curve.mjs",
-  "types": "./dist/curve.d.ts",
   "exports": {
-    ".": {
-      "require": "./dist/curve.cjs",
-      "import": "./dist/curve.mjs",
-      "types": "./dist/curve.d.ts"
-    },
-    "./axis": {
-      "require": "./dist/axis.cjs",
-      "import": "./dist/axis.mjs",
-      "types": "./dist/axis.d.ts"
-    },
-    "./convert": {
-      "require": "./dist/convert.cjs",
-      "import": "./dist/convert.mjs",
-      "types": "./dist/convert.d.ts"
-    },
-    "./splines": {
-      "require": "./dist/splines.cjs",
-      "import": "./dist/splines.mjs",
-      "types": "./dist/splines.d.ts"
+    "./vector2": {
+      "types": "./dist/vector/vector2.d.ts",
+      "import": "./dist/vector/vector2.mjs"
+    },
+    "./vector3": {
+      "types": "./dist/vector/vector3.d.ts",
+      "import": "./dist/vector/vector3.mjs"
+    },
+    "./vector4": {
+      "types": "./dist/vector/vector4.d.ts",
+      "import": "./dist/vector/vector4.mjs"
+    },
+    "./matrix2x2": {
+      "types": "./dist/matrix/matrix2x2.d.ts",
+      "import": "./dist/matrix/matrix2x2.mjs"
+    },
+    "./matrix3x3": {
+      "types": "./dist/matrix/matrix3x3.d.ts",
+      "import": "./dist/matrix/matrix3x3.mjs"
+    },
+    "./matrix4x4": {
+      "types": "./dist/matrix/matrix4x4.d.ts",
+      "import": "./dist/matrix/matrix4x4.mjs"
+    },
+    "./curve/linear2d": {
+      "types": "./dist/curve/linear2d.d.ts",
+      "import": "./dist/curve/linear2d.mjs"
+    },
+    "./curve/quadratic2d": {
+      "types": "./dist/curve/quadratic2d.d.ts",
+      "import": "./dist/curve/quadratic2d.mjs"
+    },
+    "./curve/cubic2d": {
+      "types": "./dist/curve/cubic2d.d.ts",
+      "import": "./dist/curve/cubic2d.mjs"
+    },
+    "./polynomial/linear": {
+      "types": "./dist/polynomial/linear.d.ts",
+      "import": "./dist/polynomial/linear.mjs"
+    },
+    "./polynomial/quadratic": {
+      "types": "./dist/polynomial/quadratic.d.ts",
+      "import": "./dist/polynomial/quadratic.mjs"
+    },
+    "./polynomial/cubic": {
+      "types": "./dist/polynomial/cubic.d.ts",
+      "import": "./dist/polynomial/cubic.mjs"
+    },
+    "./interval": {
+      "types": "./dist/interval.d.ts",
+      "import": "./dist/interval.mjs"
+    },
+    "./path/linear2d": {
+      "types": "./dist/path/linear2d.d.ts",
+      "import": "./dist/path/linear2d.mjs"
+    },
+    "./path/quadratic2d": {
+      "types": "./dist/path/quadratic2d.d.ts",
+      "import": "./dist/path/quadratic2d.mjs"
+    },
+    "./path/cubic2d": {
+      "types": "./dist/path/cubic2d.d.ts",
+      "import": "./dist/path/cubic2d.mjs"
+    },
+    "./splines/bezier2d": {
+      "types": "./dist/splines/bezier2d.d.ts",
+      "import": "./dist/splines/bezier2d.mjs"
     }
   },
   "files": [
@@ -42,23 +87,19 @@
     "type": "git",
     "url": "git+https://github.com/tkofh/curvy.git"
   },
-  "scripts": {
-    "build": "unbuild",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "test:ui": "vitest --ui --coverage",
-    "prepublish": "pnpm test:run && pnpm build"
-  },
   "bugs": {
     "url": "https://github.com/tkofh/curvy/issues"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^1.3.1",
-    "@vitest/ui": "^1.3.1",
-    "unbuild": "^2.0.0",
-    "vitest": "^1.3.1"
+    "typescript": "^5.7.2",
+    "unbuild": "3.0.0-rc.8",
+    "vitest": "^2.1.6",
+    "@repo/tsconfig": "1.0.0"
   },
-  "dependencies": {
-    "tiny-invariant": "^1.3.3"
+  "scripts": {
+    "build": "unbuild",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/axis.cjs

@@ -1,14 +0,0 @@
-'use strict';
-
-require('tiny-invariant');
-const axis = require('./shared/curvy.db103082.cjs');
-require('./splines.cjs');
-
-
-
-exports.createBasisAxis = axis.createBasisAxis;
-exports.createBezierAxis = axis.createBezierAxis;
-exports.createCardinalAxis = axis.createCardinalAxis;
-exports.createCatmullRomAxis = axis.createCatmullRomAxis;
-exports.createCurveAxis = axis.createCurveAxis;
-exports.createHermiteAxis = axis.createHermiteAxis;

package/dist/axis.d.cts

@@ -1,20 +0,0 @@
-import { I as Interval, M as Monotonicity, C as CubicPolynomial, a as CubicCoefficients } from './shared/curvy.df73166c.cjs';
-
-type CurveAxis = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly extrema: ReadonlyArray<number>;
-    readonly segments: ReadonlyArray<CubicPolynomial>;
-    readonly solvePosition: (t: number) => number;
-    readonly solveVelocity: (t: number) => number;
-    readonly solveT: (position: number, domain: Interval) => ReadonlyArray<number>;
-};
-declare function createCurveAxis(coefficients: ReadonlyArray<CubicCoefficients>): CurveAxis;
-declare function createBasisAxis(parameters: ReadonlyArray<number>, triplicateEndpoints?: boolean): CurveAxis;
-declare function createBezierAxis(parameters: ReadonlyArray<number>): CurveAxis;
-declare function createCardinalAxis(parameters: ReadonlyArray<number>, a?: number, duplicateEndpoints?: boolean): CurveAxis;
-declare function createCatmullRomAxis(parameters: ReadonlyArray<number>, duplicateEndpoints?: boolean): CurveAxis;
-declare function createHermiteAxis(parameters: ReadonlyArray<number>): CurveAxis;
-
-export { type CurveAxis, createBasisAxis, createBezierAxis, createCardinalAxis, createCatmullRomAxis, createCurveAxis, createHermiteAxis };

package/dist/axis.d.mts

@@ -1,20 +0,0 @@
-import { I as Interval, M as Monotonicity, C as CubicPolynomial, a as CubicCoefficients } from './shared/curvy.df73166c.mjs';
-
-type CurveAxis = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly extrema: ReadonlyArray<number>;
-    readonly segments: ReadonlyArray<CubicPolynomial>;
-    readonly solvePosition: (t: number) => number;
-    readonly solveVelocity: (t: number) => number;
-    readonly solveT: (position: number, domain: Interval) => ReadonlyArray<number>;
-};
-declare function createCurveAxis(coefficients: ReadonlyArray<CubicCoefficients>): CurveAxis;
-declare function createBasisAxis(parameters: ReadonlyArray<number>, triplicateEndpoints?: boolean): CurveAxis;
-declare function createBezierAxis(parameters: ReadonlyArray<number>): CurveAxis;
-declare function createCardinalAxis(parameters: ReadonlyArray<number>, a?: number, duplicateEndpoints?: boolean): CurveAxis;
-declare function createCatmullRomAxis(parameters: ReadonlyArray<number>, duplicateEndpoints?: boolean): CurveAxis;
-declare function createHermiteAxis(parameters: ReadonlyArray<number>): CurveAxis;
-
-export { type CurveAxis, createBasisAxis, createBezierAxis, createCardinalAxis, createCatmullRomAxis, createCurveAxis, createHermiteAxis };

package/dist/axis.d.ts

@@ -1,20 +0,0 @@
-import { I as Interval, M as Monotonicity, C as CubicPolynomial, a as CubicCoefficients } from './shared/curvy.df73166c.js';
-
-type CurveAxis = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly extrema: ReadonlyArray<number>;
-    readonly segments: ReadonlyArray<CubicPolynomial>;
-    readonly solvePosition: (t: number) => number;
-    readonly solveVelocity: (t: number) => number;
-    readonly solveT: (position: number, domain: Interval) => ReadonlyArray<number>;
-};
-declare function createCurveAxis(coefficients: ReadonlyArray<CubicCoefficients>): CurveAxis;
-declare function createBasisAxis(parameters: ReadonlyArray<number>, triplicateEndpoints?: boolean): CurveAxis;
-declare function createBezierAxis(parameters: ReadonlyArray<number>): CurveAxis;
-declare function createCardinalAxis(parameters: ReadonlyArray<number>, a?: number, duplicateEndpoints?: boolean): CurveAxis;
-declare function createCatmullRomAxis(parameters: ReadonlyArray<number>, duplicateEndpoints?: boolean): CurveAxis;
-declare function createHermiteAxis(parameters: ReadonlyArray<number>): CurveAxis;
-
-export { type CurveAxis, createBasisAxis, createBezierAxis, createCardinalAxis, createCatmullRomAxis, createCurveAxis, createHermiteAxis };

package/dist/axis.mjs

@@ -1,3 +0,0 @@
-import 'tiny-invariant';
-export { b as createBasisAxis, d as createBezierAxis, e as createCardinalAxis, f as createCatmullRomAxis, a as createCurveAxis, g as createHermiteAxis } from './shared/curvy.7876e09e.mjs';
-import './splines.mjs';