@logomarks/core 0.1.9 → 0.2.0

package/src/objects/faces.js

@@ -0,0 +1,344 @@
+/**
+ * Faces and mascots. A face's features are drawn for a face of radius R round (0, 0), clustered up and to the right (a
+ * glance, never the centred stock smiley) and parted by the gap; frame() sets the eye radius and the mouth stroke,
+ * snapped to the gap when they come near it. A mascot is an everyday object as a character: two dot eyes knocked out
+ * (eyes()), stick limbs at least the house stroke (LIMB), headphones laid over a head. From the Logomarks tools
+ * (facesparts.mjs, batches 266, 273, 283, 293, 296, 305, 313).
+ */
+import { U, D, I, circle, rect, rr, poly, stroke, arcPts, linePts, rot, roundPoly, pill, grown, over, lens } from '../geometry/index.js';
+import { spline } from '../parts/index.js';
+
+/**
+ * An open arc as a round-capped stroke.
+ *
+ * @param {number} cx The centre, x.
+ * @param {number} cy The centre, y.
+ * @param {number} r The radius.
+ * @param {number} a0 From, in degrees (0 = right, 90 = down).
+ * @param {number} a1 To, in degrees.
+ * @param {number} w The stroke.
+ * @returns {import('../geometry/types.js').Shape} The arc.
+ */
+export const arc = (cx, cy, r, a0, a1, w) => stroke(arcPts(cx, cy, r, a0, a1, 48), w, { roundCaps: true });
+
+/**
+ * A round-capped stroke along a smooth curve through pts (a straight one for two points).
+ *
+ * @param {readonly (readonly number[])[]} pts The knots.
+ * @param {number} w The stroke.
+ * @returns {import('../geometry/types.js').Shape} The limb.
+ */
+export const limb = (pts, w) => stroke(pts.length > 2 ? spline(pts, 16) : linePts(pts[0], pts[1], 12), w, { roundCaps: true });
+
+/**
+ * A half-disc hole with its flat side on top at y, centred on x, radius r (a grin).
+ *
+ * @param {number} x The centre, x.
+ * @param {number} y The flat side, y.
+ * @param {number} r The radius.
+ * @returns {import('../geometry/types.js').Shape} The grin.
+ */
+export const grinHole = (x, y, r) => I(circle(x, y, r, 160), rect(x - r - 2, y, 2 * r + 4, r + 4));
+
+/**
+ * A face's frame for radius R: the eye radius e, the mouth stroke w (and aw for shut eyes), each exactly the gap when it
+ * would come near it (so a small face's features read as the gap, not an uneven one), and the eyes' centres: a glance, up
+ * and to the right, the eyes parted by exactly the gap.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('./faces.js').FaceFrame} The frame.
+ */
+export const frame = (R, g) => {
+	const e = Math.max(0.15 * R, 15), w = 0.17 * R < 1.4 * g ? g : 0.17 * R, cx = 0.17 * R, ey = -0.27 * R;
+	return { e, w, aw: 0.9 * w < 1.4 * g ? g : 0.9 * w, ey, x1: cx - e - g / 2, x2: cx + e + g / 2, cx };
+};
+
+/**
+ * The comma smile: a short hook starting under the right eye, turning down and back to the left.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @param {import('./faces.js').FaceFrame} f The face's frame().
+ * @returns {import('../geometry/types.js').Shape} The smile.
+ */
+export const hook = (R, g, f) => arc(f.cx + 0.02 * R, f.ey + f.e + g + 0.1 * R, 0.26 * R, -20, 110, f.w);
+
+/**
+ * Where shut eyes sit: arcs are wider than dots, so their centres are parted for the arcs' ends to sit a gap apart.
+ *
+ * @param {import('./faces.js').FaceFrame} f The face's frame().
+ * @param {number} g The gap.
+ * @returns {number[]} The two centres, x.
+ */
+export const arcXs = (f, g) => { const h = f.e * 1.05 * Math.cos(Math.PI / 9) + f.aw / 2 + g / 2; return [f.cx - h, f.cx + h]; };
+
+/**
+ * ^ : a closed, happy eye at (x, y).
+ *
+ * @param {number} x The eye, x.
+ * @param {number} y The eye, y.
+ * @param {import('./faces.js').FaceFrame} f The face's frame().
+ * @returns {import('../geometry/types.js').Shape} The eye.
+ */
+export const happyEye = (x, y, f) => arc(x, y + f.e * 0.55, f.e * 1.05, 200, 340, f.aw);
+
+/**
+ * ∪ : a closed, sleeping eye at (x, y).
+ *
+ * @param {number} x The eye, x.
+ * @param {number} y The eye, y.
+ * @param {import('./faces.js').FaceFrame} f The face's frame().
+ * @returns {import('../geometry/types.js').Shape} The eye.
+ */
+export const shutEye = (x, y, f) => arc(x, y - f.e * 0.45, f.e * 1.05, 20, 160, f.aw);
+
+/**
+ * Glance, the set's face: two dots and the comma smile.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Geom[]} The features.
+ */
+export const glance = (R, g) => { const f = frame(R, g); return [circle(f.x1, f.ey, f.e), circle(f.x2, f.ey, f.e), hook(R, g, f)]; };
+
+/**
+ * Laugh: both eyes shut happy over the wide mouth.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape[]} The features.
+ */
+export const laugh = (R, g) => { const f = frame(R, g), [a, b] = arcXs(f, g); return [happyEye(a, f.ey, f), happyEye(b, f.ey, f), grinHole(f.cx, f.ey + f.e + g, 0.36 * R)]; };
+
+/**
+ * A five-point star, point up, outer radius r.
+ *
+ * @param {number} x The centre, x.
+ * @param {number} y The centre, y.
+ * @param {number} r The outer radius.
+ * @param {number} [k=0.48] The inner radius as a fraction of r.
+ * @returns {import('../geometry/types.js').Polygon} The star.
+ */
+export const star = (x, y, r, k = 0.48) => poly([...Array(10)].map((_, i) => { const a = (i * 36 - 90) * Math.PI / 180, q = i % 2 ? r * k : r; return [x + q * Math.cos(a), y + q * Math.sin(a)]; }));
+
+/**
+ * Kiss: both eyes shut happy over a puckered 3.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape[]} The features.
+ */
+export const kiss = (R, g) => {
+	const f = frame(R, g), [a, b] = arcXs(f, g), r = 0.075 * R + f.w / 4, y = f.ey + f.e + g + f.w / 2 + 0.1 * R + r, x = f.cx - 0.02 * R;
+	return [happyEye(a, f.ey, f), happyEye(b, f.ey, f), arc(x, y, r, -100, 90, f.w), arc(x, y + 2 * r, r, -90, 100, f.w)];
+};
+
+/**
+ * Starstruck: two stars for eyes over the wide mouth.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Geom[]} The features.
+ */
+export const starstruck = (R, g) => {
+	const f = frame(R, g), r = f.e * 1.55, h = 0.95 * r + g / 2, y = f.ey - 0.02 * R;
+	return [star(f.cx - h, y, r), star(f.cx + h, y, r), grinHole(f.cx, y + 0.81 * r + g, 0.34 * R)];
+};
+
+/**
+ * Hmm: one brow raised over the right eye, a short flat mouth pushed to the side.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Geom[]} The features.
+ */
+export const hmm = (R, g) => {
+	const f = frame(R, g), y = f.ey + f.e + g + f.w / 2 + 0.1 * R, ey = f.ey + 0.03 * R, bc = ey + 0.6 * f.e, rb = 1.6 * f.e + g + f.w / 2;
+	return [circle(f.x1, ey, f.e), circle(f.x2, ey, f.e), arc(f.x2 + 0.02 * R, bc, rb, 238, 302, f.w),
+		limb([[f.cx + 0.02 * R, y], [f.cx + 0.26 * R, y - 0.05 * R]], f.w)];
+};
+
+/**
+ * Zipped: two dots over a zip, a slot with teeth across it and the pull hanging off its end.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Polygon[]} The features.
+ */
+export const zipped = (R, g) => {
+	const f = frame(R, g), y = f.ey + f.e + g + 0.18 * R, x0 = f.cx - 0.3 * R, x1 = f.cx + 0.22 * R, n = 4, p = 2 * g, t = 0.11 * R;
+	const xs = [...Array(n)].map((_, i) => x0 + g + i * p);
+	return [circle(f.x1, f.ey, f.e), circle(f.x2, f.ey, f.e), rect(x0, y - g / 2, x1 - x0, g), ...xs.map((x) => rect(x, y - t, g, 2 * t)),
+		rr(x1 - g * 0.2, y - g / 2, 0.14 * R, 0.2 * R, g * 0.6)];
+};
+
+/**
+ * Dizzy: two spirals for eyes, a wavy mouth.
+ *
+ * @param {number} R The face's radius.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape[]} The features.
+ */
+export const dizzy = (R, g) => {
+	const f = frame(R, g), r = 0.27 * R, h = r + g / 2, y = f.ey + 0.04 * R;
+	const spiral = (x, s) => stroke([...Array(80)].map((_, i) => { const t = i / 79, a = s * (t * 1.75 * 2 * Math.PI) - Math.PI / 2, q = g * 0.25 + t * (r - g / 2 - g * 0.25);
+		return [x + q * Math.cos(a), y + q * Math.sin(a)]; }), g, { roundCaps: true });
+	const my = y + r + g + 0.12 * R, wave = [...Array(40)].map((_, i) => { const t = i / 39; return [f.cx - 0.24 * R + t * 0.48 * R, my + 0.045 * R * Math.sin(t * 4 * Math.PI)]; });
+	return [spiral(f.cx - h, 1), spiral(f.cx + h, 1), stroke(wave, g, { roundCaps: true })];
+};
+
+/** A mascot's stick limbs: at least the house stroke. */
+export const LIMB = 30;
+
+/**
+ * Two dot eyes, parted by the gap, at (x, y): knock them out of a body.
+ *
+ * @param {number} g The gap.
+ * @param {number} x Their middle, x.
+ * @param {number} y Their middle, y.
+ * @param {number} [e=21] Their radius.
+ * @returns {import('../geometry/types.js').Polygon[]} The eyes.
+ */
+export const eyes = (g, x, y, e = 21) => [circle(x - e - g / 2, y, e), circle(x + e + g / 2, y, e)];
+
+/**
+ * Two stick legs under a body whose bottom is at y, centred on x.
+ *
+ * @param {number} x Their middle, x.
+ * @param {number} y The body's bottom.
+ * @param {number} [d=46] Each leg's distance from the middle.
+ * @param {number} [L=64] Their length below the body.
+ * @returns {import('../geometry/types.js').Shape[]} The legs.
+ */
+export const legs = (x, y, d = 46, L = 64) => [limb([[x - d, y - 10], [x - d, y + L]], LIMB), limb([[x + d, y - 10], [x + d, y + L]], LIMB)];
+
+/**
+ * A mascot's pose: a waving arm on the left (up) and a hanging arm on the right, from shoulders at (±x, y).
+ *
+ * @param {number} x The shoulders' distance from the middle.
+ * @param {number} y The shoulders, y.
+ * @returns {import('../geometry/types.js').Shape[]} The arms.
+ */
+export const arms = (x, y) => [limb([[-x, y], [-x - 65, y - 25], [-x - 85, y - 95]], LIMB), limb([[x, y + 10], [x + 50, y + 55], [x + 52, y + 115]], LIMB)];
+
+/**
+ * A body with two dot eyes knocked out at (x, y).
+ *
+ * @param {import('../geometry/types.js').Geom} body The body.
+ * @param {number} g The gap.
+ * @param {number} x The eyes' middle, x.
+ * @param {number} y The eyes' middle, y.
+ * @param {number} [e] Their radius (eyes()'s 21 when left out).
+ * @returns {import('../geometry/types.js').Shape} The body.
+ */
+export const eyed = (body, g, x, y, e) => D(body, ...eyes(g, x, y, e));
+
+/**
+ * A waving arm from the shoulder (x, y), up and out to the side s (−1 left, 1 right).
+ *
+ * @param {number} x The shoulder, x.
+ * @param {number} y The shoulder, y.
+ * @param {number} [s=-1] The side.
+ * @returns {import('../geometry/types.js').Shape} The arm.
+ */
+export const waveArm = (x, y, s = -1) => limb([[x, y], [x + s * 65, y - 25], [x + s * 85, y - 95]], LIMB);
+
+/**
+ * A hanging arm from the shoulder (x, y), down and out to the side s.
+ *
+ * @param {number} x The shoulder, x.
+ * @param {number} y The shoulder, y.
+ * @param {number} [s=1] The side.
+ * @returns {import('../geometry/types.js').Shape} The arm.
+ */
+export const hang = (x, y, s = 1) => limb([[x, y], [x + s * 50, y + 45], [x + s * 52, y + 105]], LIMB);
+
+/**
+ * A pointed leaf from its base point (x, y), at deg (0 = right, −90 = up), length L and width W: a lemon's, a pineapple's
+ * crown, a carrot's top.
+ *
+ * @param {number} x The base, x.
+ * @param {number} y The base, y.
+ * @param {number} deg The direction, in degrees.
+ * @param {number} L The length.
+ * @param {number} W The width.
+ * @returns {import('../geometry/types.js').Shape} The leaf.
+ */
+export const leaf = (x, y, deg, L, W) => { const a = deg * Math.PI / 180; return lens(x + Math.cos(a) * L / 2, y + Math.sin(a) * L / 2, L, W, deg); };
+
+/**
+ * Headphones about (cx, cy): a band bw wide over the top along an ellipse rx × ry, from angle a0 round to a1 (degrees,
+ * 180 → 360 is the top half, y down), each end running straight down by `foot` (none when 0) into a cup cw wide and ch
+ * tall with round ends, centred under the end, its top at y = cy + top. Lay it over() the head.
+ *
+ * @param {{ rx: number, ry?: number, cx?: number, cy?: number, bw?: number, cw?: number, ch?: number, top?: number, foot?: number, a0?: number, a1?: number }} o The headphones.
+ * @returns {import('../geometry/types.js').Shape} The headphones.
+ */
+export const headphones = ({ rx, ry = rx, cx = 0, cy = 0, bw = 40, cw = 72, ch = 150, top = -20, foot = 0, a0 = 180, a1 = 360 }) => {
+	const pts = [...Array(91)].map((_, i) => { const t = ((a0 + ((a1 - a0) * i) / 90) * Math.PI) / 180; return [cx + rx * Math.cos(t), cy + ry * Math.sin(t)]; });
+	const [p, q] = [pts[0], pts[90]], run = foot > 0 ? [[[p[0], p[1] + foot]], [[q[0], q[1] + foot]]] : [[], []];
+	const cup = (x) => rr(x - cw / 2, cy + top, cw, ch, cw / 2);
+	return U(stroke([...run[0], ...pts, ...run[1]], bw), cup(p[0]), cup(q[0]));
+};
+
+/**
+ * ∪ : a shut, blissful eye (lids bowed down), e its size, w the lid's width.
+ *
+ * @param {number} x The eye, x.
+ * @param {number} y The eye, y.
+ * @param {number} e Its size.
+ * @param {number} w The lid's width.
+ * @returns {import('../geometry/types.js').Shape} The eye.
+ */
+export const lid = (x, y, e, w) => arc(x, y - e * 0.45, e * 1.05, 20, 160, w);
+
+/**
+ * A focused eye for a gamer mascot: a disc with its top cut away on a slant falling towards the face's middle.
+ *
+ * @param {number} x The eye, x.
+ * @param {number} y The eye, y.
+ * @param {number} e Its radius.
+ * @param {number} s The side: −1 left, 1 right.
+ * @param {number} [deg=24] The slant, in degrees.
+ * @returns {import('../geometry/types.js').Shape} The eye.
+ */
+export const focusEye = (x, y, e, s, deg = 24) => I(circle(x, y, e, 120), rot(rect(x - 3 * e, y - 0.15 * e, 6 * e, 3 * e), s * -deg, x, y - 0.15 * e));
+
+/**
+ * A nose: a rounded triangle point down, w across and h tall, its top at y.
+ *
+ * @param {number} x Its middle, x.
+ * @param {number} y Its top.
+ * @param {number} w Its width.
+ * @param {number} h Its height.
+ * @param {number} [r=0.3*w] The corner radius.
+ * @returns {import('../geometry/types.js').Polygon} The nose.
+ */
+export const nose = (x, y, w, h, r = 0.3 * w) => roundPoly([[x - w / 2, y], [x + w / 2, y], [x, y + h]], [r, r, 0.6 * r]);
+
+/**
+ * A mic boom off a headphone cup: a stroke w wide through pts ending in a capsule mic m long and mw wide along its last run.
+ *
+ * @param {readonly (readonly number[])[]} pts The boom's knots, cup first.
+ * @param {number} w The boom's width.
+ * @param {number} [m=64] The mic's length.
+ * @param {number} [mw=46] The mic's width.
+ * @returns {import('../geometry/types.js').Shape} The boom and mic.
+ */
+export const micBoom = (pts, w, m = 64, mw = 46) => {
+	const a = pts.at(-2), b = pts.at(-1), L = Math.hypot(b[0] - a[0], b[1] - a[1]), u = [(b[0] - a[0]) / L, (b[1] - a[1]) / L];
+	return U(limb(pts, w), pill([b[0] - u[0] * (m / 2 - mw / 2), b[1] - u[1] * (m / 2 - mw / 2)], [b[0] + u[0] * (m / 2 - mw / 2), b[1] + u[1] * (m / 2 - mw / 2)], mw));
+};
+
+/**
+ * A head wearing the phones `P` (headphones()): the head cut round them by the gap; `front` (ears, tufts, a fin) sits in
+ * front of the band, which is cut round it by the gap and so runs behind it.
+ *
+ * @param {import('../geometry/types.js').Geom} head The head.
+ * @param {import('../geometry/types.js').Geom} P The headphones.
+ * @param {number} g The gap.
+ * @param {import('../geometry/types.js').Geom} [front] What stands in front of the band.
+ * @returns {import('../geometry/types.js').Shape} The head in headphones.
+ */
+export const wearFront = (head, P, g, front) => { const p = front ? D(P, grown(front, g)) : P; return front ? U(D(head, grown(p, g)), p, front) : over(head, p, g); };

