@thi.ng/geom 6.1.9 → 7.0.1

package/path-from-svg.js

@@ -4,8 +4,8 @@ import { WS } from "@thi.ng/strings/groups";
 import { PathBuilder } from "./path-builder.js";
 const CMD_RE = /[achlmqstvz]/i;
 const WSC = { ...WS, ",": true };
-const pathFromSvg = (svg) => {
-  const b = new PathBuilder();
+const pathFromSvg = (svg, attribs) => {
+  const b = new PathBuilder(attribs);
   try {
     let cmd = "";
     for (let n = svg.length, i = 0; i < n; ) {
@@ -63,7 +63,7 @@ const pathFromSvg = (svg) => {
           break;
         }
         case "z":
-          b.closePath();
+          b.close();
           break;
         default:
           throw new Error(
@@ -71,15 +71,15 @@ const pathFromSvg = (svg) => {
           );
       }
     }
-    return b.paths;
+    const [main, ...subPaths] = b.paths;
+    return main.addSubPaths(...subPaths.map((p) => p.segments));
   } catch (e) {
     throw e instanceof Error ? e : new Error(`illegal char '${svg.charAt(e)}' @ ${e}`);
   }
 };
 const skipWS = (src, i) => {
   const n = src.length;
-  while (i < n && WSC[src.charAt(i)])
-    i++;
+  while (i < n && WSC[src.charAt(i)]) i++;
   return i;
 };
 const readPoint = (src, index) => {
@@ -113,28 +113,24 @@ const readFloat = (src, index) => {
       continue;
     }
     if (c === "-" || c === "+") {
-      if (!signOk)
-        break;
+      if (!signOk) break;
       signOk = false;
       continue;
     }
     if (c === ".") {
-      if (!dotOk)
-        break;
+      if (!dotOk) break;
       dotOk = false;
       continue;
     }
     if (c === "e") {
-      if (!expOk)
-        throw i;
+      if (!expOk) throw i;
       expOk = false;
       dotOk = false;
       signOk = true;
       continue;
     }
     if (c === ",") {
-      if (!commaOk)
-        throw i;
+      if (!commaOk) throw i;
       i++;
     }
     break;

package/path.d.ts

@@ -2,8 +2,65 @@ import type { Attribs, PathSegment } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
 import type { Cubic } from "./api/cubic.js";
 import { Path } from "./api/path.js";
-export declare const path: (segments: Iterable<PathSegment>, attribs?: Attribs) => Path;
+/**
+ * Creates a new {@link Path} instance, optional with given `segments`,
+ * `subPaths` and `attribs`.
+ *
+ * @remarks
+ * Segments and sub-paths can also be later added via {@link Path.addSegments}
+ * or {@link Path.addSubPaths}.
+ *
+ * @param segments
+ * @param subPaths
+ * @param attribs
+ */
+export declare const path: (segments?: Iterable<PathSegment>, subPaths?: Iterable<PathSegment[]>, attribs?: Attribs) => Path;
+/**
+ * Constructs a {@link Path} from given sequence of cubic curves, with optional
+ * `attribs`.
+ *
+ * @remarks
+ * If no `attribs` are given, those from the first curve will be used.
+ *
+ * For each successive curve segment, if the start point of the current curve is
+ * not the same as the last point of the previous curve, a new sub path will be
+ * started.
+ *
+ * Also see {@link normalizedPath}.
+ *
+ * @param cubics
+ * @param attribs
+ */
 export declare const pathFromCubics: (cubics: Cubic[], attribs?: Attribs) => Path;
+/**
+ * Converts given path into a new one with all segments converted to
+ * {@link Cubic} bezier segments.
+ *
+ * @remarks
+ * Also see {@link pathFromCubics}.
+ *
+ * @param path
+ */
 export declare const normalizedPath: (path: Path) => Path;
-export declare const roundedRect: (pos: Vec, size: Vec, r: number | Vec, attribs?: Attribs) => Path;
+/**
+ * Creates a new rounded rect {@link Path}, using the given corner radius or
+ * radii.
+ *
+ * @remarks
+ * If multiple `radii` are given, the interpretation logic is the same as:
+ * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
+ *
+ * - number: all corners
+ * - `[top-left-and-bottom-right, top-right-and-bottom-left]`
+ * - `[top-left, top-right-and-bottom-left, bottom-right]`
+ * - `[top-left, top-right, bottom-right, bottom-left]`
+ *
+ * No arc segments will be generated for those corners where the radius <= 0
+ *
+ * @param pos
+ * @param size
+ * @param radii
+ * @param attribs
+ */
+export declare const roundedRect: (pos: Vec, [w, h]: Vec, radii: number | [number, number] | [number, number, number] | [number, number, number, number], attribs?: Attribs) => Path;
 //# sourceMappingURL=path.d.ts.map

package/path.js

@@ -1,33 +1,58 @@
 import { isNumber } from "@thi.ng/checks/is-number";
 import { map } from "@thi.ng/transducers/map";
 import { mapcat } from "@thi.ng/transducers/mapcat";
-import { maddN2 } from "@thi.ng/vectors/maddn";
+import { equals2 } from "@thi.ng/vectors/equals";
 import { Path } from "./api/path.js";
 import { asCubic } from "./as-cubic.js";
 import { PathBuilder } from "./path-builder.js";
-const path = (segments, attribs) => new Path(segments, attribs);
+const path = (segments, subPaths, attribs) => new Path(segments, subPaths, attribs);
 const pathFromCubics = (cubics, attribs) => {
-  const path2 = new Path([], attribs || cubics[0].attribs);
-  path2.segments.push({ type: "m", point: cubics[0].points[0] });
+  let subPaths = [];
+  let curr;
+  let lastP;
+  const $beginPath = (c) => {
+    curr = [{ type: "m", point: c.points[0] }];
+    subPaths.push(curr);
+  };
   for (let c of cubics) {
-    path2.segments.push({ type: "c", geo: c });
+    if (!(lastP && equals2(lastP, c.points[0]))) $beginPath(c);
+    curr.push({ type: "c", geo: c });
+    lastP = c.points[3];
   }
+  const path2 = new Path(
+    subPaths[0],
+    subPaths.slice(1),
+    attribs || cubics[0].attribs
+  );
   return path2;
 };
-const normalizedPath = (path2) => new Path(
-  mapcat(
-    (s) => s.geo ? map(
-      (c) => ({ type: "c", geo: c }),
-      asCubic(s.geo)
-    ) : [{ ...s }],
-    path2.segments
-  ),
-  path2.attribs
-);
-const roundedRect = (pos, size, r, attribs) => {
-  r = isNumber(r) ? [r, r] : r;
-  const [w, h] = maddN2([], r, -2, size);
-  return new PathBuilder(attribs).moveTo([pos[0] + r[0], pos[1]]).hlineTo(w, true).arcTo(r, r, 0, false, true, true).vlineTo(h, true).arcTo([-r[0], r[1]], r, 0, false, true, true).hlineTo(-w, true).arcTo([-r[0], -r[1]], r, 0, false, true, true).vlineTo(-h, true).arcTo([r[0], -r[1]], r, 0, false, true, true).current();
+const normalizedPath = (path2) => {
+  const $normalize = (segments) => [
+    ...mapcat(
+      (s) => s.geo ? map(
+        (c) => ({ type: "c", geo: c }),
+        asCubic(s.geo)
+      ) : [{ ...s }],
+      segments
+    )
+  ];
+  return new Path(
+    $normalize(path2.segments),
+    path2.subPaths.map($normalize),
+    path2.attribs
+  );
+};
+const roundedRect = (pos, [w, h], radii, attribs) => {
+  const [tl, tr, br, bl] = isNumber(radii) ? [radii, radii, radii, radii] : radii.length === 2 ? [radii[0], radii[1], radii[0], radii[1]] : radii.length === 3 ? [radii[0], radii[1], radii[2], radii[1]] : radii;
+  const b = new PathBuilder(attribs).moveTo([pos[0] + tl, pos[1]]).hlineTo(w - tl - tr, true);
+  if (tr > 0) b.arcTo([tr, tr], [tr, tr], 0, false, true, true);
+  b.vlineTo(h - tr - br, true);
+  if (br > 0) b.arcTo([-br, br], [br, br], 0, false, true, true);
+  b.hlineTo(-(w - br - bl), true);
+  if (bl > 0) b.arcTo([-bl, -bl], [bl, bl], 0, false, true, true);
+  b.vlineTo(-(h - bl - tl), true);
+  if (tl > 0) b.arcTo([tl, -tl], [tl, tl], 0, false, true, true);
+  return b.current().close();
 };
 export {
   normalizedPath,

package/point-inside.d.ts

@@ -7,15 +7,18 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * @remarks
  * Currently implemented for:
  *
- * - AABB
- * - Circle
- * - Points (i.e. if `p` is one of the points in the cloud)
- * - Points3 (same as w/ Points)
- * - Polygon
- * - Quad
- * - Rect
- * - Sphere
- * - Triangle
+ * - {@link AABB}
+ * - {@link Circle}
+ * - {@link ComplexPolygon}
+ * - {@link Line} (if `p` is on line segment)
+ * - {@link Points} (i.e. if `p` is one of the points in the cloud)
+ * - {@link Points3} (same as w/ Points)
+ * - {@link Polygon}
+ * - {@link Polyline} (if `p` is on any of the line segments)
+ * - {@link Quad}
+ * - {@link Rect}
+ * - {@link Sphere}
+ * - {@link Triangle}
  *
  * @param shape
  * @param p

package/point-inside.js

@@ -5,6 +5,7 @@ import {
   pointInPolygon2,
   pointInRect,
   pointInSegment,
+  pointInSegments,
   pointInTriangle2
 } from "@thi.ng/geom-isec/point";
 import { isInArray } from "@thi.ng/vectors/eqdelta";
@@ -19,9 +20,11 @@ const pointInside = defmulti(
   {
     aabb: ($, p) => pointInAABB(p, $.pos, $.size),
     circle: ($, p) => pointInCircle(p, $.pos, $.r),
+    complexpoly: ($, p) => pointInPolygon2(p, $.boundary.points) ? !$.children.some((child) => pointInPolygon2(p, child.points)) : false,
     line: ($, p) => pointInSegment(p, $.points[0], $.points[1]),
     points: ({ points }, p) => isInArray(p, points),
     poly: ($, p) => pointInPolygon2(p, $.points) > 0,
+    polyline: ($, p) => pointInSegments(p, $.points, false),
     rect: ($, p) => pointInRect(p, $.pos, $.size),
     tri: (tri, p) => pointInTriangle2(p, ...tri.points)
   }

package/proximity.d.ts

@@ -0,0 +1,11 @@
+import type { IShape } from "@thi.ng/geom-api";
+import type { ReadonlyVec } from "@thi.ng/vectors";
+/**
+ * Computes {@link closestPoint} on `shape` to `p`, and if successful, returns
+ * eucledian distance between that point and `p`.
+ *
+ * @param shape
+ * @param p
+ */
+export declare const proximity: (shape: IShape, p: ReadonlyVec) => number | undefined;
+//# sourceMappingURL=proximity.d.ts.map

package/proximity.js

@@ -0,0 +1,9 @@
+import { dist } from "@thi.ng/vectors/dist";
+import { closestPoint } from "./closest-point.js";
+const proximity = (shape, p) => {
+  const q = closestPoint(shape, p);
+  return q ? dist(p, q) : void 0;
+};
+export {
+  proximity
+};

package/resample.d.ts

@@ -11,6 +11,7 @@ import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
  * Currently implemented for:
  *
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Ellipse}
  * - {@link Line}
  * - {@link Polygon}

package/resample.js

@@ -1,5 +1,6 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { resample as _resample } from "@thi.ng/geom-resample/resample";
+import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Polygon } from "./api/polygon.js";
 import { Polyline } from "./api/polyline.js";
 import { asPolygon } from "./as-polygon.js";
@@ -15,7 +16,12 @@ const resample = defmulti(
     rect: "circle"
   },
   {
-    circle: ($, opts) => asPolygon($, opts),
+    circle: ($, opts) => asPolygon($, opts)[0],
+    complexpoly: ($, opts) => new ComplexPolygon(
+      resample($.boundary, opts),
+      $.children.map((child) => resample(child, opts)),
+      __attribs($)
+    ),
     poly: ($, opts) => new Polygon(_resample($.points, opts, true, true), __attribs($)),
     polyline: ($, opts) => new Polyline(_resample($.points, opts, false, true), __attribs($))
   }

package/rotate.d.ts

@@ -8,6 +8,7 @@ import type { IShape } from "@thi.ng/geom-api";
  *
  * - {@link Arc}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
  * - {@link Group}

package/rotate.js

@@ -1,6 +1,7 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { rotate as $rotate } from "@thi.ng/vectors/rotate";
 import { Circle } from "./api/circle.js";
+import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Cubic } from "./api/cubic.js";
 import { Line } from "./api/line.js";
 import { Path } from "./api/path.js";
@@ -17,6 +18,7 @@ import { asPolygon } from "./as-polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __rotatedShape as tx } from "./internal/rotate.js";
+import { __segmentTransformer } from "./internal/transform.js";
 const rotate = defmulti(
   __dispatch,
   {},
@@ -27,21 +29,22 @@ const rotate = defmulti(
       return a;
     },
     circle: ($, theta) => new Circle($rotate([], $.pos, theta), $.r, __copyAttribs($)),
+    complexpoly: ($, theta) => new ComplexPolygon(
+      rotate($.boundary, theta),
+      $.children.map((child) => rotate(child, theta))
+    ),
     cubic: tx(Cubic),
     ellipse: ($, theta) => rotate(asPath($), theta),
     group: ($, theta) => $.copyTransformed((x) => rotate(x, theta)),
     line: tx(Line),
     path: ($, theta) => {
+      const $rotateSegments = __segmentTransformer(
+        (geo) => rotate(geo, theta),
+        (p) => $rotate([], p, theta)
+      );
       return new Path(
-        $.segments.map(
-          (s) => s.geo ? {
-            type: s.type,
-            geo: rotate(s.geo, theta)
-          } : {
-            type: s.type,
-            point: $rotate([], s.point, theta)
-          }
-        ),
+        $rotateSegments($.segments),
+        $.subPaths.map($rotateSegments),
         __copyAttribs($)
       );
     },
@@ -57,7 +60,7 @@ const rotate = defmulti(
         __copyAttribs($)
       );
     },
-    rect: ($, theta) => rotate(asPolygon($), theta),
+    rect: ($, theta) => rotate(asPolygon($)[0], theta),
     text: ($, theta) => new Text($rotate([], $.pos, theta), $.body, __copyAttribs($)),
     tri: tx(Triangle)
   }

package/scale-with-center.d.ts

@@ -0,0 +1,20 @@
+import type { IShape } from "@thi.ng/geom-api";
+import type { ReadonlyVec } from "@thi.ng/vectors";
+/**
+ * Applies a sequence of translate and scale operations to return an uniformly
+ * scaled version of the given shape using `center` as the point of reference.
+ *
+ * @remarks
+ * This op is likely slower than using {@link transform} with a equivalent
+ * transformation matrix (e.g. using [`scaleWithCenter()` from
+ * thi.ng/matrices](https://docs.thi.ng/umbrella/matrices/functions/scaleWithCenter23.html)),
+ * but will not change the shape type (as might be the case with `transform()`).
+ *
+ * Also see: {@link scale}, {@link translate}, {@link applyTransforms}.
+ *
+ * @param shape
+ * @param center
+ * @param factor
+ */
+export declare const scaleWithCenter: (shape: IShape, center: ReadonlyVec, factor: number) => IShape<IShape<any>>;
+//# sourceMappingURL=scale-with-center.d.ts.map

package/scale-with-center.js

@@ -0,0 +1,7 @@
+import { mulN } from "@thi.ng/vectors/muln";
+import { scale } from "./scale.js";
+import { translate } from "./translate.js";
+const scaleWithCenter = (shape, center, factor) => translate(scale(translate(shape, mulN([], center, -1)), factor), center);
+export {
+  scaleWithCenter
+};

package/scale.d.ts

@@ -13,6 +13,7 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * - {@link AABB}
  * - {@link Arc}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
  * - {@link Group}

package/scale.js

@@ -6,6 +6,7 @@ import { mulN2, mulN3 } from "@thi.ng/vectors/muln";
 import { normalize2 } from "@thi.ng/vectors/normalize";
 import { AABB } from "./api/aabb.js";
 import { Circle } from "./api/circle.js";
+import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Cubic } from "./api/cubic.js";
 import { Ellipse } from "./api/ellipse.js";
 import { Line } from "./api/line.js";
