curvy 0.1.1 → 0.3.1

package/dist/convert.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+const invariant = require('tiny-invariant');
+const splines = require('./splines.cjs');
+const util = require('./shared/curvy.262f6070.cjs');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const invariant__default = /*#__PURE__*/_interopDefaultCompat(invariant);
+
+function determinant(matrix) {
+  const size = matrix.length;
+  invariant__default(
+    matrix.every((row) => row.length === size),
+    "matrix must be square"
+  );
+  let result = 0;
+  if (size === 1) {
+    result = matrix[0][0];
+  } else if (size === 2) {
+    result = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+  } else {
+    for (const [columnIndex, value] of matrix[0].entries()) {
+      const subMatrix = [];
+      for (const row of matrix.slice(1)) {
+        const subMatrixRow = [];
+        for (const [subColumnIndex, subColumnValue] of row.entries()) {
+          if (subColumnIndex !== columnIndex) {
+            subMatrixRow.push(subColumnValue);
+          }
+        }
+        subMatrix.push(subMatrixRow);
+      }
+      result = result + (-1) ** (columnIndex + 2) * value * determinant(subMatrix);
+    }
+  }
+  return result;
+}
+function solveLinearSystem(coefficients, solutions) {
+  const coefficientDeterminant = determinant(coefficients);
+  invariant__default(
+    coefficientDeterminant !== 0,
+    "Cannot solve system of equations when coefficient matrix determinant is zero"
+  );
+  const variables = [0, 0, 0, 0];
+  for (let index = 0; index < solutions.length; index++) {
+    const solutionMatrix = [];
+    for (const [rowIndex, row] of coefficients.entries()) {
+      const solutionMatrixRow = [];
+      for (const [columnIndex, column] of row.entries()) {
+        solutionMatrixRow.push(
+          columnIndex === index ? solutions[rowIndex] : column
+        );
+      }
+      solutionMatrix.push(solutionMatrixRow);
+    }
+    variables[index] = determinant(solutionMatrix) / coefficientDeterminant;
+  }
+  return variables;
+}
+function convertScalars(points, sourceSpline, targetSpline) {
+  const solutions = solveLinearSystem(
+    targetSpline,
+    splines.pointsToCoefficients(sourceSpline, points)
+  );
+  return [
+    util.round(solutions[0]),
+    util.round(solutions[1]),
+    util.round(solutions[2]),
+    util.round(solutions[3])
+  ];
+}
+
+exports.convertScalars = convertScalars;

package/dist/convert.d.cts

@@ -0,0 +1,6 @@
+import { a as CubicCoefficients } from './shared/curvy.0f1371d7.cjs';
+import { Matrix4x4 } from './splines.cjs';
+
+declare function convertScalars(points: CubicCoefficients, sourceSpline: Matrix4x4, targetSpline: Matrix4x4): CubicCoefficients;
+
+export { convertScalars };

package/dist/convert.d.mts

@@ -0,0 +1,6 @@
+import { a as CubicCoefficients } from './shared/curvy.0f1371d7.mjs';
+import { Matrix4x4 } from './splines.mjs';
+
+declare function convertScalars(points: CubicCoefficients, sourceSpline: Matrix4x4, targetSpline: Matrix4x4): CubicCoefficients;
+
+export { convertScalars };

package/dist/convert.d.ts

@@ -0,0 +1,6 @@
+import { a as CubicCoefficients } from './shared/curvy.0f1371d7.js';
+import { Matrix4x4 } from './splines.js';
+
+declare function convertScalars(points: CubicCoefficients, sourceSpline: Matrix4x4, targetSpline: Matrix4x4): CubicCoefficients;
+
+export { convertScalars };

package/dist/convert.mjs

