@logomarks/core 0.1.11 → 0.2.1

package/src/objects/animals.js

@@ -0,0 +1,469 @@
+/**
+ * Animals: Gecko Wall's build (so a new species or pose is new data rather than a redraw), the Track animals' two-track
+ * parts (two tracks 26 wide and 48 apart round one centreline), the Bold animals' smooth outlines, tapers, seams and
+ * sickle wings, pets (a flat-footed leg, a bone, a paw print), ribbon loops and animals side-on in headphones. From the
+ * Logomarks tools (animalparts.mjs, batches 160, 176, 182, 192, 196, 197, 221, 279, 291, 297, 308, 314, 326, 335).
+ */
+import { U, D, I, circle, ellipse, pill, bar, rr, rot, stroke, polar, poly, grow, scale, sample, trackLoop, tracks, C, rect, move, over, grown, roundPoly } from '../geometry/index.js';
+import { duo, spline, splineClosed } from '../parts/index.js';
+import { arc } from './faces.js';
+
+/**
+ * A round eye hole.
+ *
+ * @param {number} x The centre, x.
+ * @param {number} y The centre, y.
+ * @param {number} [r=13] The radius.
+ * @returns {import('../geometry/types.js').Polygon} The eye.
+ */
+export const eye = (x, y, r = 13) => circle(x, y, r, 64);
+
+/**
+ * A foot of splayed toes from (x, y): n toes `len` long fanned `fanDeg` about `deg`, each ending in a round pad (a gecko's).
+ *
+ * @param {number} x The foot, x.
+ * @param {number} y The foot, y.
+ * @param {number} deg The way the foot points, in degrees.
+ * @param {number} [n=4] How many toes.
+ * @param {number} [len=52] Their length.
+ * @param {number} [w=18] Their width.
+ * @param {number} [pad=17] The pads' radius.
+ * @param {number} [fanDeg=110] How far they fan, in degrees.
+ * @returns {import('../geometry/types.js').Shape} The foot.
+ */
+export const toes = (x, y, deg, n = 4, len = 52, w = 18, pad = 17, fanDeg = 110) => U(...[...Array(n)].map((_, k) => { const a = deg - fanDeg / 2 + (fanDeg * k) / (n - 1), t = polar(len, a, x, y);
+	return U(pill([x, y], t, w), circle(...t, pad, 48)); }));
+
+/**
+ * Gecko Wall's width along the body, head to tail tip.
+ *
+ * @param {number} t How far along, 0 → 1.
+ * @returns {number} The width there.
+ */
+export const geckoW = (t) => (t < 0.08 ? 80 + 300 * t : t < 0.5 ? 104 - 20 * Math.sin(t * 9) : 100 * (1 - t) * 1.9 + 14);
+
+/**
+ * A gecko from above: the body along `spinePts` (control points, head end first), the head an ellipse on its leading
+ * end with two eyes, and `legs` [shoulder, knee, foot] each ending in a foot of padded toes turned the way the shin points.
+ *
+ * @param {readonly (readonly number[])[]} spinePts The spine's control points, head first.
+ * @param {readonly (readonly (readonly number[])[])[]} legs Each leg's [shoulder, knee, foot].
+ * @param {{ w?: (t: number) => number, legW?: number, toe?: { n?: number, len?: number, w?: number, pad?: number }, head?: number[], eyeAt?: number[] }} [o]
+ *   The width along the body, the limbs' width, toes()'s options, the head's [rx, ry] and the eyes' [back, out, r].
+ * @returns {import('../geometry/types.js').Shape} The gecko.
+ */
+export const gecko = (spinePts, legs, { w = geckoW, legW = 36, toe = {}, head: [hrx, hry] = [62, 74], eyeAt: [eb, eo, er] = [18, 34, 12] } = {}) => {
+	const sp = spline(spinePts, 12), [a, b] = spinePts, L = Math.hypot(b[0] - a[0], b[1] - a[1]), d = [(b[0] - a[0]) / L, (b[1] - a[1]) / L], n = [-d[1], d[0]];
+	const hc = [a[0] + d[0] * 32, a[1] + d[1] * 32], th = (Math.atan2(d[1], d[0]) * 180) / Math.PI;
+	const body = stroke(sp, (i, k) => w(i / k), { roundCaps: true, chunk: 6 }), head = ellipse(hc[0], hc[1], hrx, hry, th - 90);
+	const limbs = U(...legs.map(([s0, k, f]) => U(stroke([s0, k, f], legW, { roundCaps: true }), circle(f[0], f[1], 30, 48), // the palm: closes the pin-holes between toe roots
+		toes(f[0], f[1], (Math.atan2(f[1] - k[1], f[0] - k[0]) * 180) / Math.PI, toe.n, toe.len, toe.w, toe.pad))));
+	const ey = (sg) => eye(hc[0] - d[0] * eb + n[0] * eo * sg, hc[1] - d[1] * eb + n[1] * eo * sg, er);
+	return D(U(body, head, limbs), ey(1), ey(-1)); };
+
+/** The house two tracks for the Track animals: core's duo(22), 26 wide and 48 apart. */
+export const DUO = duo(22);
+
+/**
+ * Outline points drawn k times smaller about (300, 300), the fillets kept: so a mark whose drawing runs long fits to the
+ * same track weight as the rest.
+ *
+ * @param {readonly (readonly number[])[]} pts The points.
+ * @param {number} k The scale.
+ * @returns {import('../geometry/types.js').Point[]} The scaled points.
+ */
+export const sc = (pts, k) => pts.map(([x, y]) => [300 + (x - 300) * k, 300 + (y - 300) * k]);
+
+/**
+ * A solid drawn k times smaller about (300, 300), as sc() does for points.
+ *
+ * @param {import('../geometry/types.js').Geom} g The solid.
+ * @param {number} k The scale.
+ * @returns {import('../geometry/types.js').Shape} The scaled solid.
+ */
+export const scaleS = (g, k) => scale(g, k, 300, 300);
+
+/**
+ * Two tracks round a filleted outline.
+ *
+ * @param {readonly (readonly number[])[]} o The outline (the loop's centreline).
+ * @returns {import('../geometry/types.js').Shape} The loop.
+ */
+export const loop2 = (o) => trackLoop(o, DUO);
+
+/**
+ * Two tracks along an open line, round ends.
+ *
+ * @param {readonly (readonly number[])[]} pts The line.
+ * @returns {import('../geometry/types.js').Shape} The tracks.
+ */
+export const line2 = (pts) => tracks(pts, DUO);
+
+/**
+ * Where solids may sit inside a two-track loop: the band's half-width (37) plus the gap (22) in from the centreline, and
+ * 1 to spare.
+ *
+ * @param {readonly (readonly number[])[]} o The loop's centreline.
+ * @returns {import('../geometry/types.js').Shape} The room inside.
+ */
+export const inside = (o) => grow(poly(o), -60);
+
+/**
+ * A solid at the end of a line, oriented along its last heading: an ellipse `len` long and `wid` across, centred `ahead`
+ * past the end (Track Snake's head).
+ *
+ * @param {readonly (readonly number[])[]} pts The line.
+ * @param {number} len The head's length.
+ * @param {number} wid Its width.
+ * @param {number} ahead How far past the end its centre sits.
+ * @returns {[import('../geometry/types.js').Polygon, import('../geometry/types.js').Point, number]} [shape, centre, heading in degrees].
+ */
+export const endHead = (pts, len, wid, ahead) => { const a = pts.at(-2), b = pts.at(-1), h = Math.atan2(b[1] - a[1], b[0] - a[0]) * 180 / Math.PI, c = polar(ahead, h, b[0], b[1]);
+	return [ellipse(c[0], c[1], len / 2, wid / 2, h), c, h]; };
+
+/**
+ * An eye as near (x, y) as the loop `o` allows: the nearest point inside it with the band and the gap (59) plus a little
+ * clear all round (a grid search, so it is deterministic); warns when no point within 140 has that room.
+ *
+ * @param {readonly (readonly number[])[]} o The loop's centreline.
+ * @param {readonly number[]} at Where the eye should be, [x, y].
+ * @param {number} [r=16] Its radius.
+ * @returns {import('../geometry/types.js').Polygon} The eye.
+ */
+export const eyeIn = (o, [x, y], r = 16) => { const inPoly = (px, py) => { let c = false; for (let i = 0, j = o.length - 1; i < o.length; j = i++) { const [a, b] = [o[i], o[j]]; if ((a[1] > py) !== (b[1] > py) && px < ((b[0] - a[0]) * (py - a[1])) / (b[1] - a[1]) + a[0]) c = !c; } return c; };
+	let best = null, room = [-1]; for (let px = x - 140; px <= x + 140; px += 2) for (let py = y - 140; py <= y + 140; py += 2) { if (!inPoly(px, py)) continue;
+		const d = Math.min(...o.map((p) => Math.hypot(p[0] - px, p[1] - py))), off = Math.hypot(px - x, py - y); if (d > room[0]) room = [d, px, py]; if (d >= 59 + r + 4 && (!best || off < best[0])) best = [off, px, py]; }
+	if (!best) { console.warn(`  no room for an eye near ${x},${y}: ${(room[0] - 37 - r).toFixed(0)} clear at best`); best = room; }
+	return circle(best[1], best[2], r); };
+
+/**
+ * A two-track loop round a stadium centred (cx, cy), `len` long and `wid` across (its ends half circles, so the inner
+ * track keeps a radius of wid/2 − 24), turned deg. An ellipse would not do: its ends tighten and pinch the inner track.
+ *
+ * @param {number} cx The centre, x.
+ * @param {number} cy The centre, y.
+ * @param {number} len The length.
+ * @param {number} wid The width.
+ * @param {number} [deg=0] The turn, in degrees.
+ * @returns {import('../geometry/types.js').Shape} The loop.
+ */
+export const stadium2 = (cx, cy, len, wid, deg = 0) => { const r = wid / 2, h = len / 2 - r, a = deg * Math.PI / 180;
+	const pts = [...sample((t) => polar(r, t, h, 0), -90, 90, 60), ...sample((t) => polar(r, t, -h, 0), 90, 270, 60)];
+	return loop2(pts.map(([x, y]) => [cx + x * Math.cos(a) - y * Math.sin(a), cy + x * Math.sin(a) + y * Math.cos(a)])); };
+
+/**
+ * A cloud loop's centreline (a sheep's fleece, a cloud): a ring of circles [x, y, r] listed clockwise round the middle,
+ * each dip between neighbours filleted r, as points (convex arcs of the circles, concave arcs of radius r between them).
+ *
+ * @param {readonly (readonly number[])[]} cs The circles, [x, y, r], clockwise.
+ * @param {number} [r=60] The dips' fillet radius.
+ * @returns {import('../geometry/types.js').Point[]} The centreline.
+ */
+export function cloud(cs, r = 60) { const n = cs.length, G = [cs.reduce((s, c) => s + c[0], 0) / n, cs.reduce((s, c) => s + c[1], 0) / n];
+	const fil = cs.map((A, i) => { const B = cs[(i + 1) % n], ra = A[2] + r, rb = B[2] + r, dx = B[0] - A[0], dy = B[1] - A[1], d = Math.hypot(dx, dy), a = (ra * ra - rb * rb + d * d) / (2 * d), h = Math.sqrt(ra * ra - a * a);
+		const m = [A[0] + (a * dx) / d, A[1] + (a * dy) / d], P = [[m[0] - (h * dy) / d, m[1] + (h * dx) / d], [m[0] + (h * dy) / d, m[1] - (h * dx) / d]];
+		return P.sort((p, q) => Math.hypot(q[0] - G[0], q[1] - G[1]) - Math.hypot(p[0] - G[0], p[1] - G[1]))[0]; });
+	const ang = (c, p) => Math.atan2(p[1] - c[1], p[0] - c[0]), out = [];
+	cs.forEach((A, i) => { const Fin = fil[(i - 1 + n) % n], Fout = fil[i]; let a0 = ang(A, Fin), a1 = ang(A, Fout); while (a1 <= a0) a1 += 2 * Math.PI;
+		for (let t = 0; t <= 1; t += 1 / Math.ceil(((a1 - a0) * A[2]) / 6)) out.push([A[0] + A[2] * Math.cos(a0 + (a1 - a0) * t), A[1] + A[2] * Math.sin(a0 + (a1 - a0) * t)]);
+		const B = cs[(i + 1) % n]; let b0 = ang(Fout, A), b1 = ang(Fout, B); while (b1 >= b0) b1 -= 2 * Math.PI; if (b0 - b1 > Math.PI) b1 += 2 * Math.PI;
+		for (let t = 0; t <= 1; t += 1 / Math.ceil((Math.abs(b0 - b1) * r) / 6)) out.push([Fout[0] + r * Math.cos(b0 + (b1 - b0) * t), Fout[1] + r * Math.sin(b0 + (b1 - b0) * t)]); });
+	return out.filter((p, i) => Math.hypot(p[0] - out[(i + 1) % out.length][0], p[1] - out[(i + 1) % out.length][1]) > 1); }
+
+/**
+ * A smooth closed outline through control points.
+ *
+ * @param {readonly (readonly number[])[]} pts The control points.
+ * @param {number} [n=16] Spline points a span.
+ * @returns {import('../geometry/types.js').Polygon} The outline.
+ */
+export const S = (pts, n = 16) => poly(splineClosed(pts, n));
+
+/**
+ * A tapering stroke along a smooth curve through `pts`, w0 wide at the start to w1 at the end, round ends.
+ *
+ * @param {readonly (readonly number[])[]} pts The knots.
+ * @param {number} w0 The width at the start.
+ * @param {number} w1 The width at the end.
+ * @param {number} [n=10] Spline points a span.
+ * @returns {import('../geometry/types.js').Shape} The stroke.
+ */
+export const taper = (pts, w0, w1, n = 10) => stroke(spline(pts, n), (i, k) => w0 + (w1 - w0) * (i / k), { roundCaps: true, chunk: 6 });
+
+/**
+ * A cut g wide along a smooth curve through `pts` (a folded wing's edge, a stripe, a whorl), round ends. Run it off the
+ * outline or stop it inside; never let it graze an edge at a tangent (that leaves a needle).
+ *
+ * @param {readonly (readonly number[])[]} pts The knots.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The cut.
+ */
+export const seam = (pts, g) => stroke(spline(pts, 10), g, { roundCaps: true, chunk: 6 });
+
+/**
+ * A symmetric outline about x = cx from its right half (top centre round to bottom centre).
+ *
+ * @param {readonly (readonly number[])[]} half The right half.
+ * @param {number} [cx=C] The axis.
+ * @returns {import('../geometry/types.js').Point[]} The whole outline.
+ */
+export const mirror = (half, cx = C) => [...half, ...half.slice(1, -1).reverse().map(([x, y]) => [2 * cx - x, y])];
+
+/**
+ * Points on the circular arc from P to Q bulging h to the left of P→Q (negative h bulges right; 0 is the straight line).
+ *
+ * @param {readonly number[]} P The start.
+ * @param {readonly number[]} Q The end.
+ * @param {number} h The bulge.
+ * @param {number} [n=40] Steps.
+ * @returns {import('../geometry/types.js').Point[]} The arc.
+ */
+export const bow = (P, Q, h, n = 40) => { const L = Math.hypot(Q[0] - P[0], Q[1] - P[1]), u = [(Q[0] - P[0]) / L, (Q[1] - P[1]) / L], nl = [u[1], -u[0]];
+	if (Math.abs(h) < 1e-6) return sample((t) => [P[0] + (Q[0] - P[0]) * t, P[1] + (Q[1] - P[1]) * t], 0, 1, n);
+	const R = (L * L / 4 + h * h) / (2 * h), m = [(P[0] + Q[0]) / 2, (P[1] + Q[1]) / 2], c = [m[0] - nl[0] * (R - h), m[1] - nl[1] * (R - h)];
+	const a0 = Math.atan2(P[1] - c[1], P[0] - c[0]), a1 = Math.atan2(Q[1] - c[1], Q[0] - c[0]); let d = a1 - a0;
+	const mid = (t) => [c[0] + Math.abs(R) * Math.cos(a0 + d * t), c[1] + Math.abs(R) * Math.sin(a0 + d * t)];
+	while (d > Math.PI) d -= 2 * Math.PI; while (d < -Math.PI) d += 2 * Math.PI;
+	const test = mid(0.5); if (Math.hypot(test[0] - (m[0] + nl[0] * h), test[1] - (m[1] + nl[1] * h)) > Math.abs(h) * 0.5 + 1) d = d > 0 ? d - 2 * Math.PI : d + 2 * Math.PI;
+	return sample(mid, 0, 1, n); };
+
+/**
+ * A sickle wing: from the front of its root `p0` along an arc bulging h0 to the tip, back along an arc bulging h1 to the
+ * back of its root `p1` (positive bulges to the left of each run).
+ *
+ * @param {readonly number[]} p0 The root's front.
+ * @param {readonly number[]} tip The tip.
+ * @param {readonly number[]} p1 The root's back.
+ * @param {number} h0 The outward run's bulge.
+ * @param {number} h1 The return run's bulge.
+ * @returns {import('../geometry/types.js').Polygon} The wing.
+ */
+export const sickle = (p0, tip, p1, h0, h1) => poly([...bow(p0, tip, h0), ...bow(tip, p1, h1).slice(1)]);
+
+/**
+ * The near wing laid over the body and parted from it only by a straight cut g wide across its root, a→b (clipped to the
+ * wing, so the body's own outline is never notched).
+ *
+ * @param {import('../geometry/types.js').Geom} body The body.
+ * @param {import('../geometry/types.js').Geom} wing The wing.
+ * @param {readonly number[]} a The cut's start.
+ * @param {readonly number[]} b The cut's end.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} Body and wing.
+ */
+export const rootCut = (body, wing, a, b, g) => D(U(body, wing), I(bar(a, b, g), wing));
+
+/**
+ * Cuts g wide straight across a curve through `pts` at each fraction t of its length, reaching `reach` either side (rings
+ * round a tail, segments of a body, a stripe across a flank). Square to the curve, so each cut crosses its edges squarely.
+ *
+ * @param {readonly (readonly number[])[]} pts The curve's knots.
+ * @param {readonly number[]} ts Where to cut, as fractions of its length.
+ * @param {number} reach How far each cut runs either side.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The cuts.
+ */
+export const bands = (pts, ts, reach, g) => { const sp = spline(pts, 12), N = sp.length - 1;
+	return U(...ts.map((t) => { const i = Math.round(t * N), a = sp[Math.max(0, i - 1)], b = sp[Math.min(N, i + 1)], L = Math.hypot(b[0] - a[0], b[1] - a[1]), n = [-(b[1] - a[1]) / L, (b[0] - a[0]) / L];
+		return bar([sp[i][0] - n[0] * reach, sp[i][1] - n[1] * reach], [sp[i][0] + n[0] * reach, sp[i][1] + n[1] * reach], g); })); };
+
+/**
+ * A leg from hip [x, y] straight down to the ground at y `gy`, w wide, its foot squared off flat (round heel and toe, r)
+ * and pointing the way `dir` says (1 right, −1 left) by `toe` past the leg: legs that stand on a line need flat feet.
+ *
+ * @param {readonly number[]} hip The hip, [x, y].
+ * @param {number} gy The ground.
+ * @param {number} [w=54] The leg's width.
+ * @param {number} [dir=1] The way the foot points.
+ * @param {number} [toe=14] How far it reaches past the leg.
+ * @param {number} [r=14] The heel's and toe's radius.
+ * @returns {import('../geometry/types.js').Shape} The leg.
+ */
+export const flatLeg = ([x, y], gy, w = 54, dir = 1, toe = 14, r = 14) => U(pill([x, y], [x, gy - w / 2], w),
+	rr(Math.min(x - w / 2, x - w / 2 + dir * toe), gy - w / 2 - 2, w + toe, w / 2 + 2, [0, 0, r, r]));
+
+/**
+ * A dog's bone L long between its knuckle centres, w across the shaft, each end two knuckles of radius r; turned deg
+ * about its centre (cx, cy).
+ *
+ * @param {number} cx The centre, x.
+ * @param {number} cy The centre, y.
+ * @param {number} L The length between knuckle centres.
+ * @param {number} w The shaft's width.
+ * @param {number} r The knuckles' radius.
+ * @param {number} [deg=0] The turn, in degrees.
+ * @returns {import('../geometry/types.js').Shape} The bone.
+ */
+export const bone = (cx, cy, L, w, r, deg = 0) => { const s = (w / 2 + r) * 0.62;
+	return rot(U(rr(cx - L / 2, cy - w / 2, L, w, 0), ...[-1, 1].flatMap((sx) => [-1, 1].map((sy) => circle(cx + sx * L / 2, cy + sy * s, r, 120)))), deg, cx, cy); };
+
+/**
+ * A paw print centred (cx, cy), about 300 across at k = 1: the heel pad a rounded triangle, four toe pads fanned over it.
+ *
+ * @param {number} cx The centre, x.
+ * @param {number} cy The centre, y.
+ * @param {number} [k=1] The scale.
+ * @returns {import('../geometry/types.js').Shape} The print.
+ */
+export const pawPrint = (cx, cy, k = 1) => U(S([[0, 10], [70, 30], [104, 96], [70, 140], [0, 128], [-70, 140], [-104, 96], [-70, 30]].map(([x, y]) => [cx + x * k, cy + y * k])),
+	...[[-118, -36, 34, 44, -20], [-46, -100, 36, 48, -6], [46, -100, 36, 48, 6], [118, -36, 34, 44, 20]].map(([x, y, rx, ry, a]) => ellipse(cx + x * k, cy + y * k, rx * k, ry * k, a)));
+
+/**
+ * A solid kept a gap clear of a loop's two tracks: the band (37 from the centreline) plus the gap (22).
+ *
+ * @param {import('../geometry/types.js').Geom} solid The solid.
+ * @param {readonly (readonly number[])[]} o The loop's centreline.
+ * @returns {import('../geometry/types.js').Shape} What's left of the solid.
+ */
+export const clearOf = (solid, o) => D(solid, grow(poly(o), 59));
+
+/**
+ * A shape moved by (dx, dy).
+ *
+ * @param {import('../geometry/types.js').Shape} sh The shape.
+ * @param {number} dx The move, x.
+ * @param {number} dy The move, y.
+ * @returns {import('../geometry/types.js').Shape} The moved shape.
+ */
+export const moved = (sh, dx, dy) => sh.map((pg) => pg.map((r) => r.map(([x, y]) => [x + dx, y + dy])));
+
+/**
+ * A closed polyline resampled to points `step` apart along it (as filletClosed()'s are), so trackLoop()'s normals stay
+ * smooth.
+ *
+ * @param {readonly (readonly number[])[]} pts The closed polyline (open: no repeated first point).
+ * @param {number} step The spacing.
+ * @returns {import('../geometry/types.js').Point[]} The resampled points.
+ */
+export const evenPts = (pts, step) => { const n = pts.length, L = [0]; for (let i = 0; i < n; i++) { const a = pts[i], b = pts[(i + 1) % n]; L.push(L[i] + Math.hypot(b[0] - a[0], b[1] - a[1])); }
+	const out = [], m = Math.round(L[n] / step); let j = 0;
+	for (let k = 0; k < m; k++) { const d = (k * L[n]) / m; while (L[j + 1] < d) j++; const a = pts[j], b = pts[(j + 1) % n], t = (d - L[j]) / (L[j + 1] - L[j] || 1); out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]); }
+	return out; };
+
+/**
+ * A ribbon loop's centreline (a squirrel's tail, a rabbit's moon): the spine splined, offset by half the width wf(t)
+ * (t 0 → 1 along it) each side, round caps at both ends, resampled 8 apart. Keep the spine's radius over wf/2 + 40.
+ *
+ * @param {readonly (readonly number[])[]} spine The spine's knots.
+ * @param {(t: number) => number} wf The width along it.
+ * @param {number} [n=12] Spline points a span.
+ * @returns {import('../geometry/types.js').Point[]} The loop's centreline.
+ */
+export const ribbon = (spine, wf, n = 12) => { const sp = spline(spine, n), N = sp.length - 1;
+	const hd = sp.map((p, i) => { const a = sp[Math.max(0, i - 1)], b = sp[Math.min(N, i + 1)]; return Math.atan2(b[1] - a[1], b[0] - a[0]) * 180 / Math.PI; });
+	const side = (s) => sp.map((p, i) => polar(wf(i / N) / 2, hd[i] + s * 90, ...p));
+	const cap = (i, from) => sample((t) => polar(wf(i / N) / 2, from - 180 * t, ...sp[i]), 0, 1, 24).slice(1, -1);
+	return evenPts([...side(1), ...cap(N, hd[N] + 90), ...side(-1).reverse(), ...cap(0, hd[0] - 90)], 8); };
+
+/**
+ * Whether a point is inside a shape (even-odd over every ring; a polygon or a list of them).
+ *
+ * @param {import('../geometry/types.js').Geom} sh The shape.
+ * @param {readonly number[]} p The point.
+ * @returns {boolean} True inside.
+ */
+export const inShape = (sh, [px, py]) => { let c = false;
+	for (const pg of typeof sh[0][0][0] === 'number' ? [sh] : sh) for (const r of pg) for (let i = 0, j = r.length - 1; i < r.length; j = i++) { const [a, b] = [r[i], r[j]];
+		if ((a[1] > py) !== (b[1] > py) && px < ((b[0] - a[0]) * (py - a[1])) / (b[1] - a[1]) + a[0]) c = !c; }
+	return c; };
+
+/**
+ * A head side-on in headphones, layered back to front: `behind`, the band, the head, the near cup and the band's run up
+ * from it, the band re-laid whole where it clears the head. `o`: head (a solid or (g) => one, ears in front of the band
+ * included), rimOn (the outline the band clears; default head), cupY or cupC, cupIn, cw, ch, tilt, bw, lift (gaps), x1
+ * (where the band lands on the forehead: put it under an ear in front of the band, or the band shows as a sliver past the
+ * ear), holes (g) => […], parts (g) => […] parted by the gap, behind (g) => […]. With `even`, the band's straight run up
+ * from the cup is sampled as finely as its arc (an uneven spline leaves a tooth on the run's back edge), and the run in
+ * front of the head is cut level 1.5 gaps over the head's highest point under it.
+ *
+ * @param {import('./animals.js').SidePhonesOptions} o The head and the phones.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build, given the gap.
+ */
+export const sidePhones = (o) => (g) => {
+	const head = typeof o.head === 'function' ? o.head(g) : o.head, { bw = 38, cw = 88, ch = 156, tilt = 0, lift = 1.6, cupY = 10, cupIn = 18, x1 } = o, base = o.rimOn || head, off = lift * g + bw / 2;
+	const scan = (f) => { for (let t = -1200; t < 1200; t += 2) if (inShape(base, f(t))) return t; };
+	const P0 = o.cupC || [scan((x) => [x, cupY]) + cupIn, cupY], E = [x1, scan((y) => [x1, y]) + 10], cy = Math.min(E[1], P0[1] - ch / 2);
+	const mx = (P0[0] + E[0]) / 2, rx = (E[0] - P0[0]) / 2, N = 40;
+	const ell = (ry) => [...Array(N + 1)].map((_, i) => { const t = Math.PI + (Math.PI * i) / N; return [mx + rx * Math.cos(t), cy + ry * Math.sin(t)]; });
+	let ry = 30; while (ry < 900 && ell(ry).slice(N / 4, (3 * N) / 4 + 1).some(([x, y]) => inShape(base, [x, y + off]))) ry += 3;
+	const arcP = ell(ry), st = Math.hypot(arcP[1][0] - arcP[0][0], arcP[1][1] - arcP[0][1]), n = o.even ? Math.max(1, Math.round((P0[1] - cy) / st)) : 1;
+	const path = [...[...Array(n)].map((_, i) => [P0[0], P0[1] + ((cy - P0[1]) * i) / n]), ...arcP, ...(E[1] > cy + 5 ? [E] : [])];
+	const bd = stroke(spline(path, 16), bw, { roundCaps: true }), cup = rot(rr(P0[0] - cw / 2, P0[1] - ch / 2, cw, ch, cw / 2), tilt, P0[0], P0[1]);
+	const face = (o.parts ? o.parts(g) : []).reduce((f, p) => over(f, p, g), D(head, ...(o.holes ? o.holes(g) : [])));
+	const near = D(bd, rect(mx, -3000, 6000, 6000)), tops = [];
+	if (o.even) for (let x = P0[0] - bw / 2; x <= P0[0] + bw / 2; x += 2) { const t = scan((y) => [x, y]); if (t !== undefined) tops.push(t); }
+	const front = U(cup, o.even ? I(near, rect(-3000, Math.min(...tops) - 1.5 * g, 6000, 6000)) : I(near, grown(base, 1.5 * g)));
+	const s = over(over(over(o.behind ? U(...o.behind(g)) : [], bd, g), face, g), front, g);
+	return U(s, D(bd, grown(head, g))); };
+
+/**
+ * sidePhones() drawn at k, turned deg and moved to (dx, dy), the gap kept g at the mark's scale.
+ *
+ * @param {import('./animals.js').SidePhonesOptions} o sidePhones()'s options.
+ * @param {number} k The scale.
+ * @param {number} dx The move, x.
+ * @param {number} dy The move, y.
+ * @param {number} [deg=0] The turn, in degrees.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build, given the gap.
+ */
+export const wearPhones = (o, k, dx, dy, deg = 0) => (g) => move(rot(scale(sidePhones(o)(g / k), k, 0, 0), deg, 0, 0), dx, dy);
+
+/**
+ * Layers back to front, each laid over() the ones before it by the gap.
+ *
+ * @param {number} g The gap.
+ * @param {...import('../geometry/types.js').Geom} layers The layers, back first.
+ * @returns {import('../geometry/types.js').Shape} The stack.
+ */
+export const layered = (g, ...layers) => layers.reduce((s, l) => over(s, l, g));
+
+/**
+ * A cat's or a fox's head side-on round the crown's centre, facing right: the snout s further forward (0 a cat's), the
+ * pointed ear in front of the band (x1 under it), for sidePhones().
+ *
+ * @param {number} s How far the snout runs forward.
+ * @returns {{ head: import('../geometry/types.js').Shape, rimOn: import('../geometry/types.js').Polygon, x1: number }} sidePhones()'s head, rimOn and x1.
+ */
+export const pointyHead = (s) => { const base = S([[-120, 25], [-110, -55], [-45, -100], [45, -98], [110, -55], [148 + 0.4 * s, 5], [150 + s, 30], [130 + s, 52], [92, 82], [10, 96], [-80, 82]]);
+	return { head: U(base, roundPoly([[10, -90], [70, -230], [112, -50]], [20, 20, 20])), rimOn: base, x1: 100 }; };
+
+/**
+ * ∪ : a shut eye for a whole animal side-on, its radius at least 1.2 strokes: a mark drawn smaller has a wider gap in
+ * drawing units, and a tight arc blots into a heart.
+ *
+ * @param {number} x The eye, x.
+ * @param {number} y The eye, y.
+ * @param {number} r Its radius.
+ * @param {number} w Its stroke.
+ * @returns {import('../geometry/types.js').Shape} The eye.
+ */
+export const shut = (x, y, r, w) => arc(x, y, Math.max(r, 1.2 * w), 20, 160, w);
+
+/**
+ * A long head side-on round the crown's centre, facing right (a goat's, a donkey's, a kangaroo's): the muzzle s further
+ * forward and narrowing.
+ *
+ * @param {number} [s=0] How far the muzzle runs forward.
+ * @returns {import('../geometry/types.js').Polygon} The head.
+ */
+export const longBase = (s = 0) => S([[-100, 20], [-95, -50], [-40, -90], [40, -85], [110, -40], [175 + s, 5], [190 + s, 35], [170 + s, 60], [90, 65], [10, 75], [-60, 62]]);
+
+/** A bird's head side-on round the crown's centre, facing right, for a bird in headphones (the beak is the mark's). */
+export const birdHead = S([[-90, 20], [-85, -50], [-30, -90], [40, -80], [95, -30], [110, 20], [70, 60], [-10, 70], [-60, 60]]);
+
+/** A leg standing from y0 to the ground at y1, w wide. */
+const standLeg = (x, y0, y1, w) => pill([x, y0], [x, y1], w);
+
+/**
+ * Four legs standing from y0 to the ground at y1, w wide: the back pair from xb, the front pair from xf, each pair a leg's
+ * width plus the gap apart.
+ *
+ * @param {number} xb The back pair, x.
+ * @param {number} xf The front pair, x.
+ * @param {number} y0 The legs' top.
+ * @param {number} y1 The ground.
+ * @param {number} w Their width.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The legs.
+ */
+export const legs4 = (xb, xf, y0, y1, w, g) => U(standLeg(xb, y0, y1, w), standLeg(xb + w + g, y0, y1, w), standLeg(xf, y0, y1, w), standLeg(xf + w + g, y0, y1, w));

