@logomarks/core 0.1.9 → 0.2.0

package/src/forms/slats.js

@@ -0,0 +1,78 @@
+/**
+ * Turning slats: a row of flat slabs, each seen turning on its own axis, so the row reads as one panel opening, a page
+ * turning or a fan. A slab turned by τ (the sine of its turn, −1 to 1) shows a projected width of W·cos and keeps its
+ * edges upright; its near edge grows and its far edge shrinks by the perspective k (half-heights H/2 · (1 ± k·τ)), so
+ * its top and bottom edges slope towards the far side; τ > 0 turns the right edge away. The gaps are upright strips, so
+ * they stay exactly g, and no slab comes out narrower than wMin (an edge-on slab is a sliver, never a hairline).
+ * From the Logomarks tools (slatparts.mjs, batch 236, "Bold · Slats").
+ */
+import { poly, U } from '../geometry/index.js';
+
+/**
+ * The projected width of a slab of full width W turned by τ, never under wMin.
+ *
+ * @param {number} W The slab's full width.
+ * @param {number} tau The sine of its turn (−1 to 1).
+ * @param {number} wMin The narrowest it may show.
+ * @returns {number} Its projected width.
+ */
+export const turnWidth = (W, tau, wMin) => Math.max(wMin, W * Math.sqrt(Math.max(0, 1 - tau * tau)));
+
+/**
+ * A row of turning slabs, side by side with the gap g between every two, the row centred on x = cx. Each slab may carry
+ * its own full width W, height H and centre shift dy (a bowed row, or slabs shrinking along it); `align` stands every
+ * slab on one floor line ('base') or hangs it from one ('top').
+ *
+ * @param {readonly { tau: number, W?: number, H?: number, dy?: number }[]} slabs Each slab's turn, full width, full
+ *   height and centre shift.
+ * @param {{ W: number, H: number, k: number, g: number, wMin: number, cx?: number, cy?: number, align?: 'centre' | 'base' | 'top' }} o
+ *   The slabs' full width and height, the perspective k, the gap g, the narrowest slab wMin, the row's centre
+ *   (cx, cy; 256, 256) and how the slabs line up (centre).
+ * @returns {[number, number, number][][]} Each slab as its two edges [[x, top, bottom], [x, top, bottom]], left then right.
+ */
+export function slatRow(slabs, { W, H, k, g, wMin, cx = 256, cy = 256, align = 'centre' }) {
+	const ws = slabs.map((s) => turnWidth(s.W ?? W, s.tau, wMin)), total = ws.reduce((a, b) => a + b, 0) + g * (slabs.length - 1);
+	let x = cx - total / 2;
+	return slabs.map((s, i) => {
+		const h = s.H ?? H, c = cy + (s.dy ?? 0), hl = (h / 2) * (1 + k * s.tau), hr = (h / 2) * (1 - k * s.tau);
+		const edge = (xx, hh) => (align === 'base' ? [xx, c + h / 2 - 2 * hh, c + h / 2] : align === 'top' ? [xx, c - h / 2, c - h / 2 + 2 * hh] : [xx, c - hh, c + hh]);
+		const out = [edge(x, hl), edge(x + ws[i], hr)]; x += ws[i] + g; return out;
+	});
+}
+
+/**
+ * A slat row's slabs as one shape.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} row The row (slatRow()).
+ * @returns {import('../geometry/types.js').Shape} The slabs.
+ */
+export const quads = (row) => U(...row.map(([[x0, t0, b0], [x1, t1, b1]]) => poly([[x0, t0], [x1, t1], [x1, b1], [x0, b0]])));
+
+/**
+ * A slat row stood on its side as one shape: every point (x, y) becomes (y, x), so upright slabs turning on a vertical
+ * axis become flat ones turning on a horizontal axis.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} row The row (slatRow()).
+ * @returns {import('../geometry/types.js').Shape} The slabs.
+ */
+export const quadsT = (row) => U(...row.map(([[x0, t0, b0], [x1, t1, b1]]) => poly([[t0, x0], [t1, x1], [b1, x1], [b0, x0]])));
+
+/**
+ * n turns easing from a to b (a sine ease, so the turn speeds up through the middle).
+ *
+ * @param {number} n How many.
+ * @param {number} a The first.
+ * @param {number} b The last.
+ * @returns {number[]} The turns.
+ */
+export const ease = (n, a, b) => [...Array(n)].map((_, i) => a + ((b - a) * (1 - Math.cos((Math.PI * i) / (n - 1)))) / 2);
+
+/**
+ * n turns spaced evenly from a to b.
+ *
+ * @param {number} n How many.
+ * @param {number} a The first.
+ * @param {number} b The last.
+ * @returns {number[]} The turns.
+ */
+export const lerpN = (n, a, b) => [...Array(n)].map((_, i) => a + ((b - a) * i) / (n - 1));

