@johnmorrisdotca/dougu-sports 0.0.1 → 0.2.0

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

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

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

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

package/dist/emblems/ball/ball.stitch.js

@@ -0,0 +1,59 @@
+// Stitches and rows along a curve on the sphere: short marks that cross a seam, spaced evenly along it.
+import { add, cross, dot, mul, norm, sub } from "./ball.math.js";
+/** The point of a closed or open curve at a fraction of its length, and the tangent there. */
+function pointAt(pts, closed, cumulative, total, f) {
+    const target = f * total;
+    let i = 0;
+    while (i < cumulative.length - 2 && cumulative[i + 1] < target)
+        i++;
+    const a = pts[i], b = pts[(i + 1) % pts.length];
+    const span = cumulative[i + 1] - cumulative[i] || 1;
+    const k = (target - cumulative[i]) / span;
+    const p = norm(add(mul(a, 1 - k), mul(b, k)));
+    return { p, t: norm(sub(b, a)) };
+}
+/** Marks across a curve: `count` marks evenly along it; a mark runs `half` radians either side of the seam and leans along it by `lean`. A `v` mark has two legs that meet on the seam (a baseball's stitch). */
+export function stitches(pts, closed, count, half, o) {
+    const n = pts.length;
+    const cumulative = [0];
+    const last = closed ? n : n - 1;
+    for (let i = 0; i < last; i++) {
+        const a = pts[i], b = pts[(i + 1) % n];
+        cumulative.push(cumulative[i] + Math.acos(Math.max(-1, Math.min(1, dot(a, b)))));
+    }
+    const total = cumulative[cumulative.length - 1];
+    const out = [];
+    const lean = o?.lean ?? 0;
+    const shift = o?.offset ?? 0;
+    for (let i = 0; i < count; i++) {
+        const f = closed ? (i + (o?.phase ?? 0)) / count : (i + 0.5) / count;
+        const { p, t } = pointAt(pts, closed, cumulative, total, f);
+        const side = norm(cross(p, t));
+        const c = norm(add(p, mul(side, shift)));
+        const a = norm(add(add(c, mul(side, half)), mul(t, -lean)));
+        const b = norm(add(sub(c, mul(side, half)), mul(t, -lean)));
+        if (o?.v === true)
+            out.push([a, norm(add(c, mul(t, lean))), b]);
+        else
+            out.push([a, b]);
+    }
+    return out;
+}
+/** A dashed row: segments of a curve, each `dash` of every `period` long as a fraction of the curve. */
+export function dashes(pts, closed, count, fill = 0.5) {
+    const n = pts.length;
+    const out = [];
+    const per = n / count;
+    for (let i = 0; i < count; i++) {
+        const from = i * per;
+        const to = from + per * fill;
+        const seg = [];
+        for (let j = Math.floor(from); j <= Math.ceil(to); j++) {
+            const idx = closed ? j % n : Math.min(j, n - 1);
+            seg.push(pts[idx]);
+        }
+        if (seg.length > 1)
+            out.push(seg);
+    }
+    return out;
+}

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

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

package/dist/emblems/ball/ball.tennis.js

@@ -0,0 +1,13 @@
+// Tennis ball: optic-yellow felt with a white strip of rubber along the seam. The felt's fuzz is the grain.
+import { seamedBall } from "./ball.family.seamed.js";
+export const BALL_TENNIS = /* @__PURE__ */ seamedBall({
+    id: "ball:tennis",
+    en: "Tennis ball",
+    ja: "テニスボール",
+    size: { extentMm: 67.0, diameterMm: 67.0, massG: [56.0, 59.4], rule: "ITF Rules of Tennis, Rule 3 The Ball and Appendix I The Ball (a)-(c)" },
+    base: "#d3e11f",
+    b: 0.33,
+    view: { yaw: 25, pitch: 40, roll: 15 },
+    mat: { gloss: 0.12, shade: "#3f4a06", grain: { f: 1.8, a: 0.55, seed: 7 } },
+    strip: { colour: "#f4f6e4", width: 2.7 },
+});

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

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

package/dist/emblems/ball/ball.teqball.js

