@logomarks/core 0.1.11 → 0.2.1

package/src/font/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Letters from font files (Node): a font's capital as a kit shape on the serif and blackletter faces' frame, grown so its
+ * hairline holds, the measures to place a move on it, and the moves. Fonts are passed in as paths or bytes; opentype.js,
+ * clipper-lib and @resvg/resvg-js are optional peers, loaded on first use.
+ */
+export type { FontSource, Font } from './glyphs.js';
+export type { LetterMove } from './moves.js';
+export { loadFont, capUnits, nonzeroShape, glyphShape, mitreGrow, weights, hairline, structuralHairline, fontSource, onBase } from './glyphs.js';
+export { inside, runsH, runsV, strokeDepths, armEnd, thinnestStroke } from './measure.js';
+export { underCrossbar, underTopBar, underBowl, cornerDot, fullStop, starBefore, underFork, underBowlR, inlineOpen, inlineStraight, armLozenge, stemSplit, barLozenge, leftLozenge, tongueLozenge, barEnd, barEnds, crossLozenge } from './moves.js';

package/src/font/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module @logomarks/core/font
+ *
+ * Letters from font files (Node): a font's capital as a kit shape on the serif and blackletter faces' frame, grown so its
+ * hairline holds, the measures to place a move on it, and the moves. Fonts are passed in as paths or bytes; opentype.js,
+ * clipper-lib and @resvg/resvg-js are optional peers, loaded on first use.
+ */
+export { loadFont, capUnits, nonzeroShape, glyphShape, mitreGrow, weights, hairline, structuralHairline, fontSource, onBase } from './glyphs.js';
+export { inside, runsH, runsV, strokeDepths, armEnd, thinnestStroke } from './measure.js';
+export { underCrossbar, underTopBar, underBowl, cornerDot, fullStop, starBefore, underFork, underBowlR, inlineOpen, inlineStraight, armLozenge, stemSplit, barLozenge, leftLozenge, tongueLozenge, barEnd, barEnds, crossLozenge } from './moves.js';

package/src/font/measure.d.ts

@@ -0,0 +1,16 @@
+import type { Shape } from '../geometry/types.js';
+
+/** The winding number of a ring about a point. */
+export function wind(ring: readonly (readonly number[])[], p: readonly number[]): number;
+/** Whether (x, y) is in the shape's ink, by winding. */
+export function inside(s: Shape, x: number, y: number): boolean;
+/** The ink runs [a, b] along the horizontal line y. */
+export function runsH(s: Shape, y: number, x0?: number, x1?: number): number[][];
+/** The ink runs [a, b] along the vertical line x. */
+export function runsV(s: Shape, x: number, y0?: number, y1?: number): number[][];
+/** The ink's depth across its strokes from points along the outline, smallest first. */
+export function strokeDepths(s: Shape, step?: number): number[];
+/** Where a stroke ends on the right between y0 and y1, and its depth there. */
+export function armEnd(s: Shape, y0: number, y1: number, o?: { step?: number; back?: number }): { x: number; y: number; th: number; yc: number };
+/** The thinnest structural stroke, by erosion (needs @resvg/resvg-js). */
+export function thinnestStroke(s: Shape, k?: number): number;

package/src/font/measure.js

