@johnmorrisdotca/dougu-sports 0.0.1 → 0.1.0

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,14 @@
-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, 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";
+/** 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 +21,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 +30,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 +52,8 @@ 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;
 }
 /** The names, source and kind of an emblem. */
 export declare function emblemInfo(id: EmblemId): EmblemInfo;
@@ -58,3 +61,30 @@ 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;
+}
+/**
+ * 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;

package/dist/emblems/emblem.api.js

@@ -1,7 +1,7 @@
 import { EMBLEM_STYLES } from "./emblem.core.js";
-import { BALL_IDS, EMBLEM_IDS } from "./emblem.ids.js";
+import { BALL_IDS, CREST_SHAPES, EMBLEM_ALIASES, EMBLEM_IDS } from "./emblem.ids.js";
 import { EMBLEM_TABLE } from "./emblem.registry.js";
-/** 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 function parseEmblem(value) {
     if (typeof value !== "string")
         return undefined;
@@ -17,9 +17,10 @@ export function parseEmblem(value) {
         style = tail;
         text = text.slice(0, slash);
     }
-    return Object.hasOwn(EMBLEM_TABLE, text) ? { id: text, style } : undefined;
+    const id = Object.hasOwn(EMBLEM_ALIASES, text) ? EMBLEM_ALIASES[text] : text;
+    return Object.hasOwn(EMBLEM_TABLE, id) ? { id: id, style } : 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 function isEmblemId(value) {
     return typeof value === "string" && Object.hasOwn(EMBLEM_TABLE, value);
 }
@@ -29,7 +30,7 @@ export function emblemOf(ref) {
         return { emblem: ref, style: undefined };
     const parsed = parseEmblem(ref);
     if (parsed === undefined)
-        throw new Error(`Unknown emblem "${ref.slice(0, 60)}". Ids look like "award:medal" or "ball:soccer"; see EMBLEM_IDS.`);
+        throw new Error(`Unknown emblem "${ref.slice(0, 60)}". Ids look like "trophy:cup", "medal:gold", "sport:nhl" or "crest:shield"; see EMBLEM_IDS.`);
     return { emblem: EMBLEM_TABLE[parsed.id], style: parsed.style };
 }
 const withStyle = (style, options) => (style === undefined || options?.style !== undefined ? options : { ...options, style });
@@ -39,8 +40,8 @@ const withStyle = (style, options) => (style === undefined || options?.style !==
  * @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
  * ```
  */