@@ -0,0 +1,27 @@
+// Teqball: the soccer ball's 32 panels in our colours, teal and white, with a pale inset on each hexagon.
+import { defineBall } from "./ball.engine.js";
+import { shrink, truncatedIcosahedron } from "./ball.polyhedra.js";
+import { blend, mix } from "./ball.core.js";
+export const BALL_TEQBALL = /* @__PURE__ */ defineBall({
+    id: "ball:teqball",
+    en: "Teqball ball",
+    ja: "テックボール用ボール",
+    size: { extentMm: 216.4, diameterMm: 216.4, circumferenceMm: 680.0, massG: [370, 400], rule: "FITEQ Official Rules and Regulations of Teqball 2026, Rule 3 The Official Ball, 3.1.1-3.1.6", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 30, pitch: 24, roll: 8 },
+        base: "#0f9aa8",
+        ground: "#f6f8f8",
+        mat: { gloss: 0.7, shade: "#0c2a40", grain: { f: 1.1, a: 0.1 } },
+        draw: (s, base) => {
+            const t = truncatedIcosahedron();
+            const inset = blend(base, "#ffffff", 0.82);
+            let out = "";
+            t.hexagons.forEach((h, i) => (out += s.panel(shrink(h, t.hexagonCentres[i], 0.38), inset, { n: 2 })));
+            for (const p of t.pentagons)
+                out += s.panel(p, base, { ink: true });
+            out += s.strokes(t.edges, mix(base, -0.4), 1.1);
+            out += s.strokes(t.edges, "#fff", 0.4, { deco: true, opacity: 0.4, dx: 0.3, dy: 0.35 });
+            return out;
+        },
+    },
+});

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

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

package/dist/emblems/ball/ball.volleyball.js

@@ -0,0 +1,56 @@
+// Volleyball: the 18-panel indoor ball in yellow, blue and white, the 8-panel version, and the beach volleyball in its own bright colours. All made of our own layout of curved panels.
+import { defineBall } from "./ball.engine.js";
+import { octants8, strips18 } from "./ball.family.panelled.js";
+const YELLOW = "#f3c81c";
+const BLUE = "#1f5fbf";
+const WHITE = "#f6f4ee";
+export const BALL_VOLLEYBALL = /* @__PURE__ */ defineBall({
+    id: "ball:volleyball",
+    en: "Volleyball",
+    ja: "バレーボール",
+    size: { extentMm: 210.1, diameterMm: 210.1, circumferenceMm: 660.0, massG: [260, 280], rule: "FIVB Official Volleyball Rules 2025-2028, Rule 3 Balls, 3.1 Standards", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 28, pitch: 22, roll: 0 },
+        base: YELLOW,
+        mat: { gloss: 0.75, shade: "#1a2a50", grain: { f: 1.2, a: 0.12 } },
+        draw: (s, base) => strips18(s, [
+            [base, BLUE],
+            [WHITE, BLUE],
+            [BLUE, WHITE],
+            [base, WHITE],
+            [WHITE, base],
+            [BLUE, base],
+        ], "#3a4560"),
+    },
+});
+export const BALL_VOLLEYBALL_8 = /* @__PURE__ */ defineBall({
+    id: "ball:volleyball-8",
+    en: "Volleyball, 8 panels",
+    ja: "バレーボール（8枚貼り）",
+    size: { extentMm: 210.1, diameterMm: 210.1, circumferenceMm: 660.0, massG: [260, 280], rule: "FIVB Official Volleyball Rules 2025-2028, Rule 3 Balls, 3.1 Standards", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 32, pitch: 26, roll: 0 },
+        base: YELLOW,
+        mat: { gloss: 0.75, shade: "#1a2a50", grain: { f: 1.2, a: 0.12 } },
+        draw: (s, base) => octants8(s, (sx, sy, sz) => (sy > 0 ? (sx * sz > 0 ? base : BLUE) : sx * sz > 0 ? WHITE : BLUE), "#3a4560"),
+    },
+});
+export const BALL_BEACH_VOLLEYBALL = /* @__PURE__ */ defineBall({
+    id: "ball:beach-volleyball",
+    en: "Beach volleyball",
+    ja: "ビーチバレーボール",
+    size: { extentMm: 213.3, diameterMm: 213.3, circumferenceMm: 670.0, massG: [260, 280], rule: "FIVB Official Beach Volleyball Rules 2025-2028, Rule 3 Balls, 3.1 Standards", note: "Diameter worked out from the middle of the circumference range." },
+    spec: {
+        view: { yaw: 28, pitch: 22, roll: 0 },
+        base: "#f2701f",
+        mat: { gloss: 0.6, shade: "#4a2410", grain: { f: 1.2, a: 0.1 } },
+        draw: (s, base) => strips18(s, [
+            [base, WHITE],
+            [WHITE, "#14a3d6"],
+            [base, "#14a3d6"],
+            [WHITE, base],
+            [base, WHITE],
+            [WHITE, "#14a3d6"],
+        ], "#7a4a30"),
+    },
+});

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

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

