curvy 0.3.2 → 1.0.0

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,38 +1,85 @@
 {
   "name": "curvy",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "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": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -40,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,325 +0,0 @@
-'use strict';
-
-const invariant = require('tiny-invariant');
-const splines = require('./splines.cjs');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const invariant__default = /*#__PURE__*/_interopDefaultCompat(invariant);
-
-const UNIT_INTERVAL = [0, 1];
-function createLinearPolynomial(coefficients, domain = UNIT_INTERVAL) {
-  const [a, b] = coefficients;
-  invariant__default(domain[0] <= domain[1], "invalid domain");
-  let root = a === 0 ? null : b === 0 ? 0 : -b / a;
-  if (root !== null && (root < domain[0] || root > domain[1])) {
-    root = null;
-  }
-  const range = a >= 0 ? [a * domain[0] + b, a * domain[1] + b] : [a * domain[1] + b, a * domain[0] + b];
-  const solve = (x) => {
-    invariant__default(x >= domain[0] && x <= domain[1], "x out of domain");
-    return a * x + b;
-  };
-  const solveInverse = (y) => {
-    invariant__default(y >= range[0] && y <= range[1], "y out of range");
-    return a === 0 ? 0 : (y - b) / a;
-  };
-  return {
-    domain,
-    range,
-    monotonicity: a === 0 ? "constant" : a > 0 ? "increasing" : "decreasing",
-    coefficients,
-    root,
-    solve,
-    solveInverse
-  };
-}
-function createQuadraticRootSolver(coefficients, defaultDomain, range) {
-  const [a, b, c] = coefficients;
-  if (a !== 0) {
-    return function solveInverse(y, domain = defaultDomain) {
-      invariant__default(domain[0] <= domain[1], "invalid domain");
-      invariant__default(y >= range[0] && y <= range[1], "y out of range");
-      const discriminant = b ** 2 - 4 * a * (c - y);
-      if (discriminant < 0) {
-        return [];
-      }
-      if (discriminant === 0) {
-        const root = -b / (2 * a);
-        return root < domain[0] || root > domain[1] ? [] : [root];
-      }
-      const sqrtDiscriminant = Math.sqrt(discriminant);
-      const denominator = 2 * a;
-      const left = (-b - sqrtDiscriminant) / denominator;
-      const right = (-b + sqrtDiscriminant) / denominator;
-      const leftInDomain = left >= domain[0] && left <= domain[1];
-      const rightInDomain = right >= domain[0] && right <= domain[1];
-      if (leftInDomain && rightInDomain) {
-        return left < right ? [left, right] : [right, left];
-      }
-      if (leftInDomain) {
-        return [left];
-      }
-      if (rightInDomain) {
-        return [right];
-      }
-      return [];
-    };
-  }
-  if (b !== 0) {
-    return function solveInverse(y, domain = defaultDomain) {
-      invariant__default(domain[0] <= domain[1], "invalid domain");
-      invariant__default(y >= range[0] && y <= range[1], "y out of range");
-      const root = -(c - y) / b;
-      return root < domain[0] || root > domain[1] ? [] : [root];
-    };
-  }
-  return function solveInverse() {
-    return [];
-  };
-}
-function createQuadraticPolynomial(coefficients, domain = UNIT_INTERVAL) {
-  const [a, b, c] = coefficients;
-  invariant__default(domain[0] <= domain[1], "invalid domain");
-  const derivative = createLinearPolynomial([2 * a, b], domain);
-  const extreme = derivative.root;
-  const solve = (x) => {
-    invariant__default(x >= domain[0] && x <= domain[1], "x out of domain");
-    return a * x ** 2 + b * x + c;
-  };
-  const rangeCandidates = extreme === null ? [solve(domain[0]), solve(domain[1])] : [solve(domain[0]), solve(extreme), solve(domain[1])];
-  const range = [
-    Math.min(...rangeCandidates),
-    Math.max(...rangeCandidates)
-  ];
-  const solveInverse = createQuadraticRootSolver(coefficients, domain, range);
-  const roots = range[0] > 0 || range[1] < 0 ? [] : solveInverse(0);
-  return {
-    domain,
-    range,
-    coefficients,
-    monotonicity: a !== 0 ? "none" : b === 0 ? "constant" : b > 0 ? "increasing" : "decreasing",
-    extreme,
-    roots,
-    derivative,
-    solve,
-    solveInverse
-  };
-}
-const TWO_THIRDS_PI = 2 * Math.PI / 3;
-function createCubicRootSolver(coefficients, defaultDomain, range) {
-  if (coefficients[0] === 0) {
-    return createQuadraticRootSolver(
-      [coefficients[1], coefficients[2], coefficients[3]],
-      defaultDomain,
-      range
-    );
-  }
-  const oneOverA = 1 / coefficients[0];
-  const a0 = coefficients[1] * oneOverA;
-  const a1 = coefficients[2] * oneOverA;
-  const a2OverThree = a0 / 3;
-  const q = a1 / 3 - a0 ** 2 / 9;
-  const r0 = a1 * a0 / 6 - a0 ** 3 / 27;
-  return function solveInverse(y, domain = defaultDomain) {
-    invariant__default(domain[0] <= domain[1], "invalid domain");
-    invariant__default(y >= range[0] && y <= range[1], "y out of range");
-    const a02 = (coefficients[3] - y) * oneOverA;
-    const r = r0 - a02 * 0.5;
-    const discriminant = q ** 3 + r ** 2;
-    if (discriminant > 0) {
-      const a = Math.cbrt(Math.abs(r) + Math.sqrt(discriminant));
-      const root = (r < 0 ? q / a - a : a - q / a) - a2OverThree;
-      return root < domain[0] || root > domain[1] ? [] : [root];
-    }
-    const theta = Math.acos(r / Math.sqrt((-q) ** 3)) / 3;
-    const twoRootQ = 2 * Math.sqrt(-q);
-    const root1 = twoRootQ * Math.cos(theta - TWO_THIRDS_PI) - a2OverThree;
-    const root2 = twoRootQ * Math.cos(theta) - a2OverThree;
-    const root3 = twoRootQ * Math.cos(theta + TWO_THIRDS_PI) - a2OverThree;
-    const candidates = [root1, root2, root3];
-    const roots = [];
-    for (const candidate of candidates) {
-      if (candidate >= domain[0] && candidate <= domain[1] && !roots.includes(candidate)) {
-        roots.push(candidate);
-      }
-    }
-    roots.sort((a, b) => a - b);
-    return roots;
-  };
-}
-function getMonotonicity(extrema, derivative, domain) {
-  if (derivative.coefficients[0] === 0 && derivative.coefficients[1] === 0 && derivative.coefficients[2] === 0) {
-    return "constant";
-  }
-  let hasInnerExtrema = false;
-  for (const extreme of extrema) {
-    if (extreme > domain[0] && extreme > domain[1]) {
-      hasInnerExtrema = true;
-      break;
-    }
-  }
-  if (hasInnerExtrema) {
-    return "none";
-  }
-  let test = derivative.solve(domain[0]);
-  if (test === 0) {
-    test = derivative.solve((domain[0] + domain[1]) * 0.5);
-  }
-  return Math.sign(test) > 0 ? "increasing" : "decreasing";
-}
-function createCubicPolynomial(coefficients, domain = UNIT_INTERVAL) {
-  invariant__default(domain[0] <= domain[1], "invalid domain");
-  const [a, b, c, d] = coefficients;
-  const derivative = createQuadraticPolynomial([3 * a, 2 * b, c], domain);
-  const extrema = derivative.roots.length === 1 && derivative.coefficients[0] !== 0 ? [] : derivative.roots;
-  const solve = (x) => {
-    invariant__default(x >= domain[0] && x <= domain[1], "x out of domain");
-    return a * x ** 3 + b * x ** 2 + c * x + d;
-  };
-  const rangeCandidates = [
-    solve(domain[0]),
-    ...extrema.map((extreme) => solve(extreme)),
-    solve(domain[1])
-  ];
-  const range = [
-    Math.min(...rangeCandidates),
-    Math.max(...rangeCandidates)
-  ];
-  const solveInverse = createCubicRootSolver(coefficients, domain, range);
-  const roots = range[0] > 0 || range[1] < 0 ? [] : solveInverse(0, domain);
-  const monotonicity = getMonotonicity(extrema, derivative, domain);
-  return {
-    domain,
-    range,
-    monotonicity,
-    coefficients,
-    extrema,
-    roots,
-    derivative,
-    solve,
-    solveInverse
-  };
-}
-
-function getCurveExtrema(lookup) {
-  const extremaLookup = new Map(lookup);
-  const extremaCandidates = Array.from(extremaLookup.keys());
-  for (const [index, t] of extremaCandidates.entries()) {
-    if (index === 0 || index === extremaCandidates.length - 1) {
-      continue;
-    }
-    const previous = extremaLookup.get(extremaCandidates[index - 1]);
-    const current = extremaLookup.get(t);
-    const next = extremaLookup.get(extremaCandidates[index + 1]);
-    if (previous <= current && current < next || previous >= current && current > next) {
-      extremaLookup.delete(t);
-    }
-  }
-  const extrema = Array.from(extremaLookup.keys());
-  return extrema;
-}
-function createCurveAxis(coefficients) {
-  invariant__default(coefficients.length > 0, "Curve must have at least one segment");
-  const segments = [];
-  const extremaLookup = /* @__PURE__ */ new Map();
-  let monotonicity = "none";
-  const normalizedToCurve = coefficients.length;
-  const curveToNormalized = 1 / coefficients.length;
-  for (let i = 0; i < coefficients.length; i++) {
-    const segment = createCubicPolynomial(coefficients[i], UNIT_INTERVAL);
-    segments.push(segment);
-    extremaLookup.set(i * curveToNormalized, segment.solve(0));
-    for (const extreme of segment.extrema) {
-      extremaLookup.set(
-        (i + extreme) * curveToNormalized,
-        segment.solve(extreme)
-      );
-    }
-    if (i === 0) {
-      monotonicity = segment.monotonicity;
-    } else if (monotonicity !== segment.monotonicity) {
-      monotonicity = "none";
-    }
-  }
-  extremaLookup.set(1, segments[segments.length - 1].solve(1));
-  const extrema = getCurveExtrema(extremaLookup);
-  const range = [
-    Math.min(...extremaLookup.values()),
-    Math.max(...extremaLookup.values())
-  ];
-  const getSegmentAndInput = (t) => {
-    invariant__default(t >= 0 && t <= 1, "t out of range");
-    if (t === 1) {
-      return { segment: segments[segments.length - 1], input: 1 };
-    }
-    const curveT = t * normalizedToCurve;
-    const index = Math.floor(curveT);
-    const segment = segments[index];
-    const input = curveT - index;
-    return { segment, input };
-  };
-  const solvePosition = (t) => {
-    const { segment, input } = getSegmentAndInput(t);
-    return segment.solve(input);
-  };
-  const solveVelocity = (t) => {
-    const { segment, input } = getSegmentAndInput(t);
-    return segment.derivative.solve(input);
-  };
-  const solveT = (position, domain) => {
-    invariant__default(
-      position >= range[0] && position <= range[1],
-      "position out of range"
-    );
-    invariant__default(domain[0] <= domain[1], "invalid domain");
-    const result = [];
-    for (const [index, segment] of segments.entries()) {
-      if (position >= segment.range[0] && position <= segment.range[1]) {
-        const t = segment.solveInverse(position, domain);
-        for (const tValue of t) {
-          result.push((index + tValue) * curveToNormalized);
-        }
-      }
-    }
-    return result;
-  };
-  return {
-    domain: UNIT_INTERVAL,
-    range,
-    monotonicity,
-    extrema,
-    segments,
-    solvePosition,
-    solveVelocity,
-    solveT
-  };
-}
-function createBasisAxis(parameters, triplicateEndpoints = true) {
-  return createCurveAxis(
-    splines.splines.basis(triplicateEndpoints).chunkCoefficients(parameters)
-  );
-}
-function createBezierAxis(parameters) {
-  return createCurveAxis(splines.splines.bezier.chunkCoefficients(parameters));
-}
-function createCardinalAxis(parameters, a = 0.5, duplicateEndpoints = true) {
-  return createCurveAxis(
-    splines.splines.cardinal(a, duplicateEndpoints).chunkCoefficients(parameters)
-  );
-}
-function createCatmullRomAxis(parameters, duplicateEndpoints = true) {
-  return createCurveAxis(
-    splines.splines.catmullRom(duplicateEndpoints).chunkCoefficients(parameters)
-  );
-}
-function createHermiteAxis(parameters) {
-  return createCurveAxis(splines.splines.hermite.chunkCoefficients(parameters));
-}
-
-exports.createBasisAxis = createBasisAxis;
-exports.createBezierAxis = createBezierAxis;
-exports.createCardinalAxis = createCardinalAxis;
-exports.createCatmullRomAxis = createCatmullRomAxis;
-exports.createCurveAxis = createCurveAxis;
-exports.createHermiteAxis = 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 };