@@ -0,0 +1,201 @@
+/**
+ * Measures for placing a move on a letter (a font's or any shape): the ink's runs along a line, the depth across its
+ * strokes, where an arm ends, and the thinnest stroke holding it together. From the Logomarks tools (fontparts.mjs,
+ * batches 242 and 243).
+ */
+import { createRequire } from 'node:module';
+import { bbox, toPath } from '../geometry/index.js';
+
+/**
+ * The winding number of a ring about a point.
+ *
+ * @param {readonly (readonly number[])[]} ring The ring.
+ * @param {readonly number[]} p The point.
+ * @returns {number} The winding number.
+ */
+export const wind = (ring, [px, py]) => {
+	let w = 0;
+	for (let i = 0, n = ring.length; i < n; i++) {
+		const [x1, y1] = ring[i], [x2, y2] = ring[(i + 1) % n], c = (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1);
+		if (y1 <= py ? y2 > py && c > 0 : y2 <= py && c < 0) w += y1 <= py ? 1 : -1;
+	}
+	return w;
+};
+
+/**
+ * Whether (x, y) is in the shape's ink: inside an outer ring and outside its holes, by winding.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} x The point.
+ * @param {number} y The point.
+ * @returns {boolean} True when it is.
+ */
+export const inside = (s, x, y) => s.some((pg) => wind(pg[0], [x, y]) !== 0 && !pg.slice(1).some((h) => wind(h, [x, y]) !== 0));
+
+/**
+ * The runs [a, b] where `on(t)` holds, for t from a0 to a1 in steps of 0.25.
+ *
+ * @param {(t: number) => boolean} on The test.
+ * @param {number} a0 Where to start.
+ * @param {number} a1 Where to stop.
+ * @returns {number[][]} The runs.
+ */
+const runs = (on, a0, a1) => {
+	const r = []; let a = null;
+	for (let t = a0; t <= a1; t += 0.25) { const v = on(t); if (v && a === null) a = t; if (!v && a !== null) { r.push([a, t]); a = null; } }
+	if (a !== null) r.push([a, a1]);
+	return r;
+};
+
+/**
+ * The ink runs [a, b] along the horizontal line y (x from x0 to x1, in steps of 0.25).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} y The line.
+ * @param {number} [x0=-50] Where to start.
+ * @param {number} [x1=1000] Where to stop.
+ * @returns {number[][]} The runs, left to right.
+ */
+export const runsH = (s, y, x0 = -50, x1 = 1000) => runs((x) => inside(s, x, y), x0, x1);
+
+/**
+ * The ink runs [a, b] along the vertical line x (y from y0 to y1, in steps of 0.25).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} x The line.
+ * @param {number} [y0=-50] Where to start.
+ * @param {number} [y1=1000] Where to stop.
+ * @returns {number[][]} The runs, top to bottom.
+ */
+export const runsV = (s, x, y0 = -50, y1 = 1000) => runs((y) => inside(s, x, y), y0, y1);
+
+/**
+ * The ink's depth across its strokes, sorted: from points every `step` along the outline, the distance along the inward
+ * normal to the far side (the ray against every edge). Its low end is the thinnest stroke (tips and tapered swash ends
+ * included, as a reader at 32 px sees them).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} [step=3] The spacing along the outline.
+ * @returns {number[]} The depths, smallest first.
+ */
+export const strokeDepths = (s, step = 3) => {
+	const E = s.flatMap((pg) => pg.flatMap((r) => r.map((p, i) => [p, r[(i + 1) % r.length]]))), out = [];
+	for (const [p, q] of E) {
+		const L = Math.hypot(q[0] - p[0], q[1] - p[1]); if (L < 0.5) continue; const u = [(q[0] - p[0]) / L, (q[1] - p[1]) / L];
+		for (let t = step / 2; t < L; t += step) {
+			const x = p[0] + u[0] * t, y = p[1] + u[1] * t; let n = [u[1], -u[0]];
+			if (!inside(s, x + n[0] * 0.5, y + n[1] * 0.5)) n = [-n[0], -n[1]];
+			let best = Infinity;
+			for (const [a, b] of E) {
+				const ex = b[0] - a[0], ey = b[1] - a[1], den = n[0] * ey - n[1] * ex; if (Math.abs(den) < 1e-12) continue;
+				const wx = a[0] - x, wy = a[1] - y, d = (wx * ey - wy * ex) / den, v = (wx * n[1] - wy * n[0]) / den;
+				if (d > 0.3 && v >= 0 && v <= 1 && d < best) best = d;
+			}
+			if (best < Infinity) out.push(best);
+		}
+	}
+	return out.sort((a, b) => a - b);
+};
+
+/**
+ * Where a stroke ends on the right inside the band of heights y0…y1 (a middle arm's tip): the rightmost ink point found
+ * on rows `step` apart, and the stroke's depth a little back from it (the run down through x − back).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} y0 The band's top.
+ * @param {number} y1 Its bottom.
+ * @param {{ step?: number, back?: number }} [o] The rows' spacing (2) and how far back the depth is read (24).
+ * @returns {{ x: number, y: number, th: number, yc: number }} The tip, the stroke's depth there and its middle.
+ */
+export const armEnd = (s, y0, y1, { step = 2, back = 24 } = {}) => {
+	let best = { x: -Infinity, y: y0 };
+	for (let y = y0; y <= y1; y += step) { const r = runsH(s, y); if (r.length && r.at(-1)[1] > best.x) best = { x: r.at(-1)[1], y }; }
+	const run = runsV(s, best.x - back).find(([a, b]) => a <= best.y + 2 && b >= best.y - 2) || [best.y - 30, best.y + 30];
+	return { ...best, th: run[1] - run[0], yc: (run[0] + run[1]) / 2 };
+};
+
+/* ---------- the structural stroke ---------- */
+// strokeDepths() counts tips and spurs: right for a swash face, but a spiked face has so many sharp tips that its low end
+// reads far thinner than its thinnest real stroke. thinnestStroke() measures by erosion instead: the glyph is rasterised k
+// px a unit, eroded by r (a pixel survives while it is r or more from paper), and r raised until the topology changes (a
+// piece splits off, or a counter opens into another). The stroke that breaks first is the thinnest stroke holding the
+// letter together; tips, serif ends and spurs shrink without changing the topology, so they don't count. The raster is
+// @resvg/resvg-js's (an optional peer, loaded on first use): core's own scanline fill differs from it on edge pixels.
+
+/**
+ * The shape as a 0/1 mask, k px a unit, with a 6 px margin of paper.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} k Pixels a unit.
+ * @returns {{ M: Uint8Array, W: number, H: number }} The mask and its size.
+ */
+const mask = (s, k) => {
+	const { Resvg } = createRequire(import.meta.url)('@resvg/resvg-js'), [x0, y0, x1, y1] = bbox(s), m = 6;
+	const W = Math.ceil((x1 - x0) * k) + 2 * m, H = Math.ceil((y1 - y0) * k) + 2 * m;
+	const px = new Resvg(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}"><path shape-rendering="crispEdges" fill-rule="evenodd" fill="#000" transform="translate(${m} ${m}) scale(${k}) translate(${-x0} ${-y0})" d="${toPath(s)}"/></svg>`).render().pixels;
+	const M = new Uint8Array(W * H); for (let i = 0; i < W * H; i++) M[i] = px[i * 4 + 3] > 127 ? 1 : 0;
+	return { M, W, H };
+};
+
+/**
+ * The squared distance from each ink pixel to the nearest paper pixel (Felzenszwalb and Huttenlocher's two-pass
+ * transform).
+ *
+ * @param {{ M: Uint8Array, W: number, H: number }} mk The mask.
+ * @returns {Float64Array} The squared distances, row by row.
+ */
+const edt = ({ M, W, H }) => {
+	const INF = 1e12, Dt = new Float64Array(W * H), n = Math.max(W, H), f = new Float64Array(n), d = new Float64Array(n), v = new Int32Array(n), z = new Float64Array(n + 1);
+	const pass = (len) => {
+		let k = 0; v[0] = 0; z[0] = -INF; z[1] = INF;
+		for (let q = 1; q < len; q++) {
+			let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+			while (s <= z[k]) { k--; s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]); }
+			k++; v[k] = q; z[k] = s; z[k + 1] = INF;
+		}
+		k = 0; for (let q = 0; q < len; q++) { while (z[k + 1] < q) k++; d[q] = (q - v[k]) * (q - v[k]) + f[v[k]]; }
+	};
+	for (let x = 0; x < W; x++) { for (let y = 0; y < H; y++) f[y] = M[y * W + x] ? INF : 0; pass(H); for (let y = 0; y < H; y++) Dt[y * W + x] = d[y]; }
+	for (let y = 0; y < H; y++) { for (let x = 0; x < W; x++) f[x] = Dt[y * W + x]; pass(W); for (let x = 0; x < W; x++) Dt[y * W + x] = d[x]; }
+	return Dt;
+};
+
+/**
+ * How many connected pieces there are where on(i) holds (8-connected for ink, 4 for paper), ignoring any under minPx.
+ *
+ * @param {number} W The width.
+ * @param {number} H The height.
+ * @param {(i: number) => boolean} on Whether pixel i counts.
+ * @param {boolean} eight 8-connected (else 4).
+ * @param {number} [minPx=4] The smallest piece that counts.
+ * @returns {number} The count.
+ */
+const pieces = (W, H, on, eight, minPx = 4) => {
+	const seen = new Uint8Array(W * H), st = new Int32Array(W * H); let n = 0;
+	const nb = eight ? [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]] : [[1, 0], [-1, 0], [0, 1], [0, -1]];
+	for (let i = 0; i < W * H; i++) {
+		if (seen[i] || !on(i)) continue; let sp = 0, size = 0; st[sp++] = i; seen[i] = 1;
+		while (sp) {
+			const j = st[--sp], x = j % W, y = (j - x) / W; size++;
+			for (const [dx, dy] of nb) { const X = x + dx, Y = y + dy; if (X < 0 || Y < 0 || X >= W || Y >= H) continue; const q = Y * W + X; if (!seen[q] && on(q)) { seen[q] = 1; st[sp++] = q; } }
+		}
+		if (size >= minPx) n++;
+	}
+	return n;
+};
+
+/**
+ * The thinnest structural stroke of a shape, in its units (±1/k): the erosion radius at which a piece splits off or a
+ * counter opens. Needs @resvg/resvg-js (an optional peer).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} [k=2] Pixels a unit.
+ * @returns {number} The stroke's width (Infinity when nothing breaks before r 80).
+ */
+export const thinnestStroke = (s, k = 2) => {
+	const mk = mask(s, k), Dt = edt(mk), { W, H } = mk;
+	const topo = (r) => { const r2 = r * r; return [pieces(W, H, (i) => Dt[i] >= r2, true), pieces(W, H, (i) => Dt[i] < r2, false)]; };
+	let [ink, paper] = topo(1);
+	for (let r = 1.5; r < 80; r += 0.5) { const [a, b] = topo(r); if (a > ink || b < paper) return (2 * (r - 0.75)) / k; ink = Math.min(ink, a); paper = b; }
+	return Infinity;
+};