package/src/objects/bio.d.ts

@@ -0,0 +1,14 @@
+import type { Geom, Point, Shape } from '../geometry/types.js';
+
+/** Points along a helix strand down the y axis (s = ±1 picks the strand). */
+export function strandPts(s: number, o?: { H?: number; A?: number; turns?: number; ph?: number; y0?: number; n?: number }): Point[];
+/** A stroke tapering from w0 at the first point to w1 at the last. */
+export function tapered(pts: readonly (readonly number[])[], w0: number, w1: number): Shape;
+/** A comet: a head disc and a soft tapering tail. */
+export function comet(head: readonly number[], r: number, dir: number, len: number, o?: { bend?: number; wave?: number; tip?: number; n?: number }): Shape;
+/** Discs [x, y, r] packed back to front, each cut free by the gap. */
+export function cells(list: readonly (readonly number[])[], g: number): Shape;
+/** A ring w wide round a disc of radius R, with `inner` inside it. */
+export function zona(R: number, w: number, inner: Geom, g: number): Shape;
+/** A chromatid: a bowed sausage L long, w wide. */
+export function chromatid(L: number, w: number, bow: number): Shape;

package/src/objects/bio.js

@@ -0,0 +1,76 @@
+/**
+ * Biology: embryo cells, a comet (an abstract sperm), helix strands and chromatids, drawn about the origin in canvas units
+ * and placed by the mark. From the Logomarks tools (bioparts.mjs, batch 204).
+ */
+import { U, D, circle, stroke, sample, over } from '../geometry/index.js';
+
+/**
+ * Points along a helix strand down the y axis: H tall from y0, amplitude A, `turns` full turns, phase `ph` (s = ±1 picks
+ * the strand).
+ *
+ * @param {number} s The strand: 1 or −1.
+ * @param {{ H?: number, A?: number, turns?: number, ph?: number, y0?: number, n?: number }} [o] The helix.
+ * @returns {import('../geometry/types.js').Point[]} The strand's points.
+ */
+export const strandPts = (s, { H = 448, A = 130, turns = 1, ph = 0, y0 = -224, n = 200 } = {}) =>
+	sample((t) => [s * A * Math.sin(2 * Math.PI * turns * t + ph), y0 + H * t], 0, 1, n);
+
+/**
+ * A stroke whose width runs from w0 at the first point to w1 at the last (a comet's tail, a needle).
+ *
+ * @param {readonly (readonly number[])[]} pts The line.
+ * @param {number} w0 The width at the start.
+ * @param {number} w1 The width at the end.
+ * @returns {import('../geometry/types.js').Shape} The stroke.
+ */
+export const tapered = (pts, w0, w1) => stroke(pts, (i, n) => w0 + ((w1 - w0) * i) / (n - 1), { chunk: 8 });
+
+/**
+ * A comet: a head disc of radius r at `head` and a tail running away from it along `dir` (degrees), `len` long, bowing by
+ * `bend` (degrees, one arc) and waving by `wave` (degrees, one S), tapering from the head's width to `tip`. The abstract
+ * stand-in for a sperm: a dot and a short soft tail, never a realistic one.
+ *
+ * @param {readonly number[]} head The head's centre.
+ * @param {number} r The head's radius.
+ * @param {number} dir The tail's direction, in degrees.
+ * @param {number} len The tail's length.
+ * @param {{ bend?: number, wave?: number, tip?: number, n?: number }} [o] The tail's bow, wave, tip width and steps.
+ * @returns {import('../geometry/types.js').Shape} The comet.
+ */
+export const comet = (head, r, dir, len, { bend = 40, wave = 0, tip = 12, n = 40 } = {}) => {
+	const pts = [head]; let [x, y] = head, a = dir;
+	for (let i = 1; i <= n; i++) { const t = i / n; a = dir + bend * Math.sin(Math.PI * t) + wave * Math.sin(2 * Math.PI * t); x += (len / n) * Math.cos((a * Math.PI) / 180); y += (len / n) * Math.sin((a * Math.PI) / 180); pts.push([x, y]); }
+	return U(circle(...head, r, 120), tapered(pts, r * 0.9, tip));
+};
+
+/**
+ * Cells packed back to front: each disc [x, y, r] laid over the ones before it and cut free by the gap (an embryo's
+ * blastomeres, a morula).
+ *
+ * @param {readonly (readonly number[])[]} list The discs, [x, y, r], back first.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The cells.
+ */
+export const cells = (list, g) => list.reduce((s, [x, y, r]) => over(s, circle(x, y, r, 160), g), []);
+
+/**
+ * A ring w wide round a disc of radius R (the zona round an embryo), with `inner` inside it; keep the inner shape a gap
+ * clear of the ring's inner edge.
+ *
+ * @param {number} R The ring's outer radius.
+ * @param {number} w Its width.
+ * @param {import('../geometry/types.js').Geom} inner What sits inside.
+ * @param {number} g The gap (the caller keeps `inner` this far in).
+ * @returns {import('../geometry/types.js').Shape} The ring and its contents.
+ */
+export const zona = (R, w, inner, g) => U(D(circle(0, 0, R, 240), circle(0, 0, R - w, 240)), inner);
+
+/**
+ * A chromatid: a bowed sausage from (0, −L/2) to (0, L/2), w wide with round ends, its middle pushed out by `bow` along x.
+ *
+ * @param {number} L The length.
+ * @param {number} w The width.
+ * @param {number} bow The bow at the middle.
+ * @returns {import('../geometry/types.js').Shape} The chromatid.
+ */
+export const chromatid = (L, w, bow) => stroke(sample((t) => [bow * Math.sin(Math.PI * t), -L / 2 + L * t], 0, 1, 60), w, { roundCaps: true, chunk: 8 });

