curvy 0.1.1 → 0.3.1

package/dist/index.cjs

@@ -1,670 +0,0 @@
-'use strict';
-
-const invariant = require('tiny-invariant');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const invariant__default = /*#__PURE__*/_interopDefaultCompat(invariant);
-
-function toCubicScalars(values, stride) {
-  const chunks = [];
-  invariant__default(values.length >= 4, "Values must have at least 4 elements");
-  invariant__default(
-    stride === 1 || stride === 2 || stride === 3,
-    "Stride must be 1, 2, or 3"
-  );
-  if (stride === 3) {
-    invariant__default(
-      values.length % stride === 1,
-      "Values length must be a multiple of 3 plus 1"
-    );
-  } else {
-    invariant__default(
-      values.length % stride === 0,
-      `Values length must be a multiple of ${stride}`
-    );
-  }
-  for (let i = 0; i <= values.length - 4; i += stride) {
-    chunks.push([
-      values[i],
-      values[i + 1],
-      values[i + 2],
-      values[i + 3]
-    ]);
-  }
-  return chunks;
-}
-const bezier = [
-  [-1, 3, -3, 1],
-  [3, -6, 3, 0],
-  [-3, 3, 0, 0],
-  [1, 0, 0, 0]
-];
-function toBezierSegments(values) {
-  return toCubicScalars(values, 3);
-}
-const hermite = [
-  [2, 1, -2, 1],
-  [-3, -2, 3, -1],
-  [0, 1, 0, 0],
-  [1, 0, 0, 0]
-];
-function toHermiteSegments(values) {
-  return toCubicScalars(values, 2);
-}
-const cardinal = (a) => [
-  [-a, 2 - a, a - 2, a],
-  [2 * a, a - 3, 3 - 2 * a, -a],
-  [-a, 0, a, 0],
-  [0, 1, 0, 0]
-];
-function toCardinalSegments(values, duplicateEndpoints = true) {
-  return toCubicScalars(
-    duplicateEndpoints ? [values[0], ...values, values[values.length - 1]] : values,
-    1
-  );
-}
-const catmullRom = [
-  [-0.5, 1.5, -1.5, 0.5],
-  [1, -2.5, 2, -0.5],
-  [-0.5, 0, 0.5, 0],
-  [0, 1, 0, 0]
-];
-function toCatmullRomSegments(values, duplicateEndpoints = true) {
-  return toCubicScalars(
-    duplicateEndpoints ? [values[0], ...values, values[values.length - 1]] : values,
-    1
-  );
-}
-const ONE_SIXTH = 1 / 6;
-const basis = [
-  [-ONE_SIXTH, 0.5, -0.5, ONE_SIXTH],
-  [0.5, -1, 0.5, 0],
-  [-0.5, 0, 0.5, 0],
-  [ONE_SIXTH, 4 * ONE_SIXTH, ONE_SIXTH, 0]
-];
-function toBasisSegments(values, triplicateEndpoints = true) {
-  return toCubicScalars(
-    triplicateEndpoints ? [
-      values[0],
-      values[0],
-      ...values,
-      values[values.length - 1],
-      values[values.length - 1]
-    ] : values,
-    1
-  );
-}
-
-const precision = 12;
-const scale = 10 ** precision;
-function round(value) {
-  return Math.round(value * scale) / scale;
-}
-function remap(x, x1, x2, y1, y2) {
-  return round(y1 + (x - x1) / (x2 - x1) * (y2 - y1));
-}
-
-function getDerivativeUnitRoots(derivative) {
-  const roots = /* @__PURE__ */ new Set();
-  if (derivative[0] !== 0) {
-    const discriminant = derivative[1] ** 2 - 4 * derivative[0] * derivative[2];
-    if (discriminant > 0) {
-      const sqrtDiscriminant = Math.sqrt(discriminant);
-      const denominator = 2 * derivative[0];
-      const root1 = (-derivative[1] - sqrtDiscriminant) / denominator;
-      const root2 = (-derivative[1] + sqrtDiscriminant) / denominator;
-      if (root1 > 0 && root1 < 1) {
-        roots.add(root1);
-      }
-      if (root2 > 0 && root2 < 1) {
-        roots.add(root2);
-      }
-    }
-  } else if (derivative[1] !== 0) {
-    const root = -derivative[2] / derivative[1];
-    if (root >= 0 && root <= 1) {
-      roots.add(root);
-    }
-  }
-  return roots;
-}
-function getLocalExtrema(derivativeRoots, polynomial) {
-  const localExtrema = /* @__PURE__ */ new Map();
-  localExtrema.set(0, polynomial[3]);
-  for (const root of derivativeRoots) {
-    const t2 = root * root;
-    const t3 = t2 * root;
-    localExtrema.set(
-      root,
-      round(
-        polynomial[0] * t3 + polynomial[1] * t2 + polynomial[2] * root + polynomial[3]
-      )
-    );
-  }
-  localExtrema.set(
-    1,
-    round(polynomial[0] + polynomial[1] + polynomial[2] + polynomial[3])
-  );
-  return localExtrema;
-}
-function getMonotonicity(localExtrema, derivative) {
-  if (localExtrema.size > 2) {
-    return "none";
-  }
-  if (derivative[0] === 0 && derivative[1] === 0 && derivative[2] === 0) {
-    return "constant";
-  }
-  let test = derivative[0] / 4 + derivative[1] / 2 + derivative[2];
-  if (test === 0) {
-    test = derivative[2];
-  }
-  return Math.sign(test) > 0 ? "increasing" : "decreasing";
-}
-function getPolynomial(matrix, points) {
-  return [
-    round(
-      points[0] * matrix[0][0] + points[1] * matrix[0][1] + points[2] * matrix[0][2] + points[3] * matrix[0][3]
-    ),
-    round(
-      points[0] * matrix[1][0] + points[1] * matrix[1][1] + points[2] * matrix[1][2] + points[3] * matrix[1][3]
-    ),
-    round(
-      points[0] * matrix[2][0] + points[1] * matrix[2][1] + points[2] * matrix[2][2] + points[3] * matrix[2][3]
-    ),
-    round(
-      points[0] * matrix[3][0] + points[1] * matrix[3][1] + points[2] * matrix[3][2] + points[3] * matrix[3][3]
-    )
-  ];
-}
-function createCurveSegment(matrix, points) {
-  const polynomial = getPolynomial(matrix, points);
-  const derivative = [
-    round(polynomial[0] * 3),
-    round(polynomial[1] * 2),
-    polynomial[2]
-  ];
-  const derivativeRoots = getDerivativeUnitRoots(derivative);
-  const localExtrema = getLocalExtrema(derivativeRoots, polynomial);
-  const max = Math.max(...localExtrema.values());
-  const min = Math.min(...localExtrema.values());
-  const monotonicity = getMonotonicity(localExtrema, derivative);
-  return {
-    localExtrema,
-    monotonicity,
-    max,
-    min,
-    points,
-    polynomial,
-    derivative,
-    solve: (t) => {
-      const t1 = round(t);
-      const t2 = t1 * t1;
-      const t3 = t2 * t1;
-      return round(
-        polynomial[0] * t3 + polynomial[1] * t2 + polynomial[2] * t1 + polynomial[3]
-      );
-    }
-  };
-}
-function createBezierSegment(points) {
-  return createCurveSegment(bezier, points);
-}
-function createHermiteSegment(points) {
-  return createCurveSegment(hermite, points);
-}
-function createCardinalSegment(points, tension = 0.5) {
-  return createCurveSegment(cardinal(tension), points);
-}
-function createCatmullRomSegment(points) {
-  return createCurveSegment(catmullRom, points);
-}
-function createBasisSegment(points) {
-  return createCurveSegment(basis, points);
-}
-
-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,
-    getPolynomial(sourceSpline, points)
-  );
-  return [
-    round(solutions[0]),
-    round(solutions[1]),
-    round(solutions[2]),
-    round(solutions[3])
-  ];
-}
-
-function filterExtrema(extrema) {
-  const extremaArray = [...extrema.entries()];
-  for (let index = 1; index < extremaArray.length - 1; index++) {
-    const [t, currentValue] = extremaArray[index];
-    const previousValue = extremaArray[index - 1][1];
-    const nextValue = extremaArray[index + 1][1];
-    if (previousValue <= currentValue && currentValue <= nextValue || previousValue >= currentValue && currentValue >= nextValue) {
-      extrema.delete(t);
-    }
-  }
-}
-function createCurve(matrix, segmentScalars) {
-  const segments = [];
-  let min = 0;
-  let max = 0;
-  let monotonicity = "none";
-  const normalizedToSegment = segmentScalars.length;
-  const segmentToNormalized = 1 / normalizedToSegment;
-  const extrema = /* @__PURE__ */ new Map();
-  for (const [index, points] of segmentScalars.entries()) {
-    const segment = createCurveSegment(matrix, points);
-    segments.push(segment);
-    if (index === 0) {
-      min = segment.min;
-      max = segment.max;
-      monotonicity = segment.monotonicity;
-    } else {
-      min = Math.min(min, segment.min);
-      max = Math.max(max, segment.max);
-      monotonicity = segment.monotonicity === monotonicity ? monotonicity : "none";
-    }
-    for (const [t, value] of segment.localExtrema) {
-      const curveT = round((t + index) * segmentToNormalized);
-      extrema.set(curveT, value);
-    }
-  }
-  if (extrema.size > 2) {
-    filterExtrema(extrema);
-  }
-  return {
-    extrema,
-    max,
-    min,
-    monotonicity,
-    segments,
-    solve: (t) => {
-      invariant__default(t >= 0 && t <= 1, "t must be between 0 and 1");
-      const t1 = round(t);
-      if (t1 === 1) {
-        return segments[segments.length - 1].solve(1);
-      }
-      const segmentT = round(t1 * segments.length);
-      const segmentIndex = Math.floor(segmentT);
-      const segment = segments[segmentIndex];
-      return segment.solve(segmentT - segmentIndex);
-    }
-  };
-}
-function createBezierCurve(values) {
-  return createCurve(bezier, toBezierSegments(values));
-}
-function createHermiteCurve(values) {
-  return createCurve(hermite, toHermiteSegments(values));
-}
-const defaultCardinalCurveOptions = {
-  a: 0.5,
-  duplicateEndpoints: true
-};
-function createCardinalCurve(values, options = {}) {
-  const { a, duplicateEndpoints } = {
-    ...defaultCardinalCurveOptions,
-    ...options
-  };
-  return createCurve(
-    cardinal(a),
-    toCardinalSegments(values, duplicateEndpoints)
-  );
-}
-const defaultCatmullRomCurveOptions = {
-  duplicateEndpoints: true
-};
-function createCatmullRomCurve(values, options = {}) {
-  const { duplicateEndpoints } = {
-    ...defaultCatmullRomCurveOptions,
-    ...options
-  };
-  return createCurve(
-    catmullRom,
-    toCatmullRomSegments(values, duplicateEndpoints)
-  );
-}
-const defaultBasisCurveOptions = {
-  triplicateEndpoints: true
-};
-function createBasisCurve(values, options = {}) {
-  const { triplicateEndpoints } = {
-    ...defaultBasisCurveOptions,
-    ...options
-  };
-  return createCurve(basis, toBasisSegments(values, triplicateEndpoints));
-}
-
-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 createSamples(count) {
-  return Array.from({ length: count }, (_, i) => round(i / (count - 1)));
-}
-function cubicRootsInUnitInterval(polynomial) {
-  const roots = /* @__PURE__ */ new Set();
-  const a2 = polynomial[1] / polynomial[0];
-  const a1 = polynomial[2] / polynomial[0];
-  const a0 = polynomial[3] / polynomial[0];
-  const q = a1 / 3 - a2 ** 2 / 9;
-  const r = (a1 * a2 - 3 * a0) / 6 - a2 ** 3 / 27;
-  const discriminant = q ** 3 + r ** 2;
-  if (discriminant > 0) {
-    const a = Math.cbrt(Math.abs(r) + Math.sqrt(discriminant));
-    const t = r < 0 ? q / a - a : a - q / a;
-    const root = round(t - a2 / 3);
-    if (0 <= root && root <= 1) {
-      roots.add(root);
-    }
-  } else {
-    const theta = Math.acos(r / Math.sqrt((-q) ** 3));
-    const theta1 = theta / 3;
-    const theta2 = theta1 - 2 * Math.PI / 3;
-    const theta3 = theta1 + 2 * Math.PI / 3;
-    const twoRootQ = 2 * Math.sqrt(-q);
-    const a2over3 = a2 / 3;
-    const root1 = round(twoRootQ * Math.cos(theta1) - a2over3);
-    const root2 = round(twoRootQ * Math.cos(theta2) - a2over3);
-    const root3 = round(twoRootQ * Math.cos(theta3) - a2over3);
-    if (0 <= root1 && root1 <= 1) {
-      roots.add(root1);
-    }
-    if (0 <= root2 && root2 <= 1) {
-      roots.add(root2);
-    }
-    if (0 <= root3 && root3 <= 1) {
-      roots.add(root3);
-    }
-  }
-  return roots;
-}
-function addPointsOfInterest(samples, curve) {
-  const segmentToNormalized = 1 / curve.segments.length;
-  for (const [index, segment] of curve.segments.entries()) {
-    samples.set(
-      index * segmentToNormalized,
-      curve.solve(index * segmentToNormalized)
-    );
-    const extrema = Array.from(segment.localExtrema.entries());
-    for (const [t, extreme] of extrema) {
-      samples.set(round((index + t) * segmentToNormalized), extreme);
-    }
-    if (extrema.length === 4) {
-      const segmentInflectionX = (extrema[1][0] + extrema[2][0]) / 2;
-      const segmentInflectionY = (extrema[1][1] + extrema[2][1]) / 2;
-      samples.set(
-        round((index + segmentInflectionX) * segmentToNormalized),
-        round(segmentInflectionY)
-      );
-    }
-    const roots = cubicRootsInUnitInterval(segment.polynomial);
-    for (const root of roots) {
-      samples.set(round((index + root) * segmentToNormalized), 0);
-    }
-    samples.set(
-      (index + 1) * segmentToNormalized,
-      curve.solve((index + 1) * segmentToNormalized)
-    );
-  }
-}
-function getLookupTableIntegral(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 getCurveSegmentIntegral(segment, start, end) {
-  const a = segment.polynomial[0] / 4;
-  const b = segment.polynomial[1] / 3;
-  const c = segment.polynomial[2] / 2;
-  const d = segment.polynomial[3];
-  const s1 = a * start ** 4 + b * start ** 3 + c * start ** 2 + d * start;
-  const s2 = a * end ** 4 + b * end ** 3 + c * end ** 2 + d * end;
-  return Math.abs(s2 - s1);
-}
-function enforceMaxError(curve, samples, maxError) {
-  const intervalBoundaries = Array.from(samples.keys()).sort((a, b) => a - b);
-  const normalizedToSegment = curve.segments.length;
-  const queue = [...intervalBoundaries];
-  while (queue.length > 1) {
-    const start = queue[0];
-    const end = queue[1];
-    const y1 = curve.solve(start);
-    const y2 = curve.solve(end);
-    const segment = curve.segments[Math.floor(start * normalizedToSegment)];
-    const lutIntegral = getLookupTableIntegral(start, end, y1, y2);
-    const curveIntegral = getCurveSegmentIntegral(segment, start, end);
-    const error = Math.abs(lutIntegral - curveIntegral);
-    if (error > maxError) {
-      queue.splice(1, 0, (start + end) / 2);
-    } else {
-      samples.set(start, y1);
-      queue.shift();
-    }
-  }
-  samples.set(queue[0], curve.solve(queue[0]));
-}
-function sampleCurveLength(curve, minSamples, maxError) {
-  const samples = /* @__PURE__ */ new Map();
-  for (const t of createSamples(minSamples)) {
-    samples.set(t, curve.solve(t));
-  }
-  if (maxError !== false) {
-    addPointsOfInterest(samples, curve);
-    enforceMaxError(curve, samples, maxError);
-  }
-  const sortedKeys = Array.from(samples.keys()).sort((a, b) => a - b);
-  return new Map(sortedKeys.map((key) => [key, samples.get(key)]));
-}
-const defaultOptions = {
-  minSamples: 33,
-  maxError: 1e-5
-};
-function createLengthLookup(curve, options = {}) {
-  const { minSamples, maxError } = { ...defaultOptions, ...options };
-  invariant__default(minSamples >= 2, "minSamples must be at least 2");
-  invariant__default(
-    maxError === false || maxError > 0,
-    "maxError must be positive or false"
-  );
-  const samples = sampleCurveLength(curve, minSamples, maxError);
-  let totalLength = 0;
-  const lengths = /* @__PURE__ */ new Map();
-  let previousT = null;
-  for (const tValue of samples.keys()) {
-    if (previousT !== null) {
-      const yValue = samples.get(tValue);
-      const previousYValue = samples.get(previousT);
-      const length = Math.sqrt(
-        (tValue - previousT) ** 2 + (yValue - previousYValue) ** 2
-      );
-      totalLength += length;
-    }
-    lengths.set(tValue, totalLength);
-    previousT = tValue;
-  }
-  const toNormalizedLength = 1 / totalLength;
-  const remappedSamples = /* @__PURE__ */ new Map();
-  for (const [t, length] of lengths.entries()) {
-    remappedSamples.set(round(length * toNormalizedLength), t);
-  }
-  return remappedSamples;
-}
-
-const defaultSolverOptions = {
-  minSamples: 64,
-  maxError: 1e-3,
-  lengthAdjust: 1
-};
-function createSolver(curve, options = {}) {
-  const {
-    maxError,
-    minSamples,
-    lengthAdjust: defaultLengthAdjust
-  } = {
-    ...defaultSolverOptions,
-    ...options
-  };
-  const lengthSamples = createLengthLookup(curve, { maxError, minSamples });
-  const { search } = createIntervalTree(Array.from(lengthSamples.keys()));
-  return function solve(input, lengthAdjust = defaultLengthAdjust) {
-    const query = round(input);
-    invariant__default(query >= 0 && query <= 1, "input must be between 0 and 1");
-    let t;
-    if (lengthAdjust === 0) {
-      t = query;
-    } else {
-      const lengthRange = search(query);
-      invariant__default(lengthRange, "lengthRange must be defined");
-      const [length1, length2] = lengthRange;
-      const t1 = lengthSamples.get(length1);
-      const t2 = lengthSamples.get(length2);
-      const lengthT = remap(query, length1, length2, t1, t2);
-      if (lengthAdjust === 1) {
-        t = lengthT;
-      } else {
-        t = (1 - lengthAdjust) * query + lengthAdjust * lengthT;
-      }
-    }
-    return curve.solve(t);
-  };
-}
-
-exports.basis = basis;
-exports.bezier = bezier;
-exports.cardinal = cardinal;
-exports.catmullRom = catmullRom;
-exports.convertScalars = convertScalars;
-exports.createBasisCurve = createBasisCurve;
-exports.createBasisSegment = createBasisSegment;
-exports.createBezierCurve = createBezierCurve;
-exports.createBezierSegment = createBezierSegment;
-exports.createCardinalCurve = createCardinalCurve;
-exports.createCardinalSegment = createCardinalSegment;
-exports.createCatmullRomCurve = createCatmullRomCurve;
-exports.createCatmullRomSegment = createCatmullRomSegment;
-exports.createCurve = createCurve;
-exports.createCurveSegment = createCurveSegment;
-exports.createHermiteCurve = createHermiteCurve;
-exports.createHermiteSegment = createHermiteSegment;
-exports.createIntervalTree = createIntervalTree;
-exports.createLengthLookup = createLengthLookup;
-exports.createSolver = createSolver;
-exports.hermite = hermite;
-exports.remap = remap;
-exports.round = round;
-exports.toBasisSegments = toBasisSegments;
-exports.toBezierSegments = toBezierSegments;
-exports.toCardinalSegments = toCardinalSegments;
-exports.toCatmullRomSegments = toCatmullRomSegments;
-exports.toCubicScalars = toCubicScalars;
-exports.toHermiteSegments = toHermiteSegments;