@johnmorrisdotca/dougu-sports 0.0.1 → 0.2.0

package/dist/emblems/ball/ball.pickleball.js

@@ -0,0 +1,26 @@
+// Pickleball: a perforated plastic ball. The outdoor ball has 40 small holes; the indoor ball has 26 larger ones (the rulebook gives 26 to 40 holes; the split is how balls are sold).
+import { dottedBall } from "./ball.family.dotted.js";
+export const BALL_PICKLEBALL_OUTDOOR = /* @__PURE__ */ dottedBall({
+    id: "ball:pickleball-outdoor",
+    en: "Pickleball, outdoor",
+    ja: "ピックルボール（屋外用）",
+    size: { extentMm: 74.2, diameterMm: 74.2, massG: [22.1, 26.5], rule: "USA Pickleball Equipment Standards Manual (Jan 2025, Revision 3.0), 2.D.1 Design, 2.D.3 Size, 2.D.4 Weight, 2.D.8 Design (holes); USA Pickleball 2026 Official Rulebook rule 3.C Ball Specifications", note: "The rulebook does not tell indoor and outdoor balls apart: both are 26 to 40 holes; 40 small holes is the outdoor ball as sold." },
+    base: "#e6e83c",
+    count: 40,
+    radius: 0.13,
+    mat: { gloss: 0.55, shade: "#4a5008", grain: { f: 1.4, a: 0.1 } },
+    mark: "#454b0e",
+    depth: 0.75,
+});
+export const BALL_PICKLEBALL_INDOOR = /* @__PURE__ */ dottedBall({
+    id: "ball:pickleball-indoor",
+    en: "Pickleball, indoor",
+    ja: "ピックルボール（屋内用）",
+    size: { extentMm: 74.2, diameterMm: 74.2, massG: [22.1, 26.5], rule: "USA Pickleball Equipment Standards Manual (Jan 2025, Revision 3.0), 2.D.1 Design, 2.D.3 Size, 2.D.4 Weight, 2.D.8 Design (holes); USA Pickleball 2026 Official Rulebook rule 3.C Ball Specifications", note: "The rulebook does not tell indoor and outdoor balls apart: both are 26 to 40 holes; 26 large holes is the indoor ball as sold." },
+    base: "#f2f0e4",
+    count: 26,
+    radius: 0.19,
+    mat: { gloss: 0.6, shade: "#3a3a40", grain: { f: 1.4, a: 0.08 } },
+    mark: "#3d3d44",
+    depth: 0.7,
+});

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

@@ -0,0 +1,15 @@
+import { type V3 } from "./ball.math.ts";
+export interface Truncated {
+    pentagons: V3[][];
+    hexagons: V3[][];
+    /** The centre of each pentagon and hexagon, same order. */
+    pentagonCentres: V3[];
+    hexagonCentres: V3[];
+    /** Every edge between two panels once, as a curve on the sphere. */
+    edges: V3[][];
+    /** For each hexagon, the midpoints of the three edges it shares with a pentagon (alternate edges). */
+    hexagonPentagonSides: V3[][];
+}
+export declare function truncatedIcosahedron(samples?: number): Truncated;
+/** A ring pulled toward its centre by a fraction, on the sphere: the face inside the seam. */
+export declare function shrink(ring: readonly V3[], centre: V3, by: number): V3[];

package/dist/emblems/ball/ball.polyhedra.js

