@logomarks/core 0.1.9 → 0.2.0

package/src/letters/stair.js

@@ -0,0 +1,43 @@
+/**
+ * Stair letters: a letter on a coarse pixel grid (4–5 cells across, one cell per stroke), its diagonals stepping cell to
+ * cell corner to corner. Each cell's outer corners round a little; wherever two cells meet only at a corner, a straight
+ * neck bridges them along the diagonal, so the steps pinch but read as one stroke at 32 px.
+ * From the Logomarks tools (stairparts.mjs, batches 311 and 319).
+ */
+import { U, poly, pixels, soften } from '../geometry/index.js';
+
+/**
+ * The grid: P the cell (fitted, 90 for five rows to 112 for four); NECK the neck's width across the diagonal (fitted
+ * 28–34); EDGE each cell's outer corner radius; FIL the neck roots' fillet. The neck must stay wider than 2·EDGE or the
+ * rounding pinches it off; a closing to round the corners instead swells every neck to most of a cell (a blobby pixel face).
+ */
+export const STAIR = { P: 110, NECK: 34, EDGE: 14, FIL: 10 };
+
+/**
+ * A bar NECK wide along each corner-only contact's diagonal, 2.4 NECK long, so its ends sit inside the two cells.
+ *
+ * @param {readonly string[]} rows The grid, '#' a cell.
+ * @param {{ P?: number, NECK?: number }} [o] The cell and neck (STAIR's by default).
+ * @returns {import('../geometry/types.js').Polygon[]} One bar per corner contact.
+ */
+export const necks = (rows, { P = STAIR.P, NECK = STAIR.NECK } = {}) => {
+	const out = [], at = (r, c) => rows[r] && rows[r][c] === '#';
+	for (let r = 0; r + 1 < rows.length; r++) for (let c = 0; c < rows[r].length; c++) for (const d of [-1, 1]) {
+		if (!at(r, c) || !at(r + 1, c + d) || at(r, c + d) || at(r + 1, c)) continue;
+		const x = (c + (d > 0 ? 1 : 0)) * P, y = (r + 1) * P, ux = d / Math.SQRT2, uy = 1 / Math.SQRT2, L = NECK * 1.2, h = NECK / 2;
+		out.push(poly([[x - ux * L - uy * h, y - uy * L + ux * h], [x + ux * L - uy * h, y + uy * L + ux * h], [x + ux * L + uy * h, y + uy * L - ux * h], [x - ux * L + uy * h, y - uy * L - ux * h]]));
+	}
+	return out;
+};
+
+/**
+ * A stair glyph: the rows' cells ('#') as one solid, corners rounded, corner contacts necked.
+ *
+ * @param {readonly string[]} rows The grid, '#' a cell.
+ * @param {{ P?: number, NECK?: number, EDGE?: number, FIL?: number }} [o] The grid (STAIR's by default).
+ * @returns {() => import('../geometry/types.js').Shape} The build (it takes no gap: exact() only measures it).
+ */
+export const stair = (rows, o = {}) => () => {
+	const { P, EDGE, FIL } = { ...STAIR, ...o };
+	return soften(U(soften(pixels(rows, P), 0, EDGE), ...necks(rows, { ...STAIR, ...o })), FIL, 0);
+};

package/src/letters/stem.d.ts

