@johnmorrisdotca/dougu-sports 0.0.1 → 0.1.0

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

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

package/dist/emblems/ball/ball.basketball6.js

@@ -0,0 +1,10 @@
+// Basketball, size 6 (women's competitions): the same pattern a little smaller, here a shade lighter.
+import { defineBall } from "./ball.engine.js";
+import { basketballSpec } from "./ball.basketball.js";
+export const BALL_BASKETBALL_6 = /* @__PURE__ */ defineBall({
+    id: "ball:basketball-6",
+    en: "Basketball, size 6",
+    ja: "バスケットボール（6号球）",
+    size: { extentMm: 230.0, diameterMm: 230.0, circumferenceMm: 722.5, massG: [510, 550], rule: "FIBA Basketball Equipment 2026, Rule 2 Basketballs, 2.4 and Table 1 (size 6 = women's competitions)", note: "Diameter worked out from the middle of the circumference range." },
+    spec: basketballSpec("#e57a26"),
+});

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

@@ -0,0 +1,105 @@
+/** `metal` (also written `colour`): full colour, with shading. `line`: one outline in `currentColor`. */
+export type PieceStyle = "metal" | "colour" | "color" | "line";
+/** `inherit` (the default): the page's text colour. `auto`: dark ink on a light device and pale ink on a dark one. `light` and `dark` force one. */
+export type PieceTheme = "inherit" | "auto" | "light" | "dark";
+export interface PieceOptions {
+    /** `metal` or `colour` (the default) or `line`. */
+    style?: PieceStyle;
+    /** The width and height in pixels (64 by default); the drawing is a vector at any size. */
+    size?: number;
+    /** A colour that replaces the main colour of the piece, where it has one. A hex colour or `rgb()`; anything else is ignored. */
+    tint?: string;
+    theme?: PieceTheme;
+    /** A second colour, where a piece has one (laces, a stripe). */
+    accent?: string;
+    /** Force the grain on or off. By default it is on for a colour ball of 48 pixels or more that is not turning. */
+    grain?: boolean;
+}
+/** A turn: `yaw` degrees about the vertical axis (0 is the default view), `pitch` the tilt toward you, `roll` the turn about the line of sight. */
+export interface BallFrameOptions extends PieceOptions {
+    yaw?: number;
+    pitch?: number;
+    roll?: number;
+}
+/** Where a drawing comes from. */
+export type PieceSource = "generated" | "drawn" | "noto" | "mdi" | "commons" | "gameicons";
+/** `ball` is turned in 3D; `gear` is a flat drawing in a colour and a line style. */
+export type PieceKind = "ball" | "gear";
+/** The official size of a ball or an implement, from the rulebook that governs it. Lengths in millimetres, mass in grams. */
+export interface PieceSize {
+    /** The largest extent of the drawing (a ball's diameter, a football's length), in millimetres: the scale `lineup` draws at. */
+    extentMm: number;
+    /** Across a sphere or a disc. */
+    diameterMm?: number;
+    /** End to end, for a prolate ball or an implement. */
+    lengthMm?: number;
+    /** The width across the middle of a prolate ball, or a stone's height, a puck's thickness. */
+    thicknessMm?: number;
+    /** Round the middle, for a ball the rulebook measures that way. */
+    circumferenceMm?: number;
+    /** Round the long way, for a prolate ball. */
+    longCircumferenceMm?: number;
+    massG?: readonly [number, number];
+    /** The rule the figures are from: document, edition and rule number. */
+    rule: string;
+    /** Anything the figures leave out, such as a figure that is the middle of a range or a part drawn shorter than it is. */
+    note?: string;
+}
+/** One ball or piece of gear. */
+export interface Piece<Model = unknown> {
+    readonly id: string;
+    readonly en: string;
+    readonly ja: string;
+    readonly source: PieceSource;
+    readonly kind: PieceKind;
+    readonly model: Model;
+    /** The official size, where the rulebook gives one. */
+    readonly size?: PieceSize;
+    /** The still drawing: a document of SVG. */
+    svg: (options?: PieceOptions) => string;
+    /** The piece turned (a ball in 3D; gear is drawn as it is). */
+    frame: (options?: BallFrameOptions) => string;
+}
+type Rgb = readonly [number, number, number];
+export declare function readColour(value: string | undefined): Rgb | undefined;
+export declare const hexOf: (rgb: Rgb) => string;
+/** A colour mixed toward black (`amount` below 0) or white (above 0). */
+export declare function mix(colour: string, amount: number): string;
+/** Two colours mixed: `t` 0 is `a`, 1 is `b`. */
+export declare function blend(a: string, b: string, t: number): string;
+/** Text made safe to write between tags and inside a double-quoted attribute. */
+export declare const escape: (text: string) => string;
+/** A number written short: at most `digits` decimals, no trailing zeros, no `-0`. */
+export declare const num: (value: number, digits?: number) => string;
+/** A short stable hash of some text, for ids that two drawings of one piece agree on. */
+export declare function hashOf(text: string): string;
+/** The options as the renderers use them. */
+export interface ResolvedOptions {
+    style: "colour" | "line";
+    size: number;
+    theme: PieceTheme;
+    tint: string | undefined;
+    accent: string | undefined;
+    grain: boolean | undefined;
+}
+export declare function resolveOptions(o: PieceOptions | undefined): ResolvedOptions;
+/** The ink of a drawing when a theme sets it, and the page it is made to read on. */
+export declare const PIECE_INK: {
+    readonly light: "#20262d";
+    readonly dark: "#eef1f3";
+};
+/** A drawing wrapped into a document, in a 100 by 100 box: the title, the outline's colour for the theme, the definitions and the body. */
+export declare function wrapPiece(o: {
+    title: string;
+    size: number;
+    theme: PieceTheme;
+    defs?: string;
+    body: string;
+    box?: string;
+    desc?: string;
+}): string;
+/** Degrees to radians, for a value that may be missing or not a number. */
+export declare const radians: (degrees: number | undefined, fallback: number) => number;
+/** The definition of the grain filter: noise lit from the upper left and multiplied into what it is applied to. It works in the box's own units, so the grain stays where it is while a ball turns. */
+export declare function grainDef(id: string, f: number, a: number, seed?: number): string;
+export {};

