@logomarks/core 0.1.9 → 0.2.0

package/src/objects/weapons.js

@@ -0,0 +1,179 @@
+/**
+ * Weapons and blades: the parts a knife, a sword, an axe, an archery or a shooting mark is drawn from. Every part is drawn
+ * about the origin (y down), pointing right (+x) unless it says otherwise, and returns its pieces separately so a mark can
+ * part them with the house gap (`chain()`, `over()`). From the Logomarks tools (weaponparts.mjs, batch 173).
+ */
+import { U, poly, circle, rect, rr, sample, over, move, mapPts, annulus, joinPts as run } from '../geometry/index.js';
+import { turn } from '../parts/index.js';
+
+/**
+ * Turns a shape drawn about the origin by `deg` (clockwise on screen), then moves it by (dx, dy).
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @param {number} deg The turn, in degrees.
+ * @param {number} [dx=0] The move, x.
+ * @param {number} [dy=0] The move, y.
+ * @returns {import('../geometry/types.js').Shape} The placed shape.
+ */
+export const place = (s, deg, dx = 0, dy = 0) => move(turn(s, deg), dx, dy);
+
+/**
+ * Mirrors a shape left to right about x = 0.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @returns {import('../geometry/types.js').Shape} The mirrored shape.
+ */
+export const flip = (s) => mapPts(s, ([x, y]) => [-x, y]);
+
+/**
+ * A quadratic Bézier from p0 through the control point c to p1, as n + 1 points.
+ *
+ * @param {readonly number[]} p0 The start.
+ * @param {readonly number[]} c The control point.
+ * @param {readonly number[]} p1 The end.
+ * @param {number} [n=24] The steps.
+ * @returns {import('../geometry/types.js').Point[]} The curve.
+ */
+export const bez = (p0, c, p1, n = 24) => sample((t) => [0, 1].map((d) => (1 - t) ** 2 * p0[d] + 2 * (1 - t) * t * c[d] + t * t * p1[d]), 0, 1, n);
+
+/**
+ * A blade from the heel (x = 0) to the tip (x = L), spine on top, H deep at the heel, as a polygon's points: 'chef' (the
+ * spine dropping and the edge's belly rising to a tip a quarter down), 'santoku' (a flat edge, the spine rounding down to
+ * it), 'drop' (spine and edge meeting on the centre line), 'cleaver' (a tall square blade).
+ *
+ * @param {'chef' | 'santoku' | 'drop' | 'cleaver'} kind The blade.
+ * @param {number} L Its length.
+ * @param {number} H Its depth at the heel.
+ * @returns {import('../geometry/types.js').Point[]} The outline.
+ * @throws {Error} For a kind it doesn't know.
+ */
+export const bladePts = (kind, L, H) => {
+	const t = -H / 2, b = H / 2;
+	if (kind === 'chef') return run([[0, b], [0, t], [L * 0.55, t]], bez([L * 0.55, t], [L * 0.86, t], [L, t + H * 0.28]), bez([L, t + H * 0.28], [L * 0.8, b], [L * 0.42, b]));
+	if (kind === 'santoku') return run([[0, b], [0, t], [L * 0.6, t]], bez([L * 0.6, t], [L, t], [L, b]));
+	if (kind === 'drop') return run([[0, b], [0, t], [L * 0.6, t]], bez([L * 0.6, t], [L * 0.9, t + H * 0.1], [L, H * 0.06]), bez([L, H * 0.06], [L * 0.82, b], [L * 0.5, b]));
+	if (kind === 'cleaver') return [[0, b], [0, t], [L, t], [L, b - 18], [L - 18, b]];
+	throw new Error('blade ' + kind);
+};
+
+/**
+ * A knife's grip: a handle from x = x1 back to x = x1 − L, h deep, its top on y = top, the butt rounded.
+ *
+ * @param {number} x1 Its front end.
+ * @param {number} L Its length.
+ * @param {number} top Its top.
+ * @param {number} h Its depth.
+ * @param {number} [r=h/2] The butt's radius.
+ * @returns {import('../geometry/types.js').Polygon} The grip.
+ */
+export const grip = (x1, L, top, h, r = h / 2) => rr(x1 - L, top, L, h, [r, 8, 8, r]);
+
+/**
+ * A knife pointing right: the `kind` blade (L long, H deep) and its handle (HL long, HH deep, sitting `hy` below the
+ * spine), parted by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ kind?: 'chef' | 'santoku' | 'drop' | 'cleaver', L?: number, H?: number, HL?: number, HH?: number, hy?: number }} [o] The blade and handle.
+ * @returns {{ blade: import('../geometry/types.js').Polygon, handle: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const knife = (g, { kind = 'chef', L = 280, H = 100, HL = 170, HH = 56, hy = 6 } = {}) => ({
+	blade: poly(bladePts(kind, L, H)), handle: grip(-g, HL, -H / 2 + hy, HH) });
+
+/**
+ * A straight sword pointing up: a blade W wide (L long, its last `tip` a point), a crossguard bar, a grip and a round
+ * pommel, each parted from the next by the gap, the guard's top on y = 0.
+ *
+ * @param {number} g The gap.
+ * @param {{ L?: number, W?: number, tip?: number, guard?: number[], hilt?: number[], pommel?: number, taper?: number }} [o] The sizes: guard and hilt are [width, height].
+ * @returns {{ blade: import('../geometry/types.js').Polygon, guard: import('../geometry/types.js').Polygon, hilt: import('../geometry/types.js').Polygon, pommel: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const sword = (g, { L = 300, W = 56, tip = 70, guard = [176, 30], hilt = [36, 92], pommel = 26, taper = 0.78 } = {}) => {
+	const w2 = W / 2, w1 = (W * taper) / 2, blade = poly([[-w2, -g], [-w1, -g - L + tip], [0, -g - L], [w1, -g - L + tip], [w2, -g]]);
+	const gd = rr(-guard[0] / 2, 0, guard[0], guard[1], guard[1] / 2), y1 = guard[1] + g;
+	const h = rect(-hilt[0] / 2, y1, hilt[0], hilt[1]), p = circle(0, y1 + hilt[1] + g + pommel, pommel, 120);
+	return { blade, guard: gd, hilt: h, pommel: p };
+};
+
+/**
+ * Two copies of a shape drawn pointing up, crossed in an X at ±deg about the origin, the right-leaning one in front, cut
+ * free by the gap.
+ *
+ * @param {import('../geometry/types.js').Geom} s The shape.
+ * @param {number} deg The lean, in degrees.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The pair.
+ */
+export const crossed = (s, deg, g) => over(turn(flip(s), -deg), turn(s, deg), g);
+
+/**
+ * A katana pointing right along a gentle curve (the tip rising): the grip (tsuka), the guard (tsuba, a plate seen edge on)
+ * and either the drawn blade with its angled point or the scabbard (saya), each parted by the gap. `bend` is how far the
+ * ends rise over the middle.
+ *
+ * @param {number} g The gap.
+ * @param {{ sheathed?: boolean, L?: number, W?: number, tsukaL?: number, tsuba?: number[], bend?: number }} [o] The sword.
+ * @returns {{ tsuka: import('../geometry/types.js').Shape, tsuba: import('../geometry/types.js').Shape, blade: import('../geometry/types.js').Shape }} The pieces.
+ */
+export const katana = (g, { sheathed = false, L = 448, W = 46, tsukaL = 128, tsuba = [30, 104], bend = 40 } = {}) => {
+	const x0 = -L / 2, xt = x0 + tsukaL, xb = xt + g + tsuba[0] + g, w2 = W / 2;
+	const tsuka = rr(x0, -w2 + 2, tsukaL, W - 4, [20, 4, 4, 20]), guard = rr(xt + g, -tsuba[1] / 2, tsuba[0], tsuba[1], 12);
+	const len = L / 2 - xb, sw = sheathed ? W + 6 : W;
+	const blade = sheathed ? rr(xb, -sw / 2, len, sw, [4, sw / 2, sw / 2, 4])
+		: poly([[xb, -w2], [L / 2, -w2], ...bez([L / 2, -w2], [L / 2 - 14, w2 - 6], [L / 2 - 64, w2]).slice(1), [xb, w2]]);
+	const curve = (s) => mapPts(s, ([x, y]) => [x, y - bend * ((2 * x) / L) ** 2]);
+	return { tsuka: curve(tsuka), tsuba: curve(guard), blade: curve(blade) };
+};
+
+/**
+ * A felling axe pointing up: a haft W wide from y = bottom up into the head, and the head (poll on the left, the bit
+ * flaring to a convex edge on the right), the haft parted from the head by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ W?: number, poll?: number, bit?: number, top?: number, bottom?: number, edge?: number }} [o] The sizes.
+ * @returns {{ head: import('../geometry/types.js').Polygon, haft: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const axe = (g, { W = 46, poll = 64, bit = 196, top = -224, bottom = 224, edge = 1 } = {}) => {
+	const hy = top + 44, head = poly(run([[-poll, hy - 40], [W / 2 + 26, hy - 34]], bez([W / 2 + 26, hy - 34], [bit * 0.62, hy - 30], [bit, top]),
+		bez([bit, top], [bit + 36 * edge, hy + 70], [bit - 8, hy + 168]), bez([bit - 8, hy + 168], [bit * 0.6, hy + 84], [W / 2 + 26, hy + 56]), [[-poll, hy + 50]]));
+	const haft = rr(-W / 2, hy - 20, W, bottom - hy + 20, [0, 0, W / 2, W / 2]);
+	return { head, haft };
+};
+
+/**
+ * The axe as one mark: the head in front of the haft, cut free by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {{ W?: number, poll?: number, bit?: number, top?: number, bottom?: number, edge?: number }} [o] axe()'s sizes.
+ * @returns {import('../geometry/types.js').Shape} The axe.
+ */
+export const axeCut = (g, o) => { const { head, haft } = axe(g, o); return over(haft, head, g); };
+
+/**
+ * An arrow pointing right from x = x0 to x = x1: a shaft w wide, a head `hl` long and `hw` wide parted from the shaft by
+ * the gap, and the fletching, two swept vanes on the tail.
+ *
+ * @param {number} g The gap.
+ * @param {number} x0 The tail.
+ * @param {number} x1 The tip.
+ * @param {{ w?: number, hl?: number, hw?: number, vl?: number, vw?: number }} [o] The shaft's width, the head's length and width, the vanes' length and reach.
+ * @returns {{ shaft: import('../geometry/types.js').Polygon, head: import('../geometry/types.js').Polygon, vanes: import('../geometry/types.js').Shape }} The pieces.
+ */
+export const arrow = (g, x0, x1, { w = 22, hl = 74, hw = 70, vl = 92, vw = 34 } = {}) => {
+	const head = poly([[x1, 0], [x1 - hl, -hw / 2], [x1 - hl * 0.8, 0], [x1 - hl, hw / 2]]);
+	const shaft = rect(x0, -w / 2, x1 - hl * 0.8 - g - x0, w);
+	const vane = (s) => poly([[x0 + vl, s * w / 2 - 1], [x0 + vl - 34, s * (w / 2 + vw)], [x0, s * (w / 2 + vw)], [x0 + 34, s * w / 2 - 1]]);
+	return { shaft, head, vanes: U(vane(-1), vane(1)) };
+};
+
+/**
+ * Target rings about the origin: a bull of radius r0, then n rings `w` wide, each a gap out from the last.
+ *
+ * @param {number} g The gap.
+ * @param {{ r0?: number, w?: number, n?: number }} [o] The bull's radius, the rings' width and how many.
+ * @returns {import('../geometry/types.js').Shape} The target.
+ */
+export const rings = (g, { r0 = 60, w = 50, n = 2 } = {}) => {
+	const out = [circle(0, 0, r0, 240)]; let r = r0;
+	for (let i = 0; i < n; i++) { r += g; out.push(annulus(0, 0, r + w / 2, w)); r += w; }
+	return U(...out);
+};

