@logomarks/core 0.1.11 → 0.2.0

package/src/letters/pillar.d.ts

@@ -0,0 +1,31 @@
+import type { Shape } from '../geometry/types.js';
+import type { Face } from './serif.js';
+
+/** The pillar face: a condensed serif face with its counter width cw. */
+export type PillarFace = Face & { cw: number };
+/** A letter drawn beside the pillar: its ink, the pillar corners it joins, and (for a follow) its far edge. */
+export interface PillarPart {
+	s: Shape;
+	at: Record<string, number>;
+	w?: number;
+}
+/** pillarPair()'s options: a T lead's bar and an H lead's crossbar. */
+export interface PillarOptions {
+	tOver?: number;
+	tLeft?: number;
+	tBeak?: number;
+	hBar?: number;
+}
+
+/** The condensed face at cap H with hairline h. */
+export function pface(H: number, h: number): PillarFace;
+/** A condensed bowl on a stem, its right corners rounded by quarter ellipses. */
+export function cBowl(m: Face, x0: number, y0: number, y1: number, xr: number, t: number, ry: number): Shape;
+/** The leads, drawn left of the pillar. */
+export const PILLAR_LEFT: Record<string, (m: PillarFace, o?: PillarOptions) => PillarPart>;
+/** The follows, drawn right of the pillar (t: under a T lead's bar). */
+export const PILLAR_RIGHT: Record<string, (m: PillarFace, t?: boolean) => PillarPart>;
+/** The pair a + b on one pillar at cap H with hairline h. */
+export function pillarPair(a: string, b: string, H: number, h: number, o?: PillarOptions): { s: Shape; m: PillarFace };
+/** The pillar mark: the pair over a short bar a gap below, optionally knocked out of a disc. */
+export function pillar(a: string, b: string, o?: PillarOptions & { bar?: number; bh?: number; disc?: boolean; pad?: number }): (g: number) => Shape;

package/src/letters/pillar.js

