@johnmorrisdotca/dougu-sports 0.0.1 → 0.2.0

package/dist/emblems/ball/ball.family.seamed.js

@@ -0,0 +1,26 @@
+// Balls with the seam of a baseball or a tennis ball: one closed curve that winds twice round the sphere, x=(1-b)cos t + b cos 3t, y=(1-b)sin t - b sin 3t, z=2sqrt(b(1-b)) sin 2t.
+// A baseball and a softball have red stitches that cross it in Vs; a tennis or padel ball has a white rubber strip along it; a sliotar a raised rib.
+import { defineBall } from "./ball.engine.js";
+import { seamCurve } from "./ball.math.js";
+import { stitches } from "./ball.stitch.js";
+export function seamedBall(o) {
+    const spec = {
+        view: o.view ?? { yaw: 0, pitch: 0, roll: 0 },
+        base: o.base,
+        mat: o.mat,
+        draw: (s) => {
+            const seam = seamCurve(o.b, 160);
+            let out = "";
+            if (o.groove !== undefined)
+                out += s.stroke(seam, o.groove, 0.8, { closed: true, opacity: 0.55 });
+            if (o.strip !== undefined)
+                out += o.strip.raised === true ? s.seam(seam, o.strip.colour, o.strip.width, { closed: true }) : s.stroke(seam, o.strip.colour, o.strip.width, { closed: true });
+            if (o.stitch !== undefined)
+                out += s.strokes(stitches(seam, true, o.stitch.count, o.stitch.half, { v: true, lean: o.stitch.lean }), o.stitch.colour, o.stitch.width, { ink: false });
+            if (o.strip === undefined && o.stitch === undefined)
+                out += s.stroke(seam, "currentColor", 1.6, { closed: true });
+            return out;
+        },
+    };
+    return defineBall({ id: o.id, en: o.en, ja: o.ja, spec, size: o.size });
+}

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

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

package/dist/emblems/ball/ball.fieldhockey.js

@@ -0,0 +1,15 @@
+// Field hockey ball: a hard white plastic ball with dimples.
+import { dottedBall } from "./ball.family.dotted.js";
+export const BALL_FIELD_HOCKEY = /* @__PURE__ */ dottedBall({
+    id: "ball:field-hockey",
+    en: "Field hockey ball",
+    ja: "フィールドホッケーボール",
+    size: { extentMm: 73.0, diameterMm: 73.0, circumferenceMm: 229.5, massG: [156, 163], rule: "FIH Rules of Hockey, Equipment section 3 Ball, 3.1 a-e", note: "Diameter worked out from the middle of the circumference range." },
+    base: "#f6f6f2",
+    count: 110,
+    radius: 0.088,
+    depth: 0.22,
+    light: false,
+    mark: "#6a7080",
+    mat: { gloss: 0.85, shade: "#2a3350", grain: undefined },
+});

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

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

package/dist/emblems/ball/ball.football.js

@@ -0,0 +1,51 @@
+// American and Canadian football: a pebbled leather ball drawn as a prolate shape whose ends come to a point (`point` in the spec), a ball ("natural tan" in the NFL and IFAF rules), with four panels and a row of laces on one seam. The Canadian ball has a
+// 1-inch white stripe all the way round near each end (CFL Rule 1, Section 2); the IFAF ball has a stripe near each end on the two panels next to the laces only (IFAF Rule 1, Section 3).
+import { defineBall } from "./ball.engine.js";
+import { footballSeams, laces, tipRing } from "./ball.family.prolate.js";
+import { mix } from "./ball.core.js";
+/** The part of a ring that lies on the laces' side (y at or above 0), as one run: the ring is turned to start below it. */
+const upperArc = (ring) => {
+    const k = ring.findIndex((p) => p[1] < 0);
+    const turned = [...ring.slice(k), ...ring.slice(0, k)];
+    const run = [];
+    for (const p of turned)
+        if (p[1] >= 0)
+            run.push(p);
+    return run;
+};
+const BROWN = "#8b4a21";
+const AXES = [1, 0.55, 0.55];
+const VIEW = { yaw: -20, pitch: 35, roll: -35 };
+const MAT = { gloss: 0.5, shade: "#2a1006", grain: { f: 0.95, a: 0.42 } };
+function football(id, en, ja, size, stripes, colour) {
+    return defineBall({
+        id,
+        en,
+        ja,
+        size,
+        spec: {
+            axes: AXES,
+            point: 0.85,
+            view: VIEW,
+            base: colour,
+            mat: MAT,
+            draw: (s, base) => {
+                let out = "";
+                if (stripes === "ring")
+                    for (const sign of [1, -1])
+                        out += s.stroke(tipRing(sign, 0.99), "#f4f0e6", 7, { closed: true, ink: false });
+                if (stripes === "top")
+                    for (const sign of [1, -1])
+                        out += s.stroke(upperArc(tipRing(sign, 1.1, 96)), "#f4f0e6", 7, { ink: false });
+                out += s.strokes(footballSeams(), mix(base, -0.55), 1.1);
+                out += s.strokes(footballSeams(), mix(base, 0.4), 0.45, { deco: true, opacity: 0.45, dx: 0.25, dy: 0.3 });
+                out += laces(s, "#f4f0e6", mix(base, -0.7));
+                return out;
+            },
+        },
+    });
+}
+const SIZE = { extentMm: 282.6, lengthMm: 282.6, circumferenceMm: 536.58, longCircumferenceMm: 717.55, massG: [396.89, 425.24], rule: "NFL Rulebook, Rule 2 The Ball, Section 1 (Dimensions)" };
+export const BALL_FOOTBALL = /* @__PURE__ */ football("ball:football", "Football (NFL)", "アメフトボール（NFL）", SIZE, "none", BROWN);
+export const BALL_FOOTBALL_CFL = /* @__PURE__ */ football("ball:football-cfl", "Football (CFL)", "フットボール（CFL）", { extentMm: 282.6, lengthMm: 282.6, circumferenceMm: 536.58, longCircumferenceMm: 717.55, massG: [396.89, 425.24], rule: "CFL Official Playing Rules, Rule 1 Conduct of the Game, Section 2 The Ball" }, "ring", BROWN);
+export const BALL_FOOTBALL_IFAF = /* @__PURE__ */ football("ball:football-ifaf", "Football (IFAF)", "アメフトボール（IFAF）", { extentMm: 283.4, lengthMm: 283.4, circumferenceMm: 533.4, longCircumferenceMm: 714.38, massG: [396.89, 425.24], rule: "IFAF Football Rules and Interpretations 2026, Rule 1 (The Game, Field, Players and Equipment), Section 3 The Ball, Article 1 a-i", note: "The IFAF figures are in a diagram of the rules, read from the rendered page." }, "top", "#a8693a");

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

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

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, labelled, 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: labelled(def.en, def.ja, (o) => render(o, false)), frame: labelled(def.en, def.ja, (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>;