@expofp/geometry 3.8.0

package/README.md

@@ -0,0 +1,139 @@
+# @expofp/geometry
+
+Zero-dependency **2.5D** geometry primitives for the ExpoFP SDK: `Point`, `Line`, `Box`, `Rect`,
+`Polygon`, `Mesh`, plus the free functions that operate on them. No runtime dependencies (not even
+`three`).
+
+**"2.5D"** means: a 3D `Point` vector, but the **shapes are 2D geometry positioned in 3D by an
+`elevation`** — a flat shape at a given height. All spatial math (distance, angle, area, containment,
+intersection) is computed in the **xy plane**; `elevation` positions the shape and gates intersections
+(see Coordinate convention). The one genuinely-3D shape is `Mesh` (a triangle mesh whose vertices carry
+real `z`), for renderer geometry that isn't flat.
+
+## Primitives
+
+| Type      | What it is                                                                                                                                                                                                                                                                                                     |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Point`   | A mutable 3D vector (`x`, `y`, `z`). `width`/`height` alias `x`/`y` so a point can double as a size. The low-level building block the shapes write into.                                                                                                                                                       |
+| `Line`    | A segment between two **2D** points (`p0`, `p1`) at a single `elevation` (default 0).                                                                                                                                                                                                                          |
+| `Box`     | An **axis-aligned** rectangle (min/max corners, cached center/size). 2D, **infinite in z** (no elevation) — for bounding boxes and screen sizes. A `Box` structurally satisfies `RectLike`, so anything taking a `RectLike` accepts a `Box` (an unrotated, elevation-less rect that intersects at any height). |
+| `Rect`    | A rectangle that **may be rotated**: center + size + `rotation` + `elevation` (both default 0). For oriented rectangular shapes at a given height.                                                                                                                                                             |
+| `Polygon` | A **planar** triangulated polygon: 2D `vertices` + triangle `indices` + an `elevation`, with a cached bounding `Box`. Has `containsPoint`/`area` (well-defined because it's flat). Build a convex one from an ordered ring with `Polygon.fromConvexRing`.                                                      |
+| `Mesh`    | A **3D** triangle mesh: 3D `vertices` + `indices`, with a cached (xy) bounding `Box`. Transforms only — **no `containsPoint`/`area`** (undefined for a non-planar mesh). For renderer geometry that isn't flat.                                                                                                |
+
+`Shape = Box | Rect | Polygon | Mesh`, discriminated by `is*` brand fields and narrowed with the exported
+guards `isBox` / `isRect` / `isPolygon` / `isMesh`.
+
+**Coordinate convention:** `x` increases left→right, `y` increases top→bottom (screen, y-down). Rotation
+is in **radians, positive = clockwise**, uniform across every primitive and helper (`Rect`, `Polygon`,
+`Mesh`, and the `point*`/`line*` angle functions). `elevation` (and `Point.z`) is the out-of-plane height;
+positive is toward the viewer. **Spatial operations are computed in the xy plane** — distances, angles,
+areas, and `containsPoint` ignore `z`/`elevation`. **Intersection** tests (`lineIntersection`,
+`intersectLineRect`) compare `elevation` only when **both** operands define it (an `undefined` elevation —
+a `Box`, or a bare `LineLike` — means "any height" and always intersects); when both are defined they
+intersect only within an `elevationTolerance` (default `1e-3`), and the result point's `z` is the shared
+elevation.
+
+## Design decisions
+
+### 2.5D: 2D shapes + elevation, one 3D `Mesh`
+
+`Point` is the only inherently-3D type (a vector). Every _shape_ is 2D positioned by `elevation` (`Box`
+has none — it is infinite in z). `Polygon` is planar, so its `containsPoint`/`area` are exact; genuinely
+3D geometry uses `Mesh`, which deliberately omits those operations (a "contains point" on a non-planar
+mesh would only be an xy-silhouette test).
+
+### Immutable by default, with `set` mutators
+
+Shapes are immutable value objects: getters return readonly views and every transform returns a **new**
+instance, so shared geometry (e.g. a booth's rect) can't be mutated out from under another reader. Each
+primitive (`Point`, `Line`, `Box`, `Rect`, `Polygon`, `Mesh`) exposes a single public, docs-flagged
+`set(...)` mutator — the escape hatch the transforms write through, and the way to update fields like
+`elevation` in place.
+
+### Opt-in mutation via a `target` parameter
+
+Because immutable transforms allocate, every transform also accepts an optional **`target`** to write the
+result into instead of allocating — the same idiom three.js uses, but inverted so the default is pure:
+
+```ts
+const moved = box.translate(offset); // new Box (immutable default)
+box.translate(offset, box); // writes into box itself (opt-in mutation)
+box.translate(offset, scratch); // reuse a scratch Box in a hot loop
+```
+
+Free functions read all inputs before writing the target, so passing the input as the target
+(`f(x, …, x)`) is safe. Use `target` only where profiling shows allocation matters.
+
+### Classes + free functions (the duality)
+
+Every operation is a **pure free function** over structural `*Like` inputs, and each class exposes a
+**thin method** that forwards to it:
+
+```ts
+lineLength(line); // free function, accepts any { p0, p1 }
+line.length(); // method → lineLength(this)
+
+boxTranslate(box, offset); // free function
+box.translate(offset); // method → boxTranslate(this, offset)
+```
+
+Free functions accept structural shapes (`Point2Like`, `LineLike`, `RectLike`, `MeshLike`, …), so callers
+don't need class instances and there is no class-identity coupling. Methods give discoverability and
+chaining.
+
+### Transform/merge logic defined once (`Polygon` reuses `Mesh`)
+
+`Polygon` structurally satisfies `MeshLike` (its 2D vertices satisfy `PointLike`), so the transform and
+merge logic lives **once** on the mesh free functions — `meshTranslate` / `meshScale` / `meshRotate` /
+`meshMerge` (plus `meshBounds`). Both `Mesh`'s and `Polygon`'s methods forward to them via the optional
+`target`: a `Polygon` target keeps the result a `Polygon` (elevation preserved), a `Mesh` target keeps it
+a `Mesh`.
+
+### Structural input types
+
+Inputs are the loose `*Like` types (`Point2Like = { x, y }`, `RectLike = { center, size, rotation?,
+elevation? }`, `MeshLike`, `PolygonLike`, …); outputs are concrete class instances. Ops like `translate` /
+`expand` / `scale` take `number | Point2Like` (planar shapes such as `Box`) or `number | PointLike` (the
+3D `Point` ops) — a scalar broadcasts to both axes, a point gives per-axis values.
+
+### Brands instead of `instanceof`
+
+Each primitive carries a `readonly is<Name> = true` field (three.js style) so type discrimination
+survives duplicate module copies and serialization. The `Shape` guards check the brand rather than
+`instanceof`, and accept only a `Shape` (a stray `{ isBox: true }` object cannot masquerade as a box).
+
+## Geographic (`geo`)
+
+The `geo` module provides pure geodetic math on a WGS-84 sphere. It is a **separate
+coordinate space** from the planar primitives above — do not mix them without an
+explicit bridge.
+
+| Symbol                                          | Description                                                                             |
+| ----------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `LatLng`                                        | `{ lat: number; lng: number }` — decimal degrees; lat north-positive, lng east-positive |
+| `GeoAnchor`                                     | `{ local: Point2Like; geo: LatLng }` — a correspondence used by the projection bridge   |
+| `haversineDistance(a, b)`                       | Great-circle distance in metres                                                         |
+| `bearing(from, to)`                             | Initial compass bearing in degrees `[0, 360)`                                           |
+| `destinationPoint(from, distanceM, bearingDeg)` | Destination `LatLng` given origin, distance, and bearing                                |
+| `projectLocalToGps(point, a, b)`                | Maps a local `Point2Like` to `LatLng` via two anchors                                   |
+| `projectGpsToLocal(geo, a, b)`                  | Maps a `LatLng` to a local `Point2Like` via two anchors — inverse of above              |
+
+**Convention (different from the planar primitives):**
+
+- Coordinates are in **degrees** (not radians).
+- Bearings are **compass**: **0 = North, 90 = East, 180 = South, 270 = West**, increasing clockwise.
+- Earth radius constant: **6 371 000 m** (WGS-84 mean radius).
+
+This is deliberately firewalled from the planar convention (angles in radians,
+positive-clockwise starting from the +x axis, y-down screen coordinates,
+Euclidean distance). The only bridge is `projectLocalToGps` / `projectGpsToLocal`,
+which takes validated `GeoAnchor` inputs — no floorplan-domain logic enters `geo`.
+
+## Building
+
+Run `nx build geometry` to build the library.
+
+## Running unit tests
+
+Run `nx test geometry` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import type { Box } from './lib/box.js';
+import type { Mesh } from './lib/mesh.js';
+import type { Polygon } from './lib/polygon.js';
+import type { Rect } from './lib/rect.js';
+export * from './lib/angles.js';
+export * from './lib/box.js';
+export * from './lib/geo.js';
+export * from './lib/intersections.js';
+export * from './lib/line.js';
+export * from './lib/mesh.js';
+export * from './lib/point.js';
+export * from './lib/polygon.js';
+export * from './lib/rect.js';
+/** Any renderable geometry shape, discriminated by its `is*` brand. */
+export type Shape = Box | Rect | Polygon | Mesh;
+/**
+ * Narrows a {@link Shape} to {@link Box}. Accepts only shapes (not arbitrary values) so a stray
+ * `{ isBox: true }` object cannot masquerade as a box.
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Box}
+ */
+export declare function isBox(shape: Shape): shape is Box;
+/**
+ * Narrows a {@link Shape} to {@link Rect}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Rect}
+ */
+export declare function isRect(shape: Shape): shape is Rect;
+/**
+ * Narrows a {@link Shape} to {@link Polygon}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Polygon}
+ */
+export declare function isPolygon(shape: Shape): shape is Polygon;
+/**
+ * Narrows a {@link Shape} to {@link Mesh}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Mesh}
+ */
+export declare function isMesh(shape: Shape): shape is Mesh;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,42 @@
+export * from './lib/angles.js';
+export * from './lib/box.js';
+export * from './lib/geo.js';
+export * from './lib/intersections.js';
+export * from './lib/line.js';
+export * from './lib/mesh.js';
+export * from './lib/point.js';
+export * from './lib/polygon.js';
+export * from './lib/rect.js';
+/**
+ * Narrows a {@link Shape} to {@link Box}. Accepts only shapes (not arbitrary values) so a stray
+ * `{ isBox: true }` object cannot masquerade as a box.
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Box}
+ */
+export function isBox(shape) {
+    return 'isBox' in shape;
+}
+/**
+ * Narrows a {@link Shape} to {@link Rect}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Rect}
+ */
+export function isRect(shape) {
+    return 'isRect' in shape;
+}
+/**
+ * Narrows a {@link Shape} to {@link Polygon}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Polygon}
+ */
+export function isPolygon(shape) {
+    return 'isPolygon' in shape;
+}
+/**
+ * Narrows a {@link Shape} to {@link Mesh}. Accepts only shapes (not arbitrary values).
+ * @param shape - the shape to test
+ * @returns true when `shape` is a {@link Mesh}
+ */
+export function isMesh(shape) {
+    return 'isMesh' in shape;
+}

package/dist/lib/angles.d.ts

@@ -0,0 +1,36 @@
+import { type Point2Like } from './point.js';
+/**
+ * Converts degrees to radians.
+ * @param deg angle in degrees
+ * @returns the angle in radians
+ */
+export declare function degToRad(deg: number): number;
+/**
+ * Converts radians to degrees.
+ * @param rad angle in radians
+ * @returns the angle in degrees
+ */
+export declare function radToDeg(rad: number): number;
+/**
+ * Cartesian coordinates of a polar vector. Returns a `Point2Like`.
+ * @param radius distance from the origin
+ * @param angle angle in radians
+ * @returns `{ x: cos(angle)·radius, y: sin(angle)·radius }`
+ */
+export declare function fromPolar(radius: number, angle: number): Point2Like;
+/**
+ * Wraps `rad` into the half-open interval `(-π, π]`. Useful for comparing headings and computing
+ * signed angular deltas regardless of how many full turns the input contains.
+ * @param rad - angle in radians (any magnitude)
+ * @returns the equivalent angle in `(-π, π]`
+ */
+export declare function normalizeAngle(rad: number): number;
+/**
+ * Signed angular difference `a − b`, normalized to `(-π, π]`. Equivalent to
+ * `normalizeAngle(a - b)`. See {@link normalizeAngle}.
+ * @param a - first angle in radians
+ * @param b - second angle in radians
+ * @returns the difference `a − b` wrapped to `(-π, π]`
+ */
+export declare function angleDiff(a: number, b: number): number;
+//# sourceMappingURL=angles.d.ts.map

package/dist/lib/angles.js

@@ -0,0 +1,50 @@
+/**
+ * Converts degrees to radians.
+ * @param deg angle in degrees
+ * @returns the angle in radians
+ */
+export function degToRad(deg) {
+    return (deg * Math.PI) / 180;
+}
+/**
+ * Converts radians to degrees.
+ * @param rad angle in radians
+ * @returns the angle in degrees
+ */
+export function radToDeg(rad) {
+    return (rad * 180) / Math.PI;
+}
+/**
+ * Cartesian coordinates of a polar vector. Returns a `Point2Like`.
+ * @param radius distance from the origin
+ * @param angle angle in radians
+ * @returns `{ x: cos(angle)·radius, y: sin(angle)·radius }`
+ */
+export function fromPolar(radius, angle) {
+    return { x: Math.cos(angle) * radius, y: Math.sin(angle) * radius };
+}
+/**
+ * Wraps `rad` into the half-open interval `(-π, π]`. Useful for comparing headings and computing
+ * signed angular deltas regardless of how many full turns the input contains.
+ * @param rad - angle in radians (any magnitude)
+ * @returns the equivalent angle in `(-π, π]`
+ */
+export function normalizeAngle(rad) {
+    const TWO_PI = 2 * Math.PI;
+    let r = rad % TWO_PI;
+    if (r <= -Math.PI)
+        r += TWO_PI;
+    else if (r > Math.PI)
+        r -= TWO_PI;
+    return r;
+}
+/**
+ * Signed angular difference `a − b`, normalized to `(-π, π]`. Equivalent to
+ * `normalizeAngle(a - b)`. See {@link normalizeAngle}.
+ * @param a - first angle in radians
+ * @param b - second angle in radians
+ * @returns the difference `a − b` wrapped to `(-π, π]`
+ */
+export function angleDiff(a, b) {
+    return normalizeAngle(a - b);
+}

package/dist/lib/box.d.ts

@@ -0,0 +1,282 @@
+import type { LineLike } from './line.js';
+import { Point, type Point2Like, type SizeLike } from './point.js';
+/** Structural axis-aligned box defined by its corners. */
+export interface BoxLike {
+    /** Top-left corner. */
+    readonly min: Point2Like;
+    /** Bottom-right corner. */
+    readonly max: Point2Like;
+}
+/** One animated length on an SVG geometry element — the `{ baseVal: { value } }` chain we read. */
+interface SvgAnimatedLengthLike {
+    readonly baseVal: {
+        readonly value: number;
+    };
+}
+/**
+ * Structural shape of an SVG `<rect>` / `<image>` element — the subset {@link Box.fromSvg}
+ * reads. Declared structurally (rather than as `SVGRectElement | SVGImageElement`) so this
+ * package stays DOM-free; both DOM elements satisfy it.
+ */
+export interface SvgRectLike {
+    /** Horizontal position. */
+    readonly x: SvgAnimatedLengthLike;
+    /** Vertical position. */
+    readonly y: SvgAnimatedLengthLike;
+    /** Width. */
+    readonly width: SvgAnimatedLengthLike;
+    /** Height. */
+    readonly height: SvgAnimatedLengthLike;
+}
+/**
+ * Axis-aligned bounding box (AABB). Pure 2D, no elevation. Immutable value object: readonly getters;
+ * transforms return a new instance unless a method `target` is passed. For a rotated rectangle use
+ * {@link Rect}.
+ */
+export declare class Box {
+    /** Marker so callers can narrow the type at runtime. */
+    readonly isBox = true;
+    /** Internal mutable backing for the minimum corner. */
+    private readonly _min;
+    /** Internal mutable backing for the maximum corner. */
+    private readonly _max;
+    /** Internal mutable backing for the center point. */
+    private readonly _center;
+    /** Internal mutable backing for the size vector (x = width, y = height). */
+    private readonly _size;
+    /**
+     * Creates a box from an origin and dimensions. Negative width/height are normalized so
+     * {@link Box.min} is always the lesser corner.
+     * @param x - left edge x coordinate (default 0)
+     * @param y - top edge y coordinate (default 0)
+     * @param w - width; may be negative (default 0)
+     * @param h - height; may be negative (default 0)
+     */
+    constructor(x?: number, y?: number, w?: number, h?: number);
+    /**
+     * The lesser corner of the box (minimum x and y).
+     * @returns a readonly `{ x, y }` view of the minimum corner
+     */
+    get min(): Readonly<Point2Like>;
+    /**
+     * The greater corner of the box (maximum x and y).
+     * @returns a readonly `{ x, y }` view of the maximum corner
+     */
+    get max(): Readonly<Point2Like>;
+    /**
+     * The geometric center of the box.
+     * @returns a readonly `{ x, y }` view of the center point
+     */
+    get center(): Readonly<Point2Like>;
+    /**
+     * The size of the box. `width` aliases `x` and `height` aliases `y`.
+     * @returns a readonly size view with `x`, `y`, `width`, and `height`
+     */
+    get size(): SizeLike;
+    /**
+     * Area of the box (`width × height`). Delegates to {@link boxArea}.
+     * @returns the area in square units
+     */
+    get area(): number;
+    /**
+     * True when the box has zero extent in BOTH axes (collapsed to a point, or the
+     * default / `fromPoints([])` empty box). A degenerate line — extent in only one
+     * axis — is NOT considered empty. Delegates to {@link boxIsEmpty}.
+     * @returns true when `min === max` in both x and y
+     */
+    isEmpty(): boolean;
+    /**
+     * Constructs a box from two arbitrary corners. Corners are normalized so
+     * {@link Box.min} is always the lesser corner regardless of argument order.
+     * @param min - one corner of the box
+     * @param max - the opposite corner of the box
+     * @returns a new normalized {@link Box}
+     */
+    static fromMinMax(min: Point2Like, max: Point2Like): Box;
+    /**
+     * Constructs a box centred on `center` with the given `size`.
+     * @param center - the desired center point of the box
+     * @param size - `{ x: width, y: height }` of the box
+     * @returns a new {@link Box} centred at `center`
+     */
+    static fromCenter(center: Point2Like, size: Point2Like): Box;
+    /**
+     * Constructs the smallest box that contains every box in `boxes`.
+     * Delegates to {@link Box.fromPoints} over each box's two corners so the
+     * min/max sweep lives in one place. Zero args returns `new Box()`.
+     * @param boxes - zero or more boxes to union
+     * @returns a new {@link Box} that is the axis-aligned union of all inputs
+     */
+    static fromUnion(...boxes: BoxLike[]): Box;
+    /**
+     * Constructs the smallest axis-aligned box that encloses every point in `points`.
+     * An empty iterable returns a zero-size box at the origin (equivalent to `new Box()`).
+     * @param points - iterable of `{ x, y }` points
+     * @returns a new {@link Box} that is the AABB of all inputs, or a zero box when `points` is empty
+     */
+    static fromPoints(points: Iterable<Point2Like>): Box;
+    /**
+     * Constructs a box from an SVG `<rect>` or `<image>` element's base values.
+     * @param rect - the SVG element (or any {@link SvgRectLike}) to read dimensions from
+     * @returns a new {@link Box} matching the element's position and size
+     */
+    static fromSvg(rect: SvgRectLike): Box;
+    /**
+     * Returns true when this box overlaps `b`. Delegates to {@link boxIntersects}.
+     * @param b - the box to test intersection against
+     * @returns true when the boxes share at least one point
+     */
+    intersects(b: BoxLike): boolean;
+    /**
+     * Returns true when this box fully contains `b`. Delegates to {@link boxContains}.
+     * @param b - the box to test containment of
+     * @returns true when `b` lies entirely within this box
+     */
+    contains(b: BoxLike): boolean;
+    /**
+     * Returns true when `p` lies inside or on the boundary of this box.
+     * Delegates to {@link boxContainsPoint}.
+     * @param p - the point to test
+     * @returns true when `p` is within this box
+     */
+    containsPoint(p: Point2Like): boolean;
+    /**
+     * Returns true when this box has the same corners as `b`. Delegates to {@link boxEquals}.
+     * @param b - the box to compare against
+     * @returns true when both boxes share identical min and max corners
+     */
+    equals(b: BoxLike): boolean;
+    /**
+     * Returns the intersection of this box and `b`, or `null` when they do not overlap.
+     * Delegates to {@link boxIntersection}.
+     * @param b - the box to intersect with
+     * @param target - optional box to write the result into; defaults to a new {@link Box}
+     * @returns the intersection box, or `null` if the boxes do not overlap
+     */
+    intersection(b: BoxLike, target?: Box): Box | null;
+    /**
+     * Returns a copy of this box shifted by `offset`. Delegates to {@link boxTranslate}.
+     * @param offset - scalar (same shift on both axes) or `{ x, y }` amount to shift by
+     * @param target - optional box to write the result into; defaults to a new {@link Box}
+     * @returns the translated box
+     */
+    translate(offset: number | Point2Like, target?: Box): Box;
+    /**
+     * Returns a copy of this box expanded outward by `amount` on all sides.
+     * Delegates to {@link boxExpand}.
+     * @param amount - scalar or `{ x, y }` expansion per side
+     * @param target - optional box to write the result into; defaults to a new {@link Box}
+     * @returns the expanded box
+     */
+    expand(amount: number | Point2Like, target?: Box): Box;
+    /**
+     * Returns a copy of this box scaled by `factor` about `origin`. Delegates to {@link boxScale}.
+     * @param factor - uniform scale or per-axis `{ x, y }` scale
+     * @param origin - the fixed point of the scaling; defaults to this box's center
+     * @param target - optional box to write the result into; defaults to a new {@link Box}
+     * @returns the scaled box
+     */
+    scale(factor: number | Point2Like, origin?: Point2Like, target?: Box): Box;
+    /**
+     * Points where `line` crosses this box. Delegates to {@link intersectLineRect}.
+     * @param line - the segment
+     * @returns the intersection points
+     */
+    intersectLine(line: LineLike): Point[];
+    /**
+     * Returns an independent copy of this box, or writes into `target` when provided.
+     * @param target - optional box to write the result into; defaults to a new {@link Box}
+     * @returns the cloned box
+     */
+    clone(target?: Box): Box;
+    /**
+     * Mutates this box in place, normalizing corners so {@link Box.min} is always the lesser corner,
+     * and refreshes the derived center and size. Prefer the immutable transforms; use this (or a
+     * transform `target`) only for hot-path reuse.
+     * @param x0 - x coordinate of the first corner
+     * @param y0 - y coordinate of the first corner
+     * @param x1 - x coordinate of the opposite corner
+     * @param y1 - y coordinate of the opposite corner
+     * @returns `this`
+     */
+    set(x0: number, y0: number, x1: number, y1: number): this;
+}
+/**
+ * Area of an axis-aligned box (`width × height`).
+ * @param b - the box to measure
+ * @returns the area in square units
+ */
+export declare function boxArea(b: BoxLike): number;
+/**
+ * True when the box has zero extent in BOTH axes (collapsed to a point, or the
+ * default / `fromPoints([])` empty box). A degenerate line — extent in only one
+ * axis — is NOT empty.
+ * @param b - the box to test
+ * @returns true when `b.min === b.max` in both x and y
+ */
+export declare function boxIsEmpty(b: BoxLike): boolean;
+/**
+ * Returns true when boxes `a` and `b` share at least one point (edge-touching counts).
+ * @param a - first box
+ * @param b - second box
+ * @returns true when the boxes overlap or touch
+ */
+export declare function boxIntersects(a: BoxLike, b: BoxLike): boolean;
+/**
+ * Returns true when box `a` fully contains box `b` (boundary-inclusive).
+ * @param a - outer box
+ * @param b - inner box to test containment of
+ * @returns true when `b` lies entirely within `a`
+ */
+export declare function boxContains(a: BoxLike, b: BoxLike): boolean;
+/**
+ * Returns true when `p` lies inside or on the boundary of `b`.
+ * @param b - the box to test against
+ * @param p - the point to test
+ * @returns true when `p` is within `b`
+ */
+export declare function boxContainsPoint(b: BoxLike, p: Point2Like): boolean;
+/**
+ * Returns true when `a` and `b` have identical min and max corners.
+ * @param a - first box
+ * @param b - second box
+ * @returns true when both corners match exactly
+ */
+export declare function boxEquals(a: BoxLike, b: BoxLike): boolean;
+/**
+ * Returns the intersection of boxes `a` and `b`, or `null` when they do not overlap.
+ * @param a - first box
+ * @param b - second box
+ * @param target - optional box to write the result into; defaults to a new {@link Box}
+ * @returns the intersection box, or `null` if the boxes do not overlap
+ */
+export declare function boxIntersection(a: BoxLike, b: BoxLike, target?: Box): Box | null;
+/**
+ * Returns a copy of `b` shifted by `offset`. Pure — does not mutate `b`.
+ * @param b - source box
+ * @param offset - scalar (same shift on both axes) or `{ x, y }` translation vector
+ * @param target - optional box to write the result into; defaults to a new {@link Box}
+ * @returns the translated box
+ */
+export declare function boxTranslate(b: BoxLike, offset: number | Point2Like, target?: Box): Box;
+/**
+ * Returns a copy of `b` expanded outward by `amount` on all sides. A positive amount grows the box;
+ * a negative amount shrinks it. Shrinking an axis past zero collapses it to its midpoint (clamped to
+ * zero size) rather than inverting.
+ * @param b - source box
+ * @param amount - scalar (broadcast to x/y) or `{ x, y }` expansion per side
+ * @param target - optional box to write the result into; defaults to a new {@link Box}
+ * @returns the expanded (or zero-clamped) box
+ */
+export declare function boxExpand(b: BoxLike, amount: number | Point2Like, target?: Box): Box;
+/**
+ * Returns a copy of `b` scaled by `factor` about `origin`.
+ * @param b - source box
+ * @param factor - uniform scale or per-axis `{ x, y }` scale
+ * @param origin - the fixed point of the scaling; defaults to `b`'s center
+ * @param target - optional box to write the result into; defaults to a new {@link Box}
+ * @returns the scaled box
+ */
+export declare function boxScale(b: BoxLike, factor: number | Point2Like, origin?: Point2Like, target?: Box): Box;
+export {};
+//# sourceMappingURL=box.d.ts.map