@@ -0,0 +1,68 @@
+import invariant from 'tiny-invariant';
+import { pointsToCoefficients } from './splines.mjs';
+import { a as round } from './shared/curvy.9cd8b44c.mjs';
+
+function determinant(matrix) {
+  const size = matrix.length;
+  invariant(
+    matrix.every((row) => row.length === size),
+    "matrix must be square"
+  );
+  let result = 0;
+  if (size === 1) {
+    result = matrix[0][0];
+  } else if (size === 2) {
+    result = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+  } else {
+    for (const [columnIndex, value] of matrix[0].entries()) {
+      const subMatrix = [];
+      for (const row of matrix.slice(1)) {
+        const subMatrixRow = [];
+        for (const [subColumnIndex, subColumnValue] of row.entries()) {
+          if (subColumnIndex !== columnIndex) {
+            subMatrixRow.push(subColumnValue);
+          }
+        }
+        subMatrix.push(subMatrixRow);
+      }
+      result = result + (-1) ** (columnIndex + 2) * value * determinant(subMatrix);
+    }
+  }
+  return result;
+}
+function solveLinearSystem(coefficients, solutions) {
+  const coefficientDeterminant = determinant(coefficients);
+  invariant(
+    coefficientDeterminant !== 0,
+    "Cannot solve system of equations when coefficient matrix determinant is zero"
+  );
+  const variables = [0, 0, 0, 0];
+  for (let index = 0; index < solutions.length; index++) {
+    const solutionMatrix = [];
+    for (const [rowIndex, row] of coefficients.entries()) {
+      const solutionMatrixRow = [];
+      for (const [columnIndex, column] of row.entries()) {
+        solutionMatrixRow.push(
+          columnIndex === index ? solutions[rowIndex] : column
+        );
+      }
+      solutionMatrix.push(solutionMatrixRow);
+    }
+    variables[index] = determinant(solutionMatrix) / coefficientDeterminant;
+  }
+  return variables;
+}
+function convertScalars(points, sourceSpline, targetSpline) {
+  const solutions = solveLinearSystem(
+    targetSpline,
+    pointsToCoefficients(sourceSpline, points)
+  );
+  return [
+    round(solutions[0]),
+    round(solutions[1]),
+    round(solutions[2]),
+    round(solutions[3])
+  ];
+}
+
+export { convertScalars };

