@thi.ng/geom 6.0.7 → 6.0.9

package/split-arclength.js

@@ -6,117 +6,62 @@ import { asPolyline } from "./as-polyline.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __pointArraysAsShapes } from "./internal/points-as-shape.js";
-/**
- * Splits given shape into {@link Polyline} segments of given (max) arc length.
- * Returns a {@link Group} of shapes/polylines.
- *
- * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
- *
- * Currently only implemented for:
- *
- * - {@link Group}
- * - {@link Polyline}
- *
- * Other shape types will be attempted to be auto-converted via
- * {@link asPolyline} first.
- *
- * Nested groups are NOT supported. Groups are processing their child shapes and
- * forming new child groups of given max. arc lengths and potentially splitting
- * shapes if they don't fit within the current subgroup...
- *
- * @example
- * ```ts
- * // circle (to be sampled as octagon)
- * const a = circle(100, { stroke: "red", __samples: 8 });
- *
- * // inner square of circle
- * const b = inscribedSquare(a, { stroke: "blue" });
- *
- * // process as group, split/partition into subgroups of arclength max. 200
- * splitArcLength(group({}, [a, b]), 200);
- * ```
- *
- * Result serialized to SVG:
- *
- * ```svg
- * <g>
- *   <g>
- *     <polyline fill="none" points="100,0 70.7,70.7 0.0,100 -43.4,82.0" stroke="red"/>
- *   </g>
- *   <g>
- *     <polyline fill="none" points="-43.4,82.0 -70.7,70.7 -100,0.0 -70.7,-70.7 -54.7,-77.3" stroke="red"/>
- *   </g>
- *   <g>
- *     <polyline fill="none" points="-54.7,-77.3 -0.0,-100 70.7,-70.7 95.3,-11.4" stroke="red"/>
- *   </g>
- *   <g>
- *     <!-- last segment of circle -->
- *     <polyline fill="none" points="95.3,-11.4 100,0" stroke="red"/>
- *     <!-- first segment of rect -->
- *     <polyline fill="none" points="-70.7,-70.7 70.7,-70.7 70.7,-24.4" stroke="blue"/>
- *   </g>
- *   <g>
- *     <polyline fill="none" points="70.7,-24.4 70.7,70.7 -34.2,70.7" stroke="blue"/>
- *   </g>
- *   <g>
- *     <polyline fill="none" points="-34.2,70.7 -70.7,70.7 -70.7,-70.7" stroke="blue"/>
- *   </g>
- * </g>
- * ```
- *
- * @param shape
- * @param dist
- */
-export const splitArcLength = defmulti(__dispatch, {}, {
+const splitArcLength = defmulti(
+  __dispatch,
+  {},
+  {
     [DEFAULT]: ($, d) => splitArcLength(asPolyline($), d),
     group: ($, d) => {
-        const groups = [];
-        let curr = [];
-        let currLen = 0;
-        const queue = $.children.slice().reverse();
-        while (queue.length) {
-            const child = queue.pop();
-            const polyline = asPolyline(child);
-            const sampler = new Sampler(polyline.points);
-            const len = sampler.totalLength();
-            if (currLen + len <= d) {
-                curr.push(polyline);
-                currLen += len;
-            }
-            else {
-                const remainingLen = d - currLen;
-                const [fill, next] = sampler.splitAt(remainingLen / len);
-                curr.push(new Polyline(fill, __attribs(child)));
-                groups.push(new Group({}, curr));
-                curr = [];
-                currLen = 0;
-                queue.push(new Polyline(next, __attribs(child)));
-            }
+      const groups = [];
+      let curr = [];
+      let currLen = 0;
+      const queue = $.children.slice().reverse();
+      while (queue.length) {
+        const child = queue.pop();
+        const polyline = asPolyline(child);
+        const sampler = new Sampler(polyline.points);
+        const len = sampler.totalLength();
+        if (currLen + len <= d) {
+          curr.push(polyline);
+          currLen += len;
+        } else {
+          const remainingLen = d - currLen;
+          const [fill, next] = sampler.splitAt(remainingLen / len);
+          curr.push(new Polyline(fill, __attribs(child)));
+          groups.push(new Group({}, curr));
+          curr = [];
+          currLen = 0;
+          queue.push(new Polyline(next, __attribs(child)));
         }
-        if (curr.length)
-            groups.push(new Group({}, curr));
-        return new Group(__attribs($), groups);
+      }
+      if (curr.length)
+        groups.push(new Group({}, curr));
+      return new Group(__attribs($), groups);
     },
     polyline: ($, d) => {
-        const chunks = [];
-        let pts = $.points;
-        while (true) {
-            const sampler = new Sampler(pts);
-            const total = sampler.totalLength();
-            if (total > d) {
-                const parts = sampler.splitAt(d / total);
-                if (!parts)
-                    break;
-                chunks.push(parts[0]);
-                pts = parts[1];
-            }
-            else {
-                chunks.push(pts);
-                break;
-            }
+      const chunks = [];
+      let pts = $.points;
+      while (true) {
+        const sampler = new Sampler(pts);
+        const total = sampler.totalLength();
+        if (total > d) {
+          const parts = sampler.splitAt(d / total);
+          if (!parts)
+            break;
+          chunks.push(parts[0]);
+          pts = parts[1];
+        } else {
+          chunks.push(pts);
+          break;
         }
-        return new Group(__attribs($), __pointArraysAsShapes(Polyline, chunks));
-    },
-});
+      }
+      return new Group(
+        __attribs($),
+        __pointArraysAsShapes(Polyline, chunks)
+      );
+    }
+  }
+);
+export {
+  splitArcLength
+};

package/split-at.js

@@ -13,31 +13,51 @@ import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __pointArraysAsShapes } from "./internal/points-as-shape.js";
 import { __splitLine } from "./internal/split.js";