package/src/parts/index.d.ts

@@ -13,4 +13,6 @@ export * from './iso.js';
 export * from './letters.js';
 export * from './objects.js';
 export * from './faces.js';
+export * from './span.js';
+export * from './pixels.js';
 export * from './run.js';

package/src/parts/index.js

@@ -12,4 +12,6 @@ export * from './iso.js';
 export * from './letters.js';
 export * from './objects.js';
 export * from './faces.js';
+export * from './span.js';
+export * from './pixels.js';
 export * from './run.js';

package/src/parts/pixels.d.ts

@@ -0,0 +1,11 @@
+import type { Geom } from '../geometry/types.js';
+
+/** A span of pixels: [from, to, n], or [null, null, n] for n empty pixels. */
+export type PixelSpan = readonly [number | null, number | null, number];
+
+/** Whether a point is inside a kit shape (even-odd). */
+export function insideShape(shape: Geom, x: number, y: number): boolean;
+/** A mark as rows of text ('#' a pixel) over spans of pixels on each axis. */
+export function rasterRows(shape: Geom, xs: readonly PixelSpan[], ys: readonly PixelSpan[], options?: { min?: number; k?: number }): string[];
+/** A whole mark as rows of text on square pixels, n along its longest side, phase (fx, fy), cells to toggle. */
+export function rasterMark(shape: Geom, n: number, fx?: number, fy?: number, options?: { min?: number; fix?: readonly (readonly number[])[] }): string[];