package/src/forms/swash.d.ts

@@ -0,0 +1,23 @@
+import type { Point, Shape, Geom } from '../geometry/types.js';
+
+/** A swash's width and balls: swell()'s w0, w1, peak and pow, the balls' radii r0 and r1, or a width profile. */
+export interface SwashOptions {
+	w0?: number;
+	w1?: number;
+	peak?: number;
+	pow?: number;
+	r0?: number;
+	r1?: number;
+	width?: (t: number) => number;
+}
+
+/** The swash width profile: w0 at both ends swelling to w1 at `peak`. */
+export function swell(o?: { w0?: number; w1?: number; peak?: number; pow?: number }): (t: number) => number;
+/** A swash along a polyline, ball terminals r0 and r1. */
+export function swashAlong(p: readonly Point[], o?: SwashOptions): Shape;
+/** A swash along a turtle path (walk()). */
+export function swash(at: Point, deg: number, steps: readonly (['L', number] | ['A', number, number])[], o?: SwashOptions): Shape;
+/** A shape mirrored top to bottom across the canvas centre. */
+export function flipY(g: Geom): Geom;
+/** A quarter set into the top right and mirrored into four, each axis parted by g or joined. */
+export function swashQuad(q: Geom, g: number, o?: { x?: 'gap' | 'join'; y?: 'gap' | 'join'; join?: number }): Shape;

package/src/forms/swash.js

@@ -0,0 +1,74 @@
+/**
+ * Swashes: a calligraphic stroke along a turtle path or any polyline, thick in its bowl and thin at both ends, finished
+ * with ball terminals (walked as a turtle path, its curls turn smoothly); and the mirror layout that sets a quarter
+ * into four, each axis either joined or parted by exactly the gap. Drawn about the origin, y down.
+ * From the Logomarks tools (swashparts.mjs, batch 256).
+ */
+import { C, U, circle, walk, mapPts, flipX, move, bbox } from '../geometry/index.js';
+import { dense, taper } from '../parts/index.js';
+
+/**
+ * The swash's width profile: w0 at both ends swelling to w1 at `peak` (0 to 1 along it); `pow` sharpens the swell.
+ *
+ * @param {{ w0?: number, w1?: number, peak?: number, pow?: number }} [o] The end width (20), the widest (60), where it
+ *   is widest (0.55) and the swell's power (1.4).
+ * @returns {(t: number) => number} The width at t (0 to 1 along the swash).
+ */
+export const swell = ({ w0 = 20, w1 = 60, peak = 0.55, pow = 1.4 } = {}) => {
+	const e = Math.log(0.5) / Math.log(peak);
+	return (t) => w0 + (w1 - w0) * Math.sin(Math.PI * t ** e) ** pow;
+};
+
+/**
+ * A swash along any polyline (dense, open): its width `width(t)` (t from 0 to 1 along it; swell(o) unless given), a ball
+ * of radius r0 on its start and r1 on its end (0: none).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} p The polyline.
+ * @param {{ w0?: number, w1?: number, peak?: number, r0?: number, r1?: number, pow?: number, width?: (t: number) => number }} [o]
+ *   swell()'s options, the balls' radii (26, 28) and a width profile in its place.
+ * @returns {import('../geometry/types.js').Shape} The swash.
+ */
+export const swashAlong = (p, o = {}) => {
+	const { r0 = 26, r1 = 28, width = swell(o) } = o;
+	const parts = [taper(p, width)];
+	if (r0) parts.push(circle(...p[0], r0)); if (r1) parts.push(circle(...p.at(-1), r1));
+	return U(...parts);
+};
+
+/**
+ * A swash along a turtle path (the kit's walk(): from `at`, heading `deg`, through exact-radius turns), w0 wide at both
+ * ends swelling to w1 at `peak`, a ball of radius r0 on its start and r1 on its end (0: none); `width(t)` replaces the
+ * swell.
+ *
+ * @param {import('../geometry/types.js').Point} at The start.
+ * @param {number} deg The heading at the start (degrees, y down).
+ * @param {readonly (['L', number] | ['A', number, number])[]} steps The walk: runs and turns.
+ * @param {{ w0?: number, w1?: number, peak?: number, r0?: number, r1?: number, pow?: number, width?: (t: number) => number }} [o]
+ *   swashAlong()'s options.
+ * @returns {import('../geometry/types.js').Shape} The swash.
+ */
+export const swash = (at, deg, steps, o = {}) => swashAlong(dense(walk(at, deg, steps), 2, false), o);
+
+/**
+ * A shape mirrored top to bottom across the canvas centre.
+ *
+ * @param {import('../geometry/types.js').Geom} g The shape.
+ * @returns {import('../geometry/types.js').Geom} Its mirror.
+ */
+export const flipY = (g) => mapPts(g, ([x, y]) => [x, 2 * C - y]);
+
+/**
+ * A quarter (drawn anywhere) set into the top right of the canvas and mirrored into four. Each axis is either parted by
+ * exactly g (the copies' nearest points are their points nearest the axis, so the gap is twice that distance) or joined
+ * (the copies overlap by `join`).
+ *
+ * @param {import('../geometry/types.js').Geom} q The quarter.
+ * @param {number} g The gap.
+ * @param {{ x?: 'gap' | 'join', y?: 'gap' | 'join', join?: number }} [o] What each axis does (gap) and the overlap (6).
+ * @returns {import('../geometry/types.js').Shape} The four quarters.
+ */
+export const swashQuad = (q, g, { x = 'gap', y = 'gap', join = 6 } = {}) => {
+	const [x0, , , y1] = bbox(U(q));
+	const m = move(q, (x === 'gap' ? C + g / 2 : C - join) - x0, (y === 'gap' ? C - g / 2 : C + join) - y1);
+	const half = U(m, flipX(m)); return U(half, flipY(half));
+};

