@johnmorrisdotca/dougu-sports 0.0.1 → 0.1.0

package/dist/emblems/ball/ball.gaelic.js

@@ -0,0 +1,30 @@
+// Gaelic football and netball: panelled spheres. The panelling is not set by the rules; ours is the 18-panel layout (six faces of three strips), the Gaelic ball white with a green strip on
+// each face and the netball in orange and cream.
+import { defineBall } from "./ball.engine.js";
+import { strips18 } from "./ball.family.panelled.js";
+export const BALL_GAELIC_FOOTBALL = /* @__PURE__ */ defineBall({
+    id: "ball:gaelic-football",
+    en: "Gaelic football",
+    ja: "ゲーリックフットボールのボール",
+    size: { extentMm: 219.6, diameterMm: 219.6, circumferenceMm: 690.0, massG: [480, 500], rule: "GAA Official Guide Part 2, Rules of Specification, Rule 4.4(ii)", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 28, pitch: 22, roll: 0 },
+        base: "#13935a",
+        ground: "#f7f6f0",
+        mat: { gloss: 0.6, shade: "#18304a", grain: { f: 1.2, a: 0.2 } },
+        draw: (s, base) => strips18(s, [["#f7f6f0", base]], "#5a6a60", 1.25),
+    },
+});
+export const BALL_NETBALL = /* @__PURE__ */ defineBall({
+    id: "ball:netball",
+    en: "Netball",
+    ja: "ネットボール",
+    size: { extentMm: 222.8, diameterMm: 222.8, circumferenceMm: 700.0, massG: [400, 450], rule: "World Netball Rules of Netball, Rule 1 (Equipment: Ball), item 15 a-d", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 28, pitch: 22, roll: 0 },
+        base: "#ea8a2a",
+        ground: "#fbeed8",
+        mat: { gloss: 0.5, shade: "#4a2208", grain: { f: 1.2, a: 0.22 } },
+        draw: (s, base) => strips18(s, [[base, "#fbeed8"], ["#fbeed8", base]], "#7a4a28", 1.25),
+    },
+});

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

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

package/dist/emblems/ball/ball.golf.js

@@ -0,0 +1,15 @@
+// Golf ball (not one of our sports; a bonus): white, with a dimple pattern. The rules fix the size and mass, not the dimples.
+import { dottedBall } from "./ball.family.dotted.js";
+export const BALL_GOLF = /* @__PURE__ */ dottedBall({
+    id: "ball:golf",
+    en: "Golf ball",
+    ja: "ゴルフボール",
+    size: { extentMm: 42.67, diameterMm: 42.67, massG: [0, 45.93], rule: "Rules of Equipment (R&A / USGA), Part 4 Conformance of Balls, 4.2 Weight and 4.3 Size", note: "A minimum diameter and a maximum mass: the rules set no maximum size and no minimum weight." },
+    base: "#f7f7f5",
+    count: 190,
+    radius: 0.066,
+    depth: 0.2,
+    light: false,
+    mark: "#5a6070",
+    mat: { gloss: 0.85, shade: "#2a3350", grain: undefined },
+});

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

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

package/dist/emblems/ball/ball.hammer.js

