@logomarks/core 0.1.9 → 0.2.0

package/src/sdf/gap.js

@@ -0,0 +1,42 @@
+/**
+ * The house gap in fields: cuts that stay exactly g wide, and one shape laid over another.
+ */
+import { segT } from './fields.js';
+
+/**
+ * A band g wide cut along each line, its edges left crisp.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {readonly (readonly (readonly number[])[])[]} lines Segments or polylines, each a list of points.
+ * @param {number} g The gap.
+ * @returns {import('./index.js').Field} The field, cut.
+ */
+export const gapCut = (f, lines, g) => (x, y) => {
+	let m = Infinity;
+	for (const L of lines) for (let i = 1; i < L.length; i++) m = Math.min(m, segT(L[i - 1], L[i], x, y)[0]);
+	return Math.max(f(x, y), g / 2 - m);
+};
+
+/**
+ * One field laid over another, cut free of it by the gap. `front` must be a true distance near its edge.
+ *
+ * @param {import('./index.js').Field} back The field behind.
+ * @param {import('./index.js').Field} front The field in front.
+ * @param {number} g The gap.
+ * @returns {import('./index.js').Field} Both, front over back.
+ */
+export const fover = (back, front, g) => (x, y) => Math.min(front(x, y), Math.max(back(x, y), g - front(x, y)));
+
+/**
+ * Two fields linked: a over b where `aOver` holds (a half-plane, say), b over a elsewhere.
+ *
+ * @param {import('./index.js').Field} a One field.
+ * @param {import('./index.js').Field} b The other.
+ * @param {number} g The gap.
+ * @param {(x: number, y: number) => boolean} aOver Where a goes over.
+ * @returns {import('./index.js').Field} The link.
+ */
+export const flink = (a, b, g, aOver) => {
+	const ab = fover(b, a, g), ba = fover(a, b, g);
+	return (x, y) => (aOver(x, y) ? ab(x, y) : ba(x, y));
+};

package/src/sdf/index.d.ts

@@ -0,0 +1,58 @@
+import type { Shape } from '../geometry/types.js';
+
+/** A signed distance field: (x, y) → distance, negative inside, positive outside. */
+export type Field = (x: number, y: number) => number;
+/** A point. */
+export type Pt = readonly number[];
+
+/** A disc. */
+export function sdCircle(cx: number, cy: number, r: number): Field;
+/** The distance to the segment a–b, and t (0 at a, 1 at b) where the nearest point lies. */
+export function segT(a: Pt, b: Pt, x: number, y: number): [number, number];
+/** The segment a–b with round ends, w wide. */
+export function sdCapsule(a: Pt, b: Pt, w: number): Field;
+/** A round-ended stroke along a polyline, w wide (or w(t) along the run). */
+export function sdPath(pts: readonly Pt[], w: number | ((t: number) => number)): Field;
+/** Points along an arc from a0 to a1 degrees (y down), n + 1 of them (n = 48). */
+export function arcPts(cx: number, cy: number, r: number, a0: number, a1: number, n?: number): [number, number][];
+/** A rounded box centred on (cx, cy). */
+export function sdBox(cx: number, cy: number, w: number, h: number, r?: number): Field;
+/** An ellipse turned deg, as a scaled disc (approximate). */
+export function sdEllipse(cx: number, cy: number, rx: number, ry: number, deg?: number): Field;
+/** A ring of centre-line radius r and width w. */
+export function sdRing(cx: number, cy: number, r: number, w: number): Field;
+/** A polygon, exact. */
+export function sdPoly(pts: readonly Pt[]): Field;
+
+/** A band w wide along a field's zero line. */
+export function shell(f: Field, w: number): Field;
+/** A field turned deg about (cx, cy) (256, 256). */
+export function turn(f: Field, deg: number, cx?: number, cy?: number): Field;
+/** A field grown (d > 0) or shrunk (d < 0). */
+export function offset(f: Field, d: number): Field;
+/** The polynomial smooth minimum of two distances, blend k. */
+export function smin2(a: number, b: number, k: number): number;
+/** A smooth union, blend k. */
+export function smin(k: number, ...fs: Field[]): Field;
+/** A smooth intersection, blend k. */
+export function smax(k: number, ...fs: Field[]): Field;
+/** a minus b, the cut's edges softened by k. */
+export function ssub(k: number, a: Field, b: Field): Field;
+/** A sharp union. */
+export function fmin(...fs: Field[]): Field;
+/** A sharp intersection. */
+export function fmax(...fs: Field[]): Field;
+/** a minus b, sharp. */
+export function fsub(a: Field, b: Field): Field;
+
+/** A band g wide cut along each line (a list of points), edges crisp. */
+export function gapCut(f: Field, lines: readonly (readonly Pt[])[], g: number): Field;
+/** front laid over back, cut free of it by the gap. */
+export function fover(back: Field, front: Field, g: number): Field;
+/** a over b where aOver holds, b over a elsewhere. */
+export function flink(a: Field, b: Field, g: number, aOver: (x: number, y: number) => boolean): Field;
+
+/** A field's zero contour traced into a kit shape (marching squares, step h = 1, over −64…576). */
+export function shapeOf(f: Field, area?: { h?: number; x0?: number; y0?: number; x1?: number; y1?: number }): Shape;
+
+export { pinch, ballArm, node, blob, stadium } from './y2k.js';