package/dist/emblems/ball/ball.waterpolo.js

@@ -0,0 +1,31 @@
+// Water polo ball: yellow, with deep dark grip channels that follow the seams of its panels. Three seams at right angles cut it into eight panels; beside each seam run a fine groove on each side, which is
+// what the grip of a water polo ball looks like. The rest of the surface is the pebbled grain.
+import { defineBall } from "./ball.engine.js";
+import { greatCircle, smallCircle } from "./ball.math.js";
+import { mix } from "./ball.core.js";
+const AXES = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+/** How far the grooves run from a seam, in radians. */
+const OFFSETS = [0.17];
+export const BALL_WATER_POLO = /* @__PURE__ */ defineBall({
+    id: "ball:water-polo",
+    en: "Water polo ball",
+    ja: "水球ボール",
+    size: { extentMm: 221.2, diameterMm: 221.2, circumferenceMm: 695.0, massG: [400, 450], rule: "World Aquatics Competition Regulations, Part Six Water Polo Rules, Appendix 4 Field of Play & Equipment, 20.4.3 Ball (20.4.3.1-20.4.3.4); Part Six rule 1.1 points to Appendix 4", note: "Men's ball. Diameter worked out from the middle of the circumference range. Colour is not regulated." },
+    spec: {
+        view: { yaw: 30, pitch: 24, roll: 0 },
+        base: "#f2c012",
+        mat: { gloss: 0.5, shade: "#4a2c04", grain: { f: 1.6, a: 0.3 } },
+        draw: (s, base) => {
+            const channel = mix(base, -0.62);
+            let out = "";
+            // The grooves beside each seam: a pair on each side of it.
+            const grooves = AXES.flatMap((a) => OFFSETS.flatMap((o) => [smallCircle(a, Math.PI / 2 - o, 96), smallCircle(a, Math.PI / 2 + o, 96)]));
+            out += s.strokes(grooves, mix(base, -0.5), 1.1, { closed: true, ink: false, opacity: 0.9 });
+            // The seams themselves are the wide channels: dark, with the raised lips either side of them.
+            const seams = AXES.map((a) => greatCircle(a, 96));
+            out += s.strokes(seams, channel, 3.8, { closed: true });
+            out += s.strokes(seams, mix(base, 0.35), 0.5, { closed: true, deco: true, opacity: 0.55, dx: 0.6, dy: 0.7 });
+            return out;
+        },
+    },
+});

package/dist/emblems/crest/diamond.d.ts

@@ -0,0 +1,2 @@
+/** A diamond with a thin diamond inside it. */
+export declare const CREST_DIAMOND: import("../emblem.core.ts").Emblem<import("../emblem.shapes.ts").FlatModel>;

package/dist/emblems/crest/diamond.js