package/src/objects/food.d.ts

@@ -0,0 +1,12 @@
+import type { Point, Polygon, Shape } from '../geometry/types.js';
+
+/** A point r from (cx, cy) at deg (0 = right, 90 = down). */
+export function at(r: number, deg: number, cx?: number, cy?: number): Point;
+/** A closed smooth outline through a right half's knots, mirrored to the left. */
+export function symmetric(half: readonly (readonly number[])[], n?: number): Polygon;
+/** A wavy centreline from a to b. */
+export function wave(a: readonly number[], b: readonly number[], amp: number, waves: number, n?: number, phase?: number): Point[];
+/** A bowl seen from above: its body and its surface, parted by a ring of gap. */
+export function bowlTop(g: number, o?: { rx?: number; ry?: number; depth?: number; top?: number; rim?: number; rimY?: number }): { body: Shape; surface: Polygon };
+/** A tongue of flame h tall standing on (cx, cy), its point leaning. */
+export function flameTongue(cx: number, cy: number, h: number, lean?: number): Polygon;

package/src/objects/food.js

@@ -0,0 +1,74 @@
+/**
+ * Food: the outlines and pieces dish marks share (a bowl seen from above, a symmetric outline, a wavy line, a tongue of
+ * flame). Every part is drawn about the origin (y down); a part that parts anything takes the gap g, so exact() keeps it
+ * 22 once fitted. From the Logomarks tools (foodparts.mjs, batches 159, 161, 165).
+ */
+import { D, poly, ellipse, sample, grown } from '../geometry/index.js';
+import { splineClosed } from '../parts/index.js';
+
+/**
+ * A point r from (cx, cy) at `deg` (0 = right, 90 = down).
+ *
+ * @param {number} r The distance.
+ * @param {number} deg The direction, in degrees.
+ * @param {number} [cx=0] The centre, x.
+ * @param {number} [cy=0] The centre, y.
+ * @returns {import('../geometry/types.js').Point} The point.
+ */
+export const at = (r, deg, cx = 0, cy = 0) => [cx + r * Math.cos((deg * Math.PI) / 180), cy + r * Math.sin((deg * Math.PI) / 180)];
+
+/**
+ * A symmetric object: a closed smooth outline through a right half's knots (top to bottom, x ≥ 0), mirrored to the left.
+ *
+ * @param {readonly (readonly number[])[]} half The right half's knots, top to bottom.
+ * @param {number} [n=16] Spline points a span.
+ * @returns {import('../geometry/types.js').Polygon} The outline.
+ */
+export const symmetric = (half, n = 16) => poly(splineClosed([...half, ...half.slice(1, -1).reverse().map(([x, y]) => [-x, y])], n));
+
+/**
+ * A wavy centreline from a to b: `amp` either side, `waves` full periods, `phase` in periods.
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} b The end.
+ * @param {number} amp The amplitude.
+ * @param {number} waves Full periods along it.
+ * @param {number} [n=80] Steps.
+ * @param {number} [phase=0] The phase, in periods.
+ * @returns {import('../geometry/types.js').Point[]} The line.
+ */
+export const wave = (a, b, amp, waves, n = 80, phase = 0) => {
+	const L = Math.hypot(b[0] - a[0], b[1] - a[1]), u = [(b[0] - a[0]) / L, (b[1] - a[1]) / L], v = [-u[1], u[0]];
+	return sample((t) => { const o = amp * Math.sin((t * waves + phase) * 2 * Math.PI); return [a[0] + u[0] * L * t + v[0] * o, a[1] + u[1] * L * t + v[1] * o]; }, 0, 1, n);
+};
+
+/**
+ * A bowl seen a little from above: the mouth an ellipse rx × ry at y = top, the body the lower half of an ellipse
+ * rx × depth. Its surface (soup, rice, hummus) sits inside, parted from the lip by a ring of gap, `rim` wide at the sides
+ * and `rimY` at the back, so a dish can cut its toppings into the surface before joining the two.
+ *
+ * @param {number} g The gap.
+ * @param {{ rx?: number, ry?: number, depth?: number, top?: number, rim?: number, rimY?: number }} [o] The bowl.
+ * @returns {{ body: import('../geometry/types.js').Shape, surface: import('../geometry/types.js').Polygon }} The pieces.
+ */
+export const bowlTop = (g, { rx = 224, ry = 96, depth = 190, top = 0, rim = 30, rimY = 24 } = {}) => {
+	const outer = poly([...sample((t) => [rx * Math.cos(t), top + depth * Math.sin(t)], 0, Math.PI, 150), ...sample((t) => [rx * Math.cos(t), top + ry * Math.sin(t)], Math.PI, 2 * Math.PI, 150).slice(1, -1)]);
+	const surface = ellipse(0, top, rx - rim - g, ry - rimY - g, 0, 300);
+	return { body: D(outer, grown(surface, g)), surface };
+};
+
+/**
+ * A tongue of flame `h` tall standing on (cx, cy): a round foot rising to a point that leans `lean` (a fraction of h) to
+ * the right (left when negative), the fuller side bellying out under it.
+ *
+ * @param {number} cx The foot, x.
+ * @param {number} cy The foot, y.
+ * @param {number} h The height.
+ * @param {number} [lean=0.18] The lean, a fraction of h.
+ * @returns {import('../geometry/types.js').Polygon} The flame.
+ */
+export const flameTongue = (cx, cy, h, lean = 0.18) => {
+	const w = h * 0.4, s = Math.sign(lean) || 1;
+	return poly(splineClosed([[cx + lean * h, cy - h], [cx + s * w * 0.55, cy - h * 0.55], [cx + s * w * 0.62, cy - h * 0.2], [cx + s * w * 0.36, cy - h * 0.02], [cx, cy],
+		[cx - s * w * 0.36, cy - h * 0.02], [cx - s * w * 0.6, cy - h * 0.22], [cx - s * w * 0.4, cy - h * 0.5], [cx - s * w * 0.05, cy - h * 0.72]], 10));
+};