package/src/forms/tech.d.ts

@@ -0,0 +1,40 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+export { box } from '../util/vec.js';
+
+/** A parallelogram: bottom edge from (x, yb) w long, top edge h higher shifted dx. */
+export function para(x: number, yb: number, w: number, h: number, dx: number): Polygon;
+/** Points of the circle through a, m and b, from a through m to b. */
+export function arc3(a: readonly number[], m: readonly number[], b: readonly number[], n?: number): Point[];
+/** A concave star of n tips at radius R, its sides pulled towards radius rc. */
+export function star(n: number, R: number, rc?: number, deg?: number, tips?: readonly number[]): Polygon;
+/** A gap g wide across a star's arm at deg, d from the centre. */
+export function armCut(deg: number, d: number, g: number): Polygon;
+/** A folded ribbon B wide along pts, drawn as outlines t wide. */
+export function ribbon(pts: readonly Point[], B: number, t: number): Shape;
+/** Equal discs on a lattice of pitch p, the gap g between neighbours. */
+export function beads(cells: readonly (readonly number[])[], g: number, p?: number): Shape;
+/** √3 / 2. */
+export const H3: number;
+/** A bar w wide leaning `lean`° through (x, ym), cut flat at y0 and y1. */
+export function slash(x: number, ym: number, w: number, lean: number, y0: number, y1: number): Polygon;
+/** The lens marks' disc (radius 224, centred). */
+export function DISC(): Polygon;
+/** A lens gap from p to q, w wide at its middle. */
+export function lensGap(p: readonly number[], q: readonly number[], w: number): Polygon;
+/** A chevron: apex P, arms along A and B, w wide inward. */
+export function techChevron(P: readonly number[], A: readonly number[], B: readonly number[], w: number, L?: number): Polygon;
+/** A slab from a to b, its b end cut to a 90° point (a Keyed letter's key). */
+export function pointed(a: readonly number[], b: readonly number[], w: number): Polygon;
+/** The notched slab less the key grown by g, plus the key. */
+export function keyed(notched: Geom, key: Geom, g: number): Shape;
+/** The Kerf tile: a 448 square, corners rounded 78. */
+export function TILE(): Polygon;
+/** The folded ribbon letters' width (124). */
+export const RB: number;
+/** Their outline width once fitted (24). */
+export const RT: number;
+/** A folded ribbon letter along pts, as a build of the gap. */
+export function rib(pts: readonly Point[]): (g: number) => Shape;
+/** The four-point star the sparkles break. */
+export function SPARK(): Polygon;

package/src/forms/tech.js

