@logomarks/core 0.1.11 → 0.2.1

package/src/letters/blackletter.js

@@ -0,0 +1,199 @@
+/**
+ * Modern blackletter, drawn the way the hand draws it: one broad nib held at 30°. A stroke is the nib swept along a
+ * polyline (`nib()`), so the face's weights come from one rule: uprights and falling (↘) diagonals are heavy, bars a little
+ * lighter, rising (↗) strokes the hairline, and every free end is cut on the nib. Bowls are pointed (straight runs joined
+ * at 45°, never curves). On top of that each letter takes one or two nib features: a flag head and lozenge foot
+ * (`minim()`), a split stem (`splitHead()`, `splitFoot()`), or a lozenge, parted off by the gap (`parted()`) or set in as a
+ * bar or a terminal. Letters are drawn on a cap height of 440 (y down, origin at the cap's left); `blackLetter()` centres
+ * one. From the Logomarks tools (gothicparts.mjs, batch 231; batch 240 added F, J, L and P).
+ */
+import { U, D, poly, rect, move, bbox } from '../geometry/index.js';
+
+/* ---------- the nib ---------- */
+
+/**
+ * The face's nib: its width W, its thickness TH (the hairline), its angle DEG (rising, in degrees from the horizontal)
+ * and the cap height CAP every letter is drawn to. An upright comes out W·cos 30° + TH·sin 30° ≈ 104 wide, a bar ≈ 76 deep.
+ */
+export const NIB = { W: 104, TH: 28, DEG: 30, CAP: 440 };
+
+/**
+ * The nib as a rectangle about the origin: its long axis rising at `deg`, `w` long and `th` thick.
+ *
+ * @param {{ w?: number, th?: number, deg?: number }} [o] The nib (NIB's by default).
+ * @returns {import('../geometry/types.js').Point[]} Its four corners.
+ */
+const nibRect = ({ w = NIB.W, th = NIB.TH, deg = NIB.DEG } = {}) => {
+	const a = (deg * Math.PI) / 180, n = [(Math.cos(a) * w) / 2, (-Math.sin(a) * w) / 2], m = [(Math.sin(a) * th) / 2, (Math.cos(a) * th) / 2];
+	return [[n[0] + m[0], n[1] + m[1]], [n[0] - m[0], n[1] - m[1]], [-n[0] - m[0], -n[1] - m[1]], [-n[0] + m[0], -n[1] + m[1]]];
+};
+
+/**
+ * Points moved by (x, y).
+ *
+ * @param {readonly (readonly number[])[]} q The points.
+ * @param {readonly number[]} p The offset.
+ * @returns {import('../geometry/types.js').Point[]} The moved points.
+ */
+const at = (q, [x, y]) => q.map(([a, b]) => [a + x, b + y]);
+
+/**
+ * The nib swept along a polyline: the Minkowski sum of each segment with the nib, as the nib at both ends plus the
+ * parallelogram each nib edge sweeps (that union is the whole sum for a convex nib), all segments united.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {{ w?: number, th?: number, deg?: number }} [o] The nib (NIB's by default).
+ * @returns {import('../geometry/types.js').Shape} The stroke.
+ */
+export const nib = (pts, o = {}) => {
+	const q = nibRect(o), parts = [];
+	pts.forEach((p, i) => {
+		parts.push(poly(at(q, p)));
+		if (i === 0) return;
+		const a = pts[i - 1];
+		q.forEach((e, k) => { const f = q[(k + 1) % 4]; parts.push(poly([[a[0] + e[0], a[1] + e[1]], [a[0] + f[0], a[1] + f[1]], [p[0] + f[0], p[1] + f[1]], [p[0] + e[0], p[1] + e[1]]])); });
+	});
+	return U(...parts);
+};
+
+/**
+ * Several nib strokes united.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} list The polylines.
+ * @param {{ w?: number, th?: number, deg?: number }} [o] The nib (NIB's by default).
+ * @returns {import('../geometry/types.js').Shape} The strokes.
+ */
+export const nibs = (list, o = {}) => U(...list.map((pts) => nib(pts, o)));
+
+/**
+ * A lozenge: a square standing on its corner, `s` from corner to corner, centred on (x, y).
+ *
+ * @param {number} x Its centre.
+ * @param {number} y Its centre.
+ * @param {number} s Corner to corner.
+ * @returns {import('../geometry/types.js').Polygon} The lozenge.
+ */
+export const lozenge = (x, y, s) => poly([[x, y - s / 2], [x + s / 2, y], [x, y + s / 2], [x - s / 2, y]]);
+
+/**
+ * A cut g wide along the line through a and b, run far past both.
+ *
+ * @param {readonly number[]} a A point on the line.
+ * @param {readonly number[]} b Another.
+ * @param {number} g The cut's width.
+ * @returns {import('../geometry/types.js').Polygon} The cut.
+ */
+export const cutLine = (a, b, g) => {
+	const d = [b[0] - a[0], b[1] - a[1]], L = Math.hypot(...d), u = [d[0] / L, d[1] / L], v = [(-u[1] * g) / 2, (u[0] * g) / 2], F = 3000;
+	const p = [a[0] - u[0] * F, a[1] - u[1] * F], r = [a[0] + u[0] * F, a[1] + u[1] * F];
+	return poly([[p[0] + v[0], p[1] + v[1]], [r[0] + v[0], r[1] + v[1]], [r[0] - v[0], r[1] - v[1]], [p[0] - v[0], p[1] - v[1]]]);
+};
+
+/**
+ * A split head: a slit g wide down an upright at x from above the cap to depth y, so the stem forks into two prongs.
+ *
+ * @param {number} x The upright's middle.
+ * @param {number} y How far down the slit runs.
+ * @param {number} g The slit's width.
+ * @returns {import('../geometry/types.js').Polygon} The slit, to cut.
+ */
+export const splitHead = (x, y, g) => rect(x - g / 2, -400, g, 400 + y);
+
+/**
+ * A split foot: the slit up from below the base to height y.
+ *
+ * @param {number} x The upright's middle.
+ * @param {number} y How far up the slit runs.
+ * @param {number} g The slit's width.
+ * @returns {import('../geometry/types.js').Polygon} The slit, to cut.
+ */
+export const splitFoot = (x, y, g) => rect(x - g / 2, y, g, 1200);
+
+/* ---------- letters ---------- */
+
+/**
+ * A minim: an upright from y0 to y1, with the nib's flag head (a short ↘ entry from the upper left) and lozenge foot (a
+ * short ↘ exit to the lower right).
+ *
+ * @param {number} x The upright's x.
+ * @param {number} y0 Its top.
+ * @param {number} y1 Its foot.
+ * @param {{ head?: boolean, foot?: boolean, d?: number }} [o] Whether it has its head and foot (both by default), and how
+ *   far each runs (40).
+ * @returns {import('../geometry/types.js').Point[]} The polyline, for nib().
+ */
+export const minim = (x, y0, y1, { head = true, foot = true, d = 40 } = {}) =>
+	[...(head ? [[x - d, y0 - d]] : []), [x, y0], [x, y1], ...(foot ? [[x + d, y1 + d]] : [])];
+
+/**
+ * A lozenge parted from the ink: the ink less the lozenge grown by g, plus the lozenge. Run the stroke it ends into the
+ * lozenge, so the moat cuts it right across (a stroke that stops short leaves a hooked tip where its nib-cut end meets the
+ * moat).
+ *
+ * @param {import('../geometry/types.js').Geom} ink The letter.
+ * @param {import('../geometry/types.js').Polygon} z The lozenge (from lozenge()).
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The letter with its lozenge parted off.
+ */
+export const parted = (ink, z, g) => U(D(ink, grownLozenge(z, g)), z);
+
+/**
+ * A lozenge grown by g all round (its moat).
+ *
+ * @param {import('../geometry/types.js').Polygon} z The lozenge.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Polygon} The grown lozenge.
+ */
+const grownLozenge = (z, g) => { const [[x, y0], , [, y1]] = z[0], s = y1 - y0 + 2 * g * Math.SQRT2; return lozenge(x, (y0 + y1) / 2, s); };
+
+/**
+ * The capitals, each `(g) => shape` on the 440 cap (lozenges float a gap clear of the strokes): A B C D E F G H J K L M N
+ * P R S T.
+ */
+export const BLACKLETTERS = {
+	// A: a pointed arch: a thick upright rising to a hairline ↗ shoulder, the peak, the thick ↘ shoulder and the right upright
+	// ending in a lozenge foot; a bar across.
+	A: () => nibs([[[50, 440], [50, 160], [170, 30], [290, 150], [290, 400], [330, 440]], [[50, 320], [290, 250]]]),
+	// B: an upright with a flag head and two pointed bowls (each falls ↘ heavy and returns ↙ as the hairline), the upright split
+	// from its head to the lower bowl.
+	B: (g) => D(nibs([minim(52, 40, 410, { foot: false }), [[52, 40], [180, 40], [250, 110], [250, 140], [190, 210], [52, 210]], [[52, 210], [200, 210], [270, 280], [270, 330], [190, 410], [52, 410]]]), splitHead(52, 330, g)),
+	// C: a broken round (a thick back, the hairline ↗ shoulder, the thick ↘ heel), its top ending in a lozenge parted off.
+	C: (g) => parted(nibs([[[272, 46], [250, 40], [140, 40], [52, 128], [52, 330], [132, 410], [270, 410]]]), lozenge(272, 50, 120), g),
+	// D: an upright with a flag head, split at the top, and one pointed bowl.
+	D: (g) => D(nibs([minim(52, 40, 410, { foot: false }), [[52, 40], [170, 40], [270, 140], [270, 320], [180, 410], [52, 410]]]), splitHead(52, 170, g)),
+	// E: the broken round, its middle arm a lozenge parted off the back.
+	E: (g) => parted(nibs([[[270, 40], [140, 40], [52, 128], [52, 330], [132, 410], [270, 410]]]), lozenge(170, 225, 150), g),
+	// G: the broken round with a jaw rising to a spur, its top ending in a lozenge parted off.
+	G: (g) => parted(nibs([[[272, 46], [250, 40], [140, 40], [52, 128], [52, 330], [132, 410], [270, 410], [270, 250], [190, 250]]]), lozenge(272, 50, 120), g),
+	// H: two minims, their bar a lozenge set across them.
+	H: () => U(nibs([minim(52, 40, 400), minim(268, 40, 400)]), lozenge(160, 226, 200)),
+	// J: a minim falling to a foot that turns back left and runs into a lozenge parted off.
+	J: (g) => parted(nibs([minim(190, 40, 330, { foot: false }), [[190, 330], [120, 410], [30, 410], [14, 404]]]), lozenge(14, 400, 120), g),
+	// L: an upright split at its head, its foot bar running into a lozenge parted off.
+	L: (g) => parted(D(nibs([minim(52, 40, 410, { foot: false }), [[52, 410], [262, 410], [284, 404]]]), splitHead(52, 170, g)), lozenge(284, 400, 120), g),
+	// P: B's top bowl on an upright with a flag head and a lozenge foot, split at its head (R splits its foot).
+	P: (g) => D(nibs([minim(52, 40, 400), [[52, 40], [180, 40], [250, 110], [250, 160], [180, 236], [52, 236]]]), splitHead(52, 150, g)),
+	// F: an upright with a flag head and a lozenge foot, a top bar, its middle arm a lozenge parted off.
+	F: (g) => parted(nibs([minim(52, 40, 400), [[52, 40], [260, 40]], [[52, 225], [150, 225]]]), lozenge(170, 225, 150), g),
+	// K: an upright, the hairline arm rising ↗ from its middle, the thick leg falling ↘.
+	K: () => nibs([minim(52, 40, 400), [[80, 250], [270, 30]], [[140, 200], [260, 380], [300, 420]]]),
+	// M: three uprights under two pointed arches, each foot a lozenge.
+	M: () => nibs([[[44, 440], [44, 100], [114, 30], [184, 100], [184, 400], [224, 440]], [[184, 100], [254, 30], [324, 100], [324, 400], [364, 440]]]),
+	// N: two uprights joined by the thick ↘ diagonal.
+	N: () => nibs([minim(52, 40, 410, { foot: false }), [[52, 40], [268, 400]], minim(268, 40, 400, { head: false })]),
+	// R: B's top bowl over a leg falling ↘ to a lozenge foot, the upright split at its foot.
+	R: (g) => D(nibs([minim(52, 40, 440, { foot: false }), [[52, 40], [180, 40], [250, 110], [250, 150], [190, 226], [52, 226]], [[150, 226], [250, 380], [290, 420]]]), splitFoot(52, 300, g)),
+	// S: the angular S (a top bar, the heavy spine falling ↘ between two short uprights, a foot bar), each end a lozenge parted off.
+	S: (g) => parted(parted(nibs([[[272, 46], [250, 40], [130, 40], [50, 120], [50, 170], [260, 290], [260, 330], [180, 410], [40, 410], [18, 404]]]), lozenge(272, 50, 120), g), lozenge(18, 400, 120), g),
+	// T: a bar ending in two lozenges over a minim.
+	T: () => U(nibs([[[60, 50], [260, 50]], minim(160, 50, 400, { head: false })]), lozenge(20, 50, 130), lozenge(300, 50, 130)),
+};
+
+/**
+ * A blackletter capital drawn with the gap g, centred on (256, 256).
+ *
+ * @param {string} k The letter (a BLACKLETTERS key).
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The letter.
+ */
+export const blackLetter = (k, g) => { const s = BLACKLETTERS[k](g), [x0, y0, x1, y1] = bbox(s); return move(s, 256 - (x0 + x1) / 2, 256 - (y0 + y1) / 2); };