package/src/objects/index.d.ts

@@ -0,0 +1,13 @@
+export * from './devices.js';
+export * from './devglyphs.js';
+export * from './weapons.js';
+export * from './food.js';
+export * from './sport.js';
+export * from './bio.js';
+export * from './faces.js';
+export * from './animals.js';
+export * from './rosettes.js';
+export type { DeviceSize } from './devices.js';
+export type { BladeKind } from './weapons.js';
+export type { FaceFrame, HeadphoneOptions } from './faces.js';
+export type { SidePhonesOptions } from './animals.js';

package/src/objects/index.js

@@ -0,0 +1,18 @@
+/**
+ * @module @logomarks/core/objects
+ *
+ * Objects the trade and character marks share, each drawn about the origin (y down) unless it says otherwise, a part
+ * that parts anything taking the gap g so exact() keeps it 22: devices (the phone slab and screen, windows, laptops,
+ * headsets) and the code glyphs knocked out of them, blades (knives, swords, axes, arrows), dishes, sport (the glove,
+ * pixel sprites), cells and strands, faces (features, mascot eyes and limbs, headphones), animals (the gecko build,
+ * two-track animals, bold outlines, tapers and seams) and rosettes.
+ */
+export * from './devices.js';
+export * from './devglyphs.js';
+export * from './weapons.js';
+export * from './food.js';
+export * from './sport.js';
+export * from './bio.js';
+export * from './faces.js';
+export * from './animals.js';
+export * from './rosettes.js';

