@johnmorrisdotca/dougu-sports 0.0.1 → 0.1.0

package/dist/emblems/ball/ball.roundnet.js

@@ -0,0 +1,15 @@
+// Roundnet ball: a small bright ball of eight panels, yellow and orange (our colouring).
+import { defineBall } from "./ball.engine.js";
+import { octants8 } from "./ball.family.panelled.js";
+export const BALL_ROUNDNET = /* @__PURE__ */ defineBall({
+    id: "ball:roundnet",
+    en: "Roundnet ball",
+    ja: "ラウンドネットボール",
+    size: { extentMm: 105, diameterMm: 105, circumferenceMm: 330, massG: [80, 90], rule: "International Roundnet Federation (IRF) Rules, Chapter 1 Equipment and Court, 1.1.2 Set Dimensions, 1.1.4 Ball Characteristics, 1.1.5 Ball Inflation", note: "International Roundnet Federation rules (330 mm round, 10 mm either way); the rules give no diameter." },
+    spec: {
+        view: { yaw: 35, pitch: 28, roll: 0 },
+        base: "#f5dc16",
+        mat: { gloss: 0.6, shade: "#4a3a04", grain: { f: 1.4, a: 0.14 } },
+        draw: (s, base) => octants8(s, (sx, sy, sz) => (sx * sy * sz > 0 ? base : "#f08a1c"), "#7a5a10", 1.2),
+    },
+});

package/dist/emblems/ball/ball.rugby.d.ts

@@ -0,0 +1 @@
+export declare const BALL_RUGBY: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.rugby.js

@@ -0,0 +1,35 @@
+// Rugby ball: a classic white ball, pointed at the ends, with four panels, a pebbled grip all over, and two bands of colour round it on each side: a wide one and a thin one. The colour is the ball's
+// `tint` (a navy blue by default; the Laws do not set a colour and the ball carries no brand).
+import { defineBall } from "./ball.engine.js";
+import { seamAt, tipRing } from "./ball.family.prolate.js";
+import { mix } from "./ball.core.js";
+import { spread } from "./ball.math.js";
+const GRIP = spread(260, 0.4);
+const QUARTER = Math.PI / 2;
+const WHITE = "#f4f2ec";
+export const BALL_RUGBY = /* @__PURE__ */ defineBall({
+    id: "ball:rugby",
+    en: "Rugby ball",
+    ja: "ラグビーボール",
+    size: { extentMm: 290.0, lengthMm: 290.0, circumferenceMm: 600.0, longCircumferenceMm: 755.0, massG: [410, 460], rule: "World Rugby Laws of the Game (Rugby Union), Law 2 The ball, clauses 1-7" },
+    spec: {
+        axes: [1, 0.62, 0.62],
+        point: 0.72,
+        view: { yaw: -30, pitch: 20, roll: -30 },
+        base: "#1f4e9c",
+        ground: WHITE,
+        mat: { gloss: 0.4, shade: "#1a2030", grain: { f: 0.9, a: 0.18 } },
+        draw: (s, base) => {
+            let out = "";
+            // The grip: pebbles over the whole ball, a little darker than the white, each with its own highlight.
+            out += s.dots(GRIP, 0.03, mix(WHITE, -0.16), { opacity: 0.8, ink: false, light: false });
+            // The seams, tip to tip, then the bands over them.
+            out += s.strokes([0, 1, 2, 3].map((k) => seamAt(k * QUARTER + QUARTER / 2)), mix(WHITE, -0.3), 1.1);
+            for (const sign of [1, -1]) {
+                out += s.stroke(tipRing(sign, 1.02, 96), base, 9, { closed: true, ink: false });
+                out += s.stroke(tipRing(sign, 1.3, 96), base, 3, { closed: true, ink: false });
+            }
+            return out;
+        },
+    },
+});

package/dist/emblems/ball/ball.sepaktakraw.d.ts

@@ -0,0 +1 @@
+export declare const BALL_SEPAK_TAKRAW: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.sepaktakraw.js

