@logomarks/core 0.1.9 → 0.2.0

package/src/font/glyphs.js

@@ -0,0 +1,228 @@
+/**
+ * A capital from a font file as a kit shape, drawn on the frame the serif and blackletter faces draw on (cap line at y 0,
+ * baseline at y H, y down, ink starting at x 0), so the house moves (/letters' rule, split, dot, plinth, frame, inline;
+ * the blackletter's parted lozenge and split stem) apply to a font's letter unchanged. From the Logomarks tools
+ * (fontparts.mjs, batches 242 and 243). Node only.
+ *
+ * Every function takes a font as a file path or as its bytes (a Buffer, Uint8Array or ArrayBuffer): core holds no fonts
+ * and no font folder. A font is parsed on first use and cached (by path, or by the bytes' object). It reads fonts with
+ * opentype.js and grows them with clipper-lib, both optional peers loaded on first use.
+ *
+ * Two traps the Logomarks font A/B found:
+ * - opentype.js getPath() writes NaN for Bodoni Moda's static instances and drops DM Serif Display's closepaths (which
+ *   merges its rings), so paths are built here from glyph.path.commands;
+ * - font contours overlap (Bodoni, DM Serif, Unifraktur), so glyphs are filled non-zero (`nonzeroShape()`).
+ */
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { U, D, I, move, bbox, rect } from '../geometry/index.js';
+import { pathRings } from '../svg/index.js';
+import { shoelace as sArea } from '../util/vec.js';
+import { wind, runsH, runsV, strokeDepths, thinnestStroke } from './measure.js';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * A cache for values of a font (and a sub-key): a Map for paths, keyed `path` or `path|sub` as strings, and a WeakMap of
+ * Maps for fonts passed as bytes.
+ *
+ * @template T
+ * @returns {(font: import('./glyphs.js').FontSource, sub: string | undefined, make: () => T) => T} The cached lookup.
+ */
+const fontCache = () => {
+	const paths = new Map(), bytes = new WeakMap();
+	return (font, sub, make) => {
+		if (typeof font === 'string') { const k = sub === undefined ? font : `${font}|${sub}`; if (!paths.has(k)) paths.set(k, make()); return paths.get(k); }
+		let m = bytes.get(font); if (!m) bytes.set(font, (m = new Map()));
+		const k = sub ?? ''; if (!m.has(k)) m.set(k, make()); return m.get(k);
+	};
+};
+
+const fonts = fontCache();
+
+/**
+ * A font, parsed (cached): from its file's path, or from its bytes.
+ *
+ * @param {import('./glyphs.js').FontSource} source The font file's path, or its contents.
+ * @returns {import('./glyphs.js').Font} The parsed font (opentype.js's Font).
+ */
+export const loadFont = (source) => fonts(source, undefined, () => {
+	const opentype = require('opentype.js');
+	if (source instanceof ArrayBuffer) return opentype.parse(source);
+	const b = typeof source === 'string' ? fs.readFileSync(source) : source;
+	return opentype.parse(b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength));
+});
+
+/**
+ * A font's cap height in font units: the top of its H (OS/2 sCapHeight is far off in Unifraktur).
+ *
+ * @param {import('./glyphs.js').Font} font The parsed font.
+ * @returns {number} The cap height.
+ */
+export const capUnits = (font) => Math.max(...font.charToGlyph('H').path.commands.filter((c) => c.y !== undefined).map((c) => c.y));
+
+/**
+ * A glyph's outline as SVG path data, scaled by k, its baseline at y H and y down; one subpath per contour.
+ *
+ * @param {{ path: { commands: Record<string, any>[] } }} glyph The glyph.
+ * @param {number} k The scale.
+ * @param {number} H The baseline.
+ * @returns {string} The path data.
+ */
+const glyphD = (glyph, k, H) => {
+	const X = (v) => (v * k).toFixed(3), Y = (v) => (H - v * k).toFixed(3); let d = '';
+	for (const c of glyph.path.commands) {
+		if (c.type === 'M') d += (d ? 'Z' : '') + `M${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'L') d += `L${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'Q') d += `Q${X(c.x1)} ${Y(c.y1)} ${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'C') d += `C${X(c.x1)} ${Y(c.y1)} ${X(c.x2)} ${Y(c.y2)} ${X(c.x)} ${Y(c.y)}`;
+	}
+	return d + 'Z';
+};
+
+/**
+ * Rings wound non-zero (outers one way, counters the other) as a shape: each counter cut from the smallest outer
+ * holding it, then the outers united.
+ *
+ * @param {readonly (readonly number[])[][]} rings The rings.
+ * @returns {import('../geometry/types.js').Shape} The shape.
+ */
+const ringsShape = (rings) => {
+	const rs = rings.filter((r) => Math.abs(sArea(r)) > 0.5); if (!rs.length) return [];
+	const big = rs.reduce((a, r) => (Math.abs(sArea(r)) > Math.abs(sArea(a)) ? r : a)), sign = Math.sign(sArea(big));
+	const outers = rs.filter((r) => Math.sign(sArea(r)) === sign), holes = rs.filter((r) => Math.sign(sArea(r)) !== sign), own = outers.map(() => []);
+	for (const h of holes) {
+		let best = -1;
+		outers.forEach((o, i) => { if (wind(o, h[0]) !== 0 && (best < 0 || Math.abs(sArea(o)) < Math.abs(sArea(outers[best])))) best = i; });
+		if (best >= 0) own[best].push(h);
+	}
+	return U(...outers.map((o, i) => D([o], ...own[i].map((h) => [h]))));
+};
+
+/**
+ * Path data filled non-zero, as a shape, for contours that may overlap: each counter (a ring wound against the outers)
+ * is cut from the smallest outer that holds it, then the outers are united.
+ *
+ * @param {string} d The path data.
+ * @param {number} [step=1] The curves' sampling step.
+ * @returns {import('../geometry/types.js').Shape} The shape.
+ */
+export const nonzeroShape = (d, step = 1) => ringsShape(pathRings(d, step));
+
+/**
+ * A font's character as a shape, scaled so the font's cap height (its H) is `cap`: the cap line at y 0, the baseline at
+ * y cap, the ink starting at x 0. Overshoots and descenders fall outside 0…cap as the font draws them.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font (a path or its bytes).
+ * @param {string} char The character.
+ * @param {{ cap?: number, step?: number }} [o] The cap height (380) and the curves' sampling step (1).
+ * @returns {{ s: import('../geometry/types.js').Shape, w: number }} The letter and its ink's width.
+ */
+export const glyphShape = (font, char, { cap = 380, step = 1 } = {}) => {
+	const f = loadFont(font), k = cap / capUnits(f);
+	const s = nonzeroShape(glyphD(f.charToGlyph(char), k, cap), step), [x0, , x1] = bbox(s);
+	return { s: move(s, -x0, 0), w: x1 - x0 };
+};
+
+/**
+ * A mitred grow: the shape grown by d with its corners kept sharp (mitred up to `limit` times d, squared off past it),
+ * where the kit's grow() rounds every corner by d. Thickening a font's hairlines with a round grow softens every serif
+ * corner; this keeps the font's cut. Clipper's offset (clipper-lib, an optional peer), in thousandths: an exact polygon
+ * offset (/geometry's offsetPolygon) can't stand in for it, since Clipper's integer grid sets every point.
+ *
+ * @param {import('../geometry/types.js').Shape} shape The shape.
+ * @param {number} d How far (0: the shape as it is).
+ * @param {number} [limit=2] The mitre limit, in multiples of d.
+ * @returns {import('../geometry/types.js').Shape} The grown shape.
+ */
+export const mitreGrow = (shape, d, limit = 2) => {
+	if (!d) return shape;
+	const CL = require('clipper-lib');
+	const P = (r) => r.map(([x, y]) => ({ X: Math.round(x * 1000), Y: Math.round(y * 1000) })), c = new CL.Clipper(), u = new CL.Paths();
+	c.AddPaths(shape.flatMap((pg) => pg.map(P)), CL.PolyType.ptSubject, true);
+	c.Execute(CL.ClipType.ctUnion, u, CL.PolyFillType.pftEvenOdd, CL.PolyFillType.pftEvenOdd); // a clean shape: outers come back positive, holes negative
+	const co = new CL.ClipperOffset(limit, 250), out = new CL.Paths(); co.AddPaths(u, CL.JoinType.jtMiter, CL.EndType.etClosedPolygon); co.Execute(out, d * 1000);
+	return ringsShape(out.map((r) => r.map(({ X, Y }) => [X / 1000, Y / 1000])));
+};
+
+/**
+ * A font's weights, read off its H at cap 1000: the stem S (the left stem across at mid-height) and the hairline h (the
+ * bar, down through the middle), as fractions of the cap.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @returns {{ S: number, h: number }} The stem and the hairline.
+ */
+export const weights = (font) => {
+	const H = glyphShape(font, 'H', { cap: 1000 }), st = runsH(H.s, 300)[0];
+	const bar = runsV(H.s, H.w / 2).find(([a, b]) => b - a < 300); return { S: (st[1] - st[0]) / 1000, h: bar ? (bar[1] - bar[0]) / 1000 : (st[1] - st[0]) / 1000 };
+};
+
+const wcache = fontCache();
+
+/**
+ * weights(), cached.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @returns {{ S: number, h: number }} The stem and the hairline.
+ */
+const fontWeights = (font) => wcache(font, undefined, () => weights(font));
+
+const hcache = fontCache();
+
+/**
+ * A font's hairline as a fraction of its cap: the `q` quantile of the stroke depths of `chars` (a font whose H has no
+ * hairline bar, such as a Fraktur, is measured this way; the serif faces use their H's bar, `weights()`). Cached.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} [chars='ABCDEGHMNRST'] The letters measured.
+ * @param {number} [q=0.1] The quantile.
+ * @returns {number} The hairline, as a fraction of the cap.
+ */
+export const hairline = (font, chars = 'ABCDEGHMNRST', q = 0.1) => hcache(font, `${chars}|${q}`, () => {
+	const d = [...chars].flatMap((c) => strokeDepths(glyphShape(font, c, { cap: 1000, step: 4 }).s, 6)).sort((a, b) => a - b);
+	return d[Math.floor(d.length * q)] / 1000;
+});
+
+const scache = fontCache();
+
+/**
+ * A font's structural hairline as a fraction of its cap: the thinnest structural stroke (thinnestStroke()) over `chars`
+ * at a 448 cap, so tips and spikes don't count (Abril Fatface 0.026, New Rocker 0.085, Germania One 0.131): pass it to
+ * fontSource() as `h`. Cached; needs @resvg/resvg-js.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} [chars='ABEFGHMNORS'] The letters measured.
+ * @returns {number} The hairline, as a fraction of the cap.
+ */
+export const structuralHairline = (font, chars = 'ABEFGHMNORS') => scache(font, chars, () => Math.min(...[...chars].map((c) => thinnestStroke(glyphShape(font, c, { cap: 448 }).s))) / 448);
+
+/**
+ * A glyph source for /letters' moves (and any build that takes a letter): `(H, { g }) => { s, w, m }`, the font's `char`
+ * at cap H on the glyph frame, with m = { H, S, h, t, dy }: its stem and hairline (after the grow), the grow t and the
+ * lift dy. Given the gap g the mark is drawn with (exact() picks g so it lands on 22 once fitted, so the fit's scale is
+ * 22 ÷ g), the glyph is grown uniformly (mitred, so its corners stay sharp) just enough that its hairline is `hair` once
+ * fitted. The hairline is the font's H bar (`weights()`), or `h` (a fraction of the cap; hairline() and
+ * structuralHairline() measure one for a face without a bar). The grow, in fitted units, is reported through `onGrow`.
+ * Without g nothing is grown. Grown, the ink is moved back so it still starts at x 0 and its baseline stays at y H (its
+ * cap line rises 2t), so base serifs, rules and plinths line up; m.dy re-centres it in a frame.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} char The character.
+ * @param {{ hair?: number, h?: number, onGrow?: (t: number) => void }} [o] The fitted hairline wanted (29), the font's
+ *   hairline as a fraction of the cap (its H bar's by default), and a callback for the grow.
+ * @returns {import('../letters/serif.js').GlyphSource} The glyph source.
+ */
+export const fontSource = (font, char, { hair = 29, h, onGrow } = {}) => (H, o = {}) => {
+	const wt = fontWeights(font), h0 = (h ?? wt.h) * H;
+	const k = o.g ? 22 / o.g : 1, t = o.g ? Math.max(0, (hair / k - h0) / 2) : 0; if (onGrow) onGrow(+(t * k).toFixed(2));
+	const L = glyphShape(font, char, { cap: H }), s = t ? move(mitreGrow(L.s, t), t, -t) : L.s;
+	return { s, w: L.w + 2 * t, m: { H, S: wt.S * H + 2 * t, h: h0 + 2 * t, t, dy: t } };
+};
+
+/**
+ * A glyph source with its ink below the baseline trimmed off (a vertex dipping through a plinth).
+ *
+ * @param {import('../letters/serif.js').GlyphSource} src The glyph source.
+ * @returns {import('../letters/serif.js').GlyphSource} The trimmed source.
+ */
+export const onBase = (src) => (H, o) => { const L = src(H, o); return { ...L, s: I(L.s, rect(-50, -200, L.w + 100, H + 200)) }; };

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;