@thi.ng/geom 3.2.6 → 3.4.0

package/point-inside.js

@@ -2,6 +2,25 @@ import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { pointInAABB, pointInCircle, pointInPolygon2, pointInRect, pointInSegment, pointInTriangle2, } from "@thi.ng/geom-isec/point";
 import { isInArray } from "@thi.ng/vectors/eqdelta";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Returns true if point `p` is inside the given shape.
+ *
+ * @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
+ *
+ * @param shape
+ * @param p
+ */
 export const pointInside = defmulti(__dispatch, {
     points3: "points",
     quad: "poly",

package/rect.d.ts

@@ -7,7 +7,9 @@ export declare function rect(pos: Vec, size: number | Vec, attribs?: Attribs): R
 export declare function rect(size: number | Vec, attribs?: Attribs): Rect;
 export declare function rect(attribs?: Attribs): Rect;
 export declare const rectFromMinMax: (min: Vec, max: Vec, attribs?: Attribs) => Rect;
-export declare const rectFromCentroid: (centroid: Vec, size: Vec, attribs?: Attribs) => Rect;
+export declare const rectFromMinMaxWithMargin: (min: Vec, max: Vec, margin: number, attribs?: Attribs) => Rect;
+export declare const rectFromCentroid: (centroid: Vec, size: number | Vec, attribs?: Attribs) => Rect;
+export declare const rectFromCentroidWithMargin: (centroid: Vec, size: number | Vec, margin: number, attribs?: Attribs) => Rect;
 /**
  * Returns the intersection rect of given inputs or `undefined` if they
  * are non-overlapping.

package/rect.js

@@ -9,12 +9,17 @@ import { min2 } from "@thi.ng/vectors/min";
 import { sub2 } from "@thi.ng/vectors/sub";
 import { subN2 } from "@thi.ng/vectors/subn";
 import { Rect } from "./api/rect.js";
-import { __argsVV } from "./internal/args.js";
+import { __argsVV, __asVec } from "./internal/args.js";
 export function rect(...args) {
     return new Rect(...__argsVV(args));
 }
 export const rectFromMinMax = (min, max, attribs) => new Rect(min, sub2([], max, min), attribs);
-export const rectFromCentroid = (centroid, size, attribs) => new Rect(maddN2([], size, -0.5, centroid), size, attribs);
+export const rectFromMinMaxWithMargin = (min, max, margin, attribs) => rectFromMinMax(min, max, attribs).offset(margin);
+export const rectFromCentroid = (centroid, size, attribs) => {
+    size = __asVec(size);
+    return new Rect(maddN2([], size, -0.5, centroid), size, attribs);
+};
+export const rectFromCentroidWithMargin = (centroid, size, margin, attribs) => rectFromCentroid(centroid, size, attribs).offset(margin);
 /**
  * Returns the intersection rect of given inputs or `undefined` if they
  * are non-overlapping.

package/resample.d.ts

@@ -1,4 +1,23 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
+/**
+ * Resamples given 2D shape with given options and returns result as polygon (if
+ * closed) or polyline (if open).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link Circle}
+ * - {@link Ellipse}
+ * - {@link Line}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param opts
+ */
 export declare const resample: MultiFn2<IShape, number | Partial<SamplingOpts>, IShape>;
 //# sourceMappingURL=resample.d.ts.map

package/resample.js

@@ -5,6 +5,25 @@ import { Polyline } from "./api/polyline.js";
 import { asPolygon } from "./as-polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Resamples given 2D shape with given options and returns result as polygon (if
+ * closed) or polyline (if open).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link Circle}
+ * - {@link Ellipse}
+ * - {@link Line}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param opts
+ */
 export const resample = defmulti(__dispatch, {
     ellipse: "circle",
     line: "polyline",

package/rotate.d.ts

@@ -0,0 +1,30 @@
+import type { MultiFn2 } from "@thi.ng/defmulti";
+import type { IShape } from "@thi.ng/geom-api";
+/**
+ * Rotates given 2D shape by `theta` (in radians).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Points}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Ray}
+ * - {@link Rect}
+ * - {@link Text}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param theta
+ */
+export declare const rotate: MultiFn2<IShape, number, IShape>;
+//# sourceMappingURL=rotate.d.ts.map

package/rotate.js

@@ -0,0 +1,79 @@
+import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { rotate as $rotate } from "@thi.ng/vectors/rotate";
+import { Circle } from "./api/circle.js";
+import { Cubic } from "./api/cubic.js";
+import { Line } from "./api/line.js";
+import { Path } from "./api/path.js";
+import { Points } from "./api/points.js";
+import { Polygon } from "./api/polygon.js";
+import { Polyline } from "./api/polyline.js";
+import { Quad } from "./api/quad.js";
+import { Quadratic } from "./api/quadratic.js";
+import { Ray } from "./api/ray.js";
+import { Text } from "./api/text.js";
+import { Triangle } from "./api/triangle.js";
+import { asPath } from "./as-path.js";
+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";
+/**
+ * Rotates given 2D shape by `theta` (in radians).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Points}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Ray}
+ * - {@link Rect}
+ * - {@link Text}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param theta
+ */
+export const rotate = defmulti(__dispatch, {}, {
+    arc: ($, theta) => {
+        const a = $.copy();
+        $rotate(null, a.pos, theta);
+        return a;
+    },
+    circle: ($, theta) => new Circle($rotate([], $.pos, theta), $.r, __copyAttribs($)),
+    cubic: tx(Cubic),
+    ellipse: ($, theta) => rotate(asPath($), theta),
+    group: ($, theta) => $.copyTransformed((x) => rotate(x, theta)),
+    line: tx(Line),
+    path: ($, 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),
+            }), __copyAttribs($));
+    },
+    points: tx(Points),
+    poly: tx(Polygon),
+    polyline: tx(Polyline),
+    quad: tx(Quad),
+    quadratic: tx(Quadratic),
+    ray: ($, theta) => {
+        return new Ray($rotate([], $.pos, theta), $rotate([], $.dir, theta), __copyAttribs($));
+    },
+    rect: ($, theta) => rotate(asPolygon($), theta),
+    text: ($, theta) => new Text($rotate([], $.pos, theta), $.body, __copyAttribs($)),
+    tri: tx(Triangle),
+});