-/**
- * Splits given shape in 2 parts at normalized parametric position `t`.
- *
- * @remarks
- * Currently only implemented for:
- *
- * - {@link Arc}
- * - {@link Cubic}
- * - {@link Line}
- * - {@link Polyline}
- * - {@link Quadratic}
- *
- * @param shape
- * @param t
- */
-export const splitAt = defmulti(__dispatch, {}, {
+const splitAt = defmulti(
+  __dispatch,
+  {},
+  {
     arc: ($, t) => {
-        const theta = fit01(t, $.start, $.end);
-        return [
-            new Arc(set([], $.pos), set([], $.r), $.axis, $.start, theta, $.xl, $.cw, __copyAttribs($)),
-            new Arc(set([], $.pos), set([], $.r), $.axis, theta, $.end, $.xl, $.cw, __copyAttribs($)),
-        ];
+      const theta = fit01(t, $.start, $.end);
+      return [
+        new Arc(
+          set([], $.pos),
+          set([], $.r),
+          $.axis,
+          $.start,
+          theta,
+          $.xl,
+          $.cw,
+          __copyAttribs($)
+        ),
+        new Arc(
+          set([], $.pos),
+          set([], $.r),
+          $.axis,
+          theta,
+          $.end,
+          $.xl,
+          $.cw,
+          __copyAttribs($)
+        )
+      ];
     },
-    cubic: ({ attribs, points }, t) => cubicSplitAt(points[0], points[1], points[2], points[3], t).map((pts) => new Cubic(pts, { ...attribs })),
-    line: ({ attribs, points }, t) => __splitLine(points[0], points[1], t).map((pts) => new Line(pts, { ...attribs })),
-    polyline: ($, t) => __pointArraysAsShapes(Polyline, new Sampler($.points).splitAt(t), $.attribs),
-    quadratic: ({ attribs, points }, t) => quadraticSplitAt(points[0], points[1], points[2], t).map((pts) => new Quadratic(pts, { ...attribs })),
-});
+    cubic: ({ attribs, points }, t) => cubicSplitAt(points[0], points[1], points[2], points[3], t).map(
+      (pts) => new Cubic(pts, { ...attribs })
+    ),
+    line: ({ attribs, points }, t) => __splitLine(points[0], points[1], t).map(
+      (pts) => new Line(pts, { ...attribs })
+    ),
+    polyline: ($, t) => __pointArraysAsShapes(
+      Polyline,
+      new Sampler($.points).splitAt(t),
+      $.attribs
+    ),
+    quadratic: ({ attribs, points }, t) => quadraticSplitAt(points[0], points[1], points[2], t).map(
+      (pts) => new Quadratic(pts, { ...attribs })
+    )
+  }
+);
+export {
+  splitAt
+};

package/split-near.js

@@ -12,27 +12,33 @@ import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __pointArraysAsShapes } from "./internal/points-as-shape.js";
 import { __splitLine } from "./internal/split.js";