@@ -0,0 +1,48 @@
+// Sepak takraw ball: woven rattan. Six bands, each of three strands, run round the ball as the six great circles that pass through the corners of an icosahedron, which leaves twelve
+// pentagonal holes and twenty triangular ones (the ISTAF law gives 12 holes and 20 intersections). Where two bands cross one goes over: the weave is worked out, not drawn by hand.
+import { defineBall } from "./ball.engine.js";
+import { cross, dot, norm, smallCircle } from "./ball.math.js";
+import { mix } from "./ball.core.js";
+const PHI = (1 + Math.sqrt(5)) / 2;
+const CORNERS = [[0, 1, PHI], [0, 1, -PHI], [1, PHI, 0], [1, -PHI, 0], [PHI, 0, 1], [-PHI, 0, 1]];
+const AXES = CORNERS.map((v) => norm(v));
+const SAMPLES = 48;
+/** Half the width of a band, and the gap between its strands, in radians. */
+const GAP = 0.034;
+const ring = (a, d = 0) => smallCircle(a, Math.PI / 2 + d, SAMPLES);
+const piece = (a, centre, d = 0, half = 0.2) => smallCircle(a, Math.PI / 2 + d, 24).filter((p) => dot(p, centre) > Math.cos(half));
+/** The two points where band `i` crosses band `j`. */
+const crossings = (i, j) => {
+    const c = norm(cross(AXES[i], AXES[j]));
+    return [c, [-c[0], -c[1], -c[2]]];
+};
+export const BALL_SEPAK_TAKRAW = /* @__PURE__ */ defineBall({
+    id: "ball:sepak-takraw",
+    en: "Sepak takraw ball",
+    ja: "セパタクローボール",
+    size: { extentMm: 133.7, diameterMm: 133.7, circumferenceMm: 420, massG: [170, 180], rule: "ISTAF Law of the Game (Rules of the Game), Law 4 The Ball (Sepaktakraw Ball), 4.1-4.5", note: "Men's ball (410 to 430 mm round); diameter worked out from the middle of the range. The 2013 edition of the law, the newest found." },
+    spec: {
+        view: { yaw: 14, pitch: 20, roll: 0 },
+        base: "#d3a24f",
+        ground: "#2c1a0a",
+        mat: { gloss: 0.35, shade: "#2a1604", rim: 0.9, grain: { f: 1.8, a: 0.4 } },
+        draw: (s, base) => {
+            const edge = mix(base, -0.5);
+            const band = (curves, closed) => s.strokes(curves, edge, 6.2, { closed }) + s.strokes(curves, base, 5.0, { closed, ink: false }) + s.strokes(curves.flatMap((c) => [c]), mix(base, 0.3), 0.5, { closed, deco: true, opacity: 0.5 });
+            const strand = (curves, closed) => s.strokes(curves, edge, 0.55, { closed, ink: false, opacity: 0.8 });
+            // Every band, then the strands' dividing lines.
+            let out = band(AXES.map((a) => ring(a)), true);
+            out += strand(AXES.flatMap((a) => [ring(a, GAP), ring(a, -GAP)]), true);
+            // The weave: at each crossing, the band chosen by parity is drawn again over the other.
+            const over = [];
+            for (let i = 0; i < AXES.length; i++) {
+                for (let j = i + 1; j < AXES.length; j++) {
+                    crossings(i, j).forEach((c, k) => over.push([AXES[(i + j + k) % 2 === 0 ? i : j], c]));
+                }
+            }
+            out += band(over.map(([a, c]) => piece(a, c)), false);
+            out += strand(over.flatMap(([a, c]) => [piece(a, c, GAP), piece(a, c, -GAP)]), false);
+            return out;
+        },
+    },
+});

package/dist/emblems/ball/ball.shuttlecock.d.ts

@@ -0,0 +1,6 @@
+export declare const BALL_SHUTTLECOCK_FEATHER: import("./ball.core.ts").Piece<{
+    feathers: number;
+}>;
+export declare const BALL_SHUTTLECOCK_NYLON: import("./ball.core.ts").Piece<{
+    feathers: number;
+}>;

package/dist/emblems/ball/ball.shuttlecock.js