@@ -0,0 +1,293 @@
+/**
+ * Bold tech parts: split sparkles, the folded ribbon (Folio), beads on a lattice, slashes, lens gaps, keyed chevrons and
+ * the Kerf tile. Angles are degrees, 0 right, 90 down. From the Logomarks tools (techparts.mjs, batch 213, "Bold · Tech",
+ * and its editions in batches 220 and 227).
+ */
+import { C, D, I, U, bar, circle, grow, poly, rad, rr, sample } from '../geometry/index.js';
+import { sub, add, mul } from '../util/vec.js';
+
+// A rectangle from its corners, box(x0, y0, x1, y1): the tech marks draw their bars with it.
+export { box } from '../util/vec.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 */
+
+/** Far enough to run a half plane off any canvas. */
+const BIG = 3000;
+
+/**
+ * A 2D vector at unit length.
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {Point} It, unit.
+ */
+const norm = (a) => { const l = Math.hypot(...a); return [a[0] / l, a[1] / l]; };
+
+/**
+ * A 2D vector turned a quarter (to its left on screen, y down).
+ *
+ * @param {readonly number[]} a The vector.
+ * @returns {Point} It, turned.
+ */
+const perp = (a) => [-a[1], a[0]];
+
+/**
+ * The dot product in 2D.
+ *
+ * @param {readonly number[]} a One vector.
+ * @param {readonly number[]} b The other.
+ * @returns {number} a · b.
+ */
+const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
+
+/**
+ * The cross product in 2D (its z).
+ *
+ * @param {readonly number[]} a One vector.
+ * @param {readonly number[]} b The other.
+ * @returns {number} a × b.
+ */
+const cross2 = (a, b) => a[0] * b[1] - a[1] * b[0];
+
+/**
+ * The half plane left of the directed line through p along d (left: the side `perp(d)` points to).
+ *
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} d Its direction.
+ * @returns {Polygon} The half plane.
+ */
+const half = (p, d) => {
+	const u = norm(d), n = perp(u);
+	return poly([add(p, mul(u, -BIG)), add(p, mul(u, BIG)), add(add(p, mul(u, BIG)), mul(n, BIG)), add(add(p, mul(u, -BIG)), mul(n, BIG))]);
+};
+
+/**
+ * The half plane on the side of the line (p, d) that holds the point q.
+ *
+ * @param {readonly number[]} p A point on the line.
+ * @param {readonly number[]} d Its direction.
+ * @param {readonly number[]} q The point to keep.
+ * @returns {Polygon} The half plane.
+ */
+const halfWith = (p, d, q) => (cross2(norm(d), sub(q, p)) * cross2(norm(d), perp(norm(d))) > 0 ? half(p, d) : half(p, mul(d, -1)));
+
+/**
+ * A parallelogram: its bottom edge from (x, yb) w long, its top edge h higher and shifted dx right.
+ *
+ * @param {number} x The bottom edge's left end.
+ * @param {number} yb The bottom edge's height.
+ * @param {number} w The width.
+ * @param {number} h The height.
+ * @param {number} dx The top edge's shift.
+ * @returns {Polygon} The parallelogram.
+ */
+export const para = (x, yb, w, h, dx) => poly([[x, yb], [x + w, yb], [x + w + dx, yb - h], [x + dx, yb - h]]);
+
+/**
+ * Points of the circle through a, m and b, from a through m to b.
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} m A point on the way.
+ * @param {readonly number[]} b The end.
+ * @param {number} [n=60] Steps.
+ * @returns {Point[]} The arc.
+ */
+export const arc3 = (a, m, b, n = 60) => {
+	const ax = a[0], ay = a[1], bx = m[0], by = m[1], cx = b[0], cy = b[1];
+	const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+	const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+	const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+	const r = Math.hypot(ax - ux, ay - uy), t = (p) => Math.atan2(p[1] - uy, p[0] - ux); let t0 = t(a), t1 = t(m), t2 = t(b);
+	const ccw = (x, y) => ((y - x) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI); // sweep from x to y anticlockwise (in y-down terms, increasing angle)
+	const s = ccw(t0, t1) < ccw(t0, t2) ? ccw(t0, t2) : ccw(t0, t2) - 2 * Math.PI;
+	return sample((u) => [ux + r * Math.cos(t0 + s * u), uy + r * Math.sin(t0 + s * u)], 0, 1, n);
+};
+
+/**
+ * The point at radius r and angle deg from a centre.
+ *
+ * @param {number} r The radius.
+ * @param {number} deg The angle.
+ * @param {readonly number[]} [c=[C, C]] The centre.
+ * @returns {Point} The point.
+ */
+const at = (r, deg, c = [C, C]) => [c[0] + r * Math.cos(rad(deg)), c[1] + r * Math.sin(rad(deg))];
+
+/**
+ * A concave star about the canvas centre: n tips at radius R (`tips` scales single tips), each side a quadratic curve
+ * pulled in towards a control point at radius rc on the mid angle (rc 0 pulls every side to the centre), so the sides meet
+ * the tips without crossing.
+ *
+ * @param {number} n The tips.
+ * @param {number} R Their radius.
+ * @param {number} [rc=0] The sides' control radius.
+ * @param {number} [deg=-90] The first tip's angle.
+ * @param {readonly number[]} [tips=[]] Per-tip radius factors.
+ * @returns {Polygon} The star.
+ */
+export const star = (n, R, rc = 0, deg = -90, tips = []) => {
+	const pts = [];
+	for (let i = 0; i < n; i++) {
+		const a = deg + (i * 360) / n, b = a + 360 / n, p0 = at(R * (tips[i] ?? 1), a), p1 = at(rc, a + 180 / n), p2 = at(R * (tips[(i + 1) % n] ?? 1), b);
+		pts.push(...sample((t) => [(1 - t) ** 2 * p0[0] + 2 * t * (1 - t) * p1[0] + t * t * p2[0], (1 - t) ** 2 * p0[1] + 2 * t * (1 - t) * p1[1] + t * t * p2[1]], 0, 1, 64).slice(0, -1));
+	}
+	return poly(pts);
+};
+
+/**
+ * A gap g wide across a star's arm at angle deg, d from the centre.
+ *
+ * @param {number} deg The arm's angle.
+ * @param {number} d The distance from the centre.
+ * @param {number} g The gap.
+ * @returns {Polygon} The cut.
+ */
+export const armCut = (deg, d, g) => {
+	const p = at(d, deg), u = [Math.cos(rad(deg)), Math.sin(rad(deg))], n = perp(u);
+	return bar(add(p, mul(n, -400)), add(p, mul(n, 400)), g);
+};
+
+/**
+ * A ribbon B wide along the polyline pts, drawn as outlines t wide. Each turn is a fold: the crease runs through the
+ * corner along the bisector of the two directions (so the outer corner is cut on it), and each later facet lies over the
+ * one before, hiding its lines. Ends are cut square. Every facet's outline is drawn t/2 inside it, and the silhouette's
+ * another t/2, so shared folds and the outer edge are all t wide.
+ *
+ * @param {readonly Point[]} pts The ribbon's centreline.
+ * @param {number} B Its width.
+ * @param {number} t The outline's width.
+ * @returns {Shape} The ribbon's lines.
+ */
+export const ribbon = (pts, B, t) => {
+	const n = pts.length - 1, v = [...Array(n)].map((_, i) => norm(sub(pts[i + 1], pts[i])));
+	const crease = (k) => (k === 0 ? perp(v[0]) : k === n ? perp(v[n - 1]) : (Math.hypot(...add(v[k - 1], v[k])) < 1e-6 ? perp(v[k]) : add(v[k - 1], v[k])));
+	const facets = v.map((u, i) => {
+		const a = pts[i], b = pts[i + 1], nn = perp(u);
+		const strip = poly([add(add(a, mul(u, -BIG)), mul(nn, -B / 2)), add(add(a, mul(u, BIG)), mul(nn, -B / 2)), add(add(a, mul(u, BIG)), mul(nn, B / 2)), add(add(a, mul(u, -BIG)), mul(nn, B / 2))]);
+		return I(strip, halfWith(a, crease(i), b), halfWith(b, crease(i + 1), a));
+	});
+	const vis = facets.map((f, i) => (i < n - 1 ? D(f, ...facets.slice(i + 1)) : f)); // what each facet shows under the later ones
+	const all = U(...facets), ring = (s, w) => D(s, grow(s, -w)); // a line w wide just inside the outline (sharp corners kept)
+	return U(ring(all, t / 2), ...vis.map((s) => ring(s, t / 2)));
+};
+
+/**
+ * Equal discs on a lattice of pitch p, the gap g between neighbours: cells as [col, row] in pitch units.
+ *
+ * @param {readonly (readonly number[])[]} cells The lattice points.
+ * @param {number} g The gap.
+ * @param {number} [p=130] The pitch.
+ * @returns {Shape} The beads.
+ */
+export const beads = (cells, g, p = 130) => U(...cells.map(([x, y]) => circle(x * p, y * p, (p - g) / 2, 160)));
+
+/** √3 / 2: a hexagonal lattice's row pitch, in pitch units. */
+export const H3 = Math.sqrt(3) / 2;
+
+/**
+ * A bar w wide leaning `lean`° right of upright, its centreline through (x, ym), cut flat at y0 and y1.
+ *
+ * @param {number} x The centreline's x at ym.
+ * @param {number} ym The height it passes x at.
+ * @param {number} w The width (square to the bar).
+ * @param {number} lean The lean, degrees.
+ * @param {number} y0 The top cut.
+ * @param {number} y1 The bottom cut.
+ * @returns {Polygon} The slash.
+ */
+export const slash = (x, ym, w, lean, y0, y1) => {
+	const t = Math.tan(rad(lean)), xa = (y) => x + (ym - y) * t, hw = w / 2 / Math.cos(rad(lean));
+	return poly([[xa(y1) - hw, y1], [xa(y1) + hw, y1], [xa(y0) + hw, y0], [xa(y0) - hw, y0]]);
+};
+
+/**
+ * The lens marks' disc: radius 224, centred, 720 points.
+ *
+ * @returns {Polygon} The disc.
+ */
+export const DISC = () => circle(C, C, 224, 720);
+
+/**
+ * A lens gap from p to q: two arcs bowing w apart at the middle and meeting at p and q (run it on past the rim).
+ *
+ * @param {readonly number[]} p One end.
+ * @param {readonly number[]} q The other.
+ * @param {number} w Its width at the middle.
+ * @returns {Polygon} The gap.
+ */
+export const lensGap = (p, q, w) => {
+	const m = mul(add(p, q), 0.5), n = perp(norm(sub(q, p)));
+	return poly([...arc3(p, add(m, mul(n, w / 2)), q, 60), ...arc3(q, add(m, mul(n, -w / 2)), p, 60).slice(1, -1)]);
+};
+
+/**
+ * A chevron: outer apex P, arms running out along A and B (directions from P), w wide inward; long, so a box clips the
+ * ends.
+ *
+ * @param {readonly number[]} P The apex.
+ * @param {readonly number[]} A One arm's direction.
+ * @param {readonly number[]} B The other's.
+ * @param {number} w The width.
+ * @param {number} [L=1400] The arms' length.
+ * @returns {Polygon} The chevron.
+ */
+export const techChevron = (P, A, B, w, L = 1400) => {
+	const u1 = norm(A), u2 = norm(B), bis = norm(add(u1, u2)), th = Math.acos(dot2(u1, u2));
+	const side = (u, o) => { const n = perp(u); return dot2(n, o) > 0 ? n : mul(n, -1); }, n1 = side(u1, u2), n2 = side(u2, u1);
+	const Q = add(P, mul(bis, w / Math.sin(th / 2)));
+	return poly([P, add(P, mul(u1, L)), add(add(P, mul(u1, L)), mul(n1, w)), Q, add(add(P, mul(u2, L)), mul(n2, w)), add(P, mul(u2, L))]);
+};
+
+/**
+ * A slab w wide from a to b whose b end is cut to a 90° point (two 45° chamfers): the key of a Keyed letter.
+ *
+ * @param {readonly number[]} a The square end.
+ * @param {readonly number[]} b The point.
+ * @param {number} w The width.
+ * @returns {Polygon} The slab.
+ */
+export const pointed = (a, b, w) => {
+	const u = norm(sub(b, a)), n = perp(u), h = w / 2, back = add(b, mul(u, -h));
+	return poly([add(a, mul(n, h)), add(back, mul(n, h)), b, add(back, mul(n, -h)), add(a, mul(n, -h))]);
+};
+
+/**
+ * Two Keyed slabs parted: the notched slab loses the key grown by g, so the gap is even round the point.
+ *
+ * @param {Geom} notched The slab the key goes into.
+ * @param {Geom} key The key.
+ * @param {number} g The gap.
+ * @returns {Shape} Both.
+ */
+export const keyed = (notched, key, g) => U(D(notched, grow(key, g)), key);
+
+/**
+ * The Kerf tile: a 448 square from the origin, its corners rounded 78 (about 17%: a rounded square, never a squircle).
+ *
+ * @returns {Polygon} The tile.
+ */
+export const TILE = () => rr(0, 0, 448, 448, 78);
+
+/** The folded ribbon letters' width. */
+export const RB = 124;
+
+/** The folded ribbon letters' outline width once fitted. */
+export const RT = 24;
+
+/**
+ * A folded ribbon letter along pts, RB wide, its outline RT wide once fitted.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @returns {(g: number) => Shape} The build of the gap.
+ */
+export const rib = (pts) => (g) => ribbon(pts, RB, (g * RT) / 22);
+
+/**
+ * The four-point star both sparkles break: radius 224, its sides pulled to a control point 40 out, so the arms stay
+ * chunky.
+ *
+ * @returns {Polygon} The star.
+ */
+export const SPARK = () => star(4, 224, 40);