package/scale.d.ts

@@ -0,0 +1,37 @@
+import type { MultiFn2 } from "@thi.ng/defmulti";
+import type { IShape } from "@thi.ng/geom-api";
+import type { ReadonlyVec } from "@thi.ng/vectors";
+/**
+ * Scales given shape uniformly or non-uniformly by given `factor`.
+ *
+ * @remarks
+ * Scaling non-uniformly might result in different result types, e.g.
+ * {@link Circle} => {@link Ellipse}.
+ *
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@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 Sphere}
+ * - {@link Text}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param factor
+ */
+export declare const scale: MultiFn2<IShape, number | ReadonlyVec, IShape>;
+//# sourceMappingURL=scale.d.ts.map

package/scale.js

@@ -0,0 +1,112 @@
+import { isNumber } from "@thi.ng/checks/is-number";
+import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { mul2, mul3 } from "@thi.ng/vectors/mul";
+import { mulN2, mulN3 } from "@thi.ng/vectors/muln";
+import { normalize } from "@thi.ng/vectors/normalize";
+import { AABB } from "./api/aabb.js";
+import { Circle } from "./api/circle.js";
+import { Cubic } from "./api/cubic.js";
+import { Ellipse } from "./api/ellipse.js";
+import { Line } from "./api/line.js";
+import { Path } from "./api/path.js";
+import { Points, Points3 } from "./api/points.js";
+import { Polygon } from "./api/polygon.js";
+import { Polyline } from "./api/polyline.js";
+import { Quad } from "./api/quad.js";
+import { Quadratic } from "./api/quadratic.js";
+import { Ray } from "./api/ray.js";
+import { Rect } from "./api/rect.js";
+import { Sphere } from "./api/sphere.js";
+import { Text } from "./api/text.js";
+import { Triangle } from "./api/triangle.js";
+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";
+/**
+ * Scales given shape uniformly or non-uniformly by given `factor`.
+ *
+ * @remarks
+ * Scaling non-uniformly might result in different result types, e.g.
+ * {@link Circle} => {@link Ellipse}.
+ *
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@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 Sphere}
+ * - {@link Text}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param factor
+ */
+export const scale = defmulti(__dispatch, {}, {
+    aabb: ($, delta) => {
+        delta = __asVec(delta, 3);
+        return new AABB(mul3([], $.pos, delta), mul3([], $.size, delta), __copyAttribs($));
+    },
+    arc: ($, delta) => {
+        delta = __asVec(delta);
+        const a = $.copy();
+        mul2(null, a.pos, delta);
+        mul2(null, a.r, delta);
+        return a;
+    },
+    circle: ($, delta) => isNumber(delta)
+        ? new Circle(mulN2([], $.pos, delta), $.r * delta, __copyAttribs($))
+        : new Ellipse(mul2([], $.pos, delta), mulN2([], delta, $.r), __copyAttribs($)),
+    cubic: tx(Cubic),
+    ellipse: ($, delta) => {
+        delta = __asVec(delta);
+        return new Ellipse(mul2([], $.pos, delta), mul2([], $.r, delta), __copyAttribs($));
+    },
+    group: ($, delta) => $.copyTransformed((x) => scale(x, delta)),
+    line: tx(Line),
+    path: ($, delta) => {
+        delta = __asVec(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),
+            }), __copyAttribs($));
+    },
+    points: tx(Points),
+    points3: tx(Points3),
+    poly: tx(Polygon),
+    polyline: tx(Polyline),
+    quad: tx(Quad),
+    quadratic: tx(Quadratic),
+    ray: ($, delta) => {
+        delta = __asVec(delta);
+        return new Ray(mul2([], $.pos, delta), normalize(null, mul2([], $.dir, delta)), __copyAttribs($));
+    },
+    rect: ($, delta) => {
+        delta = __asVec(delta);
+        return new Rect(mul2([], $.pos, delta), mul2([], $.size, delta), __copyAttribs($));
+    },
+    sphere: ($, delta) => isNumber(delta)
+        ? new Sphere(mulN3([], $.pos, delta), $.r * delta, __copyAttribs($))
+        : unsupported("can't non-uniformly scale sphere"),
+    text: ($, delta) => new Text(mul2([], $.pos, __asVec(delta)), $.body, __copyAttribs($)),
+    tri: tx(Triangle),
+});