@@ -0,0 +1,93 @@
+// Shuttlecocks: a cork base and a skirt of 16 feathers (a goose's, overlapped), or a molded nylon skirt. Drawn from its parts in true 3D: the feathers are blades that lean out from the base, painted
+// far to near, so the shuttlecock turns like any ball. 16 feathers, 62 to 70 mm long, the skirt 58 to 68 mm across (the BWF Laws, Law 2).
+import { defineObject } from "./ball.object.js";
+import {} from "./ball.math.js";
+import { blend, mix, num } from "./ball.core.js";
+const FEATHERS = 16;
+// One unit is 32 mm: the skirt is 2 units across at the top, the base 0.84 across and the whole 2.06 long.
+const ROOT_R = 0.42;
+const TIP_R = 1;
+const ROOT_Y = -0.56;
+const TIP_Y = 1.0;
+const SLOPE = 0.4;
+const drawShuttle = (c, p) => {
+    const line = c.opts.style === "line";
+    const tip = (a, r, y, k = 0) => [Math.cos(a) * r, y, Math.sin(a) * r + k];
+    const pts = (...v) => v.map((q) => c.at(q)).map((q) => `${num(q[0])} ${num(q[1])}`).join("L");
+    const blades = [];
+    const step = (2 * Math.PI) / FEATHERS;
+    const rootHalf = p.nylon ? step / 2 : step * 0.36;
+    const tipHalf = p.nylon ? step / 2 : step * 0.62;
+    for (let i = 0; i < FEATHERS; i++) {
+        const a = i * step;
+        const corners = [tip(a - rootHalf, ROOT_R, ROOT_Y), tip(a - tipHalf, TIP_R, TIP_Y), tip(a + tipHalf, TIP_R, TIP_Y), tip(a + rootHalf, ROOT_R, ROOT_Y)];
+        const mid = tip(a, (ROOT_R + TIP_R) / 2, (ROOT_Y + TIP_Y) / 2);
+        const m = c.at(mid);
+        // How squarely the blade faces the light (from the upper left): a blade whose outward normal points left and toward you is bright.
+        const nrm = [Math.cos(a), SLOPE * -0.5, Math.sin(a)];
+        const nv = c.at([nrm[0], nrm[1], nrm[2]]);
+        const origin = c.at([0, 0, 0]);
+        const lx = (nv[0] - origin[0]) / 46, ly = (nv[1] - origin[1]) / 46, lz = nv[2] - 0;
+        const lit = Math.max(0, Math.min(1, 0.55 + 0.4 * (-0.5 * lx + 0.55 * ly + 0.3 * lz)));
+        const fill = blend(mix(p.feather, -0.28), mix(p.feather, 0.1), lit);
+        const quill = `M${pts(tip(a, ROOT_R, ROOT_Y), tip(a, TIP_R, TIP_Y))}`;
+        const outline = `M${pts(...corners)}Z`;
+        const svg = line
+            ? `<path d="${outline}${p.nylon ? "" : quill}"/>`
+            : `<path d="${outline}" fill="${fill}"${p.nylon ? ` fill-opacity=".9"` : ""} stroke="${mix(p.feather, -0.55)}" stroke-width="${num(Math.max(0.7, c.minWidth * 0.6), 2)}" stroke-linejoin="round"/>` +
+                (p.nylon ? "" : `<path d="${quill}" fill="none" stroke="${p.shaft}" stroke-width="${num(Math.max(0.45, c.minWidth * 0.5), 2)}" stroke-linecap="round" opacity=".8"/>`);
+        blades.push({ depth: m[2], svg });
+    }
+    blades.sort((x, y) => x.depth - y.depth);
+    const ring = (y, r) => {
+        const q = [];
+        for (let i = 0; i <= 36; i++)
+            q.push(`${i === 0 ? "M" : "L"}${pts(tip((i / 36) * 2 * Math.PI, r, y))}`);
+        return q.join("");
+    };
+    // Where the base is: below the skirt, so it is behind it when the tip leans toward you, in front of it when the cork leans toward you.
+    const base = c.at([0, ROOT_Y, 0]);
+    const top = c.at([0, TIP_Y, 0]);
+    const corkFirst = base[2] <= top[2];
+    const cx = c.at([0, ROOT_Y - 0.4, 0]);
+    const corkR = 46 * 0.43 * ROOT_R;
+    const defs = line
+        ? ""
+        : `<radialGradient id="${c.id}k" cx=".36" cy=".3" r=".8"><stop offset="0" stop-color="${blend(p.cork, "#fff", 0.35)}"/><stop offset=".5" stop-color="${p.cork}"/><stop offset="1" stop-color="${mix(p.cork, -0.55)}"/></radialGradient>`;
+    const cork = line
+        ? `<circle cx="${num(cx[0])}" cy="${num(cx[1])}" r="${num(corkR)}"/>`
+        : `<circle cx="${num(cx[0])}" cy="${num(cx[1])}" r="${num(corkR)}" fill="url(#${c.id}k)"/><path d="${ring(ROOT_Y + 0.02, ROOT_R)}" fill="none" stroke="${p.band}" stroke-width="${num(Math.max(1.4, c.minWidth), 2)}" opacity=".9"/>`;
+    const thread = `<path d="${ring(0.55, 0.72)}" fill="none" stroke="${line ? "currentColor" : p.thread}" stroke-width="${num(Math.max(0.5, c.minWidth * 0.7), 2)}"${line ? ' opacity=".7"' : ""}/>`;
+    const rim = `<path d="${ring(TIP_Y, TIP_R)}" fill="none" stroke="${line ? "currentColor" : mix(p.feather, -0.3)}" stroke-width="${num(Math.max(0.5, c.minWidth * 0.6), 2)}"${line ? ' opacity=".6"' : ' opacity=".5"'}/>`;
+    const feathers = blades.map((b) => b.svg).join("");
+    let body = corkFirst ? cork + feathers : feathers + cork;
+    body += thread;
+    if (line)
+        body = `<g fill="none" stroke="currentColor" stroke-width="${num(Math.max(2.4, c.minWidth * 1.4), 2)}" stroke-linejoin="round" stroke-linecap="round">${body}${rim}</g>`;
+    else
+        body += rim;
+    return { defs, body };
+};
+const VIEW = { yaw: 0, pitch: 22, roll: -32 };
+export const BALL_SHUTTLECOCK_FEATHER = /* @__PURE__ */ defineObject({
+    id: "ball:shuttlecock-feather",
+    en: "Shuttlecock, feather",
+    ja: "シャトルコック（水鳥の羽根）",
+    size: { extentMm: 150, diameterMm: 63, lengthMm: 66, massG: [4.74, 5.5], rule: "BWF Laws of Badminton, Law 2 Shuttle (2.1 general, 2.2 Feathered shuttle 2.2.1-2.2.6, 2.3 Non-feathered shuttle, 2.4 modifications) and Laws 3 Testing a shuttle for speed", note: "62 to 70 mm long with the tips on a circle 58 to 68 mm across, on a base 25 to 28 mm across; the box is drawn at the scale of the shuttlecock, which fills a part of it." },
+    view: VIEW,
+    scale: 0.43,
+    shift: [0, 0.02, 0],
+    model: { feathers: FEATHERS },
+    draw: (c) => drawShuttle(c, { feather: "#fbfaf4", shaft: "#b5ac94", cork: "#c8925a", band: "#f6f2e8", thread: "#8a826a", nylon: false }),
+});
+export const BALL_SHUTTLECOCK_NYLON = /* @__PURE__ */ defineObject({
+    id: "ball:shuttlecock-nylon",
+    en: "Shuttlecock, nylon",
+    ja: "シャトルコック（ナイロン）",
+    size: { extentMm: 150, diameterMm: 63, lengthMm: 66, massG: [4.74, 5.5], rule: "BWF Laws of Badminton, Law 2 Shuttle (2.1 general, 2.2 Feathered shuttle 2.2.1-2.2.6, 2.3 Non-feathered shuttle, 2.4 modifications) and Laws 3 Testing a shuttle for speed", note: "A non-feathered shuttle follows the same measures, with a tolerance of 10 per cent (Law 2.3); the box is drawn at the scale of the shuttlecock, which fills a part of it." },
+    view: VIEW,
+    scale: 0.43,
+    shift: [0, 0.02, 0],
+    model: { feathers: FEATHERS },
+    draw: (c) => drawShuttle(c, { feather: "#f2f4f6", shaft: "#aab0b8", cork: "#f0eadd", band: "#e04a3c", thread: "#7a8088", nylon: true }),
+});