@@ -0,0 +1,31 @@
+// Hammer (the athletics throw): a steel ball, a wire and a grip. The wire is drawn shorter than it is (the rule allows 1.215 m overall), so that the head is still big enough to read.
+import { defineBall } from "./ball.engine.js";
+import { add, cross, mul, norm } from "./ball.math.js";
+const D = norm([0.72, -0.66, 0.2]);
+const U = norm(cross(D, [0, 0, 1]));
+const HEAD = mul(D, -1.25);
+const WIRE_START = -0.25;
+const WIRE_END = 1.25;
+export const BALL_HAMMER = /* @__PURE__ */ defineBall({
+    id: "ball:hammer",
+    en: "Hammer",
+    ja: "ハンマー（ハンマー投）",
+    size: { extentMm: 273, diameterMm: 120, massG: [7260, 7260], rule: "World Athletics Technical Rules (C2.1), Rule 36 Hammer Throw - 'The hammer shall conform to the following specifications' and construction text", note: "Men's hammer, whose head is 110 to 130 mm across. The wire is drawn about a fifth of its length, so the scale is that of the head; the rules give only a maximum overall length (1215 mm)." },
+    spec: {
+        fit: 0.44,
+        at: HEAD,
+        view: { yaw: 0, pitch: 0, roll: 0 },
+        base: "#7e8791",
+        mat: { gloss: 0.95, shade: "#0a0e14", metal: true },
+        draw: () => "",
+        attach: (s) => {
+            const p = (v) => s.space(v);
+            const a = p(mul(D, WIRE_START)), b = p(mul(D, WIRE_END));
+            const g1 = p(add(mul(D, WIRE_END), mul(U, 0.42))), g2 = p(add(mul(D, WIRE_END), mul(U, -0.42))), g3 = p(add(mul(D, WIRE_END + 0.5), mul(U, 0)));
+            const wire = `<path d="M${a[0].toFixed(1)} ${a[1].toFixed(1)}L${b[0].toFixed(1)} ${b[1].toFixed(1)}" stroke="${s.line ? "currentColor" : "#aeb5be"}" stroke-width="${Math.max(0.9, s.minWidth)}" stroke-linecap="round" fill="none"/>`;
+            const grip = `<path d="M${g1[0].toFixed(1)} ${g1[1].toFixed(1)}L${g3[0].toFixed(1)} ${g3[1].toFixed(1)}L${g2[0].toFixed(1)} ${g2[1].toFixed(1)}Z" fill="none" stroke="${s.line ? "currentColor" : "#5a6270"}" stroke-width="${Math.max(2, s.minWidth * 1.5)}" stroke-linejoin="round" stroke-linecap="round"/>`;
+            const out = wire + grip;
+            return (a[2] + b[2]) / 2 < 0 ? { behind: out, front: "" } : { behind: "", front: out };
+        },
+    },
+});

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

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

package/dist/emblems/ball/ball.handball.js

@@ -0,0 +1,25 @@
+// Handball: a 32-panel ball (twelve pentagons, twenty hexagons) with a sticky matt grip, here in navy and yellow of our own choosing.
+import { defineBall } from "./ball.engine.js";
+import { truncatedIcosahedron } from "./ball.polyhedra.js";
+import { mix } from "./ball.core.js";
+export const BALL_HANDBALL = /* @__PURE__ */ defineBall({
+    id: "ball:handball",
+    en: "Handball",
+    ja: "ハンドボール",
+    size: { extentMm: 187.8, diameterMm: 187.8, circumferenceMm: 590.0, massG: [425, 475], rule: "IHF Rules of the Game (Indoor Handball), Rule 3 The Ball, 3.1-3.3; sizes 0 and 00 and panel count from IHF Ball Regulations (XIII) Articles 2 and 3", note: "IHF size 3 with resin (men and youths from 16). Diameter worked out from the middle of the circumference range. The IHF Ball Regulations ask for at least 32 panels on a leather ball." },
+    spec: {
+        view: { yaw: 30, pitch: 24, roll: 8 },
+        base: "#1f3f8f",
+        ground: "#f1c21b",
+        mat: { gloss: 0.3, shade: "#1a1a30", grain: { f: 1.3, a: 0.22 } },
+        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, mix(base, -0.45), 1.15);
+            out += s.strokes(t.edges, "#fff", 0.4, { deco: true, opacity: 0.35, dx: 0.3, dy: 0.35 });
+            return out;
+        },
+    },
+});

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