package/dist/emblems/ball/ball.core.js

@@ -0,0 +1,66 @@
+// What every ball and every piece of gear is made of: the options, the colour helpers, the way a drawing is wrapped into a document, and the `Piece` object each one is.
+// It imports nothing, so a ball stands alone: a bundler can take one ball module without the others. The shape of a piece (`id`, `en`, `ja`, `source`, `kind`, `model`, `svg`, `frame`)
+// is the shape of an emblem in the emblem registry, so a registry can take a ball or a piece of gear as it is.
+export function readColour(value) {
+    if (value === undefined)
+        return undefined;
+    const text = value.trim();
+    const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(text)?.[1];
+    if (hex !== undefined) {
+        const full = hex.length === 3 ? [...hex].map((c) => c + c).join("") : hex;
+        return [parseInt(full.slice(0, 2), 16), parseInt(full.slice(2, 4), 16), parseInt(full.slice(4, 6), 16)];
+    }
+    const rgb = /^rgb\(\s*(\d{1,3})[\s,]+(\d{1,3})[\s,]+(\d{1,3})\s*\)$/i.exec(text);
+    return rgb === null ? undefined : [Math.min(255, Number(rgb[1])), Math.min(255, Number(rgb[2])), Math.min(255, Number(rgb[3]))];
+}
+const hex2 = (n) => Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0");
+export const hexOf = (rgb) => `#${hex2(rgb[0])}${hex2(rgb[1])}${hex2(rgb[2])}`;
+/** A colour mixed toward black (`amount` below 0) or white (above 0). */
+export function mix(colour, amount) {
+    const rgb = readColour(colour) ?? [128, 128, 128];
+    const target = amount < 0 ? 0 : 255;
+    const t = Math.abs(amount);
+    return hexOf([rgb[0] + (target - rgb[0]) * t, rgb[1] + (target - rgb[1]) * t, rgb[2] + (target - rgb[2]) * t]);
+}
+/** Two colours mixed: `t` 0 is `a`, 1 is `b`. */
+export function blend(a, b, t) {
+    const x = readColour(a) ?? [128, 128, 128];
+    const y = readColour(b) ?? [128, 128, 128];
+    return hexOf([x[0] + (y[0] - x[0]) * t, x[1] + (y[1] - x[1]) * t, x[2] + (y[2] - x[2]) * t]);
+}
+/** Text made safe to write between tags and inside a double-quoted attribute. */
+export const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+/** A number written short: at most `digits` decimals, no trailing zeros, no `-0`. */
+export const num = (value, digits = 1) => {
+    const text = (Math.round(value * 10 ** digits) / 10 ** digits).toString();
+    return text === "-0" ? "0" : text;
+};
+/** A short stable hash of some text, for ids that two drawings of one piece agree on. */
+export function hashOf(text) {
+    let h = 2166136261;
+    for (let i = 0; i < text.length; i++)
+        h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+    return (h >>> 0).toString(36);
+}
+export function resolveOptions(o) {
+    const size = typeof o?.size === "number" && Number.isFinite(o.size) && o.size > 0 ? Math.min(Math.round(o.size * 100) / 100, 4096) : 64;
+    const theme = o?.theme === "auto" || o?.theme === "light" || o?.theme === "dark" ? o.theme : "inherit";
+    const tint = readColour(o?.tint);
+    const accent = readColour(o?.accent);
+    return { style: o?.style === "line" ? "line" : "colour", size, theme, tint: tint === undefined ? undefined : hexOf(tint), accent: accent === undefined ? undefined : hexOf(accent), grain: typeof o?.grain === "boolean" ? o.grain : undefined };
+}
+/** The ink of a drawing when a theme sets it, and the page it is made to read on. */
+export const PIECE_INK = { light: "#20262d", dark: "#eef1f3" };
+/** A drawing wrapped into a document, in a 100 by 100 box: the title, the outline's colour for the theme, the definitions and the body. */
+export function wrapPiece(o) {
+    const colour = o.theme === "dark" ? PIECE_INK.dark : o.theme === "inherit" ? "" : PIECE_INK.light;
+    const auto = o.theme === "auto" ? `<style>@media(prefers-color-scheme:dark){svg{color:${PIECE_INK.dark}}}</style>` : "";
+    return (`<svg xmlns="http://www.w3.org/2000/svg" viewBox="${o.box ?? "0 0 100 100"}" width="${o.size}" height="${o.size}" role="img"${colour === "" ? "" : ` color="${colour}"`}>` +
+        `<title>${escape(o.title)}</title>${o.desc === undefined ? "" : `<desc>${escape(o.desc)}</desc>`}${auto}${o.defs === undefined || o.defs === "" ? "" : `<defs>${o.defs}</defs>`}${o.body}</svg>`);
+}
+/** Degrees to radians, for a value that may be missing or not a number. */
+export const radians = (degrees, fallback) => ((typeof degrees === "number" && Number.isFinite(degrees) ? degrees : fallback) * Math.PI) / 180;
+/** The definition of the grain filter: noise lit from the upper left and multiplied into what it is applied to. It works in the box's own units, so the grain stays where it is while a ball turns. */
+export function grainDef(id, f, a, seed = 3) {
+    return `<filter id="${id}n" x="0" y="0" width="100" height="100" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feTurbulence type="fractalNoise" baseFrequency="${f}" numOctaves="2" seed="${seed}" result="n"/><feDiffuseLighting in="n" lighting-color="#fff" surfaceScale="${a}" diffuseConstant="1.15" result="l"><feDistantLight azimuth="225" elevation="58"/></feDiffuseLighting><feBlend in="SourceGraphic" in2="l" mode="multiply"/><feComposite in2="SourceGraphic" operator="in"/></filter>`;
+}

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