package/src/objects/rosettes.d.ts

@@ -0,0 +1,14 @@
+import type { Geom, Polygon, Shape } from '../geometry/types.js';
+
+/** A ringed emblem's outer radius on the 512 canvas (224). */
+export const RING_R: number;
+/** The k-th of n directions round the centre, the first pointing up. */
+export function dir(n: number, k: number, d0?: number): number;
+/** A solid lens petal from r0 out to r0 + L, W wide, the k-th of n. */
+export function lensPetal(n: number, k: number, L: number, W: number, r0?: number, d0?: number): Shape;
+/** A shape's line: it less itself shrunk by w. */
+export function outline(p: Geom, w: number): Shape;
+/** n copies of a builder (k) => T. */
+export function ring<T>(n: number, f: (k: number) => T): T[];
+/** n lens petals as outlines in a ring of the same line, its outer edge R. */
+export function lineRosette(n: number, W: number, w: number, R?: number): Shape;

package/src/objects/rosettes.js

@@ -0,0 +1,64 @@
+/**
+ * Rosettes: the line petals and rings festival emblems are drawn from. Directions are degrees, 0 = right, 90 = down; the
+ * first petal points up. From the Logomarks tools (rosetteparts.mjs, batches 252, 271).
+ */
+import { C, U, D, annulus, lens, polar, grow } from '../geometry/index.js';
+
+/** A ringed emblem's outer radius on the 512 canvas. */
+export const RING_R = 224;
+
+/**
+ * The k-th of n directions round the centre, the first pointing up, all turned by d0.
+ *
+ * @param {number} n How many.
+ * @param {number} k Which.
+ * @param {number} [d0=0] The turn, in degrees.
+ * @returns {number} The direction, in degrees.
+ */
+export const dir = (n, k, d0 = 0) => -90 + d0 + (360 * k) / n;
+
+/**
+ * A solid lens petal from radius r0 out to r0 + L, W wide, the k-th of n round the centre.
+ *
+ * @param {number} n How many petals.
+ * @param {number} k Which.
+ * @param {number} L Its length.
+ * @param {number} W Its width.
+ * @param {number} [r0=0] Where it starts, from the centre.
+ * @param {number} [d0=0] The turn, in degrees.
+ * @returns {import('../geometry/types.js').Shape} The petal.
+ */
+export const lensPetal = (n, k, L, W, r0 = 0, d0 = 0) => { const a = dir(n, k, d0); return lens(...polar(r0 + L / 2, a), L, W, a); };
+
+/**
+ * A petal's line: the shape less itself shrunk by w (a stroked closed outline would mitre sharp tips into spikes).
+ *
+ * @param {import('../geometry/types.js').Geom} p The shape.
+ * @param {number} w The line's width.
+ * @returns {import('../geometry/types.js').Shape} The line.
+ */
+export const outline = (p, w) => D(p, grow(p, -w));
+
+/**
+ * n copies of a builder.
+ *
+ * @template T
+ * @param {number} n How many.
+ * @param {(k: number) => T} f The builder, given the copy's index.
+ * @returns {T[]} The copies.
+ */
+export const ring = (n, f) => [...Array(n)].map((_, k) => f(k));
+
+/**
+ * n lens petals W wide as outlines w thick, overlapping their neighbours, in a ring of the same line whose outer edge is R.
+ *
+ * @param {number} n How many petals.
+ * @param {number} W Their width.
+ * @param {number} w The line's width.
+ * @param {number} [R=RING_R] The ring's outer edge.
+ * @returns {import('../geometry/types.js').Shape} The rosette.
+ */
+export const lineRosette = (n, W, w, R = RING_R) => {
+	const r = R - w / 2;
+	return U(annulus(C, C, r, w), ...[...Array(n)].map((_, k) => { const p = lensPetal(n, k, r, W); return D(p, grow(p, -w)); }));
+};

