curvy 0.3.3 → 1.0.1

package/dist/convert.cjs

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

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

package/dist/convert.d.mts

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

package/dist/convert.d.ts

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

package/dist/convert.mjs

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

@@ -1,365 +0,0 @@
-'use strict';
-
-const invariant = require('tiny-invariant');
-const axis = require('./shared/curvy.db103082.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 collectPointsOfInterest(axis) {
-  const samples = new Set(Array.from({ length: 33 }, (_, i) => i / 32));
-  const segmentToNormalized = 1 / axis.segments.length;
-  for (const [index, segment] of axis.segments.entries()) {
-    samples.add(index * segmentToNormalized);
-    samples.add((index + 1) * segmentToNormalized);
-    for (const t of segment.extrema) {
-      samples.add((index + t) * segmentToNormalized);
-    }
-    for (const root of segment.roots) {
-      samples.add((index + root) * segmentToNormalized);
-    }
-    for (const root of segment.derivative.roots) {
-      samples.add((index + root) * segmentToNormalized);
-    }
-  }
-  return Array.from(samples).sort((a, b) => a - b);
-}
-function takeLinearIntegral(x1, x2, y1, y2) {
-  const m = (y2 - y1) / (x2 - x1);
-  const b = y1 - m * x1;
-  const s1 = x1 ** 2 * m / 2 + b * x1;
-  const s2 = x2 ** 2 * m / 2 + b * x2;
-  return Math.abs(s2 - s1);
-}
-function takePolynomialIntegral(coefficients, start, end) {
-  let s1 = 0;
-  let s2 = 0;
-  for (let i = 0; i < coefficients.length; i++) {
-    const power = coefficients.length - i;
-    s1 += coefficients[i] * start ** power / power;
-    s2 += coefficients[i] * end ** power / power;
-  }
-  return Math.abs(s2 - s1);
-}
-function* createAxisSampler(key, axis$1) {
-  const queue = collectPointsOfInterest(axis$1);
-  let totalLength = 0;
-  const lengthLookup = /* @__PURE__ */ new Map();
-  while (queue.length > 0) {
-    const current = queue[0];
-    const next = queue[1];
-    if (next === void 0) {
-      yield current;
-      lengthLookup.set(totalLength, current);
-      break;
-    }
-    const segment = axis$1.segments[Math.floor(current * axis$1.segments.length)];
-    const currentPosition = axis$1.solvePosition(current);
-    const nextPosition = axis$1.solvePosition(next);
-    const currentVelocity = axis$1.solveVelocity(current);
-    const nextVelocity = axis$1.solveVelocity(next);
-    const lutPositionIntegral = takeLinearIntegral(
-      current,
-      next,
-      currentPosition,
-      nextPosition
-    );
-    const curvePositionIntegral = takePolynomialIntegral(
-      axis.computeCubicAntiderivative(segment.coefficients, 0),
-      current,
-      next
-    );
-    const lutVelocityIntegral = takeLinearIntegral(
-      current,
-      next,
-      currentVelocity,
-      nextVelocity
-    );
-    const curveVelocityIntegral = takePolynomialIntegral(
-      segment.derivative.coefficients,
-      current,
-      next
-    );
-    const error = Math.max(
-      Math.abs(lutPositionIntegral - curvePositionIntegral),
-      Math.abs(lutVelocityIntegral - curveVelocityIntegral)
-    );
-    if (error > 1) {
-      queue.splice(1, 0, (current + next) / 2);
-    } else {
-      yield current;
-      lengthLookup.set(totalLength, current);
-      totalLength += Math.hypot(current - next, currentPosition - nextPosition);
-      queue.shift();
-    }
-  }
-  return [
-    key,
-    {
-      length: totalLength,
-      lookup: lengthLookup
-    }
-  ];
-}
-function distance(a, b) {
-  const deltas = [];
-  for (const key of Object.keys(a)) {
-    deltas.push(a[key] - b[key]);
-  }
-  return Math.hypot(...deltas);
-}
-function createSampleBuffer() {
-  const values = /* @__PURE__ */ new Map();
-  return {
-    get size() {
-      return values.size;
-    },
-    add(key, value) {
-      if (!values.has(key)) {
-        values.set(key, /* @__PURE__ */ new Set());
-      }
-      values.get(key)?.add(value);
-    },
-    get(key) {
-      return values.get(key);
-    },
-    remove(key, value) {
-      values.get(key)?.delete(value);
-      if (values.get(key)?.size === 0) {
-        values.delete(key);
-      }
-    },
-    keys() {
-      return Array.from(values.keys());
-    }
-  };
-}
-function createLengthLookup({
-  length: totalLength,
-  lookup
-}) {
-  const { search } = createIntervalTree(Array.from(lookup.keys()));
-  return (normalized) => {
-    invariant__default(normalized >= 0 && normalized <= 1, "Length out of bounds");
-    const length = normalized * totalLength;
-    const result = search(length);
-    invariant__default(result, "Length not found");
-    return util.remap(
-      length,
-      result[0],
-      result[1],
-      lookup.get(result[0]),
-      lookup.get(result[1])
-    );
-  };
-}
-function createCurveLengthLookups(axes, positionAt) {
-  const lengthLookup = /* @__PURE__ */ new Map();
-  const axesLookups = {};
-  const sampleBuffer = createSampleBuffer();
-  for (const [key, axis] of Object.entries(axes)) {
-    const sampler = createAxisSampler(key, axis);
-    const first = sampler.next();
-    if (first.done) {
-      axesLookups[first.value[0]] = createLengthLookup(first.value[1]);
-    } else {
-      sampleBuffer.add(first.value, sampler);
-    }
-  }
-  let lastPoint = positionAt(0);
-  let length = 0;
-  lengthLookup.set(0, 0);
-  while (sampleBuffer.size > 0) {
-    const t = Math.min(...sampleBuffer.keys());
-    const point = positionAt(t);
-    length = length + distance(lastPoint, point);
-    lengthLookup.set(length, t);
-    lastPoint = point;
-    const samplers = sampleBuffer.get(t);
-    for (const sampler of samplers) {
-      const next = sampler.next();
-      if (next.done) {
-        axesLookups[next.value[0]] = createLengthLookup(next.value[1]);
-      } else {
-        sampleBuffer.add(next.value, sampler);
-      }
-      sampleBuffer.remove(t, sampler);
-    }
-  }
-  return {
-    curve: createLengthLookup({ length, lookup: lengthLookup }),
-    axes: axesLookups
-  };
-}
-
-function convertPointsToAxes(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]));
-  }
-  return axes;
-}
-function createCurve(axes) {
-  const axisKeys = Object.keys(axes);
-  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 lengthLookups = createCurveLengthLookups(axes, 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 = lengthLookups.curve(input);
-      if (normalize === 1) {
-        t = denormalizedT;
-      } else {
-        t = (1 - normalize) * input + normalize * denormalizedT;
-      }
-    }
-    return solveT(t, precision);
-  };
-  const solveAlong = (axis, 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 = lengthLookups.axes[axis](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}`
-    );
-    return positionAt(t, 0, precision);
-  };
-  return {
-    axes,
-    positionAt,
-    solveAlong,
-    solveWhere
-  };
-}
-function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.splines.basis(triplicateEndpoints))
-  );
-}
-function createBezierCurve(points) {
-  return createCurve(convertPointsToAxes(points, splines.splines.bezier));
-}
-function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.splines.cardinal(tension, duplicateEndpoints))
-  );
-}
-function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.splines.catmullRom(duplicateEndpoints))
-  );
-}
-function createHermiteCurve(points) {
-  return createCurve(convertPointsToAxes(points, splines.splines.hermite));
-}
-
-exports.createBasisCurve = createBasisCurve;
-exports.createBezierCurve = createBezierCurve;
-exports.createCardinalCurve = createCardinalCurve;
-exports.createCatmullRomCurve = createCatmullRomCurve;
-exports.createCurve = createCurve;
-exports.createHermiteCurve = createHermiteCurve;

package/dist/curve.d.cts

@@ -1,20 +0,0 @@
-import { CurveAxis } from './axis.cjs';
-import './shared/curvy.df73166c.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 solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
-};
-declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<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, createCurve, createHermiteCurve };

package/dist/curve.d.mts

@@ -1,20 +0,0 @@
-import { CurveAxis } from './axis.mjs';
-import './shared/curvy.df73166c.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 solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
-};
-declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<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, createCurve, createHermiteCurve };

package/dist/curve.d.ts

@@ -1,20 +0,0 @@
-import { CurveAxis } from './axis.js';
-import './shared/curvy.df73166c.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 solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
-};
-declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<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, createCurve, createHermiteCurve };