@@ -0,0 +1,48 @@
+import type { BallFrameOptions, Piece, PieceOptions, PieceSize } from "./ball.core.ts";
+/** Every ball, in the order a gallery shows them. */
+export declare const BALLS: readonly Piece[];
+/** The id of every ball: `"ball:soccer"`, `"ball:cricket-red"`. */
+export declare const BALL_IDS: readonly string[];
+/** A ball by its id, or by its name without the `ball:` (`"soccer"`). An unknown name is an error that lists the ids. */
+export declare function ballOf(name: string): Piece;
+/** True when the text is the id of a ball (or a ball's name without `ball:`). */
+export declare const isBallId: (name: unknown) => name is string;
+/** A ball as a document of SVG: `renderBall("soccer", { size: 64 })`, or in the line style `renderBall("ball:puck", { style: "line" })`. The same arguments give the same string. */
+export declare function renderBall(name: string, options?: PieceOptions): string;
+/**
+ * A ball turned: `yaw` degrees about its own vertical axis, `pitch` of tilt toward you and `roll` about the line of sight, all added to the ball's default 3/4 view, so `yaw` from 0 to 360 is one turn
+ * of a turntable. The grain stays out of a turning ball. Every ball is drawn in true 3D: the seams, panels and marks are on the sphere and turn with it.
+ * @example
+ * ```ts
+ * import { ballFrame } from "@johnmorrisdotca/kyogijo-stadiums/balls";
+ * const frames = [0, 60, 120, 180, 240, 300].map((yaw) => ballFrame("soccer", { yaw, size: 48 }));
+ * console.log(frames.length, frames[0].startsWith("<svg"));
+ * // 6 true
+ * ```
+ */
+export declare function ballFrame(name: string, options?: BallFrameOptions): string;
+/** The official size of a ball, with the rule it comes from. */
+export declare function ballSize(name: string): PieceSize | undefined;
+export interface LineupOptions extends PieceOptions {
+    /** `true` (the default): each ball at its real size next to the others. `same`: every ball as large as the largest. */
+    scale?: "true" | "same";
+    /** The height of the tallest ball in pixels (96 by default). */
+    height?: number;
+    /** The gap between two balls, in pixels (8 by default). */
+    gap?: number;
+    /** `bottom` (the default: they stand on one line) or `centre`. */
+    align?: "bottom" | "centre";
+}
+/**
+ * Several balls side by side. At the true scale each ball is as big, next to the others, as the rulebook makes it: a puck beside a basketball looks right. `extentMm` is what a ball's drawing is
+ * scaled by (the ball's largest size in a box of 92 units), so the sizes are the rules' sizes, not a guess. The result is one document of SVG.
+ * @example
+ * ```ts
+ * import { lineup } from "@johnmorrisdotca/kyogijo-stadiums/balls";
+ * const svg = lineup(["golf", "tennis", "soccer", "puck"], { scale: "true", height: 80 });
+ * console.log(svg.includes("<title>"));
+ * // true
+ * ```
+ */
+export declare function lineup(names: readonly string[], options?: LineupOptions): string;
+export type { BallFrameOptions, Piece, PieceOptions, PieceSize, PieceStyle, PieceTheme } from "./ball.core.ts";

package/dist/emblems/ball/ball.index.js