-/**
- * Similar to {@link splitAt}, but instead of taking a normalized parametric
- * split position, splits the given curve at the closest point to `p`.
- *
- * @remarks
- * Currently only implemented for:
- *
- * - {@link Cubic}
- * - {@link Line}
- * - {@link Polyline}
- * - {@link Quadratic}
- *
- * @param shape - shape to operate on
- * @param p - split point
- */
-export const splitNearPoint = defmulti(__dispatch, {}, {
-    cubic: ({ points, attribs }, p) => splitCubicNearPoint(p, points[0], points[1], points[2], points[3]).map((pts) => new Cubic(pts, { ...attribs })),
+const splitNearPoint = defmulti(
+  __dispatch,
+  {},
+  {
+    cubic: ({ points, attribs }, p) => splitCubicNearPoint(
+      p,
+      points[0],
+      points[1],
+      points[2],
+      points[3]
+    ).map((pts) => new Cubic(pts, { ...attribs })),
     line: ($, p) => {
-        const t = closestT(p, $.points[0], $.points[1]) || 0;
-        return __splitLine($.points[0], $.points[1], clamp01(t)).map((pts) => new Line(pts, __copyAttribs($)));
+      const t = closestT(p, $.points[0], $.points[1]) || 0;
+      return __splitLine($.points[0], $.points[1], clamp01(t)).map(
+        (pts) => new Line(pts, __copyAttribs($))
+      );
     },
-    polyline: ($, p) => __pointArraysAsShapes(Polyline, new Sampler($.points).splitNear(p), $.attribs),
-    quadratic: ({ points, attribs }, p) => quadraticSplitNearPoint(p, points[0], points[1], points[2]).map((pts) => new Quadratic(pts, { ...attribs })),
-});
+    polyline: ($, p) => __pointArraysAsShapes(
+      Polyline,
+      new Sampler($.points).splitNear(p),
+      $.attribs
+    ),
+    quadratic: ({ points, attribs }, p) => quadraticSplitNearPoint(p, points[0], points[1], points[2]).map(
+      (pts) => new Quadratic(pts, { ...attribs })
+    )
+  }
+);
+export {
+  splitNearPoint
+};

package/subdiv-curve.js

@@ -7,81 +7,42 @@ import { asPolygon } from "./as-polygon.js";
 import { asPolyline } from "./as-polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Recursively applies
- * [`SubdivKernel`](https://docs.thi.ng/umbrella/geom-api/interfaces/SubdivKernel.html)
- * to given shape/boundary. See
- * [thi.ng/geom-subdiv-curve](https://thi.ng/thi.ng/geom-subdiv-curve) package
- * for further details.
- *
- * @remarks
- * By default only applies a single iteration.
- *
- * Currently only implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Ellipse}
- * - {@link Line}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @example
- * ```ts
- *
- * ```
- *
- * @param shape
- * @param kernel
- * @param iter
- */
-export const subdivCurve = defmulti(__dispatch, {
+const subdivCurve = defmulti(
+  __dispatch,
+  {
     ellipse: "circle",
     line: "polyline",
     quad: "poly",
     rect: "circle",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     arc: ($, kernel, iter = 1) => subdivCurve(asPolyline($), kernel, iter),
     circle: ($, kernel, iter = 1) => subdivCurve(asPolygon($), kernel, iter),
-    poly: ($, kernel, iter = 1) => new Polygon(subdivide($.points, kernel, iter), __copyAttribs($)),
-    polyline: ($, kernel, iter = 1) => new Polyline(subdivide($.points, kernel, iter), __copyAttribs($)),
-});
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_MID_OPEN`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_MID_OPEN.html)
- */
-export const SUBDIV_MID_OPEN = sdc.SUBDIV_MID_OPEN;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_MID_CLOSED`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_MID_CLOSED.html)
- */
-export const SUBDIV_MID_CLOSED = sdc.SUBDIV_MID_CLOSED;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_THIRDS_OPEN`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_THIRDS_OPEN.html)
- */
-export const SUBDIV_THIRDS_OPEN = sdc.SUBDIV_THIRDS_OPEN;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_THIRDS_CLOSED`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_THIRDS_CLOSED.html)
- */
-export const SUBDIV_THIRDS_CLOSED = sdc.SUBDIV_THIRDS_CLOSED;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_CHAIKIN_OPEN`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_CHAIKIN_OPEN.html)
- */
-export const SUBDIV_CHAIKIN_OPEN = sdc.SUBDIV_CHAIKIN_OPEN;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_CHAIKIN_CLOSED`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_CHAIKIN_CLOSED.html)
- */
-export const SUBDIV_CHAIKIN_CLOSED = sdc.SUBDIV_CHAIKIN_CLOSED;
-/**
- * Re-export of thi.ng/geom-subdiv-curve
- * [`SUBDIV_CUBIC_CLOSED`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_CUBIC_CLOSED.html)
- */
-export const SUBDIV_CUBIC_CLOSED = sdc.SUBDIV_CUBIC_CLOSED;
+    poly: ($, kernel, iter = 1) => new Polygon(
+      subdivide($.points, kernel, iter),
+      __copyAttribs($)
+    ),
+    polyline: ($, kernel, iter = 1) => new Polyline(
+      subdivide($.points, kernel, iter),
+      __copyAttribs($)
+    )
+  }
+);
+const SUBDIV_MID_OPEN = sdc.SUBDIV_MID_OPEN;
+const SUBDIV_MID_CLOSED = sdc.SUBDIV_MID_CLOSED;
+const SUBDIV_THIRDS_OPEN = sdc.SUBDIV_THIRDS_OPEN;
+const SUBDIV_THIRDS_CLOSED = sdc.SUBDIV_THIRDS_CLOSED;
+const SUBDIV_CHAIKIN_OPEN = sdc.SUBDIV_CHAIKIN_OPEN;
+const SUBDIV_CHAIKIN_CLOSED = sdc.SUBDIV_CHAIKIN_CLOSED;
+const SUBDIV_CUBIC_CLOSED = sdc.SUBDIV_CUBIC_CLOSED;
+export {
+  SUBDIV_CHAIKIN_CLOSED,
+  SUBDIV_CHAIKIN_OPEN,
+  SUBDIV_CUBIC_CLOSED,
+  SUBDIV_MID_CLOSED,
+  SUBDIV_MID_OPEN,
+  SUBDIV_THIRDS_CLOSED,
+  SUBDIV_THIRDS_OPEN,
+  subdivCurve
+};