@@ -0,0 +1,5 @@
+import type { Piece } from "./ball.core.ts";
+import type { BallSpec } from "./ball.engine.ts";
+export declare const BALL_CRICKET_RED: Piece<BallSpec>;
+export declare const BALL_CRICKET_WHITE: Piece<BallSpec>;
+export declare const BALL_CRICKET_PINK: Piece<BallSpec>;

package/dist/emblems/ball/ball.cricket.js

@@ -0,0 +1,31 @@
+// Cricket balls: a leather ball with one raised seam round its middle and three rows of stitches either side of it. Red for Tests, white for limited overs, pink for day-night matches.
+// The stitching is drawn the way it is sewn: 78 stitches to a row, each square across the row.
+import { defineBall } from "./ball.engine.js";
+import { greatCircle, smallCircle } from "./ball.math.js";
+import { stitches } from "./ball.stitch.js";
+import { mix } from "./ball.core.js";
+const ROWS = [0.1, 0.19, 0.28];
+const AXIS = [0.2, 1, 0.1];
+function cricket(id, en, ja, base, thread, size, shade) {
+    return defineBall({
+        id,
+        en,
+        ja,
+        size,
+        spec: {
+            view: { yaw: 20, pitch: 24, roll: -12 },
+            base,
+            mat: { gloss: 0.62, shade, grain: { f: 1.1, a: 0.16 } },
+            draw: (s, colour) => {
+                let out = s.seam(greatCircle(AXIS, 96), mix(colour, -0.12), 2.6, { closed: true });
+                const rows = ROWS.flatMap((r) => [r, -r]).map((lat) => smallCircle(AXIS, Math.PI / 2 - lat, 96));
+                out += s.strokes(rows.flatMap((row) => stitches(row, true, 78, 0.026)), thread, 0.75, { ink: false });
+                return out;
+            },
+        },
+    });
+}
+const SIZE = { extentMm: 72.1, diameterMm: 72.1, circumferenceMm: 226.5, massG: [156, 163], rule: "Laws of Cricket, Law 4 The Ball, 4.1 Weight and size (Size 1, Size 2, Size 3)", note: "Size 1 (men's). Diameter worked out from the middle of the circumference range. The Laws do not set a colour." };
+export const BALL_CRICKET_RED = /* @__PURE__ */ cricket("ball:cricket-red", "Cricket ball, red", "クリケットボール（赤）", "#a9161e", "#f2e8d2", SIZE, "#2a0408");
+export const BALL_CRICKET_WHITE = /* @__PURE__ */ cricket("ball:cricket-white", "Cricket ball, white", "クリケットボール（白）", "#f3f0e8", "#2a2a2a", SIZE, "#4a4a58");
+export const BALL_CRICKET_PINK = /* @__PURE__ */ cricket("ball:cricket-pink", "Cricket ball, pink", "クリケットボール（ピンク）", "#e45a8c", "#2a2a2a", SIZE, "#4a0a22");

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

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

