@thi.ng/geom 7.0.1 → 8.0.0

package/path-builder.js

@@ -1,19 +1,38 @@
 import { peek } from "@thi.ng/arrays/peek";
+import { unsupported } from "@thi.ng/errors/unsupported";
 import { eqDelta } from "@thi.ng/math/eqdelta";
-import { add2 } from "@thi.ng/vectors/add";
+import { add } from "@thi.ng/vectors/add";
 import { copy } from "@thi.ng/vectors/copy";
-import { eqDelta2 } from "@thi.ng/vectors/eqdelta";
-import { mulN2 } from "@thi.ng/vectors/muln";
-import { set2 } from "@thi.ng/vectors/set";
+import { eqDelta as eqDeltaV } from "@thi.ng/vectors/eqdelta";
+import { mulN } from "@thi.ng/vectors/muln";
+import { set } from "@thi.ng/vectors/set";
 import { zeroes } from "@thi.ng/vectors/setn";
-import { sub2 } from "@thi.ng/vectors/sub";
+import { sub } from "@thi.ng/vectors/sub";
 import { Cubic } from "./api/cubic.js";
+import { Cubic3 } from "./api/cubic3.js";
 import { Line } from "./api/line.js";
+import { Line3 } from "./api/line3.js";
 import { Path } from "./api/path.js";
+import { Path3 } from "./api/path3.js";
 import { Quadratic } from "./api/quadratic.js";
+import { Quadratic3 } from "./api/quadratic3.js";
 import { arcFrom2Points } from "./arc.js";