package/src/sdf/index.js

@@ -0,0 +1,14 @@
+/**
+ * @module @logomarks/core/sdf
+ *
+ * Shapes drawn as signed distance fields and traced to polygons, so unions melt into each other with real fillets
+ * (a smooth minimum) instead of meeting at a crease. A field is (x, y) → distance, negative inside, on the 512 canvas.
+ * Build fields, combine them (smin, smax, ssub, fmin, fmax, fsub), cut the house gap (gapCut, fover, flink), then
+ * shapeOf() traces the result into a kit shape for the usual booleans and fit.
+ * The Y2K parts (pinch, ballArm, node, blob, stadium) are built from them.
+ */
+export { sdCircle, segT, sdCapsule, sdPath, arcPts, sdBox, sdEllipse, sdRing, sdPoly } from './fields.js';
+export { shell, turn, offset, smin2, smin, smax, ssub, fmin, fmax, fsub } from './ops.js';
+export { gapCut, fover, flink } from './gap.js';
+export { shapeOf } from './trace.js';
+export { pinch, ballArm, node, blob, stadium } from './y2k.js';

package/src/sdf/ops.js

@@ -0,0 +1,102 @@
+/**
+ * Combining and changing fields: smooth and sharp unions, intersections and cuts, turns, offsets and outlines.
+ */
+
+/**
+ * A band along a field's zero line: any outline turned into a ring of width w.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} w The band's width.
+ * @returns {import('./index.js').Field} The band.
+ */
+export const shell = (f, w) => (x, y) => Math.abs(f(x, y)) - w / 2;
+
+/**
+ * A field turned about a point.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} deg The turn, in degrees (clockwise on the y-down canvas).
+ * @param {number} [cx] The pivot (256).
+ * @param {number} [cy] The pivot (256).
+ * @returns {import('./index.js').Field} The turned field.
+ */
+export const turn = (f, deg, cx = 256, cy = 256) => {
+	const a = (-deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return (x, y) => f(cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c);
+};
+
+/**
+ * A field grown (d > 0) or shrunk (d < 0). Shrinking a polygon by k and growing it back rounds its convex corners to k.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} d How far.
+ * @returns {import('./index.js').Field} The field, offset.
+ */
+export const offset = (f, d) => (x, y) => f(x, y) - d;
+
+/**
+ * The polynomial smooth minimum of two distances: a union whose seam melts into a fillet about k wide.
+ *
+ * @param {number} a One distance.
+ * @param {number} b The other.
+ * @param {number} k The blend (0 for a sharp minimum).
+ * @returns {number} The blended distance.
+ */
+export const smin2 = (a, b, k) => {
+	if (k <= 0) return Math.min(a, b);
+	const h = Math.max(k - Math.abs(a - b), 0) / k;
+	return Math.min(a, b) - (h * h * k) / 4;
+};
+
+/**
+ * A smooth union.
+ *
+ * @param {number} k The blend.
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their union, seams filleted.
+ */
+export const smin = (k, ...fs) => (x, y) => fs.reduce((m, f, i) => (i ? smin2(m, f(x, y), k) : f(x, y)), 0);
+
+/**
+ * A smooth intersection.
+ *
+ * @param {number} k The blend.
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their intersection, edges softened.
+ */
+export const smax = (k, ...fs) => (x, y) => -fs.reduce((m, f, i) => (i ? smin2(m, -f(x, y), k) : -f(x, y)), 0);
+
+/**
+ * One field cut by another, the cut's edges softened.
+ *
+ * @param {number} k The blend.
+ * @param {import('./index.js').Field} a The field.
+ * @param {import('./index.js').Field} b What is cut out of it.
+ * @returns {import('./index.js').Field} a minus b.
+ */
+export const ssub = (k, a, b) => (x, y) => -smin2(-a(x, y), b(x, y), k);
+
+/**
+ * A sharp union.
+ *
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their union.
+ */
+export const fmin = (...fs) => (x, y) => Math.min(...fs.map((f) => f(x, y)));
+
+/**
+ * A sharp intersection.
+ *
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their intersection.
+ */
+export const fmax = (...fs) => (x, y) => Math.max(...fs.map((f) => f(x, y)));
+
+/**
+ * A sharp cut.
+ *
+ * @param {import('./index.js').Field} a The field.
+ * @param {import('./index.js').Field} b What is cut out of it.
+ * @returns {import('./index.js').Field} a minus b.
+ */
+export const fsub = (a, b) => (x, y) => Math.max(a(x, y), -b(x, y));

package/src/sdf/trace.js

@@ -0,0 +1,90 @@
+/**
+ * Tracing a field into a kit shape: marching squares on its zero contour, so the kit's booleans work on the result.
+ */
+import { X } from '../geometry/index.js';
+
+/**
+ * A closed ring with the points that lie (within tol) on the line through their neighbours dropped.
+ *
+ * @param {number[][]} r The ring.
+ * @param {number} [tol] How far off the line a point must be to stay (0.04).
+ * @returns {number[][]} The ring, thinned.
+ */
+const thin = (r, tol = 0.04) => {
+	const out = [];
+	for (let i = 0; i < r.length; i++) {
+		const a = out.length ? out[out.length - 1] : r[r.length - 1], p = r[i], b = r[(i + 1) % r.length];
+		const L = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1e-9, d = Math.abs((b[0] - a[0]) * (a[1] - p[1]) - (a[0] - p[0]) * (b[1] - a[1])) / L;
+		if (d > tol) out.push(p);
+	}
+	return out;
+};
+
+/**
+ * A field's zero contour (inside < 0) as a kit shape: marching squares on a grid of step h with linear interpolation,
+ * saddles split by the cell's mean, rings XORed so holes come out as holes.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {{ h?: number, x0?: number, y0?: number, x1?: number, y1?: number }} [area] The grid step (1) and the area
+ *   traced (−64 to 576 each way).
+ * @returns {import('../geometry/types.js').Shape} The shape (empty when the field is nowhere inside).
+ */
+export function shapeOf(f, { h = 1, x0 = -64, y0 = -64, x1 = 576, y1 = 576 } = {}) {
+	const nx = Math.ceil((x1 - x0) / h) + 1, ny = Math.ceil((y1 - y0) / h) + 1, v = new Float64Array(nx * ny);
+	for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+		let d = f(x0 + i * h, y0 + j * h);
+		if (d === 0) d = 1e-9;
+		v[j * nx + i] = d;
+	}
+	const V = (/** @type {number} */ i, /** @type {number} */ j) => v[j * nx + i];
+	/** @type {Map<string, number[]>} */ const P = new Map();
+	/** @type {Map<string, string[]>} */ const adj = new Map();
+	// an edge point, keyed by its grid edge: 'h' runs from (i, j) to (i+1, j), 'v' from (i, j) to (i, j+1)
+	const pt = (/** @type {'h' | 'v'} */ kind, /** @type {number} */ i, /** @type {number} */ j) => {
+		const key = `${kind}${i},${j}`;
+		if (!P.has(key)) {
+			const a = V(i, j), b = kind === 'h' ? V(i + 1, j) : V(i, j + 1), t = a / (a - b);
+			P.set(key, kind === 'h' ? [x0 + (i + t) * h, y0 + j * h] : [x0 + i * h, y0 + (j + t) * h]);
+		}
+		return key;
+	};
+	const link = (/** @type {string} */ a, /** @type {string} */ b) => {
+		(adj.get(a) || adj.set(a, []).get(a))?.push(b);
+		(adj.get(b) || adj.set(b, []).get(b))?.push(a);
+	};
+	for (let j = 0; j < ny - 1; j++) for (let i = 0; i < nx - 1; i++) {
+		const tl = V(i, j) < 0, tr = V(i + 1, j) < 0, br = V(i + 1, j + 1) < 0, bl = V(i, j + 1) < 0;
+		const c = +tl * 8 + +tr * 4 + +br * 2 + +bl;
+		if (c === 0 || c === 15) continue;
+		const T = () => pt('h', i, j), B = () => pt('h', i, j + 1), L = () => pt('v', i, j), R = () => pt('v', i + 1, j);
+		const mid = (V(i, j) + V(i + 1, j) + V(i + 1, j + 1) + V(i, j + 1)) / 4 < 0;
+		switch (c) {
+			case 1: case 14: link(L(), B()); break;
+			case 2: case 13: link(B(), R()); break;
+			case 3: case 12: link(L(), R()); break;
+			case 4: case 11: link(T(), R()); break;
+			case 6: case 9: link(T(), B()); break;
+			case 7: case 8: link(L(), T()); break;
+			case 5: if (mid) { link(L(), T()); link(B(), R()); } else { link(T(), R()); link(L(), B()); } break;
+			case 10: if (mid) { link(T(), R()); link(L(), B()); } else { link(L(), T()); link(B(), R()); } break;
+		}
+	}
+	const seen = new Set(), rings = [];
+	for (const start of adj.keys()) {
+		if (seen.has(start)) continue;
+		const ring = [];
+		/** @type {string | null} */ let prev = null;
+		/** @type {string | undefined} */ let cur = start;
+		while (cur && !seen.has(cur)) {
+			seen.add(cur);
+			ring.push(/** @type {number[]} */ (P.get(cur)));
+			const nb = /** @type {string[]} */ (adj.get(cur));
+			const nxt = nb[0] === prev ? nb[1] : nb[0];
+			prev = cur;
+			cur = nxt;
+		}
+		const r = thin(ring);
+		if (r.length >= 3) rings.push(r);
+	}
+	return rings.length ? X(...rings.map((r) => [[...r, r[0]]])) : [];
+}