package/src/objects/devglyphs.d.ts

@@ -0,0 +1,34 @@
+import type { Polygon, Shape } from '../geometry/types.js';
+
+/** The prompt >_ about (cx, cy) at scale k. */
+export function prompt(cx: number, cy: number, k?: number, t?: number): Shape;
+/** The tag </>. */
+export function code(cx: number, cy: number, k?: number, t?: number): Shape;
+/** Angular curly braces { }, their stems `apart` from the middle. */
+export function braces(cx: number, cy: number, k?: number, apart?: number): Shape;
+/** The hash #. */
+export function hash(cx: number, cy: number, k?: number, t?: number): Shape;
+/** The dollar $: an angular S with a stem through it. */
+export function dollar(cx: number, cy: number, k?: number, t?: number): Shape;
+/** The underscore cursor _. */
+export function under(cx: number, cy: number, k?: number, w?: number, t?: number): Polygon;
+/** The tilde ~ as one wave. */
+export function tilde(cx: number, cy: number, k?: number, t?: number, w?: number, a?: number): Shape;
+/** A slash /. */
+export function slash(cx: number, cy: number, k?: number, t?: number, h?: number, lean?: number): Polygon;
+/** The fat arrow =>. */
+export function fatArrow(cx: number, cy: number, k?: number, t?: number): Shape;
+/** Not equal !=. */
+export function notEqual(cx: number, cy: number, k?: number, t?: number): Shape;
+/** Binary 01. */
+export function binary(cx: number, cy: number, k?: number, t?: number): Shape;
+/** Lambda λ. */
+export function lambda(cx: number, cy: number, k?: number, t?: number): Shape;
+/** A diff + −. */
+export function diff(cx: number, cy: number, k?: number, t?: number): Shape;
+/** A tick ✓. */
+export function tick(cx: number, cy: number, k?: number, t?: number): Shape;
+/** Two slashes //, a comment. */
+export function comment(cx: number, cy: number, k?: number, t?: number): Shape;
+/** A polygon in glyph units, mapped to (cx, cy) at scale k. */
+export function glyphPoly(cx: number, cy: number, k: number, pts: readonly (readonly number[])[]): Polygon;