@@ -0,0 +1,29 @@
+import type { Shape } from '../geometry/types.js';
+import type { Face } from './serif.js';
+
+/** The stem face: a serif face whose arms reach W past the stem. */
+export type StemFace = Face & { W: number };
+/** A part drawn on the stem: its ink and the stem corners it takes. */
+export interface StemPart {
+	s: Shape;
+	at: Record<string, number | boolean>;
+}
+/** One letter's part of a stem ligature. */
+export interface StemPlacement {
+	k: string;
+	side?: string;
+	ya: number;
+	yb?: number;
+	o?: Record<string, unknown>;
+}
+
+/** The stem face for hairline h. */
+export function sface(h: number, o?: { S?: number; W?: number }): StemFace;
+/** Right-side letters on a band of the stem. */
+export const STEM_RIGHT: Record<string, (m: StemFace, ya: number, yb: number, o?: Record<string, unknown>) => StemPart>;
+/** Lowercase on the band from the x-height to the foot. */
+export const STEM_LOWER: Record<string, (m: StemFace, xh: number, o?: Record<string, unknown>) => StemPart>;
+/** Left-side parts on a band of the stem. */
+export const STEM_LEFT: Record<string, (m: StemFace, ya: number, yb: number, o?: Record<string, unknown>) => StemPart>;
+/** A stem ligature, its hairline fitted to 31. */
+export function stack(parts: readonly StemPlacement[], o?: { S?: number; W?: number }): (g: number) => Shape;

package/src/letters/stem.js