@@ -0,0 +1,103 @@
+import { escape, num, resolveOptions, PIECE_INK } from "./ball.core.js";
+import { BALL_AFL } from "./ball.afl.js";
+import { BALL_BASEBALL } from "./ball.baseball.js";
+import { BALL_BASKETBALL } from "./ball.basketball.js";
+import { BALL_BASKETBALL_3X3 } from "./ball.basketball3x3.js";
+import { BALL_BASKETBALL_6 } from "./ball.basketball6.js";
+import { BALL_CRICKET_RED, BALL_CRICKET_WHITE, BALL_CRICKET_PINK } from "./ball.cricket.js";
+import { BALL_CURLING_STONE } from "./ball.curlingstone.js";
+import { BALL_DISCUS } from "./ball.discus.js";
+import { BALL_FIELD_HOCKEY } from "./ball.fieldhockey.js";
+import { BALL_FOOTBALL, BALL_FOOTBALL_CFL, BALL_FOOTBALL_IFAF } from "./ball.football.js";
+import { BALL_GAELIC_FOOTBALL, BALL_NETBALL } from "./ball.gaelic.js";
+import { BALL_GOLF } from "./ball.golf.js";
+import { BALL_HAMMER } from "./ball.hammer.js";
+import { BALL_HANDBALL } from "./ball.handball.js";
+import { BALL_PADEL } from "./ball.padel.js";
+import { BALL_PICKLEBALL_OUTDOOR, BALL_PICKLEBALL_INDOOR } from "./ball.pickleball.js";
+import { BALL_PUCK } from "./ball.puck.js";
+import { BALL_ROUNDNET } from "./ball.roundnet.js";
+import { BALL_RUGBY } from "./ball.rugby.js";
+import { BALL_SEPAK_TAKRAW } from "./ball.sepaktakraw.js";
+import { BALL_SHUTTLECOCK_FEATHER, BALL_SHUTTLECOCK_NYLON } from "./ball.shuttlecock.js";
+import { BALL_SLIOTAR } from "./ball.sliotar.js";
+import { BALL_LACROSSE, BALL_RACQUETBALL, BALL_TABLE_TENNIS, BALL_SHOT } from "./ball.smooth.js";
+import { BALL_SOCCER, BALL_SOCCER_COLOUR } from "./ball.soccer.js";
+import { BALL_SOFTBALL } from "./ball.softball.js";
+import { BALL_SQUASH_DOUBLE_YELLOW, BALL_SQUASH_YELLOW, BALL_SQUASH_RED, BALL_SQUASH_BLUE, BALL_SQUASH_GREEN } from "./ball.squash.js";
+import { BALL_TENNIS } from "./ball.tennis.js";
+import { BALL_TEQBALL } from "./ball.teqball.js";
+import { BALL_VOLLEYBALL, BALL_VOLLEYBALL_8, BALL_BEACH_VOLLEYBALL } from "./ball.volleyball.js";
+import { BALL_WATER_POLO } from "./ball.waterpolo.js";
+/** Every ball, in the order a gallery shows them. */
+export const BALLS = [BALL_SOCCER, BALL_SOCCER_COLOUR, BALL_TEQBALL, BALL_BASKETBALL, BALL_BASKETBALL_6, BALL_BASKETBALL_3X3, BALL_BASEBALL, BALL_SOFTBALL, BALL_TENNIS, BALL_PADEL, BALL_SLIOTAR, BALL_VOLLEYBALL, BALL_VOLLEYBALL_8, BALL_BEACH_VOLLEYBALL, BALL_CRICKET_RED, BALL_CRICKET_WHITE, BALL_CRICKET_PINK, BALL_FOOTBALL, BALL_FOOTBALL_CFL, BALL_FOOTBALL_IFAF, BALL_RUGBY, BALL_AFL, BALL_GAELIC_FOOTBALL, BALL_NETBALL, BALL_PICKLEBALL_OUTDOOR, BALL_PICKLEBALL_INDOOR, BALL_SQUASH_DOUBLE_YELLOW, BALL_SQUASH_YELLOW, BALL_SQUASH_GREEN, BALL_SQUASH_RED, BALL_SQUASH_BLUE, BALL_RACQUETBALL, BALL_LACROSSE, BALL_FIELD_HOCKEY, BALL_TABLE_TENNIS, BALL_HANDBALL, BALL_WATER_POLO, BALL_GOLF, BALL_PUCK, BALL_CURLING_STONE, BALL_SHOT, BALL_DISCUS, BALL_HAMMER, BALL_SEPAK_TAKRAW, BALL_ROUNDNET, BALL_SHUTTLECOCK_FEATHER, BALL_SHUTTLECOCK_NYLON];
+/** The id of every ball: `"ball:soccer"`, `"ball:cricket-red"`. */
+export const BALL_IDS = BALLS.map((b) => b.id);
+const TABLE = new Map(BALLS.map((b) => [b.id, b]));
+/** A ball by its id, or by its name without the `ball:` (`"soccer"`). An unknown name is an error that lists the ids. */
+export function ballOf(name) {
+    const found = TABLE.get(name.startsWith("ball:") ? name : `ball:${name}`);
+    if (found === undefined)
+        throw new Error(`Unknown ball "${name}". The ids are ${BALL_IDS.join(", ")}.`);
+    return found;
+}
+/** True when the text is the id of a ball (or a ball's name without `ball:`). */
+export const isBallId = (name) => typeof name === "string" && TABLE.has(name.startsWith("ball:") ? name : `ball:${name}`);
+/** A ball as a document of SVG: `renderBall("soccer", { size: 64 })`, or in the line style `renderBall("ball:puck", { style: "line" })`. The same arguments give the same string. */
+export function renderBall(name, options) {
+    return ballOf(name).svg(options);
+}
+/**
+ * A ball turned: `yaw` degrees about its own vertical axis, `pitch` of tilt toward you and `roll` about the line of sight, all added to the ball's default 3/4 view, so `yaw` from 0 to 360 is one turn
+ * of a turntable. The grain stays out of a turning ball. Every ball is drawn in true 3D: the seams, panels and marks are on the sphere and turn with it.
+ * @example
+ * ```ts
+ * import { ballFrame } from "@johnmorrisdotca/kyogijo-stadiums/balls";
+ * const frames = [0, 60, 120, 180, 240, 300].map((yaw) => ballFrame("soccer", { yaw, size: 48 }));
+ * console.log(frames.length, frames[0].startsWith("<svg"));
+ * // 6 true
+ * ```
+ */
+export function ballFrame(name, options) {
+    return ballOf(name).frame(options);
+}
+/** The official size of a ball, with the rule it comes from. */
+export function ballSize(name) {
+    return ballOf(name).size;
+}
+/**
+ * Several balls side by side. At the true scale each ball is as big, next to the others, as the rulebook makes it: a puck beside a basketball looks right. `extentMm` is what a ball's drawing is
+ * scaled by (the ball's largest size in a box of 92 units), so the sizes are the rules' sizes, not a guess. The result is one document of SVG.
+ * @example
+ * ```ts
+ * import { lineup } from "@johnmorrisdotca/kyogijo-stadiums/balls";
+ * const svg = lineup(["golf", "tennis", "soccer", "puck"], { scale: "true", height: 80 });
+ * console.log(svg.includes("<title>"));
+ * // true
+ * ```
+ */
+export function lineup(names, options) {
+    const pieces = names.map(ballOf);
+    const height = typeof options?.height === "number" && Number.isFinite(options.height) && options.height > 0 ? Math.min(options.height, 2000) : 96;
+    const gap = typeof options?.gap === "number" && Number.isFinite(options.gap) && options.gap >= 0 ? Math.min(options.gap, 400) : 8;
+    const trueScale = options?.scale !== "same";
+    const largest = Math.max(...pieces.map((p) => p.size?.extentMm ?? 1), 1);
+    // Pixels per box unit: the largest piece's box is `height` tall.
+    const boxes = pieces.map((p) => (trueScale ? (height * (p.size?.extentMm ?? largest)) / largest : height));
+    const width = boxes.reduce((sum, b) => sum + b, 0) + gap * Math.max(0, pieces.length - 1);
+    const resolved = resolveOptions(options);
+    const colour = resolved.theme === "dark" ? PIECE_INK.dark : resolved.theme === "inherit" ? "" : PIECE_INK.light;
+    const auto = resolved.theme === "auto" ? `<style>@media(prefers-color-scheme:dark){svg{color:${PIECE_INK.dark}}}</style>` : "";
+    let x = 0;
+    const parts = pieces.map((p, i) => {
+        const box = boxes[i];
+        const doc = p.svg({ ...options, size: Math.max(1, box) });
+        const inner = doc.slice(doc.indexOf(">") + 1, doc.lastIndexOf("</svg>"));
+        const y = options?.align === "centre" ? (height - box) / 2 : height - box;
+        const out = `<g transform="translate(${num(x, 2)} ${num(y, 2)}) scale(${num(box / 100, 4)})">${inner}</g>`;
+        x += box + gap;
+        return out;
+    });
+    const title = `Balls at ${trueScale ? "their true relative sizes" : "one size"}: ${pieces.map((p) => p.en).join(", ")}`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${num(width, 2)} ${num(height, 2)}" width="${num(width, 2)}" height="${num(height, 2)}" role="img"${colour === "" ? "" : ` color="${colour}"`}><title>${escape(title)}</title>${auto}${parts.join("")}</svg>`;
+}

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