package/src/sdf/y2k.d.ts

@@ -0,0 +1,12 @@
+import type { Field, Pt } from './index.js';
+
+/** A bar from a to b, w wide at its ends, waisted n times to `waist` wide (a cosine profile). */
+export function pinch(a: Pt, b: Pt, w: number, waist: number, n?: number): Field;
+/** An arm from the hub c at deg: a stem ending in a ball of radius r, melted with blend k. */
+export function ballArm(c: Pt, deg: number, len: number, stem: number, r: number, k?: number): Field;
+/** n ball-ended arms from (cx, cy) melted into a hub. */
+export function node(cx: number, cy: number, n: number, len: number, stem: number, r: number, o?: { deg0?: number; hub?: number; k?: number; kArm?: number }): Field;
+/** A smooth blob: discs [cx, cy, r] melted with blend k. */
+export function blob(discs: readonly (readonly number[])[], k?: number): Field;
+/** A stadium (a pill) centred on (cx, cy), w × h. */
+export function stadium(cx: number, cy: number, w: number, h: number): Field;

package/src/sdf/y2k.js

@@ -0,0 +1,80 @@
+/**
+ * The Y2K family's parts as fields: a bar waisted along its length, an arm ending in a ball, a node of ball-ended arms
+ * melted into a hub, a smooth blob of discs and a stadium frame. Combine and trace them like any other field.
+ * From the Logomarks tools (y2kparts.mjs, batch 232, "Bold · Y2K").
+ */
+import { sdCircle, segT, sdCapsule } from './fields.js';
+import { smin } from './ops.js';
+
+/**
+ * A bar from a to b, w wide at its ends, waisted n times along its length to `waist` wide (n = 1 an hourglass bar, 2
+ * two beads' necks…; a waist wider than w swells instead). The waist follows a cosine, so the outline has no corners;
+ * the ends are round.
+ *
+ * @param {readonly number[]} a One end.
+ * @param {readonly number[]} b The other.
+ * @param {number} w The width at the ends.
+ * @param {number} waist The width at each waist.
+ * @param {number} [n=1] Waists along it.
+ * @returns {import('./index.js').Field} The bar.
+ */
+export const pinch = (a, b, w, waist, n = 1) => (x, y) => {
+	const [d, t] = segT(a, b, x, y);
+	return d - (w - ((w - waist) * (1 - Math.cos(2 * Math.PI * n * t))) / 2) / 2;
+};
+
+/**
+ * An arm from the hub c at `deg`, `len` to the ball's centre: a stem `stem` wide ending in a ball of radius r, melted
+ * with blend k.
+ *
+ * @param {readonly number[]} c The hub.
+ * @param {number} deg The arm's direction (degrees, y down).
+ * @param {number} len Hub to ball centre.
+ * @param {number} stem The stem's width.
+ * @param {number} r The ball's radius.
+ * @param {number} [k=30] The blend.
+ * @returns {import('./index.js').Field} The arm.
+ */
+export const ballArm = (c, deg, len, stem, r, k = 30) => {
+	const a = (deg * Math.PI) / 180, e = [c[0] + len * Math.cos(a), c[1] + len * Math.sin(a)];
+	return smin(k, sdCapsule(c, e, stem), sdCircle(e[0], e[1], r));
+};
+
+/**
+ * A node: n ball-ended arms from (cx, cy), the first at deg0, melted into a hub of radius `hub` (0: none).
+ *
+ * @param {number} cx The hub's centre.
+ * @param {number} cy The hub's centre.
+ * @param {number} n Arms.
+ * @param {number} len Hub to ball centre.
+ * @param {number} stem The stems' width.
+ * @param {number} r The balls' radius.
+ * @param {{ deg0?: number, hub?: number, k?: number, kArm?: number }} [o] The first arm's direction (−90), the hub's
+ *   radius (0), the hub's blend (40) and each arm's (30).
+ * @returns {import('./index.js').Field} The node.
+ */
+export const node = (cx, cy, n, len, stem, r, { deg0 = -90, hub = 0, k = 40, kArm = 30 } = {}) =>
+	smin(k, ...(hub ? [sdCircle(cx, cy, hub)] : []), ...[...Array(n)].map((_, i) => ballArm([cx, cy], deg0 + (i * 360) / n, len, stem, r, kArm)));
+
+/**
+ * A smooth blob: discs [cx, cy, r] melted with blend k.
+ *
+ * @param {readonly (readonly number[])[]} discs The discs.
+ * @param {number} [k=90] The blend.
+ * @returns {import('./index.js').Field} The blob.
+ */
+export const blob = (discs, k = 90) => smin(k, ...discs.map(([cx, cy, r]) => sdCircle(cx, cy, r)));
+
+/**
+ * A stadium (a pill) centred on (cx, cy), w × h, as a field.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} w The width.
+ * @param {number} h The height.
+ * @returns {import('./index.js').Field} The stadium.
+ */
+export const stadium = (cx, cy, w, h) => {
+	const r = Math.min(w, h) / 2;
+	return w >= h ? sdCapsule([cx - w / 2 + r, cy], [cx + w / 2 - r, cy], h) : sdCapsule([cx, cy - h / 2 + r], [cx, cy + h / 2 - r], w);
+};

