@johnmorrisdotca/taisen-brackets 0.6.1 → 0.8.0

package/dist/judo-text.d.ts

@@ -0,0 +1,19 @@
+import type { JudoMethod, JudoSide } from "./judo-model.ts";
+import type { Tie } from "./types.ts";
+import { type Voice } from "./locales.ts";
+type Filled = Required<JudoSide>;
+/** A side's score as the box writes it: `I` for ippon, `W` a waza-ari (`W2` two), `Y` a yuko (`Y3` three), "0" for none. The marks are the language's (`judoIppon`, `judoWazaAri`, `judoYuko`). */
+export declare function judoMark(side: Filled, v: Voice): string;
+/** A side's score in words, for a sentence: "ippon", "waza-ari yuko", "2 waza-ari 3 yuko", "0". */
+export declare function judoSideLong(side: Filled, v: Voice): string;
+/** How a contest was won, in the language. */
+export declare function judoMethodWord(method: JudoMethod, v: Voice): string;
+/** The pieces of a judo contest's note, short or in a sentence: how it was won, golden score, the contest time, and (long only) each side's shido. */
+export declare function judoNotes(tie: Tie, v: Voice, long: boolean): string[];
+/** What a row of a box writes for a side's score: a judo contest's marks, else the number. `""` when nothing was played. */
+export declare function sideScore(tie: Tie, k: 0 | 1, v: Voice): string;
+/** A side's score in words for a sentence (a judo contest's, else the number). */
+export declare function sideScoreLong(tie: Tie, k: 0 | 1, v: Voice): string;
+/** The cards beside a side's score: a yellow one for each shido, and a red one for the third (hansoku-make) or for a direct hansoku-make: `["y", "y", "r"]`. */
+export declare function shidoCards(tie: Tie, k: 0 | 1): ("y" | "r")[];
+export {};

package/dist/judo-text.js

@@ -0,0 +1,84 @@
+import { judoClock } from "./judo-model.js";
+import { fill } from "./locales.js";
+/** A side's score as the box writes it: `I` for ippon, `W` a waza-ari (`W2` two), `Y` a yuko (`Y3` three), "0" for none. The marks are the language's (`judoIppon`, `judoWazaAri`, `judoYuko`). */
+export function judoMark(side, v) {
+    const w = v.words;
+    if (side.ippon)
+        return w.judoIppon;
+    const parts = [];
+    if (side.wazaAri > 0)
+        parts.push(w.judoWazaAri + (side.wazaAri > 1 ? v.number(side.wazaAri) : ""));
+    if (side.yuko > 0)
+        parts.push(w.judoYuko + (side.yuko > 1 ? v.number(side.yuko) : ""));
+    return parts.length ? parts.join(" ") : v.number(0);
+}
+/** A side's score in words, for a sentence: "ippon", "waza-ari yuko", "2 waza-ari 3 yuko", "0". */
+export function judoSideLong(side, v) {
+    const w = v.words;
+    if (side.ippon)
+        return w.judoIpponLong;
+    const parts = [];
+    if (side.wazaAri > 0)
+        parts.push(side.wazaAri > 1 ? `${v.number(side.wazaAri)} ${w.judoWazaAriLong}` : w.judoWazaAriLong);
+    if (side.yuko > 0)
+        parts.push(side.yuko > 1 ? `${v.number(side.yuko)} ${w.judoYukoLong}` : w.judoYukoLong);
+    return parts.length ? parts.join(" ") : v.number(0);
+}
+/** How a contest was won, in the language. */
+export function judoMethodWord(method, v) {
+    const w = v.words;
+    switch (method) {
+        case "ippon": return w.judoMethodIppon;
+        case "waza-ari-awasete-ippon": return w.judoMethodAwasete;
+        case "score": return w.judoMethodScore;
+        case "hansoku-make": return w.judoMethodHansoku;
+        case "fusen-gachi": return w.judoMethodFusen;
+        case "kiken-gachi": return w.judoMethodKiken;
+    }
+}
+/** The pieces of a judo contest's note, short or in a sentence: how it was won, golden score, the contest time, and (long only) each side's shido. */
+export function judoNotes(tie, v, long) {
+    const j = tie.judo;
+    if (!j)
+        return [];
+    const w = v.words;
+    const out = [];
+    if (j.method !== null)
+        out.push(judoMethodWord(j.method, v));
+    if (j.goldenScore)
+        out.push(long ? w.judoGoldenLong : w.judoGolden);
+    if (j.seconds !== null)
+        out.push(fill(w.judoTime, { t: judoClock(j.seconds) }));
+    if (long) {
+        [0, 1].forEach((k) => {
+            const team = tie.sides[k];
+            if (j.sides[k].shido > 0 && team)
+                out.push(fill(w.judoShidoOf, { name: v.team(team), n: v.number(j.sides[k].shido) }));
+        });
+    }
+    return out;
+}
+/** What a row of a box writes for a side's score: a judo contest's marks, else the number. `""` when nothing was played. */
+export function sideScore(tie, k, v) {
+    if (tie.judo)
+        return tie.result.score ? judoMark(tie.judo.sides[k], v) : "";
+    return tie.result.score ? v.number(tie.result.score[k]) : "";
+}
+/** A side's score in words for a sentence (a judo contest's, else the number). */
+export function sideScoreLong(tie, k, v) {
+    if (tie.judo)
+        return judoSideLong(tie.judo.sides[k], v);
+    return tie.result.score ? v.number(tie.result.score[k]) : "";
+}
+/** The cards beside a side's score: a yellow one for each shido, and a red one for the third (hansoku-make) or for a direct hansoku-make: `["y", "y", "r"]`. */
+export function shidoCards(tie, k) {
+    const j = tie.judo;
+    if (!j)
+        return [];
+    const n = j.sides[k].shido;
+    if (n >= 3)
+        return ["y", "y", "r"];
+    // A direct hansoku-make is the loser's red card, when it came with no third shido.
+    const penalised = j.method === "hansoku-make" && j.winner !== null && j.winner !== k;
+    return penalised ? [...Array.from({ length: n }, () => "y"), "r"] : Array.from({ length: n }, () => "y");
+}