package/dist/emblems/ball/ball.curlingstone.js

@@ -0,0 +1,46 @@
+// Curling stone: a granite drum with a polished striking band round its belly, a narrow running ring under it with the concave recess inside (it shows when the stone is turned over), and a
+// handle on top. The slices follow the stone's profile.
+import { drawStack } from "./ball.stack.js";
+import { defineObject } from "./ball.object.js";
+import {} from "./ball.math.js";
+import { num } from "./ball.core.js";
+const GRANITE = "#8d929a";
+const POLISHED = "#4d525b";
+const HANDLE = "#d4202c";
+export const BALL_CURLING_STONE = /* @__PURE__ */ defineObject({
+    id: "ball:curling-stone",
+    en: "Curling stone",
+    ja: "カーリングストーン",
+    size: { extentMm: 290.9, diameterMm: 290.9, thicknessMm: 114, circumferenceMm: 914, massG: [17240, 19960], rule: "World Curling The Rules of Curling, R2 Stones (a)-(j); R3(b) handle colour", note: "The largest stone the rule allows: a circumference of at most 914 mm and a height of at least 114 mm; the mass includes the handle." },
+    view: { yaw: 0, pitch: 30, roll: -6 },
+    model: { slices: 6 },
+    draw: (c) => drawStack(c, {
+        slices: [
+            { y0: -0.2, y1: -0.15, r: [0.74, 0.8], colour: POLISHED, outline: true },
+            { y0: -0.15, y1: -0.04, r: [0.8, 0.94], colour: GRANITE },
+            { y0: -0.04, y1: 0.08, r: 1, colour: POLISHED, outline: true },
+            { y0: 0.08, y1: 0.15, r: [1, 0.9], colour: GRANITE },
+            { y0: 0.15, y1: 0.2, r: [0.9, 0.78], colour: GRANITE, outline: true },
+        ],
+        top: "#9a9fa7",
+        bottom: "#6a6f78",
+        gloss: 0.5,
+        shade: "#000",
+        grain: { f: 1.9, a: 0.55 },
+        dish: { r: 0.74, colour: "#555a63" },
+        extra: (ctx) => {
+            // The handle: a post and a bar, a capsule in 3D (a thick line with round ends).
+            const post0 = ctx.at([0, 0.2, 0]), post1 = ctx.at([0, 0.34, 0]);
+            const a = [-0.42, 0.4, 0], b = [0.42, 0.4, 0];
+            const p = ctx.at(a), q = ctx.at(b);
+            const colour = ctx.opts.style === "line" ? "currentColor" : (ctx.opts.tint ?? HANDLE);
+            const line = ctx.opts.style === "line";
+            const w = (r) => (line ? Math.max(2.4, ctx.minWidth) : Math.max(92 * r, ctx.minWidth));
+            const stroke = (width) => `stroke="${colour}" stroke-width="${num(width, 2)}"`;
+            const post = `<path d="M${num(post0[0])} ${num(post0[1])}L${num(post1[0])} ${num(post1[1])}" ${stroke(w(0.075))} stroke-linecap="round" fill="none"/>`;
+            const bar = `<path d="M${num(p[0])} ${num(p[1])}L${num(q[0])} ${num(q[1])}" ${stroke(w(0.11))} stroke-linecap="round" fill="none"/>`;
+            const sheen = line ? "" : `<path d="M${num(p[0])} ${num(p[1] - 1.2)}L${num(q[0])} ${num(q[1] - 1.2)}" stroke="#fff" stroke-opacity=".35" stroke-width="${num(Math.max(0.8, 46 * 0.03), 2)}" stroke-linecap="round" fill="none"/>`;
+            return post + bar + sheen;
+        },
+    }),
+});

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

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