@@ -0,0 +1,205 @@
+/**
+ * Stem monograms: two letters stacked on ONE thick Didone stem, the upper letter's arms or bowls on the stem's top part,
+ * the lower letter's on its foot; every arm and bowl off ONE side of the stem (or a hook off the other side, at the other
+ * end), each arm with ONE free end, and that end alone flared into a sharp wedge (never the double-barred cross). Drawn on
+ * the serif face's parts (foot serifs and brackets, slants, stressed rings, D bowls, balls). From the Logomarks tools
+ * (stemparts.mjs, batches 309 and 329).
+ */
+import { U, I, rect, poly, move, bbox } from '../geometry/index.js';
+import { despeckShape } from '../parts/index.js';
+import { foot, slant, ringArc, ball, bracket, dBowl } from './serif.js';
+
+/**
+ * A rectangle from its corners.
+ *
+ * @param {number} x0 Left.
+ * @param {number} y0 Top.
+ * @param {number} x1 Right.
+ * @param {number} y1 Bottom.
+ * @returns {import('../geometry/types.js').Polygon} The rectangle.
+ */
+const R = (x0, y0, x1, y1) => rect(x0, y0, x1 - x0, y1 - y0);
+
+/**
+ * A vector made unit length.
+ *
+ * @param {readonly number[]} v The vector.
+ * @returns {number[]} Its direction.
+ */
+const unit = ([x, y]) => { const l = Math.hypot(x, y) || 1; return [x / l, y / l]; };
+
+/** The stem's height T: the stem is x 0…S, y 0…T. A part is drawn on a local band [ya, yb] of the stem. */
+const T = 640;
+
+/**
+ * The stem face for hairline h: stem S (0.15 T unless `o.S`), arms reaching W past the stem (0.46 T unless `o.W`).
+ *
+ * @param {number} h The hairline.
+ * @param {{ S?: number, W?: number }} [o] The stem and the arms' reach, as fractions of the stem's height.
+ * @returns {import('./stem.js').StemFace} The face.
+ */
+export const sface = (h, o = {}) => {
+	const S = Math.round(T * (o.S ?? 0.15));
+	return { H: T, S, h, ov: Math.round(T * 0.045), br: Math.round(T * 0.03), bw: Math.round(h * 1.25), W: Math.round(T * (o.W ?? 0.46)) };
+};
+
+/**
+ * The face m with its cap height c (for the serif face's foot(), which reads m.H and m.h).
+ *
+ * @param {import('./stem.js').StemFace} m The face.
+ * @param {number} c The band's height.
+ * @returns {import('./stem.js').StemFace} The face on the band.
+ */
+const band = (m, c) => ({ ...m, H: c });
+
+/** The power of a wedge's concave sides. */
+const PW = 2.4;
+
+/**
+ * A hairline arm off the stem's right edge from x0 to xe, its top edge at y: the free end flares into a sharp wedge `up`
+ * above and `dn` below over the last `len`, its sides concave (a power curve tangent to the arm), its end square. The root
+ * gets a small bracket on each open side.
+ *
+ * @param {import('./stem.js').StemFace} m The face.
+ * @param {number} x0 The root.
+ * @param {number} xe The free end.
+ * @param {number} y The arm's top edge.
+ * @param {{ up?: number, dn?: number, len?: number, root?: number[] }} [o] The wedge and the root's brackets.
+ * @returns {import('../geometry/types.js').Shape} The arm.
+ */
+const arm = (m, x0, xe, y, { up = 0, dn = 0, len = (xe - x0) * 0.4, root = [1, 1] } = {}) => {
+	const n = 28, top = [], bot = [];
+	for (let i = 0; i <= n; i++) { const t = i / n, x = xe - len + len * t; top.push([x, y - up * t ** PW]); bot.push([x, y + m.h + dn * t ** PW]); }
+	const s = poly([[x0 - 1, y], ...top, ...bot.reverse(), [x0 - 1, y + m.h]]);
+	return U(s, root[0] ? bracket([x0, y], [1, 0], [0, -1], m.br * 0.7) : [], root[1] ? bracket([x0, y + m.h], [1, 0], [0, 1], m.br * 0.7) : []);
+};
+
+/**
+ * The same arm to the LEFT of the stem (x1 its root, xe < x1 its free end).
+ *
+ * @param {import('./stem.js').StemFace} m The face.
+ * @param {number} x1 The root.
+ * @param {number} xe The free end.
+ * @param {number} y The arm's top edge.
+ * @param {{ up?: number, dn?: number, len?: number, root?: number[] }} [o] As arm().
+ * @returns {import('../geometry/types.js').Shape} The arm.
+ */
+const armL = (m, x1, xe, y, o = {}) => { const a = arm(m, -x1, -xe, y, o); return a.map((pg) => pg.map((r) => r.map(([x, yy]) => [-x, yy]).reverse())); };
+
+/** The wedge depth, in hairlines. */
+const WD = 3;
+
+/**
+ * Right-side letters on the band [ya, yb]: `(m, ya, yb, o) => { s, at }`, with `at` the stem's corners it takes (tr: the
+ * top-right serif, br: the foot's right serif) when the band reaches the stem's ends. F L P B R K N H.
+ */
+export const STEM_RIGHT = {
+	F(m, ya, yb, o = {}) {
+		const c = yb - ya, W = m.W * (o.k ?? 1), ym = ya + c * (o.mid ?? 0.46) - m.h / 2;
+		return { s: U(arm(m, m.S, m.S + W, ya, { dn: m.h * WD, root: [0, 1] }), arm(m, m.S, m.S + W * 0.84, ym, { up: m.h * WD * 0.62, dn: m.h * WD * 0.62 })), at: { tr: ya === 0 } };
+	},
+	L(m, ya, yb, o = {}) {
+		const W = m.W * (o.k ?? 1.04);
+		return { s: arm(m, m.S, m.S + W, yb - m.h, { up: m.h * WD, root: [1, 0] }), at: { br: yb === T } };
+	},
+	// P: a D bowl on the stem from the band's top, closing on the stem at `cl` of the band
+	P(m, ya, yb, o = {}) {
+		const c = yb - ya, y1 = ya + c * (o.cl ?? 0.56);
+		return { s: dBowl(m, 0, ya, y1, m.S + m.W * (o.k ?? 0.92), m.S * 0.96, c * 0.04), at: { tr: ya === 0 } };
+	},
+	B(m, ya, yb, o = {}) {
+		const c = yb - ya, yu = ya + c * 0.47 + m.h / 2;
+		return { s: U(dBowl(m, 0, ya, yu, m.S + m.W * 0.84, m.S * 0.9, c * 0.03), dBowl(m, 0, yu - m.h, yb, m.S + m.W * 0.98, m.S * 0.98, c * 0.04)), at: { tr: ya === 0, br: yb === T } };
+	},
+	// R: P's bowl and a thick leg slanting from under it to the band's baseline, with a foot serif
+	R(m, ya, yb, o = {}) {
+		const c = yb - ya, yr = ya + c * 0.53, xr = m.S + m.W * 0.86, Wl = m.S + m.W * 1.06, mb = band(m, c);
+		const bowl = dBowl(m, 0, ya, yr, xr, m.S * 0.94, c * 0.04), wedge = U(R(-10, yr - m.h, Wl + 50, yb), bowl);
+		const leg = slant(m.S + m.W * 0.1, Wl - m.S * 1.05, m.S, ya + (yr - ya) * 0.45, yb);
+		const lf = move(foot(mb, leg.at(yb)[0], leg.at(yb)[1], 'base', { da: leg.up, db: leg.up, brk: 0 }), 0, ya);
+		return { s: U(bowl, I(leg.s, wedge), lf), at: { tr: ya === 0 } };
+	},
+	// K: a hairline arm from the stem up to the band's cap line and a thick leg from the arm to the baseline
+	K(m, ya, yb, o = {}) {
+		const c = yb - ya, mb = band(m, c), Wk = m.S + m.W * (o.k ?? 1.0);
+		const sx = m.S, arm_ = slant(Wk - m.ov * 1.2 - m.h * 1.3, sx - m.h * 1.2, m.h, 0, c * 0.72), armS = I(arm_.s, R(sx - 1, -1, Wk + 50, c));
+		const y0 = c * 0.4, P = [(arm_.at(y0)[0] + arm_.at(y0)[1]) / 2, y0], B = [Wk - m.ov - m.S * 1.1, c], u = unit([B[0] - P[0], B[1] - P[1]]);
+		const ad = arm_.up, cr = Math.abs(ad[0] * u[1] - ad[1] * u[0]), Q = [P[0] + (ad[0] * m.S) / cr, P[1] + (ad[1] * m.S) / cr], wb = m.S / u[1];
+		const leg = poly([P, Q, [B[0] + wb, c], B]), lu = unit([P[0] - B[0], P[1] - B[1]]);
+		// the arm's free end, cut level with the band's cap line, flares out to the right into a sharp wedge (no slab serif)
+		const fl = m.h * WD * (o.fl ?? 0.38), ln = c * 0.13, n = 24, xt = arm_.at(0)[0];
+		const wedge = poly([[xt, 0], ...[...Array(n + 1)].map((_, i) => { const t = i / n, y = ln * t; return [arm_.at(y)[1] + fl * (1 - t) ** PW, y]; }), [arm_.at(ln)[0], ln]]);
+		const s = U(armS, wedge, leg, foot(mb, B[0], B[0] + wb, 'base', { da: lu, db: lu, brk: 0 }));
+		return { s: move(s, 0, ya), at: {} };
+	},
+	// N: a thick diagonal from the stem at the band's top down to a hairline right stem's foot; that stem's free top flares
+	// right into a wedge (as the K's arm)
+	N(m, ya, yb, o = {}) {
+		const c = yb - ya, W = m.S + m.W * (o.k ?? 0.82), rx = W - m.h, wd = m.S * (o.t ?? 0.95);
+		const d = slant(0, W - (wd * Math.hypot(rx, c)) / c, wd, 0, c), fl = m.h * WD * 0.38, ln = c * 0.16, n = 24;
+		const wedge = poly([[rx, 0], ...[...Array(n + 1)].map((_, i) => { const t = i / n; return [W + fl * (1 - t) ** PW, ln * t]; }), [rx, ln]]);
+		return { s: move(U(I(d.s, R(0, 0, W + 10, c)), R(rx, 0, W, c), wedge), 0, ya), at: {} };
+	},
+	// H: a hairline crossbar from the stem to a thick right stem with foot serifs top and base
+	H(m, ya, yb, o = {}) {
+		const c = yb - ya, mb = band(m, c), b = m.S + m.W * (o.k ?? 0.5), W = b + m.S * (o.t ?? 0.9), yc = c * (o.bar ?? 0.5) - m.h / 2;
+		return { s: move(U(R(b, 0, W, c), foot(mb, b, W, 'top'), foot(mb, b, W, 'base'), R(m.S - 1, yc, b + 1, yc + m.h)), 0, ya), at: {} };
+	},
+};
+
+/**
+ * Lowercase: `(m, xh, o) => { s, at }` on the band from the x-height xh to the stem's foot. f k.
+ */
+export const STEM_LOWER = {
+	// f: the stem's top curls right over into a ball (a stressed ring's left side is the stem), and a hairline bar off ONE side
+	// of the stem at `xh`, its free end wedged (`right`: off the right side)
+	f(m, xh, o = {}) {
+		const rx = m.S * 0.5 + m.W * (o.k ?? 0.5), ry = T * 0.13, cx = rx, cy = ry, a1 = o.a1 ?? -38, r = ringArc(cx, cy, rx, ry, m.S, m.h, -180, a1), e = r.end(a1);
+		const bar = o.right ? arm(m, m.S, m.S + m.W * (o.bar ?? 0.42), xh, { up: m.h * WD * 0.5, dn: m.h * WD * 0.5 }) : armL(m, 0, -m.W * (o.bar ?? 0.42), xh, { up: m.h * WD * 0.5, dn: m.h * WD * 0.5 });
+		return { s: U(r.s, ball(e.o, [cx, cy], m.S * 0.52), R(0, cy, m.S, cy + 2), bar), at: { tl: 1, tr: 1 } };
+	},
+	// k: K's arm and leg on the band [xh, T]
+	k(m, xh, o = {}) { return STEM_RIGHT.K(m, xh, T, o); },
+};
+
+/**
+ * Left-side parts on the band [ya, yb]: `(m, ya, yb, o) => { s, at }`. J (the stem's foot hooks left; `at.foot` is where
+ * the stem ends) and A (the stem is its upright right leg).
+ */
+export const STEM_LEFT = {
+	// J: the stem's foot runs on into a hook curling left along the baseline, ending in a ball
+	J(m, ya, yb) {
+		const c = yb - ya, rx = m.S * 0.5 + m.W * 0.5, ry = c * 0.34, cx = m.S - rx, cy = yb - ry, r = ringArc(cx, cy, rx, ry, m.S, m.h, 0, 160), e = r.end(160);
+		return { s: U(r.s, ball(e.o, [cx, cy - ry * 0.4], m.S * 0.5)), at: { bl: 1, br: 1, foot: cy } };
+	},
+	// A: the stem is the A's upright right leg; a thick diagonal leaves the stem's left edge at the band's top and runs down
+	// left to a foot serif, a hairline bar back to the stem at `bar` of the band
+	A(m, ya, yb, o = {}) {
+		const c = yb - ya, mb = band(m, c), Wa = m.W * (o.k ?? 0.9), t = m.S * (o.t ?? 0.66), w = (t * Math.hypot(Wa, c)) / c;
+		const d = I(poly([[0, 0], [w, 0], [-Wa + w, c], [-Wa, c]]), R(-Wa - 10, 0, m.S, c)), xIn = (y) => w - (Wa * y) / c, yb_ = c * (o.bar ?? 0.6);
+		const bar = R(xIn(yb_ + m.h) - 1, yb_, 0.5, yb_ + m.h), dir = unit([Wa, -c]);
+		// the slab runs on past the slanted stroke's inner side at its top (foot() measures the reach from the foot's corner)
+		const sl = (m.h * Wa) / c, slab = U(foot(mb, -Wa, -Wa + w, 'base', { da: dir, db: dir }), R(-Wa + w, c - m.h, -Wa + w + sl + m.ov * 0.8, c));
+		return { s: move(U(d, bar, slab), 0, ya), at: {} };
+	},
+};
+
+/**
+ * A stem ligature: the parts drawn on one stem, each `{ k, side, ya, yb, o }` (side 'r' STEM_RIGHT, 'L' STEM_LEFT, 'l'
+ * STEM_LOWER from ya; ya and yb as fractions of the stem). The stem's serifs go where no part takes the corner. The
+ * hairline is redrawn so it fits to 31.
+ *
+ * @param {readonly { k: string, side?: string, ya: number, yb?: number, o?: Record<string, unknown> }[]} parts The parts.
+ * @param {{ S?: number, W?: number }} [o] sface()'s stem and reach.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build, for exact().
+ */
+export const stack = (parts, { S, W } = {}) => (g) => {
+	const draw = (h) => {
+		const m = sface(h, { S, W }); let at = {}, s = [];
+		for (const p of parts) { const r = p.side === 'l' ? STEM_LOWER[p.k](m, p.ya * T, p.o || {}) : (p.side === 'L' ? STEM_LEFT : STEM_RIGHT)[p.k](m, p.ya * T, p.yb * T, p.o || {}); s = U(s, r.s); at = { ...at, ...r.at }; }
+		const yEnd = at.foot ?? T, stem = R(0, 0, m.S, yEnd + 1);
+		const serifs = U(at.tl ? [] : foot(m, 0, m.S, 'top', { l: 1, r: at.tr ? 0 : 1 }), at.foot ? [] : foot(m, 0, m.S, 'base', { l: at.bl ? 0 : 1, r: at.br ? 0 : 1 }));
+		const mk = U(stem, s, serifs), [X0, Y0, X1, Y1] = bbox(mk); return move(mk, 256 - (X0 + X1) / 2, 256 - (Y0 + Y1) / 2);
+	};
+	const [x0, y0, x1, y1] = bbox(draw(32)); return despeckShape(draw(Math.ceil((31 * Math.max(x1 - x0, y1 - y0)) / 448)), 200, 30);
+};