package/dist/judo.d.ts

@@ -0,0 +1,44 @@
+import type { BracketInput, BracketLayout, Matchup, Team } from "./types.ts";
+export { JUDO_WEIGHT_CLASSES, judoOutcome, judoSeconds, judoClock } from "./judo-model.ts";
+export type { JudoMethod, JudoOutcome, JudoResult, JudoSide } from "./judo-model.ts";
+/** How a judo tournament is drawn: `repechage` (the IJF's quarter-final repechage, with its two bronze medal contests), or `direct` (a direct knockout in which both semi-final losers are bronze medallists). */
+export type JudoSystem = "repechage" | "direct";
+export interface JudoBracketOptions {
+    /** Default `repechage` for eight athletes or more, else `direct`. */
+    system?: JudoSystem;
+    /** The ids of the contests are `${prefix}1-1`, `${prefix}1-2`… (round, then place in the round), `${prefix}rep-1`, `${prefix}bronze-1`. Default "J". */
+    prefix?: string;
+}
+/**
+ * The contests of one judo weight category for any number of athletes, seeded in the standard way (the top seeds have the byes when the number is
+ * not a power of two). The athlete drawn first is white and the second blue (`Matchup.sides`: first white).
+ *
+ * With `repechage` (IJF Sport and Organisation Rules, 2.5.2 "Quarter-final Repechage", the system of the Olympic Games): the athletes are in two tables
+ * and an elimination produces two finalists. "The athletes defeated in the quarter-final will compete in two (2) repechage contests. The winners of each of
+ * these two (2) repechage contests will compete in bronze medal contests against the loser of the semi-final contest of the respective opposite table.
+ * The winners (2) of those contests are placed third." The repechage and bronze contests are `stage: "repechage"` and `stage: "bronze"` matchups, fed by
+ * the losers of the tree's, and are drawn under it. Needs eight athletes or more. With `direct`, there are no such contests: the two losing semi-finalists are
+ * the bronze medallists (`judoPodium`).
+ *
+ * Double repechage and full repechage (2.5.3 and 2.5.4) are not drawn: their pools are laid out in the rules' Appendix G charts.
+ */
+export declare function judoBracket(athletes: readonly Team[], options?: JudoBracketOptions): {
+    teams: Team[];
+    matchups: Matchup[];
+};
+/** The medallists of a judo tournament, as far as it has been fought. */
+export interface JudoPodium {
+    gold: Team | null;
+    silver: Team | null;
+    /** The two bronze medallists: the winners of the bronze medal contests, or the losing semi-finalists of a direct knockout. Only those decided. */
+    bronze: Team[];
+}
+/** The gold, silver and two bronze medals of a bracket (matchups, input or layout), from the final, the bronze medal contests or the semi-finals. */
+export declare function judoPodium(input: BracketLayout | readonly Matchup[] | BracketInput): JudoPodium;
+export interface JudoCategory {
+    sex: "men" | "women";
+    /** `"-66"` (up to and including 66 kg), `"+100"` (over 100 kg): see `JUDO_WEIGHT_CLASSES`. */
+    weight: string;
+}
+/** A weight category as a heading in a language: "Men -66 kg", "Women +78 kg". */
+export declare function judoCategoryLabel(category: JudoCategory, locale?: string): string;