package/src/skill/bundle.js

@@ -14,7 +14,7 @@ const SRC = new URL('../', import.meta.url);
 
 /** The geometry kit's modules, in dependency order. */
 const KIT = ['geometry/core.js', 'geometry/booleans.js', 'geometry/polygon.js', 'geometry/random.js', 'geometry/shapes.js', 'geometry/stroke.js',
-	'geometry/path.js', 'geometry/offset.js', 'geometry/iso.js', 'geometry/modular.js', 'geometry/badges.js', 'geometry/letters.js',
+	'geometry/path.js', 'geometry/offset.js', 'geometry/mitre.js', 'geometry/iso.js', 'geometry/modular.js', 'geometry/badges.js', 'geometry/letters.js',
 	'svg/path.js', 'svg/shapes.js', 'svg/rings.js', 'svg/nonzero.js', 'svg/shape.js', 'geometry/glitch.js', 'geometry/needle.js'];
 
 /** The fit's modules, in dependency order. */

package/src/util/vec.d.ts

@@ -0,0 +1,14 @@
+import type { Point, Point3, Polygon } from '../geometry/types.js';
+
+/** a − b, in 2D. */
+export function sub(a: readonly number[], b: readonly number[]): Point;
+/** a + b, in 2D. */
+export function add(a: readonly number[], b: readonly number[]): Point;
+/** a scaled by k, in 2D. */
+export function mul(a: readonly number[], k: number): Point;
+/** The cross product of two 3D vectors. */
+export function cross3(a: readonly number[], b: readonly number[]): Point3;
+/** A ring's signed area by the shoelace sum, added point by point. */
+export function shoelace(r: readonly (readonly number[])[]): number;
+/** A rectangle from its corners (x0, y0) and (x1, y1). */
+export function box(x0: number, y0: number, x1: number, y1: number): Polygon;