package/dist/emblems/ball/ball.sliotar.d.ts

@@ -0,0 +1 @@
+export declare const BALL_SLIOTAR: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.sliotar.js

@@ -0,0 +1,14 @@
+// Sliotar: a cork-cored leather ball for hurling, with a raised rib along its seam.
+import { seamedBall } from "./ball.family.seamed.js";
+export const BALL_SLIOTAR = /* @__PURE__ */ seamedBall({
+    id: "ball:sliotar",
+    en: "Sliotar",
+    ja: "シリター",
+    size: { extentMm: 70.5, diameterMm: 70.5, massG: [110, 116], rule: "GAA Official Guide Part 2, Rules of Specification, Rule 4.4(i)", note: "The rule gives a diameter that leaves out the raised rib." },
+    base: "#efe8d4",
+    b: 0.36,
+    view: { yaw: 22, pitch: 34, roll: 8 },
+    mat: { gloss: 0.4, shade: "#4a3a20", grain: { f: 1.3, a: 0.2 } },
+    strip: { colour: "#ded4b6", width: 2.4, raised: true },
+    stitch: { colour: "#8a7a58", count: 90, half: 0.05, width: 0.6, lean: 0.0 },
+});

package/dist/emblems/ball/ball.smooth.d.ts

@@ -0,0 +1,4 @@
+export declare const BALL_LACROSSE: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_RACQUETBALL: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_TABLE_TENNIS: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SHOT: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.smooth.js

@@ -0,0 +1,51 @@
+// Plain round balls: the lacrosse ball, the racquetball, the table-tennis ball and the shot. A faint seam where a real one has it.
+import { defineBall } from "./ball.engine.js";
+import { greatCircle } from "./ball.math.js";
+export const BALL_LACROSSE = /* @__PURE__ */ defineBall({
+    id: "ball:lacrosse",
+    en: "Lacrosse ball",
+    ja: "ラクロスボール",
+    size: { extentMm: 63.7, diameterMm: 63.7, circumferenceMm: 200.05, massG: [141.75, 148.83], rule: "World Lacrosse Rules of Men's Field Lacrosse 2025-2027 (Ver 1.0), Section 2 Equipment, Rule 14 The Ball, 14.1", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 0, pitch: 0, roll: 0 },
+        base: "#f2791c",
+        mat: { gloss: 0.5, shade: "#5a2208", grain: { f: 1.5, a: 0.14 } },
+        draw: () => "",
+    },
+});
+export const BALL_RACQUETBALL = /* @__PURE__ */ defineBall({
+    id: "ball:racquetball",
+    en: "Racquetball",
+    ja: "ラケットボール",
+    size: { extentMm: 57.1, diameterMm: 57.1, massG: [39.7, 39.7], rule: "USA Racquetball Rules, Rule 2.2 Ball Specifications (a)-(b); Rule 2.3 Ball Selection", note: "Nominal values; the rule gives no tolerance." },
+    spec: {
+        view: { yaw: 25, pitch: 30, roll: 0 },
+        base: "#2f63d2",
+        mat: { gloss: 0.55, shade: "#06143a", grain: { f: 1.5, a: 0.1 } },
+        draw: (s) => s.stroke(greatCircle([0.35, 0.9, 0.25], 72), "#10265e", 0.9, { closed: true, opacity: 0.5, deco: false }),
+    },
+});
+export const BALL_TABLE_TENNIS = /* @__PURE__ */ defineBall({
+    id: "ball:table-tennis",
+    en: "Table-tennis ball",
+    ja: "卓球ボール",
+    size: { extentMm: 40.0, diameterMm: 40.0, massG: [2.7, 2.7], rule: "Laws of Table Tennis, 2.3 The Ball, 2.3.1-2.3.3" },
+    spec: {
+        view: { yaw: 25, pitch: 30, roll: 0 },
+        base: "#f6f5f0",
+        mat: { gloss: 0.32, shade: "#2e3550", grain: { f: 2, a: 0.05 } },
+        draw: (s) => s.stroke(greatCircle([0.3, 0.8, 0.5], 72), "#9aa0ac", 0.45, { closed: true, opacity: 0.8 }),
+    },
+});
+export const BALL_SHOT = /* @__PURE__ */ defineBall({
+    id: "ball:shot",
+    en: "Shot",
+    ja: "砲丸",
+    size: { extentMm: 120, diameterMm: 120, massG: [7260, 7260], rule: "World Athletics Technical Rules (C2.1), Rule 33 Shot Put - implement specification ('Shot'); smooth finish N7 (Ra <= 1.6 micrometres)", note: "Men's shot, 110 to 130 mm across; 7.260 kg is a minimum." },
+    spec: {
+        view: { yaw: 0, pitch: 0, roll: 0 },
+        base: "#8c949e",
+        mat: { gloss: 0.95, shade: "#0c1018", metal: true, rim: 1 },
+        draw: () => "",
+    },
+});