@@ -0,0 +1,38 @@
+export type V3 = readonly [number, number, number];
+export type M3 = readonly [V3, V3, V3];
+export declare const dot: (a: V3, b: V3) => number;
+export declare const add: (a: V3, b: V3) => V3;
+export declare const sub: (a: V3, b: V3) => V3;
+export declare const mul: (a: V3, k: number) => V3;
+export declare const cross: (a: V3, b: V3) => V3;
+export declare const len: (a: V3) => number;
+export declare const norm: (a: V3) => V3;
+/** The point `t` of the way along the great circle from `a` to `b` (unit vectors): a spherical linear interpolation. */
+export declare function slerp(a: V3, b: V3, t: number): V3;
+/** A unit vector from longitude and latitude in radians: longitude 0 faces +z, 90 degrees faces +x, latitude is toward +y. */
+export declare const lonLat: (lon: number, lat: number) => V3;
+/** The rotation of a view: `yaw` about the vertical axis, then `pitch` about the horizontal one, then `roll` about the line of sight. */
+export declare function rotation(yaw: number, pitch: number, roll: number): M3;
+export declare function matmul(a: M3, b: M3): M3;
+export declare const apply: (m: M3, v: V3) => V3;
+export declare const transpose: (m: M3) => M3;
+/** Points along the great circle with this unit normal, `n` of them, starting from a chosen direction (or any) around the circle. */
+export declare function greatCircle(normal: V3, n?: number, from?: V3): V3[];
+/** Points of the small circle at angular distance `angle` (radians) from the unit axis. */
+export declare function smallCircle(axis: V3, angle: number, n?: number, from?: V3): V3[];
+/** The arc of a great circle from `a` to `b`, `n` steps (n + 1 points). */
+export declare const arc: (a: V3, b: V3, n: number) => V3[];
+/** A basis (u, w) of the plane perpendicular to the unit vector. */
+export declare function basis(a: V3): [V3, V3];
+/** Evenly spread points on a sphere (a Fibonacci spiral), `n` of them; `phase` turns the whole set about the y axis. */
+export declare function spread(n: number, phase?: number): V3[];
+/** The seam of a baseball or a tennis ball: the curve x=(1-b)cos t + b cos 3t, y=(1-b)sin t - b sin 3t, z=2sqrt(b(1-b)) sin 2t. It lies on the unit sphere for any b. */
+export declare function seamCurve(b: number, n?: number): V3[];
+/** The singular values and the angle of the ellipse that a 2 by 3 matrix makes of the unit sphere: its semi-axes (largest first) and the direction of the first, in radians. */
+export declare function ellipseOf(rows: readonly [V3, V3]): {
+    rx: number;
+    ry: number;
+    angle: number;
+};
+/** A ring's edges followed along the sphere: each edge from a vertex to the next is sampled `n` times (n = 1 keeps the vertices). */
+export declare function sampleRing(ring: readonly V3[], n: number): V3[];