package/tangent-at.js

@@ -7,34 +7,22 @@ import { HALF_PI, TAU } from "@thi.ng/math/api";
 import { direction2 } from "@thi.ng/vectors/direction";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Computes tangent on shape/boundary at normalized parametric position `t`.
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Line}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param t
- */
-export const tangentAt = defmulti(__dispatch, {
+const tangentAt = defmulti(
+  __dispatch,
+  {
     quad: "poly",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     circle: (_, t) => cossin(TAU * t + HALF_PI),
     cubic: ({ points }, t) => cubicTangentAt([], points[0], points[1], points[2], points[3], t),
     line: ({ points }) => direction2([], points[0], points[1]),
     poly: ($, t) => new Sampler($.points, true).tangentAt(t),
     polyline: ($, t) => new Sampler($.points).tangentAt(t),
     quadratic: ({ points }, t) => quadraticTangentAt([], points[0], points[1], points[2], t),
-    rect: ($, t) => new Sampler(vertices($), true).tangentAt(t),
-});
+    rect: ($, t) => new Sampler(vertices($), true).tangentAt(t)
+  }
+);
+export {
+  tangentAt
+};

package/tessellate.js

@@ -10,51 +10,26 @@ import { mapcat } from "@thi.ng/transducers/mapcat";
 import { Group } from "./api/group.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Recursively tessellates shape using provided