@@ -0,0 +1,18 @@
+// A diamond with a thin diamond inside it, tinted by a team's colours, with the team's letters on it or a star. Drawn for this package.
+import { defineFlat, starPath } from "../emblem.shapes.js";
+/** A diamond with a thin diamond inside it. */
+export const CREST_DIAMOND = /* @__PURE__ */ defineFlat("crest:diamond", "Diamond crest", "ひし形のエンブレム", "ours", {
+    metal: "flat",
+    color: "#2d5a8c",
+    ribbon: "#f4f0e4",
+    front: [
+        ["m", "M32 3L61 32 32 61 3 32z"],
+        ["r", "M32 9L55 32 32 55 9 32z"],
+        ["m", "M32 14L50 32 32 50 14 32z"],
+        ["e", "M32 6L58 32 32 58 6 32z", "1.4"],
+        ["l", "M32 14L14 32l7 0 11-11z"],
+    ],
+    blank: [["f", starPath(32, 33, 11, 4.6), "#ffffff"]],
+    letters: [32, 32, 20],
+    rim: 3,
+});

package/dist/emblems/crest/pennant.d.ts

@@ -0,0 +1,2 @@
+/** A pennant on a pole. */
+export declare const CREST_PENNANT: import("../emblem.core.ts").Emblem<import("../emblem.shapes.ts").FlatModel>;

package/dist/emblems/crest/pennant.js

@@ -0,0 +1,18 @@
+// A pennant on a pole, tinted by a team's colours, with the team's letters on it or a star. Drawn for this package.
+import { defineFlat, starPath } from "../emblem.shapes.js";
+/** A pennant on a pole. */
+export const CREST_PENNANT = /* @__PURE__ */ defineFlat("crest:pennant", "Pennant crest", "ペナント形のエンブレム", "ours", {
+    metal: "flat",
+    color: "#2d5a8c",
+    ribbon: "#f4f0e4",
+    front: [
+        ["m", "M9 3h4v58H9z"],
+        ["m", "M13 8L58 32 13 56z"],
+        ["r", "M13 8L58 32 52 35 13 14z"],
+        ["e", "M16 12.6L50.4 32 16 51.4z", "1.2"],
+        ["l", "M16 13l16 8-16 4z"],
+    ],
+    blank: [["f", starPath(28, 33, 9, 3.8), "#ffffff"]],
+    letters: [29, 33, 17],
+    rim: 3,
+});

package/dist/emblems/crest/roundel.d.ts

@@ -0,0 +1,2 @@
+/** A round badge with a ring inside its edge. */
+export declare const CREST_ROUNDEL: import("../emblem.core.ts").Emblem<import("../emblem.shapes.ts").FlatModel>;

package/dist/emblems/crest/roundel.js

@@ -0,0 +1,18 @@
+// A round badge with a ring inside its edge, tinted by a team's colours, with the team's letters on it or a star. Drawn for this package.
+import { circlePath, defineFlat, starPath } from "../emblem.shapes.js";
+/** A round badge with a ring inside its edge. */
+export const CREST_ROUNDEL = /* @__PURE__ */ defineFlat("crest:roundel", "Round crest", "丸形のエンブレム", "ours", {
+    metal: "flat",
+    color: "#2d5a8c",
+    ribbon: "#f4f0e4",
+    front: [
+        ["o", circlePath(32, 32, 28)],
+        ["r", circlePath(32, 32, 23.4)],
+        ["o", circlePath(32, 32, 20.4)],
+        ["e", circlePath(32, 32, 26.2), "1.4"],
+        ["l", "M12 28a21 21 0 0 1 15-15 22 22 0 0 0-10 21z"],
+    ],
+    blank: [["f", starPath(32, 33, 13, 5.4), "#ffffff"]],
+    letters: [32, 32, 24],
+    rim: 3,
+});

package/dist/emblems/crest/shield.d.ts

@@ -0,0 +1,2 @@
+/** A heraldic shield with a band across the top. */
+export declare const CREST_SHIELD: import("../emblem.core.ts").Emblem<import("../emblem.shapes.ts").FlatModel>;

package/dist/emblems/crest/shield.js