package/dist/curve.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+const invariant = require('tiny-invariant');
+const axis = require('./axis.cjs');
+const util = require('./shared/curvy.262f6070.cjs');
+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);
+
+function createNode(interval) {
+  return {
+    interval,
+    left: null,
+    right: null
+  };
+}
+function takeCenterInterval(boundaries) {
+  const mid = Math.floor((boundaries.length - 1) / 2);
+  const left = mid > 0 ? boundaries.slice(0, mid + 1) : null;
+  const right = mid + 1 < boundaries.length - 1 ? boundaries.slice(mid + 1) : null;
+  return {
+    center: [boundaries[mid], boundaries[mid + 1]],
+    left,
+    right
+  };
+}
+function createIntervalTree(boundaries) {
+  const container = createNode([0, 0]);
+  const branches = [{ parent: container, direction: "left", boundaries }];
+  for (const branch of branches) {
+    const { parent, direction, boundaries: boundaries2 } = branch;
+    const { center, left, right } = takeCenterInterval(boundaries2);
+    const node = createNode(center);
+    if (direction === "left") {
+      parent.left = node;
+    } else {
+      parent.right = node;
+    }
+    if (left !== null) {
+      branches.push({ parent: node, direction: "left", boundaries: left });
+    }
+    if (right !== null) {
+      branches.push({ parent: node, direction: "right", boundaries: right });
+    }
+  }
+  const root = container.left;
+  function searchNode(node, query) {
+    if (node.interval[0] <= query && node.interval[1] >= query) {
+      return node.interval;
+    }
+    if (node.interval[0] > query && node.left) {
+      return searchNode(node.left, query);
+    }
+    if (node.interval[1] < query && node.right) {
+      return searchNode(node.right, query);
+    }
+    return null;
+  }
+  function search(query) {
+    return searchNode(root, query);
+  }
+  return {
+    root,
+    search
+  };
+}
+
+function distance(a, b) {
+  const keys = Object.keys(a);
+  const deltas = keys.map((key) => a[key] - b[key]);
+  return Math.hypot(...deltas);
+}
+function createLengthLookup(positionAt) {
+  const count = 512;
+  const orderedSamples = Array.from({ length: count + 1 }, (_, i) => i / count);
+  const lengthLookup = /* @__PURE__ */ new Map();
+  let lastPoint = positionAt(0);
+  let length = 0;
+  lengthLookup.set(0, 0);
+  for (const t of orderedSamples.slice(1)) {
+    const point = positionAt(t);
+    length = length + distance(lastPoint, point);
+    lengthLookup.set(length, t);
+    lastPoint = point;
+  }
+  const totalLength = length;
+  const { search } = createIntervalTree(Array.from(lengthLookup.keys()));
+  return (normalized) => {
+    invariant__default(normalized >= 0 && normalized <= 1, "Length out of bounds");
+    const length2 = normalized * totalLength;
+    const result = search(length2);
+    invariant__default(result, "Length not found");
+    return util.remap(
+      length2,
+      result[0],
+      result[1],
+      lengthLookup.get(result[0]),
+      lengthLookup.get(result[1])
+    );
+  };
+}
+
+function createCurve(points, spline) {
+  const axisKeys = Object.keys(points[0]);
+  const axisPoints = {};
+  for (const key of axisKeys) {
+    axisPoints[key] = [];
+  }
+  for (const point of points) {
+    for (const key of axisKeys) {
+      invariant__default(key in point, `Point ${point} is missing axis "${key}"`);
+      axisPoints[key].push(point[key]);
+    }
+  }
+  const axes = {};
+  for (const key of axisKeys) {
+    axes[key] = axis.createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
+  }
+  const solveT = (t, precision = 12) => {
+    const rounded = util.round(t);
+    invariant__default(
+      rounded >= 0 && rounded <= 1,
+      `t must be between 0 and 1, got ${rounded}`
+    );
+    const position = {};
+    for (const key of axisKeys) {
+      position[key] = util.round(axes[key].solvePosition(rounded), precision);
+    }
+    return position;
+  };
+  const lengthLookup = createLengthLookup(solveT);
+  const positionAt = (input, normalize = 1, precision = 12) => {
+    invariant__default(
+      input >= 0 && input <= 1,
+      `Input must be between 0 and 1, got ${input}`
+    );
+    let t = input;
+    if (normalize > 0) {
+      const denormalizedT = lengthLookup(input);
+      if (normalize === 1) {
+        t = denormalizedT;
+      } else {
+        t = (1 - normalize) * input + normalize * denormalizedT;
+      }
+    }
+    return solveT(t, precision);
+  };
+  const solveWhere = (axis, position, precision = 12) => {
+    const curveAxis = axes[axis];
+    invariant__default(curveAxis.monotonicity !== "none", "Axis is not monotonic");
+    const t = curveAxis.solveT(position, curveAxis.domain)[0];
+    invariant__default(
+      typeof t === "number",
+      `Could not solve for ${axis} = ${position}`
+    );
+    const result = { [axis]: util.round(position, precision) };
+    for (const key of axisKeys) {
+      if (key !== axis) {
+        result[key] = util.round(axes[key].solvePosition(t), precision);
+      }
+    }
+    return result;
+  };
+  return {
+    axes,
+    positionAt,
+    solveWhere
+  };
+}
+function createBasisCurve(points, triplicateEndpoints = true) {
+  return createCurve(points, splines.splines.basis(triplicateEndpoints));
+}
+function createBezierCurve(points) {
+  return createCurve(points, splines.splines.bezier);
+}
+function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
+  return createCurve(points, splines.splines.cardinal(tension, duplicateEndpoints));
+}
+function createCatmullRomCurve(points, duplicateEndpoints = true) {
+  return createCurve(points, splines.splines.catmullRom(duplicateEndpoints));
+}
+function createHermiteCurve(points) {
+  return createCurve(points, splines.splines.hermite);
+}
+
+exports.createBasisCurve = createBasisCurve;
+exports.createBezierCurve = createBezierCurve;
+exports.createCardinalCurve = createCardinalCurve;
+exports.createCatmullRomCurve = createCatmullRomCurve;
+exports.createHermiteCurve = createHermiteCurve;

package/dist/curve.d.cts

@@ -0,0 +1,18 @@
+import { CurveAxis } from './axis.cjs';
+import './shared/curvy.0f1371d7.cjs';
+
+type Point<Axis extends string | number> = Readonly<{
+    [A in Axis]: number;
+}>;
+type Curve<Axis extends string | number> = {
+    readonly axes: Readonly<Record<Axis, CurveAxis>>;
+    readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+};
+declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
+declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };

package/dist/curve.d.mts

@@ -0,0 +1,18 @@
+import { CurveAxis } from './axis.mjs';
+import './shared/curvy.0f1371d7.mjs';
+
+type Point<Axis extends string | number> = Readonly<{
+    [A in Axis]: number;
+}>;
+type Curve<Axis extends string | number> = {
+    readonly axes: Readonly<Record<Axis, CurveAxis>>;
+    readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+};
+declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
+declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };

package/dist/curve.d.ts

@@ -0,0 +1,18 @@
+import { CurveAxis } from './axis.js';
+import './shared/curvy.0f1371d7.js';
+
+type Point<Axis extends string | number> = Readonly<{
+    [A in Axis]: number;
+}>;
+type Curve<Axis extends string | number> = {
+    readonly axes: Readonly<Record<Axis, CurveAxis>>;
+    readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+};
+declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
+declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
+declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
+
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };

package/dist/curve.mjs

@@ -0,0 +1,182 @@
+import invariant from 'tiny-invariant';
+import { createCurveAxis } from './axis.mjs';
+import { r as remap, a as round } from './shared/curvy.9cd8b44c.mjs';
+import { splines } from './splines.mjs';
+
+function createNode(interval) {
+  return {
+    interval,
+    left: null,
+    right: null
+  };
+}
+function takeCenterInterval(boundaries) {
+  const mid = Math.floor((boundaries.length - 1) / 2);
+  const left = mid > 0 ? boundaries.slice(0, mid + 1) : null;
+  const right = mid + 1 < boundaries.length - 1 ? boundaries.slice(mid + 1) : null;
+  return {
+    center: [boundaries[mid], boundaries[mid + 1]],
+    left,
+    right
+  };
+}
+function createIntervalTree(boundaries) {
+  const container = createNode([0, 0]);
+  const branches = [{ parent: container, direction: "left", boundaries }];
+  for (const branch of branches) {
+    const { parent, direction, boundaries: boundaries2 } = branch;
+    const { center, left, right } = takeCenterInterval(boundaries2);
+    const node = createNode(center);
+    if (direction === "left") {
+      parent.left = node;
+    } else {
+      parent.right = node;
+    }
+    if (left !== null) {
+      branches.push({ parent: node, direction: "left", boundaries: left });
+    }
+    if (right !== null) {
+      branches.push({ parent: node, direction: "right", boundaries: right });
+    }
+  }
+  const root = container.left;
+  function searchNode(node, query) {
+    if (node.interval[0] <= query && node.interval[1] >= query) {
+      return node.interval;
+    }
+    if (node.interval[0] > query && node.left) {
+      return searchNode(node.left, query);
+    }
+    if (node.interval[1] < query && node.right) {
+      return searchNode(node.right, query);
+    }
+    return null;
+  }
+  function search(query) {
+    return searchNode(root, query);
+  }
+  return {
+    root,
+    search
+  };
+}
+
+function distance(a, b) {
+  const keys = Object.keys(a);
+  const deltas = keys.map((key) => a[key] - b[key]);
+  return Math.hypot(...deltas);
+}
+function createLengthLookup(positionAt) {
+  const count = 512;
+  const orderedSamples = Array.from({ length: count + 1 }, (_, i) => i / count);
+  const lengthLookup = /* @__PURE__ */ new Map();
+  let lastPoint = positionAt(0);
+  let length = 0;
+  lengthLookup.set(0, 0);
+  for (const t of orderedSamples.slice(1)) {
+    const point = positionAt(t);
+    length = length + distance(lastPoint, point);
+    lengthLookup.set(length, t);
+    lastPoint = point;
+  }
+  const totalLength = length;
+  const { search } = createIntervalTree(Array.from(lengthLookup.keys()));
+  return (normalized) => {
+    invariant(normalized >= 0 && normalized <= 1, "Length out of bounds");
+    const length2 = normalized * totalLength;
+    const result = search(length2);
+    invariant(result, "Length not found");
+    return remap(
+      length2,
+      result[0],
+      result[1],
+      lengthLookup.get(result[0]),
+      lengthLookup.get(result[1])
+    );
+  };
+}
+
+function createCurve(points, spline) {
+  const axisKeys = Object.keys(points[0]);
+  const axisPoints = {};
+  for (const key of axisKeys) {
+    axisPoints[key] = [];
+  }
+  for (const point of points) {
+    for (const key of axisKeys) {
+      invariant(key in point, `Point ${point} is missing axis "${key}"`);
+      axisPoints[key].push(point[key]);
+    }
+  }
+  const axes = {};
+  for (const key of axisKeys) {
+    axes[key] = createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
+  }
+  const solveT = (t, precision = 12) => {
+    const rounded = round(t);
+    invariant(
+      rounded >= 0 && rounded <= 1,
+      `t must be between 0 and 1, got ${rounded}`
+    );
+    const position = {};
+    for (const key of axisKeys) {
+      position[key] = round(axes[key].solvePosition(rounded), precision);
+    }
+    return position;
+  };
+  const lengthLookup = createLengthLookup(solveT);
+  const positionAt = (input, normalize = 1, precision = 12) => {
+    invariant(
+      input >= 0 && input <= 1,
+      `Input must be between 0 and 1, got ${input}`
+    );
+    let t = input;
+    if (normalize > 0) {
+      const denormalizedT = lengthLookup(input);
+      if (normalize === 1) {
+        t = denormalizedT;
+      } else {
+        t = (1 - normalize) * input + normalize * denormalizedT;
+      }
+    }
+    return solveT(t, precision);
+  };
+  const solveWhere = (axis, position, precision = 12) => {
+    const curveAxis = axes[axis];
+    invariant(curveAxis.monotonicity !== "none", "Axis is not monotonic");
+    const t = curveAxis.solveT(position, curveAxis.domain)[0];
+    invariant(
+      typeof t === "number",
+      `Could not solve for ${axis} = ${position}`
+    );
+    const result = { [axis]: round(position, precision) };
+    for (const key of axisKeys) {
+      if (key !== axis) {
+        result[key] = round(axes[key].solvePosition(t), precision);
+      }
+    }
+    return result;
+  };
+  return {
+    axes,
+    positionAt,
+    solveWhere
+  };
+}
+function createBasisCurve(points, triplicateEndpoints = true) {
+  return createCurve(points, splines.basis(triplicateEndpoints));
+}
+function createBezierCurve(points) {
+  return createCurve(points, splines.bezier);
+}
+function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
+  return createCurve(points, splines.cardinal(tension, duplicateEndpoints));
+}
+function createCatmullRomCurve(points, duplicateEndpoints = true) {
+  return createCurve(points, splines.catmullRom(duplicateEndpoints));
+}
+function createHermiteCurve(points) {
+  return createCurve(points, splines.hermite);
+}
+
+export { createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };

