@logomarks/core 0.1.11 → 0.2.0

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>;

package/src/forms/ref.js

@@ -0,0 +1,246 @@
+/**
+ * Four constructions from the reference sheets, as small helpers a generator composes (constructions only; no mark's
+ * geometry lives here):
+ *
+ * - rotation ("Bold · Rotational"): turns() sets one unit round a centre n times; cyclic() puts each copy in front of the
+ *   one before it (a cyclic overlap on any unit), every crossing parted by the gap;
+ * - stripes ("Bold · Stripes"): stripeBands() draws stripes as bands between two edge functions of x, so a stripe can
+ *   ripple or taper; stripesAlong() bends them with mitred corners, widths held square to each run; evenBands() spaces
+ *   n stripes evenly across a span and thinning() with a fixed gap, their widths easing from one end to the other;
+ * - guilloche ("Line · Guilloche"): waveRing() is the closed curve the bold guilloche strands run along (the kit's
+ *   weave() parts them over and under);
+ * - speed italics ("Letters · Speed"): italic() slants a glyph built upright, wedge() is the one sharp notch, and the
+ *   slab capitals (SPEED_GLYPHS, on SPEED_BOX) take the speed slit (slit()) through speed().
+ *
+ * From the Logomarks tools (refparts.mjs, batch 237; the speed capitals shared from batch 240).
+ */
+import { C, poly, rect, rot, mapPts, U, D, grown, closedCurve, mitreBand as band, mitreOffset as mitreOff } from '../geometry/index.js';
+
+/* ---------- rotation ---------- */
+
+/**
+ * n copies of a shape turned evenly round (cx, cy), the first turned deg0: a list, not yet united.
+ *
+ * @param {import('../geometry/types.js').Geom} g The unit.
+ * @param {number} n How many.
+ * @param {number} [deg0=0] The first copy's turn (degrees).
+ * @param {number} [cx=C] The centre.
+ * @param {number} [cy=C] The centre.
+ * @returns {import('../geometry/types.js').Geom[]} The copies.
+ */
+export const turns = (g, n, deg0 = 0, cx = C, cy = C) => [...Array(n)].map((_, k) => rot(g, deg0 + (360 * k) / n, cx, cy));
+
+/**
+ * A cyclic overlap: every unit cut free by the next one round, so each lies in front of one neighbour and behind the
+ * other (no real stack does that, which is the move); every crossing is parted by g.
+ *
+ * @param {readonly import('../geometry/types.js').Geom[]} units The units, in order round.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The overlap.
+ */
+export const cyclic = (units, g) => U(...units.map((u, k) => D(u, grown(units[(k + 1) % units.length], g))));
+
+/**
+ * A chevron: two arms w wide meeting at a sharp apex at the origin, opening `spread` degrees, pointing along +x, each
+ * arm L long (measured along its outer edge). Move and turn it into place.
+ *
+ * @param {number} L The arms' length.
+ * @param {number} w Their width.
+ * @param {number} spread The opening (degrees).
+ * @returns {import('../geometry/types.js').Polygon} The chevron.
+ */
+export function chevron(L, w, spread) {
+	const h = (spread / 2) * (Math.PI / 180), s = w / Math.sin(h);
+	const arm = (k) => [-L * Math.cos(h), k * L * Math.sin(h)];
+	const a = arm(1), b = arm(-1), tipIn = [-s, 0];
+	const inner = (p) => [p[0] - s, p[1]];
+	return poly([[0, 0], b, inner(b), tipIn, inner(a), a]);
+}
+
+/* ---------- stripes ---------- */
+
+/**
+ * Stripes as bands: each entry [top, bottom], each a number or a function of x (y down), sampled every dx across the
+ * canvas and beyond, so a region clips them.
+ *
+ * @param {readonly (readonly (number | ((x: number) => number))[])[]} list The stripes' [top, bottom] edges.
+ * @param {{ x0?: number, x1?: number, dx?: number }} [o] Where the sampling starts (−80) and ends (592), and its step (4).
+ * @returns {import('../geometry/types.js').Shape} The stripes.
+ */
+export function stripeBands(list, { x0 = -80, x1 = 592, dx = 4 } = {}) {
+	const at = (f, x) => (typeof f === 'function' ? f(x) : f), xs = [];
+	for (let x = x0; x <= x1 + 1e-9; x += dx) xs.push(x);
+	return U(...list.map(([t, b]) => poly([...xs.map((x) => [x, at(t, x)]), ...xs.slice().reverse().map((x) => [x, at(b, x)])])));
+}
+
+/**
+ * n even stripes across [a, b] with a gap gs between them.
+ *
+ * @param {number} n How many.
+ * @param {number} a Where they start.
+ * @param {number} b Where they end.
+ * @param {number} gs The gap between two.
+ * @returns {[number, number][]} Each stripe's [top, bottom].
+ */
+export const evenBands = (n, a, b, gs) => { const w = (b - a - (n - 1) * gs) / n; return [...Array(n)].map((_, k) => [a + k * (w + gs), a + k * (w + gs) + w]); };
+
+/**
+ * n stripes across [a, b] with a fixed gap gs, their widths in the ratio r0 : r1 from the first to the last (linear).
+ *
+ * @param {number} n How many.
+ * @param {number} a Where they start.
+ * @param {number} b Where they end.
+ * @param {number} gs The gap between two.
+ * @param {number} r0 The first stripe's share.
+ * @param {number} r1 The last stripe's share.
+ * @returns {[number, number][]} Each stripe's [top, bottom].
+ */
+export function thinning(n, a, b, gs, r0, r1) {
+	const ws = [...Array(n)].map((_, k) => r0 + ((r1 - r0) * k) / (n - 1)), k = (b - a - (n - 1) * gs) / ws.reduce((s, v) => s + v, 0);
+	let y = a; return ws.map((v) => { const out = [y, y + v * k]; y += v * k + gs; return out; });
+}
+
+/**
+ * n stripes w wide along a polyline, `pitch` apart measured square to every run (corners mitred), so a stripe that
+ * bends keeps its width and every gap through the bend.
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} pts The polyline.
+ * @param {number} n How many stripes.
+ * @param {number} w Their width.
+ * @param {number} pitch Centre to centre.
+ * @returns {import('../geometry/types.js').Shape} The stripes.
+ */
+export const stripesAlong = (pts, n, w, pitch) => U(...[...Array(n)].map((_, k) => band(mitreOff(pts, (k - (n - 1) / 2) * pitch), w)));
+
+/**
+ * A stripe list shifted by f(x), so every stripe follows one wave or one pulse.
+ *
+ * @param {readonly (readonly number[])[]} list The stripes' [top, bottom].
+ * @param {(x: number) => number} f The shift.
+ * @returns {((x: number) => number)[][]} The stripes as edge functions, for stripeBands().
+ */
+export const shifted = (list, f) => list.map(([t, b]) => [(x) => t + f(x), (x) => b + f(x)]);
+
+/**
+ * Stripes in a turned frame: drawn level, then turned deg about the centre.
+ *
+ * @param {readonly (readonly (number | ((x: number) => number))[])[]} list The stripes' [top, bottom] edges.
+ * @param {number} deg The turn (degrees).
+ * @param {{ x0?: number, x1?: number, dx?: number }} [o] stripeBands()'s options.
+ * @returns {import('../geometry/types.js').Shape} The stripes.
+ */
+export const turned = (list, deg, o) => rot(stripeBands(list, o), deg);
+
+/* ---------- guilloche curves ---------- */
+
+/**
+ * A ring whose radius waves k times round: r = R + A·cos(k·t + ph), sampled at n points.
+ *
+ * @param {number} R The mean radius.
+ * @param {number} A The wave's amplitude.
+ * @param {number} k Waves round.
+ * @param {number} [ph=0] The phase.
+ * @param {number} [n=480] Points.
+ * @param {number} [cx=C] The centre.
+ * @param {number} [cy=C] The centre.
+ * @returns {import('../geometry/types.js').Point[]} The ring.
+ */
+export const waveRing = (R, A, k, ph = 0, n = 480, cx = C, cy = C) => closedCurve((t) => { const r = R + A * Math.cos(k * t + ph); return [cx + r * Math.cos(t), cy + r * Math.sin(t)]; }, n);
+
+/* ---------- speed italics ---------- */
+
+/**
+ * A glyph drawn upright, slanted deg degrees (tops lean right) about the line y = cy.
+ *
+ * @param {import('../geometry/types.js').Geom} g The glyph.
+ * @param {number} [deg=17] The slant.
+ * @param {number} [cy=C] The line it slants about.
+ * @returns {import('../geometry/types.js').Geom} The slanted glyph.
+ */
+export const italic = (g, deg = 17, cy = C) => { const t = Math.tan((deg * Math.PI) / 180); return mapPts(g, ([x, y]) => [x + (cy - y) * t, y]); };
+
+/**
+ * A sharp notch: the triangle from the edge points a and b to the tip t, set `out` past the edge so it cuts clean.
+ *
+ * @param {readonly number[]} a One edge point.
+ * @param {readonly number[]} b The other.
+ * @param {import('../geometry/types.js').Point} t The tip.
+ * @param {number} [out=6] How far past the edge it starts.
+ * @returns {import('../geometry/types.js').Polygon} The notch.
+ */
+export const wedge = (a, b, t, out = 6) => {
+	const m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2], v = [m[0] - t[0], m[1] - t[1]], L = Math.hypot(...v);
+	const o = [(v[0] / L) * out, (v[1] / L) * out]; return poly([[a[0] + o[0], a[1] + o[1]], [b[0] + o[0], b[1] + o[1]], t]);
+};
+
+/* ---------- speed slab capitals ---------- */
+// Heavy slab capitals built upright on a 368 × 400 box (M 432 wide; stems 112, bars 92, sharp corners, flat terminals; S
+// has its two outer turns chamfered so it never reads as a 5), slanted 17°, each with ONE speed slit: a sharp wedge cut
+// in from the trailing (left) edge of one stroke, rising slightly forward.
+
+/** The speed capitals' box: cap line T0, baseline B0, left edge L0, right edge R0, stem SW and bar BW. */
+export const SPEED_BOX = { T0: 56, B0: 456, L0: 72, R0: 440, SW: 112, BW: 92 };
+const { T0, B0, L0, R0, SW, BW } = SPEED_BOX;
+
+/**
+ * A bar from y0 to y1, across the speed box unless told.
+ *
+ * @param {number} y0 Its top.
+ * @param {number} y1 Its bottom.
+ * @param {number} [x0] Its left (the box's).
+ * @param {number} [x1] Its right (the box's).
+ * @returns {import('../geometry/types.js').Polygon} The bar.
+ */
+export const hz = (y0, y1, x0 = L0, x1 = R0) => rect(x0, y0, x1 - x0, y1 - y0);
+
+/**
+ * An upright from x0 to x1, the speed box's full height unless told.
+ *
+ * @param {number} x0 Its left.
+ * @param {number} x1 Its right.
+ * @param {number} [y0] Its top (the cap line).
+ * @param {number} [y1] Its bottom (the baseline).
+ * @returns {import('../geometry/types.js').Polygon} The upright.
+ */
+export const vt = (x0, x1, y0 = T0, y1 = B0) => rect(x0, y0, x1 - x0, y1 - y0);
+
+/**
+ * The speed slit: a wedge `bw` wide where it enters at a, its sharp tip `len` further along `dir`.
+ *
+ * @param {readonly number[]} a Where it enters.
+ * @param {number} len How far the tip runs.
+ * @param {number} [dir=-8] Its direction (degrees, y down).
+ * @param {number} [bw=46] Its width at the entry.
+ * @returns {import('../geometry/types.js').Polygon} The slit.
+ */
+export const slit = (a, len, dir = -8, bw = 46) => {
+	const r = (dir * Math.PI) / 180, n = [(-Math.sin(r) * bw) / 2, (Math.cos(r) * bw) / 2];
+	return wedge([a[0] + n[0], a[1] + n[1]], [a[0] - n[0], a[1] - n[1]], [a[0] + Math.cos(r) * len, a[1] + Math.sin(r) * len]);
+};
+
+/**
+ * A speed letter: the glyph less its slit, slanted 17°.
+ *
+ * @param {import('../geometry/types.js').Geom} glyph The upright glyph.
+ * @param {import('../geometry/types.js').Geom} cut Its slit.
+ * @returns {import('../geometry/types.js').Geom} The letter.
+ */
+export const speed = (glyph, cut) => italic(D(glyph, cut), 17);
+
+/** The speed slab capitals (N M Z K X S R A), each a function returning the upright glyph on SPEED_BOX. */
+export const SPEED_GLYPHS = {
+	N: () => U(vt(L0, L0 + SW), vt(R0 - SW, R0), poly([[L0, T0], [L0 + SW + 18, T0], [R0, B0 - 150], [R0, B0], [R0 - SW - 18, B0], [L0, T0 + 150]])),
+	M: () => poly([[40, T0], [150, T0], [C, 262], [362, T0], [472, T0], [472, B0], [368, B0], [368, 232], [C + 30, B0], [C - 30, B0], [144, 232], [144, B0], [40, B0]]),
+	Z: () => U(hz(T0, T0 + BW), hz(B0 - BW, B0), poly([[R0 - 140, T0 + BW], [R0, T0 + BW], [L0 + 140, B0 - BW], [L0, B0 - BW]])),
+	K: () => {
+		const a = [L0 + SW - 10, 372], b = [R0, T0], p = (t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+		return U(vt(L0, L0 + SW), poly([[L0 + SW - 10, 236], [R0 - 128, T0], [R0, T0], a]), poly([p(0.3), p(0.62), [R0, B0], [R0 - 126, B0]]));
+	},
+	X: () => U(poly([[L0, T0], [L0 + 124, T0], [R0, B0], [R0 - 124, B0]]), poly([[R0 - 124, T0], [R0, T0], [L0 + 124, B0], [L0, B0]])),
+	S: () => D(U(hz(T0, T0 + BW), vt(L0, L0 + SW, T0, 302), hz(210, 302), vt(R0 - SW, R0, 210, B0), hz(B0 - BW, B0)), poly([[L0 - 1, T0 - 1], [L0 + 76, T0 - 1], [L0 - 1, T0 + 76]]), poly([[R0 + 1, B0 + 1], [R0 - 76, B0 + 1], [R0 + 1, B0 - 76]])),
+	R: () => U(vt(L0, L0 + SW), hz(T0, T0 + BW), vt(R0 - SW, R0, T0, 314), hz(222, 314), poly([[R0 - SW - 70, 314], [R0 - SW + 44, 314], [R0, B0], [R0 - 120, B0]])),
+	A: () => {
+		const out = poly([[166, T0], [346, T0], [R0, B0], [L0, B0]]), inner = poly([[226, T0 + BW], [286, T0 + BW], [312, 290], [200, 290]]), foot = poly([[178, 372], [334, 372], [358, B0 + 4], [154, B0 + 4]]);
+		return D(out, inner, foot);
+	},
+};

package/src/forms/shatter.d.ts

@@ -0,0 +1,40 @@
+import type { Geom, Point, Ring, Shape } from '../geometry/types.js';
+
+/** A rail: s in 0…1 to a point. */
+export type Rail = (s: number) => Point;
+/** A shard of a strip: its ring, its place along the strip and the rail its long side lies on. */
+export interface Shard {
+	r: Ring;
+	s: number;
+	base: 'inner' | 'outer';
+	c?: Point;
+}
+/** A shard's shrink, turn and move. */
+export interface ShardMove {
+	k?: number;
+	deg?: number;
+	d?: readonly number[];
+}
+
+/** A rail along a polyline, by arc length. */
+export function rail(pts: readonly Point[]): Rail;
+/** The run of a closed outline from the vertex nearest p to the vertex nearest q. */
+export function outlineRun(ring: readonly Point[], p: readonly number[], q: readonly number[]): Point[];
+/** The two rails of a band w wide along a centreline, mitred: [left, right]. */
+export function bandRails(pts: readonly Point[], w: number): [Rail, Rail];
+/** The triangular shards of a band between two rails, smaller down the strip. */
+export function shardStrip(inner: Rail, outer: Rail, o?: { n?: number; ratio?: number; jit?: number; rng?: () => number; arcN?: number }): Shard[];
+/** A shard inset by half a gap, its tips cleared. */
+export function inset(r: readonly Point[], g: number): Ring | undefined;
+/** The form less the band, cut back half a gap along the crack. */
+export function cutBack(shape: Geom, inner: Rail, outer: Rail, i0: readonly number[], g: number, k?: number): Shape;
+/** The shards moved off the body, each pushed on until it is g clear. */
+export function drift(body: Geom, shards: readonly Shard[], o: { move: (p: Shard & { c: Point }) => ShardMove; g: number; step?: number; min: number }): Geom[];
+/** A move spreading the shards out from a point. */
+export function spread(from: readonly number[], grow: readonly number[], shrink?: number, turn?: number): (p: Shard & { c: Point }) => ShardMove;
+/** A form breaking on one side into drifting shards. */
+export function breakOff(shape: Geom, inner: Rail, outer: Rail, o: { n?: number; ratio?: number; jit?: number; all?: boolean; move: (p: Shard & { c: Point }) => ShardMove; g: number; min?: number }): Shape;
+/** The house recipe: breakOff() spread from the centre, as a build of the gap. */
+export function houseBreak(shape: Geom, inner: Rail, outer: Rail, o?: { from?: readonly number[]; grow?: readonly number[]; shrink?: number; turn?: number; n?: number; ratio?: number; jit?: number; all?: boolean; min?: number }): (g: number) => Shape;
+/** The point k of the way from p to q. */
+export function lerpAt(p: readonly number[], q: readonly number[], k: number): Point;