@@ -0,0 +1,17 @@
+// A heraldic shield with a band across the top, tinted by a team's colours, with the team's letters on it or a star. Drawn for this package.
+import { defineFlat, starPath } from "../emblem.shapes.js";
+/** A heraldic shield with a band across the top. */
+export const CREST_SHIELD = /* @__PURE__ */ defineFlat("crest:shield", "Shield crest", "盾形のエンブレム", "ours", {
+    metal: "flat",
+    color: "#2d5a8c",
+    ribbon: "#f4f0e4",
+    front: [
+        ["m", "M9 5h46v23c0 15-10 24-23 30C19 52 9 43 9 28z"],
+        ["r", "M9 5h46v9H9z"],
+        ["e", "M12.5 8.5h39v19.5c0 12.5-8.3 20.6-19.5 26C21.8 48.6 12.5 40.5 12.5 28z", "1.4"],
+        ["l", "M13 16h10L13 30z"],
+    ],
+    blank: [["f", starPath(32, 34, 12, 5), "#ffffff"]],
+    letters: [32, 37, 24],
+    rim: 3,
+});

package/dist/emblems/emblem.api.d.ts

@@ -1,13 +1,15 @@
-import type { Emblem, EmblemOptions, EmblemStyle, FrameOptions } from "./emblem.core.ts";
-import { type BallId, type EmblemId } from "./emblem.ids.ts";
-/** What can name an emblem: an id, or an id with a style (`"award:medal/line"`), or the emblem itself. */
+import type { Emblem, EmblemLocale, EmblemOptions, EmblemStyle, EmblemTheme, FrameOptions } from "./emblem.core.ts";
+import { type BallId, type CrestShape, type EmblemId, type MedalKind, type SportName } from "./emblem.ids.ts";
+import type { PieceSize } from "./ball/ball.core.ts";
+import { type EmblemDescription } from "./emblem.descriptions.ts";
+/** What can name an emblem: an id, a short name (`"cup"` for `"trophy:cup"`), either with a style (`"trophy:cup/line"`), or the emblem itself. */
 export type EmblemRef = EmblemId | `${EmblemId}/${EmblemStyle}` | (string & {}) | Emblem;
-/** The id and style a string names, or `undefined` when it is not an emblem. An id may end in `/metal`, `/line` or `/color`. */
+/** The id and style a string names, or `undefined` when it is not an emblem. An id may end in `/metal`, `/line` or `/color`, and a trophy or an award may be written without its group (`cup`, `crown`). */
 export declare function parseEmblem(value: unknown): {
     id: EmblemId;
     style: EmblemStyle | undefined;
 } | undefined;