package/dist/emblems/ball/ball.soccer.d.ts

@@ -0,0 +1,2 @@
+export declare const BALL_SOCCER: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;
+export declare const BALL_SOCCER_COLOUR: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.soccer.js

@@ -0,0 +1,54 @@
+// The classic soccer ball: 32 panels, twelve black pentagons and twenty white hexagons, laid on a truncated icosahedron; and a coloured one with a motif of our own (a triangle on each hexagon
+// pointing at its three pentagons). No brand, no tournament's pattern.
+import { defineBall } from "./ball.engine.js";
+import { truncatedIcosahedron } from "./ball.polyhedra.js";
+import { add, mul, norm } from "./ball.math.js";
+import { blend, mix } from "./ball.core.js";
+const SEAM = "#6b7180";
+export const BALL_SOCCER = /* @__PURE__ */ defineBall({
+    id: "ball:soccer",
+    en: "Soccer ball",
+    ja: "サッカーボール",
+    size: { extentMm: 219.6, diameterMm: 219.6, circumferenceMm: 690.0, massG: [410, 450], rule: "IFAB Laws of the Game, Law 2 The Ball, section 2.1 Qualities and measurements", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 30, pitch: 24, roll: 8 },
+        base: "#1e2025",
+        ground: "#f8f8f6",
+        mat: { gloss: 0.8, shade: "#2a3450", grain: { f: 1.1, a: 0.16 } },
+        draw(s, base) {
+            const t = truncatedIcosahedron();
+            let out = "";
+            for (const p of t.pentagons)
+                out += s.panel(p, base, { ink: true });
+            out += s.strokes(t.edges, SEAM, 1.15);
+            out += s.strokes(t.edges, "#fff", 0.45, { deco: true, opacity: 0.5, dx: 0.3, dy: 0.35 });
+            return out;
+        },
+    },
+});
+export const BALL_SOCCER_COLOUR = /* @__PURE__ */ defineBall({
+    id: "ball:soccer-colour",
+    en: "Soccer ball, coloured",
+    ja: "サッカーボール（カラー）",
+    size: { extentMm: 219.6, diameterMm: 219.6, circumferenceMm: 690.0, massG: [410, 450], rule: "IFAB Laws of the Game, Law 2 The Ball, section 2.1 Qualities and measurements", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 30, pitch: 24, roll: 8 },
+        base: "#d4283c",
+        ground: "#f8f8f6",
+        mat: { gloss: 0.8, shade: "#3a2030", grain: { f: 1.1, a: 0.16 } },
+        draw(s, base) {
+            const t = truncatedIcosahedron();
+            const light = blend(base, "#ffffff", 0.45);
+            let out = "";
+            t.hexagons.forEach((_, i) => {
+                const c = t.hexagonCentres[i];
+                out += s.panel(t.hexagonPentagonSides[i].map((m) => norm(add(mul(c, 0.38), mul(m, 0.62)))), light, { n: 2 });
+            });
+            for (const p of t.pentagons)
+                out += s.panel(p, base, { ink: true });
+            out += s.strokes(t.edges, mix(base, -0.35), 1.1);
+            out += s.strokes(t.edges, "#fff", 0.45, { deco: true, opacity: 0.45, dx: 0.3, dy: 0.35 });
+            return out;
+        },
+    },
+});

package/dist/emblems/ball/ball.softball.d.ts

@@ -0,0 +1 @@
+export declare const BALL_SOFTBALL: import("./ball.core.ts").Piece<import("./ball.engine.ts").BallSpec>;

package/dist/emblems/ball/ball.softball.js

@@ -0,0 +1,14 @@
+// Softball: an optic-yellow ball with red stitches along the seam (88 here, which the rule leaves free).
+import { seamedBall } from "./ball.family.seamed.js";
+export const BALL_SOFTBALL = /* @__PURE__ */ seamedBall({
+    id: "ball:softball",
+    en: "Softball",
+    ja: "ソフトボール",
+    size: { extentMm: 97.1, diameterMm: 97.1, circumferenceMm: 305.0, massG: [178.0, 198.4], rule: "WBSC Official Rules of Softball Slow Pitch 2026-2029, Appendix 3 (Ball Specifications), B. Dimensions and Specifications and 'Ball standards' table; Fast Pitch 2026-2029 Appendix 3 gives the same 12 in ball", note: "The 12 in ball (the 11 in ball is 279.5 mm round). Diameter worked out from the middle of the circumference range." },
+    base: "#d8e22a",
+    b: 0.4,
+    view: { yaw: 18, pitch: 28, roll: -10 },
+    mat: { gloss: 0.35, shade: "#4c5a10", grain: { f: 1.4, a: 0.12 } },
+    groove: "#8a9420",
+    stitch: { colour: "#d0262c", count: 88, half: 0.085, width: 0.95, lean: 0.04 },
+});

package/dist/emblems/ball/ball.squash.d.ts