@@ -0,0 +1,63 @@
+// The truncated icosahedron: the 32 panels of a classic soccer ball (12 pentagons and 20 hexagons), as rings of unit vectors. Each vertex is on an edge of an icosahedron, a third of the way
+// along it; the edges between vertices follow the sphere (spherical interpolation), so the panels bulge as an inflated ball's do.
+import { add, arc, cross, dot, mul, norm, slerp, sub } from "./ball.math.js";
+const PHI = (1 + Math.sqrt(5)) / 2;
+let cached;
+export function truncatedIcosahedron(samples = 4) {
+    if (cached !== undefined && samples === 4)
+        return cached;
+    const verts = [];
+    for (const a of [-1, 1])
+        for (const b of [-PHI, PHI])
+            verts.push(norm([0, a, b]), norm([a, b, 0]), norm([b, 0, a]));
+    const near = (a, b) => Math.abs(dot(a, b) - 1 / Math.sqrt(5)) < 1e-6;
+    const third = (a, b) => slerp(verts[a], verts[b], 1 / 3);
+    const pentagons = [];
+    const pentagonCentres = [];
+    verts.forEach((c, i) => {
+        const nb = verts.map((_, j) => j).filter((j) => j !== i && near(c, verts[j]));
+        const ex = norm(sub(verts[nb[0]], mul(c, dot(verts[nb[0]], c))));
+        const ey = cross(c, ex);
+        nb.sort((p, q) => Math.atan2(dot(verts[p], ey), dot(verts[p], ex)) - Math.atan2(dot(verts[q], ey), dot(verts[q], ex)));
+        pentagons.push(nb.map((j) => third(i, j)));
+        pentagonCentres.push(c);
+    });
+    const hexagons = [];
+    const hexagonCentres = [];
+    const hexagonPentagonSides = [];
+    for (let i = 0; i < 12; i++) {
+        for (let j = i + 1; j < 12; j++) {
+            if (!near(verts[i], verts[j]))
+                continue;
+            for (let k = j + 1; k < 12; k++) {
+                if (!near(verts[i], verts[k]) || !near(verts[j], verts[k]))
+                    continue;
+                hexagons.push([third(i, j), third(j, i), third(j, k), third(k, j), third(k, i), third(i, k)]);
+                hexagonCentres.push(norm(add(add(verts[i], verts[j]), verts[k])));
+                // The edges P(i,k)-P(i,j), P(j,i)-P(j,k) and P(k,j)-P(k,i) touch a pentagon (the one at i, j and k).
+                const mid = (a, b) => norm(add(a, b));
+                hexagonPentagonSides.push([mid(third(i, k), third(i, j)), mid(third(j, i), third(j, k)), mid(third(k, j), third(k, i))]);
+            }
+        }
+    }
+    const seen = new Set();
+    const edges = [];
+    for (const ring of [...pentagons, ...hexagons]) {
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i], b = ring[(i + 1) % ring.length];
+            const key = [a, b].map((v) => v.map((x) => Math.round(x * 1000)).join(",")).sort().join("|");
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            edges.push(arc(a, b, samples));
+        }
+    }
+    const result = { pentagons, hexagons, pentagonCentres, hexagonCentres, edges, hexagonPentagonSides };
+    if (samples === 4)
+        cached = result;
+    return result;
+}
+/** A ring pulled toward its centre by a fraction, on the sphere: the face inside the seam. */
+export function shrink(ring, centre, by) {
+    return ring.map((p) => norm(add(mul(p, 1 - by), mul(centre, by))));
+}

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

@@ -0,0 +1,3 @@
+export declare const BALL_PUCK: import("./ball.core.ts").Piece<{
+    slices: number;
+}>;

package/dist/emblems/ball/ball.puck.js

@@ -0,0 +1,22 @@
+// Ice hockey puck: vulcanised black rubber, 76.2 mm across and 25.4 mm thick (so 1 : 3), with a ridged edge. Drawn as a cylinder in true 3D, so it turns.
+import { drawStack } from "./ball.stack.js";
+import { defineObject } from "./ball.object.js";
+const H = 25.4 / 76.2 / 2;
+export const BALL_PUCK = /* @__PURE__ */ defineObject({
+    id: "ball:puck",
+    en: "Hockey puck",
+    ja: "アイスホッケーのパック",
+    size: { extentMm: 76, diameterMm: 76, thicknessMm: 25, massG: [156, 170], rule: "IIHF Official Rule Book, Rule 13 Puck, 13.1 Dimensions (the puck is Rule 13, not Rule 1)", note: "IIHF figures, rounded as the rule rounds them (the NHL puck is 3 in by 1 in). Colour is not stated in the rule." },
+    view: { yaw: 0, pitch: 36, roll: -8 },
+    model: { slices: 1 },
+    draw: (c) => drawStack(c, {
+        slices: [{ y0: -H, y1: H, r: 1, colour: "#26282d", outline: true }],
+        top: "#2e3036",
+        bottom: "#2e3036",
+        gloss: 0.5,
+        shade: "#000",
+        grain: { f: 1.6, a: 0.25 },
+        grooves: { count: 30, slices: [0], colour: "#000", opacity: 0.5 },
+        topRing: { r: 0.9, colour: "#4a4d56" },
+    }),
+});

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

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

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, 2 yellow dots", "スカッシュ球（ダブルイエロー）", "#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;
+};