package/dist/shared/curvy.0f1371d7.d.cts

@@ -0,0 +1,38 @@
+type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
+type Interval = readonly [number, number];
+type LinearCoefficients = readonly [number, number];
+type LinearPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: LinearCoefficients;
+    readonly root: number | null;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number) => number;
+};
+type QuadraticCoefficients = readonly [number, number, number];
+type QuadraticPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: QuadraticCoefficients;
+    readonly extreme: number | null;
+    readonly roots: ReadonlyArray<number>;
+    readonly derivative: LinearPolynomial;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
+};
+type CubicCoefficients = readonly [number, number, number, number];
+type CubicPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: CubicCoefficients;
+    readonly extrema: ReadonlyArray<number>;
+    readonly roots: ReadonlyArray<number>;
+    readonly derivative: QuadraticPolynomial;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
+};
+
+export type { CubicPolynomial as C, Interval as I, Monotonicity as M, CubicCoefficients as a };

package/dist/shared/curvy.0f1371d7.d.mts

@@ -0,0 +1,38 @@
+type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
+type Interval = readonly [number, number];
+type LinearCoefficients = readonly [number, number];
+type LinearPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: LinearCoefficients;
+    readonly root: number | null;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number) => number;
+};
+type QuadraticCoefficients = readonly [number, number, number];
+type QuadraticPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: QuadraticCoefficients;
+    readonly extreme: number | null;
+    readonly roots: ReadonlyArray<number>;
+    readonly derivative: LinearPolynomial;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
+};
+type CubicCoefficients = readonly [number, number, number, number];
+type CubicPolynomial = {
+    readonly domain: Interval;
+    readonly range: Interval;
+    readonly monotonocity: Monotonicity;
+    readonly coefficients: CubicCoefficients;
+    readonly extrema: ReadonlyArray<number>;
+    readonly roots: ReadonlyArray<number>;
+    readonly derivative: QuadraticPolynomial;
+    readonly solve: (x: number) => number;
+    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
+};
+
+export type { CubicPolynomial as C, Interval as I, Monotonicity as M, CubicCoefficients as a };