@logomarks/core 0.1.9 → 0.2.0

package/src/forms/index.d.ts

@@ -0,0 +1,22 @@
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';
+export type { Hook } from './hooks.js';
+export type { JogArm } from './jog.js';
+export type { Rail, Shard, ShardMove } from './shatter.js';
+export type { Slat, SlatRowOptions, SlatEdges } from './slats.js';
+export type { FlowOptions } from './flow.js';
+export type { SwashOptions } from './swash.js';
+export type { StripeEdge } from './ref.js';
+export type { TrackKit } from './tracks.js';

package/src/forms/index.js

@@ -0,0 +1,24 @@
+/**
+ * @module @logomarks/core/forms
+ *
+ * The constructions the Bold, Line and Track families are drawn with, on the 512 canvas with the house gap: needle
+ * gaps, knobs and split discs (geo), one disc cut so a moved piece keeps its gap (discs), capsules whose ends curl round
+ * a neighbour (hooks), jogged bursts and chamfer checkers (jog), sparkles, ribbons and keyed chevrons (tech), the split
+ * emblem's horizon and grounds (emblems), a form breaking into shards (shatter), turning slats, flow grids, fold seams
+ * and straps, swashes, rotation, stripes, guilloche and speed letters (ref), the Track editions' kit (tracks), and soft
+ * blobs, Rail lines, chamfered paths and interlocking overlaps (lines).
+ */
+export * from './geo.js';
+export * from './discs.js';
+export * from './hooks.js';
+export * from './jog.js';
+export * from './tech.js';
+export * from './emblems.js';
+export * from './shatter.js';
+export * from './slats.js';
+export * from './flow.js';
+export * from './folds.js';
+export * from './swash.js';
+export * from './ref.js';
+export * from './tracks.js';
+export * from './lines.js';

package/src/forms/jog.d.ts

@@ -0,0 +1,33 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** One jogged arm's options. */
+export interface JogArm {
+	r0?: number;
+	rb?: number;
+	breaks?: readonly number[];
+	R: number;
+	w: number;
+	g: number;
+	shift: number;
+	scarf?: number;
+	innerShift?: number;
+	cx?: number;
+	cy?: number;
+}
+
+/** The point `along` the axis at deg from (cx, cy), stepped `side` square to it. */
+export function axisAt(deg: number, along: number, side?: number, cx?: number, cy?: number): Point;
+/** A bar on the axis at deg from a0 to a1, w wide, `side` off the axis, its ends slanted by cut0 / cut1. */
+export function axisBar(deg: number, a0: number, a1: number, w: number, side?: number, o?: { cut0?: number; cut1?: number; cx?: number; cy?: number }): Polygon;
+/** One jogged arm: runs broken by g and stepped sideways. */
+export function jogArm(deg: number, o: JogArm): Shape;
+/** n jogged arms round the centre, the first at deg0. */
+export function jogBurst(n: number, deg0: number, o: JogArm, each?: (i: number) => Partial<JogArm>): Shape;
+/** A polygon with its corners cut at 45° by c (one or one per corner). */
+export function chamfer(pts: readonly Point[], c: number | readonly number[]): Polygon;
+/** A box from its corners, chamfered by c. */
+export function chamferBox(x0: number, y0: number, x1: number, y1: number, c?: number | readonly number[]): Polygon;
+/** A checker's dark cells, corner meetings cut so two squares are parted by exactly g. */
+export function checkerCells(x0: number, y0: number, p: number, cols: number, rows: number, g: number, o?: { parity?: 0 | 1; outer?: number; skip?: (i: number, j: number) => boolean }): Shape;
+/** Throws unless a stands at least g (less 0.5) clear of b. */
+export function assertClear(a: Geom, b: Geom, g: number, what?: string): void;

package/src/forms/jog.js

