@johnmorrisdotca/dougu-sports 0.1.0 → 0.2.1

package/dist/emblems/emblem.engrave.js

@@ -0,0 +1,145 @@
+// Engraving: text cut into a face. A plate is a box on a flat face; its lines are fitted to it (the biggest size at which the longest line and the stack of lines both fit), and the ink is chosen
+// to read at 4.5 to 1 on the metal under it, the same way a crest's letters are. A plinth is a band round a body of revolution: its letters are set one by one at their angle round it, so the
+// text foreshortens, goes behind the edge and comes round as the body turns. Imports only the core.
+import { clean, escape, lum, mix, n2, readColour } from "./emblem.core.js";
+const FONT = "system-ui,-apple-system,'Segoe UI','Hiragino Sans','Noto Sans JP','Yu Gothic',sans-serif";
+/** The width of one character in em: a guess that holds for the usual sans-serif fonts, whole for Japanese and the wide forms. */
+export function advance(ch) {
+    const c = ch.codePointAt(0);
+    if (c >= 0x2e80 && c <= 0xffef && !(c >= 0xff61 && c <= 0xff9f))
+        return 1.02;
+    if (ch === " ")
+        return 0.3;
+    if (/[iljI.,:;'!|]/.test(ch))
+        return 0.34;
+    if (/[mwMW]/.test(ch))
+        return 0.92;
+    if (/[A-Z]/.test(ch))
+        return 0.72;
+    if (/[0-9]/.test(ch))
+        return 0.62;
+    return 0.58;
+}
+/** The width of a text in em. */
+export const widthOf = (text) => [...text].reduce((sum, ch) => sum + advance(ch), 0);
+/** The contrast ratio of two colours, 1 to 21. */
+export const contrastOf = (a, b) => (Math.max(lum(a), lum(b)) + 0.05) / (Math.min(lum(a), lum(b)) + 0.05);
+/** Black or white, or a deep or pale tone of the colour itself, whichever reads at 4.5 to 1 on the colour (the best of them when none does). */
+export function inkFor(main) {
+    const dark = lum(main) > 0.18;
+    const list = dark ? [mix(main, -0.72), "#000000", mix(main, 0.9), "#ffffff"] : [mix(main, 0.9), "#ffffff", mix(main, -0.72), "#000000"];
+    const scored = list.map((c) => [c, contrastOf(readColour(c), main)]);
+    return (scored.find((s) => s[1] >= 4.5) ?? scored.reduce((a, b) => (b[1] > a[1] ? b : a)))[0];
+}
+/** The lines to cut, as candidates (the layout takes the one that gives the biggest letters), and the year when a plate of its own holds it. */
+export function linesOf(e, place) {
+    const yearApart = place?.yearApart === true;
+    if (e.free !== undefined) {
+        const rows = e.free.split("\n");
+        if (rows.length > 1)
+            return { main: [rows.map((text, i) => ({ text, weight: i === 0 ? 1 : i === 1 ? 0.62 : 0.5 }))], year: undefined };
+        const words = (e.free.match(/\S+/g) ?? [e.free]);
+        const cut = words.slice(1).map((_, i) => [words.slice(0, i + 1).join(" "), words.slice(i + 1).join(" ")]);
+        const one = [{ text: e.free, weight: 1 }];
+        return { main: [one, ...cut.map((pair) => pair.map((text, i) => ({ text, weight: i === 0 ? 1 : 0.62 })))], year: undefined };
+    }
+    const rank = e.rank ?? place?.rank;
+    const lines = [];
+    const big = rank !== undefined;
+    if (rank !== undefined)
+        lines.push({ text: rank, weight: 1 });
+    if (e.label !== undefined)
+        lines.push({ text: e.label, weight: big ? 0.5 : 1 });
+    if (e.year !== undefined && !yearApart)
+        lines.push({ text: e.year, weight: big ? 0.42 : 0.6 });
+    return { main: lines.length === 0 ? [] : [lines], year: yearApart ? e.year : undefined };
+}
+/** Lines fitted to a plate: each line's size and baseline, and the smallest size (the score of the fit). */
+function fit(lines, p) {
+    const lh = 1.14;
+    const unit = p.h / lines.reduce((sum, l) => sum + l.weight * lh, 0);
+    const sizes = lines.map((l) => Math.min(unit * l.weight, (p.w * 0.96) / Math.max(widthOf(l.text), 0.4)));
+    const total = sizes.reduce((sum, s) => sum + s * lh, 0);
+    let top = p.y - total / 2;
+    const rows = lines.map((l, i) => {
+        const size = sizes[i];
+        const y = top + (size * lh) / 2 + size * 0.36;
+        top += size * lh;
+        return { text: l.text, size, y, width: widthOf(l.text) * size };
+    });
+    return { rows, score: Math.min(...sizes) };
+}
+/** The ink of an engraving: the page's ink in the line style, else the colour that reads on the metal. */
+export const engravingInk = (style, main) => (style === "line" ? "currentColor" : inkFor(main));
+/** Lines cut into a plate, as markup: the ink, and in the metal style a faint light under each line where the cut catches it. `candidates` are alternative line breaks, and the best fit is used. */
+export function plateMarkup(candidates, plate, main, style) {
+    const fits = candidates.filter((c) => c.length > 0).map((c) => fit(c, plate));
+    if (fits.length === 0)
+        return "";
+    const best = fits.reduce((a, b) => (b.score > a.score + 0.01 ? b : a));
+    const text = (dx) => best.rows
+        .map((r) => `<text x="${n2(plate.x + dx)}" y="${n2(r.y + dx)}" font-size="${n2(r.size)}" textLength="${n2(r.width)}" lengthAdjust="spacingAndGlyphs">${escape(r.text)}</text>`)
+        .join("");
+    const head = `font-family="${FONT}" font-weight="800" text-anchor="middle" stroke="none"`;
+    const glint = style === "metal" ? `<g ${head} fill="${mix(main, 0.7)}" fill-opacity=".7">${text(0.3)}</g>` : "";
+    const marks = `${glint}<g ${head} fill="${engravingInk(style, main)}">${text(0)}</g>`;
+    return plate.rot === undefined ? marks : `<g transform="rotate(${plate.rot} ${n2(plate.x)} ${n2(plate.y)})">${marks}</g>`;
+}
+/** The letters of a text set round a body at a radius: `angle` is the turn of the body now, `place` puts a point of the surface on the screen. A letter on the far side is left out. */
+export function cylinderText(text, radius, height, ink, angle, centre, place) {
+    const em = Math.max(widthOf(text), 0.4);
+    const size = Math.min(height * 0.8, (radius * 1.9) / em);
+    const letters = [...text];
+    let run = -(em * size) / 2;
+    let out = "";
+    for (const ch of letters) {
+        const w = advance(ch) * size;
+        const deg = centre + angle + ((run + w / 2) / radius) * (180 / Math.PI);
+        run += w;
+        if (ch === " ")
+            continue;
+        const [x, y, depth] = place(deg);
+        if (depth < 0.14)
+            continue;
+        out += `<text transform="translate(${n2(x)} ${n2(y + size * 0.36)}) scale(${n2(depth)} 1)">${escape(ch)}</text>`;
+    }
+    return out === "" ? "" : `<g font-family="${FONT}" font-weight="800" text-anchor="middle" font-size="${n2(size)}" fill="${ink}" fill-opacity=".92" stroke="none">${out}</g>`;
+}
+/** The letters of a text set on one flat side of a body, from one edge of the side to the other, as that side faces the eye. `a` and `b` are the two edges on the screen, `depth` how squarely the side faces. */
+export function sideText(text, chord, height, ink, a, b, depth) {
+    if (depth < 0.14)
+        return "";
+    const em = Math.max(widthOf(text), 0.4);
+    const size = Math.min(height * 0.8, (chord * 0.8) / em);
+    const slope = (b[1] - a[1]) / (b[0] - a[0] || 1);
+    let run = -(em * size) / 2;
+    let out = "";
+    for (const ch of text) {
+        const w = advance(ch) * size;
+        const u = 0.5 + (run + w / 2) / chord;
+        run += w;
+        if (ch === " ")
+            continue;
+        out += `<text transform="matrix(${n2(depth)} ${n2(slope * depth)} 0 1 ${n2(a[0] + (b[0] - a[0]) * u)} ${n2(a[1] + (b[1] - a[1]) * u + size * 0.36)})">${escape(ch)}</text>`;
+    }
+    return `<g font-family="${FONT}" font-weight="800" text-anchor="middle" font-size="${n2(size)}" fill="${ink}" fill-opacity=".92" stroke="none">${out}</g>`;
+}
+/** The text of an engraving as one line, for a band that holds one: the free text with its lines joined, or the rank, label and year. */
+export const flatText = (e) => (e.free ?? [e.rank, e.label, e.year].filter((part) => part !== undefined).join(" ")).replace(/\n/g, " ");
+/** What is to be cut into a face, from the options: the free text, or the label, year and rank, and the text of the back. */
+export function engravingOf(o) {
+    const e = {};
+    const free = clean(o?.engrave, 3);
+    const [label, year, rank, back] = [clean(o?.label), clean(o?.year), clean(o?.rank), clean(o?.engraveBack, 3)];
+    if (free !== undefined)
+        e.free = free;
+    if (label !== undefined)
+        e.label = label;
+    if (year !== undefined)
+        e.year = year;
+    if (rank !== undefined)
+        e.rank = rank;
+    if (back !== undefined)
+        e.back = back;
+    return e;
+}

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

@@ -0,0 +1,24 @@
+import type { BallId, GearId, MedalId, SportName, TrophyId } from "./emblem.ids.ts";
+/** The equipment of one sport. */
+export interface SportEquipment {
+    sport: SportName;
+    /** The ball, or the implement that stands for one (the puck, the shuttlecock, the shot). Swimming, diving, artistic swimming, skating and the Japanese sports (sumo, kendo, judo, kyudo, karate) have none. */
+    ball?: BallId;
+    /** The gear the sport has an emblem for, most telling first. Empty where the package has none yet. */
+    gear: GearId[];
+    /** The trophy that stands for the sport's cup: its own where the package draws one, otherwise a plain cup, bowl or globe. */
+    trophy: TrophyId;
+    /** The medal of the sport's champion, for a sport in the Games. */
+    medal?: MedalId;
+}
+/**
+ * What a sport is played and won with, as ids of the registry: `sportEquipment("nhl")` is the puck, a stick, a skate, a goalie's mask and a net, and the hockey cup. The arrays are new each call. An unknown sport is an error.
+ * @example
+ * ```ts
+ * import { sportEquipment } from "@johnmorrisdotca/dougu-sports/emblems";
+ * const nhl = sportEquipment("nhl");
+ * console.log(nhl.ball, nhl.trophy);
+ * // ball:puck trophy:hockey-cup
+ * ```
+ */
+export declare function sportEquipment(sport: SportName): SportEquipment;

package/dist/emblems/emblem.equipment.js

@@ -0,0 +1,57 @@
+const GOLD = "medal:gold";
+const TABLE = {
+    nfl: ["ball:football", ["gear:football-helmet", "gear:goalposts"], "trophy:football"],
+    cfl: ["ball:football-cfl", ["gear:football-helmet", "gear:goalposts"], "trophy:canadian-bowl"],
+    ifaf: ["ball:football-ifaf", ["gear:football-helmet", "gear:goalposts"], "trophy:cup"],
+    nhl: ["ball:puck", ["gear:hockey-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net"], "trophy:hockey-cup"],
+    nba: ["ball:basketball", ["gear:basketball-hoop"], "trophy:basketball"],
+    mlb: ["ball:baseball", ["gear:baseball-bat", "gear:baseball-glove"], "trophy:baseball"],
+    soccer: ["ball:soccer", ["gear:goal-net"], "trophy:soccer-globe", GOLD],
+    curling: ["ball:curling-stone", ["gear:curling-broom"], "trophy:bowl", GOLD],
+    tennis: ["ball:tennis", ["gear:tennis-racket"], "trophy:tennis-cup", GOLD],
+    volleyball: ["ball:volleyball", ["gear:volleyball-net"], "trophy:cup", GOLD],
+    badminton: ["ball:shuttlecock-feather", ["gear:badminton-racket"], "trophy:cup", GOLD],
+    pickleball: ["ball:pickleball-outdoor", ["gear:pickleball-paddle"], "trophy:cup"],
+    tabletennis: ["ball:table-tennis", ["gear:table-tennis-paddle"], "trophy:cup", GOLD],
+    padel: ["ball:padel", ["gear:padel-racket"], "trophy:cup"],
+    squash: ["ball:squash", ["gear:squash-racket"], "trophy:cup", GOLD],
+    racquetball: ["ball:racquetball", ["gear:racquetball-racket"], "trophy:cup"],
+    sepaktakraw: ["ball:sepak-takraw", [], "trophy:cup"],
+    teqball: ["ball:teqball", [], "trophy:cup"],
+    roundnet: ["ball:roundnet", ["gear:roundnet-set"], "trophy:cup"],
+    netball: ["ball:netball", [], "trophy:cup"],
+    swimming: [undefined, ["gear:swim-goggles"], "trophy:cup", GOLD],
+    waterpolo: ["ball:water-polo", ["gear:swim-goggles"], "trophy:cup", GOLD],
+    diving: [undefined, ["gear:diving-board"], "trophy:cup", GOLD],
+    artisticswimming: [undefined, ["gear:swim-goggles"], "trophy:cup", GOLD],
+    lacrosse: ["ball:lacrosse", ["gear:lacrosse-stick"], "trophy:cup", GOLD],
+    rugby: ["ball:rugby", ["gear:goalposts"], "trophy:rugby-cup", GOLD],
+    afl: ["ball:afl", ["gear:goalposts"], "trophy:cup"],
+    gaelic: ["ball:sliotar", ["gear:hurley", "gear:goalposts"], "trophy:cup"],
+    cricket: ["ball:cricket-red", ["gear:cricket-bat", "gear:wicket"], "trophy:cricket-urn", GOLD],
+    fieldhockey: ["ball:field-hockey", ["gear:field-hockey-stick", "gear:goal-net"], "trophy:cup", GOLD],
+    handball: ["ball:handball", ["gear:goal-net"], "trophy:cup", GOLD],
+    athletics: ["ball:shot", ["gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles"], "trophy:laurel", GOLD],
+    skating: [undefined, ["gear:figure-skate", "gear:speed-skate"], "trophy:cup", GOLD],
+    sumo: [undefined, ["gear:gunbai", "gear:mawashi"], "trophy:sumo-cup"],
+    kendo: [undefined, ["gear:shinai", "gear:kendo-men"], "trophy:cup"],
+    judo: [undefined, ["gear:judogi", "gear:obi"], "trophy:cup", GOLD],
+    kyudo: [undefined, ["gear:yumi", "gear:ya"], "trophy:cup"],
+    karate: [undefined, ["gear:karate-gi"], "trophy:cup", GOLD],
+};
+/**
+ * What a sport is played and won with, as ids of the registry: `sportEquipment("nhl")` is the puck, a stick, a skate, a goalie's mask and a net, and the hockey cup. The arrays are new each call. An unknown sport is an error.
+ * @example
+ * ```ts
+ * import { sportEquipment } from "@johnmorrisdotca/dougu-sports/emblems";
+ * const nhl = sportEquipment("nhl");
+ * console.log(nhl.ball, nhl.trophy);
+ * // ball:puck trophy:hockey-cup
+ * ```
+ */
+export function sportEquipment(sport) {
+    if (!Object.hasOwn(TABLE, sport))
+        throw new Error(`Unknown sport "${String(sport).slice(0, 40)}": the equipment is for the names in SPORT_NAMES.`);
+    const [ball, gear, trophy, medal] = TABLE[sport];
+    return { sport, ...(ball === undefined ? {} : { ball }), gear: [...gear], trophy, ...(medal === undefined ? {} : { medal }) };
+}

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

@@ -0,0 +1,10 @@
+/** What a turn needs. `line` is the line style (the rim is drawn in the page's ink), `back` is the document of the back view, and `thick` is the thickness as a fraction of the width. */
+export interface FlipOptions {
+    yaw: number;
+    pitch: number;
+    line?: boolean;
+    back?: string;
+    thick?: number;
+}
+/** A document turned by `yaw` and `pitch` degrees from its still drawing. With no turn it is the document itself. */
+export declare function flipSvg(svg: string, o: FlipOptions): string;

package/dist/emblems/emblem.flip.js

@@ -0,0 +1,46 @@
+// The coin-flip turn for any flat drawing: it takes a finished document and returns it turned. The face is squeezed by the cosine of the yaw and shows its back past a quarter turn, and the rim
+// (the thickness of the sheet) shows as a dark edge on the side that is turning away, widest when the drawing is edge on. A piece with no drawing of its own for the back (a bat, a racket, a pictogram)
+// shows its front mirrored and a little darker, as the other side of a cut-out; a pennant passes the drawing of its back. A pure function of strings and numbers; it imports nothing.
+const RAD = Math.PI / 180;
+const n2 = (value) => String(Math.round(value * 100) / 100 + 0);
+/** The parts of a document of SVG: its opening tag, its titles, and the rest. */
+function split(svg) {
+    const open = /^<svg[^>]*>/.exec(svg)?.[0] ?? "";
+    const after = svg.slice(open.length, svg.length - "</svg>".length);
+    const head = /^<title>[\s\S]*?<\/title>(?:<desc>[\s\S]*?<\/desc>)?/.exec(after)?.[0] ?? "";
+    const box = (/viewBox="([^"]*)"/.exec(open)?.[1] ?? "0 0 64 64").split(/\s+/).map(Number);
+    return { open, head, rest: after.slice(head.length), box: [box[0] ?? 0, box[1] ?? 0, box[2] || 64, box[3] || 64] };
+}
+/** A document turned by `yaw` and `pitch` degrees from its still drawing. With no turn it is the document itself. */
+export function flipSvg(svg, o) {
+    if (o.yaw === 0 && o.pitch === 0)
+        return svg;
+    const across = Math.cos(o.yaw * RAD);
+    const tilt = Math.cos(o.pitch * RAD);
+    const front = split(svg);
+    const showBack = across < 0;
+    const own = showBack && o.back !== undefined ? split(o.back) : undefined;
+    const face = own ?? front;
+    const [x0, y0, w, h] = front.box;
+    const sx = Math.max(Math.abs(across), 0.02);
+    const sy = Math.max(Math.abs(tilt), 0.02);
+    const thick = w * (o.thick ?? 0.035);
+    // A turn to a positive yaw carries the front toward the right, as it does for a ball and a cup (and for a drag to the right), so the rim is seen on the left, on the edge that comes toward the eye.
+    const dx = -thick * Math.sin(o.yaw * RAD);
+    const dy = -thick * Math.sin(o.pitch * RAD) * 0.6;
+    const mirror = showBack && own === undefined;
+    const cx = x0 + w / 2;
+    const cy = y0 + h / 2;
+    // The turned face, then the filter that adds the rim behind it (and dims a mirrored back).
+    // The id names everything the definition depends on (its region comes from the box), so two drawings in one page that share an id share one filter.
+    const id = `dgf${o.line === true ? "l" : "c"}${mirror ? "b" : "f"}${Math.round(dx * 100)}_${Math.round(dy * 100)}_${[x0, y0, w, h].map((v) => Math.round(v)).join("_")}`;
+    const flood = o.line === true ? '<feFlood flood-color="currentColor" flood-opacity=".5"/>' : '<feFlood flood-color="#000" flood-opacity=".42"/>';
+    const steps = [1, 2, 3].map((k) => (Math.abs(dx) + Math.abs(dy) < 0.05 ? "" : `<feOffset in="s" dx="${n2((dx * k) / 3)}" dy="${n2((dy * k) / 3)}" result="o${k}"/>`)).join("");
+    const nodes = Math.abs(dx) + Math.abs(dy) < 0.05 ? "" : '<feMergeNode in="o3"/><feMergeNode in="o2"/><feMergeNode in="o1"/>';
+    const dim = mirror && o.line !== true ? '<feColorMatrix in="SourceGraphic" values=".8 0 0 0 0 0 .8 0 0 0 0 0 .8 0 0 0 0 0 1 0" result="d"/>' : "";
+    const filter = `<filter id="${id}" x="${n2(x0 - w * 0.15)}" y="${n2(y0 - h * 0.15)}" width="${n2(w * 1.3)}" height="${n2(h * 1.3)}" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">` +
+        `${flood}<feComposite in2="SourceAlpha" operator="in" result="s"/>${steps}${dim}<feMerge>${nodes}<feMergeNode in="${dim === "" ? "SourceGraphic" : "d"}"/></feMerge></filter>`;
+    const flip = mirror ? -1 : 1;
+    const group = `<g filter="url(#${id})"><g transform="translate(${n2(cx)} ${n2(cy)}) scale(${n2(sx * flip)} ${n2(sy)}) translate(${n2(-cx)} ${n2(-cy)})">${face.rest}</g></g>`;
+    return `${front.open}${front.head}<defs>${filter}</defs>${group}</svg>`;
+}

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

@@ -1,11 +1,11 @@
-/** The thirty-three sports the emblems are made for: the names that `ball:<sport>`, `gear:<sport>` and `sport:<sport>` use. */
-export declare const SPORT_NAMES: readonly ["nfl", "cfl", "ifaf", "nhl", "nba", "mlb", "soccer", "curling", "tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "squash", "racquetball", "sepaktakraw", "teqball", "roundnet", "netball", "swimming", "waterpolo", "diving", "artisticswimming", "lacrosse", "rugby", "afl", "gaelic", "cricket", "fieldhockey", "handball", "athletics", "skating"];
+/** The thirty-eight sports the emblems are made for (the five Japanese ones, sumo, kendo, judo, kyudo and karate, have a pictogram and their gear, and no ball): the names that `ball:<sport>`, `gear:<sport>` and `sport:<sport>` use. */
+export declare const SPORT_NAMES: readonly ["nfl", "cfl", "ifaf", "nhl", "nba", "mlb", "soccer", "curling", "tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "squash", "racquetball", "sepaktakraw", "teqball", "roundnet", "netball", "swimming", "waterpolo", "diving", "artisticswimming", "lacrosse", "rugby", "afl", "gaelic", "cricket", "fieldhockey", "handball", "athletics", "skating", "sumo", "kendo", "judo", "kyudo", "karate"];
 export type SportName = (typeof SPORT_NAMES)[number];
-/** The awards, drawn from Material Symbols: a medal on a ribbon, a badge, a crown, a star and a shield. */
+/** The awards: a medal on a ribbon, a badge, a crown, a star and a shield. */
 export declare const AWARD_IDS: readonly ["award:medal", "award:badge", "award:crown", "award:star", "award:shield"];
 export type AwardId = (typeof AWARD_IDS)[number];
 /** The trophies: a cup for each league's champion in a descriptive, generic form, the plain cups and dishes, and the flat plaque, belt, wreath and rosette. */
-export declare const TROPHY_IDS: readonly ["trophy:cup", "trophy:lidded-cup", "trophy:bowl", "trophy:salver", "trophy:globe", "trophy:hockey-cup", "trophy:basketball", "trophy:baseball", "trophy:football", "trophy:canadian-bowl", "trophy:soccer-ball", "trophy:soccer-globe", "trophy:tennis-plate", "trophy:tennis-cup", "trophy:cricket-urn", "trophy:rugby-cup", "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette"];
+export declare const TROPHY_IDS: readonly ["trophy:cup", "trophy:lidded-cup", "trophy:bowl", "trophy:salver", "trophy:globe", "trophy:hockey-cup", "trophy:basketball", "trophy:baseball", "trophy:football", "trophy:canadian-bowl", "trophy:soccer-ball", "trophy:soccer-globe", "trophy:tennis-plate", "trophy:tennis-cup", "trophy:cricket-urn", "trophy:rugby-cup", "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette", "trophy:ring", "trophy:banner", "trophy:sumo-cup", "trophy:championship-banner"];
 export type TrophyId = (typeof TROPHY_IDS)[number];
 /** The medals on a ribbon, and the badges for the first three places. */
 export declare const MEDAL_KINDS: readonly ["gold", "silver", "bronze"];
@@ -20,23 +20,30 @@ export type CrestId = (typeof CREST_IDS)[number];
 /** The balls: one for each ball and implement the sports use, in 3D, with the official size it comes from. The balls of one family (the three crickets, the five squash balls) share a module. */
 export declare const BALL_IDS: readonly ["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", "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"];
 export type BallId = (typeof BALL_IDS)[number];
-/** The pieces of gear: a piece of equipment for each sport, flat, drawn here or copied from open icon sets (NOTICE.md says which). */
-export declare const GEAR_IDS: readonly ["gear:hockey-stick", "gear:goalie-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net", "gear:field-hockey-stick", "gear:lacrosse-stick", "gear:cricket-bat", "gear:wicket", "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle", "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley", "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles"];
+/** The pieces of gear: a piece of equipment for each sport, flat, drawn for this package, turning like a coin. */
+export declare const GEAR_IDS: readonly ["gear:hockey-stick", "gear:goalie-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net", "gear:field-hockey-stick", "gear:lacrosse-stick", "gear:cricket-bat", "gear:wicket", "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle", "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley", "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles", "gear:gunbai", "gear:mawashi", "gear:shinai", "gear:kendo-men", "gear:judogi", "gear:obi", "gear:yumi", "gear:ya", "gear:karate-gi"];
 export type GearId = (typeof GEAR_IDS)[number];
-/** The sports' own emblems: one pictogram for each of the thirty-three. */
+/** The Japanese sports and budo: sumo, kendo, judo, kyudo and karate, with the trophies and the gear that belong to them. Every one is also in its own group; this list is for showing them together. */
+export declare const JAPANESE_IDS: readonly ["sport:sumo", "trophy:sumo-cup", "gear:gunbai", "gear:mawashi", "trophy:championship-banner", "sport:kendo", "gear:shinai", "gear:kendo-men", "sport:judo", "gear:judogi", "gear:obi", "sport:kyudo", "gear:yumi", "gear:ya", "sport:karate", "gear:karate-gi"];
+export type JapaneseId = (typeof JAPANESE_IDS)[number];
+/** The pennants: a felt championship pennant with a stitched edge. */
+export declare const PENNANT_IDS: readonly ["pennant:championship"];
+export type PennantId = (typeof PENNANT_IDS)[number];
+/** The sports' own emblems: one pictogram for each of the thirty-eight. */
 export type SportEmblemId = `sport:${SportName}`;
 export declare const SPORT_IDS: readonly SportEmblemId[];
 /** Every emblem id. */
-export type EmblemId = AwardId | TrophyId | MedalId | CrestId | BallId | GearId | SportEmblemId;
+export type EmblemId = AwardId | TrophyId | MedalId | CrestId | BallId | GearId | SportEmblemId | PennantId;
 /** The groups of ids, in the order a gallery shows them. */
 export declare const EMBLEM_GROUPS: {
     readonly award: readonly ["award:medal", "award:badge", "award:crown", "award:star", "award:shield"];
-    readonly trophy: readonly ["trophy:cup", "trophy:lidded-cup", "trophy:bowl", "trophy:salver", "trophy:globe", "trophy:hockey-cup", "trophy:basketball", "trophy:baseball", "trophy:football", "trophy:canadian-bowl", "trophy:soccer-ball", "trophy:soccer-globe", "trophy:tennis-plate", "trophy:tennis-cup", "trophy:cricket-urn", "trophy:rugby-cup", "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette"];
+    readonly trophy: readonly ["trophy:cup", "trophy:lidded-cup", "trophy:bowl", "trophy:salver", "trophy:globe", "trophy:hockey-cup", "trophy:basketball", "trophy:baseball", "trophy:football", "trophy:canadian-bowl", "trophy:soccer-ball", "trophy:soccer-globe", "trophy:tennis-plate", "trophy:tennis-cup", "trophy:cricket-urn", "trophy:rugby-cup", "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette", "trophy:ring", "trophy:banner", "trophy:sumo-cup", "trophy:championship-banner"];
     readonly medal: readonly ["medal:gold", "medal:silver", "medal:bronze", "medal:place-1", "medal:place-2", "medal:place-3"];
     readonly crest: readonly ["crest:shield", "crest:roundel", "crest:diamond", "crest:pennant"];
     readonly ball: readonly ["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", "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"];
-    readonly gear: readonly ["gear:hockey-stick", "gear:goalie-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net", "gear:field-hockey-stick", "gear:lacrosse-stick", "gear:cricket-bat", "gear:wicket", "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle", "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley", "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles"];
-    readonly sport: readonly ("sport:nfl" | "sport:cfl" | "sport:ifaf" | "sport:nhl" | "sport:nba" | "sport:mlb" | "sport:soccer" | "sport:curling" | "sport:tennis" | "sport:volleyball" | "sport:badminton" | "sport:pickleball" | "sport:tabletennis" | "sport:padel" | "sport:squash" | "sport:racquetball" | "sport:sepaktakraw" | "sport:teqball" | "sport:roundnet" | "sport:netball" | "sport:swimming" | "sport:waterpolo" | "sport:diving" | "sport:artisticswimming" | "sport:lacrosse" | "sport:rugby" | "sport:afl" | "sport:gaelic" | "sport:cricket" | "sport:fieldhockey" | "sport:handball" | "sport:athletics" | "sport:skating")[];
+    readonly gear: readonly ["gear:hockey-stick", "gear:goalie-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net", "gear:field-hockey-stick", "gear:lacrosse-stick", "gear:cricket-bat", "gear:wicket", "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle", "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley", "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles", "gear:gunbai", "gear:mawashi", "gear:shinai", "gear:kendo-men", "gear:judogi", "gear:obi", "gear:yumi", "gear:ya", "gear:karate-gi"];
+    readonly sport: readonly ("sport:sumo" | "sport:kendo" | "sport:judo" | "sport:kyudo" | "sport:karate" | "sport:nfl" | "sport:cfl" | "sport:ifaf" | "sport:nhl" | "sport:nba" | "sport:mlb" | "sport:soccer" | "sport:curling" | "sport:tennis" | "sport:volleyball" | "sport:badminton" | "sport:pickleball" | "sport:tabletennis" | "sport:padel" | "sport:squash" | "sport:racquetball" | "sport:sepaktakraw" | "sport:teqball" | "sport:roundnet" | "sport:netball" | "sport:swimming" | "sport:waterpolo" | "sport:diving" | "sport:artisticswimming" | "sport:lacrosse" | "sport:rugby" | "sport:afl" | "sport:gaelic" | "sport:cricket" | "sport:fieldhockey" | "sport:handball" | "sport:athletics" | "sport:skating")[];
+    readonly pennant: readonly ["pennant:championship"];
 };
 export type EmblemGroup = keyof typeof EMBLEM_GROUPS;
 /** Every id, in group order. */
@@ -50,6 +57,7 @@ export declare const EMBLEM_FOLDERS: {
     readonly ball: "ball";
     readonly gear: "gear";
     readonly sport: "sport";
+    readonly pennant: "pennant";
 };
 /** The short names of the trophies and awards that stand for a full id: `"cup"` is `"trophy:cup"` and `"crown"` is `"award:crown"`. */
 export declare const EMBLEM_ALIASES: Readonly<Record<string, EmblemId>>;

package/dist/emblems/emblem.ids.js

@@ -1,18 +1,20 @@
 // The ids of the emblems, in their groups, and the types they make. Nothing is imported: this file is only names, so it costs nothing to read. An id is `<group>:<name>`.
 // Each list below holds the emblems that exist. The art for the rest arrives group by group (docs/layout.md), and each arrival adds its names here and its entry to emblem.registry.ts.
-/** The thirty-three sports the emblems are made for: the names that `ball:<sport>`, `gear:<sport>` and `sport:<sport>` use. */
+/** The thirty-eight sports the emblems are made for (the five Japanese ones, sumo, kendo, judo, kyudo and karate, have a pictogram and their gear, and no ball): the names that `ball:<sport>`, `gear:<sport>` and `sport:<sport>` use. */
 export const SPORT_NAMES = [
     "nfl", "cfl", "ifaf", "nhl", "nba", "mlb", "soccer", "curling", "tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "squash", "racquetball", "sepaktakraw", "teqball", "roundnet", "netball",
     "swimming", "waterpolo", "diving", "artisticswimming", "lacrosse", "rugby", "afl", "gaelic", "cricket", "fieldhockey", "handball", "athletics", "skating",
+    "sumo", "kendo", "judo", "kyudo", "karate",
 ];
-/** The awards, drawn from Material Symbols: a medal on a ribbon, a badge, a crown, a star and a shield. */
+/** The awards: a medal on a ribbon, a badge, a crown, a star and a shield. */
 export const AWARD_IDS = ["award:medal", "award:badge", "award:crown", "award:star", "award:shield"];
 /** The trophies: a cup for each league's champion in a descriptive, generic form, the plain cups and dishes, and the flat plaque, belt, wreath and rosette. */
 export const TROPHY_IDS = [
     "trophy:cup", "trophy:lidded-cup", "trophy:bowl", "trophy:salver", "trophy:globe",
     "trophy:hockey-cup", "trophy:basketball", "trophy:baseball", "trophy:football", "trophy:canadian-bowl", "trophy:soccer-ball", "trophy:soccer-globe",
     "trophy:tennis-plate", "trophy:tennis-cup", "trophy:cricket-urn", "trophy:rugby-cup",
-    "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette",
+    "trophy:plaque", "trophy:belt", "trophy:laurel", "trophy:rosette", "trophy:ring", "trophy:banner",
+    "trophy:sumo-cup", "trophy:championship-banner",
 ];
 /** The medals on a ribbon, and the badges for the first three places. */
 export const MEDAL_KINDS = ["gold", "silver", "bronze"];
@@ -28,13 +30,25 @@ export const BALL_IDS = [
     "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 pieces of gear: a piece of equipment for each sport, flat, drawn here or copied from open icon sets (NOTICE.md says which). */
+/** The pieces of gear: a piece of equipment for each sport, flat, drawn for this package, turning like a coin. */
 export const GEAR_IDS = [
     "gear:hockey-stick", "gear:goalie-stick", "gear:hockey-skate", "gear:goalie-mask", "gear:goal-net", "gear:field-hockey-stick", "gear:lacrosse-stick", "gear:cricket-bat", "gear:wicket",
     "gear:table-tennis-paddle", "gear:badminton-racket", "gear:tennis-racket", "gear:squash-racket", "gear:racquetball-racket", "gear:padel-racket", "gear:pickleball-paddle",
     "gear:roundnet-set", "gear:volleyball-net", "gear:basketball-hoop", "gear:baseball-bat", "gear:baseball-glove", "gear:football-helmet", "gear:goalposts", "gear:hurley",
-    "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles"
+    "gear:curling-broom", "gear:figure-skate", "gear:speed-skate", "gear:diving-board", "gear:swim-goggles", "gear:starting-blocks", "gear:relay-baton", "gear:javelin", "gear:hurdles",
+    "gear:gunbai", "gear:mawashi", "gear:shinai", "gear:kendo-men", "gear:judogi", "gear:obi", "gear:yumi", "gear:ya", "gear:karate-gi"
 ];
+/** The Japanese sports and budo: sumo, kendo, judo, kyudo and karate, with the trophies and the gear that belong to them. Every one is also in its own group; this list is for showing them together. */
+export const JAPANESE_IDS = [
+    "sport:sumo", "trophy:sumo-cup", "gear:gunbai", "gear:mawashi",
+    "trophy:championship-banner",
+    "sport:kendo", "gear:shinai", "gear:kendo-men",
+    "sport:judo", "gear:judogi", "gear:obi",
+    "sport:kyudo", "gear:yumi", "gear:ya",
+    "sport:karate", "gear:karate-gi",
+];
+/** The pennants: a felt championship pennant with a stitched edge. */
+export const PENNANT_IDS = ["pennant:championship"];
 export const SPORT_IDS = SPORT_NAMES.map((name) => `sport:${name}`);
 /** The groups of ids, in the order a gallery shows them. */
 export const EMBLEM_GROUPS = {
@@ -45,10 +59,11 @@ export const EMBLEM_GROUPS = {
     ball: BALL_IDS,
     gear: GEAR_IDS,
     sport: SPORT_IDS,
+    pennant: PENNANT_IDS,
 };
 /** Every id, in group order. */
 export const EMBLEM_IDS = Object.values(EMBLEM_GROUPS).flat();
 /** The folder under `src/emblems/` that holds a group's art, one module per item named by the id's last part: `trophy:hockey-cup` is `trophy/hockey-cup.ts`, `ball:soccer` is `ball/soccer.ts`. Each group has a folder of its own, so no two ids share a file name. */
-export const EMBLEM_FOLDERS = { award: "award", trophy: "trophy", medal: "medal", crest: "crest", ball: "ball", gear: "gear", sport: "sport" };
+export const EMBLEM_FOLDERS = { award: "award", trophy: "trophy", medal: "medal", crest: "crest", ball: "ball", gear: "gear", sport: "sport", pennant: "pennant" };
 /** The short names of the trophies and awards that stand for a full id: `"cup"` is `"trophy:cup"` and `"crown"` is `"award:crown"`. */
 export const EMBLEM_ALIASES = Object.fromEntries([...TROPHY_IDS, ...AWARD_IDS].map((id) => [id.slice(id.indexOf(":") + 1), id]));

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

@@ -1,4 +1,5 @@
 import { type Emblem, type EmblemSource, type Metal } from "./emblem.core.ts";
+import { type Band } from "./emblem.engrave.ts";
 /** A point of the profile: the height `y` (0 at the top of the 64 unit box), the radius `r` from the axis (x = 32), 1 for a sharp corner (a smooth run of points ends at one), and the tone of the piece that starts here. */
 export type Pt = readonly [y: number, r: number, corner?: 0 | 1, tone?: string];
 /** Something drawn on the surface, by height and angle (90 degrees is the right side, 0 faces the eye): a `ring` round the body at a height; `mer`idians from one height to another; `helix` strands that wind `turns` times; a diamond `net`; `dots` (beads) round at a height with a size; on an open top, a `disc` of a tone out to a radius and `pills`, short rounded marks, round a radius. */
@@ -52,6 +53,8 @@ export interface LatheModel {
     handles?: readonly Handle[];
     balls?: readonly Ball[];
     poles?: Poles;
+    /** The plinth: the band of the body (heights, the tone it is cut into, and for a body with flat sides which side) that holds an engraving, which turns with the body. */
+    plate?: Band;
 }
 /** The radius of the body at a height. */
 export declare function radiusAt(profile: readonly Pt[], y: number): number;

package/dist/emblems/emblem.lathe.js

@@ -2,7 +2,8 @@
 // grooves round the body, a pattern on a dish) are placed by the angle they are turned to. One model draws the still emblem (yaw 0) and the emblem turned (`frame`), so the 2D and the turning view
 // come from the same data. The silhouette is the profile at every yaw; the light, the handles, the grooves and the seams move to where `sin(yaw)` puts them, and are drawn back to front. Plain SVG.
 // Imports only the core.
-import { cylinderGradient, defsOf, hexOf, mainOf, mix, orbGradient, readColour, resolve, wrap, } from "./emblem.core.js";
+import { cylinderGradient, defsOf, hexOf, labelled, mainOf, mix, orbGradient, readColour, resolve, wrap, } from "./emblem.core.js";
+import { cylinderText, engravingInk, engravingOf, flatText, sideText } from "./emblem.engrave.js";
 const CX = 32;
 const RAD = Math.PI / 180;
 const f = (n) => String(Math.round(n * 10) / 10 + 0);
@@ -64,7 +65,7 @@ function piecesOf(p) {
 const arc = (y, r, s, toLeft) => `Q${pt(CX, y + 2 * r * s)} ${pt(CX + (toLeft ? -r : r), y)}`;
 const ellipse = (cx, cy, rx, ry, fill, extra = "") => `<ellipse cx="${f(cx)}" cy="${f(cy)}" rx="${f(rx)}" ry="${f(Math.max(ry, 0.25))}" fill="${fill}"${extra}/>`;
 /** The geometry and paint of one drawing of the model at a yaw and a pitch. */
-function draw(model, r, yaw, pitch) {
+function draw(model, r, o, yaw, pitch) {
     const line = r.style === "line";
     const flat = r.style === "color";
     const elevation = Math.max(0, Math.min(75, (model.tilt ?? 12) + pitch));
@@ -384,6 +385,26 @@ function draw(model, r, yaw, pitch) {
         }
         mid.push(...parts);
     }
+    // The engraving on the plinth: letters set round the body (or along one flat side), foreshortened and hidden as they turn away.
+    const plate = model.plate;
+    const words = plate === undefined ? "" : flatText(engravingOf(o));
+    if (plate !== undefined && words !== "") {
+        const y = (plate.y0 + plate.y1) / 2;
+        const solid = model.solids.find((q) => q.p[0][0] <= y && y <= q.p[q.p.length - 1][0]) ?? model.solids[0];
+        const radius = radiusAt(solid.p, y);
+        const ink = engravingInk(r.style, tone(plate.tone ?? solid.tone).rgb);
+        if (solid.sides === undefined)
+            mid.push(cylinderText(words, radius, plate.y1 - plate.y0, ink, yaw, plate.at ?? 0, (deg) => at(radius, y, deg)));
+        else {
+            const n = solid.sides;
+            const k = plate.face ?? 0;
+            const a0 = (360 * k) / n + yaw;
+            const a1 = (360 * (k + 1)) / n + yaw;
+            const [ax, ay] = at(radius, y, a0);
+            const [bx, by] = at(radius, y, a1);
+            mid.push(sideText(words, 2 * radius * Math.sin(Math.PI / n), plate.y1 - plate.y0, ink, [ax, ay], [bx, by], Math.cos(((a0 + a1) / 2) * RAD)));
+        }
+    }
     return { body: back.join("") + mid.join("") + front.join(""), defs: line || flat ? "" : defsOf(grads), edge: main.edge };
 }
 /** The twelve pentagons of a ball, as the centres of a sphere's faces: the poles and two rings of five. */
@@ -397,8 +418,9 @@ export function defineLathe(id, en, ja, source, model) {
         const r = resolve(o);
         const yaw = typeof o?.yaw === "number" && Number.isFinite(o.yaw) ? o.yaw % 360 : 0;
         const pitch = typeof o?.pitch === "number" && Number.isFinite(o.pitch) ? Math.max(-40, Math.min(60, o.pitch)) : 0;
-        const d = draw(model, r, yaw, pitch);
+        const d = draw(model, r, o, yaw, pitch);
         return wrap({ title: en, size: r.size, style: r.style, theme: r.theme, defs: d.defs, body: d.body, edge: d.edge, width: r.style === "line" ? 2.3 : 0.6 });
     };
-    return { id, en, ja, source, kind: "lathe", model, svg: (o) => frame(o), frame };
+    const still = labelled(en, ja, (o) => frame(o));
+    return { id, en, ja, source, kind: "lathe", model, svg: still, frame: labelled(en, ja, frame) };
 }

package/dist/emblems/emblem.medal.js

@@ -23,16 +23,16 @@ export function defineMedal(id, en, ja, metal) {
     const front = [
         ...ribbon(),
         ...disc,
-        ["m", starPath(32, 43, 9, 3.9)],
+        ["M", starPath(32, 43, 9, 3.9)],
         ["l", "M19.2 40a13.4 13.4 0 0 1 9.4-10.4 14 14 0 0 0-6.6 12.6z"],
     ];
-    const back = [...disc, ["e", circlePath(32, 43, 8.4), "1.4"]];
-    return defineFlat(id, en, ja, "ours", { metal, front, back, rim: 3 });
+    const back = [...disc, ["E", circlePath(32, 43, 8.4), "1.4"]];
+    return defineFlat(id, en, ja, "ours", { metal, front, back, rim: 3, engrave: { front: { x: 32, y: 43, w: 19, h: 15 }, back: { x: 32, y: 43, w: 20, h: 13 } } });
 }
 /** The numerals 1, 2 and 3 as strokes. */
 const NUMERALS = { 1: "M26 28l7-5v20", 2: "M25 28c1-9 15-9 15 0 0 6-14 9-15 15h16", 3: "M25 26c4-6 14-4 13 2-1 5-6 6-9 6 3 0 9 1 9 7 0 8-14 9-16 2" };
 /** A plain badge for a place: a bevelled disc with its numeral. */
 export function definePlace(id, en, ja, place, metal) {
     const base = [["o", circlePath(32, 32, 27.5)], ["e", circlePath(32, 32, 24.2), "2.2"]];
-    return defineFlat(id, en, ja, "ours", { metal, front: [...base, ["d", NUMERALS[place]], ["l", "M10.4 28a22 22 0 0 1 16.6-17 24 24 0 0 0-11 22z"]], back: [...base, ["e", circlePath(32, 32, 14), "1.6"]], rim: 3 });
+    return defineFlat(id, en, ja, "ours", { metal, front: [...base, ["D", NUMERALS[place]], ["l", "M10.4 28a22 22 0 0 1 16.6-17 24 24 0 0 0-11 22z"]], back: [...base, ["E", circlePath(32, 32, 14), "1.6"]], rim: 3, engrave: { front: { x: 32, y: 32, w: 30, h: 28 }, back: { x: 32, y: 32, w: 30, h: 20 }, rank: String(place) } });
 }

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

@@ -0,0 +1,3 @@
+import { type Emblem } from "./emblem.core.ts";
+/** A pennant: its front with the lettering, turned like a coin to its plain back. */
+export declare function definePennant(id: string, en: string, ja: string): Emblem<null>;