package/src/font/moves.d.ts

@@ -0,0 +1,42 @@
+import type { Polygon, Shape } from '../geometry/types.js';
+import type { Face, Placer, SourceGlyph, GlyphSource } from '../letters/serif.js';
+
+/** A move on a blackletter letter: the letter and the gap to the new letter. */
+export type LetterMove = (s: Shape, g: number) => Shape;
+
+/** Split (A): the gap just under the crossbar. */
+export function underCrossbar(m: Face, w: number, g: number, L: SourceGlyph): Polygon;
+/** Split (T): the gap right under the top bar. */
+export function underTopBar(at?: number): Placer<Polygon>;
+/** Split (P): the gap across the stem under the bowl. */
+export function underBowl(below?: number): Placer<Polygon>;
+/** Dot (L): a ball in the L's corner, clear of the foot. */
+export function cornerDot(o?: { along?: number; from?: number; clear?: number; r?: number }): Placer<number[]>;
+/** Stop (H): a full stop a gap after the letter. */
+export function fullStop(k?: number): Placer<number[]>;
+/** Star (J): a five-point star before the stem. */
+export function starBefore(o?: { k?: number; y?: number }): Placer<number[]>;
+/** Split (Y): the gap just under the fork. */
+export function underFork(m: Face, w: number, g: number, L: SourceGlyph): Polygon;
+/** Split (R): the gap across the stem only, under the bowl's foot. */
+export function underBowlR(m: Face, w: number, g: number, L: SourceGlyph): Polygon;
+/** The serif inline, its channel opened where a stroke tapers. */
+export function inlineOpen(src: GlyphSource, H?: number, open?: number): (g: number) => Shape;
+/** The inline with a straight channel, for straight-stroked letters. */
+export function inlineStraight(src: GlyphSource, H?: number, open?: number): (g: number) => Shape;
+/** A parted lozenge on a font's middle arm. */
+export function armLozenge(cap: number, y0: number, y1: number, k?: number): LetterMove;
+/** A split stem down from the head or up from the foot. */
+export function stemSplit(cap: number, end: 'head' | 'foot', depth: number): LetterMove;
+/** A lozenge set across the H's bar. */
+export function barLozenge(cap: number, o?: { k?: number; at?: number }): LetterMove;
+/** armLozenge mirrored, for a stroke ending on the left. */
+export function leftLozenge(cap: number, y0: number, y1: number, k?: number): LetterMove;
+/** A short middle tongue taken off whole, a lozenge a gap clear of the stem. */
+export function tongueLozenge(cap: number, y0: number, y1: number, z?: number): LetterMove;
+/** A bar's right end run into a level parted lozenge. */
+export function barEnd(cap: number, o?: { back?: number; k?: number }): LetterMove;
+/** barEnd at both ends of the bar. */
+export function barEnds(cap: number, o?: { back?: number; k?: number }): LetterMove;
+/** A parted lozenge at the crossing or the fork. */
+export function crossLozenge(cap: number, y0: number, y1: number, k?: number): LetterMove;

