@thi.ng/geom 3.2.6 → 3.4.0

package/bounds.d.ts

@@ -1,4 +1,32 @@
-import type { MultiFn1 } from "@thi.ng/defmulti";
+import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { AABBLike, IShape } from "@thi.ng/geom-api";
-export declare const bounds: MultiFn1<IShape, AABBLike | undefined>;
+/**
+ * Computes and returns bounding rect/box for the given shape, optionally with
+ * extra uniform margin/padding (default: 0). For groups, the compound bounds of
+ * all children will be returned.
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Text} - (no way to compute size, only position & any margin)
+ *
+ * @param shape
+ * @param margin
+ */
+export declare const bounds: MultiFn1O<IShape, number, AABBLike | undefined>;
 //# sourceMappingURL=bounds.d.ts.map

package/bounds.js

@@ -7,18 +7,46 @@ import { comp } from "@thi.ng/transducers/comp";
 import { filter } from "@thi.ng/transducers/filter";
 import { iterator1 } from "@thi.ng/transducers/iterator";
 import { map } from "@thi.ng/transducers/map";
+import { addN2 } from "@thi.ng/vectors/addn";
 import { max } from "@thi.ng/vectors/max";
 import { min } from "@thi.ng/vectors/min";
 import { mul2 } from "@thi.ng/vectors/mul";
 import { mulN2 } from "@thi.ng/vectors/muln";
-import { set2 } from "@thi.ng/vectors/set";
 import { sub2 } from "@thi.ng/vectors/sub";
 import { subN2 } from "@thi.ng/vectors/subn";
-import { aabbFromMinMax } from "./aabb.js";
+import { aabbFromMinMaxWithMargin } from "./aabb.js";
 import { Rect } from "./api/rect.js";
 import { __collBounds } from "./internal/bounds.js";
 import { __dispatch } from "./internal/dispatch.js";
