@thi.ng/geom-splines 2.2.66 → 2.2.67

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/cubic-arc.js

@@ -4,51 +4,41 @@ import { EPS, HALF_PI, PI } from "@thi.ng/math/api";
 import { roundEps } from "@thi.ng/math/prec";
 import { magSq2 } from "@thi.ng/vectors/magsq";
 import { cubicFromLine } from "./cubic-line.js";
-/**
- * Converts elliptic arc into a 1-4 cubic curve segments, depending on arc's
- * angle range.
- *
- * Partially based on:
- * https://github.com/chromium/chromium/blob/develop/third_party/blink/renderer/core/svg/svg_path_parser.cc#L253
- *
- * @param pos - ellipse center
- * @param r - ellipse radii
- * @param axis - rotation angle (radians)
- * @param start - start angle (radians)
- * @param end - end angle (radians)
- */
-export const cubicFromArc = (pos, r, axis, start, end) => {
-    const p = pointAtTheta(pos, r, axis, start);
-    const q = pointAtTheta(pos, r, axis, end);
-    const delta = end - start;
-    const [rx, ry] = r;
-    const [s, c] = sincos(axis);
-    const dx = (c * (p[0] - q[0])) / 2 + (s * (p[1] - q[1])) / 2;
-    const dy = (-s * (p[0] - q[0])) / 2 + (c * (p[1] - q[1])) / 2;
-    if ((Math.abs(delta) < PI && dx === 0 && dy === 0) || magSq2(r) < EPS) {
-        return [cubicFromLine(p, q)];
-    }
-    const mapP = (x, y) => {
-        x *= rx;
-        y *= ry;
-        return [c * x - s * y + pos[0], s * x + c * y + pos[1]];
-    };
-    const res = [];
-    const n = Math.ceil(roundEps(Math.abs(delta) / HALF_PI, 1e-3));
-    const d = delta / n;
-    const t = (8 / 6) * Math.tan(0.25 * d);
-    if (!isFinite(t)) {
-        return [cubicFromLine(p, q)];
-    }
-    for (let i = n, theta = start, sc = sincos(theta); i > 0; i--, theta += d) {
-        const [s1, c1] = sc;
-        const [s2, c2] = (sc = sincos(theta + d));
-        res.push([
-            mapP(c1, s1),
-            mapP(c1 - s1 * t, s1 + c1 * t),
-            mapP(c2 + s2 * t, s2 - c2 * t),
-            mapP(c2, s2),
-        ]);
-    }
-    return res;
+const cubicFromArc = (pos, r, axis, start, end) => {
+  const p = pointAtTheta(pos, r, axis, start);
+  const q = pointAtTheta(pos, r, axis, end);
+  const delta = end - start;
+  const [rx, ry] = r;
+  const [s, c] = sincos(axis);
+  const dx = c * (p[0] - q[0]) / 2 + s * (p[1] - q[1]) / 2;
+  const dy = -s * (p[0] - q[0]) / 2 + c * (p[1] - q[1]) / 2;
+  if (Math.abs(delta) < PI && dx === 0 && dy === 0 || magSq2(r) < EPS) {
+    return [cubicFromLine(p, q)];
+  }
+  const mapP = (x, y) => {
+    x *= rx;
+    y *= ry;
+    return [c * x - s * y + pos[0], s * x + c * y + pos[1]];
+  };
+  const res = [];
+  const n = Math.ceil(roundEps(Math.abs(delta) / HALF_PI, 1e-3));
+  const d = delta / n;
+  const t = 8 / 6 * Math.tan(0.25 * d);
+  if (!isFinite(t)) {
+    return [cubicFromLine(p, q)];
+  }
+  for (let i = n, theta = start, sc = sincos(theta); i > 0; i--, theta += d) {
+    const [s1, c1] = sc;
+    const [s2, c2] = sc = sincos(theta + d);
+    res.push([
+      mapP(c1, s1),
+      mapP(c1 - s1 * t, s1 + c1 * t),
+      mapP(c2 + s2 * t, s2 - c2 * t),
+      mapP(c2, s2)
+    ]);
+  }
+  return res;
+};
+export {
+  cubicFromArc
 };

package/cubic-bounds.js

@@ -1,42 +1,32 @@
 import { mixCubic } from "@thi.ng/math/mix";
-/**
- * Computes cubic spline bounds for a single vector component.
- *
- * Based on: http://www.iquilezles.org/www/articles/bezierbbox/bezierbbox.htm
- *
- * @param min - min accumulator
- * @param max - max accumulator
- * @param i - vector component
- * @param pa - control point 1
- * @param pb - control point 2
- * @param pc - control point 3
- * @param pd - control point 4
- */
 const axisBounds = (min, max, i, pa, pb, pc, pd) => {
-    min[i] = Math.min(pa, pd);
-    max[i] = Math.max(pa, pd);
-    const k0 = -pa + pb;
-    const k1 = pa - 2 * pb + pc;
-    const k2 = -pa + 3 * pb - 3 * pc + pd;
-    let h = k1 * k1 - k0 * k2;
-    if (h > 0) {
-        h = Math.sqrt(h);
-        const update = (t) => {
-            if (t > 0 && t < 1) {
-                const q = mixCubic(pa, pb, pc, pd, t);
-                min[i] = Math.min(min[i], q);
-                max[i] = Math.max(max[i], q);
-            }
-        };
-        update(k0 / (-k1 - h));
-        update(k0 / (-k1 + h));
-    }
+  min[i] = Math.min(pa, pd);
+  max[i] = Math.max(pa, pd);
+  const k0 = -pa + pb;
+  const k1 = pa - 2 * pb + pc;
+  const k2 = -pa + 3 * pb - 3 * pc + pd;
+  let h = k1 * k1 - k0 * k2;
+  if (h > 0) {
+    h = Math.sqrt(h);
+    const update = (t) => {
+      if (t > 0 && t < 1) {
+        const q = mixCubic(pa, pb, pc, pd, t);
+        min[i] = Math.min(min[i], q);
+        max[i] = Math.max(max[i], q);
+      }
+    };
+    update(k0 / (-k1 - h));
+    update(k0 / (-k1 + h));
+  }
 };
-export const cubicBounds = (a, b, c, d) => {
-    const min = [];
-    const max = [];
-    for (let i = a.length; i-- > 0;) {
-        axisBounds(min, max, i, a[i], b[i], c[i], d[i]);
-    }
-    return [min, max];
+const cubicBounds = (a, b, c, d) => {
+  const min = [];
+  const max = [];
+  for (let i = a.length; i-- > 0; ) {
+    axisBounds(min, max, i, a[i], b[i], c[i], d[i]);
+  }
+  return [min, max];
+};
+export {
+  cubicBounds
 };

package/cubic-closest-point.js

@@ -1,24 +1,10 @@
 import { minError } from "@thi.ng/math/min-error";
 import { distSq } from "@thi.ng/vectors/distsq";
 import { mixCubic } from "@thi.ng/vectors/mix-cubic";
-/**
- * Performs recursive search for closest point to `p` on cubic curve defined by
- * control points `a`,`b`,`c`,`d`. The `res` and `recur` params are used to
- * control the recursion behavior. If `eps` is given, the search is terminated
- * as soon as a point with a shorter *squared* distance than `eps` is found.
- *
- * [`minError()`](https://docs.thi.ng/umbrella/math/functions/minError.html)
- *
- * @param p - query point
- * @param a - control point 1
- * @param b - control point 2
- * @param c - control point 3
- * @param d - control point 4
- * @param res - search steps per iteration
- * @param iter - iterations
- * @param eps - epsilon value
- */
-export const closestPointCubic = (p, a, b, c, d, out = [], res, iter, eps) => {
-    const fn = (t) => mixCubic(out, a, b, c, d, t);
-    return fn(minError(fn, distSq, p, res, iter, 0, 1, eps));
+const closestPointCubic = (p, a, b, c, d, out = [], res, iter, eps) => {
+  const fn = (t) => mixCubic(out, a, b, c, d, t);
+  return fn(minError(fn, distSq, p, res, iter, 0, 1, eps));
+};
+export {
+  closestPointCubic
 };

package/cubic-from-breakpoints.js

@@ -7,39 +7,51 @@ import { mulN, mulN2 } from "@thi.ng/vectors/muln";
 import { perpendicularCW } from "@thi.ng/vectors/perpendicular";
 import { set2 } from "@thi.ng/vectors/set";
 const buildSegments = (tangents, t, uniform) => {
-    const res = [];
-    for (let i = 0, num = tangents.length - 1; i < num; i++) {
-        const [a, na] = tangents[i];
-        const [b, nb] = tangents[i + 1];
-        const d = uniform ? t : t * dist(a, b);
-        res.push([a, maddN2([], na, d, a), maddN2([], nb, -d, b), b]);
-    }
-    return res;
+  const res = [];
+  for (let i = 0, num = tangents.length - 1; i < num; i++) {
+    const [a, na] = tangents[i];
+    const [b, nb] = tangents[i + 1];
+    const d = uniform ? t : t * dist(a, b);
+    res.push([a, maddN2([], na, d, a), maddN2([], nb, -d, b), b]);
+  }
+  return res;
 };
-export const closedCubicFromBreakPoints = (points, t = 1 / 3, uniform = false) => {
-    const tangents = [];
-    for (let num = points.length, i = num - 1, j = 0; j < num; i = j, j++) {
-        const a = points[i];
-        const b = points[j];
-        const c = points[(j + 1) % num];
-        const n = mulN(null, perpendicularCW(null, cornerBisector([], a, b, c)), corner2(a, b, c));
-        tangents.push([set2([], b), n]);
-    }
-    tangents.push(tangents[0]);
-    return buildSegments(tangents, t, uniform);
+const closedCubicFromBreakPoints = (points, t = 1 / 3, uniform = false) => {
+  const tangents = [];
+  for (let num = points.length, i = num - 1, j = 0; j < num; i = j, j++) {
+    const a = points[i];
+    const b = points[j];
+    const c = points[(j + 1) % num];
+    const n = mulN(
+      null,
+      perpendicularCW(null, cornerBisector([], a, b, c)),
+      corner2(a, b, c)
+    );
+    tangents.push([set2([], b), n]);
+  }
+  tangents.push(tangents[0]);
+  return buildSegments(tangents, t, uniform);
 };
-export const openCubicFromBreakPoints = (points, t = 1 / 3, uniform = false) => {
-    const tangents = [
-        [points[0], direction2([], points[0], points[1])],
-    ];
-    const num = points.length - 1;
-    for (let i = 1; i < num; i++) {
-        const a = points[i - 1];
-        const b = points[i];
-        const c = points[i + 1];
-        const n = mulN2(null, perpendicularCW(null, cornerBisector([], a, b, c)), corner2(a, b, c));
-        tangents.push([set2([], b), n]);
-    }
-    tangents.push([points[num], direction2([], points[num - 1], points[num])]);
-    return buildSegments(tangents, t, uniform);
+const openCubicFromBreakPoints = (points, t = 1 / 3, uniform = false) => {
+  const tangents = [
+    [points[0], direction2([], points[0], points[1])]
+  ];
+  const num = points.length - 1;
+  for (let i = 1; i < num; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    const n = mulN2(
+      null,
+      perpendicularCW(null, cornerBisector([], a, b, c)),
+      corner2(a, b, c)
+    );
+    tangents.push([set2([], b), n]);
+  }
+  tangents.push([points[num], direction2([], points[num - 1], points[num])]);
+  return buildSegments(tangents, t, uniform);
+};
+export {
+  closedCubicFromBreakPoints,
+  openCubicFromBreakPoints
 };

package/cubic-from-controlpoints.js

@@ -4,46 +4,50 @@ import { direction } from "@thi.ng/vectors/direction";
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
 const buildUniform = (segments, t) => {
-    const res = [];
-    for (let i = 0, n = segments.length - 2; i < n; i += 2) {
-        const a = segments[i];
-        const b = segments[i + 1];
-        const c = segments[i + 2];
-        res.push([
-            a,
-            add(null, direction([], a, b, t), a),
-            add(null, direction([], c, b, t), c),
-            c,
-        ]);
-    }
-    return res;
+  const res = [];
+  for (let i = 0, n = segments.length - 2; i < n; i += 2) {
+    const a = segments[i];
+    const b = segments[i + 1];
+    const c = segments[i + 2];
+    res.push([
+      a,
+      add(null, direction([], a, b, t), a),
+      add(null, direction([], c, b, t), c),
+      c
+    ]);
+  }
+  return res;
 };
 const buildNonUniform = (segments, t) => {
-    const res = [];
-    for (let i = 0, n = segments.length - 2; i < n; i += 2) {
-        const a = segments[i];
-        const b = segments[i + 1];
-        const c = segments[i + 2];
-        res.push([a, mixN([], a, b, t), mixN([], c, b, t), c]);
-    }
-    return res;
+  const res = [];
+  for (let i = 0, n = segments.length - 2; i < n; i += 2) {
+    const a = segments[i];
+    const b = segments[i + 1];
+    const c = segments[i + 2];
+    res.push([a, mixN([], a, b, t), mixN([], c, b, t), c]);
+  }
+  return res;
 };
-export const closedCubicFromControlPoints = (points, t = 1, uniform = false) => {
-    const segments = [];
-    for (let i = 0, num = points.length; i < num; i++) {
-        const q = points[(i + 1) % num];
-        segments.push(addmN([], points[i], q, 0.5), set([], q));
-    }
-    segments.push(segments[0]);
-    return uniform ? buildUniform(segments, t) : buildNonUniform(segments, t);
+const closedCubicFromControlPoints = (points, t = 1, uniform = false) => {
+  const segments = [];
+  for (let i = 0, num = points.length; i < num; i++) {
+    const q = points[(i + 1) % num];
+    segments.push(addmN([], points[i], q, 0.5), set([], q));
+  }
+  segments.push(segments[0]);
+  return uniform ? buildUniform(segments, t) : buildNonUniform(segments, t);
 };
-export const openCubicFromControlPoints = (points, t = 1, uniform = false) => {
-    const segments = [set([], points[0]), set([], points[0])];
-    const num = points.length - 1;
-    for (let i = 0; i < num; i++) {
-        const q = points[i + 1];
-        segments.push(addmN([], points[i], q, 0.5), set([], q));
-    }
-    segments.push(set([], points[num]));
-    return uniform ? buildUniform(segments, t) : buildNonUniform(segments, t);
+const openCubicFromControlPoints = (points, t = 1, uniform = false) => {
+  const segments = [set([], points[0]), set([], points[0])];
+  const num = points.length - 1;
+  for (let i = 0; i < num; i++) {
+    const q = points[i + 1];
+    segments.push(addmN([], points[i], q, 0.5), set([], q));
+  }
+  segments.push(set([], points[num]));
+  return uniform ? buildUniform(segments, t) : buildNonUniform(segments, t);
+};
+export {
+  closedCubicFromControlPoints,
+  openCubicFromControlPoints
 };

package/cubic-line.js

@@ -1,16 +1,11 @@
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
-/**
- * Converts line segment `a` -> `b` into a cubic curve, which when
- * sampled yields uniformly spaced points. The inner control points are
- * located at 1/3 and 2/3 respectively.
- *
- * @param a - line endpoint
- * @param b - line endpoint
- */
-export const cubicFromLine = (a, b) => [
-    set([], a),
-    mixN([], a, b, 1 / 3),
-    mixN([], b, a, 1 / 3),
-    set([], b),
+const cubicFromLine = (a, b) => [
+  set([], a),
+  mixN([], a, b, 1 / 3),
+  mixN([], b, a, 1 / 3),
+  set([], b)
 ];
+export {
+  cubicFromLine
+};

package/cubic-quadratic.js

@@ -1,40 +1,21 @@
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
-/**
- * Converts the quadratic curve defined by given control points into a cubic
- * bezier. Returns array of 4 new control points.
- *
- * @param a
- * @param b
- * @param c
- */
-export const cubicFromQuadratic = (a, b, c) => [
-    set([], a),
-    mixN([], a, b, 2 / 3),
-    mixN([], c, b, 2 / 3),
-    set([], c),
+const cubicFromQuadratic = (a, b, c) => [
+  set([], a),
+  mixN([], a, b, 2 / 3),
+  mixN([], c, b, 2 / 3),
+  set([], c)
 ];
-/**
- * Splits given cubic curve (defined by given control points) into 2 quadratic
- * curve segments approximating the original curve. The `gamma` param (in [0..1]
- * interval) can be used to control the split point (default: 0.5). Returns
- * array of new curves (each a 3-tuple of control points).
- *
- * @remarks
- * Reference: https://ttnghia.github.io/pdf/QuadraticApproximation.pdf
- *
- * @param a
- * @param b
- * @param c
- * @param d
- * @param gamma
- */
-export const quadraticFromCubic = (a, b, c, d, gamma = 0.5) => {
-    const qb = mixN([], a, b, 1.5 * gamma);
-    const qd = mixN([], d, c, 1.5 * (1 - gamma));
-    const qc = mixN([], qb, qd, gamma);
-    return [
-        [set([], a), qb, qc],
-        [set([], qc), qd, set([], d)],
-    ];
+const quadraticFromCubic = (a, b, c, d, gamma = 0.5) => {
+  const qb = mixN([], a, b, 1.5 * gamma);
+  const qd = mixN([], d, c, 1.5 * (1 - gamma));
+  const qc = mixN([], qb, qd, gamma);
+  return [
+    [set([], a), qb, qc],
+    [set([], qc), qd, set([], d)]
+  ];
+};
+export {
+  cubicFromQuadratic,
+  quadraticFromCubic
 };

package/cubic-sample.js

@@ -1,9 +1,13 @@
 import { mixCubic } from "@thi.ng/vectors/mix-cubic";
 import { __sample, __sampleArray } from "./internal/sample.js";
-export const sampleCubic = __sample((res, [a, b, c, d], num) => {
-    const delta = 1 / num;
-    for (let t = 0; t < num; t++) {
-        res.push(mixCubic([], a, b, c, d, t * delta));
-    }
+const sampleCubic = __sample((res, [a, b, c, d], num) => {
+  const delta = 1 / num;
+  for (let t = 0; t < num; t++) {
+    res.push(mixCubic([], a, b, c, d, t * delta));
+  }
 });
-export const sampleCubicArray = __sampleArray(sampleCubic);
+const sampleCubicArray = __sampleArray(sampleCubic);
+export {
+  sampleCubic,
+  sampleCubicArray
+};

package/cubic-split.js

@@ -3,22 +3,38 @@ import { distSq } from "@thi.ng/vectors/distsq";
 import { mixCubic } from "@thi.ng/vectors/mix-cubic";
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
-export const cubicSplitAt = (a, b, c, d, t) => {
-    if (t <= 0 || t >= 1) {
-        const p = t <= 0 ? a : d;
-        const c1 = [set([], p), set([], p), set([], p), set([], p)];
-        const c2 = [set([], a), set([], b), set([], c), set([], d)];
-        return t <= 0 ? [c1, c2] : [c2, c1];
-    }
-    const ab = mixN([], a, b, t);
-    const bc = mixN([], b, c, t);
-    const cd = mixN([], c, d, t);
-    const abc = mixN([], ab, bc, t);
-    const bcd = mixN([], bc, cd, t);
-    const p = mixN([], abc, bcd, t);
-    return [
-        [set([], a), ab, abc, set([], p)],
-        [p, bcd, cd, set([], d)],
-    ];
+const cubicSplitAt = (a, b, c, d, t) => {
+  if (t <= 0 || t >= 1) {
+    const p2 = t <= 0 ? a : d;
+    const c1 = [set([], p2), set([], p2), set([], p2), set([], p2)];
+    const c2 = [set([], a), set([], b), set([], c), set([], d)];
+    return t <= 0 ? [c1, c2] : [c2, c1];
+  }
+  const ab = mixN([], a, b, t);
+  const bc = mixN([], b, c, t);
+  const cd = mixN([], c, d, t);
+  const abc = mixN([], ab, bc, t);
+  const bcd = mixN([], bc, cd, t);
+  const p = mixN([], abc, bcd, t);
+  return [
+    [set([], a), ab, abc, set([], p)],
+    [p, bcd, cd, set([], d)]
+  ];
+};
+const splitCubicNearPoint = (p, a, b, c, d, res, iter) => cubicSplitAt(
+  a,
+  b,
+  c,
+  d,
+  minError(
+    (t) => mixCubic([], a, b, c, d, t),
+    distSq,
+    p,
+    res,
+    iter
+  )
+);
+export {
+  cubicSplitAt,
+  splitCubicNearPoint
 };
-export const splitCubicNearPoint = (p, a, b, c, d, res, iter) => cubicSplitAt(a, b, c, d, minError((t) => mixCubic([], a, b, c, d, t), distSq, p, res, iter));

package/cubic-tangent.js

@@ -1,9 +1,16 @@
 import { addW4 } from "@thi.ng/vectors/addw";
 import { normalize } from "@thi.ng/vectors/normalize";
-export const cubicTangentAt = (out, a, b, c, d, t, len = 1) => {
-    const s = 1 - t;
-    const ss = s * s;
-    const tt = t * t;
-    const ts2 = 2 * t * s;
-    return normalize(out, addW4(out, a, b, c, d, -3 * ss, 3 * (ss - ts2), 3 * (ts2 - tt), 3 * tt), len);
+const cubicTangentAt = (out, a, b, c, d, t, len = 1) => {
+  const s = 1 - t;
+  const ss = s * s;
+  const tt = t * t;
+  const ts2 = 2 * t * s;
+  return normalize(
+    out,
+    addW4(out, a, b, c, d, -3 * ss, 3 * (ss - ts2), 3 * (ts2 - tt), 3 * tt),
+    len
+  );
+};
+export {
+  cubicTangentAt
 };

package/internal/sample.js

@@ -3,26 +3,38 @@ import { isPlainObject } from "@thi.ng/checks/is-plain-object";
 import { DEFAULT_SAMPLES } from "@thi.ng/geom-api/sample";
 import { Sampler } from "@thi.ng/geom-resample/sampler";
 import { set } from "@thi.ng/vectors/set";
-export const __sample = (sample) => function $(pts, opts) {
-    if (isPlainObject(opts) && opts.dist !== undefined) {
-        return new Sampler($(pts, opts.num || DEFAULT_SAMPLES)).sampleUniform(opts.dist, opts.last !== false);
-    }
-    opts = isNumber(opts)
-        ? {
-            num: opts,
-            last: true,
-        }
-        : {
-            num: DEFAULT_SAMPLES,
-            ...opts,
-        };
-    const res = [];
-    sample(res, pts, opts.num);
-    opts.last && res.push(set([], pts[pts.length - 1]));
-    return res;
+const __sample = (sample) => function $(pts, opts) {
+  if (isPlainObject(opts) && opts.dist !== void 0) {
+    return new Sampler(
+      $(pts, opts.num || DEFAULT_SAMPLES)
+    ).sampleUniform(
+      opts.dist,
+      opts.last !== false
+    );
+  }
+  opts = isNumber(opts) ? {
+    num: opts,
+    last: true
+  } : {
+    num: DEFAULT_SAMPLES,
+    ...opts
+  };
+  const res = [];
+  sample(res, pts, opts.num);
+  opts.last && res.push(set([], pts[pts.length - 1]));
+  return res;
 };
-export const __sampleArray = (fn) => (segments, closed = false, opts) => {
-    const _opts = isNumber(opts) ? { num: opts } : opts;
-    const n = segments.length - 1;
-    return Array.prototype.concat.apply([], segments.map((seg, i) => fn(seg, { ..._opts, last: !closed && i === n })));
+const __sampleArray = (fn) => (segments, closed = false, opts) => {
+  const _opts = isNumber(opts) ? { num: opts } : opts;
+  const n = segments.length - 1;
+  return Array.prototype.concat.apply(
+    [],
+    segments.map(
+      (seg, i) => fn(seg, { ..._opts, last: !closed && i === n })
+    )
+  );
+};
+export {
+  __sample,
+  __sampleArray
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-splines",
-  "version": "2.2.66",
+  "version": "2.2.67",
   "description": "nD cubic & quadratic curve analysis, conversion, interpolation, splitting",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc internal",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,16 +35,17 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/geom-api": "^3.4.49",
-    "@thi.ng/geom-arc": "^2.1.92",
-    "@thi.ng/geom-resample": "^2.3.13",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/geom-api": "^3.4.50",
+    "@thi.ng/geom-arc": "^2.1.93",
+    "@thi.ng/geom-resample": "^2.3.14",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/vectors": "^7.8.9"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -142,5 +145,5 @@
       "geom-subdiv-curve"
     ]
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/point-at.js

@@ -1,10 +1,8 @@
 import { mixCubic } from "@thi.ng/vectors/mix-cubic";
 import { mixQuadratic } from "@thi.ng/vectors/mix-quadratic";
-/**
- * Same as thi.ng/vectors/mixCubic
- */
-export const cubicPointAt = mixCubic;
-/**
- * Same as thi.ng/vectors/mixQuadratic
- */
-export const quadraticPointAt = mixQuadratic;
+const cubicPointAt = mixCubic;
+const quadraticPointAt = mixQuadratic;
+export {
+  cubicPointAt,
+  quadraticPointAt
+};

package/quadratic-bounds.js

@@ -2,27 +2,30 @@ import { clamp01, inRange } from "@thi.ng/math/interval";
 import { max } from "@thi.ng/vectors/max";
 import { min } from "@thi.ng/vectors/min";
 const solveQuadratic = (a, b, c) => {
-    const t = clamp01((a - b) / (a - 2.0 * b + c));
-    const s = 1 - t;
-    return s * s * a + 2.0 * s * t * b + t * t * c;
+  const t = clamp01((a - b) / (a - 2 * b + c));
+  const s = 1 - t;
+  return s * s * a + 2 * s * t * b + t * t * c;
 };
-const inBounds = (p, min, max) => {
-    for (let i = p.length; i-- > 0;) {
-        if (!inRange(p[i], min[i], max[i]))
-            return false;
-    }
-    return true;
+const inBounds = (p, min2, max2) => {
+  for (let i = p.length; i-- > 0; ) {
+    if (!inRange(p[i], min2[i], max2[i]))
+      return false;
+  }
+  return true;
 };
-export const quadraticBounds = (a, b, c) => {
-    const mi = min([], a, c);
-    const ma = max([], a, c);
-    if (!inBounds(b, mi, ma)) {
-        const q = [];
-        for (let i = a.length; i-- > 0;) {
-            q[i] = solveQuadratic(a[i], b[i], c[i]);
-        }
-        min(null, mi, q);
-        max(null, ma, q);
+const quadraticBounds = (a, b, c) => {
+  const mi = min([], a, c);
+  const ma = max([], a, c);
+  if (!inBounds(b, mi, ma)) {
+    const q = [];
+    for (let i = a.length; i-- > 0; ) {
+      q[i] = solveQuadratic(a[i], b[i], c[i]);
     }
-    return [mi, ma];
+    min(null, mi, q);
+    max(null, ma, q);
+  }
+  return [mi, ma];
+};
+export {
+  quadraticBounds
 };

package/quadratic-closest-point.js

@@ -1,23 +1,10 @@
 import { minError } from "@thi.ng/math/min-error";
 import { distSq } from "@thi.ng/vectors/distsq";
 import { mixQuadratic } from "@thi.ng/vectors/mix-quadratic";
-/**
- * Performs recursive search for closest point to `p` on quadratic curve defined
- * by control points `a`,`b`,`c`. The `res` and `recur` params are used to
- * control the recursion behavior. If `eps` is given, the search is terminated
- * as soon as a point with a shorter *squared* distance than `eps` is found.
- *
- * [`minError()`](https://docs.thi.ng/umbrella/math/functions/minError.html)
- *
- * @param p - query point
- * @param a - control point 1
- * @param b - control point 2
- * @param c - control point 3
- * @param res - search steps per iteration
- * @param iter - iterations
- * @param eps - epsilon value
- */
-export const closestPointQuadratic = (p, a, b, c, out = [], res, iter, eps) => {
-    const fn = (t) => mixQuadratic(out, a, b, c, t);
-    return fn(minError(fn, distSq, p, res, iter, 0, 1, eps));
+const closestPointQuadratic = (p, a, b, c, out = [], res, iter, eps) => {
+  const fn = (t) => mixQuadratic(out, a, b, c, t);
+  return fn(minError(fn, distSq, p, res, iter, 0, 1, eps));
+};
+export {
+  closestPointQuadratic
 };

package/quadratic-line.js

@@ -1,7 +1,10 @@
 import { addmN } from "@thi.ng/vectors/addmn";
 import { set } from "@thi.ng/vectors/set";
-export const quadraticFromLine = (a, b) => [
-    set([], a),
-    addmN([], a, b, 0.5),
-    set([], b),
+const quadraticFromLine = (a, b) => [
+  set([], a),
+  addmN([], a, b, 0.5),
+  set([], b)
 ];
+export {
+  quadraticFromLine
+};

package/quadratic-sample.js

@@ -1,9 +1,13 @@
 import { mixQuadratic } from "@thi.ng/vectors/mix-quadratic";
 import { __sample, __sampleArray } from "./internal/sample.js";
-export const sampleQuadratic = __sample((res, [a, b, c], num) => {
-    const delta = 1 / num;
-    for (let t = 0; t < num; t++) {
-        res.push(mixQuadratic([], a, b, c, t * delta));
-    }
+const sampleQuadratic = __sample((res, [a, b, c], num) => {
+  const delta = 1 / num;
+  for (let t = 0; t < num; t++) {
+    res.push(mixQuadratic([], a, b, c, t * delta));
+  }
 });
-export const sampleQuadraticArray = __sampleArray(sampleQuadratic);
+const sampleQuadraticArray = __sampleArray(sampleQuadratic);
+export {
+  sampleQuadratic,
+  sampleQuadraticArray
+};

package/quadratic-split.js

@@ -3,19 +3,34 @@ import { distSq } from "@thi.ng/vectors/distsq";
 import { mixQuadratic } from "@thi.ng/vectors/mix-quadratic";
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
-export const quadraticSplitAt = (a, b, c, t) => {
-    if (t <= 0 || t >= 1) {
-        const p = t <= 0 ? a : c;
-        const c1 = [set([], p), set([], p), set([], p)];
-        const c2 = [set([], a), set([], b), set([], c)];
-        return t <= 0 ? [c1, c2] : [c2, c1];
-    }
-    const ab = mixN([], a, b, t);
-    const bc = mixN([], b, c, t);
-    const p = mixN([], ab, bc, t);
-    return [
-        [set([], a), ab, p],
-        [p, bc, set([], c)],
-    ];
+const quadraticSplitAt = (a, b, c, t) => {
+  if (t <= 0 || t >= 1) {
+    const p2 = t <= 0 ? a : c;
+    const c1 = [set([], p2), set([], p2), set([], p2)];
+    const c2 = [set([], a), set([], b), set([], c)];
+    return t <= 0 ? [c1, c2] : [c2, c1];
+  }
+  const ab = mixN([], a, b, t);
+  const bc = mixN([], b, c, t);
+  const p = mixN([], ab, bc, t);
+  return [
+    [set([], a), ab, p],
+    [p, bc, set([], c)]
+  ];
+};
+const quadraticSplitNearPoint = (p, a, b, c, res, iter) => quadraticSplitAt(
+  a,
+  b,
+  c,
+  minError(
+    (t) => mixQuadratic([], a, b, c, t),
+    distSq,
+    p,
+    res,
+    iter
+  )
+);
+export {
+  quadraticSplitAt,
+  quadraticSplitNearPoint
 };
-export const quadraticSplitNearPoint = (p, a, b, c, res, iter) => quadraticSplitAt(a, b, c, minError((t) => mixQuadratic([], a, b, c, t), distSq, p, res, iter));

package/quadratic-tangent.js

@@ -1,4 +1,11 @@
 import { addW2 } from "@thi.ng/vectors/addw";
 import { normalize } from "@thi.ng/vectors/normalize";
 import { sub } from "@thi.ng/vectors/sub";
-export const quadraticTangentAt = (out, a, b, c, t, len = 1) => normalize(out, addW2(out, sub(out, b, a), sub([], c, b), 2 * (1 - t), 2 * t), len);
+const quadraticTangentAt = (out, a, b, c, t, len = 1) => normalize(
+  out,
+  addW2(out, sub(out, b, a), sub([], c, b), 2 * (1 - t), 2 * t),
+  len
+);
+export {
+  quadraticTangentAt
+};