@@ -24,6 +25,7 @@ import { __asVec } from "./internal/args.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __scaledShape as tx } from "./internal/scale.js";
+import { __segmentTransformer } from "./internal/transform.js";
 const scale = defmulti(
   __dispatch,
   {},
@@ -52,6 +54,10 @@ const scale = defmulti(
       mulN2([], delta, $.r),
       __copyAttribs($)
     ),
+    complexpoly: ($, delta) => new ComplexPolygon(
+      scale($.boundary, delta),
+      $.children.map((child) => scale(child, delta))
+    ),
     cubic: tx(Cubic),
     ellipse: ($, delta) => {
       delta = __asVec(delta);
@@ -65,16 +71,13 @@ const scale = defmulti(
     line: tx(Line),
     path: ($, delta) => {
       delta = __asVec(delta);
+      const $scaleSegments = __segmentTransformer(
+        (geo) => scale(geo, delta),
+        (p) => mul2([], p, delta)
+      );
       return new Path(
-        $.segments.map(
-          (s) => s.geo ? {
-            type: s.type,
-            geo: scale(s.geo, delta)
-          } : {
-            type: s.type,
-            point: mul2([], s.point, delta)
-          }
-        ),
+        $scaleSegments($.segments),
+        $.subPaths.map($scaleSegments),
         __copyAttribs($)
       );
     },

package/scatter.js

@@ -4,8 +4,7 @@ import { bounds } from "./bounds.js";
 import { pointInside } from "./point-inside.js";
 const scatter = (shape, num, rnd = SYSTEM, out = []) => {
   const b = bounds(shape);
-  if (!b)
-    return;
+  if (!b) return;
   const mi = b.pos;
   const mx = b.max();
   for (; num-- > 0; ) {

package/simplify.d.ts

@@ -1,15 +1,16 @@
-import type { MultiFn2 } from "@thi.ng/defmulti";
+import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 /**
  * Simplifies given 2D shape boundary using Douglas-Peucker algorithm
  * (implemented by
  * [`simplify()`](https://docs.thi.ng/umbrella/geom-resample/functions/simplify.html))
- * and given `threshold` distance (default: 0, which removes only co-linear
+ * and given `threshold` distance (default: 1e-6, which removes only co-linear
  * vertices).
  *
  * @remarks
  * Currently only implemented for:
  *
+ * - {@link ComplexPolygon}
  * - {@link Path}
  * - {@link Polygon}
  * - {@link Polyline}
@@ -20,5 +21,5 @@ import type { IShape } from "@thi.ng/geom-api";
  * @param shape
  * @param threshold
  */
-export declare const simplify: MultiFn2<IShape, number, IShape>;
+export declare const simplify: MultiFn1O<IShape, number, IShape>;
 //# sourceMappingURL=simplify.d.ts.map

package/simplify.js

@@ -1,6 +1,7 @@
 import { peek } from "@thi.ng/arrays/peek";
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { simplify as _simplify } from "@thi.ng/geom-resample/simplify";
+import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Path } from "./api/path.js";
 import { Polygon } from "./api/polygon.js";
 import { Polyline } from "./api/polyline.js";
@@ -11,39 +12,50 @@ const simplify = defmulti(
   __dispatch,
   {},
   {
-    path: ($, eps = 0) => {
-      const res = [];
-      const orig = $.segments;
-      const n = orig.length;
-      let points;
-      let lastP;
-      for (let i = 0; i < n; i++) {
-        const s = orig[i];
-        if (s.type === "l" || s.type === "p") {
-          points = points ? points.concat(vertices(s.geo)) : vertices(s.geo);
-          lastP = peek(points);
-        } else if (points) {
+    complexpoly: ($, eps) => new ComplexPolygon(
+      simplify($.boundary, eps),
+      $.children.map((child) => simplify(child, eps)),
+      __copyAttribs($)
+    ),
+    path: ($, eps = 1e-6) => {
+      const $simplifySegments = (segments) => {
+        const res = [];
+        const n = segments.length;
+        let points;
+        let lastP;
+        for (let i = 0; i < n; i++) {
+          const s = segments[i];
+          if (s.type === "l" || s.type === "p") {
+            points = points ? points.concat(vertices(s.geo)) : vertices(s.geo);
+            lastP = peek(points);
+          } else if (points) {
+            points.push(lastP);
+            res.push({
+              geo: new Polyline(_simplify(points, eps)),
+              type: "p"
+            });
+            points = null;
+          } else {
+            res.push({ ...s });
+          }
+        }
+        if (points) {
           points.push(lastP);
           res.push({
-            geo: new Polyline(_simplify(points, eps)),
+            geo: new Polyline(points),
             type: "p"
           });
-          points = null;
-        } else {
-          res.push({ ...s });
         }
-      }
-      if (points) {
-        points.push(lastP);
-        res.push({
-          geo: new Polyline(points),
-          type: "p"
-        });
-      }
-      return new Path(res, __copyAttribs($));
+        return res;
+      };
+      return new Path(
+        $simplifySegments($.segments),
+        $.subPaths.map($simplifySegments),
+        __copyAttribs($)
+      );
     },
-    poly: ($, eps = 0) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
-    polyline: ($, eps = 0) => new Polyline(_simplify($.points, eps), __copyAttribs($))
+    poly: ($, eps = 1e-6) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
+    polyline: ($, eps = 1e-6) => new Polyline(_simplify($.points, eps), __copyAttribs($))
   }
 );
 export {

package/split-arclength.d.ts

@@ -15,7 +15,7 @@ import { Group } from "./api/group.js";
  * - {@link Polyline}
  *
  * Other shape types will be attempted to be auto-converted via
- * {@link asPolyline} first.
+ * {@link asPolyline} first. Only shapes with a single boundary are supported.
  *
  * Nested groups are NOT supported. Groups are processing their child shapes and
  * forming new child groups of given max. arc lengths and potentially splitting

package/split-arclength.js

@@ -10,7 +10,7 @@ const splitArcLength = defmulti(
   __dispatch,
   {},
   {
-    [DEFAULT]: ($, d) => splitArcLength(asPolyline($), d),
+    [DEFAULT]: ($, d) => splitArcLength(asPolyline($)[0], d),
     group: ($, d) => {
       const groups = [];
       let curr = [];
@@ -18,7 +18,7 @@ const splitArcLength = defmulti(
       const queue = $.children.slice().reverse();
       while (queue.length) {
         const child = queue.pop();
-        const polyline = asPolyline(child);
+        const polyline = asPolyline(child)[0];
         const sampler = new Sampler(polyline.points);
         const len = sampler.totalLength();
         if (currLen + len <= d) {
@@ -34,8 +34,7 @@ const splitArcLength = defmulti(
           queue.push(new Polyline(next, __attribs(child)));
         }
       }
-      if (curr.length)
-        groups.push(new Group({}, curr));
+      if (curr.length) groups.push(new Group({}, curr));
       return new Group(__attribs($), groups);
     },
     polyline: ($, d) => {
@@ -46,8 +45,7 @@ const splitArcLength = defmulti(
         const total = sampler.totalLength();
         if (total > d) {
           const parts = sampler.splitAt(d / total);
-          if (!parts)
-            break;
+          if (!parts) break;
           chunks.push(parts[0]);
           pts = parts[1];
         } else {