@@ -0,0 +1,257 @@
+/**
+ * Pillar monograms: two tall condensed Didone capitals sharing ONE stem, the pillar, over a short bar a gap below,
+ * optionally knocked out of a disc. A geometric condensed Didone on the serif face's parts (foot serifs, brackets,
+ * slants, stressed rings): the first letter is drawn left of the pillar (x < 0), the second right of it (x > S). Leads
+ * (PILLAR_LEFT): J M N D A H, and a T lead is the pillar's own top. Follows (PILLAR_RIGHT): D P B H F R N K A E L. From the
+ * Logomarks tools (pillarparts.mjs, batches 292, 300 and 329).
+ */
+import { U, D, I, rect, ellipse, circle, move, bbox, poly } from '../geometry/index.js';
+import { despeckShape } from '../parts/index.js';
+import { face, foot, slant, ringArc, ball, bracket } from './serif.js';
+
+/**
+ * A vector made unit length.
+ *
+ * @param {readonly number[]} v The vector.
+ * @returns {number[]} Its direction.
+ */
+const unit = ([x, y]) => { const l = Math.hypot(x, y) || 1; return [x / l, y / l]; };
+
+/**
+ * The condensed face: cap H, stems S (the pillar, 0.19 H), hairlines h (set so they fit to 31), serifs reaching ov,
+ * counters cw wide (facing serifs keep 40+ between them). The pillar is x 0…S.
+ *
+ * @param {number} H The cap height.
+ * @param {number} h The hairline.
+ * @returns {import('./serif.js').Face & { cw: number }} The face.
+ */
+export const pface = (H, h) => ({ ...face(H, { S: Math.round(H * 0.19), h, ov: Math.round(H * 0.06), br: Math.round(H * 0.04), beak: Math.round(H * 0.16) }),
+	cw: Math.round(H * 0.24) });
+
+/**
+ * A rectangle from its corners.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} x1 Right.
+ * @param {number} y1 Bottom.
+ * @returns {import('../geometry/types.js').Polygon} The rectangle.
+ */
+const R = (x0, y0, x1, y1) => rect(x0, y0, x1 - x0, y1 - y0);
+
+/**
+ * A condensed bowl on a stem whose left edge is x0, from y0 to y1, reaching right to xr: straight hairlines top and
+ * bottom, its right side t thick and straight, the right corners rounded by quarter ellipses (ry down). Includes the
+ * stem.
+ *
+ * @param {import('./serif.js').Face} m The face.
+ * @param {number} x0 The stem's left edge.
+ * @param {number} y0 The bowl's top.
+ * @param {number} y1 Its bottom.
+ * @param {number} xr Its right edge.
+ * @param {number} t Its right side's thickness.
+ * @param {number} ry The corners' radius down.
+ * @returns {import('../geometry/types.js').Shape} The bowl.
+ */
+export const cBowl = (m, x0, y0, y1, xr, t, ry) => {
+	ry = Math.min(ry, (y1 - y0) / 2); const rx = Math.min(xr - x0 - m.S - 2, (xr - x0 - m.S) * 0.9);
+	const rr = (a, b, c, d, rx, ry) => { const cx = c - rx; return U(R(a, b, cx + 0.5, d), I(U(ellipse(cx, b + ry, rx, ry, 0, 200), ellipse(cx, d - ry, rx, ry, 0, 200), R(cx, b + ry, c, d - ry)), R(cx, b - 1, c + 1, d + 1))); };
+	return D(rr(x0, y0, xr, y1, rx, ry), rr(x0 + m.S, y0 + m.h, xr - t, y1 - m.h, Math.max(4, rx - t), Math.max(4, ry - m.h)));
+};
+
+/**
+ * A beak serif: a hairline-wide drop of `len` at the end x of a bar along the cap line (dir −1: the bar runs left of x).
+ *
+ * @param {import('./serif.js').Face} m The face.
+ * @param {number} x The bar's end.
+ * @param {number} dir Which way the bar runs from x.
+ * @param {number} len The drop.
+ * @returns {import('../geometry/types.js').Shape} The beak.
+ */
+const beak = (m, x, dir, len) => dir > 0
+	? U(R(x - m.bw, 0, x, len), bracket([x - m.bw, m.h], [-1, 0], [0, 1], m.br * 0.8))
+	: U(R(x, 0, x + m.bw, len), bracket([x + m.bw, m.h], [1, 0], [0, 1], m.br * 0.8));
+
+/**
+ * A beak serif up from the baseline: a hairline-wide rise of `len` at the free end x of a foot bar running right.
+ *
+ * @param {import('./serif.js').Face} m The face.
+ * @param {number} x The bar's free end.
+ * @param {number} len The rise.
+ * @returns {import('../geometry/types.js').Shape} The beak.
+ */
+const beakUp = (m, x, len) => U(R(x - m.bw, m.H - len, x, m.H), bracket([x - m.bw, m.H - m.h], [-1, 0], [0, -1], m.br * 0.8));
+
+/**
+ * The pillar's top as a T's bar: from xl to xr along the cap line, beaks at the ends, bracketed under into the pillar.
+ *
+ * @param {import('./serif.js').Face} m The face.
+ * @param {number} xl The bar's left end.
+ * @param {number} xr Its right end.
+ * @param {{ bl?: number, brk?: number }} [o] Whether each end has its beak.
+ * @returns {import('../geometry/types.js').Shape} The bar.
+ */
+const tBar = (m, xl, xr, { bl = 1, brk = 1 } = {}) => U(R(xl, 0, xr, m.h), bl ? beak(m, xl, -1, m.beak) : [], brk ? beak(m, xr, 1, m.beak) : [],
+	bracket([0, m.h], [-1, 0], [0, 1], m.br), bracket([m.S, m.h], [1, 0], [0, 1], m.br));
+
+/**
+ * An A with one upright leg (the pillar) and one thick diagonal: side −1 the diagonal runs down-left from the pillar's
+ * top-left corner (A leads), +1 down-right from its top-right (A follows).
+ *
+ * @param {import('./serif.js').Face} m The face.
+ * @param {number} side −1 or 1.
+ * @param {{ W?: number, t?: number, yb?: number }} [o] The A's width at the baseline past the pillar, the diagonal's
+ *   thickness and its bar's height.
+ * @returns {{ s: import('../geometry/types.js').Shape, at: Record<string, number> }} The A and the pillar corners it joins.
+ */
+const aSide = (m, side, { W = m.H * 0.5, t = m.S * 0.92, yb = m.H * 0.64 } = {}) => {
+	// the diagonal's outer edge runs from the pillar's outer top corner to the foot; its inner edge t across
+	const xo = side < 0 ? 0 : m.S, xf = side < 0 ? -W : m.S + W, dy = m.H, w = (t * Math.hypot(xf - xo, dy)) / dy;
+	const d = side < 0 ? poly([[xo, 0], [xo + w, 0], [xf + w, m.H], [xf, m.H]]) : poly([[xo - w, 0], [xo, 0], [xf, m.H], [xf - w, m.H]]);
+	const dk = I(d, side < 0 ? R(-W - w - 10, 0, m.S, m.H) : R(0, 0, m.S + W + w + 10, m.H));
+	const xIn = (y) => (side < 0 ? xo + w + ((xf - xo) * y) / dy : xo - w + ((xf - xo) * y) / dy); // the diagonal's inner edge at y
+	const bar = side < 0 ? R(xIn(yb + m.h) - 1, yb, 0.5, yb + m.h) : R(m.S - 0.5, yb, xIn(yb + m.h) + 1, yb + m.h);
+	const dir = unit([xo - xf, -dy]);
+	const ft = side < 0 ? foot(m, xf, xf + w, 'base', { da: dir, db: dir }) : foot(m, xf - w, xf, 'base', { da: dir, db: dir });
+	return { s: U(dk, bar, ft), at: side < 0 ? { tl: 1 } : { tr: 1 } };
+};
+
+/**
+ * The leads, drawn left of the pillar: `(m, o) => { s, at }`, with `at` the pillar's corners it joins (tl, bl), which get
+ * no serif. H takes `o.hBar`, its crossbar's height as a fraction of the cap (0.47).
+ */
+export const PILLAR_LEFT = {
+	// J: the pillar runs on into a hook curling left along the baseline, ending in a ball
+	J(m) {
+		const rx = (m.S + m.cw) / 2 + 20, ry = m.H * 0.22, cx = m.S - rx, cy = m.H - ry, r = ringArc(cx, cy, rx, ry, m.S, m.h, 0, 160), e = r.end(160);
+		return { s: U(r.s, ball(e.o, [cx, cy - ry * 0.4], m.S * 0.5)), at: { bl: 1 } };
+	},
+	// M: a hairline left stem, a thick diagonal down to the vertex, a hairline diagonal up into the pillar's top
+	M(m) {
+		const W = m.H * 0.62, x0 = -W, vx = -W * 0.3, wd = m.S * 1.0;
+		const dl = slant(x0, vx - (wd * Math.hypot(vx - x0, m.H)) / m.H, wd, 0, m.H), dr = slant(-m.h * 0.4, vx - m.h * 1.1, m.h, 0, m.H);
+		return { s: U(R(x0, 0, x0 + m.h, m.H), foot(m, x0, x0 + m.h, 'top', { r: 0 }), foot(m, x0, x0 + m.h, 'base'), I(U(dl.s, dr.s), R(x0 - 10, 0, 0.5, m.H))), at: { tl: 1 } };
+	},
+	// N: a hairline left stem and a thick diagonal from its top down into the pillar's foot
+	N(m) {
+		const W = m.H * 0.46, x0 = -W, wd = m.S * 1.0; let xb = 0;
+		for (let i = 0; i < 4; i++) { const w = (wd * Math.hypot(xb - x0, m.H)) / m.H; xb = m.S - w; }
+		const d = slant(x0, xb, wd, 0, m.H);
+		return { s: U(R(x0, 0, x0 + m.h, m.H), foot(m, x0, x0 + m.h, 'top', { r: 0 }), foot(m, x0, x0 + m.h, 'base'), I(d.s, R(x0 - 10, 0, m.S, m.H))), at: { bl: 1 } };
+	},
+	// D: a thick left stem and hairlines top and bottom into the pillar, the counter's corners rounded on the pillar's side
+	D(m) {
+		const x0 = -(m.S + m.cw), ry = m.H * 0.2, rx = m.cw * 0.7;
+		const inner = U(R(x0 + m.S, m.h, -rx, m.H - m.h), I(U(ellipse(-rx, m.h + ry, rx, ry, 0, 200), ellipse(-rx, m.H - m.h - ry, rx, ry, 0, 200), R(-rx, m.h + ry, 0, m.H - m.h - ry)), R(-rx, 0, 0, m.H)));
+		return { s: U(D(R(x0, 0, 0.5, m.H), inner), foot(m, x0, x0 + m.S, 'top', { r: 0 }), foot(m, x0, x0 + m.S, 'base', { r: 0 })), at: { tl: 1, bl: 1 } };
+	},
+	// A: the pillar is its upright right leg, the thick diagonal runs down-left from the pillar's top
+	A(m) { return aSide(m, -1); },
+	// H: a thick left stem and a hairline crossbar at `o.hBar` of the cap (0.47) into the pillar, its right stem
+	H(m, o = {}) {
+		const x0 = -(m.S + m.cw), yc = m.H * (o.hBar ?? 0.47) - m.h / 2;
+		return { s: U(R(x0, 0, x0 + m.S, m.H), foot(m, x0, x0 + m.S, 'top'), foot(m, x0, x0 + m.S, 'base'), R(x0 + m.S - 1, yc, 1, yc + m.h)), at: {} };
+	},
+};
+
+/**
+ * The follows, drawn right of the pillar: `(m, t) => { s, at, w? }`, with `at` the pillar's corners it joins (tr, br),
+ * `t` true under a T lead's bar, and `w` its far edge.
+ */
+export const PILLAR_RIGHT = {
+	D(m) { return { s: cBowl(m, 0, 0, m.H, m.S + m.cw + m.S * 1.02, m.S * 1.02, m.H * 0.24), at: { tr: 1, br: 1 } }; },
+	P(m) { return { s: cBowl(m, 0, 0, m.H * 0.56, m.S + m.cw * 0.95 + m.S * 0.96, m.S * 0.96, m.H * 0.16), at: { tr: 1 } }; },
+	B(m) {
+		const yu = m.H * 0.47 + m.h / 2;
+		return { s: U(cBowl(m, 0, 0, yu, m.S + m.cw * 0.8 + m.S * 0.9, m.S * 0.9, m.H * 0.13), cBowl(m, 0, yu - m.h, m.H, m.S + m.cw * 0.95 + m.S * 0.98, m.S * 0.98, m.H * 0.15)), at: { tr: 1, br: 1 } };
+	},
+	// H: the crossbar from the pillar to a right stem. `t`: the T's bar runs on over the H and its right stem rises into it.
+	H(m, t) {
+		const b = m.S + m.cw, yc = m.H * 0.47 - m.h / 2;
+		return { s: U(R(b, 0, b + m.S, m.H), t ? [] : foot(m, b, b + m.S, 'top'), foot(m, b, b + m.S, 'base'), R(m.S - 1, yc, b + 1, yc + m.h)), at: {}, w: b + m.S };
+	},
+	F(m) {
+		const W = m.S + m.cw + m.H * 0.06, ym = m.H * 0.47 - m.h / 2, xm = W - m.H * 0.07, bk = (x, len) => U(R(x - m.bw, 0, x, len), bracket([x - m.bw, m.h], [-1, 0], [0, 1], m.br * 0.8));
+		return { s: U(R(0, 0, W, m.h), bk(W, m.beak), R(0, ym, xm, ym + m.h), R(xm - m.bw, ym - m.beak * 0.3, xm, ym + m.h + m.beak * 0.3),
+			bracket([xm - m.bw, ym], [-1, 0], [0, -1], m.br * 0.6), bracket([xm - m.bw, ym + m.h], [-1, 0], [0, 1], m.br * 0.6)), at: { tr: 1 } };
+	},
+	// R: P's bowl, a little shorter, and a thick leg slanting from under it to the baseline
+	R(m) {
+		const yr = m.H * 0.53, xr = m.S + m.cw * 0.95 + m.S * 0.94, W = xr + m.H * 0.05;
+		const bowl = cBowl(m, 0, 0, yr, xr, m.S * 0.94, m.H * 0.15), leg = slant(m.S + m.cw * 0.25, W - m.S * 1.05, m.S, yr - m.h, m.H);
+		return { s: U(bowl, I(leg.s, R(0, yr - m.h, W + 50, m.H)), foot(m, leg.at(m.H)[0], leg.at(m.H)[1], 'base', { da: leg.up, db: leg.up })), at: { tr: 1 } };
+	},
+	// N: a thick diagonal from the pillar's top down to a hairline right stem's foot; under a T lead's bar its right stem
+	// rises into the bar, no top serif
+	N(m, t) {
+		const W = m.H * 0.46, rx = m.S + W - m.h, wd = m.S * 1.0;
+		const d = slant(0, rx + m.h - (wd * Math.hypot(rx - 0, m.H)) / m.H, wd, 0, m.H);
+		return { s: U(I(d.s, R(0, 0, rx + m.h + 10, m.H)), R(rx, 0, rx + m.h, m.H), t ? [] : foot(m, rx, rx + m.h, 'top')), at: { tr: 1 }, w: rx + m.h };
+	},
+	// K: a hairline arm from the pillar up to the right and a thick leg from the arm down to the baseline (the serif K, condensed)
+	K(m, t) {
+		const W = m.S + m.H * 0.5, sx = m.S, yTop = t ? m.h - 1 : 0;
+		const arm = slant(W - m.ov - m.h * 1.3, sx - m.h * 1.2, m.h, yTop, m.H * 0.7), armS = I(arm.s, R(sx - 0.5, -1, W + 50, m.H));
+		const y0 = m.H * 0.4, P = [(arm.at(y0)[0] + arm.at(y0)[1]) / 2, y0], B = [W - m.S * 0.95, m.H], u = unit([B[0] - P[0], B[1] - P[1]]);
+		const ad = arm.up, cr = Math.abs(ad[0] * u[1] - ad[1] * u[0]), Q = [P[0] + (ad[0] * m.S) / cr, P[1] + (ad[1] * m.S) / cr], wb = m.S / u[1];
+		const leg = I(poly([P, Q, [B[0] + wb, m.H], B]), R(sx - 0.5, 0, W + 80, m.H)), lu = unit([P[0] - B[0], P[1] - B[1]]);
+		const top = t ? [] : foot(m, arm.at(0)[0], arm.at(0)[1], 'top', { da: arm.down, db: arm.down, brk: 0 });
+		return { s: U(armS, leg, top, foot(m, B[0], B[0] + wb, 'base', { da: lu, db: lu })), at: { tr: 1 }, w: arm.at(yTop)[1] };
+	},
+	// A: the pillar is its upright left leg, the thick diagonal runs down-right from the pillar's top
+	A(m) { return aSide(m, 1); },
+	// E: the pillar is its stem; a top bar with a beak down, a shorter middle arm with a serif, a longer foot bar with a beak up
+	E(m) {
+		const W = m.S + m.cw + m.H * 0.06, ym = m.H * 0.47 - m.h / 2, xm = W - m.H * 0.07, Wb = W + m.H * 0.03;
+		return { s: U(R(0, 0, W, m.h), beak(m, W, 1, m.beak), R(0, ym, xm, ym + m.h), R(xm - m.bw, ym - m.beak * 0.3, xm, ym + m.h + m.beak * 0.3),
+			bracket([xm - m.bw, ym], [-1, 0], [0, -1], m.br * 0.6), bracket([xm - m.bw, ym + m.h], [-1, 0], [0, 1], m.br * 0.6),
+			R(0, m.H - m.h, Wb, m.H), beakUp(m, Wb, m.beak)), at: { tr: 1, br: 1 }, w: W };
+	},
+	// L: the pillar is its stem; a foot bar with a beak up
+	L(m) { const Wb = m.S + m.cw + m.H * 0.09; return { s: U(R(0, m.H - m.h, Wb, m.H), beakUp(m, Wb, m.beak)), at: { br: 1 } }; },
+};
+
+/**
+ * The pair a + b on one pillar, at cap H with hairline h. A T lead is the pillar's own top: a bar both ways, its left arm
+ * `o.tLeft` long (as far as the right arm by default), its right arm out to the second letter's far edge plus `o.tOver`.
+ *
+ * @param {string} a The lead (a PILLAR_LEFT key, or 'T').
+ * @param {string} b The follow (a PILLAR_RIGHT key).
+ * @param {number} H The cap height.
+ * @param {number} h The hairline.
+ * @param {{ tOver?: number, tLeft?: number, tBeak?: number, hBar?: number }} [o] A T lead's bar, and an H lead's crossbar.
+ * @returns {{ s: import('../geometry/types.js').Shape, m: import('./serif.js').Face & { cw: number } }} The pair and its face.
+ */
+export const pillarPair = (a, b, H, h, o = {}) => {
+	const m = pface(H, h);
+	if (a === 'T') {
+		const Rt = PILLAR_RIGHT[b](m, true), xr = Rt.w + (o.tOver ?? 0), xl = -(o.tLeft ?? (xr - m.S));
+		const s = U(R(0, 0, m.S, m.H), Rt.s, tBar(m, xl, xr, { brk: o.tBeak ?? 1 }), foot(m, 0, m.S, 'base', { l: 1, r: Rt.at.br ? 0 : 1 }));
+		return { s, m };
+	}
+	const L = PILLAR_LEFT[a](m, o), Rt = PILLAR_RIGHT[b](m), at = { ...L.at, ...Rt.at };
+	const s = U(R(0, 0, m.S, m.H), L.s, Rt.s, foot(m, 0, m.S, 'top', { l: at.tl ? 0 : 1, r: at.tr ? 0 : 1 }), foot(m, 0, m.S, 'base', { l: at.bl ? 0 : 1, r: at.br ? 0 : 1 }));
+	return { s, m };
+};
+
+/**
+ * The pillar mark: the pair over a short bar (`bar` of the pair's width, `bh` of the stem thick) a gap below; `disc`:
+ * knocked out of a disc whose edge stays `pad` gaps clear of the ink. The hairline is redrawn so it fits to 31.
+ *
+ * @param {string} a The lead.
+ * @param {string} b The follow.
+ * @param {{ bar?: number, bh?: number, disc?: boolean, pad?: number, tOver?: number, tLeft?: number, tBeak?: number, hBar?: number }} [o]
+ *   The bar (0.5 wide, 0.6 thick), the disc (none; 2 gaps clear), and pillarPair()'s options.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build, for exact().
+ */
+export const pillar = (a, b, { bar = 0.5, bh = 0.6, disc = false, pad = 2, ...o } = {}) => (g) => {
+	const draw = (h) => {
+		const H = 380, { s, m } = pillarPair(a, b, H, h, o), [x0, , x1] = bbox(s), xc = (x0 + x1) / 2, bw = (x1 - x0) * bar;
+		let mk = U(s, R(xc - bw / 2, H + g, xc + bw / 2, H + g + m.S * bh));
+		const [X0, Y0, X1, Y1] = bbox(mk); mk = move(mk, 256 - (X0 + X1) / 2, 256 - (Y0 + Y1) / 2);
+		if (!disc) return mk;
+		const rmax = Math.max(...mk.flatMap((pg) => pg[0].map(([x, y]) => Math.hypot(x - 256, y - 256))));
+		return D(circle(256, 256, rmax + g * pad, 360), mk);
+	};
+	const [x0, y0, x1, y1] = bbox(draw(32)); return despeckShape(draw(Math.ceil((31 * Math.max(x1 - x0, y1 - y0)) / 448)), 200, 30);
+};