-/** True when the value is the id of an emblem (with no style). */
+/** True when the value is the id of an emblem (not a short name, and with no style). */
 export declare function isEmblemId(value: unknown): value is EmblemId;
 /** The emblem a reference names. An unknown name is an error that says what an id looks like. */
 export declare function emblemOf(ref: EmblemRef): {
@@ -20,8 +22,8 @@ export declare function emblemOf(ref: EmblemRef): {
  * @example
  * ```ts
  * import { renderEmblem } from "@johnmorrisdotca/dougu-sports/emblems";
- * const svg = renderEmblem("award:medal", { style: "line", size: 32 });
- * console.log(svg.startsWith("<svg"), svg.includes("<title>Medal</title>"));
+ * const svg = renderEmblem("trophy:cup", { style: "line", size: 32 });
+ * console.log(svg.startsWith("<svg"), svg.includes("<title>Cup</title>"));
  * // true true
  * ```
  */
@@ -29,11 +31,11 @@ export declare function renderEmblem(ref: EmblemRef, options?: EmblemOptions): s
 /** The same as `renderEmblem`. */
 export declare const emblemSvg: typeof renderEmblem;
 /**
- * An emblem turned: `yaw` degrees about its vertical axis and `pitch` degrees of tilt, from its resting view, in plain SVG. A flat emblem (a medal) flips like a coin and shows its back; a ball rolls.
+ * An emblem turned: `yaw` degrees about its vertical axis and `pitch` degrees of tilt, from its resting view, in plain SVG. A cup, bowl or urn keeps its outline and moves its light, handles and seams; a medal flips like a coin and shows its back; a ball rolls; an icon is not turned.
  * @example
  * ```ts
  * import { emblemFrame, renderEmblem } from "@johnmorrisdotca/dougu-sports/turn";
- * console.log(emblemFrame("award:medal", { yaw: 0 }) === renderEmblem("award:medal"));
+ * console.log(emblemFrame("medal:gold", { yaw: 0 }) === renderEmblem("medal:gold"));
  * // true
  * ```
  */
@@ -51,6 +53,10 @@ export interface EmblemInfo {
     ja: string;
     source: Emblem["source"];
     kind: Emblem["kind"];
+    /** A ball's or an implement's official size, with the rule it is from, where the rulebook gives one. */
+    size?: PieceSize;
+    /** What is drawn, in more words than the short name (which is the accessible name), for the docs and a gallery; not every emblem has one. */
+    description?: EmblemDescription;
 }
 /** The names, source and kind of an emblem. */
 export declare function emblemInfo(id: EmblemId): EmblemInfo;
@@ -58,3 +64,65 @@ export declare function emblemInfo(id: EmblemId): EmblemInfo;
 export declare function emblemName(id: EmblemId, language?: "en" | "ja"): string;
 /** The data an emblem is drawn from: a flat emblem's shapes or a ball's marks, for a view that turns it itself. */
 export declare function emblemModel(id: EmblemId): unknown;
+/** What `crest` takes. */
+export interface CrestOptions {
+    /** `shield` (the default), `roundel`, `diamond` or `pennant`. */
+    shape?: CrestShape;
+    /** The team's colour, or its colour and a second colour for the band and the ring. Hex colours or `rgb()`. */
+    colors?: string | readonly [string, string?];
+    /** Up to three letters. A crest with none has a star. */
+    initials?: string;
+    size?: number;
+    style?: EmblemStyle;
+    theme?: EmblemTheme;
+    /** The language of the `<title>`, `"en"` (the default) or `"ja"`. */
+    locale?: EmblemLocale;
+    /** A string is the `<title>`; `false` drops it and hides the drawing from a screen reader. */
+    title?: string | false;
+}
+/**
+ * A generic crest tinted by a team's colours, with its letters if it has any: what a team with no logo gets. The letters are in the ink that reads on the colour.
+ * @example
+ * ```ts
+ * import { crest } from "@johnmorrisdotca/dougu-sports/emblems";
+ * const svg = crest({ shape: "shield", colors: ["#c8102e", "#f4f0e4"], initials: "NO" });
+ * console.log(svg.includes(">NO<"));
+ * // true
+ * ```
+ */
+export declare function crest(options?: CrestOptions): string;
+/** A medal on a ribbon: `medal("gold")`, `"silver"` or `"bronze"`; any other kind is the gold one. */
+export declare function medal(kind: MedalKind, options?: EmblemOptions): string;
+/** The icon of a sport, by the names of `SPORT_NAMES`: `sportIcon("nhl")`. An unknown sport is an error. */
+export declare function sportIcon(sport: SportName, options?: EmblemOptions): string;
+/** What `pennant` takes. */
+export interface PennantOptions {
+    /** The felt, the stitching, and the lettering (the stitching's colour unless a third is given), as hex colours or `rgb()`. */
+    colors?: string | readonly [felt?: string, stitching?: string, lettering?: string];
+    /** The words, in capitals ("Champions", "優勝"); more than one line with line breaks. The engraving options `label`, `rank` and `year` work too. */
+    text?: string;
+    /** The label and rank, as for any engraving: ignored when `text` is given. */
+    label?: string;
+    rank?: number | string;
+    /** The year, in smaller letters under the words. */
+    year?: number | string;
+    /** `"front"` (the default) or `"back"`: plain felt, with the dowel on the other side. */
+    view?: "front" | "back";
+    size?: number;
+    style?: EmblemStyle;
+    theme?: EmblemTheme;
+    /** A turn from the resting view, in degrees. */
+    yaw?: number;
+    pitch?: number;
+}
+/**
+ * A felt championship pennant with a stitched edge, lettered with its words and its year.
+ * @example
+ * ```ts
+ * import { pennant } from "@johnmorrisdotca/dougu-sports/emblems";
+ * const svg = pennant({ colors: ["#1f4e8c", "#f2c230"], text: "Champions", year: 2026 });
+ * console.log(svg.includes(">CHAMPIONS<"), svg.includes(">2026<"));
+ * // true true
+ * ```
+ */
+export declare function pennant(options?: PennantOptions): string;