package/src/util/vec.js

@@ -0,0 +1,61 @@
+/**
+ * Small vector helpers several part families share (the Logomarks tools had a copy in each of the ink-trap, tech,
+ * echo and plane parts), each written once here so they all draw with the same arithmetic.
+ */
+import { rect } from '../geometry/index.js';
+
+/**
+ * a − b, in 2D.
+ *
+ * @param {readonly number[]} a The point.
+ * @param {readonly number[]} b The point taken away.
+ * @returns {import('../geometry/types.js').Point} The difference.
+ */
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+
+/**
+ * a + b, in 2D.
+ *
+ * @param {readonly number[]} a The point.
+ * @param {readonly number[]} b The point added.
+ * @returns {import('../geometry/types.js').Point} The sum.
+ */
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+
+/**
+ * a scaled by k, in 2D.
+ *
+ * @param {readonly number[]} a The vector.
+ * @param {number} k The factor.
+ * @returns {import('../geometry/types.js').Point} The scaled vector.
+ */
+export const mul = (a, k) => [a[0] * k, a[1] * k];
+
+/**
+ * The cross product of two 3D vectors.
+ *
+ * @param {readonly number[]} a The first.
+ * @param {readonly number[]} b The second.
+ * @returns {import('../geometry/types.js').Point3} a × b.
+ */
+export const cross3 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+
+/**
+ * A ring's signed area by the shoelace sum, added up point by point (positive when it runs clockwise on screen, y
+ * down). The geometry kit's signedArea() sums the same terms in another order, so the two can differ in the last bit.
+ *
+ * @param {readonly (readonly number[])[]} r The ring.
+ * @returns {number} The area, signed.
+ */
+export const shoelace = (r) => r.reduce((s, p, i) => { const q = r[(i + 1) % r.length]; return s + p[0] * q[1] - q[0] * p[1]; }, 0) / 2;
+
+/**
+ * A rectangle from its corners (x0, y0) and (x1, y1).
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} x1 Right.
+ * @param {number} y1 Bottom.
+ * @returns {import('../geometry/types.js').Polygon} The rectangle.
+ */
+export const box = (x0, y0, x1, y1) => rect(x0, y0, x1 - x0, y1 - y0);