@@ -0,0 +1,162 @@
+/**
+ * Jog bursts and chamfer checkers. A jog burst is straight bars radiating from a centre, each broken part way along and
+ * its outer run stepped sideways, parallel to itself (a splice jog), so the burst looks mis-registered; the break is a gap
+ * g along the arm (square, or a scarf cut at an angle, measured square to the cut), so the two runs are parted by exactly
+ * the house gap wherever they face each other. A chamfer checker is a heavy slab with 45° chamfered corners and a small
+ * checker of chamfered squares tucked into a corner: two dark squares that meet corner to corner have that corner cut at
+ * 45° with legs of g/√2, so they are parted by exactly g and stay full size. Angles are degrees, y down. From the
+ * Logomarks tools (jogparts.mjs, batch 244, "Bold · Jog" and "Bold · Chamfer").
+ */
+import { C, U, I, poly, grow } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/**
+ * The point at distance `along` on the axis at angle `deg` from (cx, cy), stepped `side` square to it.
+ *
+ * @param {number} deg The axis's angle.
+ * @param {number} along The distance along it.
+ * @param {number} [side=0] The step square to it.
+ * @param {number} [cx=C] The axis's origin.
+ * @param {number} [cy=C] The axis's origin.
+ * @returns {Point} The point.
+ */
+export const axisAt = (deg, along, side = 0, cx = C, cy = C) => {
+	const a = (deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return [cx + c * along - s * side, cy + s * along + c * side];
+};
+
+/**
+ * A bar on the axis at `deg` from `a0` to `a1` along it, `w` wide, centred `side` off the axis. `cut0` / `cut1` slant its
+ * ends: the end line turned that many degrees off square (positive leans the end forward on the +side).
+ *
+ * @param {number} deg The axis's angle.
+ * @param {number} a0 Where the bar starts along it.
+ * @param {number} a1 Where it ends.
+ * @param {number} w Its width.
+ * @param {number} [side=0] Its offset from the axis.
+ * @param {{ cut0?: number, cut1?: number, cx?: number, cy?: number }} [o] The end slants and the axis's origin.
+ * @returns {Polygon} The bar.
+ */
+export const axisBar = (deg, a0, a1, w, side = 0, { cut0 = 0, cut1 = 0, cx = C, cy = C } = {}) => {
+	const t0 = Math.tan((cut0 * Math.PI) / 180) * (w / 2), t1 = Math.tan((cut1 * Math.PI) / 180) * (w / 2);
+	const P = (al, sd) => axisAt(deg, al, sd, cx, cy);
+	return poly([P(a0 - t0, side - w / 2), P(a1 - t1, side - w / 2), P(a1 + t1, side + w / 2), P(a0 + t0, side + w / 2)]);
+};
+
+/**
+ * One arm of a jog burst.
+ *
+ * @typedef {object} JogArm
+ * @property {number} [r0] Where the inner run starts (0: the centre).
+ * @property {number} [rb] The break (or give `breaks`).
+ * @property {readonly number[]} [breaks] Several breaks, each run stepped `shift` further than the last.
+ * @property {number} R Where the outer run ends.
+ * @property {number} w The bar's width.
+ * @property {number} g The gap at each break.
+ * @property {number} shift Each run's step square to the axis (positive is clockwise on screen).
+ * @property {number} [scarf] The breaks' slant, degrees off square; the gap stays g square to the cut.
+ * @property {number} [innerShift] The inner run's own step.
+ * @property {number} [cx] The centre.
+ * @property {number} [cy] The centre.
+ */
+
+/**
+ * One jogged arm on the axis at `deg`: an inner run from `r0` to the break at `rb`, a gap g, and an outer run on to `R`
+ * stepped `shift` square to the axis. A slanted face stepped sideways slides along the axis by shift·tan, so each later
+ * run starts that much further on.
+ *
+ * @param {number} deg The axis's angle.
+ * @param {JogArm} o The arm.
+ * @returns {Shape} The arm.
+ */
+export const jogArm = (deg, { r0 = 0, rb, breaks = [rb], R, w, g, shift, scarf = 0, innerShift = 0, cx = C, cy = C }) => {
+	const a = (scarf * Math.PI) / 180, half = g / 2 / Math.cos(a), t = Math.tan(a); // the axial half-gap that leaves g square to a slanted cut
+	const runs = []; let from = r0, side = innerShift;
+	breaks.forEach((b, i) => { runs.push(axisBar(deg, from, b - half, w, side, { cut0: i ? scarf : 0, cut1: scarf, cx, cy })); side += shift; from = b + half + shift * t; });
+	runs.push(axisBar(deg, from, R, w, side, { cut0: scarf, cx, cy }));
+	return U(...runs);
+};
+
+/**
+ * n jogged arms round the centre, the first at `deg0`; `each(i)` may override any jogArm option per arm (a shift's sign, a
+ * break radius). The inner runs meet at the centre when r0 is 0.
+ *
+ * @param {number} n The number of arms.
+ * @param {number} deg0 The first arm's angle.
+ * @param {JogArm} o Every arm's options.
+ * @param {(i: number) => Partial<JogArm>} [each] Per-arm overrides.
+ * @returns {Shape} The burst.
+ */
+export const jogBurst = (n, deg0, o, each = () => ({})) => U(...[...Array(n)].map((_, i) => jogArm(deg0 + (i * 360) / n, { ...o, ...each(i) })));
+
+/**
+ * A polygon with each corner cut at 45° (along the line square to its bisector) by `c` along both edges: a number for
+ * every corner or one per corner, 0 keeping it sharp. Points run in any order; corners are cut symmetrically.
+ *
+ * @param {readonly Point[]} pts The corners.
+ * @param {number | readonly number[]} c The cut.
+ * @returns {Polygon} The chamfered polygon.
+ */
+export const chamfer = (pts, c) => {
+	const n = pts.length, cs = Array.isArray(c) ? c : pts.map(() => c), out = [];
+	for (let i = 0; i < n; i++) {
+		const p = pts[i], a = pts[(i - 1 + n) % n], b = pts[(i + 1) % n], k = cs[i];
+		if (!k) { out.push(p); continue; }
+		const ua = [(a[0] - p[0]) / Math.hypot(a[0] - p[0], a[1] - p[1]), (a[1] - p[1]) / Math.hypot(a[0] - p[0], a[1] - p[1])];
+		const ub = [(b[0] - p[0]) / Math.hypot(b[0] - p[0], b[1] - p[1]), (b[1] - p[1]) / Math.hypot(b[0] - p[0], b[1] - p[1])];
+		out.push([p[0] + ua[0] * k, p[1] + ua[1] * k], [p[0] + ub[0] * k, p[1] + ub[1] * k]);
+	}
+	return poly(out);
+};
+
+/**
+ * A box from its corners, its corners (top-left, top-right, bottom-right, bottom-left) chamfered by c.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} x1 Right.
+ * @param {number} y1 Bottom.
+ * @param {number | readonly number[]} [c=0] The chamfer, for every corner or one per corner.
+ * @returns {Polygon} The box.
+ */
+export const chamferBox = (x0, y0, x1, y1, c = 0) => chamfer([[x0, y0], [x1, y0], [x1, y1], [x0, y1]], c);
+
+/**
+ * A checker of `cols` × `rows` cells of size p from (x0, y0): the dark cells (where (i + j) % 2 === parity, less any
+ * `skip(i, j)`) as full squares, each corner that meets another dark square cut at 45° with legs of g/√2, so two squares
+ * meeting corner to corner are parted by exactly g; `outer` chamfers every other corner too.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} p The cell size.
+ * @param {number} cols Cells across.
+ * @param {number} rows Cells down.
+ * @param {number} g The gap.
+ * @param {{ parity?: 0 | 1, outer?: number, skip?: (i: number, j: number) => boolean }} [o] Which cells are dark, the
+ *   free corners' chamfer (0: sharp) and cells to leave out.
+ * @returns {Shape} The checker.
+ */
+export const checkerCells = (x0, y0, p, cols, rows, g, { parity = 0, outer = 0, skip = () => false } = {}) => {
+	const dark = (i, j) => i >= 0 && j >= 0 && i < cols && j < rows && (i + j) % 2 === parity && !skip(i, j), c = g / Math.SQRT2, out = [];
+	for (let j = 0; j < rows; j++) for (let i = 0; i < cols; i++) if (dark(i, j)) {
+		const cut = [[-1, -1], [1, -1], [1, 1], [-1, 1]].map(([di, dj]) => (dark(i + di, j + dj) ? c : outer));
+		out.push(chamferBox(x0 + i * p, y0 + j * p, x0 + (i + 1) * p, y0 + (j + 1) * p, cut));
+	}
+	return U(...out);
+};
+
+/**
+ * Throws unless every part of `a` stands at least g (less a half-unit tolerance) clear of `b`.
+ *
+ * @param {Geom} a One shape.
+ * @param {Geom} b The other.
+ * @param {number} g The gap.
+ * @param {string} [what='parts'] What to call them in the error.
+ * @returns {void}
+ * @throws {Error} When they come closer than the gap.
+ */
+export const assertClear = (a, b, g, what = 'parts') => { if (I(grow(a, g - 0.5), b).length) throw new Error(`${what} closer than the gap`); };

package/src/forms/lines.d.ts

@@ -0,0 +1,32 @@
+import type { Point, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** A blob: radius R wobbled by sine terms [k, amplitude, phase]; sy squashes it. */
+export function blob(cx: number, cy: number, R: number, terms?: readonly (readonly number[])[], sy?: number, n?: number): Polygon;
+/** The same blob grown by g all round. */
+export function blobGrown(cx: number, cy: number, R: number, terms: readonly (readonly number[])[], sy?: number, g?: number): Polygon;
+/** The Cairo pentagonal tiling on unit cells round the origin (t = 0.2257: every edge equal). */
+export function cairo(t?: number): Point[][];
+/** The polygons whose centres lie within r of (cx, cy). */
+export function near<T extends readonly (readonly number[])[]>(list: readonly T[], cx: number, cy: number, r: number): T[];
+/** A polyline with every inner corner cut at 45° by c (or one per inner corner). */
+export function chamPath(pts: readonly Point[], c: number | readonly number[]): Point[];
+/** A Rail: two tracks w wide, pitch apart, along an open polyline, corners mitred, ends flat. */
+export function railsOf(pts: readonly Point[], w?: number, pitch?: number): Shape;
+/** A closed Rail round a regular n-gon whose centre path has inradius r. */
+export function railRing(cx: number, cy: number, r: number, n: number, deg?: number, w?: number, pitch?: number): Shape;
+/** A closed Rail along any polygon, corners mitred. */
+export function railLoop(pts: readonly Point[], w?: number, pitch?: number): Shape;
+/** Points from a to b bowed sideways by k times the length at the middle. */
+export function bow(a: readonly number[], b: readonly number[], k: number, n?: number): Point[];
+/** A slot g wide leaving the canvas centre at angle a, from `from` to `to` along it. */
+export function slot(a: number, g: number, from?: number, to?: number): Polygon;
+/** The two half-planes either side of the line p→q: [left, right]. */
+export function halves(p: readonly number[], q: readonly number[]): Polygon[];
+/** Shapes in a chain along p→q, each in front of the next on the left and behind it on the right, gap g. */
+export function lockChain(list: readonly Geom[], p: readonly number[], q: readonly number[], g?: number): Shape;
+/** a and b overlapped: a in front left of p→q, b in front right of it. */
+export function lockAlong(a: Geom, b: Geom, p: readonly number[], q: readonly number[], g?: number): Shape;
+/** The least distance between two shapes' outline points. */
+export function gapBetween(a: Geom, b: Geom): number;
+/** A part slid along deg until it sits exactly g clear of `fixed`. */
+export function slideToGap(fixed: Geom, part: Geom, deg: number, g: number, far?: number): Geom;

package/src/forms/lines.js

@@ -0,0 +1,233 @@
+/**
+ * Lines, blobs, rails and locks several families share: soft blobs, the Cairo tiling and a centre picker, chamfered
+ * polylines, Rails (two tracks along a line, corners mitred sharp), bowed lines and the Y of gaps, interlocking overlaps
+ * (each shape in front of the next on one side of a line and behind it on the other), and placing one part exactly a
+ * gap clear of another.
+ * From the Logomarks tools (shared.mjs's generic half: batches 14, 101, 116, 117, 163, 166, 169, 178, 187, 255).
+ */
+import { C, TAU, U, D, I, X, poly, sample, stroke, grown, regular, move, GAP as G, mitreOffset as mitreOff } from '../geometry/index.js';
+
+/* ---------- soft blobs ---------- */
+
+/**
+ * A blob: radius R wobbled by sine terms, each [k, amplitude, phase] (r = 1 + Σ a·sin(k·t + p)); sy squashes it
+ * vertically.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} R The radius.
+ * @param {readonly (readonly number[])[]} [terms=[]] The wobble's terms.
+ * @param {number} [sy=1] The vertical squash.
+ * @param {number} [n=360] Points round it.
+ * @returns {import('../geometry/types.js').Polygon} The blob.
+ */
+export const blob = (cx, cy, R, terms = [], sy = 1, n = 360) =>
+	poly(sample((t) => { let r = 1; for (const [k, a, p] of terms) r += a * Math.sin(k * t + p); return [cx + R * r * Math.cos(t), cy + sy * R * r * Math.sin(t)]; }, 0, TAU, n).slice(0, -1));
+
+/**
+ * The same blob grown by g all round (near enough), to cut a gap round it.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} R The radius.
+ * @param {readonly (readonly number[])[]} terms The wobble's terms.
+ * @param {number} [sy=1] The vertical squash.
+ * @param {number} [g=GAP] How far it grows.
+ * @returns {import('../geometry/types.js').Polygon} The grown blob.
+ */
+export const blobGrown = (cx, cy, R, terms, sy = 1, g = G) => blob(cx, cy, R + g, terms, sy);
+
+/* ---------- tiling ---------- */
+
+/**
+ * The Cairo pentagonal tiling, equilateral, on a 7 × 7 block of unit cells round the origin: square cells alternately
+ * crossed by a short horizontal or vertical bar, each bar end joined to the two nearest corners.
+ *
+ * @param {number} [t=0.2257] The bar's share (0.2257: every edge the same length).
+ * @returns {import('../geometry/types.js').Point[][]} The pentagons.
+ */
+export const cairo = (t = 0.2257) => {
+	const out = [];
+	for (let i = -3; i <= 3; i++) for (let j = -3; j <= 3; j++) {
+		if ((i + j) % 2 === 0) out.push([[i + t, j + 0.5], [i + 1 - t, j + 0.5], [i + 1, j + 1], [i + 0.5, j + 1 + t], [i, j + 1]], [[i + t, j + 0.5], [i, j], [i + 0.5, j - t], [i + 1, j], [i + 1 - t, j + 0.5]]);
+		else out.push([[i + 0.5, j + t], [i + 0.5, j + 1 - t], [i, j + 1], [i - t, j + 0.5], [i, j]], [[i + 0.5, j + t], [i + 1, j], [i + 1 + t, j + 0.5], [i + 1, j + 1], [i + 0.5, j + 1 - t]]);
+	}
+	return out;
+};
+
+/**
+ * The polygons whose centres (the mean of their points) lie within r of (cx, cy).
+ *
+ * @template {readonly (readonly number[])[]} T
+ * @param {readonly T[]} list The polygons, as point lists.
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} r The reach.
+ * @returns {T[]} Those near it.
+ */
+export const near = (list, cx, cy, r) => list.filter((pl) => { const m = pl.reduce((a, p) => [a[0] + p[0] / pl.length, a[1] + p[1] / pl.length], [0, 0]); return Math.hypot(m[0] - cx, m[1] - cy) <= r; });
+
+/* ---------- chamfered and mitred lines ---------- */
+
+const add2 = (a, b) => [a[0] + b[0], a[1] + b[1]], sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]], mul2 = (a, k) => [a[0] * k, a[1] * k];
+const unit2 = (v) => { const l = Math.hypot(...v) || 1; return [v[0] / l, v[1] / l]; };
+
+/**
+ * A polyline with every inner corner cut at 45° by c.
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} pts The polyline.
+ * @param {number | readonly number[]} c The cut (or one per inner corner; 0 keeps the corner).
+ * @returns {import('../geometry/types.js').Point[]} The chamfered polyline.
+ */
+export const chamPath = (pts, c) => {
+	const out = [pts[0]];
+	for (let i = 1; i < pts.length - 1; i++) {
+		const k = Array.isArray(c) ? c[i - 1] : c, p = pts[i];
+		if (!k) { out.push(p); continue; } const u = unit2(sub2(p, pts[i - 1])), v = unit2(sub2(pts[i + 1], p)); out.push(sub2(p, mul2(u, k)), add2(p, mul2(v, k)));
+	}
+	out.push(pts.at(-1)); return out;
+};
+
+/**
+ * A Rail: two tracks w wide, pitch apart, along an open polyline, every corner mitred sharp and the ends cut flat (the
+ * Duo's 26 and 48 by default).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} pts The centre line.
+ * @param {number} [w=26] Each track's width.
+ * @param {number} [pitch=48] Track to track, centre to centre.
+ * @returns {import('../geometry/types.js').Shape} The Rail.
+ */
+export const railsOf = (pts, w = 26, pitch = 48) => U(stroke(mitreOff(pts, pitch / 2), w, { chunk: 4 }), stroke(mitreOff(pts, -pitch / 2), w, { chunk: 4 }));
+
+/**
+ * A closed Rail: the two tracks (w wide, pitch apart) of a regular n-gon whose centre path has inradius r, corners
+ * mitred sharp.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {number} r The centre path's inradius.
+ * @param {number} n Sides.
+ * @param {number} [deg=-90] The first corner's angle.
+ * @param {number} [w=26] Each track's width.
+ * @param {number} [pitch=48] Track to track.
+ * @returns {import('../geometry/types.js').Shape} The Rail ring.
+ */
+export const railRing = (cx, cy, r, n, deg = -90, w = 26, pitch = 48) => {
+	const ng = (ri) => regular(cx, cy, ri / Math.cos(Math.PI / n), n, deg);
+	return U(D(ng(r + pitch / 2 + w / 2), ng(r + pitch / 2 - w / 2)), D(ng(r - pitch / 2 + w / 2), ng(r - pitch / 2 - w / 2)));
+};
+
+/**
+ * A closed Rail along any polygon (concave too), every corner mitred sharp.
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} pts The centre path (open: no repeated point).
+ * @param {number} [w=26] Each track's width.
+ * @param {number} [pitch=48] Track to track.
+ * @returns {import('../geometry/types.js').Shape} The Rail loop.
+ */
+export const railLoop = (pts, w = 26, pitch = 48) => {
+	const off = (d) => poly(mitreOff([pts.at(-1), ...pts, pts[0]], d).slice(1, -1));
+	return U(X(off(pitch / 2 + w / 2), off(pitch / 2 - w / 2)), X(off(-pitch / 2 + w / 2), off(-pitch / 2 - w / 2)));
+};
+
+/* ---------- bows, slots and locks ---------- */
+
+/**
+ * Points from a to b bowed sideways at the middle by k times the length (a parabola; k < 0 bows to the right of a→b,
+ * y down).
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} b The end.
+ * @param {number} k The bow, as a share of the length.
+ * @param {number} [n=24] Steps.
+ * @returns {import('../geometry/types.js').Point[]} The bowed line.
+ */
+export const bow = (a, b, k, n = 24) => {
+	const dx = b[0] - a[0], dy = b[1] - a[1], L = Math.hypot(dx, dy), nx = dy / L, ny = -dx / L;
+	return Array.from({ length: n + 1 }, (_, i) => { const t = i / n, h = k * L * 4 * t * (1 - t); return [a[0] + dx * t + nx * h, a[1] + dy * t + ny * h]; });
+};
+
+/**
+ * A slot g wide leaving the canvas centre at angle a, from `from` to `to` along it (three of them make the Y of gaps
+ * that splits a cube).
+ *
+ * @param {number} a The angle (degrees, y down).
+ * @param {number} g The width.
+ * @param {number} [from=-40] Where it starts along the ray.
+ * @param {number} [to=400] Where it ends.
+ * @returns {import('../geometry/types.js').Polygon} The slot.
+ */
+export const slot = (a, g, from = -40, to = 400) => {
+	const u = [Math.cos((a * Math.PI) / 180), Math.sin((a * Math.PI) / 180)], v = [-u[1] * g / 2, u[0] * g / 2];
+	return poly([[C + u[0] * from + v[0], C + u[1] * from + v[1]], [C + u[0] * to + v[0], C + u[1] * to + v[1]], [C + u[0] * to - v[0], C + u[1] * to - v[1]], [C + u[0] * from - v[0], C + u[1] * from - v[1]]]);
+};
+
+/**
+ * The two half-planes either side of the line p→q (as large squares).
+ *
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} q Another.
+ * @returns {import('../geometry/types.js').Polygon[]} [left, right].
+ */
+export const halves = (p, q) => {
+	const d = [q[0] - p[0], q[1] - p[1]], L = Math.hypot(...d), u = [(d[0] / L) * 2000, (d[1] / L) * 2000], n = [-u[1], u[0]];
+	return [1, -1].map((k) => poly([[p[0] - u[0], p[1] - u[1]], [p[0] + u[0], p[1] + u[1]], [p[0] + u[0] + k * n[0], p[1] + u[1] + k * n[1]], [p[0] - u[0] + k * n[0], p[1] - u[1] + k * n[1]]]));
+};
+
+/**
+ * Shapes in a chain along the line p→q, each overlapping the next: every shape is in front of the next on the left of
+ * the line and behind it on the right (a cyclic lock, link by link), the gap g round every crossing.
+ *
+ * @param {readonly import('../geometry/types.js').Geom[]} list The links, in order.
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} q Another.
+ * @param {number} [g=GAP] The gap.
+ * @returns {import('../geometry/types.js').Shape} The chain.
+ */
+export const lockChain = (list, p, q, g = G) => {
+	const [left, right] = halves(p, q);
+	return U(...list.map((s, k) => D(s, ...(list[k + 1] ? [grown(I(list[k + 1], right), g)] : []), ...(k ? [grown(I(list[k - 1], left), g)] : []))));
+};
+
+/**
+ * Two shapes overlapped, a in front on the left of the line p→q, b in front on its right.
+ *
+ * @param {import('../geometry/types.js').Geom} a The first.
+ * @param {import('../geometry/types.js').Geom} b The second.
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} q Another.
+ * @param {number} [g=GAP] The gap.
+ * @returns {import('../geometry/types.js').Shape} The pair.
+ */
+export const lockAlong = (a, b, p, q, g = G) => lockChain([a, b], p, q, g);
+
+/* ---------- placing a part a gap clear ---------- */
+
+/**
+ * The least distance between two shapes, measured between their outline points (dense outlines give it to a fraction).
+ *
+ * @param {import('../geometry/types.js').Geom} a One shape.
+ * @param {import('../geometry/types.js').Geom} b The other.
+ * @returns {number} The distance.
+ */
+export const gapBetween = (a, b) => {
+	const B = U(b).flat(2); let m = Infinity;
+	for (const p of U(a).flat(2)) for (const q of B) { const d = (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2; if (d < m) m = d; } return Math.sqrt(m);
+};
+
+/**
+ * A part slid along `deg` (0 = right, 90 = down) until it sits exactly g clear of `fixed`, by bisection between 0 and
+ * `far`.
+ *
+ * @param {import('../geometry/types.js').Geom} fixed What it must clear.
+ * @param {import('../geometry/types.js').Geom} part The part.
+ * @param {number} deg The direction (degrees).
+ * @param {number} g The gap.
+ * @param {number} [far=400] The farthest it may go.
+ * @returns {import('../geometry/types.js').Geom} The moved part.
+ */
+export const slideToGap = (fixed, part, deg, g, far = 400) => {
+	const u = [Math.cos((deg * Math.PI) / 180), Math.sin((deg * Math.PI) / 180)];
+	const at = (t) => move(part, u[0] * t, u[1] * t); let lo = 0, hi = far;
+	for (let i = 0; i < 30; i++) { const t = (lo + hi) / 2; if (gapBetween(fixed, at(t)) < g) lo = t; else hi = t; } return at(hi);
+};

package/src/forms/ref.d.ts

@@ -0,0 +1,41 @@
+import type { Point, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** A stripe's edges: each a number or a function of x (y down). */
+export type StripeEdge = number | ((x: number) => number);
+
+/** n copies of a shape turned evenly round (cx, cy), the first turned deg0. */
+export function turns(g: Geom, n: number, deg0?: number, cx?: number, cy?: number): Geom[];
+/** A cyclic overlap: every unit cut free by the next one round, crossings parted by g. */
+export function cyclic(units: readonly Geom[], g: number): Shape;
+/** A chevron: two arms w wide meeting at an apex at the origin, opening `spread` degrees, pointing along +x. */
+export function chevron(L: number, w: number, spread: number): Polygon;
+/** Stripes as bands between [top, bottom] edges, sampled every dx from x0 to x1. */
+export function stripeBands(list: readonly (readonly StripeEdge[])[], o?: { x0?: number; x1?: number; dx?: number }): Shape;
+/** n even stripes across [a, b] with a gap gs: [top, bottom] each. */
+export function evenBands(n: number, a: number, b: number, gs: number): [number, number][];
+/** n stripes across [a, b] with a fixed gap gs, widths in the ratio r0 : r1 first to last. */
+export function thinning(n: number, a: number, b: number, gs: number, r0: number, r1: number): [number, number][];
+/** n stripes w wide along a polyline, `pitch` apart square to every run, corners mitred. */
+export function stripesAlong(pts: readonly Point[], n: number, w: number, pitch: number): Shape;
+/** A stripe list shifted by f(x). */
+export function shifted(list: readonly (readonly number[])[], f: (x: number) => number): ((x: number) => number)[][];
+/** Stripes drawn level, then turned deg about the centre. */
+export function turned(list: readonly (readonly StripeEdge[])[], deg: number, o?: { x0?: number; x1?: number; dx?: number }): Shape;
+/** A ring whose radius waves k times round: r = R + A·cos(k·t + ph). */
+export function waveRing(R: number, A: number, k: number, ph?: number, n?: number, cx?: number, cy?: number): Point[];
+/** A glyph slanted deg degrees (tops lean right) about the line y = cy. */
+export function italic(g: Geom, deg?: number, cy?: number): Geom;
+/** A sharp notch: the triangle from edge points a and b to the tip t, `out` past the edge. */
+export function wedge(a: readonly number[], b: readonly number[], t: Point, out?: number): Polygon;
+/** The speed capitals' box: cap line, baseline, left and right edges, stem and bar. */
+export const SPEED_BOX: { T0: number; B0: number; L0: number; R0: number; SW: number; BW: number };
+/** A bar from y0 to y1, across the speed box unless told. */
+export function hz(y0: number, y1: number, x0?: number, x1?: number): Polygon;
+/** An upright from x0 to x1, the speed box's height unless told. */
+export function vt(x0: number, x1: number, y0?: number, y1?: number): Polygon;
+/** The speed slit: a wedge bw wide entering at a, its tip len along dir. */
+export function slit(a: readonly number[], len: number, dir?: number, bw?: number): Polygon;
+/** A speed letter: the glyph less its slit, slanted 17°. */
+export function speed(glyph: Geom, cut: Geom): Geom;
+/** The speed slab capitals (N M Z K X S R A), each returning the upright glyph. */
+export const SPEED_GLYPHS: Record<string, () => Geom>;