package/src/letters/dotstroke.d.ts

@@ -0,0 +1,16 @@
+import type { Geom, Polygon, Shape } from '../geometry/types.js';
+
+/** The stem width: 100. */
+export const DOT_S: number;
+/** The disc's radius: 56. */
+export const DOT_R: number;
+/** The band between two lines (cap line and baseline by default), wider than the canvas. */
+export function dotBand(y0?: number, y1?: number): Polygon;
+/** A straight stroke a → b, w wide square to it, run ext past both ends. */
+export function stroke(a: readonly number[], b: readonly number[], w?: number, ext?: number): Polygon;
+/** A diagonal from (xt, y0) to (xb, y1), w wide square to it, its ends flat on the lines. */
+export function diag(xt: number, xb: number, y0?: number, y1?: number, w?: number): Shape;
+/** The disc. */
+export function dot(cx: number, cy: number, r?: number): Polygon;
+/** The disc at (cx, cy) and the rest of the letter cut free of it by the gap g. */
+export function withDot(rest: Shape | Geom[], cx: number, cy: number, g: number, r?: number): Shape;

package/src/letters/dotstroke.js

@@ -0,0 +1,77 @@
+/**
+ * Dot Stroke letters: a bold, square-ended letter, numeral or simple shape with ONE of its strokes replaced by ONE disc
+ * where that stroke would end or stand. Stems are DOT_S wide, diagonals the same width square to the stroke and clipped
+ * flat to the cap line and baseline (the 448 frame's T and B), the disc DOT_R in radius (1.12 of a stem across: about the
+ * stroke width or a touch larger), and the rest of the letter cut free of the disc by the gap (`withDot()`).
+ * From the Logomarks tools (dotstrokeparts.mjs, batches 331 and 333).
+ */
+import { U, D, I, rect, circle, poly } from '../geometry/index.js';
+import { T, B } from './frame.js';
+
+/** The stem width: 100. */
+export const DOT_S = 100;
+
+/** The disc's radius: 56 (its diameter 1.12 of a stem). */
+export const DOT_R = 56;
+
+/**
+ * The band between two lines (the cap line and the baseline by default): every diagonal is clipped to it, so its ends sit
+ * flat on the lines.
+ *
+ * @param {number} [y0] The top line (T).
+ * @param {number} [y1] The bottom line (B).
+ * @returns {import('../geometry/types.js').Polygon} A rectangle wider than the canvas.
+ */
+export const dotBand = (y0 = T, y1 = B) => rect(-400, y0, 1312, y1 - y0);
+
+/**
+ * A straight stroke from a to b, w wide measured square to it, run `ext` past both ends (clip it with `dotBand()` or a
+ * union).
+ *
+ * @param {readonly number[]} a The start of the centre line.
+ * @param {readonly number[]} b The end of the centre line.
+ * @param {number} [w] The width, square to the stroke (DOT_S).
+ * @param {number} [ext=0] How far it runs on past both ends.
+ * @returns {import('../geometry/types.js').Polygon} The stroke.
+ */
+export const stroke = (a, b, w = DOT_S, ext = 0) => {
+	const dx = b[0] - a[0], dy = b[1] - a[1], L = Math.hypot(dx, dy), ux = dx / L, uy = dy / L,
+		nx = -uy * w / 2, ny = ux * w / 2, A = [a[0] - ux * ext, a[1] - uy * ext], Bp = [b[0] + ux * ext, b[1] + uy * ext];
+	return poly([[A[0] + nx, A[1] + ny], [Bp[0] + nx, Bp[1] + ny], [Bp[0] - nx, Bp[1] - ny], [A[0] - nx, A[1] - ny]]);
+};
+
+/**
+ * A diagonal between two lines: its centre line from (xt, y0) to (xb, y1), w wide square to it, its ends flat on the lines.
+ *
+ * @param {number} xt The centre line's x on the top line.
+ * @param {number} xb The centre line's x on the bottom line.
+ * @param {number} [y0] The top line (T).
+ * @param {number} [y1] The bottom line (B).
+ * @param {number} [w] The width, square to the stroke (DOT_S).
+ * @returns {import('../geometry/types.js').Shape} The diagonal.
+ */
+export const diag = (xt, xb, y0 = T, y1 = B, w = DOT_S) => I(stroke([xt, y0], [xb, y1], w, 200), dotBand(y0, y1));
+
+/**
+ * The disc.
+ *
+ * @param {number} cx Its centre's x.
+ * @param {number} cy Its centre's y.
+ * @param {number} [r] Its radius (DOT_R).
+ * @returns {import('../geometry/types.js').Polygon} The disc.
+ */
+export const dot = (cx, cy, r = DOT_R) => circle(cx, cy, r, 120);
+
+/**
+ * The family's one move: the disc at (cx, cy), and the rest of the letter cut free of it by the gap g where it comes
+ * nearer.
+ *
+ * @param {import('../geometry/types.js').Shape | import('../geometry/types.js').Geom[]} rest The rest of the letter (a
+ *   shape, or a list of shapes and polygons, united).
+ * @param {number} cx The disc's centre's x.
+ * @param {number} cy The disc's centre's y.
+ * @param {number} g The gap.
+ * @param {number} [r] The disc's radius (DOT_R).
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const withDot = (rest, cx, cy, g, r = DOT_R) => U(dot(cx, cy, r), D(U(...[rest].flat()), circle(cx, cy, r + g, 120)));

package/src/letters/echo.d.ts

@@ -0,0 +1,42 @@
+import type { Geom, Shape } from '../geometry/types.js';
+
+/** An Echo letter: its cap height, width, shape and keep-out. */
+export interface EchoLetter {
+	H: number;
+	W: number;
+	shape: Shape;
+	/** Every stroke widened by the gap: where an echo may not go. */
+	keepOut: (gap: number) => Shape;
+}
+/** A stroke part: its solid and its keep-out. */
+export interface EchoPart {
+	s: Geom;
+	k: (gap: number) => Geom;
+}
+/** A stroke's centreline: its two ends. */
+export type EchoLine = number[][];
+
+/** How far a stroke runs on before it is clipped: 4000. */
+export const BIG: number;
+/** A letter: its parts united and clipped to its box. */
+export function echoLetter(H: number, W: number, parts: readonly EchoPart[], x0?: number): EchoLetter;
+/** The echo of stroke [a, b]: the same stroke set a gap off it toward `to`, cut back clear of every stroke. */
+export function echo(L: EchoLetter, ab: readonly (readonly number[])[], to: readonly number[], gap: number, o?: { w?: number; y0?: number; y1?: number; x0?: number; x1?: number }): Shape;
+/** A mark drawn at the cap height that makes its longest side span. */
+export function fitH(draw: (H: number) => Shape, span?: number): Shape;
+/** A letter and its echo at the size that makes the stroke 104, as a build for exact(). */
+export function mark<K extends { L: EchoLetter }>(make: (H: number) => K, ech: (k: K, gap: number) => Shape, air?: boolean): (g: number) => Shape;
+/** K: stem, arm and leg. */
+export function K_(H: number): { arm: EchoLine; leg: EchoLine; L: EchoLetter };
+/** R: stem, round bowl and leg. */
+export function R_(H: number): { leg: EchoLine; L: EchoLetter };
+/** Y: two arms into a stem. */
+export function Y_(H: number): { r: EchoLine; j: number[]; L: EchoLetter };
+/** Seven: the bar and the diagonal. */
+export function Seven_(H: number): { d: EchoLine; W: number; L: EchoLetter };
+/** Q: a ring and a tail. */
+export function Q_(H: number): { d: EchoLine; L: EchoLetter };
+/** Lowercase k. */
+export function k_(H: number): { leg: EchoLine; arm: EchoLine; L: EchoLetter };
+/** Lowercase y. */
+export function y_(H: number): { long: EchoLine; xh: number; L: EchoLetter };

