@thi.ng/geom 6.0.6 → 6.0.8

package/as-cubic.js

@@ -1,6 +1,12 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { closedCubicFromBreakPoints, openCubicFromBreakPoints, } from "@thi.ng/geom-splines/cubic-from-breakpoints";
-import { closedCubicFromControlPoints, openCubicFromControlPoints, } from "@thi.ng/geom-splines/cubic-from-controlpoints";
+import {
+  closedCubicFromBreakPoints,
+  openCubicFromBreakPoints
+} from "@thi.ng/geom-splines/cubic-from-breakpoints";
+import {
+  closedCubicFromControlPoints,
+  openCubicFromControlPoints
+} from "@thi.ng/geom-splines/cubic-from-controlpoints";
 import { TAU } from "@thi.ng/math/api";
 import { mapcat } from "@thi.ng/transducers/mapcat";
 import { Cubic } from "./api/cubic.js";
@@ -9,73 +15,48 @@ import { asPolygon } from "./as-polygon.js";
 import { cubicFromArc, cubicFromLine, cubicFromQuadratic } from "./cubic.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Converts given shape into an array of {@link Cubic} curves. For some shapes
- * (see below) the conversion supports optionally provided {@link CubicOpts}.
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * Shape types supporting custom conversion options (see
- * [@thi.ng/geom-splines](https://github.com/thi-ng/umbrella/tree/develop/packages/geom-splines#cubic-curve-conversion-from-polygons--polylines)
- * for more details):
- *
- * - {@link Group} (only used for eligible children)
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param opts
- */
-export const asCubic = defmulti(__dispatch, {
+const asCubic = defmulti(
+  __dispatch,
+  {
     ellipse: "circle",
     quad: "poly",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     arc: cubicFromArc,
     circle: ($) => asCubic(arc($.pos, $.r, 0, 0, TAU, true, true)),
     cubic: ($) => [$],
     group: ($, opts) => [
-        ...mapcat((x) => asCubic(x, opts), $.children),
+      ...mapcat((x) => asCubic(x, opts), $.children)
     ],
     line: ({ attribs, points }) => [
-        cubicFromLine(points[0], points[1], { ...attribs }),
+      cubicFromLine(points[0], points[1], { ...attribs })
     ],
     path: ($) => [
-        ...mapcat((s) => (s.geo ? asCubic(s.geo) : null), $.segments),
+      ...mapcat((s) => s.geo ? asCubic(s.geo) : null, $.segments)
     ],
-    poly: ($, opts = {}) => __polyCubic($, opts, closedCubicFromBreakPoints, closedCubicFromControlPoints),
-    polyline: ($, opts = {}) => __polyCubic($, opts, openCubicFromBreakPoints, openCubicFromControlPoints),
+    poly: ($, opts = {}) => __polyCubic(
+      $,
+      opts,
+      closedCubicFromBreakPoints,
+      closedCubicFromControlPoints
+    ),
+    polyline: ($, opts = {}) => __polyCubic(
+      $,
+      opts,
+      openCubicFromBreakPoints,
+      openCubicFromControlPoints
+    ),
     quadratic: ({ attribs, points }) => [
-        cubicFromQuadratic(points[0], points[1], points[2], { ...attribs }),
+      cubicFromQuadratic(points[0], points[1], points[2], { ...attribs })
     ],
-    rect: ($, opts) => asCubic(asPolygon($), opts),
-});
-/**
- * @internal
- */
-// prettier-ignore
+    rect: ($, opts) => asCubic(asPolygon($), opts)
+  }
+);
 const __polyCubic = ($, opts, breakPoints, controlPoints) => {
-    opts = { breakPoints: false, scale: 1 / 3, uniform: false, ...opts };
-    return (opts.breakPoints
-        ? breakPoints($.points, opts.scale, opts.uniform)
-        : controlPoints($.points, opts.scale, opts.uniform)).map((pts) => new Cubic(pts, __copyAttribs($)));
+  opts = { breakPoints: false, scale: 1 / 3, uniform: false, ...opts };
+  return (opts.breakPoints ? breakPoints($.points, opts.scale, opts.uniform) : controlPoints($.points, opts.scale, opts.uniform)).map((pts) => new Cubic(pts, __copyAttribs($)));
+};
+export {
+  asCubic
 };

package/as-path.js

@@ -1,11 +1,7 @@
 import { asCubic } from "./as-cubic.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { pathFromCubics } from "./path.js";
-/**
- * Converts given shape into a {@link Path} (via {@link asCubic} and
- * {@link pathFromCubics}).
- *
- * @param src
- * @param attribs
- */
-export const asPath = (src, attribs) => pathFromCubics(asCubic(src), attribs || __copyAttribs(src));
+const asPath = (src, attribs) => pathFromCubics(asCubic(src), attribs || __copyAttribs(src));
+export {
+  asPath
+};

package/as-polygon.js

@@ -3,31 +3,9 @@ import { Polygon } from "./api/polygon.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Converts given shape into a {@link Polygon}, optionally using provided
- * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html)
- * or number of target vertices.
- *
- * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
- *
- * Currently implemented for:
- *
- * - {@link Circle}
- * - {@link Ellipse}
- * - {@link Line}
- * - {@link Path}
- * - {@link Poly}
- * - {@link Polyline} (will be closed)
- * - {@link Quad}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param opts
- */
-export const asPolygon = defmulti(__dispatch, {
+const asPolygon = defmulti(
+  __dispatch,
+  {
     circle: "points",
     ellipse: "points",
     line: "points",
@@ -36,7 +14,12 @@ export const asPolygon = defmulti(__dispatch, {
     polyline: "points",
     quad: "points",
     rect: "points",
-    tri: "points",
-}, {
-    points: ($, opts) => new Polygon(vertices($, opts), __attribs($)),
-});
+    tri: "points"
+  },
+  {
+    points: ($, opts) => new Polygon(vertices($, opts), __attribs($))
+  }
+);
+export {
+  asPolygon
+};

package/as-polyline.js

@@ -4,34 +4,9 @@ import { Polyline } from "./api/polyline.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Converts given shape into a {@link Polyline}, optionally using provided
- * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html)
- * or number of target vertices.
- *
- * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
- *
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Line}
- * - {@link Path}
- * - {@link Poly}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param opts
- */
-export const asPolyline = defmulti(__dispatch, {
+const asPolyline = defmulti(
+  __dispatch,
+  {
     arc: "points",
     circle: "poly",
     cubic: "points",
@@ -41,17 +16,22 @@ export const asPolyline = defmulti(__dispatch, {
     quad: "poly",
     quadratic: "points",
     rect: "poly",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     points: ($, opts) => new Polyline(vertices($, opts), __attribs($)),
     path: ($, opts) => {
-        const pts = vertices($, opts);
-        $.closed && pts.push(set([], pts[0]));
-        return new Polyline(pts, __attribs($));
+      const pts = vertices($, opts);
+      $.closed && pts.push(set([], pts[0]));
+      return new Polyline(pts, __attribs($));
     },
     poly: ($, opts) => {
-        const pts = vertices($, opts);
-        pts.push(set([], pts[0]));
-        return new Polyline(pts, __attribs($));
-    },
-});
+      const pts = vertices($, opts);
+      pts.push(set([], pts[0]));
+      return new Polyline(pts, __attribs($));
+    }
+  }
+);
+export {
+  asPolyline
+};

package/as-svg.js

@@ -5,69 +5,38 @@ import { svg } from "@thi.ng/hiccup-svg/svg";
 import { serialize } from "@thi.ng/hiccup/serialize";
 import { bounds } from "./bounds.js";
 import { __collBounds } from "./internal/bounds.js";
-/**
- * Can be overridden via {@link setSvgDefaultAttribs}.
- */
-export let DEFAULT_ATTRIBS = { fill: "none", stroke: "#000" };
-/**
- * Sets the SVG root element attribs used by default by {@link svgDoc}.
- *
- * @param attribs
- */
-export const setSvgDefaultAttribs = (attribs) => {
-    DEFAULT_ATTRIBS = attribs;
+let DEFAULT_ATTRIBS = { fill: "none", stroke: "#000" };
+const setSvgDefaultAttribs = (attribs) => {
+  DEFAULT_ATTRIBS = attribs;
 };
-/**
- * Serializes given hiccup tree to an actual SVG source string.
- *
- * @param args
- */
-export const asSvg = (...args) => args.map((x) => serialize(convertTree(x))).join("");
-/**
- * Creates a hiccup SVG doc element container for given {@link IShape}s and
- * attribs (merged with {@link DEFAULT_ATTRIBS}). If the attribs do not include
- * a `viewBox`, it will be computed automatically. Furthermore (and only for the
- * case a viewbox needs to be computed), a `__bleed` attrib can be provided to
- * include a bleed/margin for the viewbox (in world space units).
- *
- * @remarks
- * Use {@link asSvg} to serialize the resulting doc to an SVG string.
- *
- * The actual serialization is performed via the
- * [thi.ng/hiccup](https://thi.ng/hiccup) and
- * [thi.ng/hiccup-svg](https://thi.ng/hiccup-svg) packages. Floating point
- * precision for various point coordinates can be controlled via the `__prec`
- * attribute (number of fractional digits), either for the entire doc or on a
- * per-shape basis. If omitted, the currently configured precision will be used
- * (default: 3).
- *
- * Also see
- * [`convertTree()`](https://docs.thi.ng/umbrella/hiccup-svg/functions/convertTree.html)
- * and
- * [`setPrecision()`](https://docs.thi.ng/umbrella/hiccup-svg/functions/setPrecision.html).
- *
- * @param attribs
- * @param xs
- */
-export const svgDoc = (attribs, ...xs) => {
-    attribs = { ...DEFAULT_ATTRIBS, ...attribs };
-    if (xs.length > 0) {
-        if (!attribs.viewBox) {
-            const cbounds = __collBounds(xs, bounds);
-            if (cbounds) {
-                const [[x, y], [w, h]] = cbounds;
-                const bleed = attribs.__bleed || 0;
-                const bleed2 = 2 * bleed;
-                const width = ff(w + bleed2);
-                const height = ff(h + bleed2);
-                attribs = {
-                    width,
-                    height,
-                    viewBox: `${ff(x - bleed)} ${ff(y - bleed)} ${width} ${height}`,
-                    ...withoutKeysObj(attribs, ["__bleed"]),
-                };
-            }
-        }
+const asSvg = (...args) => args.map((x) => serialize(convertTree(x))).join("");
+const svgDoc = (attribs, ...xs) => {
+  attribs = { ...DEFAULT_ATTRIBS, ...attribs };
+  if (xs.length > 0) {
+    if (!attribs.viewBox) {
+      const cbounds = __collBounds(xs, bounds);
+      if (cbounds) {
+        const [[x, y], [w, h]] = cbounds;
+        const bleed = attribs.__bleed || 0;
+        const bleed2 = 2 * bleed;
+        const width = ff(w + bleed2);
+        const height = ff(h + bleed2);
+        attribs = {
+          width,
+          height,
+          viewBox: `${ff(x - bleed)} ${ff(
+            y - bleed
+          )} ${width} ${height}`,
+          ...withoutKeysObj(attribs, ["__bleed"])
+        };
+      }
     }
-    return svg(attribs, ...xs);
+  }
+  return svg(attribs, ...xs);
+};
+export {
+  DEFAULT_ATTRIBS,
+  asSvg,
+  setSvgDefaultAttribs,
+  svgDoc
 };

package/bounds.js

@@ -19,65 +19,63 @@ import { Rect } from "./api/rect.js";
 import { __collBounds } from "./internal/bounds.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { rectFromMinMaxWithMargin } from "./rect.js";
-/**
- * Computes and returns bounding rect/box for the given shape, optionally with
- * extra uniform margin/padding (default: 0). For groups, the compound bounds of
- * all children will be returned.
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link AABB}
- * - {@link Arc}
- * - {@link BPatch}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Text} - (no way to compute size, only position & any margin)
- *
- * @param shape
- * @param margin
- */
-export const bounds = defmulti(__dispatch, {
+const bounds = defmulti(
+  __dispatch,
+  {
     aabb: "rect",
     bpatch: "points",
     poly: "points",
     polyline: "points",
     quad: "points",
-    tri: "points",
-}, {
-    arc: ($, margin = 0) => rectFromMinMaxWithMargin(...arcBounds($.pos, $.r, $.axis, $.start, $.end), margin),
-    circle: ($, margin = 0) => new Rect(subN2([], $.pos, $.r + margin), mulN2(null, [2, 2], $.r + margin)),
-    cubic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(...cubicBounds(points[0], points[1], points[2], points[3]), margin),
+    tri: "points"
+  },
+  {
+    arc: ($, margin = 0) => rectFromMinMaxWithMargin(
+      ...arcBounds($.pos, $.r, $.axis, $.start, $.end),
+      margin
+    ),
+    circle: ($, margin = 0) => new Rect(
+      subN2([], $.pos, $.r + margin),
+      mulN2(null, [2, 2], $.r + margin)
+    ),
+    cubic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(
+      ...cubicBounds(points[0], points[1], points[2], points[3]),
+      margin
+    ),
     ellipse: ($, margin = 0) => {
-        const r = addN2([], $.r, margin);
-        return new Rect(sub2([], $.pos, r), mul2(null, [2, 2], r));
+      const r = addN2([], $.r, margin);
+      return new Rect(sub2([], $.pos, r), mul2(null, [2, 2], r));
     },
     group: ($, margin = 0) => {
-        const res = __collBounds($.children, bounds);
-        return res ? new Rect(...res).offset(margin) : undefined;
+      const res = __collBounds($.children, bounds);
+      return res ? new Rect(...res).offset(margin) : void 0;
     },
     line: ({ points: [a, b] }, margin = 0) => rectFromMinMaxWithMargin(min([], a, b), max([], a, b), margin),
     path: (path, margin = 0) => {
-        const b = __collBounds([
-            ...iterator1(comp(map((s) => s.geo), filter((s) => !!s)), path.segments),
-        ], bounds);
-        return b ? new Rect(...b).offset(margin) : undefined;
+      const b = __collBounds(
+        [
+          ...iterator1(
+            comp(
+              map((s) => s.geo),
+              filter((s) => !!s)
+            ),
+            path.segments
+          )
+        ],
+        bounds
+      );
+      return b ? new Rect(...b).offset(margin) : void 0;
     },
     points: ($, margin = 0) => rectFromMinMaxWithMargin(...bounds2($.points), margin),
     points3: ($, margin = 0) => aabbFromMinMaxWithMargin(...bounds3($.points), margin),
-    quadratic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(...quadraticBounds(points[0], points[1], points[2]), margin),
-    rect: ($, margin = 0) => margin === 0
-        ? $.copy()
-        : $.copy().offset(margin),
-    text: ($, margin = 0) => new Rect(subN2([], $.pos, margin), margin * 2),
-});
+    quadratic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(
+      ...quadraticBounds(points[0], points[1], points[2]),
+      margin
+    ),
+    rect: ($, margin = 0) => margin === 0 ? $.copy() : $.copy().offset(margin),
+    text: ($, margin = 0) => new Rect(subN2([], $.pos, margin), margin * 2)
+  }
+);
+export {
+  bounds
+};

package/bpatch.js

@@ -1,20 +1,28 @@
 import { assert } from "@thi.ng/errors/assert";
 import { mixBilinear } from "@thi.ng/vectors/mix-bilinear";
 import { BPatch } from "./api/bpatch.js";
-export const bpatch = (pts, attribs) => new BPatch(pts, attribs);
-export const bpatchFromQuad = (pts, attribs) => {
-    assert(pts.length === 4, "require 4 points");
-    const [a, b, c, d] = pts;
-    const cps = [];
-    for (let u = 0; u < 4; u++) {
-        for (let v = 0; v < 4; v++) {
-            cps.push(mixBilinear([], a, b, d, c, u / 3, v / 3));
-        }
+const bpatch = (pts, attribs) => new BPatch(pts, attribs);
+const bpatchFromQuad = (pts, attribs) => {
+  assert(pts.length === 4, "require 4 points");
+  const [a, b, c, d] = pts;
+  const cps = [];
+  for (let u = 0; u < 4; u++) {
+    for (let v = 0; v < 4; v++) {
+      cps.push(mixBilinear([], a, b, d, c, u / 3, v / 3));
     }
-    return new BPatch(cps, attribs);
+  }
+  return new BPatch(cps, attribs);
 };
-export const bpatchFromHex = (pts, attribs) => {
-    assert(pts.length === 6, "require 6 points");
-    const [a, b, c, d, e, f] = pts;
-    return new BPatch([e, e, f, f, d, d, a, a, d, d, a, a, c, c, b, b], attribs);
+const bpatchFromHex = (pts, attribs) => {
+  assert(pts.length === 6, "require 6 points");
+  const [a, b, c, d, e, f] = pts;
+  return new BPatch(
+    [e, e, f, f, d, d, a, a, d, d, a, a, c, c, b, b],
+    attribs
+  );
+};
+export {
+  bpatch,
+  bpatchFromHex,
+  bpatchFromQuad
 };

package/center.js

@@ -10,24 +10,29 @@ import { centroid } from "./centroid.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { translate } from "./translate.js";
-/**
- * Returns copy of given shape centered around optionally provided point `p`
- * (default: worldspace origin).
- *
- * @remarks
- * Implemented for all shape types supported by {@link centroid} and
- * {@link translate}.
- *
- * @param shape
- * @param p
- */
-export const center = defmulti(__dispatch, {}, {
+const center = defmulti(
+  __dispatch,
+  {},
+  {
     [DEFAULT]: ($, origin = ZERO3) => {
-        const c = centroid($);
-        return c ? translate($, submN(null, c, origin, -1)) : undefined;
+      const c = centroid($);
+      return c ? translate($, submN(null, c, origin, -1)) : void 0;
     },
-    arc: ($, origin = ZERO2) => new Arc(set2([], origin), set2([], $.r), $.axis, $.start, $.end, $.xl, $.cw, __copyAttribs($)),
+    arc: ($, origin = ZERO2) => new Arc(
+      set2([], origin),
+      set2([], $.r),
+      $.axis,
+      $.start,
+      $.end,
+      $.xl,
+      $.cw,
+      __copyAttribs($)
+    ),
     circle: ($, origin = ZERO2) => new Circle(set2([], origin), $.r, __copyAttribs($)),
     ellipse: ($, origin = ZERO2) => new Ellipse(set2([], origin), set2([], $.r), __copyAttribs($)),
-    sphere: ($, origin = ZERO3) => new Sphere(set3([], origin), $.r, __copyAttribs($)),
-});
+    sphere: ($, origin = ZERO3) => new Sphere(set3([], origin), $.r, __copyAttribs($))
+  }
+);
+export {
+  center
+};

package/centroid.js

@@ -9,34 +9,9 @@ import { mulN } from "@thi.ng/vectors/muln";
 import { set } from "@thi.ng/vectors/set";
 import { bounds } from "./bounds.js";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Computes centroid of given shape, writes result in optionally provided output
- * vector (or creates new one if omitted).
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link AABB}
- * - {@link Arc}
- * - {@link BPatch}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Text} - (no way to compute size, only position & any margin)
- *
- * @param shape
- * @param out
- */
-export const centroid = defmulti(__dispatch, {
+const centroid = defmulti(
+  __dispatch,
+  {
     arc: "circle",
     aabb: "rect",
     bpatch: "points",
@@ -47,17 +22,22 @@ export const centroid = defmulti(__dispatch, {
     quad: "poly",
     sphere: "circle",
     text: "circle",
-    tri3: "tri",
-}, {
+    tri3: "tri"
+  },
+  {
     circle: ($, out) => set(out || [], $.pos),
     group: ($, out) => {
-        const b = bounds($);
-        return b ? centroid(b, out) : undefined;
+      const b = bounds($);
+      return b ? centroid(b, out) : void 0;
     },
     line: ({ points }, out) => mixN(out || [], points[0], points[1], 0.5),
     points: ($, out) => _centroid($.points, out),
     plane: ($, out) => mulN(out || [], $.normal, $.w),
     poly: ($, out) => centerOfWeight2($.points, out),
     rect: ($, out) => maddN(out || [], $.size, 0.5, $.pos),
-    tri: ({ points }, out) => addmN(null, add(out || [], points[0], points[1]), points[2], 1 / 3),
-});
+    tri: ({ points }, out) => addmN(null, add(out || [], points[0], points[1]), points[2], 1 / 3)
+  }
+);
+export {
+  centroid
+};

package/circle.js

@@ -3,11 +3,16 @@ import { dist } from "@thi.ng/vectors/dist";
 import { mixN2 } from "@thi.ng/vectors/mixn";
 import { Circle } from "./api/circle.js";
 import { __argsVN } from "./internal/args.js";
-export function circle(...args) {
-    return new Circle(...__argsVN(args));
+function circle(...args) {
+  return new Circle(...__argsVN(args));
 }
-export const circleFrom2Points = (a, b, attribs) => new Circle(mixN2([], a, b, 0.5), dist(a, b) / 2, attribs);
-export const circleFrom3Points = (a, b, c, attribs) => {
-    const o = circumCenter2(a, b, c);
-    return o ? new Circle(o, dist(a, o), attribs) : undefined;
+const circleFrom2Points = (a, b, attribs) => new Circle(mixN2([], a, b, 0.5), dist(a, b) / 2, attribs);
+const circleFrom3Points = (a, b, c, attribs) => {
+  const o = circumCenter2(a, b, c);
+  return o ? new Circle(o, dist(a, o), attribs) : void 0;
+};
+export {
+  circle,
+  circleFrom2Points,
+  circleFrom3Points
 };