package/dist/emblems/ball/ball.discus.js

@@ -0,0 +1,24 @@
+// Discus: a lens, thin at the rim, with a metal plate let into each face and a metal rim. Drawn as a flattened ellipsoid.
+import { defineBall } from "./ball.engine.js";
+import { greatCircle, smallCircle } from "./ball.math.js";
+export const BALL_DISCUS = /* @__PURE__ */ defineBall({
+    id: "ball:discus",
+    en: "Discus",
+    ja: "円盤",
+    size: { extentMm: 220, diameterMm: 220, thicknessMm: 45, massG: [2000, 2000], rule: "World Athletics Technical Rules (C2.1), Rule 34 Discus Throw - 'The discus shall conform to the following specifications'", note: "Men's discus, 219 to 221 mm across the rim and 44 to 46 mm thick at the middle; 2 kg is a minimum." },
+    spec: {
+        axes: [1, 0.2, 1],
+        view: { yaw: 25, pitch: 52, roll: -12 },
+        base: "#3b3f48",
+        mat: { gloss: 0.7, shade: "#050608", grain: { f: 1.4, a: 0.12 } },
+        draw: (s) => {
+            let out = "";
+            for (const sign of [1, -1])
+                out += s.panel(smallCircle([0, sign, 0], 0.82, 72), "#b4bac3", { n: 1, ink: false });
+            for (const sign of [1, -1])
+                out += s.stroke(smallCircle([0, sign, 0], 0.82, 72), "#555b66", 0.7, { closed: true });
+            out += s.stroke(greatCircle([0, 1, 0], 96), "#cfd4dc", 1.6, { closed: true });
+            return out;
+        },
+    },
+});

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