package/scatter.d.ts

@@ -1,4 +1,17 @@
 import type { IShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
+/**
+ * Produces `num` random points for which {@link pointInside} succeeeds for the
+ * given `shape`. Writes results into `out` array (or creates a new one).
+ *
+ * @remarks
+ * Samples are only created with the shapes bounding box and are chosen using
+ * optionall yprovided `rnd` {@link @thi.ng/random#IRandom} instance.
+ *
+ * @param shape
+ * @param num
+ * @param rnd
+ * @param out
+ */
 export declare const scatter: (shape: IShape, num: number, rnd?: import("@thi.ng/random/system").SystemRandom, out?: Vec[]) => Vec[] | undefined;
 //# sourceMappingURL=scatter.d.ts.map

package/scatter.js

@@ -2,6 +2,19 @@ import { SYSTEM } from "@thi.ng/random/system";
 import { randMinMax } from "@thi.ng/vectors/random";
 import { bounds } from "./bounds.js";
 import { pointInside } from "./point-inside.js";
+/**
+ * Produces `num` random points for which {@link pointInside} succeeeds for the
+ * given `shape`. Writes results into `out` array (or creates a new one).
+ *
+ * @remarks
+ * Samples are only created with the shapes bounding box and are chosen using
+ * optionall yprovided `rnd` {@link @thi.ng/random#IRandom} instance.
+ *
+ * @param shape
+ * @param num
+ * @param rnd
+ * @param out
+ */
 export const scatter = (shape, num, rnd = SYSTEM, out = []) => {
     const b = bounds(shape);
     if (!b)

package/simplify.d.ts

@@ -1,4 +1,22 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
+/**
+ * Simplifies given 2D shape boundary using Douglas-Peucker algorithm
+ * (implemented by {@link @thi.ng/geom-resample#simplify}) and given `threshold`
+ * distance (default: 0, which removes only co-linear vertices).
+ *
+ * @remarks
+ * Currently only implemented for:
+ *
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ *
+ * Use {@link asPath}, {@link asPolygon} or {@link asPolyline} to convert other
+ * shape types first.
+ *
+ * @param shape
+ * @param threshold
+ */
 export declare const simplify: MultiFn2<IShape, number, IShape>;
 //# sourceMappingURL=simplify.d.ts.map

package/simplify.js

@@ -7,8 +7,26 @@ import { Polyline } from "./api/polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
+/**
+ * Simplifies given 2D shape boundary using Douglas-Peucker algorithm
+ * (implemented by {@link @thi.ng/geom-resample#simplify}) and given `threshold`
+ * distance (default: 0, which removes only co-linear vertices).
+ *
+ * @remarks
+ * Currently only implemented for:
+ *
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ *
+ * Use {@link asPath}, {@link asPolygon} or {@link asPolyline} to convert other
+ * shape types first.
+ *
+ * @param shape
+ * @param threshold
+ */
 export const simplify = defmulti(__dispatch, {}, {
-    path: ($, eps = 0.1) => {
+    path: ($, eps = 0) => {
         const res = [];
         const orig = $.segments;
         const n = orig.length;
@@ -43,6 +61,6 @@ export const simplify = defmulti(__dispatch, {}, {
         }
         return new Path(res, __copyAttribs($));
     },
-    poly: ($, eps = 0.1) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
-    polyline: ($, eps = 0.1) => new Polyline(_simplify($.points, eps), __copyAttribs($)),
+    poly: ($, eps = 0) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
+    polyline: ($, eps = 0) => new Polyline(_simplify($.points, eps), __copyAttribs($)),
 });

package/split-at.d.ts

@@ -1,4 +1,19 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
+/**
+ * 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 declare const splitAt: MultiFn2<IShape, number, IShape[] | undefined>;
 //# sourceMappingURL=split-at.d.ts.map

package/split-at.js

@@ -13,6 +13,21 @@ 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, {}, {
     arc: ($, t) => {
         const theta = fit01(t, $.start, $.end);

package/split-near.d.ts

@@ -4,14 +4,14 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
 /**
  * Similar to {@link splitAt}, but instead of taking a normalized parametric
  * split position, splits the given curve at the closest point to `p`.
- * Returns tuple of split shapes of same type as `shape`.
  *
- * Implemented for:
+ * @remarks
+ * Currently only implemented for:
  *
- * - Cubic
- * - Line
- * - Polyline
- * - Quadratic
+ * - {@link Cubic}
+ * - {@link Line}
+ * - {@link Polyline}
+ * - {@link Quadratic}
  *
  * @param shape - shape to operate on
  * @param p - split point

package/split-near.js

@@ -15,14 +15,14 @@ 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`.
- * Returns tuple of split shapes of same type as `shape`.
  *
- * Implemented for:
+ * @remarks
+ * Currently only implemented for:
  *
- * - Cubic
- * - Line
- * - Polyline
- * - Quadratic
+ * - {@link Cubic}
+ * - {@link Line}
+ * - {@link Polyline}
+ * - {@link Quadratic}
  *
  * @param shape - shape to operate on
  * @param p - split point

package/subdiv-curve.d.ts

@@ -1,4 +1,21 @@
 import type { MultiFn2O } from "@thi.ng/defmulti";
 import type { IShape, SubdivKernel } from "@thi.ng/geom-api";
+/**
+ * Recursively applies {@link @thi.ng/geom-api#SubdivKernel} to given
+ * shape/boundary. See {@link @thi.ng/geom-subdiv-curve#} package for further
+ * details.
+ *
+ * @remarks
+ * By default only applies a single iteration.
+ *
+ * Currently only implemented for:
+ *
+ * - {@link Polygon}
+ * - {@link Polyline}
+ *
+ * @param shape
+ * @param kernel
+ * @param iter
+ */
 export declare const subdivCurve: MultiFn2O<IShape, SubdivKernel, number, IShape>;
 //# sourceMappingURL=subdiv-curve.d.ts.map

package/subdiv-curve.js

@@ -4,6 +4,23 @@ import { Polygon } from "./api/polygon.js";
 import { Polyline } from "./api/polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Recursively applies {@link @thi.ng/geom-api#SubdivKernel} to given
+ * shape/boundary. See {@link @thi.ng/geom-subdiv-curve#} package for further
+ * details.
+ *
+ * @remarks
+ * By default only applies a single iteration.
+ *
+ * Currently only implemented for:
+ *
+ * - {@link Polygon}
+ * - {@link Polyline}
+ *
+ * @param shape
+ * @param kernel
+ * @param iter
+ */
 export const subdivCurve = defmulti(__dispatch, {}, {
     poly: ($, kernel, iter = 1) => new Polygon(subdivide($.points, kernel, iter), __copyAttribs($)),
     polyline: ($, kernel, iter = 1) => new Polyline(subdivide($.points, kernel, iter), __copyAttribs($)),

package/tangent-at.d.ts

@@ -1,5 +1,24 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
+/**
+ * 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 declare const tangentAt: MultiFn2<IShape, number, Vec | undefined>;
 //# sourceMappingURL=tangent-at.d.ts.map

package/tangent-at.js

@@ -7,6 +7,25 @@ import { HALF_PI, TAU } from "@thi.ng/math/api";
 import { direction } 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, {
     quad: "poly",
     tri: "poly",

package/tessellate.d.ts

@@ -1,4 +1,15 @@
 import type { IShape, Tessellator } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
-export declare const tessellate: import("@thi.ng/defmulti").MultiFn2<IShape, Tessellator[], Vec[][]>;
+/**
+ * Recursively tessellates shape using provided
+ * {@link @thi.ng/geom-api#Tessellator} functions. See
+ * {@link @thi.ng/geom-tessellate#} package for more details.
+ *
+ * @remarks
+ * Implemented for all shapes supported by {@link vertices}.
+ *
+ * @param shape
+ * @param tessellators
+ */
+export declare const tessellate: import("@thi.ng/defmulti").MultiFn2<IShape<IShape<any>>, Tessellator[], Vec[][]>;
 //# sourceMappingURL=tessellate.d.ts.map