@logomarks/core 0.1.11 → 0.2.0

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;

package/src/forms/discs.js

@@ -0,0 +1,114 @@
+/**
+ * Bold discs: one solid disc of radius DISC_R, centred, and the cuts that keep its gap exact when a piece moves. A
+ * moving piece is I(region, moved disc): the region's edge (the cut) stays put and only the rim moves, so the gap along
+ * the cut is still g. From the Logomarks tools (discparts.mjs, batch 201, "Bold · Discs", and its editions in batch 220).
+ */
+import { C, D, I, U, circle, poly, rot, sample, stroke } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** The disc's radius. */
+export const DISC_R = 224;
+
+/**
+ * The disc (720 points), moved by (dx, dy).
+ *
+ * @param {number} [dx=0] Moved right.
+ * @param {number} [dy=0] Moved down.
+ * @param {number} [r=DISC_R] Its radius.
+ * @returns {Polygon} The disc.
+ */
+export const disc = (dx = 0, dy = 0, r = DISC_R) => circle(C + dx, C + dy, r, 720);
+
+/**
+ * A curve across the disc: `f(u)` gives [u, v] in a frame turned by `deg` about the centre, u running from −span·R to
+ * span·R.
+ *
+ * @param {(u: number) => readonly number[]} f The curve in its own frame.
+ * @param {number} [deg=0] The frame's turn.
+ * @param {number} [span=1.5] How far either side it runs, in radii.
+ * @param {number} [n=300] Points along it.
+ * @returns {Point[]} The curve on the canvas.
+ */
+export const across = (f, deg = 0, span = 1.5, n = 300) => {
+	const a = (deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return sample(f, -span * DISC_R, span * DISC_R, n).map(([u, v]) => [C + u * c - v * s, C + u * s + v * c]);
+};
+
+/**
+ * The half plane on one side of an open curve that runs right across the disc: the curve closed 3000 out along the
+ * normal of its first-to-last chord.
+ *
+ * @param {readonly Point[]} L The curve.
+ * @param {number} s Which side: 1 or −1.
+ * @returns {Polygon} The half plane.
+ */
+export const discSide = (L, s) => {
+	const a = L[0], b = L.at(-1), d = [b[0] - a[0], b[1] - a[1]], l = Math.hypot(...d), n = [(-d[1] / l) * s * 3000, (d[0] / l) * s * 3000];
+	return poly([...L, [b[0] + n[0], b[1] + n[1]], [a[0] + n[0], a[1] + n[1]]]);
+};
+
+/**
+ * The disc parted along the curve L by the gap g, each half's rim moved by sa / sb (the cut stays put, so the gap stays g).
+ *
+ * @param {readonly Point[]} L The cut.
+ * @param {number} g The gap.
+ * @param {readonly number[]} [sa=[0, 0]] The left half's rim, moved.
+ * @param {readonly number[]} [sb=[0, 0]] The right half's rim, moved.
+ * @returns {Shape} The two halves.
+ */
+export const split = (L, g, sa = [0, 0], sb = [0, 0]) => {
+	const z = stroke(L, g, { chunk: 8 });
+	return U(D(I(disc(...sa), discSide(L, 1)), z), D(I(disc(...sb), discSide(L, -1)), z));
+};
+
+/**
+ * A solid band of width b along L, parted from both halves of the disc by g; the band's ends follow a disc moved by sm, so
+ * it rides out past the rim at one end.
+ *
+ * @param {readonly Point[]} L The band's centreline.
+ * @param {number | ((i: number, n: number) => number)} b Its width, or a width per point.
+ * @param {number} g The gap.
+ * @param {readonly number[]} [sm=[0, 0]] The band's disc, moved.
+ * @param {readonly number[]} [sa=[0, 0]] The left half's rim, moved.
+ * @param {readonly number[]} [sb=[0, 0]] The right half's rim, moved.
+ * @returns {Shape} The halves and the band.
+ */
+export const bandCut = (L, b, g, sm = [0, 0], sa = [0, 0], sb = [0, 0]) => {
+	const wz = typeof b === 'function' ? (i, n) => b(i, n) + 2 * g : b + 2 * g, z = stroke(L, wz, { chunk: 8 });
+	return U(D(I(disc(...sa), discSide(L, 1)), z), D(I(disc(...sb), discSide(L, -1)), z), I(disc(...sm), stroke(L, b, { chunk: 8 })));
+};
+
+/**
+ * A point on the disc's frame: radius r from the centre at angle deg (0 right, 90 down).
+ *
+ * @param {number} r The radius.
+ * @param {number} deg The angle.
+ * @returns {Point} The point.
+ */
+export const discAt = (r, deg) => [C + r * Math.cos((deg * Math.PI) / 180), C + r * Math.sin((deg * Math.PI) / 180)];
+
+/**
+ * A shape turned by deg about the point p.
+ *
+ * @param {Geom} s The shape.
+ * @param {number} deg The turn, degrees.
+ * @param {readonly number[]} p The pivot.
+ * @returns {Geom} The shape, turned.
+ */
+export const turn = (s, deg, p) => rot(s, deg, p[0], p[1]);
+
+/**
+ * The two sides of a circular cut (centre P, radius Ra) through the disc, parted by g; the inner side turned th° about P,
+ * so it glides along the cut.
+ *
+ * @param {readonly number[]} P The cut's centre.
+ * @param {number} Ra The cut's radius.
+ * @param {number} g The gap.
+ * @param {number} th The inner side's turn, degrees.
+ * @returns {Shape} The two sides.
+ */
+export const arcSplit = (P, Ra, g, th) => U(I(turn(disc(), th, P), circle(...P, Ra - g / 2, 900)), D(disc(), circle(...P, Ra + g / 2, 900)));

package/src/forms/emblems.d.ts

@@ -0,0 +1,22 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** The frame's left edge (32). */
+export const EMBLEM_X0: number;
+/** The frame's right edge (480). */
+export const EMBLEM_X1: number;
+/** The frame's bottom edge (480). */
+export const EMBLEM_Y1: number;
+/** The frame's width (448). */
+export const EMBLEM_W: number;
+/** The scene parted by the horizon: everything within g/2 of y = hz cut away. */
+export function horizon(shape: Geom, hz: number, g: number): Shape;
+/** A sine line across the frame at height y. */
+export function sine(y: number, amp: number, cycles: number, ph?: number, x0?: number, x1?: number): Point[];
+/** The sea: a block cut by n wave bands g wide. */
+export function sea(y0: number, y1: number, g: number, o?: { n?: number; amp?: number; cycles?: number; ph?: number; block?: Geom }): Shape;
+/** A ploughed field: a block cut by n bands fanning from a vanishing point. */
+export function field(y0: number, y1: number, g: number, n?: number, vy?: number, spread?: number, block?: Geom): Shape;
+/** A triangle, its base on y from xa to xb, its apex at (ax, ay). */
+export function tri(xa: number, xb: number, y: number, ax: number, ay: number): Polygon;
+/** A cloud: a flat base on y, three bumps. */
+export function cloud(cx: number, y: number, w: number, h: number): Shape;

package/src/forms/emblems.js

@@ -0,0 +1,109 @@
+/**
+ * Split emblems: a 448 frame (x and y from 32 to 480) whose scene is drawn whole and then parted by the horizon gap
+ * (`horizon()`), so the cut is always exactly g; the lower half is a ground block carved by gap-wide bands (`sea()`: sine
+ * bands; `field()`: bands fanning from a vanishing point). Each mark sets its own horizon. From the Logomarks tools
+ * (emblemparts.mjs, batch 216, "Bold · Emblems", and its editions in batch 241).
+ */
+import { U, D, I, poly, rect, circle, sample, mitreBand as band } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** The frame's left edge. */
+export const EMBLEM_X0 = 32;
+
+/** The frame's right edge. */
+export const EMBLEM_X1 = 480;
+
+/** The frame's bottom edge. */
+export const EMBLEM_Y1 = 480;
+
+/** The frame's width. */
+export const EMBLEM_W = EMBLEM_X1 - EMBLEM_X0;
+
+/**
+ * The scene parted by the horizon: everything within g/2 of y = hz cut away.
+ *
+ * @param {Geom} shape The scene.
+ * @param {number} hz The horizon's height.
+ * @param {number} g The gap.
+ * @returns {Shape} The scene, parted.
+ */
+export const horizon = (shape, hz, g) => D(shape, rect(-200, hz - g / 2, 900, g));
+
+/**
+ * A sine line across the frame at height y: amp tall, `cycles` waves over the frame's width, starting at phase ph.
+ *
+ * @param {number} y Its middle height.
+ * @param {number} amp Its amplitude.
+ * @param {number} cycles Waves across the frame.
+ * @param {number} [ph=0] The phase, degrees.
+ * @param {number} [x0=EMBLEM_X0 - 40] Where it starts.
+ * @param {number} [x1=EMBLEM_X1 + 40] Where it ends.
+ * @returns {Point[]} The line (160 steps).
+ */
+export const sine = (y, amp, cycles, ph = 0, x0 = EMBLEM_X0 - 40, x1 = EMBLEM_X1 + 40) =>
+	sample((x) => [x, y + amp * Math.sin(((x - EMBLEM_X0) / EMBLEM_W) * cycles * 2 * Math.PI + (ph * Math.PI) / 180)], x0, x1, 160);
+
+/**
+ * The sea: the block from y0 to y1 with n wave bands g wide cut across it, evenly spaced.
+ *
+ * @param {number} y0 The block's top.
+ * @param {number} y1 Its bottom.
+ * @param {number} g The gap (the bands' width).
+ * @param {{ n?: number, amp?: number, cycles?: number, ph?: number, block?: Geom }} [o] Bands (2), their amplitude (16),
+ *   waves across (2), phase (0) and the block to carve (the frame's width from y0 to y1).
+ * @returns {Shape} The sea.
+ */
+export const sea = (y0, y1, g, { n = 2, amp = 16, cycles = 2, ph = 0, block = rect(EMBLEM_X0, y0, EMBLEM_W, y1 - y0) } = {}) => {
+	const step = (y1 - y0) / (n + 1);
+	return D(block, ...[...Array(n)].map((_, i) => band(sine(y0 + step * (i + 1), amp, cycles, ph), g)));
+};
+
+/**
+ * A ploughed field in perspective: the block cut by n bands g wide fanning down from a vanishing point (256, vy) above
+ * the horizon, their feet spread across the width (spread 1 lays the outer feet on the frame's corners).
+ *
+ * @param {number} y0 The block's top.
+ * @param {number} y1 Its bottom.
+ * @param {number} g The gap (the bands' width).
+ * @param {number} [n=3] The bands.
+ * @param {number} [vy=y0 - 150] The vanishing point's height.
+ * @param {number} [spread=1.15] How far the feet spread.
+ * @param {Geom} [block] The block to carve (the frame's width from y0 to y1).
+ * @returns {Shape} The field.
+ */
+export const field = (y0, y1, g, n = 3, vy = y0 - 150, spread = 1.15, block = rect(EMBLEM_X0, y0, EMBLEM_W, y1 - y0)) =>
+	D(block, ...[...Array(n)].map((_, i) => {
+		const t = (i - (n - 1) / 2) / ((n + 1) / 2), foot = [256 + t * (EMBLEM_W / 2) * spread * 1.6, y1 + 60];
+		return I(band([[256, vy], foot], g), rect(-200, y0, 900, 900));
+	}));
+
+/**
+ * A triangle with its base on y from xa to xb and its apex at (ax, ay).
+ *
+ * @param {number} xa The base's left end.
+ * @param {number} xb The base's right end.
+ * @param {number} y The base's height.
+ * @param {number} ax The apex.
+ * @param {number} ay The apex.
+ * @returns {Polygon} The triangle.
+ */
+export const tri = (xa, xb, y, ax, ay) => poly([[xa, y], [ax, ay], [xb, y]]);
+
+/**
+ * A cloud: a flat base on y and three bumps, w wide and h tall about cx.
+ *
+ * @param {number} cx Its middle.
+ * @param {number} y Its base.
+ * @param {number} w Its width.
+ * @param {number} h Its height.
+ * @returns {Shape} The cloud.
+ */
+export const cloud = (cx, y, w, h) => {
+	const r1 = h * 0.42, r2 = h * 0.62, r3 = h * 0.36;
+	return I(U(circle(cx - w * 0.26, y - r1, r1, 240), circle(cx + w * 0.04, y - h + r2, r2, 240), circle(cx + w * 0.3, y - r3, r3, 240),
+		rect(cx - w * 0.26, y - r1, w * 0.56, r1)), rect(cx - w, y - 2 * h, 2 * w, 2 * h));
+};

package/src/forms/flow.d.ts

@@ -0,0 +1,21 @@
+import type { Point, Shape } from '../geometry/types.js';
+
+/** A flow grid's drawing: n × m discs of radius r, gap g, the path, the bridges' neck, blend, fillet and skipped cells. */
+export interface FlowOptions {
+	n: number;
+	m?: number;
+	r: number;
+	g: number;
+	path: string;
+	neck?: number;
+	k?: number;
+	fillet?: number;
+	skip?: string;
+}
+
+/** A flow path ("a0 b0 b1", a trailing "~" closing it) as cells [column, row]. */
+export function cells(s: string): { path: [number, number][]; closed: boolean };
+/** A flow grid's pitch and each cell's centre, for n × m discs of radius r and gap g centred on (cx, cy). */
+export function grid(n: number, m: number, r: number, g: number, cx?: number, cy?: number): { p: number; at: (cell: readonly number[]) => Point };
+/** A flow grid as shapes: the path, the free discs, both, and the narrowest gap between them. */
+export function flowShape(o: FlowOptions): { path: Shape; free: Shape; shape: Shape; clearance: number };