curvy 0.3.3 → 1.0.0

package/dist/curve.mjs

@@ -1,354 +0,0 @@
-import invariant from 'tiny-invariant';
-import { c as computeCubicAntiderivative, a as createCurveAxis } from './shared/curvy.7876e09e.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 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) {
-  const queue = collectPointsOfInterest(axis);
-  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.segments[Math.floor(current * axis.segments.length)];
-    const currentPosition = axis.solvePosition(current);
-    const nextPosition = axis.solvePosition(next);
-    const currentVelocity = axis.solveVelocity(current);
-    const nextVelocity = axis.solveVelocity(next);
-    const lutPositionIntegral = takeLinearIntegral(
-      current,
-      next,
-      currentPosition,
-      nextPosition
-    );
-    const curvePositionIntegral = takePolynomialIntegral(
-      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(normalized >= 0 && normalized <= 1, "Length out of bounds");
-    const length = normalized * totalLength;
-    const result = search(length);
-    invariant(result, "Length not found");
-    return 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(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]));
-  }
-  return axes;
-}
-function createCurve(axes) {
-  const axisKeys = Object.keys(axes);
-  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 lengthLookups = createCurveLengthLookups(axes, 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 = 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(
-      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(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}`
-    );
-    return positionAt(t, 0, precision);
-  };
-  return {
-    axes,
-    positionAt,
-    solveAlong,
-    solveWhere
-  };
-}
-function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.basis(triplicateEndpoints))
-  );
-}
-function createBezierCurve(points) {
-  return createCurve(convertPointsToAxes(points, splines.bezier));
-}
-function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.cardinal(tension, duplicateEndpoints))
-  );
-}
-function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(
-    convertPointsToAxes(points, splines.catmullRom(duplicateEndpoints))
-  );
-}
-function createHermiteCurve(points) {
-  return createCurve(convertPointsToAxes(points, splines.hermite));
-}
-
-export { createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createCurve, createHermiteCurve };

package/dist/shared/curvy.262f6070.cjs

@@ -1,16 +0,0 @@
-'use strict';
-
-function round(value, precision = 12) {
-  const scale = 10 ** precision;
-  const result = Math.round(value * scale) / scale;
-  if (result === 0) {
-    return 0;
-  }
-  return result;
-}
-function remap(x, x1, x2, y1, y2) {
-  return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
-}
-
-exports.remap = remap;
-exports.round = round;

package/dist/shared/curvy.7876e09e.mjs

@@ -1,323 +0,0 @@
-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 computeCubicAntiderivative(coefficients, integrationConstant) {
-  return [
-    coefficients[0] / 4,
-    coefficients[1] / 3,
-    coefficients[2] / 2,
-    coefficients[3],
-    integrationConstant
-  ];
-}
-
-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 { createCurveAxis as a, createBasisAxis as b, computeCubicAntiderivative as c, createBezierAxis as d, createCardinalAxis as e, createCatmullRomAxis as f, createHermiteAxis as g };

package/dist/shared/curvy.9cd8b44c.mjs

@@ -1,13 +0,0 @@
-function round(value, precision = 12) {
-  const scale = 10 ** precision;
-  const result = Math.round(value * scale) / scale;
-  if (result === 0) {
-    return 0;
-  }
-  return result;
-}
-function remap(x, x1, x2, y1, y2) {
-  return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
-}
-
-export { round as a, remap as r };