package/dist/judo.js

@@ -0,0 +1,75 @@
+import { layoutBracket } from "./layout.js";
+import { singleElimination } from "./seeding.js";
+import { fill, voiceOf } from "./locales.js";
+export { JUDO_WEIGHT_CLASSES, judoOutcome, judoSeconds, judoClock } from "./judo-model.js";
+/**
+ * The contests of one judo weight category for any number of athletes, seeded in the standard way (the top seeds have the byes when the number is
+ * not a power of two). The athlete drawn first is white and the second blue (`Matchup.sides`: first white).
+ *
+ * With `repechage` (IJF Sport and Organisation Rules, 2.5.2 "Quarter-final Repechage", the system of the Olympic Games): the athletes are in two tables
+ * and an elimination produces two finalists. "The athletes defeated in the quarter-final will compete in two (2) repechage contests. The winners of each of
+ * these two (2) repechage contests will compete in bronze medal contests against the loser of the semi-final contest of the respective opposite table.
+ * The winners (2) of those contests are placed third." The repechage and bronze contests are `stage: "repechage"` and `stage: "bronze"` matchups, fed by
+ * the losers of the tree's, and are drawn under it. Needs eight athletes or more. With `direct`, there are no such contests: the two losing semi-finalists are
+ * the bronze medallists (`judoPodium`).
+ *
+ * Double repechage and full repechage (2.5.3 and 2.5.4) are not drawn: their pools are laid out in the rules' Appendix G charts.
+ */
+export function judoBracket(athletes, options = {}) {
+    const system = options.system ?? (athletes.length >= 8 ? "repechage" : "direct");
+    if (system !== "repechage" && system !== "direct")
+        throw new RangeError(`taisen-brackets: a judo system is "repechage" or "direct", not ${JSON.stringify(system)}`);
+    if (athletes.length < 4)
+        throw new RangeError("taisen-brackets: a judo bracket needs four athletes or more (the two losing semi-finalists are bronze medallists)");
+    if (system === "repechage" && athletes.length < 8)
+        throw new RangeError("taisen-brackets: a quarter-final repechage needs eight athletes or more; use system: \"direct\" for fewer");
+    const prefix = options.prefix ?? "J";
+    const made = singleElimination(athletes, { prefix });
+    if (system === "direct")
+        return made;
+    const rounds = Math.max(...made.matchups.map((m) => m.round ?? 0));
+    const semis = made.matchups.filter((m) => m.round === rounds - 1);
+    const quarters = (semi) => {
+        const [a, b] = semi.feeds ?? [];
+        if (typeof a !== "string" || typeof b !== "string")
+            throw new Error("taisen-brackets: a semi-final of a repechage bracket needs two quarter-finals feeding it");
+        return [a, b];
+    };
+    const loser = (tie) => ({ tie, result: "loser" });
+    const extra = [];
+    semis.forEach((semi, k) => {
+        const [q1, q2] = quarters(semi);
+        extra.push({ id: `${prefix}rep-${k + 1}`, sides: [null, null], feeds: [loser(q1), loser(q2)], stage: "repechage" });
+    });
+    semis.forEach((semi, k) => {
+        // The repechage winner of one table meets the semi-final loser of the other.
+        const other = semis[1 - k];
+        extra.push({ id: `${prefix}bronze-${k + 1}`, sides: [null, null], feeds: [`${prefix}rep-${k + 1}`, loser(other.id)], stage: "bronze" });
+    });
+    return { teams: made.teams, matchups: [...made.matchups, ...extra] };
+}
+/** The gold, silver and two bronze medals of a bracket (matchups, input or layout), from the final, the bronze medal contests or the semi-finals. */
+export function judoPodium(input) {
+    const layout = "ties" in input && "sides" in input ? input : layoutBracket(input);
+    const fin = layout.finalIndex === null ? null : layout.ties[layout.finalIndex];
+    const gold = fin && fin.winner !== null ? fin.sides[fin.winner] : null;
+    const silver = fin && fin.winner !== null ? fin.sides[(1 - fin.winner)] : null;
+    const bronzeTies = layout.ties.filter((t) => t.stage === "bronze");
+    let bronze;
+    if (bronzeTies.length)
+        bronze = bronzeTies.flatMap((t) => (t.winner === null || !t.sides[t.winner] ? [] : [t.sides[t.winner]]));
+    else {
+        const semis = layout.finalIndex === null ? [] : layout.ties.filter((t) => t.round === layout.rounds - 1 && t.stage === undefined && !t.third && layout.place[t.index] !== "o");
+        bronze = semis.flatMap((t) => (t.winner === null || !t.sides[(1 - t.winner)] ? [] : [t.sides[(1 - t.winner)]]));
+    }
+    return { gold, silver, bronze };
+}
+/** A weight category as a heading in a language: "Men -66 kg", "Women +78 kg". */
+export function judoCategoryLabel(category, locale) {
+    if (category.sex !== "men" && category.sex !== "women")
+        throw new RangeError(`taisen-brackets: a judo category's sex is "men" or "women", not ${JSON.stringify(category.sex)}`);
+    if (!/^[-+]\d{2,3}$/.test(category.weight))
+        throw new RangeError(`taisen-brackets: a judo weight is "-66" or "+100", not ${JSON.stringify(category.weight)}`);
+    const w = voiceOf({ locale }).words;
+    return fill(category.weight.startsWith("+") ? w.judoWeightOver : w.judoWeightClass, { sex: category.sex === "men" ? w.judoMen : w.judoWomen, w: category.weight.slice(1) });
+}