@@ -0,0 +1,114 @@
+import { type Piece, type PieceSize, type ResolvedOptions } from "./ball.core.ts";
+import { type V3 } from "./ball.math.ts";
+/** How a ball takes the light. */
+export interface Material {
+    /** The colour of the shadowed side; by default the base colour made darker. */
+    shade?: string;
+    /** 0 (matt) to 1 (a hard bright highlight). */
+    gloss: number;
+    /** A polished metal: the sky above and the ground below are mirrored in it. */
+    metal?: boolean;
+    /** How dark the limb is, 0 to 1 (1 by default). */
+    rim?: number;
+    /** The grain: `f` is the noise's frequency per unit of the 100 by 100 box, `a` its relief. */
+    grain?: {
+        f: number;
+        a: number;
+        seed?: number;
+    };
+}
+/** What a ball's `draw` lays things with. Points are unit vectors on the sphere the ball is made on (an ellipsoid ball is stretched after). */
+export interface Surface {
+    /** True in the line style: a panel with `ink` is filled with the ink, a stroke without `deco` is drawn in it, and the rest is left out. */
+    readonly line: boolean;
+    /** The ball's radius in the box (the longest semi-axis). */
+    readonly radius: number;
+    /** The width of the thinnest line that still shows at this size, in box units. */
+    readonly minWidth: number;
+    /** The screen position of a point and how squarely it faces you (1 facing, 0 on the limb, below 0 hidden). */
+    project(u: V3): [number, number, number];
+    /** A closed polygon on the surface, cut at the limb. Its edges follow the sphere. `n` is the samples an edge gets. */
+    panel(ring: readonly V3[], fill: string, o?: {
+        ink?: boolean;
+        opacity?: number;
+        n?: number;
+    }): string;
+    /** A curve on the surface: only what faces you. `closed` joins its ends; `deco` marks a line that is not part of the ball's form (a highlight), which the line style leaves out. */
+    stroke(pts: readonly V3[], colour: string, width: number, o?: StrokeOptions): string;
+    /** Several curves drawn as one path. */
+    strokes(curves: ReadonlyArray<readonly V3[]>, colour: string, width: number, o?: StrokeOptions): string;
+    /** A raised seam: a shadow, the colour and a highlight along the curve. */
+    seam(pts: readonly V3[], colour: string, width: number, o?: {
+        closed?: boolean;
+        light?: string;
+        opacity?: number;
+    }): string;
+    /** Small round marks lying on the surface (holes, dimples, dots): each is a cap of `radius` radians round its centre. */
+    dots(centres: readonly V3[], radius: number, fill: string, o?: {
+        opacity?: number;
+        ink?: boolean;
+        light?: boolean;
+    }): string;
+    /** The facing of a point: 1 straight at you, 0 on the limb. */
+    facing(u: V3): number;
+    /** A point of space, in units of the ball's radius from its centre (not on the surface): its screen position and depth (positive is toward you). */
+    space(p: V3): [number, number, number];
+}
+export interface StrokeOptions {
+    closed?: boolean;
+    ink?: boolean;
+    deco?: boolean;
+    opacity?: number;
+    dx?: number;
+    dy?: number;
+    dash?: string;
+}
+export interface BallSpec {
+    /** The semi-axes of the ellipsoid along x, y and z before the view turns it. A sphere is `[1, 1, 1]`; a football is longer along x. */
+    axes?: V3;
+    /**
+     * Makes a prolate ball pointed at the ends. The ball is a body of revolution about its long axis whose radius at a distance x from the middle (as a fraction of the half length) is `(1 - x^2)^point`
+     * times the cross-section's semi-axis: 0.5 is the ellipsoid, and nearer 1 the ends are drawn to a point (a football's). The cross-section's two semi-axes must be equal.
+     */
+    point?: number;
+    /** The default view in degrees. */
+    view: {
+        yaw: number;
+        pitch: number;
+        roll: number;
+    };
+    /** The main colour of the ball (what `tint` replaces). */
+    base: string;
+    /** The colour the whole ball is filled with before its panels are laid on, where it is not `base` (a soccer ball is white, its pentagons are `base`). */
+    ground?: string;
+    mat: Material;
+    /** Lays the panels and seams. `base` is the main colour, or the tint; `accent` is the second colour or undefined. */
+    draw: (s: Surface, base: string, accent: string | undefined) => string;
+    /** Where the ball's centre is in the 100 by 100 box (50, 50 by default): a hammer's head sits in a corner to leave room for the wire. */
+    centre?: readonly [number, number];
+    /** Where the ball is in space, in units of its radius from the middle of the whole (0, 0, 0 by default), turned with it: a hammer's head is at one end of the hammer, which turns about its middle. */
+    at?: V3;
+    /** The fraction of the box's radius the ball takes (1 by default): a hammer's head is small, to leave room for its wire. */
+    fit?: number;
+    /** What is attached to the ball and sticks out of it (a hammer's wire and handle): drawn behind the ball or in front of it, by what is nearer to you. */
+    attach?: (s: Surface, base: string) => {
+        behind: string;
+        front: string;
+    };
+}
+/** Draws a ball: the document for a spec, the options and a turn in radians. */
+export declare function drawBall(title: string, key: string, spec: BallSpec, opts: ResolvedOptions, turn: {
+    yaw: number;
+    pitch: number;
+    roll: number;
+}, turning: boolean): string;
+/** What `defineBall` takes. */
+export interface BallDef {
+    id: string;
+    en: string;
+    ja: string;
+    spec: BallSpec;
+    size: PieceSize;
+}
+/** A ball from its definition: the `Piece` the registry and the gallery take. */
+export declare function defineBall(def: BallDef): Piece<BallSpec>;