curvy 0.1.1 → 0.3.2

package/dist/axis.cjs

@@ -0,0 +1,325 @@
+'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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,314 @@
+import invariant from 'tiny-invariant';
+import { splines } from './splines.mjs';
+
+const UNIT_INTERVAL = [0, 1];
+function createLinearPolynomial(coefficients, domain = UNIT_INTERVAL) {
+  const [a, b] = coefficients;
+  invariant(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(x >= domain[0] && x <= domain[1], "x out of domain");
+    return a * x + b;
+  };
+  const solveInverse = (y) => {
+    invariant(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(domain[0] <= domain[1], "invalid domain");
+      invariant(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(domain[0] <= domain[1], "invalid domain");
+      invariant(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(domain[0] <= domain[1], "invalid domain");
+  const derivative = createLinearPolynomial([2 * a, b], domain);
+  const extreme = derivative.root;
+  const solve = (x) => {
+    invariant(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(domain[0] <= domain[1], "invalid domain");
+    invariant(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(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(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(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(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(
+      position >= range[0] && position <= range[1],
+      "position out of range"
+    );
+    invariant(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.basis(triplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createBezierAxis(parameters) {
+  return createCurveAxis(splines.bezier.chunkCoefficients(parameters));
+}
+function createCardinalAxis(parameters, a = 0.5, duplicateEndpoints = true) {
+  return createCurveAxis(
+    splines.cardinal(a, duplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createCatmullRomAxis(parameters, duplicateEndpoints = true) {
+  return createCurveAxis(
+    splines.catmullRom(duplicateEndpoints).chunkCoefficients(parameters)
+  );
+}
+function createHermiteAxis(parameters) {
+  return createCurveAxis(splines.hermite.chunkCoefficients(parameters));
+}
+
+export { createBasisAxis, createBezierAxis, createCardinalAxis, createCatmullRomAxis, createCurveAxis, createHermiteAxis };