package/dist/layout.js

@@ -17,8 +17,8 @@ export function layoutBracket(input, options = {}) {
             throw new Error(`taisen-brackets: two matchups have the id ${JSON.stringify(t.id)}`);
         byId.set(t.id, t.index);
     }
-    // A play-in game is outside the tree; so are a third-place match and a round-robin game.
-    const playIns = ties.filter((t) => matchups[t.index].stage === "play-in").map((t) => t.index);
+    // A play-in game is outside the tree, and so are a judo repechage and bronze medal contest (a stage's ties are fed by the tree's losers); so are a third-place match and a round-robin game.
+    const playIns = ties.filter((t) => matchups[t.index].stage !== undefined).map((t) => t.index);
     const isPlayIn = new Set(playIns);
     const thirds = ties.filter((t) => t.third && !isPlayIn.has(t.index)).map((t) => t.index);
     const robin = ties.filter((t) => !t.third && !isPlayIn.has(t.index) && matchups[t.index].round === 0).map((t) => t.index);

package/dist/layouts.js

@@ -1,10 +1,11 @@
 import { abbrOf } from "./matchup.js";
+import { sideScore } from "./judo-text.js";
 import { drawMark } from "./marks.js";
 import { emWidth, esc, fit, num } from "./text.js";
 const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
 /** The width of a text set in bold at a size: the package's generous estimate, so that a text stays inside its place in any font. */
 const bw = (text, size) => emWidth(text) * size;