@@ -51,11 +52,11 @@ export function renderEmblem(ref, options) {
 /** The same as `renderEmblem`. */
 export const emblemSvg = 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
  * ```
  */
@@ -76,7 +77,8 @@ export const EMBLEMS = Object.freeze(Object.fromEntries(EMBLEM_IDS.map((id) => [
 /** The names, source and kind of an emblem. */
 export function emblemInfo(id) {
     const e = EMBLEM_TABLE[id];
-    return { id, en: e.en, ja: e.ja, source: e.source, kind: e.kind };
+    const size = e.size;
+    return size === undefined ? { id, en: e.en, ja: e.ja, source: e.source, kind: e.kind } : { id, en: e.en, ja: e.ja, source: e.source, kind: e.kind, size };
 }
 /** An emblem's name in a language. */
 export function emblemName(id, language = "en") {
@@ -86,3 +88,29 @@ export function emblemName(id, language = "en") {
 export function emblemModel(id) {
     return EMBLEM_TABLE[id].model;
 }
+/**
+ * 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 function crest(options = {}) {
+    const colors = typeof options.colors === "string" ? [options.colors] : (options.colors ?? []);
+    const shape = CREST_SHAPES.includes(options.shape) ? options.shape : "shield";
+    return EMBLEM_TABLE[`crest:${shape}`].svg({ tint: colors[0], accent: colors[1], initials: options.initials, size: options.size, style: options.style, theme: options.theme });
+}
+/** A medal on a ribbon: `medal("gold")`, `"silver"` or `"bronze"`; any other kind is the gold one. */
+export function medal(kind, options) {
+    return (EMBLEM_TABLE[`medal:${kind}`] ?? EMBLEM_TABLE["medal:gold"]).svg(options);
+}
+/** The icon of a sport, by the names of `SPORT_NAMES`: `sportIcon("nhl")`. An unknown sport is an error. */
+export function sportIcon(sport, options) {
+    const e = Object.hasOwn(EMBLEM_TABLE, `sport:${sport}`) ? EMBLEM_TABLE[`sport:${sport}`] : undefined;
+    if (e === undefined)
+        throw new Error(`Unknown sport "${String(sport).slice(0, 40)}": the icons are for the names in SPORT_NAMES.`);
+    return e.svg(options);
+}

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

@@ -15,11 +15,19 @@ export interface EmblemOptions {
     tint?: string;
     /** `inherit` (the default), `auto`, `light` or `dark`. */
     theme?: EmblemTheme;
+    /** A second colour: a medal's ribbon, a crest's band, the flags of a trophy. A hex colour or `rgb()`; anything else is ignored. */
+    accent?: string;
+    /** The letters of a crest, up to three. */
+    initials?: string;
+    /** A ball: force the grain of its surface on or off. By default it is on for a ball of 48 pixels or more that is not turning. */
+    grain?: boolean;
 }
 /** A turn, in degrees from the resting view (0 and 0 is the still drawing): `yaw` about the vertical axis, `pitch` the tilt toward the eye. */
 export interface FrameOptions extends EmblemOptions {
     yaw?: number;
     pitch?: number;
+    /** A ball: the turn about the line of sight. */
+    roll?: number;
 }
 /** The ink of a drawing when a theme sets it, and the page it is made to read on. */
 export declare const EMBLEM_INK: {
@@ -36,11 +44,12 @@ export declare const METALS: {
     readonly silver: "#aeb6c0";
     readonly bronze: "#b8733a";
 };
-export type Metal = keyof typeof METALS;
+/** A metal by name, or `flat` for a colour that is no metal (a crest's blue, a sport's plain ink). */
+export type Metal = keyof typeof METALS | "flat";
 /** Where an emblem's art comes from: drawn for this package (`ours`) or taken from a source listed in NOTICE.md. */
-export type EmblemSource = "ours" | "material" | "noto" | "mdi" | "game-icons";
-/** What an emblem is: a flat object (a front and a back, to flip), a ball (marks on a sphere, to roll), a body of revolution (`lathe`) or an icon (one path, not turned). */
-export type EmblemKind = "flat" | "ball" | "lathe" | "icon";
+export type EmblemSource = "ours" | "material" | "generated" | "drawn" | "noto" | "mdi" | "commons" | "gameicons";
+/** What an emblem is: a flat object (a front and a back, to flip), a ball (a sphere or a solid, turned in 3D), a body of revolution (`lathe`), an icon (one drawing, not turned) or a piece of gear (a flat drawing, not turned). */
+export type EmblemKind = "flat" | "ball" | "lathe" | "icon" | "gear";
 export type Rgb = readonly [number, number, number];
 /** A colour from `#rgb`, `#rrggbb` or `rgb(r, g, b)`, or `undefined` for anything else. */
 export declare function readColour(value: string | undefined): Rgb | undefined;
@@ -57,10 +66,16 @@ export interface Resolved {
     size: number;
     theme: EmblemTheme;
     tint: Rgb | undefined;
+    accent: string | undefined;
+    initials: string;
 }
 export declare function resolve(o: EmblemOptions | undefined): Resolved;
 /** The main colour of a metal, or the tint when there is one. */
 export declare const mainOf: (metal: Metal, tint: Rgb | undefined) => Rgb;
+/** The relative luminance of a colour, 0 to 1. */
+export declare function lum(rgb: Rgb): number;
+/** Black or white, whichever reads better on a colour. */
+export declare const onColour: (rgb: Rgb) => string;
 /** A turn in degrees, as a finite number (0 for anything else). */
 export declare const degrees: (value: number | undefined) => number;
 /** The colours a drawing is painted with. In the `line` style every fill is `none`. */
@@ -74,8 +89,27 @@ export interface Paint {
     /** The definitions the fills refer to. */
     defs: string;
 }
-/** The paint for a main colour in a style. The gradient's id names the colour, so two of one colour in a page agree. */
-export declare function paintFor(style: EmblemStyle, main: Rgb, kind?: "linear" | "radial"): Paint;
+/** The paint of a ball: a radial gradient in the metal style. The gradient's id names the colour, so two of one colour in a page agree. */
+export declare function paintFor(style: EmblemStyle, main: Rgb): Paint;
+/** A gradient: its id, its definition (a fragment for a `<defs>`) and the fill that names it. */
+export interface Gradient {
+    id: string;
+    def: string;
+    fill: string;
+}
+/**
+ * The shading of a round metal body: a dark edge, a bright band left of the middle, the metal, a darker side, and a faint light from the rim on the far edge, as polished metal throws it. `shift` slides the bright
+ * band (a turn). The id names the colour and the shift, so two bodies of one colour in a page share one definition.
+ */
+export declare function cylinderGradient(main: Rgb, shift?: number): Gradient;
+/** The shading of a round flat or a ball: light from the top left, the metal, then dark at the far edge. */
+export declare function orbGradient(main: Rgb): Gradient;
+/** The shading of a flat sheet of metal, from a bright corner to a dark one. */
+export declare function sheetGradient(main: Rgb): Gradient;
+/** The shading of a raised rim: bright on the top left, dark on the bottom right, as a bevel catches the light (or the other way round, for a groove). */
+export declare function bevelGradient(main: Rgb, groove?: boolean): Gradient;
+/** The gradients' definitions as one `<defs>`, with none twice. */
+export declare const defsOf: (gradients: readonly Gradient[]) => string;
 /** A drawing wrapped into a document: the title, the outline's colour for the theme, and the group that strokes it. */
 export declare function wrap(o: {
     title: string;
@@ -85,6 +119,8 @@ export declare function wrap(o: {
     defs?: string;
     body: string;
     box?: string;
+    edge?: string;
+    width?: number;
 }): string;
 /** One emblem: its id and names, where its art comes from, and the functions that draw it. Importing one of these pulls in its own module and the small renderer it needs, not the other emblems. */
 export interface Emblem<Model = unknown> {