package/dist/emblems/ball/ball.math.js

@@ -0,0 +1,105 @@
+// The geometry of a ball: vectors, the rotation, the curves a seam is made of. Pure functions on numbers; nothing here writes SVG.
+export const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const mul = (a, k) => [a[0] * k, a[1] * k, a[2] * k];
+export const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+export const len = (a) => Math.hypot(a[0], a[1], a[2]);
+export const norm = (a) => {
+    const l = len(a) || 1;
+    return [a[0] / l, a[1] / l, a[2] / l];
+};
+/** The point `t` of the way along the great circle from `a` to `b` (unit vectors): a spherical linear interpolation. */
+export function slerp(a, b, t) {
+    const d = Math.max(-1, Math.min(1, dot(a, b)));
+    const omega = Math.acos(d);
+    if (omega < 1e-6)
+        return a;
+    const s = Math.sin(omega);
+    return add(mul(a, Math.sin((1 - t) * omega) / s), mul(b, Math.sin(t * omega) / s));
+}
+/** A unit vector from longitude and latitude in radians: longitude 0 faces +z, 90 degrees faces +x, latitude is toward +y. */
+export const lonLat = (lon, lat) => [Math.sin(lon) * Math.cos(lat), Math.sin(lat), Math.cos(lon) * Math.cos(lat)];
+/** The rotation of a view: `yaw` about the vertical axis, then `pitch` about the horizontal one, then `roll` about the line of sight. */
+export function rotation(yaw, pitch, roll) {
+    const cy = Math.cos(yaw), sy = Math.sin(yaw), cp = Math.cos(pitch), sp = Math.sin(pitch), cr = Math.cos(roll), sr = Math.sin(roll);
+    const ry = [[cy, 0, sy], [0, 1, 0], [-sy, 0, cy]];
+    const rx = [[1, 0, 0], [0, cp, -sp], [0, sp, cp]];
+    const rz = [[cr, -sr, 0], [sr, cr, 0], [0, 0, 1]];
+    return matmul(rz, matmul(rx, ry));
+}
+export function matmul(a, b) {
+    const col = (j) => [b[0][j], b[1][j], b[2][j]];
+    const row = (i) => [dot(a[i], col(0)), dot(a[i], col(1)), dot(a[i], col(2))];
+    return [row(0), row(1), row(2)];
+}
+export const apply = (m, v) => [dot(m[0], v), dot(m[1], v), dot(m[2], v)];
+export const transpose = (m) => [[m[0][0], m[1][0], m[2][0]], [m[0][1], m[1][1], m[2][1]], [m[0][2], m[1][2], m[2][2]]];
+/** Points along the great circle with this unit normal, `n` of them, starting from a chosen direction (or any) around the circle. */
+export function greatCircle(normal, n = 96, from) {
+    const a = norm(normal);
+    const ref = from ?? (Math.abs(a[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]);
+    const u = norm(sub(ref, mul(a, dot(ref, a))));
+    const w = cross(a, u);
+    return Array.from({ length: n }, (_, i) => {
+        const t = (i / n) * 2 * Math.PI;
+        return add(mul(u, Math.cos(t)), mul(w, Math.sin(t)));
+    });
+}
+/** Points of the small circle at angular distance `angle` (radians) from the unit axis. */
+export function smallCircle(axis, angle, n = 96, from) {
+    const a = norm(axis);
+    const c = Math.cos(angle), s = Math.sin(angle);
+    return greatCircle(a, n, from).map((p) => add(mul(a, c), mul(p, s)));
+}
+/** The arc of a great circle from `a` to `b`, `n` steps (n + 1 points). */
+export const arc = (a, b, n) => Array.from({ length: n + 1 }, (_, i) => slerp(a, b, i / n));
+/** A basis (u, w) of the plane perpendicular to the unit vector. */
+export function basis(a) {
+    const ref = Math.abs(a[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0];
+    const u = norm(sub(ref, mul(a, dot(ref, a))));
+    return [u, cross(a, u)];
+}
+/** Evenly spread points on a sphere (a Fibonacci spiral), `n` of them; `phase` turns the whole set about the y axis. */
+export function spread(n, phase = 0) {
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    return Array.from({ length: n }, (_, i) => {
+        const y = 1 - ((i + 0.5) / n) * 2;
+        const r = Math.sqrt(1 - y * y);
+        const t = i * golden + phase;
+        return [Math.cos(t) * r, y, Math.sin(t) * r];
+    });
+}
+/** The seam of a baseball or a tennis ball: the curve x=(1-b)cos t + b cos 3t, y=(1-b)sin t - b sin 3t, z=2sqrt(b(1-b)) sin 2t. It lies on the unit sphere for any b. */
+export function seamCurve(b, n = 120) {
+    const o = [];
+    const z = 2 * Math.sqrt(b * (1 - b));
+    for (let i = 0; i < n; i++) {
+        const t = (i / n) * 2 * Math.PI;
+        o.push([(1 - b) * Math.cos(t) + b * Math.cos(3 * t), (1 - b) * Math.sin(t) - b * Math.sin(3 * t), z * Math.sin(2 * t)]);
+    }
+    return o;
+}
+/** The singular values and the angle of the ellipse that a 2 by 3 matrix makes of the unit sphere: its semi-axes (largest first) and the direction of the first, in radians. */
+export function ellipseOf(rows) {
+    const a = dot(rows[0], rows[0]);
+    const b = dot(rows[0], rows[1]);
+    const d = dot(rows[1], rows[1]);
+    const tr = a + d;
+    const disc = Math.sqrt(Math.max(0, ((a - d) / 2) ** 2 + b * b));
+    const l1 = tr / 2 + disc;
+    const l2 = Math.max(0, tr / 2 - disc);
+    return { rx: Math.sqrt(l1), ry: Math.sqrt(l2), angle: 0.5 * Math.atan2(2 * b, a - d) };
+}
+/** A ring's edges followed along the sphere: each edge from a vertex to the next is sampled `n` times (n = 1 keeps the vertices). */
+export function sampleRing(ring, n) {
+    if (n <= 1)
+        return [...ring];
+    const out = [];
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i], b = ring[(i + 1) % ring.length];
+        for (let j = 0; j < n; j++)
+            out.push(slerp(a, b, j / n));
+    }
+    return out;
+}

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

