@expofp/geometry 3.8.0

package/dist/lib/polygon.d.ts

@@ -0,0 +1,169 @@
+import { Box } from './box.js';
+import { type TriangleIndex } from './mesh.js';
+import { type Point2Like, type PointLike } from './point.js';
+/** Structural polygon: 2D vertices plus triangle indices and an optional elevation. */
+export interface PolygonLike {
+    /** Polygon vertices (2D — xy only). */
+    readonly vertices: readonly Point2Like[];
+    /** Triangle index triplets. */
+    readonly indices: readonly TriangleIndex[];
+    /** Elevation in 3D space (default 0). */
+    readonly elevation?: number;
+}
+/**
+ * A planar triangulated polygon: 2D vertices (`{ x, y }`), triangle index triplets, and an
+ * `elevation` scalar that positions the plane in 3D space. Immutable value object: readonly
+ * getters; transforms return a new instance unless a `target` is passed.
+ *
+ * Polygon structurally satisfies `MeshLike` so its transform methods can forward to the
+ * canonical mesh free functions (`meshTranslate`, `meshScale`, `meshRotate`) without duplicating
+ * any transform logic.
+ */
+export declare class Polygon {
+    /** Marker so callers can narrow the type at runtime. */
+    readonly isPolygon = true;
+    /** Internal mutable 2D vertex array. */
+    private _vertices;
+    /** Internal triangle index array. */
+    private _indices;
+    /** Elevation in 3D space. */
+    private _elevation;
+    /** Cached axis-aligned bounding box (xy only). */
+    private _bounds;
+    /**
+     * Constructs a polygon from a 2D vertex list, triangle index triplets, and an optional
+     * elevation.
+     * @param vertices - source vertices; stored as `{ x, y }` (z is dropped) (default `[]`)
+     * @param indices - triangle index triplets referencing positions in `vertices` (default `[]`)
+     * @param elevation - elevation of the plane in 3D space (default 0)
+     */
+    constructor(vertices?: readonly Point2Like[], indices?: readonly TriangleIndex[], elevation?: number);
+    /**
+     * Fan-triangulates an ordered convex ring into a {@link Polygon}.
+     *
+     * Generates triangles `[0, i, i+1]` for `i` in `1 .. n-2`. This triangulation is only valid
+     * for **convex** input rings — fan triangulation produces incorrect results for concave rings.
+     * For a concave or arbitrary shape, construct `Polygon` directly with explicit `indices`.
+     *
+     * Use `containsPoint` on the resulting polygon (via `polygonContainsPoint`) to test inclusion.
+     * @param points - ordered convex polygon vertices (CCW or CW)
+     * @param elevation - elevation of the plane in 3D space (default 0)
+     * @returns a new polygon, or an empty polygon when fewer than 3 points are given
+     */
+    static fromConvexRing(points: readonly Point2Like[], elevation?: number): Polygon;
+    /**
+     * Merges two or more polygons into a single {@link Polygon}, offsetting each polygon's
+     * triangle indices by the cumulative vertex count so they remain valid. Forwards to
+     * {@link meshMerge}.
+     * @param polygons - polygons to merge
+     * @returns a new merged polygon (elevation taken from first polygon, or 0)
+     */
+    static merge(...polygons: PolygonLike[]): Polygon;
+    /**
+     * Readonly array of polygon vertices as `{ x, y }` objects.
+     * @returns the vertex array
+     */
+    get vertices(): readonly Point2Like[];
+    /**
+     * Readonly array of triangle index triplets.
+     * @returns the index array
+     */
+    get indices(): readonly TriangleIndex[];
+    /**
+     * Elevation of this polygon's plane in 3D space.
+     * @returns the elevation
+     */
+    get elevation(): number;
+    /**
+     * Cached axis-aligned bounding {@link Box} of this polygon (xy only).
+     * @returns the bounding box
+     */
+    get bounds(): Box;
+    /**
+     * Total area of this polygon (sum of absolute triangle areas). See {@link polygonArea}.
+     * @returns the area in square units
+     */
+    get area(): number;
+    /**
+     * Returns true when `point` lies inside or on the boundary of this polygon.
+     * See {@link polygonContainsPoint}.
+     * @param point - the point to test
+     * @param opts - options controlling tolerance
+     * @param opts.areaTolerance - relative tolerance per triangle (0–1); default 0.01
+     * @returns true when `point` is contained
+     */
+    containsPoint(point: Point2Like, opts?: {
+        areaTolerance?: number;
+    }): boolean;
+    /**
+     * Returns a new polygon translated by `offset`. Forwards to {@link meshTranslate}.
+     * The elevation is preserved on the result.
+     * @param offset - 2D translation vector
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns translated polygon
+     */
+    translate(offset: Point2Like, target?: Polygon): Polygon;
+    /**
+     * Returns a new polygon scaled by `factor` about `origin`. Forwards to {@link meshScale}.
+     * The elevation is preserved on the result.
+     * @param factor - uniform scale or per-axis `{ x, y }` scale
+     * @param origin - the fixed point of the scaling; defaults to the bounding-box center
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns scaled polygon
+     */
+    scale(factor: number | Point2Like, origin?: Point2Like, target?: Polygon): Polygon;
+    /**
+     * Returns a new polygon rotated by `angle` radians about `origin`. Forwards to
+     * {@link meshRotate}.
+     * The elevation is preserved on the result.
+     * @param angle - rotation angle in radians (positive = clockwise in y-down space)
+     * @param origin - the pivot of the rotation; defaults to the bounding-box center
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns rotated polygon
+     */
+    rotate(angle: number, origin?: Point2Like, target?: Polygon): Polygon;
+    /**
+     * Mutates this polygon in place, replacing vertices/indices and optionally the elevation, then
+     * refreshing the cached bounds. Vertices are stored as 2D `{ x, y }` — any z from the input is
+     * dropped. Do not optimize this clone away; the mesh transform free functions rely on it to avoid
+     * aliasing shared vertices. When `elevation` is omitted the current elevation is preserved (this
+     * keeps the 2-arg `target.set(v, i)` forwarding path in the mesh free functions intact). Use
+     * only for hot-path reuse.
+     * @param vertices - new vertex list (z ignored)
+     * @param indices - new triangle index list
+     * @param elevation - new elevation; defaults to the current elevation when omitted
+     * @returns `this`
+     */
+    set(vertices: readonly PointLike[], indices: readonly TriangleIndex[], elevation?: number): this;
+}
+/**
+ * Total signed area of the polygon, computed as the sum of the absolute areas of each triangle
+ * in the index list (fan/shoelace per triangle). The result is always non-negative regardless of
+ * vertex winding order.
+ * @param p - polygon or polygon-like object
+ * @returns the total area in square units
+ */
+export declare function polygonArea(p: PolygonLike): number;
+/**
+ * Returns true when `point` lies inside or on the boundary of polygon `p`. The test iterates
+ * over every triangle in `p.indices` and checks whether `point` lies within any of them using a
+ * signed-area (barycentric) test. Works for both convex shapes and arbitrary triangulated meshes.
+ * Zero-area (degenerate) triangles are skipped — they have no interior and never contain a point.
+ *
+ * The optional `areaTolerance` (default `0.01`, i.e. 1%) expands each triangle's containment
+ * boundary by a margin proportional to its area, admitting points that lie just outside the
+ * strict geometric boundary.
+ * @param p - polygon or polygon-like object
+ * @param point - the point to test
+ * @param opts - options controlling the tolerance
+ * @param opts.areaTolerance - relative slack per triangle, as a fraction of that triangle's own
+ * area; default `0.01` (1%), which absorbs float/GPS boundary noise. `0` is the strict geometric
+ * test. Intended range is small (`~[0, 0.1]`); values `>= 1` let the slack reach or exceed a
+ * triangle's area and admit points well outside the polygon, so they are not meaningful for
+ * containment.
+ * @returns true when `point` is contained within any triangle (within tolerance)
+ */
+export declare function polygonContainsPoint(p: PolygonLike, point: Point2Like, opts?: {
+    areaTolerance?: number;
+}): boolean;
+//# sourceMappingURL=polygon.d.ts.map