-import { rectFromMinMax } from "./rect.js";
+import { rectFromMinMaxWithMargin } from "./rect.js";
+/**
+ * Computes and returns bounding rect/box for the given shape, optionally with
+ * extra uniform margin/padding (default: 0). For groups, the compound bounds of
+ * all children will be returned.
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Text} - (no way to compute size, only position & any margin)
+ *
+ * @param shape
+ * @param margin
+ */
 export const bounds = defmulti(__dispatch, {
     aabb: "rect",
     bpatch: "points",
@@ -27,24 +55,29 @@ export const bounds = defmulti(__dispatch, {
     quad: "points",
     tri: "points",
 }, {
-    arc: ($) => rectFromMinMax(...arcBounds($.pos, $.r, $.axis, $.start, $.end)),
-    circle: ($) => new Rect(subN2([], $.pos, $.r), mulN2(null, [2, 2], $.r)),
-    cubic: ({ points }) => rectFromMinMax(...cubicBounds(points[0], points[1], points[2], points[3])),
-    ellipse: ($) => new Rect(sub2([], $.pos, $.r), mul2(null, [2, 2], $.r)),
-    group: ($) => {
+    arc: ($, margin = 0) => rectFromMinMaxWithMargin(...arcBounds($.pos, $.r, $.axis, $.start, $.end), margin),
+    circle: ($, margin = 0) => new Rect(subN2([], $.pos, $.r + margin), mulN2(null, [2, 2], $.r + margin)),
+    cubic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(...cubicBounds(points[0], points[1], points[2], points[3]), margin),
+    ellipse: ($, margin = 0) => {
+        const r = addN2([], $.r, margin);
+        return new Rect(sub2([], $.pos, r), mul2(null, [2, 2], r));
+    },
+    group: ($, margin = 0) => {
         const res = __collBounds($.children, bounds);
-        return res ? new Rect(...res) : undefined;
+        return res ? new Rect(...res).offset(margin) : undefined;
     },
-    line: ({ points: [a, b] }) => rectFromMinMax(min([], a, b), max([], a, b)),
-    path: (path) => {
+    line: ({ points: [a, b] }, margin = 0) => rectFromMinMaxWithMargin(min([], a, b), max([], a, b), margin),
+    path: (path, margin = 0) => {
         const b = __collBounds([
             ...iterator1(comp(map((s) => s.geo), filter((s) => !!s)), path.segments),
         ], bounds);
-        return b ? new Rect(...b) : undefined;
+        return b ? new Rect(...b).offset(margin) : undefined;
     },
-    points: ($) => rectFromMinMax(...bounds2($.points)),
-    points3: ($) => aabbFromMinMax(...bounds3($.points)),
-    quadratic: ({ points }) => rectFromMinMax(...quadraticBounds(points[0], points[1], points[2])),
-    rect: ($) => $.copy(),
-    text: ($) => new Rect(set2([], $.pos), [0, 0]),
+    points: ($, margin = 0) => rectFromMinMaxWithMargin(...bounds2($.points), margin),
+    points3: ($, margin = 0) => aabbFromMinMaxWithMargin(...bounds3($.points), margin),
+    quadratic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(...quadraticBounds(points[0], points[1], points[2]), margin),
+    rect: ($, margin = 0) => margin === 0
+        ? $.copy()
+        : $.copy().offset(margin),
+    text: ($, margin = 0) => new Rect(subN2([], $.pos, margin), margin * 2),
 });

package/center.d.ts

@@ -1,5 +1,16 @@
 import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import { ReadonlyVec } from "@thi.ng/vectors/api";
+/**
+ * Returns copy of given shape centered around optionally provided point `p`
+ * (default: worldspace origin).
+ *
+ * @remarks
+ * Implemented for all shape types supported by {@link centroid} and
+ * {@link translate}.
+ *
+ * @param shape
+ * @param p
+ */
 export declare const center: MultiFn1O<IShape, ReadonlyVec, IShape | undefined>;
 //# sourceMappingURL=center.d.ts.map

package/center.js

@@ -10,6 +10,17 @@ import { centroid } from "./centroid.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { translate } from "./translate.js";
+/**
+ * Returns copy of given shape centered around optionally provided point `p`
+ * (default: worldspace origin).
+ *
+ * @remarks
+ * Implemented for all shape types supported by {@link centroid} and
+ * {@link translate}.
+ *
+ * @param shape
+ * @param p
+ */
 export const center = defmulti(__dispatch, {}, {
     [DEFAULT]: ($, origin = ZERO3) => {
         const c = centroid($);

package/centroid.d.ts

@@ -1,5 +1,32 @@
 import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
+/**
+ * Computes centroid of given shape, writes result in optionally provided output
+ * vector (or creates new one if omitted).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Text} - (no way to compute size, only position & any margin)
+ *
+ * @param shape
+ * @param out
+ */
 export declare const centroid: MultiFn1O<IShape, Vec, Vec | undefined>;
 //# sourceMappingURL=centroid.d.ts.map

package/centroid.js

@@ -2,16 +2,44 @@ import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { centerOfWeight2 } from "@thi.ng/geom-poly-utils/center-of-weight";
 import { centroid as _centroid } from "@thi.ng/geom-poly-utils/centroid";
 import { add } from "@thi.ng/vectors/add";
-import { divN } from "@thi.ng/vectors/divn";
+import { addmN } from "@thi.ng/vectors/addmn";
 import { maddN } from "@thi.ng/vectors/maddn";
 import { mixN } from "@thi.ng/vectors/mixn";
 import { mulN } from "@thi.ng/vectors/muln";
 import { set } from "@thi.ng/vectors/set";
 import { bounds } from "./bounds.js";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Computes centroid of given shape, writes result in optionally provided output
+ * vector (or creates new one if omitted).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Text} - (no way to compute size, only position & any margin)
+ *
+ * @param shape
+ * @param out
+ */
 export const centroid = defmulti(__dispatch, {
     arc: "circle",
     aabb: "rect",
+    bpatch: "points",
     ellipse: "circle",
     line3: "line",
     points3: "points",
@@ -22,14 +50,14 @@ export const centroid = defmulti(__dispatch, {
     tri3: "tri",
 }, {
     circle: ($, out) => set(out || [], $.pos),
-    group: ($) => {
+    group: ($, out) => {
         const b = bounds($);
-        return b ? centroid(b) : undefined;
+        return b ? centroid(b, out) : undefined;
     },
     line: ({ points }, out) => mixN(out || [], points[0], points[1], 0.5),
     points: ($, out) => _centroid($.points, out),
     plane: ($, out) => mulN(out || [], $.normal, $.w),
     poly: ($, out) => centerOfWeight2($.points, out),
     rect: ($, out) => maddN(out || [], $.size, 0.5, $.pos),
-    tri: ({ points }, out) => divN(null, add(null, add(out || [], points[0], points[1]), points[2]), 3),
+    tri: ({ points }, out) => addmN(null, add(out || [], points[0], points[1]), points[2], 1 / 3),
 });

package/classify-point.d.ts

@@ -1,5 +1,28 @@
 import type { MultiFn2O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+/**
+ * Classifies point `p` with respect to given shape. Returns -1 if `p` is
+ * inside, 1 if outside  or 0 if `p` is on the shape boundary (using optional
+ * tolerance `eps`, default: 1e-6).
+ *
+ * @remarks
+ * Currently only implemented for:
+ *
+ * - {@link Circle}
+ * - {@link Plane}
+ * - {@link Sphere}
+ * - {@link Triangle}
+ *
+ * The {@link @thi.ng/geom-sdf#} package provides a much more comprehensive
+ * feature set (incl. support for more shapes) to perform similar checks as this
+ * function.
+ *
+ * Also see {@link pointInside}.
+ *
+ * @param shape
+ * @param p
+ * @param eps
+ */
 export declare const classifyPoint: MultiFn2O<IShape, ReadonlyVec, number, number>;
 //# sourceMappingURL=classify-point.d.ts.map

package/classify-point.js

@@ -4,6 +4,29 @@ import { sign } from "@thi.ng/math/abs";
 import { EPS } from "@thi.ng/math/api";
 import { dot } from "@thi.ng/vectors/dot";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Classifies point `p` with respect to given shape. Returns -1 if `p` is
+ * inside, 1 if outside  or 0 if `p` is on the shape boundary (using optional
+ * tolerance `eps`, default: 1e-6).
+ *
+ * @remarks
+ * Currently only implemented for:
+ *
+ * - {@link Circle}
+ * - {@link Plane}
+ * - {@link Sphere}
+ * - {@link Triangle}
+ *
+ * The {@link @thi.ng/geom-sdf#} package provides a much more comprehensive
+ * feature set (incl. support for more shapes) to perform similar checks as this
+ * function.
+ *
+ * Also see {@link pointInside}.
+ *
+ * @param shape
+ * @param p
+ * @param eps
+ */
 export const classifyPoint = defmulti(__dispatch, { sphere: "circle" }, {
     circle: ($, p, eps = EPS) => classifyPointInCircle(p, $.pos, $.r, eps),
     plane: ($, p, eps) => sign(dot($.normal, p) - $.w, eps),

package/clip-convex.d.ts

@@ -1,5 +1,18 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+/**
+ * Takes a shape and a boundary (both convex). Uses the Sutherland-Hodgman
+ * algorithm to compute a clipped version of the first shape (against the
+ * boundary). Returns `undefined` if there're no remaining result vertices.
+ *
+ * @remarks
+ * Internally uses {@link @thi.ng/geom-clip-poly#sutherlandHodgeman}. For
+ * groups, calls itself for each child shape individually and returns a new
+ * group of results (if any).
+ *
+ * @param shape
+ * @param boundary
+ */
 export declare const clipConvex: MultiFn2<IShape, IShape | ReadonlyVec[], IShape | undefined>;
 //# sourceMappingURL=clip-convex.d.ts.map

package/clip-convex.js

@@ -8,6 +8,19 @@ import { Polygon } from "./api/polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { ensureVertices, vertices } from "./vertices.js";
+/**
+ * Takes a shape and a boundary (both convex). Uses the Sutherland-Hodgman
+ * algorithm to compute a clipped version of the first shape (against the
+ * boundary). Returns `undefined` if there're no remaining result vertices.
+ *
+ * @remarks
+ * Internally uses {@link @thi.ng/geom-clip-poly#sutherlandHodgeman}. For
+ * groups, calls itself for each child shape individually and returns a new
+ * group of results (if any).
+ *
+ * @param shape
+ * @param boundary
+ */
 export const clipConvex = defmulti(__dispatch, {
     circle: "rect",
     ellipse: "rect",
@@ -23,7 +36,9 @@ export const clipConvex = defmulti(__dispatch, {
             if (res)
                 clipped.push(res);
         }
-        return new Group({ ...attribs }, clipped);
+        return clipped.length
+            ? new Group({ ...attribs }, clipped)
+            : undefined;
     },
     line: ($, boundary) => {
         const segments = clipLineSegmentPoly($.points[0], $.points[1], ensureVertices(boundary));

package/closest-point.d.ts

@@ -1,5 +1,31 @@
 import type { MultiFn2O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+/**
+ * Computes closest point to `p` on boundary of given shape. Writes result in
+ * optionally provided output vector (or creates new one if omitted).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Line}
+ * - {@link Plane}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Rect}
+ * - {@link Sphere}
+ *
+ * @param shape
+ * @param p
+ * @param out
+ */
 export declare const closestPoint: MultiFn2O<IShape, ReadonlyVec, Vec, Vec | undefined>;
 //# sourceMappingURL=closest-point.d.ts.map

package/closest-point.js

@@ -9,8 +9,35 @@ import { closestPointCubic } from "@thi.ng/geom-splines/cubic-closest-point";
 import { closestPointQuadratic } from "@thi.ng/geom-splines/quadratic-closest-point";
 import { add2, add3 } from "@thi.ng/vectors/add";
 import { __dispatch } from "./internal/dispatch.js";
+/**
+ * Computes closest point to `p` on boundary of given shape. Writes result in
+ * optionally provided output vector (or creates new one if omitted).
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Line}
+ * - {@link Plane}
+ * - {@link Points}
+ * - {@link Points3}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Rect}
+ * - {@link Sphere}
+ *
+ * @param shape
+ * @param p
+ * @param out
+ */
 export const closestPoint = defmulti(__dispatch, {
     quad: "poly",
+    points3: "points",
     sphere: "circle",
     tri: "poly",
 }, {

package/convex-hull.d.ts

@@ -1,4 +1,25 @@
 import type { MultiFn1 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
+/**
+ * Computes the convex hull for given shape and returns it as {@link Polygon}.
+ *
+ * @remarks
+ * Internally uses {@link @thi.ng/geom-hull#grahamScan2}.
+ *
+ * Currently implemented for:
+ *
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Ellipse}
+ * - {@link Group} (only the listed child shape types are considered)
+ * - {@link Points}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ */
 export declare const convexHull: MultiFn1<IShape, IShape>;
 //# sourceMappingURL=convex-hull.d.ts.map

package/convex-hull.js

@@ -4,15 +4,40 @@ import { Polygon } from "./api/polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
+/**
+ * Computes the convex hull for given shape and returns it as {@link Polygon}.
+ *
+ * @remarks
+ * Internally uses {@link @thi.ng/geom-hull#grahamScan2}.
+ *
+ * Currently implemented for:
+ *
+ * - {@link Arc}
+ * - {@link Circle}
+ * - {@link Ellipse}
+ * - {@link Group} (only the listed child shape types are considered)
+ * - {@link Points}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ */
 export const convexHull = defmulti(__dispatch, {
+    arc: "group",
     circle: "tri",
+    cubic: "group",
     ellipse: "tri",
+    line: "tri",
     poly: "points",
     polyline: "points",
     quad: "points",
+    quadratic: "group",
     rect: "tri",
 }, {
-    group: ($) => new Polygon(vertices($), __copyAttribs($)),
+    group: ($) => new Polygon(grahamScan2(vertices($)), __copyAttribs($)),
     points: ($) => new Polygon(grahamScan2($.points), __copyAttribs($)),
-    tri: ($) => $.copy(),
+    tri: ($) => new Polygon(vertices($), __copyAttribs($)),
 });

package/edges.d.ts

@@ -1,5 +1,31 @@
 import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
 import type { VecPair } from "@thi.ng/vectors";
+/**
+ * Extracts the edges of given shape's boundary and returns them as an iterable
+ * of vector pairs. Some shapes also support
+ * {@link @thi.ng/geom-api#SamplingOpts}.
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param opts
+ */
 export declare const edges: MultiFn1O<IShape, number | Partial<SamplingOpts>, Iterable<VecPair>>;
 //# sourceMappingURL=edges.d.ts.map

package/edges.js

@@ -1,10 +1,41 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { asPolygon } from "./as-polygon.js";
+import { asPolyline } from "./as-polyline.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __edges } from "./internal/edges.js";
 import { vertices } from "./vertices.js";
+/**
+ * Extracts the edges of given shape's boundary and returns them as an iterable
+ * of vector pairs. Some shapes also support
+ * {@link @thi.ng/geom-api#SamplingOpts}.
+ *
+ * @remarks
+ * Currently implemented for:
+ *
+ * - {@link AABB}
+ * - {@link Arc}
+ * - {@link BPatch}
+ * - {@link Circle}
+ * - {@link Cubic}
+ * - {@link Ellipse}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Polyline}
+ * - {@link Quad}
+ * - {@link Quadratic}
+ * - {@link Rect}
+ * - {@link Triangle}
+ *
+ * @param shape
+ * @param opts
+ */
 export const edges = defmulti(__dispatch, {
+    cubic: "arc",
+    ellipse: "circle",
     line: "polyline",
     quad: "poly",
+    quadratic: "arc",
     tri: "poly",
 }, {
     aabb: ($) => {
@@ -24,6 +55,10 @@ export const edges = defmulti(__dispatch, {
             [d, h], // right
         ];
     },
+    arc: ($, opts) => __edges(asPolyline($, opts).points, false),
+    bpatch: ($) => $.edges(),
+    circle: ($, opts) => __edges(asPolygon($, opts).points, true),
+    path: ($, opts) => __edges(asPolygon($, opts).points, $.closed),
     poly: ($) => __edges($.points, true),
     polyline: ($) => __edges($.points),
     rect: ($) => __edges(vertices($), true),

package/fit-into-bounds.d.ts

@@ -1,7 +1,26 @@
 import type { IShape } from "@thi.ng/geom-api";
 import type { AABB } from "./api/aabb.js";
 import { Rect } from "./api/rect.js";
-export declare const fitIntoBounds2: (shape: IShape, dest: Rect) => IShape | undefined;
-export declare const fitIntoBounds3: (shape: IShape, dest: AABB) => IShape | undefined;
-export declare const fitAllIntoBounds2: (shapes: IShape[], dest: Rect) => IShape[] | undefined;
+/**
+ * Uniformly rescales & repositions given 2D `shape` such that it fits into
+ * destination bounds. Returns transformed copy of `shape`.
+ *
+ * @param shape
+ * @param dest
+ */
+export declare const fitIntoBounds2: (shape: IShape, dest: Rect) => IShape<IShape<any>> | undefined;
+/**
+ * 3D version of {@link fitIntoBounds2}.
+ *
+ * @param shape
+ * @param dest
+ */
+export declare const fitIntoBounds3: (shape: IShape, dest: AABB) => IShape<IShape<any>> | undefined;
+/**
+ * Version of {@link fitIntoBounds2} for multiple source shapes.
+ *
+ * @param shapes
+ * @param dest
+ */
+export declare const fitAllIntoBounds2: (shapes: IShape[], dest: Rect) => IShape<IShape<any>>[] | undefined;
 //# sourceMappingURL=fit-into-bounds.d.ts.map