@@ -0,0 +1,38 @@
+import { type Piece, type PieceSize, type ResolvedOptions } from "./ball.core.ts";
+import { type M3, type V3 } from "./ball.math.ts";
+export interface ObjectView {
+    yaw: number;
+    pitch: number;
+    roll: number;
+}
+/** What an object's `draw` is given. */
+export interface ObjectContext {
+    rot: M3;
+    opts: ResolvedOptions;
+    /** True when the ball is turning: no grain. */
+    turning: boolean;
+    /** An id prefix that no other drawing of this piece in the page shares. */
+    id: string;
+    /** The thinnest line that shows at this size, in box units. */
+    minWidth: number;
+    /** A point of the object in its own space to the box: x, y and depth (positive toward you); one unit is 46 box units. */
+    at(p: V3): [number, number, number];
+}
+export interface ObjectDef<Model> {
+    id: string;
+    en: string;
+    ja: string;
+    size: PieceSize;
+    view: ObjectView;
+    /** How much of the box the object takes: its own unit is `46 * scale` box units. */
+    scale?: number;
+    /** A point of the object to put at the centre of the box. */
+    shift?: V3;
+    model: Model;
+    /** The drawing: its definitions and its body. */
+    draw: (c: ObjectContext) => {
+        defs: string;
+        body: string;
+    };
+}
+export declare function defineObject<Model>(def: ObjectDef<Model>): Piece<Model>;