package/src/objects/sport.d.ts

@@ -0,0 +1,8 @@
+import type { Polygon, Shape } from '../geometry/types.js';
+
+/** A pixel sprite (rows of '#') centred on the origin, p a pixel. */
+export function pixelSprite(rows: readonly string[], p?: number): Shape;
+/** A smooth closed outline through a few knots. */
+export function blobOf(pts: readonly (readonly number[])[], n?: number): Polygon;
+/** A boxing glove hanging cuff up: fist, thumb and cuff parted by the gap. */
+export function glove(g: number): Shape;

package/src/objects/sport.js

@@ -0,0 +1,37 @@
+/**
+ * Sport: the boxing glove, a smooth outline through knots and a pixel sprite centred on the origin. From the Logomarks
+ * tools (sportparts.mjs, batches 193, 229, 246).
+ */
+import { U, poly, ellipse, rr, over, move, pixels } from '../geometry/index.js';
+import { splineClosed } from '../parts/index.js';
+
+/**
+ * A pixel sprite (rows of '#'), p a pixel, centred on the origin (the kit's pixels() draws from the top-left corner).
+ *
+ * @param {readonly string[]} rows The rows.
+ * @param {number} [p=40] The pixel.
+ * @returns {import('../geometry/types.js').Shape} The sprite.
+ */
+export const pixelSprite = (rows, p = 40) => move(pixels(rows, p), (-rows[0].length * p) / 2, (-rows.length * p) / 2);
+
+/**
+ * A smooth closed outline through a few knots.
+ *
+ * @param {readonly (readonly number[])[]} pts The knots.
+ * @param {number} [n=14] Spline points a span.
+ * @returns {import('../geometry/types.js').Polygon} The outline.
+ */
+export const blobOf = (pts, n = 14) => poly(splineClosed(pts, n));
+
+/**
+ * A boxing glove hanging cuff up, front on: the fist a rounded mitt, the thumb lobe on its inner (left) side parted off by
+ * the gap, the cuff a band parted off the top.
+ *
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The glove.
+ */
+export const glove = (g) => {
+	const fist = blobOf([[-60, -80], [60, -96], [120, -40], [126, 60], [90, 150], [0, 176], [-90, 150], [-120, 70], [-104, -20]]);
+	const thumb = ellipse(-118, 30, 46, 74, 14, 160), cuff = rr(-78, -170, 150, 90 - g, 18);
+	return U(over(fist, thumb, g), cuff);
+};