package/src/parts/pixels.js

@@ -0,0 +1,74 @@
+/**
+ * Pixel editions: a drawn mark sampled into rows of text ('#' a pixel), the format PIX7 and the pixel animals use. From
+ * the Logomarks tools' dither parts (batches 210 and 234).
+ */
+
+/**
+ * A kit shape as a polygon set (the kit's primitives return one polygon, its booleans a set).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @returns {import('../geometry/types.js').Shape} A polygon set.
+ */
+const polys = (shape) => /** @type {import('../geometry/types.js').Shape} */ (typeof shape[0][0][0] === 'number' ? [shape] : shape);
+
+/**
+ * Whether a point is inside a kit shape, even-odd over every ring.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} x The point.
+ * @param {number} y The point.
+ * @returns {boolean} True when it is.
+ */
+export const insideShape = (shape, x, y) => {
+	let k = false;
+	for (const pg of polys(shape)) for (const r of pg) for (let a = 0, b = r.length - 1; a < r.length; b = a++) {
+		const [xa, ya] = r[a], [xb, yb] = r[b];
+		if ((ya > y) !== (yb > y) && x < xa + ((y - ya) * (xb - xa)) / (yb - ya)) k = !k;
+	}
+	return k;
+};
+
+/**
+ * A mark on the 512 canvas as rows of text. Each axis is a list of spans `[from, to, n]`: n pixels across from..to, or
+ * `[null, null, n]` for n empty pixels. A tiled mark gives each tile its own span and each gap one empty pixel, so the
+ * gaps stay whole pixels (Cove Rise on a 2 × 2 grid: `[[32, 245, 7], [null, null, 1], [267, 480, 7]]`).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The mark.
+ * @param {readonly (readonly (number | null)[])[]} xs The spans across.
+ * @param {readonly (readonly (number | null)[])[]} ys The spans down.
+ * @param {{ min?: number, k?: number }} [options] A cell is set when the mark covers `min` (0.5) of a k × k (6) sample.
+ * @returns {string[]} The rows, '#' a pixel and '.' none.
+ */
+export const rasterRows = (shape, xs, ys, { min = 0.5, k = 6 } = {}) => {
+	const sh = polys(shape);
+	const cells = (/** @type {readonly (readonly (number | null)[])[]} */ spans) => spans.flatMap(([a, b, n]) => [...Array(/** @type {number} */ (n))].map((_, i) =>
+		(a == null ? null : [a + ((/** @type {number} */ (b) - a) * i) / /** @type {number} */ (n), a + ((/** @type {number} */ (b) - a) * (i + 1)) / /** @type {number} */ (n)])));
+	const X = cells(xs), Y = cells(ys);
+	return Y.map((y) => X.map((x) => {
+		if (!x || !y) return '.';
+		let n = 0;
+		for (let a = 0; a < k; a++) for (let b = 0; b < k; b++) n += +insideShape(sh, x[0] + ((x[1] - x[0]) * (a + 0.5)) / k, y[0] + ((y[1] - y[0]) * (b + 0.5)) / k);
+		return n / (k * k) >= min ? '#' : '.';
+	}).join(''));
+};
+
+/**
+ * A whole mark as rows of text on square pixels, for the pixel edition of a non-tiled mark: n pixels along its longest
+ * side, the grid starting (fx, fy) pixels before its top-left (sweep this phase so the gaps land on whole empty pixels),
+ * then each `fix` cell [i, j] toggled by hand (to fill a corner-only contact or clear a stray).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The mark.
+ * @param {number} n Pixels along its longest side.
+ * @param {number} [fx] The grid's phase across, in pixels (0).
+ * @param {number} [fy] Its phase down (0).
+ * @param {{ min?: number, fix?: readonly (readonly number[])[] }} [options] The coverage a pixel needs (0.5), and cells to toggle.
+ * @returns {string[]} The rows.
+ */
+export const rasterMark = (shape, n, fx = 0, fy = 0, { min = 0.5, fix = [] } = {}) => {
+	const pts = polys(shape).flat(2), xs = pts.map((p) => p[0]), ys = pts.map((p) => p[1]);
+	const x0 = Math.min(...xs), x1 = Math.max(...xs), y0 = Math.min(...ys), y1 = Math.max(...ys), p = Math.max(x1 - x0, y1 - y0) / n;
+	const nx = Math.ceil((x1 - x0) / p + fx), ny = Math.ceil((y1 - y0) / p + fy), ox = x0 - fx * p, oy = y0 - fy * p;
+	const rows = rasterRows(shape, [[ox, ox + nx * p, nx]], [[oy, oy + ny * p, ny]], { min }).map((r) => [...r]);
+	for (const [i, j] of fix) rows[j][i] = rows[j][i] === '#' ? '.' : '#';
+	return rows.map((r) => r.join(''));
+};