package/src/objects/animals.d.ts

@@ -0,0 +1,105 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+import type { TrackSet } from '../parts/lines.js';
+
+type Pts = readonly (readonly number[])[];
+
+/** sidePhones()'s options: the head and how the headphones sit on it. */
+export interface SidePhonesOptions {
+	/** The head (ears in front of the band included), or a build of it from the gap. */
+	head: Geom | ((g: number) => Geom);
+	/** The outline the band clears (default: the head). */
+	rimOn?: Geom;
+	/** Where the band lands on the forehead, x. */
+	x1: number;
+	cupY?: number;
+	cupC?: number[];
+	cupIn?: number;
+	cw?: number;
+	ch?: number;
+	tilt?: number;
+	bw?: number;
+	/** The band's lift off the head, in gaps. */
+	lift?: number;
+	holes?: (g: number) => Geom[];
+	parts?: (g: number) => Geom[];
+	behind?: (g: number) => Geom[];
+	/** Batch 308's even run and level cut. */
+	even?: boolean;
+}
+
+/** A round eye hole. */
+export function eye(x: number, y: number, r?: number): Polygon;
+/** A foot of n splayed toes, each ending in a round pad. */
+export function toes(x: number, y: number, deg: number, n?: number, len?: number, w?: number, pad?: number, fanDeg?: number): Shape;
+/** Gecko Wall's width along the body (t 0 → 1). */
+export function geckoW(t: number): number;
+/** A gecko from above: body along a spine, head, eyes and padded feet. */
+export function gecko(spinePts: Pts, legs: readonly Pts[], o?: { w?: (t: number) => number; legW?: number; toe?: { n?: number; len?: number; w?: number; pad?: number }; head?: number[]; eyeAt?: number[] }): Shape;
+/** The house two tracks for the Track animals (26 wide, 48 apart). */
+export const DUO: TrackSet;
+/** Points drawn k times smaller about (300, 300). */
+export function sc(pts: Pts, k: number): Point[];
+/** A solid drawn k times smaller about (300, 300). */
+export function scaleS(g: Geom, k: number): Shape;
+/** Two tracks round a filleted outline. */
+export function loop2(o: Pts): Shape;
+/** Two tracks along an open line, round ends. */
+export function line2(pts: Pts): Shape;
+/** Where solids may sit inside a two-track loop. */
+export function inside(o: Pts): Shape;
+/** An ellipse head at the end of a line: [shape, centre, heading]. */
+export function endHead(pts: Pts, len: number, wid: number, ahead: number): [Polygon, Point, number];
+/** An eye as near (x, y) as the loop allows. */
+export function eyeIn(o: Pts, at: readonly number[], r?: number): Polygon;
+/** A two-track loop round a stadium. */
+export function stadium2(cx: number, cy: number, len: number, wid: number, deg?: number): Shape;
+/** A cloud loop's centreline from a ring of circles [x, y, r]. */
+export function cloud(cs: Pts, r?: number): Point[];
+/** A smooth closed outline through control points. */
+export function S(pts: Pts, n?: number): Polygon;
+/** A tapering round-ended stroke along a smooth curve. */
+export function taper(pts: Pts, w0: number, w1: number, n?: number): Shape;
+/** A cut g wide along a smooth curve, round ends. */
+export function seam(pts: Pts, g: number): Shape;
+/** A symmetric outline about x = cx from its right half. */
+export function mirror(half: Pts, cx?: number): Point[];
+/** Points on the circular arc from P to Q bulging h to the left. */
+export function bow(P: readonly number[], Q: readonly number[], h: number, n?: number): Point[];
+/** A sickle wing from root to tip and back. */
+export function sickle(p0: readonly number[], tip: readonly number[], p1: readonly number[], h0: number, h1: number): Polygon;
+/** The near wing over the body, parted by a straight cut across its root. */
+export function rootCut(body: Geom, wing: Geom, a: readonly number[], b: readonly number[], g: number): Shape;
+/** Cuts g wide square across a curve at fractions of its length. */
+export function bands(pts: Pts, ts: readonly number[], reach: number, g: number): Shape;
+/** A leg standing to the ground, its foot squared off flat. */
+export function flatLeg(hip: readonly number[], gy: number, w?: number, dir?: number, toe?: number, r?: number): Shape;
+/** A dog's bone, turned deg about its centre. */
+export function bone(cx: number, cy: number, L: number, w: number, r: number, deg?: number): Shape;
+/** A paw print: heel pad and four toe pads. */
+export function pawPrint(cx: number, cy: number, k?: number): Shape;
+/** A solid kept a gap clear of a loop's two tracks. */
+export function clearOf(solid: Geom, o: Pts): Shape;
+/** A shape moved by (dx, dy). */
+export function moved(sh: Shape, dx: number, dy: number): Shape;
+/** A closed polyline resampled to points `step` apart. */
+export function evenPts(pts: Pts, step: number): Point[];
+/** A ribbon loop's centreline round a spine, wf(t) wide. */
+export function ribbon(spine: Pts, wf: (t: number) => number, n?: number): Point[];
+/** Whether a point is inside a shape (even-odd). */
+export function inShape(sh: Geom, p: readonly number[]): boolean;
+/** A head side-on in headphones, as a build from the gap. */
+export function sidePhones(o: SidePhonesOptions): (g: number) => Shape;
+/** sidePhones() scaled, turned and moved, the gap kept. */
+export function wearPhones(o: SidePhonesOptions, k: number, dx: number, dy: number, deg?: number): (g: number) => Shape;
+/** Layers back to front, each laid over() the ones before by the gap. */
+export function layered(g: number, ...layers: Geom[]): Shape;
+/** A cat's or fox's head side-on, for sidePhones(). */
+export function pointyHead(s: number): { head: Shape; rimOn: Polygon; x1: number };
+/** ∪ : a shut eye for an animal side-on. */
+export function shut(x: number, y: number, r: number, w: number): Shape;
+/** A long head side-on (a goat's, a donkey's). */
+export function longBase(s?: number): Polygon;
+/** A bird's head side-on, facing right. */
+export const birdHead: Polygon;
+/** Four standing legs, each pair a leg's width plus the gap apart. */
+export function legs4(xb: number, xf: number, y0: number, y1: number, w: number, g: number): Shape;