package/src/forms/tracks.d.ts

@@ -0,0 +1,36 @@
+import type { Point, Ring, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** The source-unit helpers trackKit(K) returns. */
+export interface TrackKit {
+	/** A solid built in source units, drawn K larger. */
+	S(g: Geom): Geom;
+	/** A loop's centreline: a region's boundary, corners rounded r1 (inner) and r2 (outer), resampled evenly. */
+	ring(region: Geom, r1?: number, r2?: number): Point[];
+	/** A solid cut a house gap clear of tracks. */
+	off(sol: Geom, ...tracks: Geom[]): Shape;
+	/** A solid kept only outside a loop's centreline, a gap clear of its outer track. */
+	out(sol: Geom, o: Point[]): Shape;
+	/** A solid kept only inside a loop's centreline, a gap clear of the inner track. */
+	within(sol: Geom, o: Point[]): Shape;
+}
+
+/** Source units to drawing units, for the fixed-K editions (1.6). */
+export const TRACK_K: number;
+/** A closed ring resampled every `step` along its length. */
+export function evenRing(o: readonly Point[], step?: number): Point[];
+/** The source-unit helpers at a fixed K. */
+export function trackKit(K?: number): TrackKit;
+/** A closed region from a radius function round (cx, cy), every 2 degrees. */
+export function radial(cx: number, cy: number, f: (a: number) => number): Polygon;
+/** A drop pointing up: a disc of radius r at (x, y), its point h above the centre. */
+export function drop(x: number, y: number, r: number, h: number): Shape;
+/** A shape's area: outer rings less their holes. */
+export function sArea(s: Shape): number;
+/** Whether a point lies inside a ring (even-odd). */
+export function inRing(r: readonly Point[], p: readonly number[]): boolean;
+/** A ring's box centre. */
+export function mid(r: Ring): Point;
+/** The largest outer ring of a shape, its closing point dropped. */
+export function largest(s: Shape): Point[];
+/** A cut shape's parts, less any piece under `min`. */
+export function parts2(s: Shape, min?: number): Shape;

package/src/forms/tracks.js

@@ -0,0 +1,121 @@
+/**
+ * Track editions: a mark redrawn as two-track loops (the kit's trackLoop with the house Duo, the gap between the tracks)
+ * round its solid parts. A source is drawn in source units and scaled K into drawing units; trackKit(K) gives the
+ * source-unit helpers at a fixed K, and the rest split a live source into its parts.
+ * From the Logomarks tools (trackparts.mjs, the helpers every Track edition generator had copied; shared since Drop 35).
+ */
+import { U, D, I, poly, circle, grow, scale, soften, area, bbox } from '../geometry/index.js';
+import { inside } from '../objects/animals.js';
+
+/** Source units to drawing units, for the editions drawn at a fixed K. */
+export const TRACK_K = 1.6;
+
+/**
+ * A closed ring resampled every `step` along its length (soften()'s rings crowd points at the arcs, and two points a
+ * hair apart turn a track's offset normals: the loop frays).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} o The ring (open: its first point not repeated).
+ * @param {number} [step=6] The spacing.
+ * @returns {import('../geometry/types.js').Point[]} The resampled ring.
+ */
+export function evenRing(o, step = 6) {
+	const n = o.length, seg = o.map((p, i) => Math.hypot(o[(i + 1) % n][0] - p[0], o[(i + 1) % n][1] - p[1])), L = seg.reduce((a, b) => a + b, 0), m = Math.round(L / step), out = [];
+	let i = 0, acc = 0;
+	for (let k = 0; k < m; k++) { const d = (k * L) / m; while (acc + seg[i] < d) acc += seg[i++]; const t = seg[i] ? (d - acc) / seg[i] : 0, a = o[i], b = o[(i + 1) % n]; out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]); }
+	return out;
+}
+
+/**
+ * The source-unit helpers at a fixed K:
+ *
+ * - `S(g)`: a solid built in source units, drawn K larger;
+ * - `ring(region, r1, r2)`: a loop's centreline, the boundary of a region drawn in source units, its inner corners
+ *   rounded r1 and outer r2 (drawing units, 60 or more): the largest ring, its closing point dropped, resampled evenly;
+ * - `off(sol, ...tracks)`: a solid (source units) cut a house gap clear of tracks (drawing units);
+ * - `out(sol, o)`: a solid (source units) kept only outside a loop's centreline o, a gap clear of its outer track;
+ * - `within(sol, o)`: a solid (source units) kept only inside a loop's centreline o, a gap clear of the inner track.
+ *
+ * @param {number} [K=TRACK_K] Source units to drawing units.
+ * @returns {{ S: (g: import('../geometry/types.js').Geom) => import('../geometry/types.js').Geom, ring: (region: import('../geometry/types.js').Geom, r1?: number, r2?: number) => import('../geometry/types.js').Point[], off: (sol: import('../geometry/types.js').Geom, ...tracks: import('../geometry/types.js').Geom[]) => import('../geometry/types.js').Shape, out: (sol: import('../geometry/types.js').Geom, o: import('../geometry/types.js').Point[]) => import('../geometry/types.js').Shape, within: (sol: import('../geometry/types.js').Geom, o: import('../geometry/types.js').Point[]) => import('../geometry/types.js').Shape }}
+ *   The helpers.
+ */
+export const trackKit = (K = TRACK_K) => {
+	const S = (g) => scale(g, K, 0, 0);
+	const ring = (region, r1 = 64, r2 = 64) => {
+		const g = soften(S(region), r1, r2), area = (r) => Math.abs(r.reduce((s, p, i) => { const q = r[(i + 1) % r.length]; return s + p[0] * q[1] - q[0] * p[1]; }, 0));
+		let best = null; for (const pg of g) if (!best || area(pg[0]) > area(best)) best = pg[0];
+		const o = best.slice(); if (Math.hypot(o[0][0] - o.at(-1)[0], o[0][1] - o.at(-1)[1]) < 0.01) o.pop(); return evenRing(o);
+	};
+	const off = (sol, ...trs) => D(S(sol), grow(U(...trs), 22));
+	const out = (sol, o) => D(S(sol), grow(poly(o), 37 + 22));
+	const within = (sol, o) => I(S(sol), inside(o));
+	return { S, ring, off, out, within };
+};
+
+/**
+ * A closed region from a radius function round (cx, cy), sampled every 2 degrees.
+ *
+ * @param {number} cx The centre.
+ * @param {number} cy The centre.
+ * @param {(a: number) => number} f The radius at the angle a (radians).
+ * @returns {import('../geometry/types.js').Polygon} The region.
+ */
+export const radial = (cx, cy, f) => poly(Array.from({ length: 180 }, (_, i) => { const a = (i * 2 * Math.PI) / 180, r = f(a); return [cx + r * Math.cos(a), cy + r * Math.sin(a)]; }));
+
+/**
+ * A drop pointing up: a disc of radius r at (x, y) and its point h above the centre.
+ *
+ * @param {number} x The disc's centre.
+ * @param {number} y The disc's centre.
+ * @param {number} r Its radius.
+ * @param {number} h How far above the centre the point is.
+ * @returns {import('../geometry/types.js').Shape} The drop.
+ */
+export const drop = (x, y, r, h) => { const t = Math.asin(r / h); return U(circle(x, y, r), poly([[x, y - h], [x + r * Math.cos(t), y - r * Math.sin(t)], [x - r * Math.cos(t), y - r * Math.sin(t)]])); };
+
+/* ---------- splitting a live source ---------- */
+
+/**
+ * A shape's area: its outer rings less their holes.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @returns {number} The area.
+ */
+export const sArea = (s) => s.reduce((t, pg) => t + area(pg[0]) - pg.slice(1).reduce((h, r) => h + area(r), 0), 0);
+
+/**
+ * Whether a point lies inside a ring (even-odd).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} r The ring.
+ * @param {readonly number[]} p The point.
+ * @returns {boolean} True inside.
+ */
+export const inRing = (r, [px, py]) => { let c = false; 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 ring's box centre.
+ *
+ * @param {import('../geometry/types.js').Ring} r The ring.
+ * @returns {import('../geometry/types.js').Point} The centre of its box.
+ */
+export const mid = (r) => { const [x0, y0, x1, y1] = bbox([[r]]); return [(x0 + x1) / 2, (y0 + y1) / 2]; };
+
+/**
+ * The largest outer ring of a shape, its closing point dropped.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @returns {import('../geometry/types.js').Point[]} The ring.
+ */
+export const largest = (s) => {
+	let best = null; for (const pg of s) if (!best || area(pg[0]) > area(best)) best = pg[0];
+	const o = best.slice(); if (Math.hypot(o[0][0] - o.at(-1)[0], o[0][1] - o.at(-1)[1]) < 0.01) o.pop(); return o;
+};
+
+/**
+ * A cut shape's parts, less any piece under `min` (drawing units): a limb's stub left between two cuts.
+ *
+ * @param {import('../geometry/types.js').Shape} s The cut shape.
+ * @param {number} [min=1000] The smallest piece kept.
+ * @returns {import('../geometry/types.js').Shape} The parts.
+ */
+export const parts2 = (s, min = 1000) => s.filter((pg) => area(pg[0]) >= min);