+const P2D = {
+  path: Path,
+  a: arcFrom2Points,
+  c: Cubic,
+  l: Line,
+  q: Quadratic
+};
+const P3D = {
+  path: Path3,
+  c: Cubic3,
+  l: Line3,
+  q: Quadratic3
+};
 class PathBuilder {
-  constructor(attribs, opts = {}) {
+  constructor(ctors, attribs, opts = {}) {
+    this.ctors = ctors;
     this.attribs = attribs;
     this.opts = opts;
     this.paths = [];
@@ -42,36 +61,40 @@ class PathBuilder {
    * will only act on this new path.
    */
   newPath() {
-    this.curr = new Path(
+    this.curr = new this.ctors.path(
       [],
       [],
       this.attribs ? { ...this.attribs } : void 0
     );
     this.paths.push(this.curr);
-    this.currP = zeroes(2);
-    this.bezierP = zeroes(2);
-    this.startP = zeroes(2);
+    const dim = this.curr.dim;
+    this.currP = zeroes(dim);
+    this.bezierP = zeroes(dim);
+    this.startP = zeroes(dim);
   }
   moveTo(p, relative = false) {
     if (this.opts.autoSplit !== false && this.curr.segments.length > 0) {
-      this.curr = new Path([], [], this.attribs);
+      this.curr = new this.ctors.path([], [], this.attribs);
       this.paths.push(this.curr);
     }
     p = this.updateCurrent(p, relative);
-    set2(this.startP, p);
-    set2(this.bezierP, p);
+    set(this.startP, p);
+    set(this.bezierP, p);
     this.curr.addSegments({
-      point: p,
-      type: "m"
+      type: "m",
+      point: p
     });
     return this;
   }
   lineTo(p, relative = false) {
     this.curr.addSegments({
-      geo: new Line([copy(this.currP), this.updateCurrent(p, relative)]),
-      type: "l"
+      type: "l",
+      geo: new this.ctors.l([
+        copy(this.currP),
+        this.updateCurrent(p, relative)
+      ])
     });
-    set2(this.bezierP, this.currP);
+    set(this.bezierP, this.currP);
     return this;
   }
   hlineTo(x, relative = false) {
@@ -95,89 +118,92 @@ class PathBuilder {
   cubicChainTo(cp2, p, relative = false) {
     const prevMode = peek(this.curr.segments).type;
     const c1 = copy(this.currP);
-    prevMode === "c" && add2(null, sub2([], c1, this.bezierP), c1);
+    prevMode === "c" && add(null, sub([], c1, this.bezierP), c1);
     this.addCubic(c1, cp2, p, relative);
     return this;
   }
   quadraticChainTo(p, relative = false) {
     const prevMode = peek(this.curr.segments).type;
     const c1 = copy(this.currP);
-    prevMode === "q" && sub2(null, mulN2(null, c1, 2), this.bezierP);
+    prevMode === "q" && sub(null, mulN(null, c1, 2), this.bezierP);
     this.addQuadratic(c1, p, relative);
     return this;
   }
   arcTo(p, r, xaxis, xl, clockwise, relative = false) {
+    if (!this.ctors.a) unsupported("arcs");
     if (eqDelta(r[0], 0) || eqDelta(r[1], 0)) {
       return this.lineTo(p, relative);
     }
     const prev = copy(this.currP);
     this.curr.addSegments({
-      geo: arcFrom2Points(
+      type: "a",
+      geo: this.ctors.a(
         prev,
         this.updateCurrent(p, relative),
         r,
         xaxis,
         xl,
         clockwise
-      ),
-      type: "a"
+      )
     });
-    set2(this.bezierP, this.currP);
+    set(this.bezierP, this.currP);
     return this;
   }
   close() {
-    if (!eqDelta2(this.startP, this.currP)) {
+    if (!eqDeltaV(this.startP, this.currP)) {
       this.curr.addSegments({
-        geo: new Line([copy(this.currP), copy(this.startP)]),
-        type: "l"
+        type: "l",
+        geo: new this.ctors.l([copy(this.currP), copy(this.startP)])
       });
     }
     this.curr.close();
     return this;
   }
   updateCurrent(p, relative) {
-    p = copy(relative ? add2(null, this.currP, p) : set2(this.currP, p));
+    p = copy(relative ? add(null, this.currP, p) : set(this.currP, p));
     return p;
   }
   absPoint(p, relative) {
-    return relative ? add2(null, p, this.currP) : p;
+    return relative ? add(null, p, this.currP) : p;
   }
   addHVLine(p, i, relative) {
     const prev = copy(this.currP);
     this.currP[i] = relative ? this.currP[i] + p : p;
-    set2(this.bezierP, this.currP);
+    set(this.bezierP, this.currP);
     this.curr.addSegments({
-      geo: new Line([prev, copy(this.currP)]),
-      type: "l"
+      type: "l",
+      geo: new this.ctors.l([prev, copy(this.currP)])
     });
   }
   addCubic(cp1, cp2, p, relative) {
     cp2 = this.absPoint(cp2, relative);
-    set2(this.bezierP, cp2);
+    set(this.bezierP, cp2);
     this.curr.addSegments({
-      geo: new Cubic([
+      type: "c",
+      geo: new this.ctors.c([
         copy(this.currP),
         cp1,
         cp2,
         this.updateCurrent(p, relative)
-      ]),
-      type: "c"
+      ])
     });
   }
   addQuadratic(cp, p, relative) {
-    set2(this.bezierP, cp);
+    set(this.bezierP, cp);
     this.curr.addSegments({
-      geo: new Quadratic([
+      type: "q",
+      geo: new this.ctors.q([
         copy(this.currP),
         cp,
         this.updateCurrent(p, relative)
-      ]),
-      type: "q"
+      ])
     });
   }
 }
-const pathBuilder = (attribs, opts) => new PathBuilder(attribs, opts);
+const pathBuilder = (attribs, opts) => new PathBuilder(P2D, attribs, opts);
+const pathBuilder3 = (attribs, opts) => new PathBuilder(P3D, attribs, opts);
 export {
   PathBuilder,
-  pathBuilder
+  pathBuilder,
+  pathBuilder3
 };

package/path-from-cubics.d.ts

@@ -0,0 +1,26 @@
+import type { Attribs } from "./api.js";
+import type { Cubic } from "./api/cubic.js";
+import type { Cubic3 } from "./api/cubic3.js";
+import { Path } from "./api/path.js";
+import { Path3 } from "./api/path3.js";
+/**
+ * Constructs a {@link Path} or {@link Path3} from given sequence of cubic
+ * curves, with optional `attribs`.
+ *
+ * @remarks
+ * If no `attribs` are given, those from the first curve will be used (if any).
+ *
+ * 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.
+ *
+ * The path will automatically be closed if possible.
+ *
+ * Also see {@link normalizedPath}.
+ *
+ * @param cubics
+ * @param attribs
+ */
+export declare function pathFromCubics(cubics: Cubic[], attribs?: Attribs): Path;
+export declare function pathFromCubics(cubics: Cubic3[], attribs?: Attribs): Path3;
+//# sourceMappingURL=path-from-cubics.d.ts.map

package/path-from-cubics.js

@@ -0,0 +1,39 @@
+import { peek } from "@thi.ng/arrays/peek";
+import { eqDelta } from "@thi.ng/vectors/eqdelta";
+import { equals } from "@thi.ng/vectors/equals";
+import { Path } from "./api/path.js";
+import { Path3 } from "./api/path3.js";
+function pathFromCubics(cubics, attribs) {
+  return __pathFromCubics(
+    cubics[0].dim === 2 ? Path : Path3,
+    cubics,
+    attribs
+  );
+}
+const __pathFromCubics = (ctor, cubics, attribs) => {
+  let subPaths = [];
+  let curr;
+  let lastP;
+  const $beginPath = (c) => {
+    curr = [{ type: "m", point: c.points[0] }];
+    subPaths.push(curr);
+  };
+  for (let c of cubics) {
+    if (!(lastP && equals(lastP, c.points[0]))) $beginPath(c);
+    curr.push({ type: "c", geo: c });
+    lastP = c.points[3];
+  }
+  const path = new ctor(
+    subPaths[0],
+    subPaths.slice(1),
+    attribs || cubics[0].attribs
+  );
+  const segments = path.segments;
+  if (segments.length > 1 && eqDelta(segments[0].point, peek(peek(segments).geo.points))) {
+    path.close();
+  }
+  return path;
+};
+export {
+  pathFromCubics
+};

package/path-from-svg.d.ts

@@ -1,4 +1,4 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 /**
  * Takes a SVG path string and parses it into a {@link Path} shape, optionally
  * with given attributes.

package/path-from-svg.js

@@ -1,15 +1,15 @@
 import { illegalState } from "@thi.ng/errors/illegal-state";
 import { rad } from "@thi.ng/math/angle";
 import { WS } from "@thi.ng/strings/groups";
-import { PathBuilder } from "./path-builder.js";
+import { pathBuilder } from "./path-builder.js";
 const CMD_RE = /[achlmqstvz]/i;
 const WSC = { ...WS, ",": true };
 const pathFromSvg = (svg, attribs) => {
-  const b = new PathBuilder(attribs);
+  const b = pathBuilder(attribs);
   try {
     let cmd = "";
     for (let n = svg.length, i = 0; i < n; ) {
-      i = skipWS(svg, i);
+      i = __skipWS(svg, i);
       const c = svg.charAt(i);
       if (CMD_RE.test(c)) {
         cmd = c;
@@ -18,47 +18,47 @@ const pathFromSvg = (svg, attribs) => {
       let p, pa, pb, t1, t2, t3;
       switch (cmd.toLowerCase()) {
         case "m":
-          [p, i] = readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.moveTo(p, cmd === "m");
           break;
         case "l":
-          [p, i] = readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.lineTo(p, cmd === "l");
           break;
         case "h":
-          [p, i] = readFloat(svg, i);
+          [p, i] = __readFloat(svg, i);
           b.hlineTo(p, cmd === "h");
           break;
         case "v":
-          [p, i] = readFloat(svg, i);
+          [p, i] = __readFloat(svg, i);
           b.vlineTo(p, cmd === "v");
           break;
         case "q":
-          [pa, i] = readPoint(svg, i);
-          [p, i] = readPoint(svg, i);
+          [pa, i] = __readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.quadraticTo(pa, p, cmd === "q");
           break;
         case "c":
-          [pa, i] = readPoint(svg, i);
-          [pb, i] = readPoint(svg, i);
-          [p, i] = readPoint(svg, i);
+          [pa, i] = __readPoint(svg, i);
+          [pb, i] = __readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.cubicTo(pa, pb, p, cmd === "c");
           break;
         case "s":
-          [pa, i] = readPoint(svg, i);
-          [p, i] = readPoint(svg, i);
+          [pa, i] = __readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.cubicChainTo(pa, p, cmd === "s");
           break;
         case "t":
-          [p, i] = readPoint(svg, i);
+          [p, i] = __readPoint(svg, i);
           b.quadraticChainTo(p, cmd === "t");
           break;
         case "a": {
-          [pa, i] = readPoint(svg, i);
-          [t1, i] = readFloat(svg, i);
-          [t2, i] = readFlag(svg, i);
-          [t3, i] = readFlag(svg, i);
-          [pb, i] = readPoint(svg, i);
+          [pa, i] = __readPoint(svg, i);
+          [t1, i] = __readFloat(svg, i);
+          [t2, i] = __readFlag(svg, i);
+          [t3, i] = __readFlag(svg, i);
+          [pb, i] = __readPoint(svg, i);
           b.arcTo(pb, pa, rad(t1), t2, t3, cmd === "a");
           break;
         }
@@ -77,28 +77,28 @@ const pathFromSvg = (svg, attribs) => {
     throw e instanceof Error ? e : new Error(`illegal char '${svg.charAt(e)}' @ ${e}`);
   }
 };
-const skipWS = (src, i) => {
+const __skipWS = (src, i) => {
   const n = src.length;
   while (i < n && WSC[src.charAt(i)]) i++;
   return i;
 };
-const readPoint = (src, index) => {
+const __readPoint = (src, index) => {
   let x, y;
-  [x, index] = readFloat(src, index);
-  index = skipWS(src, index);
-  [y, index] = readFloat(src, index);
+  [x, index] = __readFloat(src, index);
+  index = __skipWS(src, index);
+  [y, index] = __readFloat(src, index);
   return [[x, y], index];
 };
-const readFlag = (src, i) => {
-  i = skipWS(src, i);
+const __readFlag = (src, i) => {
+  i = __skipWS(src, i);
   const c = src.charAt(i);
   return [
     c === "0" ? false : c === "1" ? true : illegalState(`expected '0' or '1' @ pos: ${i}`),
     i + 1
   ];
 };
-const readFloat = (src, index) => {
-  index = skipWS(src, index);
+const __readFloat = (src, index) => {
+  index = __skipWS(src, index);
   let signOk = true;
   let dotOk = true;
   let expOk = false;

package/path.d.ts

@@ -1,6 +1,4 @@
-import type { Attribs, PathSegment } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
-import type { Cubic } from "./api/cubic.js";
+import type { Attribs, PathSegment2 } from "./api.js";
 import { Path } from "./api/path.js";
 /**
  * Creates a new {@link Path} instance, optional with given `segments`,
@@ -14,53 +12,5 @@ import { Path } from "./api/path.js";
  * @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;
-/**
- * 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;
+export declare const path: (segments?: Iterable<PathSegment2>, subPaths?: Iterable<PathSegment2[]>, attribs?: Attribs) => Path;
 //# sourceMappingURL=path.d.ts.map

package/path.js

@@ -1,62 +1,5 @@
-import { isNumber } from "@thi.ng/checks/is-number";
-import { map } from "@thi.ng/transducers/map";
-import { mapcat } from "@thi.ng/transducers/mapcat";
-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, subPaths, attribs) => new Path(segments, subPaths, attribs);
-const pathFromCubics = (cubics, attribs) => {
-  let subPaths = [];
-  let curr;
-  let lastP;
-  const $beginPath = (c) => {
-    curr = [{ type: "m", point: c.points[0] }];
-    subPaths.push(curr);
-  };
-  for (let c of cubics) {
-    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) => {
-  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,
-  path,
-  pathFromCubics,
-  roundedRect
+  path
 };

package/path3.d.ts

@@ -0,0 +1,16 @@
+import type { Attribs, PathSegment3 } from "./api.js";
+import { Path3 } from "./api/path3.js";
+/**
+ * Creates a new {@link Path3} instance, optional with given `segments`,
+ * `subPaths` and `attribs`.
+ *
+ * @remarks
+ * Segments and sub-paths can also be later added via {@link Path3.addSegments}
+ * or {@link Path3.addSubPaths}.
+ *
+ * @param segments
+ * @param subPaths
+ * @param attribs
+ */
+export declare const path3: (segments?: Iterable<PathSegment3>, subPaths?: Iterable<PathSegment3[]>, attribs?: Attribs) => Path3;
+//# sourceMappingURL=path3.d.ts.map

package/path3.js

@@ -0,0 +1,5 @@
+import { Path3 } from "./api/path3.js";
+const path3 = (segments, subPaths, attribs) => new Path3(segments, subPaths, attribs);
+export {
+  path3
+};

package/plane.d.ts

@@ -1,7 +1,17 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
 import { Plane } from "./api/plane.js";
+import type { Ray3 } from "./api/ray3.js";
 export declare const plane: (normal: Vec, w: number, attribs?: Attribs) => Plane;
 export declare const planeWithPoint: (normal: Vec, p: ReadonlyVec, attribs?: Attribs) => Plane;
+/**
+ * Creates a new plane from the given ray, using the ray's position as point on
+ * the plane and the ray's direction as plane normal. If `attribs` are given,
+ * they take precedence over the ray's attribs.
+ *
+ * @param ray
+ * @param attribs
+ */
+export declare const planeFromRay: ({ pos, dir, attribs }: Ray3, $attribs?: Attribs) => Plane;
 export declare const planeFrom3Points: (a: ReadonlyVec, b: ReadonlyVec, c: ReadonlyVec, attribs?: Attribs) => Plane;
 //# sourceMappingURL=plane.d.ts.map

package/plane.js

@@ -1,15 +1,18 @@
 import { dot3 } from "@thi.ng/vectors/dot";
 import { normalize3 } from "@thi.ng/vectors/normalize";
 import { orthoNormal3 } from "@thi.ng/vectors/ortho-normal";
+import { set3 } from "@thi.ng/vectors/set";
 import { Plane } from "./api/plane.js";
 const plane = (normal, w, attribs) => new Plane(normalize3(null, normal), w, attribs);
 const planeWithPoint = (normal, p, attribs) => {
   normal = normalize3(null, normal);
   return new Plane(normal, dot3(normal, p), attribs);
 };
+const planeFromRay = ({ pos, dir, attribs }, $attribs) => new Plane(set3([], dir), dot3(dir, pos), $attribs || attribs);
 const planeFrom3Points = (a, b, c, attribs) => planeWithPoint(orthoNormal3([], a, b, c), a, attribs);
 export {
   plane,
   planeFrom3Points,
+  planeFromRay,
   planeWithPoint
 };

package/point-at.d.ts

@@ -1,6 +1,6 @@
 import type { Maybe } from "@thi.ng/api";
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import type { Vec } from "@thi.ng/vectors";
 /**
  * Samples and returns point on the boundary of given 2D shape at normalized

package/point-inside.d.ts

@@ -1,5 +1,5 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import type { ReadonlyVec } from "@thi.ng/vectors";
 /**
  * Returns true if point `p` is inside the given shape.
@@ -10,6 +10,8 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * - {@link AABB}
  * - {@link Circle}
  * - {@link ComplexPolygon}
+ * - {@link Group}
+ * - {@link Group3}
  * - {@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)

package/point-inside.js

@@ -1,4 +1,4 @@
-import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
 import {
   pointInAABB,
   pointInCircle,
@@ -13,14 +13,17 @@ import { __dispatch } from "./internal/dispatch.js";
 const pointInside = defmulti(
   __dispatch,
   {
+    group3: "group",
     points3: "points",
     quad: "poly",
     sphere: "circle"
   },
   {
+    [DEFAULT]: () => false,
     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,
+    group: ($, p) => $.children.some((child) => pointInside(child, p)),
     line: ($, p) => pointInSegment(p, $.points[0], $.points[1]),
     points: ({ points }, p) => isInArray(p, points),
     poly: ($, p) => pointInPolygon2(p, $.points) > 0,

package/points.d.ts

@@ -1,6 +1,5 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import type { Vec } from "@thi.ng/vectors";
-import { Points, Points3 } from "./api/points.js";
+import { Points } from "./api/points.js";
 export declare const points: (pts?: Iterable<Vec>, attribs?: Attribs) => Points;
-export declare const points3: (pts?: Iterable<Vec>, attribs?: Attribs) => Points3;
 //# sourceMappingURL=points.d.ts.map

package/points.js

@@ -1,7 +1,5 @@
-import { Points, Points3 } from "./api/points.js";
+import { Points } from "./api/points.js";
 const points = (pts, attribs) => new Points(pts, attribs);
-const points3 = (pts, attribs) => new Points3(pts, attribs);
 export {
-  points,
-  points3
+  points
 };