package/src/objects/weapons.d.ts

@@ -0,0 +1,31 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** A blade's outline kind. */
+export type BladeKind = 'chef' | 'santoku' | 'drop' | 'cleaver';
+
+/** A shape turned by deg about the origin, then moved by (dx, dy). */
+export function place(s: Geom, deg: number, dx?: number, dy?: number): Shape;
+/** A shape mirrored left to right about x = 0. */
+export function flip(s: Geom): Shape;
+/** A quadratic Bézier from p0 through c to p1, n + 1 points. */
+export function bez(p0: readonly number[], c: readonly number[], p1: readonly number[], n?: number): Point[];
+/** A blade's outline from the heel (x = 0) to the tip (x = L). */
+export function bladePts(kind: BladeKind, L: number, H: number): Point[];
+/** A knife's grip from x1 back L, h deep, its butt rounded. */
+export function grip(x1: number, L: number, top: number, h: number, r?: number): Polygon;
+/** A knife pointing right: blade and handle parted by the gap. */
+export function knife(g: number, o?: { kind?: BladeKind; L?: number; H?: number; HL?: number; HH?: number; hy?: number }): { blade: Polygon; handle: Polygon };
+/** A straight sword pointing up: blade, guard, hilt and pommel, each parted by the gap. */
+export function sword(g: number, o?: { L?: number; W?: number; tip?: number; guard?: number[]; hilt?: number[]; pommel?: number; taper?: number }): { blade: Polygon; guard: Polygon; hilt: Polygon; pommel: Polygon };
+/** Two copies of a shape crossed in an X at ±deg, the right-leaning one in front. */
+export function crossed(s: Geom, deg: number, g: number): Shape;
+/** A katana along a gentle curve: grip, guard and blade (or scabbard), parted by the gap. */
+export function katana(g: number, o?: { sheathed?: boolean; L?: number; W?: number; tsukaL?: number; tsuba?: number[]; bend?: number }): { tsuka: Shape; tsuba: Shape; blade: Shape };
+/** A felling axe pointing up: head and haft, parted by the gap. */
+export function axe(g: number, o?: { W?: number; poll?: number; bit?: number; top?: number; bottom?: number; edge?: number }): { head: Polygon; haft: Polygon };
+/** The axe as one mark, the head in front of the haft. */
+export function axeCut(g: number, o?: { W?: number; poll?: number; bit?: number; top?: number; bottom?: number; edge?: number }): Shape;
+/** An arrow pointing right from x0 to x1: shaft, head and vanes. */
+export function arrow(g: number, x0: number, x1: number, o?: { w?: number; hl?: number; hw?: number; vl?: number; vw?: number }): { shaft: Polygon; head: Polygon; vanes: Shape };
+/** Target rings about the origin: a bull and n rings, each a gap out. */
+export function rings(g: number, o?: { r0?: number; w?: number; n?: number }): Shape;