@@ -0,0 +1,7 @@
+import type { Piece } from "./ball.core.ts";
+import type { BallSpec } from "./ball.engine.ts";
+export declare const BALL_SQUASH_DOUBLE_YELLOW: Piece<BallSpec>;
+export declare const BALL_SQUASH_YELLOW: Piece<BallSpec>;
+export declare const BALL_SQUASH_RED: Piece<BallSpec>;
+export declare const BALL_SQUASH_BLUE: Piece<BallSpec>;
+export declare const BALL_SQUASH_GREEN: Piece<BallSpec>;

package/dist/emblems/ball/ball.squash.js

@@ -0,0 +1,27 @@
+// Squash balls: small hollow black rubber balls with a coloured dot (or two) that says how lively the ball is: double yellow (the competition ball), yellow (club), green (high altitude), red
+// (medium) and blue (fast). World Squash's specification recommends the dots; it does not require them.
+import { defineBall } from "./ball.engine.js";
+import { norm } from "./ball.math.js";
+function squash(id, en, ja, colour, count, size) {
+    return defineBall({
+        id,
+        en,
+        ja,
+        size,
+        spec: {
+            view: { yaw: -18, pitch: 18, roll: 0 },
+            base: "#1f2023",
+            mat: { gloss: 0.5, shade: "#000000", grain: { f: 1.6, a: 0.12 } },
+            draw: (s) => {
+                const centres = count === 2 ? [norm([-0.28, 0.12, 1]), norm([0.34, 0.1, 1])] : [norm([0.04, 0.1, 1])];
+                return s.dots(centres, count === 2 ? 0.2 : 0.28, colour, { ink: true });
+            },
+        },
+    });
+}
+const SIZE = { extentMm: 40.0, diameterMm: 40.0, massG: [23.0, 25.0], rule: "World Squash 'Specifications for Squash Balls' (Recommended standards approved by the WSF; updated WSF AGM 2021, rebranded 2025), sections 1-3 and Notes 2-4", note: "Size and weight are set for the double yellow, yellow and green dot balls; the red and blue dot balls carry no limits in the specification." };
+export const BALL_SQUASH_DOUBLE_YELLOW = /* @__PURE__ */ squash("ball:squash", "Squash ball, double yellow dot", "スカッシュボール（ダブルイエロードット）", "#f4d41c", 2, SIZE);
+export const BALL_SQUASH_YELLOW = /* @__PURE__ */ squash("ball:squash-yellow", "Squash ball, yellow dot", "スカッシュボール（イエロードット）", "#f4d41c", 1, SIZE);
+export const BALL_SQUASH_RED = /* @__PURE__ */ squash("ball:squash-red", "Squash ball, red dot", "スカッシュボール（レッドドット）", "#d9262c", 1, SIZE);
+export const BALL_SQUASH_BLUE = /* @__PURE__ */ squash("ball:squash-blue", "Squash ball, blue dot", "スカッシュボール（ブルードット）", "#2b6fd6", 1, SIZE);
+export const BALL_SQUASH_GREEN = /* @__PURE__ */ squash("ball:squash-green", "Squash ball, green dot", "スカッシュボール（グリーンドット）", "#2aa84a", 1, SIZE);

package/dist/emblems/ball/ball.stack.d.ts

@@ -0,0 +1,48 @@
+import { type ObjectContext } from "./ball.object.ts";
+export interface Slice {
+    y0: number;
+    y1: number;
+    /** The radius at the lower end and at the upper end (one number for a plain cylinder). */
+    r: number | readonly [number, number];
+    colour: string;
+    /** Drawn in the line style (the others are left out so a line drawing keeps to the outline). */
+    outline?: boolean;
+}
+export interface StackSpec {
+    slices: readonly Slice[];
+    top: string;
+    bottom: string;
+    gloss: number;
+    shade: string;
+    grain?: {
+        f: number;
+        a: number;
+    };
+    /** Lines down the side: how many round the whole slice, on the slices that have `grooved`. */
+    grooves?: {
+        count: number;
+        slices: readonly number[];
+        colour: string;
+        opacity: number;
+    };
+    /** A ring on the top face: radius as a fraction, colour. */
+    topRing?: {
+        r: number;
+        colour: string;
+    };
+    /** What lies in the bottom face when it faces you: a dish. */
+    dish?: {
+        r: number;
+        colour: string;
+    };
+    /** Drawn on top of the stack, in the stack's own space (a handle). `up` is the screen position of the top face's centre. */
+    extra?: (c: ObjectContext, top: {
+        cx: number;
+        cy: number;
+        nz: number;
+    }) => string;
+}
+export declare function drawStack(c: ObjectContext, spec: StackSpec): {
+    defs: string;
+    body: string;
+};

package/dist/emblems/ball/ball.stack.js