package/src/parts/run.js

@@ -7,12 +7,14 @@ import { seeded, toPath } from '../geometry/index.js';
 import { exact } from './frame.js';
 
 /** Writes a batch: every mark in `M` ({ name: { trade, style, fn(g) } }) drawn with exact() so its gap is 22 once fitted,
- * seeded per mark (a re-run is byte-identical); `node genbatchN.mjs <workdir> ["Name,Name" | "fam:Industry · Law"]`. */
+ * seeded per mark (a re-run is byte-identical); `node genbatchN.mjs <workdir> ["Name,Name" | "fam:Industry · Law"]`.
+ * `fam:` also takes the trade as written, for batches that pass a whole family as the trade ("fam:Letters · Latch").
+ * New batches use `runBatch` from `@logomarks/core/batch`. */
 export const runIndustry = (batch, M) => {
   const [S, only = ''] = process.argv.slice(2), OUT = path.join(S, `newraw${batch}`), slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-');
   fs.mkdirSync(OUT, { recursive: true }); let n = 0;
   for (const [name, { trade, fn }] of Object.entries(M)) {
-    if (only.startsWith('fam:') ? 'Industry · ' + trade !== only.slice(4) : only && !only.split(',').includes(name)) continue;
+    if (only.startsWith('fam:') ? !['Industry · ' + trade, trade].includes(only.slice(4)) : only && !only.split(',').includes(name)) continue;
     try { const s = exact(fn, () => { Math.random = seeded(name); });
       fs.writeFileSync(path.join(OUT, slug(name) + '.svg'), `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="currentColor"><path fill-rule="evenodd" d="${toPath(s)}"/></svg>\n`); n++; }
     catch (e) { console.log('FAIL', name, e.message.slice(0, 160)); } }

package/src/parts/span.d.ts

@@ -0,0 +1,13 @@
+import type { Geom, Shape } from '../geometry/types.js';
+import type { Cell } from './tiles.js';
+
+/** One tile token over a w × h block of cells, the gaps inside it filled (oblong blocks: S, t<k>, d<k>, h<k>, q<k>). */
+export function spanTile(tok: string, cs: readonly Cell[], n: number, i: number, j: number, w: number, h: number): Geom;
+/** A grid of tiles from rows of tokens, a token spanning cells as tok^2, tok>2, tok_2 or tok@2x3. */
+export function spanGrid(rows: readonly string[], s: number): Shape;
+/** A shape's longest side. */
+export function longSide(sh: Geom): number;
+/** The cell size that draws the rows 422 at their longest with the gap 22. */
+export function evenCell(rows: readonly string[]): number;
+/** The span grid at evenCell(rows). */
+export function evenGrid(rows: readonly string[]): Shape;

package/src/parts/span.js

@@ -0,0 +1,100 @@
+/**
+ * Span tiles: a grid of tile() tokens on the 422 span with the house gap, where one token may span a block of cells (the
+ * gaps inside it filled), so a big tile sits among unit tiles. From the Logomarks tools (batch 269, shared since 280).
+ */
+import { rr, rect, poly, bbox, ellipse, I, U } from '../geometry/index.js';
+import { gridCells, tile } from './tiles.js';
+
+/**
+ * One tile token over a w × h block of cells, the gaps inside the block filled. A square block takes every tile() token;
+ * an oblong one takes `S` (a slab), `t<k>` (a right triangle keeping corner k: tl, tr, br, bl), `d<k>` (a slab with side
+ * k fully round: t, r, b, l; `dp` a pill), `h<k>` (a half ellipse filling the block, flat on side k) and `q<k>` (a
+ * quarter ellipse centred on corner k).
+ *
+ * @param {string} tok The token.
+ * @param {readonly import('./tiles.js').Cell[]} cs The grid's cells (gridCells), row by row.
+ * @param {number} n Cells across.
+ * @param {number} i The block's first column.
+ * @param {number} j Its first row.
+ * @param {number} w Its width, in cells.
+ * @param {number} h Its height, in cells.
+ * @returns {import('../geometry/types.js').Geom} The tile.
+ * @throws {Error} For a token an oblong block doesn't take.
+ */
+export const spanTile = (tok, cs, n, i, j, w, h) => {
+	const a = cs[j * n + i], b = cs[(j + h - 1) * n + (i + w - 1)], x = a.x, y = a.y, W = b.x + b.s - a.x, H = b.y + b.s - a.y;
+	if (Math.abs(W - H) < 1e-6) return tile(tok, { i, j, x, y, s: W });
+	if (tok === 'S') return rect(x, y, W, H);
+	if (tok[0] === 't') {
+		/** @type {Record<string, number[]>} */ const K = { tl: [x, y], tr: [x + W, y], br: [x + W, y + H], bl: [x, y + H] };
+		const O = ['tl', 'tr', 'br', 'bl'], q = O.indexOf(tok.slice(1));
+		return poly([K[O[(q + 3) % 4]], K[O[q]], K[O[(q + 1) % 4]]]);
+	}
+	if (tok[0] === 'd') {
+		const r = Math.min(W, H) / 2, k = tok[1];
+		return rr(x, y, W, H, /** @type {Record<string, number[]>} */ ({ t: [r, r, 0, 0], r: [0, r, r, 0], b: [0, 0, r, r], l: [r, 0, 0, r], p: [r, r, r, r] })[k]);
+	}
+	if (tok[0] === 'h') {
+		const k = tok[1], box = rect(x, y, W, H), v = k === 't' || k === 'b';
+		const [cx, cy] = /** @type {Record<string, number[]>} */ ({ t: [x + W / 2, y], b: [x + W / 2, y + H], l: [x, y + H / 2], r: [x + W, y + H / 2] })[k];
+		return I(ellipse(cx, cy, v ? W / 2 : W, v ? H : H / 2, 0, 400), box);
+	}
+	if (tok[0] === 'q') {
+		const k = tok.slice(1), cx = k[1] === 'r' ? x + W : x, cy = k[0] === 'b' ? y + H : y;
+		return I(ellipse(cx, cy, W, H, 0, 400), rect(x, y, W, H));
+	}
+	throw new Error('span tile ' + tok);
+};
+
+/**
+ * A grid of tiles from rows of tokens, where a token may span cells: `tok^2` a 2 × 2 block (`tok^3` 3 × 3), `tok>2` two
+ * cells across, `tok_2` two cells down, `tok@2x3` any block (2 across, 3 down). The cells a block covers are written `-`,
+ * an empty cell `.`.
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @param {number} s The cell's size.
+ * @returns {import('../geometry/types.js').Shape} The grid.
+ */
+export const spanGrid = (rows, s) => {
+	const g = rows.map((r) => r.trim().split(/\s+/)), n = Math.max(...g.map((r) => r.length)), m = g.length, cs = gridCells(n, m, { s }), out = [];
+	g.forEach((row, j) => row.forEach((t, i) => {
+		if (t === '.' || t === '-') return;
+		const bx = t.match(/^(.+?)@(\d)x(\d)$/);
+		if (bx) { out.push(spanTile(bx[1], cs, n, i, j, +bx[2], +bx[3])); return; }
+		const mm = t.match(/^(.+?)(?:\^(\d)|>(\d)|_(\d))$/);
+		if (!mm) { out.push(tile(t, cs[j * n + i])); return; }
+		const [, tok, sq, wd, ht] = mm, w = +(sq || wd || 1), h = +(sq || ht || 1);
+		out.push(spanTile(tok, cs, n, i, j, w, h));
+	}));
+	return U(...out);
+};
+
+/**
+ * A shape's longest side.
+ *
+ * @param {import('../geometry/types.js').Geom} sh The shape.
+ * @returns {number} Its longer box side.
+ */
+export const longSide = (sh) => { const [x0, y0, x1, y1] = bbox(sh); return Math.max(x1 - x0, y1 - y0); };
+
+/**
+ * The cell size that draws `rows` so the mark (not the grid) is 422 at its longest with the gap 22, so a mark whose
+ * tiles stop short of the grid's edge fits to 448 with the family's gap. The longest side is linear in the cell, so
+ * two trial builds find it.
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @returns {number} The cell size.
+ */
+export const evenCell = (rows) => {
+	const n = Math.max(...rows.map((r) => r.trim().split(/\s+/).length), rows.length), s0 = (422 - (n - 1) * 22) / n;
+	const a = longSide(spanGrid(rows, s0)), b = longSide(spanGrid(rows, s0 * 1.2));
+	return s0 + ((422 - a) * 0.2 * s0) / (b - a);
+};
+
+/**
+ * The span grid at evenCell(rows).
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @returns {import('../geometry/types.js').Shape} The grid.
+ */
+export const evenGrid = (rows) => spanGrid(rows, evenCell(rows));

package/src/pixels/dither.d.ts

@@ -0,0 +1,78 @@
+import type { Box, Geom, Shape } from '../geometry/types.js';
+
+/** Cells: [i, j], or tapered [i, j, f] / [i, j, f, deg] (f the size as a share of the pitch). */
+export type Cells = readonly (readonly number[])[];
+/** A ramp: a cell centre (grid units) to t (≤ 0 solid, 1 gone). */
+export type Ramp = (x: number, y: number) => number;
+/** A threshold mask: (i, j) to a value in (0, 1). */
+export type Mask = (i: number, j: number) => number;
+/** taper()'s settings. */
+export interface TaperOptions {
+	ramp: Ramp;
+	n?: number;
+	size?: boolean;
+	density?: number;
+	mask?: string | Mask;
+	gamma?: number;
+	min?: number;
+	turn?: number;
+}
+
+/** The smallest dither cell once fitted (16). */
+export const MIN_CELL: number;
+/** The smallest gap between dither cells once fitted (22). */
+export const MIN_GAP: number;
+/** The fitted span (448). */
+export const SPAN: number;
+/** The n × n Bayer matrix as thresholds in (0, 1). */
+export function bayer(n: number): number[][];
+/** Threshold masks: bayer4, bayer8 (ordered dither) and r2 (low-discrepancy). */
+export const MASKS: Record<'bayer4' | 'bayer8' | 'r2', Mask>;
+/** The cells a shape (in grid units) covers by at least `min` of a k × k sample. */
+export function raster(shape: Geom, o?: { min?: number; k?: number }): [number, number][];
+/** Cells from rows of text ('#' or 'X' a cell), top-left at (i0, j0). */
+export function fromRows(rows: readonly string[], i0?: number, j0?: number): [number, number][];
+/** A w × h block of cells, top-left at (i, j). */
+export function block(i: number, j: number, w: number, h: number): [number, number][];
+/** The cells of a not in b. */
+export function minus(a: Cells, b: Cells): number[][];
+/** A square frame n cells across, walls w thick, top-left at (i, j). */
+export function squareFrame(i: number, j: number, n: number, w: number): number[][];
+/** A comet: the head's cells and a trail behind them, with the ramp that fades it. */
+export function comet(head: Cells, deg: number, len: number, o?: { narrow?: number; lanes?: boolean; edge?: number | null }): { cells: number[][]; ramp: Ramp };
+/** The cells within `depth` steps of a shape's cells, the shape included. */
+export function dilate(cells: Cells, depth?: number): number[][];
+/** A shape's cells less every cell within `depth` steps of its outside. */
+export function erode(cells: Cells, depth?: number): number[][];
+/** A linear ramp: 0 at distance a along deg from (cx, cy), 1 at distance b. */
+export function linear(deg: number, a: number, b: number, cx?: number, cy?: number): Ramp;
+/** A ramp solid (−1) on the `solid` cells and `ramp` elsewhere. */
+export function solidOn(solid: Cells, ramp: Ramp): Ramp;
+/** A ramp by Chebyshev steps from a core: 0 on it, 1 at `depth` steps out. */
+export function steps(core: Cells, depth: number): Ramp;
+/** The dither zone's cell sizes (shares of the pitch p), largest first, in n steps. */
+export function levels(p: number, n: number, min?: number): number[];
+/** The pitch a set of cells gets once its longest side is fitted to 448. */
+export function pitchOf(cells: Cells): number;
+/** Cells tapered by a ramp: [i, j, f] (or [i, j, f, deg]) per kept cell. */
+export function taper(cells: Cells, o: TaperOptions): number[][];
+/** Cells drawn by hand as rows ('#' full, '1'–'9' a dither size, or a legend's [size, deg]). */
+export function mapCells(rows: readonly string[], o?: { n?: number; min?: number; legend?: Record<string, number[]>; i0?: number; j0?: number }): number[][];
+/** Full cells touching only at a corner: each 2 × 2 checker's top-left. */
+export function corners(cells: Cells): number[][];
+/** Tapered cells drawn on the 512 canvas, fitted to 448, every gap checked. */
+export function sprite(cells: Cells, o?: { round?: boolean; r?: number; push?: number[]; allowCorners?: boolean }): Shape;
+/** The upright box of a square of side s turned by deg. */
+export function turnBox(s: number, deg?: number): number;
+/** The side of a square turned by deg whose upright box is b across. */
+export function turnedSide(b: number, deg?: number): number;
+/** Squares [x, y, s, deg] as one shape. */
+export function squares(list: Cells): Shape;
+/** The bounding box of a square list. */
+export function extent(list: Cells): Box;
+/** A square list moved so its box is centred on the canvas. */
+export function centred(list: Cells): number[][];
+/** A resolution run: columns of 1, 2, 3 … squares, H solved so the run is `span` wide. */
+export function resRun(counts: readonly number[], o?: { span?: number; gap?: number }): { list: number[][]; H: number; side: number };
+/** A single file of squares [side, deg] along x, MIN_GAP apart, on one line. */
+export function file(items: Cells, o?: { gap?: number; align?: 'top' | 'bottom' | 'centre'; span?: number }): number[][];