-const scoreOf = (e, k) => (e.scoresOn && e.tie.result.score ? e.v.number(e.tie.result.score[k]) : "");
+const scoreOf = (e, k) => (e.scoresOn ? sideScore(e.tie, k, e.v) : "");
 const pensOf = (e, k) => (e.scoresOn && e.tie.result.pens ? `(${e.v.number(e.tie.result.pens[k])})` : "");
 /** A small pill with a seed tag, its left edge at `x`, centred on `cy`. */
 function tagPill(text, x, cy, size) {
@@ -260,7 +261,7 @@ export function seriesLineWidth(tie, v, size, scoresOn) {
     const score = scoresOn && tie.result.score ? fillScore(tie, v) : v.words.vs;
     return bw(code(0), size) + bw(code(1), size) + bw(score, size) + 4 * size * 0.6 + 8 * 2 + 2 * bw("00", size * 0.72);
 }
-const fillScore = (tie, v) => (tie.result.score ? v.words.scoreText.replace("{a}", v.number(tie.result.score[0])).replace("{b}", v.number(tie.result.score[1])) : "");
+const fillScore = (tie, v, swap = false) => (tie.result.score ? v.words.scoreText.replace("{a}", sideScore(tie, swap ? 1 : 0, v)).replace("{b}", sideScore(tie, swap ? 0 : 1, v)) : "");
 /** One line a series: "(1) BOS 4–0 MIA (8)", the winner in bold and the loser quiet. Where the box is too narrow for a line, two compact rows. */
 function series(e) {
     const { x, y, w, h, tie, v } = e;
@@ -274,7 +275,7 @@ function series(e) {
     const [a, b] = e.order;
     const cy = y + h / 2;
     const score = e.scoresOn && tie.result.score ? fillScore(tie, v) : v.words.vs;
-    const scoreOrdered = e.scoresOn && tie.result.score && a === 1 ? v.words.scoreText.replace("{a}", v.number(tie.result.score[1])).replace("{b}", v.number(tie.result.score[0])) : score;
+    const scoreOrdered = e.scoresOn && tie.result.score && a === 1 ? fillScore(tie, v, true) : score;
     const sw = bw(scoreOrdered, size);
     const cx = x + w / 2;
     const ss = Math.max(size * 0.72, 7.5);

package/dist/locales.js

@@ -21,6 +21,12 @@ const EN = {
     roadFinal: "The final: {a} {score} {b} ({how}).", roadChampion: "{name} won the final.", roadToPlay: "The final is still to be played.",
     vs: "vs", at: "AT", groupName: "Group {n}", colPlayed: "P", colWon: "W", colDrawn: "D", colLost: "L", colDiff: "GD", colPoints: "Pts",
     playIn: "Play-in", playInWinner: "Winner {a}/{b}", playInLoser: "Loser {a}/{b}", seedSlot: "Seed {n}", winnerOf: "Winner of {name}", loserOf: "Loser of {name}",
+    judoIppon: "I", judoWazaAri: "W", judoYuko: "Y", judoIpponLong: "ippon", judoWazaAriLong: "waza-ari", judoYukoLong: "yuko",
+    judoMethodIppon: "ippon", judoMethodAwasete: "waza-ari awasete ippon", judoMethodScore: "decision", judoMethodHansoku: "hansoku-make", judoMethodFusen: "fusen-gachi", judoMethodKiken: "kiken-gachi",
+    judoGolden: "GS", judoGoldenLong: "golden score", judoTime: "{t}", judoShidoOf: "{name}: {n} shido", judoShidoShort: "shido {a}–{b}",
+    judoRepechage: "Repechage", judoBronze: "Bronze medal contest", judoRepechageBronze: "Repechage and bronze medal contests", judoWhite: "white", judoBlue: "blue",
+    judoWeightClass: "{sex} -{w} kg", judoWeightOver: "{sex} +{w} kg", judoMen: "Men", judoWomen: "Women",
+    judoOsaekomi: "Osaekomi", judoShido: "Shido", judoMat: "Mat {n}", judoContest: "Contest {n}", judoCoach: "Coach: {name}", judoBoardTitle: "Judo contest scoreboard",
 };
 const FR = {
     tbd: "À déterminer", bye: "exempt", walkover: "forfait", champion: "Champion", thirdPlace: "Match pour la troisième place", other: "Autres rencontres",
@@ -38,6 +44,12 @@ const FR = {
     roadFinal: "La finale : {a} {score} {b} ({how}).", roadChampion: "{name} a remporté la finale.", roadToPlay: "La finale reste à jouer.",
     vs: "vs", at: "À", groupName: "Groupe {n}", colPlayed: "PJ", colWon: "V", colDrawn: "N", colLost: "D", colDiff: "+/-", colPoints: "Pts",
     playIn: "Play-in", playInWinner: "Gagnant {a}/{b}", playInLoser: "Perdant {a}/{b}", seedSlot: "N°\u00a0{n}", winnerOf: "Gagnant du match {name}", loserOf: "Perdant du match {name}",
+    judoIppon: "I", judoWazaAri: "W", judoYuko: "Y", judoIpponLong: "ippon", judoWazaAriLong: "waza-ari", judoYukoLong: "yuko",
+    judoMethodIppon: "ippon", judoMethodAwasete: "waza-ari awasete ippon", judoMethodScore: "décision", judoMethodHansoku: "hansoku-make", judoMethodFusen: "fusen-gachi", judoMethodKiken: "kiken-gachi",
+    judoGolden: "GS", judoGoldenLong: "golden score", judoTime: "{t}", judoShidoOf: "{name}\u00a0: {n}\u00a0shido", judoShidoShort: "shido {a}–{b}",
+    judoRepechage: "Repêchage", judoBronze: "Combat pour la médaille de bronze", judoRepechageBronze: "Repêchages et combats pour la médaille de bronze", judoWhite: "blanc", judoBlue: "bleu",
+    judoWeightClass: "{sex} -{w}\u00a0kg", judoWeightOver: "{sex} +{w}\u00a0kg", judoMen: "Hommes", judoWomen: "Femmes",
+    judoOsaekomi: "Osaekomi", judoShido: "Shido", judoMat: "Tapis {n}", judoContest: "Combat {n}", judoCoach: "Entraîneur\u00a0: {name}", judoBoardTitle: "Tableau d’affichage d’un combat de judo",
 };
 const JA = {
     tbd: "未定", bye: "シード", walkover: "不戦勝", champion: "優勝", thirdPlace: "3位決定戦", other: "その他の対戦",
@@ -55,6 +67,12 @@ const JA = {
     roadFinal: "決勝は{a} {score} {b}（{how}）でした。", roadChampion: "{name}が優勝しました。", roadToPlay: "決勝はまだ行われていません。",
     vs: "対", at: "@", groupName: "グループ{n}", colPlayed: "試合", colWon: "勝", colDrawn: "分", colLost: "敗", colDiff: "得失差", colPoints: "勝点",
     playIn: "プレイイン", playInWinner: "{a}/{b}の勝者", playInLoser: "{a}/{b}の敗者", seedSlot: "第{n}シード", winnerOf: "{name}の勝者", loserOf: "{name}の敗者",
+    judoIppon: "一", judoWazaAri: "技", judoYuko: "有", judoIpponLong: "一本", judoWazaAriLong: "技あり", judoYukoLong: "有効",
+    judoMethodIppon: "一本", judoMethodAwasete: "合わせ技一本", judoMethodScore: "優勢勝ち", judoMethodHansoku: "反則勝ち", judoMethodFusen: "不戦勝", judoMethodKiken: "棄権勝ち",
+    judoGolden: "GS", judoGoldenLong: "ゴールデンスコア", judoTime: "{t}", judoShidoOf: "{name}：指導{n}", judoShidoShort: "指導{a}–{b}",
+    judoRepechage: "敗者復活戦", judoBronze: "銅メダル決定戦", judoRepechageBronze: "敗者復活戦と銅メダル決定戦", judoWhite: "白", judoBlue: "青",
+    judoWeightClass: "{sex}{w}kg級", judoWeightOver: "{sex}{w}kg超級", judoMen: "男子", judoWomen: "女子",
+    judoOsaekomi: "抑え込み", judoShido: "指導", judoMat: "第{n}試合場", judoContest: "試合 {n}", judoCoach: "コーチ：{name}", judoBoardTitle: "柔道試合のスコアボード",
 };
 const ES = {
     tbd: "Por definir", bye: "exento", walkover: "incomparecencia", champion: "Campeón", thirdPlace: "Partido por el tercer puesto", other: "Otros partidos",
@@ -72,6 +90,12 @@ const ES = {
     roadFinal: "La final: {a} {score} {b} ({how}).", roadChampion: "{name} ganó la final.", roadToPlay: "La final aún no se ha jugado.",
     vs: "vs.", at: "EN", groupName: "Grupo {n}", colPlayed: "PJ", colWon: "G", colDrawn: "E", colLost: "P", colDiff: "DG", colPoints: "Pts",
     playIn: "Play-in", playInWinner: "Ganador {a}/{b}", playInLoser: "Perdedor {a}/{b}", seedSlot: "Puesto {n}", winnerOf: "Ganador de {name}", loserOf: "Perdedor de {name}",
+    judoIppon: "I", judoWazaAri: "W", judoYuko: "Y", judoIpponLong: "ippon", judoWazaAriLong: "waza-ari", judoYukoLong: "yuko",
+    judoMethodIppon: "ippon", judoMethodAwasete: "waza-ari awasete ippon", judoMethodScore: "decisión", judoMethodHansoku: "hansoku-make", judoMethodFusen: "fusen-gachi", judoMethodKiken: "kiken-gachi",
+    judoGolden: "GS", judoGoldenLong: "golden score", judoTime: "{t}", judoShidoOf: "{name}: {n} shido", judoShidoShort: "shido {a}–{b}",
+    judoRepechage: "Repesca", judoBronze: "Combate por la medalla de bronce", judoRepechageBronze: "Repesca y combates por la medalla de bronce", judoWhite: "blanco", judoBlue: "azul",
+    judoWeightClass: "{sex} -{w} kg", judoWeightOver: "{sex} +{w} kg", judoMen: "Hombres", judoWomen: "Mujeres",
+    judoOsaekomi: "Osaekomi", judoShido: "Shido", judoMat: "Tatami {n}", judoContest: "Combate {n}", judoCoach: "Entrenador: {name}", judoBoardTitle: "Marcador de un combate de judo",
 };
 const DE = {
     tbd: "offen", bye: "Freilos", walkover: "kampflos", champion: "Turniersieger", thirdPlace: "Spiel um Platz 3", other: "Weitere Begegnungen",
@@ -89,6 +113,12 @@ const DE = {
     roadFinal: "Das Finale: {a} {score} {b} ({how}).", roadChampion: "{name} gewann das Finale.", roadToPlay: "Das Finale steht noch aus.",
     vs: "vs.", at: "BEI", groupName: "Gruppe {n}", colPlayed: "Sp", colWon: "S", colDrawn: "U", colLost: "N", colDiff: "Diff.", colPoints: "Pkt",
     playIn: "Play-in", playInWinner: "Sieger {a}/{b}", playInLoser: "Verlierer {a}/{b}", seedSlot: "Platz {n}", winnerOf: "Sieger von {name}", loserOf: "Verlierer von {name}",
+    judoIppon: "I", judoWazaAri: "W", judoYuko: "Y", judoIpponLong: "Ippon", judoWazaAriLong: "Waza-ari", judoYukoLong: "Yuko",
+    judoMethodIppon: "Ippon", judoMethodAwasete: "Waza-ari awasete Ippon", judoMethodScore: "Punktsieg", judoMethodHansoku: "Hansoku-make", judoMethodFusen: "Fusen-gachi", judoMethodKiken: "Kiken-gachi",
+    judoGolden: "GS", judoGoldenLong: "Golden Score", judoTime: "{t}", judoShidoOf: "{name}: {n} Shido", judoShidoShort: "Shido {a}–{b}",
+    judoRepechage: "Hoffnungsrunde", judoBronze: "Kampf um Bronze", judoRepechageBronze: "Hoffnungsrunde und Kämpfe um Bronze", judoWhite: "weiß", judoBlue: "blau",
+    judoWeightClass: "{sex} -{w} kg", judoWeightOver: "{sex} +{w} kg", judoMen: "Herren", judoWomen: "Damen",
+    judoOsaekomi: "Osaekomi", judoShido: "Shido", judoMat: "Matte {n}", judoContest: "Kampf {n}", judoCoach: "Trainer: {name}", judoBoardTitle: "Anzeigetafel eines Judokampfes",
 };
 /**
  * The round names, English name first. The football rounds are the terms of each language's Wikipedia article on the World Cup;

package/dist/matchup.js

@@ -1,3 +1,5 @@
+import { judoHasScore, judoOutcome } from "./judo-model.js";
+import { judoNotes, sideScoreLong } from "./judo-text.js";
 import { abbreviate } from "./text.js";
 import { fill } from "./locales.js";
 /** A bracket's teams: the list given, plus a team made from every id that a matchup names and the list does not. */
@@ -77,18 +79,31 @@ export function resolveMatchup(m, index, teams) {
     if (ids[0] !== null && ids[0] === ids[1])
         throw new Error(`taisen-brackets: matchup ${index} has ${JSON.stringify(ids[0])} on both sides`);
     const kind = kindOf(m);
-    const { result, winner: settled } = settle(m, kind);
-    let winner = settled;
+    let named;
     if (m.winner !== undefined) {
         if (m.winner === null)
-            winner = null;
+            named = null;
         else if (ids[0] === m.winner)
-            winner = 0;
+            named = 0;
         else if (ids[1] === m.winner)
-            winner = 1;
+            named = 1;
         else
             throw new Error(`taisen-brackets: matchup ${index}'s winner ${JSON.stringify(m.winner)} is not one of its sides`);
     }
+    let judo;
+    let result;
+    let winner;
+    if (m.judo) {
+        judo = judoOutcome(m.judo, named ?? null);
+        if (judo.winner !== null && named !== undefined && named !== null && named !== judo.winner)
+            throw new RangeError(`taisen-brackets: matchup ${index}'s judo scores make side ${judo.winner} the winner, but its winner is side ${named}`);
+        winner = judo.winner;
+        result = { kind: "game", score: judoHasScore(judo) || winner !== null ? judo.points : null, played: judoHasScore(judo) || winner !== null ? 1 : 0, bestOf: null, pens: null, extraTime: false, replays: 0, games: [judo.points], decided: winner !== null };
+    }
+    else
+        ({ result, winner } = settle(m, kind));
+    if (named !== undefined)
+        winner = named;
     const sides = ids.map((id) => (id === null ? null : teams.get(id) ?? null));
     return {
         index,
@@ -102,6 +117,8 @@ export function resolveMatchup(m, index, teams) {
         third: !!m.third,
         walkover: !!m.walkover,
         note: m.note ?? null,
+        ...(judo ? { judo } : {}),
+        ...(m.stage ? { stage: m.stage } : {}),
         ...(m.seeds ? { seeds: m.seeds } : {}),
         ...(m.home !== undefined ? { home: m.home } : {}),
     };
@@ -112,7 +129,16 @@ export const abbrOf = (team, v) => (team ? team.abbr ?? abbreviate(v.team(team))
 export function noteParts(tie, v) {
     const r = tie.result;
     const w = v.words;
-    const out = [];
+    const out = tie.judo ? judoNotes(tie, v, false) : [];
+    if (tie.stage === "repechage" || tie.stage === "bronze")
+        out.unshift(tie.stage === "repechage" ? w.judoRepechage : w.judoBronze);
+    if (tie.judo) {
+        if (tie.walkover)
+            out.push(w.walkover);
+        if (tie.note)
+            out.push(tie.note);
+        return out;
+    }
     if (r.kind === "series") {
         if (r.decided && r.played > 0)
             out.push(fill(w.inGames, { n: v.number(r.played) }));
@@ -139,7 +165,14 @@ export function noteParts(tie, v) {
 export function noteLong(tie, v) {
     const r = tie.result;
     const w = v.words;
-    const out = [];
+    const out = tie.judo ? judoNotes(tie, v, true) : [];
+    if (tie.judo) {
+        if (tie.walkover)
+            out.push(w.walkover);
+        if (tie.note)
+            out.push(tie.note);
+        return out;
+    }
     if (r.kind === "series") {
         if (r.decided && r.played > 0)
             out.push(fill(w.inGames, { n: v.number(r.played) }));
@@ -169,7 +202,7 @@ export function describeTie(tie, v) {
     const [a, b] = tie.sides;
     const r = tie.result;
     let text = r.score
-        ? fill(w.tieScore, { a: name(a), b: name(b), sa: v.number(r.score[0]), sb: v.number(r.score[1]) })
+        ? fill(w.tieScore, { a: name(a), b: name(b), sa: sideScoreLong(tie, 0, v), sb: sideScoreLong(tie, 1, v) })
         : fill(w.tieVs, { a: name(a), b: name(b) });
     const notes = noteLong(tie, v);
     if (notes.length)

package/dist/playin.js

@@ -1,5 +1,6 @@
 import { fill } from "./locales.js";
 import { abbrOf, describeTie } from "./matchup.js";
+import { sideScore } from "./judo-text.js";
 import { drawMark } from "./marks.js";
 import { bold, headTile, headingTexts, titleHeight } from "./furniture.js";
 import { esc, fit, num } from "./text.js";
@@ -147,7 +148,7 @@ export function drawPlayIn(layout, o, v, size, ctx, road, linked) {
                 const team = t.sides[k];
                 const ry = rect.y + k * rowH;
                 const cy = ry + rowH / 2;
-                const score = o.scores !== false && t.result.score ? v.number(t.result.score[k]) : "";
+                const score = o.scores !== false ? sideScore(t, k, v) : "";
                 const cls = t.winner === null ? "tb-pending" : t.winner === k ? "tb-won" : "tb-lost";
                 const items = [];
                 const slotX = rect.x + rect.w - 5 - 26;