package/dist/emblems/ball/ball.object.js

@@ -0,0 +1,20 @@
+// Objects that are not an ellipsoid: a puck, a stone, a shuttlecock. They share what a ball has (the rotation, the options, the shading palette and the `Piece` shape) and draw their own geometry.
+import { escape, hashOf, radians, resolveOptions, wrapPiece } from "./ball.core.js";
+import { apply, rotation } from "./ball.math.js";
+const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+export function defineObject(def) {
+    const render = (o, turning) => {
+        const opts = resolveOptions(o);
+        const rot = rotation(radians(def.view.yaw + finite(o?.yaw), 0), radians(def.view.pitch + finite(o?.pitch), 0), radians(def.view.roll + finite(o?.roll), 0));
+        const id = `k${hashOf(`${def.id}|${opts.style}|${opts.tint ?? ""}|${opts.accent ?? ""}|${rot.map((r) => r.map((x) => x.toFixed(2)).join()).join()}`)}`;
+        const at = (p) => {
+            const sh = def.shift ?? [0, 0, 0];
+            const k = def.scale ?? 1;
+            const q = apply(rot, [(p[0] - sh[0]) * k, (p[1] - sh[1]) * k, (p[2] - sh[2]) * k]);
+            return [50 + 46 * q[0], 50 - 46 * q[1], q[2]];
+        };
+        const { defs, body } = def.draw({ rot, opts, turning, id, minWidth: 80 / opts.size, at });
+        return wrapPiece({ title: escape(def.en), size: opts.size, theme: opts.theme, defs, body });
+    };
+    return { id: def.id, en: def.en, ja: def.ja, source: "generated", kind: "ball", model: def.model, size: def.size, svg: (o) => render(o, false), frame: (o) => render(o, true) };
+}

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

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

package/dist/emblems/ball/ball.padel.js

@@ -0,0 +1,13 @@
+// Padel ball: a yellow felt ball a little larger than a tennis ball's, with a seam of its own proportions.
+import { seamedBall } from "./ball.family.seamed.js";
+export const BALL_PADEL = /* @__PURE__ */ seamedBall({
+    id: "ball:padel",
+    en: "Padel ball",
+    ja: "パデルボール",
+    size: { extentMm: 65.6, diameterMm: 65.6, massG: [56.0, 59.4], rule: "FIP Rules of Padel, 'The Ball' article (as extracted in FIP Game Ball Certification Process, section B) and Appendix 'Technical specifications of the padel ball'" },
+    base: "#ecdc2c",
+    b: 0.36,
+    view: { yaw: 25, pitch: 40, roll: 15 },
+    mat: { gloss: 0.1, shade: "#5a4d06", grain: { f: 1.6, a: 0.5, seed: 5 } },
+    strip: { colour: "#fbfaf0", width: 2.2 },
+});

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

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

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>;