package/src/font/moves.js

@@ -0,0 +1,263 @@
+/**
+ * Moves placed on a font's letter: each measures the font's own letter (its bar, stem, bowl or arm), never a house
+ * face's fractions, so every font edition places its source mark's move the same way. The serif ones are the `cut` and
+ * `at` arguments of /letters' split() and dotted(): `(m, w, g, L)`, with L the glyph source's { s, w, m }; the blackletter
+ * ones are `(s, g) => shape` on a letter at cap `cap`. From the Logomarks tools (fontparts.mjs: batch 242's placements,
+ * 243's blackletter ones, 292's and 298's inlines and cuts, 312's tongue and 334's bar ends).
+ */
+import { U, D, I, move, bbox, rect, circle, flipX, grow, poly } from '../geometry/index.js';
+import { parted, lozenge, splitHead, splitFoot } from '../letters/blackletter.js';
+import { runsH, runsV, armEnd } from './measure.js';
+
+/* ---------- serif moves: split, dot and star ---------- */
+
+/**
+ * Split (A): the gap across the letter just UNDER its crossbar (a gap through a 29 hairline leaves slivers), the bar
+ * found down the counter's middle at 0.8 of the cap.
+ *
+ * @param {import('../letters/serif.js').Face} m The glyph's face.
+ * @param {number} w Its width.
+ * @param {number} g The gap.
+ * @param {import('../letters/serif.js').SourceGlyph} L The glyph.
+ * @returns {import('../geometry/types.js').Polygon} The strip to cut.
+ */
+export const underCrossbar = (m, w, g, L) => {
+	const [l, r] = runsH(L.s, m.H * 0.8), x = (l[1] + r[0]) / 2;
+	const bar = runsV(L.s, x).find(([a]) => a > m.H * 0.3); return rect(-10, bar[1], w + 20, g);
+};
+
+/**
+ * Split (T): the gap right under the top bar, measured `at` of the width in.
+ *
+ * @param {number} [at=0.3] Where across the bar is measured.
+ * @returns {import('../letters/serif.js').Placer<import('../geometry/types.js').Polygon>} The cut.
+ */
+export const underTopBar = (at = 0.3) => (m, w, g, L) => rect(-10, runsV(L.s, w * at)[0][1], w + 20, g);
+
+/**
+ * Split (P): the gap across the stem `below` under the bowl (the bowl's foot found halfway out from the stem).
+ *
+ * @param {number} [below=6] How far under the bowl's foot.
+ * @returns {import('../letters/serif.js').Placer<import('../geometry/types.js').Polygon>} The cut.
+ */
+export const underBowl = (below = 6) => (m, w, g, L) => {
+	const x = runsH(L.s, m.H * 0.8)[0][1], y = runsV(L.s, (x + w) / 2).at(-1)[1];
+	return rect(-10, y + below, w + 20, g);
+};
+
+/**
+ * Dot (L): a ball of half the stem in the L's corner, `along` the way from the stem to the arm's end, risen from `from`
+ * of the cap until it sits `clear` gaps off the foot (a font's foot curves up into a beak).
+ *
+ * @param {{ along?: number, from?: number, clear?: number, r?: number }} [o] Where across (0.42), where it starts (0.62
+ *   of the cap), its clearance in gaps (1.5) and its radius as a fraction of the stem (0.5).
+ * @returns {import('../letters/serif.js').Placer<number[]>} The placement: [cx, cy, r].
+ */
+export const cornerDot = ({ along = 0.42, from = 0.62, clear = 1.5, r: rk = 0.5 } = {}) => (m, w, g, L) => {
+	const x = runsH(L.s, m.H * 0.5)[0][1], cx = x + (w - x) * along, r = m.S * rk; let cy = m.H * from;
+	while (I(circle(cx, cy, r + g * clear, 64), L.s).length && cy > m.H * 0.4) cy -= 2;
+	return [cx, cy, r];
+};
+
+/**
+ * Stop (H): a full stop (radius `k` of the stem) a gap after the letter, sitting on the baseline.
+ *
+ * @param {number} [k=0.52] The radius, as a fraction of the stem.
+ * @returns {import('../letters/serif.js').Placer<number[]>} The placement: [cx, cy, r].
+ */
+export const fullStop = (k = 0.52) => (m, w, g) => [w + g + m.S * k, m.H - m.S * k, m.S * k];
+
+/**
+ * Star (J): a five-point star (radius `k` of the cap) a radius before the stem at 0.3 of the cap, its centre at `y` of
+ * the cap.
+ *
+ * @param {{ k?: number, y?: number }} [o] The radius (0.13) and the height (0.42), as fractions of the cap.
+ * @returns {import('../letters/serif.js').Placer<number[]>} The placement: [cx, cy, r].
+ */
+export const starBefore = ({ k = 0.13, y = 0.42 } = {}) => (m, w, g, L) => {
+	const r = m.H * k, x = runsH(L.s, m.H * 0.3)[0][0];
+	return [x - m.H * k - r * 0.95, m.H * y, r];
+};
+
+/**
+ * Split (Y): the gap across the letter just under the fork, where the two arms have run into one stem.
+ *
+ * @param {import('../letters/serif.js').Face} m The glyph's face.
+ * @param {number} w Its width.
+ * @param {number} g The gap.
+ * @param {import('../letters/serif.js').SourceGlyph} L The glyph.
+ * @returns {import('../geometry/types.js').Polygon} The strip to cut.
+ */
+export const underFork = (m, w, g, L) => { let y = m.H * 0.25; while (runsH(L.s, y).length > 1 && y < m.H * 0.8) y += 1; return rect(-10, y, w + 20, g); };
+
+/**
+ * Split (R): the gap across the stem just under the bowl's foot, cutting only the stem (the leg runs on whole), so the
+ * bowl and the leg float as one piece beside the stem's foot.
+ *
+ * @param {import('../letters/serif.js').Face} m The glyph's face.
+ * @param {number} w Its width.
+ * @param {number} g The gap.
+ * @param {import('../letters/serif.js').SourceGlyph} L The glyph.
+ * @returns {import('../geometry/types.js').Polygon} The strip to cut.
+ */
+export const underBowlR = (m, w, g, L) => {
+	const x = runsH(L.s, m.H * 0.25)[0][1] + 4, y = runsV(L.s, x + 30).find(([a]) => a > m.H * 0.3)[1];
+	return rect(-10, y + 4, runsH(L.s, y + 4 + g / 2)[0][1] + 10, g);
+};
+
+/* ---------- inlines ---------- */
+
+/**
+ * The serif inline with its channel opened: the shrunk letter less any part under `open` wide, so where a stroke tapers
+ * (K's and R's legs, a bowl's side) the channel stops rather than running on as a slit under 10. Centred.
+ *
+ * @param {import('../letters/serif.js').GlyphSource} src The glyph source.
+ * @param {number} [H=380] The cap height.
+ * @param {number} [open=6] The narrowest channel kept.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build.
+ */
+export const inlineOpen = (src, H = 380, open = 6) => (g) => {
+	const { s, w, m } = src(H, { g }), inner = grow(grow(s, -(m.S - g) / 2), -open);
+	return move(D(s, grow(inner, open)), 256 - w / 2, 256 - H / 2);
+};
+
+/**
+ * The inline with a STRAIGHT channel, for letters of straight strokes (E, F, M, T): each piece of the shrunk letter
+ * clipped to the strip through its own runs at 0.3 and 0.7 of its height, so the channel keeps its width past a junction
+ * instead of bulging into the arm. The strip follows a slanted stroke as well as an upright. Centred.
+ *
+ * @param {import('../letters/serif.js').GlyphSource} src The glyph source.
+ * @param {number} [H=380] The cap height.
+ * @param {number} [open=6] The narrowest channel kept.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build.
+ */
+export const inlineStraight = (src, H = 380, open = 6) => (g) => {
+	const { s, w, m } = src(H, { g }), inner = grow(grow(grow(s, -(m.S - g) / 2), -open), open);
+	const ch = U(...inner.map((pg) => {
+		const [, t, , b] = bbox([pg]), at = (f) => runsH([pg], t + (b - t) * f)[0], y1 = t + (b - t) * 0.3, y2 = t + (b - t) * 0.7;
+		const [a1, b1] = at(0.3), [a2, b2] = at(0.7), X = (x1, x2, y) => x1 + ((x2 - x1) * (y - y1)) / (y2 - y1);
+		return I([pg], poly([[X(a1, a2, -500), -500], [X(b1, b2, -500), -500], [X(b1, b2, 1500), 1500], [X(a1, a2, 1500), 1500]]));
+	}));
+	return move(D(s, ch), 256 - w / 2, 256 - H / 2);
+};
+
+/* ---------- blackletter moves ---------- */
+
+/**
+ * The blackletter's parted lozenge on a font's middle arm (E, F): its tip found between y0 and y1 of the cap, a lozenge
+ * `k` times the arm's depth (110 at least) parted off by the gap.
+ *
+ * @param {number} cap The cap height.
+ * @param {number} y0 The band's top, as a fraction of the cap.
+ * @param {number} y1 Its bottom.
+ * @param {number} [k=1.7] The lozenge's size, in arm depths.
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const armLozenge = (cap, y0, y1, k = 1.7) => (s, g) => {
+	const a = armEnd(s, cap * y0, cap * y1), z = Math.max(110, a.th * k);
+	return parted(s, lozenge(a.x + z * 0.13, a.yc, z), g);
+};
+
+/**
+ * The blackletter's split stem on a font's letter: a slit g wide down the left stem from above the cap to `depth` of the
+ * cap ('head', B D P) or up from below the base to it ('foot', R). The slit is centred on the median of the stem's
+ * middles along the slit's length, spike tips (runs under half the median width) left out: a flag head juts left at the
+ * top and the bowl joins on the right, so one middle measured there puts the slit on the joint and leaves a sliver.
+ *
+ * @param {number} cap The cap height.
+ * @param {'head' | 'foot'} end Which end the slit runs from.
+ * @param {number} depth How far, as a fraction of the cap.
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const stemSplit = (cap, end, depth) => (s, g) => {
+	const [y0, y1] = end === 'head' ? [0, cap * depth] : [cap * depth, cap];
+	const rs = [...Array(19)].map((_, i) => runsH(s, y0 + ((y1 - y0) * (i + 1)) / 20)[0]).filter(Boolean), med = (a) => a.sort((p, q) => p - q)[a.length >> 1];
+	const wm = med(rs.map(([a, b]) => b - a)), x = med(rs.filter(([a, b]) => b - a >= wm / 2).map(([a, b]) => (a + b) / 2));
+	return D(s, (end === 'head' ? splitHead : splitFoot)(x, cap * depth, g));
+};
+
+/**
+ * The blackletter's H: a lozenge set across the bar, `k` times the counter's width from corner to corner, on the bar's
+ * middle (the counter and bar measured across and down the letter's middle).
+ *
+ * @param {number} cap The cap height.
+ * @param {{ k?: number, at?: number }} [o] The lozenge's size in counter widths (1.7), and its height when no bar is
+ *   found (0.5 of the cap).
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const barLozenge = (cap, { k = 1.7, at = 0.5 } = {}) => (s, g) => {
+	const [x0, , x1] = bbox(s), xm = (x0 + x1) / 2;
+	const across = runsH(s, cap * 0.25), cw = across[1][0] - across[0][1], bar = runsV(s, xm).find(([a, b]) => (a + b) / 2 > cap * 0.25 && (a + b) / 2 < cap * 0.75);
+	return U(s, lozenge(xm, bar ? (bar[0] + bar[1]) / 2 : cap * at, cw * k));
+};
+
+/**
+ * armLozenge mirrored: a stroke ending on the LEFT (a J's foot) runs into a parted lozenge, its tip found between y0
+ * and y1.
+ *
+ * @param {number} cap The cap height.
+ * @param {number} y0 The band's top, as a fraction of the cap.
+ * @param {number} y1 Its bottom.
+ * @param {number} [k] The lozenge's size, in arm depths (1.7).
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const leftLozenge = (cap, y0, y1, k) => (s, g) => flipX(armLozenge(cap, y0, y1, k)(flipX(s), g));
+
+/**
+ * The middle arm as a lozenge a gap off the stem (E, F), for a face whose middle arm is a short tongue (armLozenge would
+ * leave a stub on the stem): the tongue goes whole (the ink right of the stem between y0 and y1 of the cap, the stem's
+ * right edge read at 0.3 and 0.7 of the cap) and a lozenge `z` across stands a gap clear of the stem, centred on the
+ * tongue.
+ *
+ * @param {number} cap The cap height.
+ * @param {number} y0 The band's top, as a fraction of the cap.
+ * @param {number} y1 Its bottom.
+ * @param {number} [z=120] The lozenge, corner to corner.
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const tongueLozenge = (cap, y0, y1, z = 120) => (s, g) => {
+	const sr = Math.max(runsH(s, cap * 0.3)[0][1], runsH(s, cap * 0.7)[0][1]);
+	let a = Infinity, b = -Infinity; for (let y = cap * y0; y <= cap * y1; y += 1) { const r = runsH(s, y)[0]; if (r[1] > sr + 2) { a = Math.min(a, y); b = Math.max(b, y); } }
+	const body = D(s, rect(sr, a - 1, 400, b - a + 2)), yc = (a + b) / 2;
+	return U(body, lozenge(sr + g + z / 2, yc, z));
+};
+
+/**
+ * A bar's right end run into a lozenge parted off by the gap and set LEVEL on the bar (the geometric T's lozenge
+ * terminals), for a face whose bar curls up at its tips (armLozenge would perch it above the curl): the bar's depth and
+ * middle are read `back` in from the tip (found in the top 0.2 of the cap), the lozenge is `k` times that depth (110 at
+ * least) and centred on the tip itself, so the moat takes the curl off whole.
+ *
+ * @param {number} cap The cap height.
+ * @param {{ back?: number, k?: number }} [o] How far in the bar is read (60) and the lozenge's size in bar depths (1.5).
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const barEnd = (cap, { back = 60, k = 1.5 } = {}) => (s, g) => {
+	const a = armEnd(s, 0, cap * 0.2), r = runsV(s, a.x - back).find(([y0]) => y0 < cap * 0.3);
+	const z = Math.max(110, (r[1] - r[0]) * k); return parted(s, lozenge(a.x, (r[0] + r[1]) / 2, z), g);
+};
+
+/**
+ * barEnd at both ends of the bar: the left end is the right end of the letter mirrored.
+ *
+ * @param {number} cap The cap height.
+ * @param {{ back?: number, k?: number }} [o] As barEnd().
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const barEnds = (cap, o) => (s, g) => { const f = barEnd(cap, o); return flipX(f(flipX(f(s, g)), g)); };
+
+/**
+ * The blackletter's parted lozenge `k` times the stroke at the crossing (X) or the fork (Y): placed on the first row
+ * between y0 and y1 of the cap where the ink is one run, narrowest.
+ *
+ * @param {number} cap The cap height.
+ * @param {number} y0 The band's top, as a fraction of the cap.
+ * @param {number} y1 Its bottom.
+ * @param {number} [k=1.6] The lozenge's size, in stroke widths.
+ * @returns {(s: import('../geometry/types.js').Shape, g: number) => import('../geometry/types.js').Shape} The move.
+ */
+export const crossLozenge = (cap, y0, y1, k = 1.6) => (s, g) => {
+	let best = null;
+	for (let y = cap * y0; y <= cap * y1; y += 1) { const r = runsH(s, y); if (r.length === 1 && (!best || r[0][1] - r[0][0] < best.w)) best = { y, x: (r[0][0] + r[0][1]) / 2, w: r[0][1] - r[0][0] }; }
+	return parted(s, lozenge(best.x, best.y, best.w * k), g);
+};

