@thi.ng/geom 3.3.1 → 3.4.2

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-06-23T12:16:18Z
+- **Last updated**: 2022-07-19T15:36:12Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,23 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [3.4.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/geom@3.4.0) (2022-06-28)
+
+#### 🚀 Features
+
+- add AABB support for intersects() ([768dddd](https://github.com/thi-ng/umbrella/commit/768dddd))
+- update warpPoints() args, add docs ([50cb467](https://github.com/thi-ng/umbrella/commit/50cb467))
+- update edges(), support more types ([3e1b340](https://github.com/thi-ng/umbrella/commit/3e1b340))
+- add new transform ops & helpers ([cd8217c](https://github.com/thi-ng/umbrella/commit/cd8217c))
+  - add applyTransforms(), rotate(), scale()
+  - add internal helpers
+  - update transform() rect coercion (now => Quad, previous Polygon)
+- add IAttributed impls for all shape types ([ccb40f1](https://github.com/thi-ng/umbrella/commit/ccb40f1))
+
+#### 🩹 Bug fixes
+
+- update AABB/Rect.offset(), clamp size to zero ([620121d](https://github.com/thi-ng/umbrella/commit/620121d))
+
 ### [3.3.1](https://github.com/thi-ng/umbrella/tree/@thi.ng/geom@3.3.1) (2022-06-23)
 
 #### ♻️ Refactoring

package/README.md

@@ -29,11 +29,57 @@ This project is a partially ported from the [Clojure version of the same
 name](http://thi.ng/geom-clj). All polymorphic operations built on
 [@thi.ng/defmulti](https://github.com/thi-ng/umbrella/tree/develop/packages/defmulti).
 
+<!--
 [**Up-to-date feature matrix spreadsheet**](https://docs.google.com/spreadsheets/d/1GxJm-zOQaGECui2MJUmy3gQPTF-T6BJ6vhNlUnPsmDs/edit?usp=sharing)
-
-This package acts as a higher-level frontend for most of the following
-related packages (which are more low-level, lightweight and usable by
-themselves too):
+-->
+
+The following operations are provided (many also applicable to shape groups
+directly and/or perform automatic resampling/conversion if needed):
+
+| Operation                                                                                 | Description                                                  |
+|-------------------------------------------------------------------------------------------|--------------------------------------------------------------|
+| [`arcLength()`](https://docs.thi.ng/umbrella/geom/modules.html#arcLength)                 | compute arc length / perimeter of shape boundary             |
+| [`area()`](https://docs.thi.ng/umbrella/geom/modules.html#area)                           | signed/unsigned surface area                                 |
+| [`asCubic()`](https://docs.thi.ng/umbrella/geom/modules.html#asCubic)                     | convert shape boundary to cubic bezier segments              |
+| [`asPath()`](https://docs.thi.ng/umbrella/geom/modules.html#asPath)                       | convert shape to path                                        |
+| [`asPolygon()`](https://docs.thi.ng/umbrella/geom/modules.html#asPolygon)                 | convert shape to polygon                                     |
+| [`asPolyline()`](https://docs.thi.ng/umbrella/geom/modules.html#asPolyline)               | convert shape to polyline                                    |
+| [`asSvg()`](https://docs.thi.ng/umbrella/geom/modules.html#asSvg)                         | serialize shape/group/hierarchy to SVG                       |
+| [`bounds()`](https://docs.thi.ng/umbrella/geom/modules.html#bounds)                       | compute bounding box                                         |
+| [`center()`](https://docs.thi.ng/umbrella/geom/modules.html#center)                       | center shape around origin or point                          |
+| [`centroid()`](https://docs.thi.ng/umbrella/geom/modules.html#centroid)                   | compute shape centroid                                       |
+| [`classifyPoint()`](https://docs.thi.ng/umbrella/geom/modules.html#classifyPoint)         | classify point in relation to shape boundary (in/out)        |
+| [`clipConvex()`](https://docs.thi.ng/umbrella/geom/modules.html#clipConvex)               | clip shape against convex boundary                           |
+| [`closestPoint()`](https://docs.thi.ng/umbrella/geom/modules.html#closestPoint)           | compute closest point on shape boundary                      |
+| [`convexHull()`](https://docs.thi.ng/umbrella/geom/modules.html#convexHull)               | compute convex hull (2d only)                                |
+| [`edges()`](https://docs.thi.ng/umbrella/geom/modules.html#edges)                         | extract edges                                                |
+| [`fitIntoBounds()`](https://docs.thi.ng/umbrella/geom/modules.html#fitIntoBounds)         | rescale/reposition shapes into a destination boundary        |
+| [`flip()`](https://docs.thi.ng/umbrella/geom/modules.html#flip)                           | reverse order (vertices or direction)                        |
+| [`intersects()`](https://docs.thi.ng/umbrella/geom/modules.html#intersects)               | pairwise shape intersection (various types)                  |
+| [`mapPoint()`](https://docs.thi.ng/umbrella/geom/modules.html#mapPoint)                   | transform world space point into local shape space           |
+| [`offset()`](https://docs.thi.ng/umbrella/geom/modules.html#offset)                       | shape/path offsetting                                        |
+| [`pointAt()`](https://docs.thi.ng/umbrella/geom/modules.html#pointAt)                     | compute point on shape boundary at parametric position       |
+| [`pointInside()`](https://docs.thi.ng/umbrella/geom/modules.html#pointInside)             | check if point is inside shape                               |
+| [`resample()`](https://docs.thi.ng/umbrella/geom/modules.html#resample)                   | resample/convert shape                                       |
+| [`rotate()`](https://docs.thi.ng/umbrella/geom/modules.html#rotate)                       | rotate shape                                                 |
+| [`scale()`](https://docs.thi.ng/umbrella/geom/modules.html#scale)                         | scale shape (uniformly/non-uniformly)                        |
+| [`scatter()`](https://docs.thi.ng/umbrella/geom/modules.html#scatter)                     | create random points inside a shape boundary                 |
+| [`simplify()`](https://docs.thi.ng/umbrella/geom/modules.html#simplify)                   | simplify shape/boundary (Douglas-Peucker)                    |
+| [`splitAt()`](https://docs.thi.ng/umbrella/geom/modules.html#splitAt)                     | split shape/boundary at parametric position                  |
+| [`splitNear()`](https://docs.thi.ng/umbrella/geom/modules.html#splitNear)                 | split shape/boundary near world position                     |
+| [`subdivCurve()`](https://docs.thi.ng/umbrella/geom/modules.html#subdivCurve)             | recursively apply curve subdivision kernel                   |
+| [`tangentAt()`](https://docs.thi.ng/umbrella/geom/modules.html#tangentAt)                 | compute tangent at parametric position                       |
+| [`tessellate()`](https://docs.thi.ng/umbrella/geom/modules.html#tessellate)               | (recursively) tessellate shape                               |
+| [`transformVertices()`](https://docs.thi.ng/umbrella/geom/modules.html#transformVertices) | apply custom function to each vertex                         |
+| [`transform()`](https://docs.thi.ng/umbrella/geom/modules.html#transform)                 | apply transformation matrix                                  |
+| [`translate()`](https://docs.thi.ng/umbrella/geom/modules.html#translate)                 | translate shape                                              |
+| [`union()`](https://docs.thi.ng/umbrella/geom/modules.html#union)                         | compute shape union                                          |
+| [`vertices()`](https://docs.thi.ng/umbrella/geom/modules.html#vertices)                   | extract/sample vertices from shape boundary                  |
+| [`volume()`](https://docs.thi.ng/umbrella/geom/modules.html#volume)                       | compute shape volume (3D only)                               |
+| [`warpPoints()`](https://docs.thi.ng/umbrella/geom/modules.html#warpPoints)               | transfer points between the local spaces defined by 2 shapes |
+
+This package acts as a higher-level frontend for most of the following related
+packages (which are more low-level, lightweight and usable by themselves too):
 
 ### Support packages
 
@@ -85,7 +131,7 @@ node --experimental-repl-await
 > const geom = await import("@thi.ng/geom");
 ```
 
-Package sizes (gzipped, pre-treeshake): ESM: 12.67 KB
+Package sizes (gzipped, pre-treeshake): ESM: 13.50 KB
 
 ## Dependencies
 

package/api/aabb.d.ts

@@ -1,5 +1,5 @@
 import type { AABBLike, Attribs } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import { Vec } from "@thi.ng/vectors/api";
 export declare class AABB implements AABBLike {
     pos: Vec;
     attribs?: Attribs | undefined;
@@ -7,6 +7,7 @@ export declare class AABB implements AABBLike {
     constructor(pos?: Vec, size?: number | Vec, attribs?: Attribs | undefined);
     get type(): string;
     copy(): AABB;
+    withAttribs(attribs: Attribs): AABB;
     max(): Vec;
     offset(offset: number): this;
 }

package/api/aabb.js

@@ -1,5 +1,7 @@
 import { add3 } from "@thi.ng/vectors/add";
 import { addN3 } from "@thi.ng/vectors/addn";
+import { ZERO3 } from "@thi.ng/vectors/api";
+import { max3 } from "@thi.ng/vectors/max";
 import { set3 } from "@thi.ng/vectors/set";
 import { subN3 } from "@thi.ng/vectors/subn";
 import { __asVec } from "../internal/args.js";
@@ -16,12 +18,15 @@ export class AABB {
     copy() {
         return new AABB(set3([], this.pos), set3([], this.size), __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new AABB(this.pos, this.size, attribs);
+    }
     max() {
         return add3([], this.pos, this.size);
     }
     offset(offset) {
         subN3(null, this.pos, offset);
-        addN3(null, this.size, offset * 2);
+        max3(null, addN3(null, this.size, offset * 2), ZERO3);
         return this;
     }
 }

package/api/apc.d.ts

@@ -1,11 +1,12 @@
-import type { Attribs, IShape, PCLike } from "@thi.ng/geom-api";
+import type { Attribs, PCLike } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
 export declare abstract class APC implements PCLike {
     points: Vec[];
     attribs?: Attribs | undefined;
     constructor(points?: Vec[], attribs?: Attribs | undefined);
     abstract get type(): number | string;
-    abstract copy(): IShape;
+    abstract copy(): APC;
+    abstract withAttribs(attribs: Attribs): APC;
     [Symbol.iterator](): Generator<Vec, void, undefined>;
 }
 //# sourceMappingURL=apc.d.ts.map

package/api/arc.d.ts

@@ -12,6 +12,7 @@ export declare class Arc implements IHiccupShape, IHiccupPathSegment {
     constructor(pos: Vec, r: Vec, axis: number, start: number, end: number, xl?: boolean, cw?: boolean, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Arc;
+    withAttribs(attribs: Attribs): Arc;
     equiv(o: any): boolean;
     pointAt(t: number, out?: Vec): Vec;
     pointAtTheta(theta: number, out?: Vec): Vec;

package/api/arc.js

@@ -19,6 +19,9 @@ export class Arc {
     copy() {
         return new Arc(set([], this.pos), set([], this.r), this.axis, this.start, this.end, this.xl, this.cw, __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Arc(this.pos, this.r, this.axis, this.start, this.end, this.xl, this.cw, attribs);
+    }
     equiv(o) {
         return (o instanceof Arc &&
             equiv(this.pos, o.pos) &&

package/api/bpatch.d.ts

@@ -1,5 +1,5 @@
 import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
-import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { ReadonlyVec, Vec, VecPair } from "@thi.ng/vectors";
 import { APC } from "./apc.js";
 /**
  * nD Cubic bezier patch defined by array of 4x4 control points in this
@@ -31,7 +31,8 @@ export declare class BPatch extends APC implements IHiccupShape {
     constructor(points: Vec[], attribs?: Attribs);
     get type(): string;
     copy(): BPatch;
-    edges(): Vec[][];
+    withAttribs(attribs: Attribs): BPatch;
+    edges(): VecPair[];
     unmapPoint(uv: ReadonlyVec, out?: Vec): Vec;
     toHiccup(): any[];
 }

package/api/bpatch.js

@@ -39,6 +39,9 @@ export class BPatch extends APC {
     copy() {
         return __copyShape(BPatch, this);
     }
+    withAttribs(attribs) {
+        return new BPatch(this.points, attribs);
+    }
     edges() {
         const p = this.points;
         return [

package/api/circle.d.ts

@@ -7,6 +7,7 @@ export declare class Circle implements IHiccupShape {
     constructor(pos?: Vec, r?: number, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Circle;
+    withAttribs(attribs: Attribs): Circle;
     toHiccup(): (string | number | Attribs | undefined)[];
 }
 //# sourceMappingURL=circle.d.ts.map

package/api/circle.js

@@ -12,6 +12,9 @@ export class Circle {
     copy() {
         return new Circle(set([], this.pos), this.r, __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Circle(this.pos, this.r, attribs);
+    }
     toHiccup() {
         return ["circle", this.attribs, this.pos, this.r];
     }

package/api/cubic.d.ts

@@ -1,9 +1,10 @@
-import type { IHiccupPathSegment } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupPathSegment } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Cubic extends APC implements IHiccupPathSegment {
     get type(): string;
     copy(): Cubic;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Cubic;
+    toHiccup(): (string | Attribs | undefined)[];
     toHiccupPathSegments(): (string | import("@thi.ng/vectors").Vec)[][];
 }
 //# sourceMappingURL=cubic.d.ts.map

package/api/cubic.js

@@ -7,6 +7,9 @@ export class Cubic extends APC {
     copy() {
         return __copyShape(Cubic, this);
     }
+    withAttribs(attribs) {
+        return new Cubic(this.points, attribs);
+    }
     toHiccup() {
         return [
             "path",

package/api/ellipse.d.ts

@@ -7,6 +7,7 @@ export declare class Ellipse implements IHiccupShape {
     constructor(pos?: Vec, r?: number | Vec, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Ellipse;
+    withAttribs(attribs: Attribs): Ellipse;
     toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=ellipse.d.ts.map

package/api/ellipse.js

@@ -13,6 +13,9 @@ export class Ellipse {
     copy() {
         return new Ellipse(set([], this.pos), set([], this.r), __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Ellipse(this.pos, this.r, attribs);
+    }
     toHiccup() {
         return ["ellipse", this.attribs, this.pos, this.r];
     }

package/api/group.d.ts

@@ -8,6 +8,7 @@ export declare class Group implements IHiccupShape {
     [Symbol.iterator](): Generator<IHiccupShape, void, undefined>;
     copy(): Group;
     copyTransformed(fn: Fn<IHiccupShape, IHiccupShape>): Group;
+    withAttribs(attribs: Attribs): Group;
     equiv(o: any): boolean;
     toHiccup(): any[];
 }

package/api/group.js

@@ -17,6 +17,9 @@ export class Group {
     copyTransformed(fn) {
         return new Group(__copyAttribs(this), this.children.map(fn));
     }
+    withAttribs(attribs) {
+        return new Group(attribs, this.children);
+    }
     equiv(o) {
         return o instanceof Group && equiv(this.children, o.children);
     }

package/api/line.d.ts

@@ -1,9 +1,10 @@
-import type { IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Line extends APC implements IHiccupShape, IHiccupPathSegment {
     get type(): string;
     copy(): Line;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Line;
+    toHiccup(): (string | Attribs | undefined)[];
     toHiccupPathSegments(): ((string | number)[] | (string | import("@thi.ng/vectors").Vec)[])[];
 }
 //# sourceMappingURL=line.d.ts.map

package/api/line.js

@@ -7,6 +7,9 @@ export class Line extends APC {
     copy() {
         return __copyShape(Line, this);
     }
+    withAttribs(attribs) {
+        return new Line(this.points, attribs);
+    }
     toHiccup() {
         return ["line", this.attribs, this.points[0], this.points[1]];
     }

package/api/path.d.ts

@@ -7,6 +7,7 @@ export declare class Path implements IHiccupShape {
     get type(): string;
     [Symbol.iterator](): Generator<PathSegment, void, undefined>;
     copy(): Path;
+    withAttribs(attribs: Attribs): Path;
     equiv(o: any): boolean;
     add(s: PathSegment): void;
     toHiccup(): (string | Attribs)[];

package/api/path.js

@@ -24,6 +24,11 @@ export class Path {
         p.closed = this.closed;
         return p;
     }
+    withAttribs(attribs) {
+        const res = new Path(this.segments, attribs);
+        res.closed = true;
+        return res;
+    }
     equiv(o) {
         return o instanceof Path && equiv(this.segments, o.segments);
     }

package/api/plane.d.ts

@@ -7,6 +7,7 @@ export declare class Plane implements IHiccupShape {
     constructor(normal?: Vec, w?: number, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Plane;
+    withAttribs(attribs: Attribs): Plane;
     toHiccup(): (string | number | Attribs | undefined)[];
 }
 //# sourceMappingURL=plane.d.ts.map

package/api/plane.js

@@ -12,6 +12,9 @@ export class Plane {
     copy() {
         return new Plane(set3([], this.normal), this.w, __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Plane(this.normal, this.w, attribs);
+    }
     toHiccup() {
         return ["plane", this.attribs, this.normal, this.w];
     }

package/api/points.d.ts

@@ -1,13 +1,15 @@
-import type { IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Points extends APC implements IHiccupShape {
     get type(): string;
     copy(): Points;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Points;
+    toHiccup(): (string | Attribs | undefined)[];
 }
 export declare class Points3 extends APC implements IHiccupShape {
     get type(): string;
     copy(): Points3;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Points3;
+    toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=points.d.ts.map

package/api/points.js

@@ -7,6 +7,9 @@ export class Points extends APC {
     copy() {
         return __copyShape(Points, this);
     }
+    withAttribs(attribs) {
+        return new Points(this.points, attribs);
+    }
     toHiccup() {
         return ["points", this.attribs, this.points];
     }
@@ -18,6 +21,9 @@ export class Points3 extends APC {
     copy() {
         return __copyShape(Points3, this);
     }
+    withAttribs(attribs) {
+        return new Points3(this.points, attribs);
+    }
     toHiccup() {
         return ["points3", this.attribs, this.points];
     }

package/api/polygon.d.ts

@@ -1,8 +1,9 @@
-import type { IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Polygon extends APC implements IHiccupShape {
     get type(): string;
     copy(): Polygon;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Polygon;
+    toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=polygon.d.ts.map

package/api/polygon.js

@@ -7,6 +7,9 @@ export class Polygon extends APC {
     copy() {
         return __copyShape(Polygon, this);
     }
+    withAttribs(attribs) {
+        return new Polygon(this.points, attribs);
+    }
     toHiccup() {
         return ["polygon", this.attribs, this.points];
     }

package/api/polyline.d.ts

@@ -1,8 +1,9 @@
-import type { IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Polyline extends APC implements IHiccupShape, IHiccupPathSegment {
     get type(): string;
     copy(): Polyline;
+    withAttribs(attribs: Attribs): Polyline;
     toHiccup(): (string | import("@thi.ng/vectors").Vec[] | {
         fill: string;
     })[];

package/api/polyline.js

@@ -7,6 +7,9 @@ export class Polyline extends APC {
     copy() {
         return __copyShape(Polyline, this);
     }
+    withAttribs(attribs) {
+        return new Polyline(this.points, attribs);
+    }
     toHiccup() {
         return ["polyline", { ...this.attribs, fill: "none" }, this.points];
     }

package/api/quad.d.ts

@@ -1,8 +1,9 @@
-import type { IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Quad extends APC implements IHiccupShape {
     get type(): string;
     copy(): Quad;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Quad;
+    toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=quad.d.ts.map

package/api/quad.js

@@ -7,6 +7,9 @@ export class Quad extends APC {
     copy() {
         return __copyShape(Quad, this);
     }
+    withAttribs(attribs) {
+        return new Quad(this.points, attribs);
+    }
     toHiccup() {
         return ["polygon", this.attribs, this.points];
     }

package/api/quad3.d.ts

@@ -1,8 +1,9 @@
-import type { IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Quad3 extends APC implements IHiccupShape {
     get type(): string;
     copy(): Quad3;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Quad3;
+    toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=quad3.d.ts.map

package/api/quad3.js

@@ -7,6 +7,9 @@ export class Quad3 extends APC {
     copy() {
         return __copyShape(Quad3, this);
     }
+    withAttribs(attribs) {
+        return new Quad3(this.points, attribs);
+    }
     toHiccup() {
         return ["polygon", this.attribs, this.points];
     }

package/api/quadratic.d.ts

@@ -1,9 +1,10 @@
-import type { IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
+import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
 import { APC } from "./apc.js";
 export declare class Quadratic extends APC implements IHiccupShape, IHiccupPathSegment {
     get type(): string;
     copy(): Quadratic;
-    toHiccup(): (string | import("@thi.ng/geom-api").Attribs | undefined)[];
+    withAttribs(attribs: Attribs): Quadratic;
+    toHiccup(): (string | Attribs | undefined)[];
     toHiccupPathSegments(): (string | import("@thi.ng/vectors").Vec)[][];
 }
 //# sourceMappingURL=quadratic.d.ts.map

package/api/quadratic.js

@@ -7,6 +7,9 @@ export class Quadratic extends APC {
     copy() {
         return __copyShape(Quadratic, this);
     }
+    withAttribs(attribs) {
+        return new Quadratic(this.points, attribs);
+    }
     toHiccup() {
         return [
             "path",

package/api/ray.d.ts

@@ -7,6 +7,7 @@ export declare class Ray implements IHiccupShape {
     constructor(pos: Vec, dir: Vec, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Ray;
+    withAttribs(attribs: Attribs): Ray;
     toHiccup(): (string | Attribs | undefined)[];
 }
 //# sourceMappingURL=ray.d.ts.map

package/api/ray.js

@@ -13,6 +13,9 @@ export class Ray {
     copy() {
         return new Ray(set([], this.pos), set([], this.dir), __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Ray(this.pos, this.dir, attribs);
+    }
     toHiccup() {
         return [
             "line",

package/api/rect.d.ts

@@ -1,5 +1,5 @@
 import type { AABBLike, Attribs, IHiccupShape } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import { Vec } from "@thi.ng/vectors/api";
 export declare class Rect implements AABBLike, IHiccupShape {
     pos: Vec;
     attribs?: Attribs | undefined;
@@ -7,6 +7,7 @@ export declare class Rect implements AABBLike, IHiccupShape {
     constructor(pos?: Vec, size?: number | Vec, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Rect;
+    withAttribs(attribs: Attribs): Rect;
     max(): Vec;
     offset(offset: number): this;
     toHiccup(): (string | number | Attribs | undefined)[];

package/api/rect.js

@@ -1,5 +1,7 @@
 import { add2 } from "@thi.ng/vectors/add";
 import { addN2 } from "@thi.ng/vectors/addn";
+import { ZERO2 } from "@thi.ng/vectors/api";
+import { max2 } from "@thi.ng/vectors/max";
 import { set2 } from "@thi.ng/vectors/set";
 import { subN2 } from "@thi.ng/vectors/subn";
 import { __asVec } from "../internal/args.js";
@@ -16,12 +18,15 @@ export class Rect {
     copy() {
         return new Rect(set2([], this.pos), set2([], this.size), __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Rect(this.pos, this.size, attribs);
+    }
     max() {
         return add2([], this.pos, this.size);
     }
     offset(offset) {
         subN2(null, this.pos, offset);
-        addN2(null, this.size, offset * 2);
+        max2(null, addN2(null, this.size, offset * 2), ZERO2);
         return this;
     }
     toHiccup() {

package/api/sphere.d.ts

@@ -7,6 +7,7 @@ export declare class Sphere implements IHiccupShape {
     constructor(pos?: Vec, r?: number, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Sphere;
+    withAttribs(attribs: Attribs): Sphere;
     toHiccup(): (string | number | Attribs | undefined)[];
 }
 //# sourceMappingURL=sphere.d.ts.map

package/api/sphere.js

@@ -12,6 +12,9 @@ export class Sphere {
     copy() {
         return new Sphere(set3([], this.pos), this.r, __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Sphere(this.pos, this.r, attribs);
+    }
     toHiccup() {
         return ["sphere", this.attribs, this.pos, this.r];
     }

package/api/text.d.ts

@@ -13,6 +13,7 @@ export declare class Text implements IHiccupShape {
     constructor(pos: Vec, body: any, attribs?: Attribs | undefined);
     get type(): string;
     copy(): Text;
+    withAttribs(attribs: Attribs): Text;
     toHiccup(): any[];
 }
 //# sourceMappingURL=text.d.ts.map

package/api/text.js

@@ -18,6 +18,9 @@ export class Text {
     copy() {
         return new Text(set([], this.pos), this.body, __copyAttribs(this));
     }
+    withAttribs(attribs) {
+        return new Text(this.pos, this.body, attribs);
+    }
     toHiccup() {
         return ["text", this.attribs, this.pos, this.body];
     }