package/src/letters/serif.d.ts

@@ -0,0 +1,109 @@
+import type { Geom, Polygon, Shape } from '../geometry/types.js';
+
+/** A serif face's metrics: cap H, stem S, hairline h, serif reach ov, bracket br, beak length and beak width bw. */
+export interface Face {
+	H: number;
+	S: number;
+	h: number;
+	ov: number;
+	br: number;
+	beak: number;
+	bw: number;
+	[key: string]: number;
+}
+/** A glyph: its ink (from x 0) and its width. */
+export interface Glyph {
+	s: Shape;
+	w: number;
+}
+/** A glyph from a source: its ink, width and face (a grown font glyph's m carries t and dy too). */
+export interface SourceGlyph extends Glyph {
+	m: Face & { t?: number; dy?: number };
+}
+/** A glyph source: the capital at cap H, given face options and the gap g. */
+export type GlyphSource = (H: number, o?: { g?: number; S?: number; h?: number; [key: string]: number | undefined }) => SourceGlyph;
+/** A straight stroke: its shape, its sides at a height, its width along a flat end and its directions. */
+export interface Slant {
+	s: Polygon;
+	at: (y: number) => [number, number];
+	w: number;
+	up: number[];
+	down: number[];
+}
+/** A stressed ring and the points of its cut at an angle. */
+export interface RingArc {
+	s: Shape;
+	end: (a: number) => { o: number[]; i: number[] };
+}
+/** A crossing of two shapes and its centre. */
+export interface Crossing {
+	pg: Polygon;
+	c: number[];
+}
+/** Which shape is in front at each crossing. */
+export type Order = string | { under?: number[][] };
+/** A move's build, for exact(). */
+export type Build = (g: number) => Shape;
+/** Where a move cuts or places, from the face, the width, the gap and the glyph. */
+export type Placer<T> = (m: Face, w: number, g: number, L: SourceGlyph) => T;
+
+/** The metrics of a serif face with cap height H. */
+export function face(H?: number, o?: Partial<Face>): Face;
+/** The concave fillet of radius r in the corner K between two edges along d1 and d2. */
+export function bracket(K: readonly number[], d1: readonly number[], d2: readonly number[], r: number): Shape;
+/** A hairline serif slab on a stroke's end [a, b] at the cap line or the baseline. */
+export function foot(m: Face, a: number, b: number, at: 'top' | 'base', o?: { l?: number; r?: number; da?: readonly number[]; db?: readonly number[]; brk?: number }): Shape;
+/** A straight stroke with flat ends, t thick across, its left side from (xt, y0) to (xb, y1). */
+export function slant(xt: number, xb: number, t: number, y0: number, y1: number): Slant;
+/** A D-bowl on a stem from y0 to y1 reaching right to xr, its side t thick. */
+export function dBowl(m: Face, x0: number, y0: number, y1: number, xr: number, t: number, flat: number): Shape;
+/** A stressed ring kept from a0 to a1 degrees, cut along rays. */
+export function ringArc(cx: number, cy: number, rx: number, ry: number, t: number, h: number, a0?: number, a1?: number): RingArc;
+/** A ball terminal of radius rb hung inside a curve at o, toward its centre c. */
+export function ball(o: readonly number[], c: readonly number[], rb: number): Polygon;
+/** The serif capitals, each `(m) => { s, w }`. */
+export const SERIF_GLYPHS: Record<string, (m: Face) => Glyph>;
+/** The serif capital k in face m, its ink from x and its cap line at y. */
+export function serifLetter(k: string, m: Face, x?: number, y?: number): Glyph;
+/** The serif capital k in face m, centred on (cx, cy). */
+export function serifLetterAt(k: string, m: Face, cx: number, cy: number): Shape;
+/** Where two shapes cross, larger than min, sorted by key. */
+export function crossings(a: Geom, b: Geom, min?: number, key?: (c: number[]) => number): Crossing[];
+/** Two shapes laid over each other, at each crossing one in front and the other cut back by the gap. */
+export function interlace(a: Geom, b: Geom, order: Order, g?: number, o?: { reach?: number; key?: (c: number[]) => number; min?: number }): { s: Shape; n: number; xs: Crossing[] };
+/** A tucked serif pair, its hairline fitted to 31. */
+export function pairOf(a: string, b: string, o?: { H?: number; kb?: number; fx?: number; fy?: number; order?: Order }): Build;
+/** A stressed oval frame. */
+export function ovalFrame(cx: number, cy: number, rx: number, ry: number, t: number, h: number): Shape;
+/** A rectangle with its corners scooped out by quarter circles. */
+export function cartouche(cx: number, cy: number, w: number, h: number, r: number): Shape;
+/** A cartouche's outline, t thick. */
+export function cartoucheRule(cx: number, cy: number, w: number, h: number, r: number, t: number): Shape;
+/** A hairline rule, its ends tapered to a point over `taper`. */
+export function rule(x0: number, x1: number, y: number, h: number, taper?: number): Polygon;
+/** A rectangle with its corners chamfered c. */
+export function octagon(cx: number, cy: number, w: number, h: number, c: number): Polygon;
+/** An octagonal plaque's outline, t thick. */
+export function octagonRule(cx: number, cy: number, w: number, h: number, c: number, t: number): Shape;
+/** This face's capital k as a glyph source. */
+export function drawn(k: string): GlyphSource;
+/** A five-point star of radius R, its inner radius R·k. */
+export function star5(cx: number, cy: number, R: number, k?: number): Polygon;
+/** The capital alone, centred. */
+export function plain(src: GlyphSource, H?: number): Build;
+/** A capital a gap above a tapered hairline rule. */
+export function ruled(src: GlyphSource, H: number, over?: number): Build;
+/** A capital cut once across by the gap. */
+export function split(src: GlyphSource, H: number, cut: Placer<Geom>): Build;
+/** A capital with a ball or a star placed by `at`. */
+export function dotted(src: GlyphSource, H: number, at: Placer<number[]>, kind?: 'dot' | 'star'): Build;
+/** A capital on one hairline plinth. */
+export function plinth(src: GlyphSource, H: number, over?: number): Build;
+/** A capital in a frame. */
+export function framed(src: GlyphSource, H: number, frame: (g: number) => Geom, o?: { dx?: number; dy?: number }): Build;
+/** A capital in a double frame. */
+export function crest(src: GlyphSource, H: number, outer: (g: number) => Geom, inner: (g: number) => Geom, o?: { dx?: number; dy?: number }): Build;
+/** A capital knocked out of a plaque with a hairline inner rule. */
+export function plaque(src: GlyphSource, H: number, shape: () => Geom, ruleFn: (g: number) => Geom): Build;
+/** The fat-face inline: a g-wide channel down every thick stroke. */
+export function inline(src: GlyphSource, H?: number): Build;