@@ -0,0 +1,127 @@
+// A stack of round slices on one axis, drawn in true 3D by the rules of an orthographic view: each end of a slice is an ellipse (its minor axis along the projected axis), the side between them
+// is a band as wide as the slice, and what is nearer is painted last. A puck is one slice; a curling stone is six and a handle.
+import {} from "./ball.object.js";
+import { apply } from "./ball.math.js";
+import { blend, grainDef, mix, num } from "./ball.core.js";
+const LIGHT = [-0.55, -0.72, 0];
+const ellipsePath = (cx, cy, major, minor, deg) => {
+    const rad = (deg * Math.PI) / 180;
+    const ax = Math.cos(rad) * major, ay = Math.sin(rad) * major;
+    const arcs = `${num(major, 2)} ${num(Math.max(minor, 0.02), 2)} ${num(deg, 1)} 1 0`;
+    return `M${num(cx + ax, 2)} ${num(cy + ay, 2)}A${arcs} ${num(cx - ax, 2)} ${num(cy - ay, 2)}A${arcs} ${num(cx + ax, 2)} ${num(cy + ay, 2)}Z`;
+};
+/** The half of an ellipse on one side: through the point `side` (-1 or 1) of the way along `d` from the centre. */
+const halfEllipse = (cx, cy, major, minor, deg, side) => {
+    const rad = (deg * Math.PI) / 180;
+    const ax = Math.cos(rad) * major, ay = Math.sin(rad) * major;
+    const sweep = side < 0 ? 1 : 0;
+    return `M${num(cx + ax, 2)} ${num(cy + ay, 2)}A${num(major, 2)} ${num(Math.max(minor, 0.02), 2)} ${num(deg, 1)} 0 ${sweep} ${num(cx - ax, 2)} ${num(cy - ay, 2)}`;
+};
+export function drawStack(c, spec) {
+    const line = c.opts.style === "line";
+    const n = apply(c.rot, [0, 1, 0]);
+    const nz = n[2];
+    const ax = 46 * n[0], ay = -46 * n[1];
+    const dl = Math.hypot(ax, ay);
+    const d = dl < 1e-3 ? [1, 0] : [ax / dl, ay / dl];
+    const perp = [-d[1], d[0]];
+    const perpDeg = (Math.atan2(perp[1], perp[0]) * 180) / Math.PI;
+    const at = (y) => [50 + y * ax, 50 + y * ay];
+    const topVisible = nz >= 0;
+    const shadeEnd = (col) => mix(col, -0.55);
+    const pl = perp[0] * LIGHT[0] + perp[1] * LIGHT[1];
+    const u = Math.min(0.78, Math.max(0.22, 0.5 + 0.34 * pl));
+    const radius = (s, end) => (typeof s.r === "number" ? s.r : s.r[end]);
+    let defs = "";
+    const slices = spec.slices;
+    const maxR = Math.max(...slices.map((s) => Math.max(radius(s, 0), radius(s, 1))));
+    const mid = at((slices[0].y0 + slices.at(-1).y1) / 2);
+    const g0 = [mid[0] - perp[0] * 46 * maxR, mid[1] - perp[1] * 46 * maxR];
+    const g1 = [mid[0] + perp[0] * 46 * maxR, mid[1] + perp[1] * 46 * maxR];
+    const side = (s, i) => {
+        const gid = `${c.id}s${i}`;
+        const base = s.colour;
+        defs += `<linearGradient id="${gid}" gradientUnits="userSpaceOnUse" x1="${num(g0[0], 2)}" y1="${num(g0[1], 2)}" x2="${num(g1[0], 2)}" y2="${num(g1[1], 2)}"><stop offset="0" stop-color="${shadeEnd(base)}"/><stop offset="${num(Math.max(0.03, u - 0.26), 2)}" stop-color="${base}"/><stop offset="${num(u, 2)}" stop-color="${blend(base, "#ffffff", 0.18 + spec.gloss * 0.3)}"/><stop offset="${num(Math.min(0.97, u + 0.28), 2)}" stop-color="${base}"/><stop offset="1" stop-color="${shadeEnd(base)}"/></linearGradient>`;
+        const [x0, y0] = at(s.y0), [x1, y1] = at(s.y1);
+        const rb = 46 * radius(s, 0), rt = 46 * radius(s, 1);
+        const pts = [[x0 + perp[0] * rb, y0 + perp[1] * rb], [x1 + perp[0] * rt, y1 + perp[1] * rt], [x1 - perp[0] * rt, y1 - perp[1] * rt], [x0 - perp[0] * rb, y0 - perp[1] * rb]];
+        const d4 = `M${pts.map((p) => `${num(p[0], 2)} ${num(p[1], 2)}`).join("L")}Z`;
+        if (line) {
+            if (s.outline !== true)
+                return "";
+            const lines = `M${num(pts[0][0], 2)} ${num(pts[0][1], 2)}L${num(pts[1][0], 2)} ${num(pts[1][1], 2)}M${num(pts[2][0], 2)} ${num(pts[2][1], 2)}L${num(pts[3][0], 2)} ${num(pts[3][1], 2)}`;
+            const rim = (y, r, side) => {
+                const [cx, cy] = at(y);
+                return halfEllipse(cx, cy, 46 * r, 46 * r * Math.abs(nz), perpDeg, side);
+            };
+            const near = topVisible ? -1 : 1;
+            return `<path d="${lines}${rim(s.y0, radius(s, 0), near)}${i === slices.length - 1 ? "" : rim(s.y1, radius(s, 1), near)}" fill="none"/>`;
+        }
+        let out = `<path d="${d4}" fill="url(#${gid})"/>`;
+        const gr = spec.grooves;
+        if (!line && gr !== undefined && gr.slices.includes(i)) {
+            let marks = "";
+            for (let k = 0; k < gr.count; k++) {
+                const t = ((k + 0.5) / gr.count) * Math.PI;
+                const uu = Math.cos(t);
+                const facing = Math.sin(t);
+                if (facing < 0.15)
+                    continue;
+                marks += `M${num(x0 + perp[0] * rb * uu, 2)} ${num(y0 + perp[1] * rb * uu, 2)}L${num(x1 + perp[0] * rt * uu, 2)} ${num(y1 + perp[1] * rt * uu, 2)}`;
+            }
+            out += `<path d="${marks}" stroke="${gr.colour}" stroke-width="${num(Math.max(0.5, c.minWidth * 0.5), 2)}" opacity="${gr.opacity}" fill="none"/>`;
+        }
+        return out;
+    };
+    const cap = (y, r, colour, i, topFace) => {
+        const [cx, cy] = at(y);
+        const major = 46 * r;
+        const minor = Math.max(major * Math.abs(nz), 0.02);
+        const dpath = ellipsePath(cx, cy, major, minor, perpDeg);
+        if (line)
+            return (topFace && (i === `t${slices.length - 1}` || i === `d0`)) || i === "dish" ? `<path d="${dpath}" fill="none"/>` : "";
+        const gid = `${c.id}c${i}`;
+        defs += `<radialGradient id="${gid}" cx=".36" cy=".3" r=".85"><stop offset="0" stop-color="${blend(colour, "#ffffff", 0.2 + spec.gloss * 0.34)}"/><stop offset=".45" stop-color="${colour}"/><stop offset="1" stop-color="${mix(colour, topFace ? -0.34 : -0.5)}"/></radialGradient>`;
+        return `<path d="${dpath}" fill="url(#${gid})"/>`;
+    };
+    const ordered = topVisible ? slices.map((s, i) => [s, i]) : slices.map((s, i) => [s, i]).reverse();
+    let body = "";
+    if (topVisible) {
+        const s0 = slices[0];
+        body += cap(s0.y0, radius(s0, 0), mix(s0.colour, -0.25), "b", false);
+        for (const [s, i] of ordered) {
+            body += side(s, i);
+            body += cap(s.y1, radius(s, 1), i === slices.length - 1 ? spec.top : s.colour, `t${i}`, true);
+        }
+        if (spec.topRing !== undefined) {
+            const [cx, cy] = at(slices.at(-1).y1);
+            const r = 46 * radius(slices.at(-1), 1) * spec.topRing.r;
+            body += `<path d="${ellipsePath(cx, cy, r, r * Math.abs(nz), perpDeg)}" fill="none" stroke="${line ? "currentColor" : spec.topRing.colour}" stroke-width="${num(Math.max(0.6, c.minWidth * 0.6), 2)}" opacity=".7"/>`;
+        }
+    }
+    else {
+        const sT = slices.at(-1);
+        body += cap(sT.y1, radius(sT, 1), mix(sT.colour, -0.25), "u", false);
+        for (const [s, i] of ordered) {
+            body += side(s, i);
+            body += cap(s.y0, radius(s, 0), i === 0 ? spec.bottom : s.colour, `d${i}`, true);
+        }
+        if (spec.dish !== undefined) {
+            const [cx, cy] = at(slices[0].y0);
+            const r = 46 * radius(slices[0], 0) * spec.dish.r;
+            const gid = `${c.id}dish`;
+            defs += `<radialGradient id="${gid}" cx=".64" cy=".7" r=".9"><stop offset="0" stop-color="${blend(spec.dish.colour, "#ffffff", 0.3)}"/><stop offset=".5" stop-color="${spec.dish.colour}"/><stop offset="1" stop-color="${mix(spec.dish.colour, -0.6)}"/></radialGradient>`;
+            body += `<path d="${ellipsePath(cx, cy, r, r * Math.abs(nz), perpDeg)}" fill="${line ? "none" : `url(#${gid})`}"/>`;
+        }
+    }
+    const [tx, ty] = at(slices.at(-1).y1);
+    if (spec.extra !== undefined)
+        body += spec.extra(c, { cx: tx, cy: ty, nz });
+    const gr = c.opts.grain ?? (c.opts.size >= 48 && !c.turning);
+    const grain = !line && gr && spec.grain !== undefined;
+    if (grain)
+        defs += grainDef(c.id, spec.grain.f, spec.grain.a);
+    if (line)
+        return { defs: "", body: `<g fill="none" stroke="currentColor" stroke-width="${num(Math.max(2.4, c.minWidth * 1.4), 2)}" stroke-linejoin="round" stroke-linecap="round">${body}</g>` };
+    return { defs, body: grain ? `<g filter="url(#${c.id}n)">${body}</g>` : body };
+}

package/dist/emblems/ball/ball.stitch.d.ts

@@ -0,0 +1,10 @@
+import { type V3 } from "./ball.math.ts";
+/** Marks across a curve: `count` marks evenly along it; a mark runs `half` radians either side of the seam and leans along it by `lean`. A `v` mark has two legs that meet on the seam (a baseball's stitch). */
+export declare function stitches(pts: readonly V3[], closed: boolean, count: number, half: number, o?: {
+    lean?: number;
+    v?: boolean;
+    offset?: number;
+    phase?: number;
+}): V3[][];
+/** A dashed row: segments of a curve, each `dash` of every `period` long as a fraction of the curve. */
+export declare function dashes(pts: readonly V3[], closed: boolean, count: number, fill?: number): V3[][];