package/src/letters/echo.js

@@ -0,0 +1,246 @@
+/**
+ * Echo letters: heavy geometric letters (stroke 104, flat terminals) built from stroke parts with keep-outs, and the echo
+ * of one stroke set off a gap beside it. Each part is { s, k }: its solid, and its keep-out (the solid widened by a gap),
+ * so an echo stops parallel to every stroke it meets. `mark()` builds a letter and its echo at the size that makes the
+ * stroke 104 once fitted.
+ * From the Logomarks tools (echoparts.mjs, batches 202 and 220).
+ */
+import { D, I, U, bar, circle, grow, stroke, sample, bbox } from '../geometry/index.js';
+import { despeckShape } from '../parts/index.js';
+import { box } from '../util/vec.js';
+
+/* ================================================================ geometry ================================================================ */
+
+/** The stroke. */
+const T = 104;
+
+/** How far a stroke runs on before it is clipped: 4000, past any canvas. */
+export const BIG = 4000;
+
+/**
+ * The unit vector from a to b.
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @returns {number[]} The direction.
+ */
+const unit = (a, b) => { const L = Math.hypot(b[0] - a[0], b[1] - a[1]); return [(b[0] - a[0]) / L, (b[1] - a[1]) / L]; };
+
+/**
+ * A straight stroke w wide along a→b, run on by e0 before a and e1 past b (run a stroke past the cap or base, then clip it).
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @param {number} [w] The width (104).
+ * @param {number} [e0=0] The run before a.
+ * @param {number} [e1=0] The run past b.
+ * @returns {import('../geometry/types.js').Polygon} The stroke.
+ */
+const seg = (a, b, w = T, e0 = 0, e1 = 0) => { const u = unit(a, b); return bar([a[0] - u[0] * e0, a[1] - u[1] * e0], [b[0] + u[0] * e1, b[1] + u[1] * e1], w); };
+
+/**
+ * A ring's area.
+ *
+ * @param {readonly (readonly number[])[]} r The ring.
+ * @returns {number} Its area.
+ */
+const area = (r) => Math.abs(r.reduce((s, p, i) => { const q = r[(i + 1) % r.length]; return s + p[0] * q[1] - q[0] * p[1]; }, 0)) / 2;
+
+/**
+ * The largest piece of a shape (an echo cut by another stroke keeps its main run, not the scrap beyond).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @returns {import('../geometry/types.js').Shape} Its largest polygon.
+ */
+const largest = (s) => (s.length ? [s.reduce((a, b) => (area(b[0]) > area(a[0]) ? b : a))] : s);
+
+/**
+ * A diagonal's centreline from two anchors: k = +1 puts the stroke's left edge on the anchor, −1 its right edge, 0 its
+ * centre (the horizontal half-width is T / 2 over the slope's sine). So a stroke can run edge to corner, as a geometric Z
+ * or X does.
+ *
+ * @param {readonly number[]} p The top anchor.
+ * @param {readonly number[]} q The bottom anchor.
+ * @param {number} [kp=0] Which edge sits on p.
+ * @param {number} [kq=0] Which edge sits on q.
+ * @param {number} [w] The stroke (104).
+ * @returns {readonly number[][]} The centreline's two ends.
+ */
+const diag = (p, q, kp = 0, kq = 0, w = T) => {
+	let a = p, b = q;
+	for (let i = 0; i < 4; i++) { const Th = (w * Math.hypot(b[0] - a[0], b[1] - a[1])) / Math.abs(b[1] - a[1]); a = [p[0] + (kp * Th) / 2, p[1]]; b = [q[0] + (kq * Th) / 2, q[1]]; }
+	return [a, b];
+};
+
+/**
+ * A stroke part: its solid and its keep-out (the stroke widened by a gap, so an echo stops parallel to it). k0, k1 set
+ * the keep-out's run past either end (0 where the stroke ends flush in another, as a 7's bar does in its diagonal).
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @param {number} [e0=0] The run before a.
+ * @param {number} [e1=0] The run past b.
+ * @param {number} [w] The stroke (104).
+ * @param {{ k0?: number | null, k1?: number | null }} [o] The keep-out's runs.
+ * @returns {{ s: import('../geometry/types.js').Polygon, k: (gap: number) => import('../geometry/types.js').Polygon, a: readonly number[], b: readonly number[] }} The part.
+ */
+const st = (a, b, e0 = 0, e1 = 0, w = T, { k0 = null, k1 = null } = {}) =>
+	({ s: seg(a, b, w, e0, e1), k: (gap) => seg(a, b, w + 2 * gap, k0 ?? e0 + gap, k1 ?? e1 + gap), a, b });
+
+/**
+ * A solid part: any shape, its keep-out the shape grown by the gap.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @returns {{ s: import('../geometry/types.js').Geom, k: (gap: number) => import('../geometry/types.js').Shape }} The part.
+ */
+const solid = (shape) => ({ s: shape, k: (gap) => grow(shape, gap) });
+
+/**
+ * A part kept inside a box (an arm cut flat on the x-height, a diagonal stopped inside the bar it lands on).
+ *
+ * @param {{ s: import('../geometry/types.js').Geom, k: (gap: number) => import('../geometry/types.js').Geom }} q The part.
+ * @param {readonly number[]} box The box [x0, y0, x1, y1].
+ * @returns {{ s: import('../geometry/types.js').Shape, k: (gap: number) => import('../geometry/types.js').Shape }} The part, clipped.
+ */
+const clip = (q, [x0, y0, x1, y1]) => ({ ...q, s: I(q.s, box(x0, y0, x1, y1)), k: (gap) => I(q.k(gap), box(x0 - gap, y0 - gap, x1 + gap, y1 + gap)) });
+
+/**
+ * A letter: its parts united and clipped to its box (flat terminals on the cap, base and sides).
+ *
+ * @param {number} H The cap height.
+ * @param {number} W The width.
+ * @param {readonly { s: import('../geometry/types.js').Geom, k: (gap: number) => import('../geometry/types.js').Geom }[]} parts The parts.
+ * @param {number} [x0=0] The box's left edge.
+ * @returns {import('./echo.js').EchoLetter} The letter: H, W, its shape and its keep-out.
+ */
+export const echoLetter = (H, W, parts, x0 = 0) => ({ H, W, shape: I(U(...parts.map((p) => p.s)), box(x0, 0, W, H)), keepOut: (gap) => U(...parts.map((p) => p.k(gap))) });
+
+/**
+ * The echo of stroke a→b: the same stroke (w wide) set off to the side of point `to`, `gap` clear of it, run long,
+ * clipped to the box x0…x1, y0…y1 (default the cap and base lines), cut back `gap` clear of every stroke, and its main
+ * piece kept.
+ *
+ * @param {import('./echo.js').EchoLetter} L The letter.
+ * @param {readonly (readonly number[])[]} ab The stroke's centreline [a, b].
+ * @param {readonly number[]} to A point on the side the echo goes.
+ * @param {number} gap The gap.
+ * @param {{ w?: number, y0?: number, y1?: number, x0?: number, x1?: number }} [o] The echo's width and box.
+ * @returns {import('../geometry/types.js').Shape} The echo.
+ */
+export const echo = (L, [a, b], to, gap, { w = T, y0 = 0, y1 = L.H, x0 = -BIG, x1 = BIG } = {}) => {
+	const u = unit(a, b);
+	let n = [-u[1], u[0]];
+	if ((to[0] - a[0]) * n[0] + (to[1] - a[1]) * n[1] < 0) n = [-n[0], -n[1]];
+	const d = T / 2 + gap + w / 2, off = (p) => [p[0] + n[0] * d, p[1] + n[1] * d];
+	return largest(despeckShape(D(I(seg(off(a), off(b), w, BIG, BIG), box(x0, y0, x1, y1)), L.keepOut(gap)), 400, 30));
+};
+
+/**
+ * Builds a mark at the cap height that makes its longest side `span` (the stroke and gaps stay fixed), by up to eight
+ * rounds of rescaling.
+ *
+ * @param {(H: number) => import('../geometry/types.js').Shape} draw The mark at cap height H.
+ * @param {number} [span=448] The longest side wanted.
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const fitH = (draw, span = 448) => {
+	let H = 420, s;
+	for (let i = 0; i < 8; i++) { s = draw(H); const [x0, y0, x1, y1] = bbox(s), m = Math.max(x1 - x0, y1 - y0); if (Math.abs(m - span) < 0.2) break; H *= span / m; }
+	return s;
+};
+
+/**
+ * A mark: the letter from `make(H)` plus its echo from `ech(k, gap)`, at the size that makes the stroke 104.
+ *
+ * @template {{ L: import('./echo.js').EchoLetter }} K
+ * @param {(H: number) => K} make A letter builder (K_, R_, Y_…).
+ * @param {(k: K, gap: number) => import('../geometry/types.js').Shape} ech Its echo, from the letter's parts.
+ * @param {boolean} [air=false] A wider gap (40 for 22).
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build, for exact().
+ */
+export const mark = (make, ech, air = false) => (g) => fitH((H) => { const k = make(H); return U(k.L.shape, ech(k, air ? (g * 40) / 22 : g)); });
+
+/* ================================================================ letters ================================================================ */
+
+/**
+ * K: stem, arm to the top right corner, leg from the arm to the bottom right corner. Echo of the arm or the leg, outside.
+ *
+ * @param {number} H The cap height.
+ * @returns {{ arm: readonly number[][], leg: readonly number[][], L: import('./echo.js').EchoLetter }} The letter and its strokes.
+ */
+export const K_ = (H) => {
+	const W = 0.74 * H, arm = diag([T / 2, 0.64 * H], [W, 0], 0, -1), t = 0.42, p = [arm[0][0] + (arm[1][0] - arm[0][0]) * t, arm[0][1] + (arm[1][1] - arm[0][1]) * t];
+	const leg = diag(p, [W, H], 0, -1);
+	return { arm, leg, L: echoLetter(H, W, [st([T / 2, -T], [T / 2, H + T]), st(...arm, 0, 2 * T), st(...leg, 0, 2 * T)]) };
+};
+
+/**
+ * R: stem, a round bowl, the leg from the bowl to the bottom right corner; the echo is the leg's, on the right under the
+ * bowl.
+ *
+ * @param {number} H The cap height.
+ * @returns {{ leg: readonly number[][], L: import('./echo.js').EchoLetter }} The letter and its leg.
+ */
+export const R_ = (H) => {
+	const W = 0.74 * H, yb = 0.58 * H, r = (yb - T / 2) / 2, bx = W - T / 2 - r;
+	const bowl = stroke([[T / 2, T / 2], [bx, T / 2], ...sample((t) => [bx + r * Math.cos(t), T / 2 + r - r * Math.sin(t)], Math.PI / 2, -Math.PI / 2, 60).slice(1), [T / 2, yb]], T, { chunk: 80 });
+	const leg = diag([bx - 0.1 * H, yb], [W, H], 0, -1);
+	return { leg, L: echoLetter(H, W, [st([T / 2, -T], [T / 2, H + T]), solid(bowl), st(...leg, 0, 2 * T)]) };
+};
+
+/**
+ * Y: two arms into a stem. The echo of the right arm stands outside it and runs down until the stem stops it.
+ *
+ * @param {number} H The cap height.
+ * @returns {{ r: readonly number[][], j: number[], L: import('./echo.js').EchoLetter }} The letter, its right arm and the join.
+ */
+export const Y_ = (H) => {
+	const W = 0.86 * H, j = [W / 2, 0.54 * H], r = diag([W, 0], j, -1, 0), l = diag([0, 0], j, 1, 0);
+	return { r, j, L: echoLetter(H, W, [st(...l, 2 * T, 0), st(...r, 2 * T, 0), st([W / 2, j[1] - T / 2], [W / 2, H], 0, T)]) };
+};
+
+/**
+ * Seven: the bar and the diagonal (its right edge from the bar's corner); the echo outside on the right.
+ *
+ * @param {number} H The cap height.
+ * @returns {{ d: readonly number[][], W: number, L: import('./echo.js').EchoLetter }} The numeral, its diagonal and width.
+ */
+export const Seven_ = (H) => {
+	const W = 0.72 * H, d = diag([W, T], [0.16 * W, H], -1, 1);
+	return { d, W, L: echoLetter(H, W, [st([0, T / 2], [W, T / 2], 0, 0, T, { k1: 0 }), st(...d, 2 * T, 2 * T)]) };
+};
+
+/**
+ * Q: a ring and a tail; the tail's echo runs beside it, outside the ring.
+ *
+ * @param {number} H The cap height.
+ * @returns {{ d: readonly number[][], L: import('./echo.js').EchoLetter }} The letter and its tail.
+ */
+export const Q_ = (H) => {
+	const W = 1.02 * H, r = (H - T) / 2, c = [H / 2, H / 2], d = diag([c[0] + r * 0.72, c[1] + r * 0.72], [W, H], 0, -1);
+	return { d, L: echoLetter(H, W, [solid(D(circle(...c, r + T / 2, 240), circle(...c, r - T / 2, 240))), st(...d, 0, 2 * T)]) };
+};
+
+/**
+ * Lowercase k: the tall stem, the arm up to the x-height, the leg to the base; the echo is the leg's.
+ *
+ * @param {number} H The ascender height.
+ * @returns {{ leg: readonly number[][], arm: readonly number[][], L: import('./echo.js').EchoLetter }} The letter and its strokes.
+ */
+export const k_ = (H) => {
+	const W = 0.66 * H, xh = 0.36 * H, arm = diag([T / 2, 0.74 * H], [W, xh], 0, -1), t = 0.4, p = [arm[0][0] + (arm[1][0] - arm[0][0]) * t, arm[0][1] + (arm[1][1] - arm[0][1]) * t];
+	const leg = diag(p, [W, H], 0, -1);
+	return { leg, arm, L: echoLetter(H, W, [st([T / 2, -T], [T / 2, H + T]), clip(st(...arm, 0, 2 * T), [-BIG, xh, BIG, BIG]), st(...leg, 0, 2 * T)]) };
+};
+
+/**
+ * Lowercase y: the short arm meets the long stroke, which runs on to the descender; the echo is the long stroke's,
+ * outside.
+ *
+ * @param {number} H The height, x-height top to descender.
+ * @returns {{ long: readonly number[][], xh: number, L: import('./echo.js').EchoLetter }} The letter, its long stroke and x-height.
+ */
+export const y_ = (H) => {
+	const W = 0.74 * H, xh = 0.3 * H, j = [0.5 * W, 0.72 * H], long = diag([W, xh], [0.06 * W, H], -1, 1), sh = diag([0, xh], j, 1, 0);
+	return { long, xh, L: echoLetter(H, W, [clip(st(...long, 2 * T, 2 * T), [-BIG, xh, BIG, BIG]), clip(st(sh[0], sh[1], 2 * T, 0), [-BIG, xh, BIG, BIG])]) };
+};