package/dist/lib/polygon.js

@@ -0,0 +1,220 @@
+import { Box } from './box.js';
+import { meshBounds, meshMerge, meshRotate, meshScale, meshTranslate, } from './mesh.js';
+/**
+ * A planar triangulated polygon: 2D vertices (`{ x, y }`), triangle index triplets, and an
+ * `elevation` scalar that positions the plane in 3D space. Immutable value object: readonly
+ * getters; transforms return a new instance unless a `target` is passed.
+ *
+ * Polygon structurally satisfies `MeshLike` so its transform methods can forward to the
+ * canonical mesh free functions (`meshTranslate`, `meshScale`, `meshRotate`) without duplicating
+ * any transform logic.
+ */
+export class Polygon {
+    /** Marker so callers can narrow the type at runtime. */
+    isPolygon = true;
+    /** Internal mutable 2D vertex array. */
+    _vertices = [];
+    /** Internal triangle index array. */
+    _indices = [];
+    /** Elevation in 3D space. */
+    _elevation;
+    /** Cached axis-aligned bounding box (xy only). */
+    _bounds = new Box();
+    /**
+     * Constructs a polygon from a 2D vertex list, triangle index triplets, and an optional
+     * elevation.
+     * @param vertices - source vertices; stored as `{ x, y }` (z is dropped) (default `[]`)
+     * @param indices - triangle index triplets referencing positions in `vertices` (default `[]`)
+     * @param elevation - elevation of the plane in 3D space (default 0)
+     */
+    constructor(vertices = [], indices = [], elevation = 0) {
+        this._elevation = elevation;
+        this.set(vertices, indices);
+    }
+    /**
+     * Fan-triangulates an ordered convex ring into a {@link Polygon}.
+     *
+     * Generates triangles `[0, i, i+1]` for `i` in `1 .. n-2`. This triangulation is only valid
+     * for **convex** input rings — fan triangulation produces incorrect results for concave rings.
+     * For a concave or arbitrary shape, construct `Polygon` directly with explicit `indices`.
+     *
+     * Use `containsPoint` on the resulting polygon (via `polygonContainsPoint`) to test inclusion.
+     * @param points - ordered convex polygon vertices (CCW or CW)
+     * @param elevation - elevation of the plane in 3D space (default 0)
+     * @returns a new polygon, or an empty polygon when fewer than 3 points are given
+     */
+    static fromConvexRing(points, elevation = 0) {
+        if (points.length < 3)
+            return new Polygon([], [], elevation);
+        const indices = [];
+        for (let i = 1; i <= points.length - 2; i++) {
+            indices.push([0, i, i + 1]);
+        }
+        return new Polygon(points, indices, elevation);
+    }
+    /**
+     * Merges two or more polygons into a single {@link Polygon}, offsetting each polygon's
+     * triangle indices by the cumulative vertex count so they remain valid. Forwards to
+     * {@link meshMerge}.
+     * @param polygons - polygons to merge
+     * @returns a new merged polygon (elevation taken from first polygon, or 0)
+     */
+    static merge(...polygons) {
+        return meshMerge(polygons, new Polygon([], [], polygons[0]?.elevation ?? 0));
+    }
+    /**
+     * Readonly array of polygon vertices as `{ x, y }` objects.
+     * @returns the vertex array
+     */
+    get vertices() {
+        return this._vertices;
+    }
+    /**
+     * Readonly array of triangle index triplets.
+     * @returns the index array
+     */
+    get indices() {
+        return this._indices;
+    }
+    /**
+     * Elevation of this polygon's plane in 3D space.
+     * @returns the elevation
+     */
+    get elevation() {
+        return this._elevation;
+    }
+    /**
+     * Cached axis-aligned bounding {@link Box} of this polygon (xy only).
+     * @returns the bounding box
+     */
+    get bounds() {
+        return this._bounds;
+    }
+    /**
+     * Total area of this polygon (sum of absolute triangle areas). See {@link polygonArea}.
+     * @returns the area in square units
+     */
+    get area() {
+        return polygonArea(this);
+    }
+    /**
+     * Returns true when `point` lies inside or on the boundary of this polygon.
+     * See {@link polygonContainsPoint}.
+     * @param point - the point to test
+     * @param opts - options controlling tolerance
+     * @param opts.areaTolerance - relative tolerance per triangle (0–1); default 0.01
+     * @returns true when `point` is contained
+     */
+    containsPoint(point, opts) {
+        return polygonContainsPoint(this, point, opts);
+    }
+    /**
+     * Returns a new polygon translated by `offset`. Forwards to {@link meshTranslate}.
+     * The elevation is preserved on the result.
+     * @param offset - 2D translation vector
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns translated polygon
+     */
+    translate(offset, target) {
+        return meshTranslate(this, offset, target ?? new Polygon([], [], this._elevation));
+    }
+    /**
+     * Returns a new polygon scaled by `factor` about `origin`. Forwards to {@link meshScale}.
+     * The elevation is preserved on the result.
+     * @param factor - uniform scale or per-axis `{ x, y }` scale
+     * @param origin - the fixed point of the scaling; defaults to the bounding-box center
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns scaled polygon
+     */
+    scale(factor, origin = this._bounds.center, target) {
+        return meshScale(this, factor, origin, target ?? new Polygon([], [], this._elevation));
+    }
+    /**
+     * Returns a new polygon rotated by `angle` radians about `origin`. Forwards to
+     * {@link meshRotate}.
+     * The elevation is preserved on the result.
+     * @param angle - rotation angle in radians (positive = clockwise in y-down space)
+     * @param origin - the pivot of the rotation; defaults to the bounding-box center
+     * @param target - optional polygon to write into instead of allocating a new one
+     * @returns rotated polygon
+     */
+    rotate(angle, origin = this._bounds.center, target) {
+        return meshRotate(this, angle, origin, target ?? new Polygon([], [], this._elevation));
+    }
+    /**
+     * Mutates this polygon in place, replacing vertices/indices and optionally the elevation, then
+     * refreshing the cached bounds. Vertices are stored as 2D `{ x, y }` — any z from the input is
+     * dropped. Do not optimize this clone away; the mesh transform free functions rely on it to avoid
+     * aliasing shared vertices. When `elevation` is omitted the current elevation is preserved (this
+     * keeps the 2-arg `target.set(v, i)` forwarding path in the mesh free functions intact). Use
+     * only for hot-path reuse.
+     * @param vertices - new vertex list (z ignored)
+     * @param indices - new triangle index list
+     * @param elevation - new elevation; defaults to the current elevation when omitted
+     * @returns `this`
+     */
+    set(vertices, indices, elevation = this._elevation) {
+        this._vertices = vertices.map((v) => ({ x: v.x, y: v.y }));
+        this._indices = indices;
+        this._elevation = elevation;
+        this._bounds = meshBounds(this);
+        return this;
+    }
+}
+/**
+ * Total signed area of the polygon, computed as the sum of the absolute areas of each triangle
+ * in the index list (fan/shoelace per triangle). The result is always non-negative regardless of
+ * vertex winding order.
+ * @param p - polygon or polygon-like object
+ * @returns the total area in square units
+ */
+export function polygonArea(p) {
+    let area = 0;
+    for (const [ai, bi, ci] of p.indices) {
+        const va = p.vertices[ai], vb = p.vertices[bi], vc = p.vertices[ci];
+        area += Math.abs((vb.x - va.x) * (vc.y - va.y) - (vc.x - va.x) * (vb.y - va.y)) / 2;
+    }
+    return area;
+}
+/**
+ * Returns true when `point` lies inside or on the boundary of polygon `p`. The test iterates
+ * over every triangle in `p.indices` and checks whether `point` lies within any of them using a
+ * signed-area (barycentric) test. Works for both convex shapes and arbitrary triangulated meshes.
+ * Zero-area (degenerate) triangles are skipped — they have no interior and never contain a point.
+ *
+ * The optional `areaTolerance` (default `0.01`, i.e. 1%) expands each triangle's containment
+ * boundary by a margin proportional to its area, admitting points that lie just outside the
+ * strict geometric boundary.
+ * @param p - polygon or polygon-like object
+ * @param point - the point to test
+ * @param opts - options controlling the tolerance
+ * @param opts.areaTolerance - relative slack per triangle, as a fraction of that triangle's own
+ * area; default `0.01` (1%), which absorbs float/GPS boundary noise. `0` is the strict geometric
+ * test. Intended range is small (`~[0, 0.1]`); values `>= 1` let the slack reach or exceed a
+ * triangle's area and admit points well outside the polygon, so they are not meaningful for
+ * containment.
+ * @returns true when `point` is contained within any triangle (within tolerance)
+ */
+export function polygonContainsPoint(p, point, opts) {
+    const tol = opts?.areaTolerance ?? 0.01;
+    for (const [ai, bi, ci] of p.indices) {
+        const va = p.vertices[ai], vb = p.vertices[bi], vc = p.vertices[ci];
+        const triArea = Math.abs((vb.x - va.x) * (vc.y - va.y) - (vc.x - va.x) * (vb.y - va.y)) / 2;
+        // A zero-area triangle (single-point or collinear vertices) has no interior, so it
+        // contains nothing. Skip it: otherwise threshold = 0 and the barycentric test below
+        // sees every d = 0 and reports the entire plane as contained.
+        if (triArea === 0)
+            continue;
+        const threshold = tol * triArea;
+        // Barycentric signed-area test: the point is inside when d1, d2, d3 all share the
+        // same sign (or lie within the threshold margin).
+        const d1 = (point.x - vb.x) * (va.y - vb.y) - (va.x - vb.x) * (point.y - vb.y);
+        const d2 = (point.x - vc.x) * (vb.y - vc.y) - (vb.x - vc.x) * (point.y - vc.y);
+        const d3 = (point.x - va.x) * (vc.y - va.y) - (vc.x - va.x) * (point.y - va.y);
+        const hasNeg = d1 < -threshold || d2 < -threshold || d3 < -threshold;
+        const hasPos = d1 > threshold || d2 > threshold || d3 > threshold;
+        if (!(hasNeg && hasPos))
+            return true;
+    }
+    return false;
+}