- * [`Tessellator`](https://docs.thi.ng/umbrella/geom-api/types/Tessellator.html)
- * functions. See
- * [thi.ng/geom-tessellate](https://thi.ng/thi.ng/geom-tessellate) package for
- * more details.
- *
- * @remarks
- * Implemented for all shapes supported by {@link vertices}. For groups, every
- * child shape will be tessellated individually.
- *
- * @param shape
- * @param tessellators
- */
-export const tessellate = defmulti(__dispatch, {}, {
+const tessellate = defmulti(
+  __dispatch,
+  {},
+  {
     [DEFAULT]: ($, fns) => _tessellate(vertices($), fns),
-    group: ($, fns) => mapcat((x) => _tessellate(vertices(x), fns), $.children),
-});
-/**
- * Alias for thi.ng/geom-tessellate
- * [`earCut2`](https://docs.thi.ng/umbrella/geom-tessellate/functions/earCut2.html)
- */
-export const TESSELLATE_EARCUT = earCut2;
-/**
- * Alias for thi.ng/geom-tessellate
- * [`edgeSplit`](https://docs.thi.ng/umbrella/geom-tessellate/functions/edgeSplit.html)
- */
-export const TESSELLATE_EDGE_SPLIT = edgeSplit;
-/**
- * Alias for thi.ng/geom-tessellate
- * [`tesselInset`](https://docs.thi.ng/umbrella/geom-tessellate/functions/tesselInset.html)
- */
-export const TESSELLATE_INSET = tesselInset;
-/**
- * Alias for thi.ng/geom-tessellate
- * [`quadFan`](https://docs.thi.ng/umbrella/geom-tessellate/functions/quadFan.html)
- */
-export const TESSELLATE_QUAD_FAN = quadFan;
-/**
- * Alias for thi.ng/geom-tessellate
- * [`rimTris`](https://docs.thi.ng/umbrella/geom-tessellate/functions/rimTris.html)
- */
-export const TESSELLATE_RIM_TRIS = rimTris;
-/**
- * Alias for thi.ng/geom-tessellate
- * [`triFan`](https://docs.thi.ng/umbrella/geom-tessellate/functions/triFan.html)
- */
-export const TESSELLATE_TRI_FAN = triFan;
+    group: ($, fns) => mapcat((x) => _tessellate(vertices(x), fns), $.children)
+  }
+);
+const TESSELLATE_EARCUT = earCut2;
+const TESSELLATE_EDGE_SPLIT = edgeSplit;
+const TESSELLATE_INSET = tesselInset;
+const TESSELLATE_QUAD_FAN = quadFan;
+const TESSELLATE_RIM_TRIS = rimTris;
+const TESSELLATE_TRI_FAN = triFan;
+export {
+  TESSELLATE_EARCUT,
+  TESSELLATE_EDGE_SPLIT,
+  TESSELLATE_INSET,
+  TESSELLATE_QUAD_FAN,
+  TESSELLATE_RIM_TRIS,
+  TESSELLATE_TRI_FAN,
+  tessellate
+};

package/text.js

@@ -1,2 +1,5 @@
 import { Text } from "./api/text.js";
-export const text = (pos, body, attribs) => new Text(pos, body, attribs);
+const text = (pos, body, attribs) => new Text(pos, body, attribs);
+export {
+  text
+};

package/transform-vertices.js

@@ -14,64 +14,36 @@ import { asPolygon } from "./as-polygon.js";
 import { asPolyline } from "./as-polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
-import { __transformedShapePoints as tx, __transformedShapePoints3 as tx3, } from "./internal/transform.js";
-/**
- * Similar to {@link transform}. Transforms vertices of given shape with
- * provided function, which is being called for each vertex individually and
- * should produce a transformation matrix.
- *
- * @remark
- * Some shape types will be automatically converted to other types prior to
- * transformation because they cannot be reliably represented in their original
- * type anymore, this includes:
- *
- * - {@link Arc} => {@link Path} (cubics)
- * - {@link Circle} => {@link Path} (cubics)
- * - {@link Ellipse} => {@link Path} (cubics)
- * - {@link Rect} => {@link Polygon}
- *
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Ray}
- * - {@link Rect}
- * - {@link Text}
- * - {@link Triangle}
- *
- * @param shape
- * @param fn
- */
-export const transformVertices = defmulti(__dispatch, {
+import {
+  __transformedShapePoints as tx,
+  __transformedShapePoints3 as tx3
+} from "./internal/transform.js";
+const transformVertices = defmulti(
+  __dispatch,
+  {
     circle: "rect",
-    ellipse: "circle",
-}, {
+    ellipse: "circle"
+  },
+  {
     arc: ($, fn) => transformVertices(asPolyline($), fn),
     cubic: tx(Cubic),
     group: ($, fn) => $.copyTransformed((x) => transformVertices(x, fn)),
     line: tx(Line),
-    path: ($, fn) => new Path([
-        ...map((s) => s.type === "m"
-            ? {
-                type: s.type,
-                point: mulV([], fn(s.point), s.point),
-            }
-            : {
-                type: s.type,
-                geo: transformVertices(s.geo, fn),
-            }, $.segments),
-    ], __copyAttribs($)),
+    path: ($, fn) => new Path(
+      [
+        ...map(
+          (s) => s.type === "m" ? {
+            type: s.type,
+            point: mulV([], fn(s.point), s.point)
+          } : {
+            type: s.type,
+            geo: transformVertices(s.geo, fn)
+          },
+          $.segments
+        )
+      ],
+      __copyAttribs($)
+    ),
     points: tx(Points),
     points3: tx3(Points3),
     poly: tx(Polygon),
@@ -79,5 +51,9 @@ export const transformVertices = defmulti(__dispatch, {
     quad: tx(Quad),
     quadratic: tx(Quadratic),
     rect: ($, fn) => transformVertices(asPolygon($), fn),
-    tri: tx(Triangle),
-});
+    tri: tx(Triangle)
+  }
+);
+export {
+  transformVertices
+};