package/src/letters/frame.d.ts

@@ -0,0 +1,6 @@
+/** The cap line: y 32. */
+export const T: number;
+/** The baseline: y 480. */
+export const B: number;
+/** The cap height: 448. */
+export const H: number;

package/src/letters/frame.js

@@ -0,0 +1,14 @@
+/**
+ * The 448 cap frame the Dot Stroke and Ink Trap letters are drawn on: the cap line, the baseline and the cap height,
+ * centred on the 512 canvas. From the Logomarks tools (dotstrokeparts.mjs and inktrapparts.mjs, which each had a copy).
+ */
+import { C } from '../geometry/index.js';
+
+/** The cap line: y 32. */
+export const T = C - 224;
+
+/** The baseline: y 480. */
+export const B = C + 224;
+
+/** The cap height: 448. */
+export const H = 448;

package/src/letters/index.d.ts

@@ -0,0 +1,16 @@
+export * from './frame.js';
+export * from './serif.js';
+export * from './blackletter.js';
+export * from './pillar.js';
+export * from './stem.js';
+export * from './mono.js';
+export * from './echo.js';
+export * from './dotstroke.js';
+export * from './inktrap.js';
+export * from './stair.js';
+export type { Face, Glyph, SourceGlyph, GlyphSource, Slant, RingArc, Crossing, Order, Build, Placer } from './serif.js';
+export type { Nib } from './blackletter.js';
+export type { PillarFace, PillarPart, PillarOptions } from './pillar.js';
+export type { StemFace, StemPart, StemPlacement } from './stem.js';
+export type { EchoLetter, EchoPart, EchoLine } from './echo.js';
+export type { TrapJoin, TrapOptions } from './inktrap.js';

package/src/letters/index.js

@@ -0,0 +1,18 @@
+/**
+ * @module @logomarks/core/letters
+ *
+ * Letters built from geometry, never typeset: a high-contrast Didone capital alphabet with its frames and one-move
+ * builds (serif), modern blackletter from one 30° broad nib (blackletter), condensed Didone pairs on one shared stem
+ * (pillar, stem), the monogram letters (Fused, Track, Badge and Fan), and the Echo, Dot Stroke, Ink Trap and Stair faces.
+ * The Dot Stroke and Ink Trap letters share the 448 cap frame T, B, H. Moves that place on a font's letter are /font's.
+ */
+export * from './frame.js';
+export * from './serif.js';
+export * from './blackletter.js';
+export * from './pillar.js';
+export * from './stem.js';
+export * from './mono.js';
+export * from './echo.js';
+export * from './dotstroke.js';
+export * from './inktrap.js';
+export * from './stair.js';