curvy 0.1.1

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tim Morris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

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