package/dist/lib/rect.d.ts

@@ -0,0 +1,200 @@
+import { Box } from './box.js';
+import type { LineLike } from './line.js';
+import { Point, type Point2Like, type SizeLike } from './point.js';
+import { Polygon } from './polygon.js';
+/** Structural rotatable rect. */
+export interface RectLike {
+    /** Center point. */
+    readonly center: Point2Like;
+    /** Width/height. */
+    readonly size: Point2Like;
+    /** Rotation in radians; positive = clockwise (y-down). Defaults to 0. */
+    readonly rotation?: number;
+    /** Planar elevation (z). Defaults to 0. */
+    readonly elevation?: number;
+}
+/**
+ * A rectangle that may be rotated about its center (center + size + rotation + elevation; the
+ * unrotated box is not exposed). Immutable value object: readonly getters; transforms return new
+ * unless a method `target` is passed. Rotation in radians, positive = clockwise (y-down).
+ */
+export declare class Rect {
+    /** Marker so callers can narrow the type at runtime. */
+    readonly isRect = true;
+    /** Internal mutable backing for the center point. */
+    private readonly _center;
+    /** Internal mutable backing for the size vector (x = width, y = height). */
+    private readonly _size;
+    /** Internal mutable rotation in radians. */
+    private _rotation;
+    /** Internal mutable elevation (z). */
+    private _elevation;
+    /**
+     * Constructs a {@link Rect} from center, size, rotation, and elevation.
+     * @param center - center point `{ x, y }`
+     * @param size - dimensions `{ x: width, y: height }`
+     * @param rotation - rotation in radians, positive = clockwise (y-down); defaults to 0
+     * @param elevation - planar elevation (z); defaults to 0
+     */
+    constructor(center: Point2Like, size: Point2Like, rotation?: number, elevation?: number);
+    /**
+     * Constructs a {@link Rect} from a min/max corner pair.
+     * @param min - minimum (top-left) corner `{ x, y }`
+     * @param max - maximum (bottom-right) corner `{ x, y }`
+     * @param rotation - rotation in radians; defaults to 0
+     * @param elevation - planar elevation (z); defaults to 0
+     * @returns a new {@link Rect} whose center is the midpoint of min/max
+     */
+    static fromMinMax(min: Point2Like, max: Point2Like, rotation?: number, elevation?: number): Rect;
+    /**
+     * The center point of this rect.
+     * @returns a readonly `{ x, y }` view of the center
+     */
+    get center(): Readonly<Point2Like>;
+    /**
+     * The size (width/height) of this rect. `width` aliases `x`; `height` aliases `y`.
+     * @returns a readonly point view with `width` and `height` accessors
+     */
+    get size(): SizeLike;
+    /**
+     * Rotation in radians (positive = clockwise, y-down).
+     * @returns the current rotation
+     */
+    get rotation(): number;
+    /**
+     * Planar elevation (z coordinate of the rect plane).
+     * @returns the current elevation
+     */
+    get elevation(): number;
+    /**
+     * Returns the four corners of this rect, rotated about its center.
+     * @returns array of four {@link Point} instances: top-left, top-right, bottom-right, bottom-left
+     */
+    corners(): Point[];
+    /**
+     * The axis-aligned bounding box that contains this (possibly rotated) rect.
+     * @returns a {@link Box} representing the AABB
+     */
+    get bounds(): Box;
+    /**
+     * Converts this rect to a triangulated {@link Polygon}, embedding the elevation as `z`.
+     * @returns a {@link Polygon} with four vertices and two triangle indices
+     */
+    toPolygon(): Polygon;
+    /**
+     * Returns whether a point lies inside this (possibly rotated) rect.
+     * @param p - the point to test `{ x, y }`
+     * @returns `true` if `p` is inside or on the boundary of this rect
+     */
+    containsPoint(p: Point2Like): boolean;
+    /**
+     * Returns a new rect translated by `offset`. If `target` is provided, writes into `target`
+     * and returns it instead of allocating.
+     * @param offset - translation vector `{ x, y }`
+     * @param target - optional rect to mutate in place
+     * @returns the translated rect
+     */
+    translate(offset: Point2Like, target?: Rect): Rect;
+    /**
+     * Returns a new rect with rotation increased by `angle`. If `target` is provided, writes into
+     * `target` and returns it instead of allocating.
+     * @param angle - angle to add in radians
+     * @param target - optional rect to mutate in place
+     * @returns the rotated rect
+     */
+    rotate(angle: number, target?: Rect): Rect;
+    /**
+     * Returns a new rect scaled by `factor` about `origin`: the center moves toward/away from `origin`
+     * by `factor` and the size is multiplied by `factor`; rotation and elevation are preserved.
+     * If `target` is provided, writes into it instead of allocating.
+     * @param factor - uniform scale or per-axis `{ x, y }` scale
+     * @param origin - the fixed point of the scaling; defaults to this rect's center
+     * @param target - optional rect to mutate in place
+     * @returns the scaled rect
+     */
+    scale(factor: number | Point2Like, origin?: Point2Like, target?: Rect): Rect;
+    /**
+     * Points where `line` crosses this rect. Delegates to {@link intersectLineRect}.
+     * @param line - the segment
+     * @returns the intersection points
+     */
+    intersectLine(line: LineLike): Point[];
+    /**
+     * Returns a copy of this rect. If `target` is provided, writes into `target` and returns it.
+     * @param target - optional rect to mutate in place
+     * @returns the cloned rect
+     */
+    clone(target?: Rect): Rect;
+    /**
+     * Mutates this rect in place (center, size, rotation, elevation). Prefer the immutable
+     * transforms; use this (or a transform `target`) only for hot-path reuse.
+     * @param cx - center x
+     * @param cy - center y
+     * @param sx - size x (width)
+     * @param sy - size y (height)
+     * @param rotation - rotation in radians
+     * @param elevation - planar elevation (z)
+     * @returns `this` for chaining
+     */
+    set(cx: number, cy: number, sx: number, sy: number, rotation: number, elevation: number): this;
+}
+/**
+ * Returns the four corners of a {@link RectLike}, rotated about its center.
+ * Order: top-left, top-right, bottom-right, bottom-left.
+ * @param r - the rect-like to compute corners for
+ * @returns array of four {@link Point} instances
+ */
+export declare function rectCorners(r: RectLike): Point[];
+/**
+ * Returns the axis-aligned bounding box (AABB) that contains all four corners of a
+ * {@link RectLike}.
+ * @param r - the rect-like to compute bounds for
+ * @returns a {@link Box} representing the AABB
+ */
+export declare function rectBounds(r: RectLike): Box;
+/**
+ * Converts a {@link RectLike} to a triangulated {@link Polygon} via fan-triangulation, embedding
+ * the elevation as `z` on each vertex. Rect corners form a convex quad, so
+ * {@link Polygon.fromConvexRing} is valid here.
+ * @param r - the rect-like to convert
+ * @returns a {@link Polygon} with four vertices and two triangle indices
+ */
+export declare function rectToPolygon(r: RectLike): Polygon;
+/**
+ * Returns whether a point lies inside a (possibly rotated) {@link RectLike} by transforming the
+ * point into the rect's local axis-aligned space.
+ * @param r - the rect-like to test against
+ * @param p - the point to test `{ x, y }`
+ * @returns `true` if `p` is inside or on the boundary of `r`
+ */
+export declare function rectContainsPoint(r: RectLike, p: Point2Like): boolean;
+/**
+ * Returns a new rect translated by `offset`. If `target` is provided, writes into `target` and
+ * returns it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param offset - translation vector `{ x, y }`
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the translated rect
+ */
+export declare function rectTranslate(r: RectLike, offset: Point2Like, target?: Rect): Rect;
+/**
+ * Returns a new rect with rotation increased by `angle`. If `target` is provided, writes into
+ * `target` and returns it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param angle - angle to add in radians
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the rotated rect
+ */
+export declare function rectRotate(r: RectLike, angle: number, target?: Rect): Rect;
+/**
+ * Returns a new rect scaled by `factor` about `origin`: the center moves toward/away from `origin`
+ * by `factor` and the size is multiplied by `factor`; rotation and elevation are preserved. If
+ * `target` is provided, writes into it instead of allocating a new instance.
+ * @param r - the source rect-like
+ * @param factor - uniform scale or per-axis `{ x, y }` scale
+ * @param origin - the fixed point of the scaling; defaults to `r`'s center
+ * @param target - optional {@link Rect} to mutate in place
+ * @returns the scaled rect
+ */
+export declare function rectScale(r: RectLike, factor: number | Point2Like, origin?: Point2Like, target?: Rect): Rect;
+//# sourceMappingURL=rect.d.ts.map