package/src/forms/discs.d.ts

@@ -0,0 +1,20 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** The disc's radius (224). */
+export const DISC_R: number;
+/** The disc, moved by (dx, dy). */
+export function disc(dx?: number, dy?: number, r?: number): Polygon;
+/** A curve across the disc: f(u) → [u, v] in a frame turned by deg. */
+export function across(f: (u: number) => readonly number[], deg?: number, span?: number, n?: number): Point[];
+/** The half plane on one side (s = ±1) of a curve that runs right across the disc. */
+export function discSide(L: readonly Point[], s: number): Polygon;
+/** The disc parted along L by g, each half's rim moved by sa / sb. */
+export function split(L: readonly Point[], g: number, sa?: readonly number[], sb?: readonly number[]): Shape;
+/** A band b wide along L, parted from both halves by g, riding on a disc moved by sm. */
+export function bandCut(L: readonly Point[], b: number | ((i: number, n: number) => number), g: number, sm?: readonly number[], sa?: readonly number[], sb?: readonly number[]): Shape;
+/** A point at radius r and angle deg from the disc's centre. */
+export function discAt(r: number, deg: number): Point;
+/** A shape turned by deg about p. */
+export function turn(s: Geom, deg: number, p: readonly number[]): Geom;
+/** The two sides of a circular cut through the disc, parted by g, the inner one turned th° about P. */
+export function arcSplit(P: readonly number[], Ra: number, g: number, th: number): Shape;