@johnmorrisdotca/taisen-brackets 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to this project are written here. The format follows
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-10-20
+
+Judo, step 1: results in the bracket boxes, and the bracket of a weight category with the repechage and two bronze medals. Nothing changes for a bracket that has no judo result (every existing snapshot is unchanged).
+
+### Added
+
+- **`Matchup.judo`**: a judo contest's result, `{ sides: [white, blue], method?, hansokuMake?, goldenScore?, time? }`, each side `{ ippon, wazaAri, yuko, shido }`. The winner, the method and the score come from it under the IJF Sport and Organisation Rules, Refereeing Rules of 21 January 2026: ippon, two waza-ari are ippon (Article 16), yuko are counted and never add up to a waza-ari (Article 15; yuko is back since 2025, 5 to 9 seconds of osaekomi, Article 7), shido never decide a contest and the third is hansoku-make (Article 18), a direct hansoku-make (`hansokuMake`), golden score (Article 13), fusen-gachi and kiken-gachi (Article 19, the matchup names the `winner`). `Tie.result.score` is the scoreboard's 100, 10 and 1. [docs/judo.md](docs/judo.md) quotes each rule.
+- **`judoOutcome(result, winner?)`** checks a result and works out the winner, the method, the scoreboard points and whether both sides were disqualified; a count out of range, two ippon, a method or winner the scores contradict, and a default with no winner are a `RangeError` that names the field. `judoSeconds`, `judoClock`.
+- **The boxes**: the score in marks (`I`, `W`, `W2`, `Y`, `Y3`, `0`), a white or blue bar at the edge of each row, the shido as yellow and red cards beside the score, and under the rows how it was won, `GS` for golden score and the time. The tooltip, the description and `bracketTable` say the same in a sentence, with each side's shido. Works in the tree, `rows`, `shields`, `update`, `columns` and `series`, both looks, every size. CSS custom properties `--tb-judo-white`, `--tb-judo-blue`, `--tb-shido`, `--tb-hansoku`; `bracketStyle({ judo: true })`.
+- **`judoBracket(athletes, { system, prefix })`**: a weight category for any number of athletes, with the IJF's quarter-final repechage (Sport and Organisation Rules 2.5.2: two repechage contests, two bronze medal contests) for eight athletes or more, or a direct knockout whose losing semi-finalists are the bronze medallists. `Matchup.stage` takes `"repechage"` and `"bronze"` (fed by the losers of the tree's ties, drawn together under the tree with their own heading); `Tie.stage`. `judoPodium(input)` gives gold, silver and the bronze medallists; `judoCategoryLabel({ sex, weight }, locale)` the heading ("Men -66 kg"); `JUDO_WEIGHT_CLASSES`.
+- Words for judo in the five languages (the marks, the methods, golden score, the shido, the headings, the weight class). The French and Japanese were read by native-language reviewers; the Spanish and German need one (docs/languages.md).
+- The demo has a Judo sport: a made-up men's -66 kg category of 16 athletes with every kind of ending, in the tree and in rows, with Hata's flags (Georgia, Uzbekistan, Cuba, Mongolia, Azerbaijan, Hungary, Italy added).
+
+### Changed
+
+- The note under a box is cut to fit with the same width estimate the names use, so that a long note never reaches past its box.
+- The ties kept apart under the tree are 66 high in the road look when one of them has a note.
+
 ## [0.6.1] - 2026-10-19
 
 No change to the package's code. The README's pictures were checked against 0.6.0's features and remade: they already show every layout, so none is added.

package/NOTICE.md

@@ -22,9 +22,11 @@ The code of this package is under the MIT licence (see [LICENSE](LICENSE)). The
 | The demo's trophies (`demo/emblems.js`, and the `dougu-sports/` files the Pages build copies beside the page) | [Dougu Sports](https://github.com/johnmorrisdotca/dougu-sports) 0.1.0, a development dependency and an optional peer: generic emblems drawn for that package, which carry no league's or federation's name or mark | MIT, same owner; its NOTICE is in the package |
 | The words of the languages (`src/locales.ts`) | The football terms (the rounds of the World Cup, extra time, the shoot-out, a replay, a walkover) were read on 2026-10-14 in the French, Spanish, German and Japanese Wikipedia articles on the World Cups of 2022, 2026 and 1938; the articles are cited in [docs/languages.md](docs/languages.md). The other words, including those of the road to the final, are written for this package; the French and Japanese were read by native-language reviewers, the Spanish and German were not | Wikipedia's text is CC BY-SA 4.0; only terms (single words and short phrases) are taken, no sentence or table, and the articles are credited in docs/languages.md |
 | The names of countries in each language | Not in the package: `countryName` asks `Intl.DisplayNames`, which holds Unicode CLDR's names; the demo passes it each team's ISO code. The home nations and the two states that no longer exist are written in `src/locales.ts` and `demo/data.js` | CLDR is under the Unicode licence (https://www.unicode.org/license.txt) |
+| The judo scoring (`src/judo-model.ts`, [docs/judo.md](docs/judo.md)) | The facts of the IJF Sport and Organisation Rules, Refereeing Rules, version 21 January 2026 (Articles 6, 7, 13 to 19), and of its competition systems (2.5, March 2023 version) and weight classes (2.2.1), as published by the International Judo Federation on ijf.org; and the IJF news items of 9 December 2016 and December 2024. Read on 2026-10-20. Only facts and a few short quotations, cited by article, are used; no text, drawing or mark of the IJF is copied | The rules are the IJF's; the package states what they say and names the article. No IJF mark is used |
+| The demo's made-up judo tournament (`demo/data/judo-sample.js`) | Made up: the 16 athletes and their results are invented, and the countries are only there for the flags (the same Hata flags as above, with Azerbaijan, Cuba, Georgia, Hungary, Italy, Mongolia and Uzbekistan added) | Not real |
 | The demo's page | Written for this package, with the family stylesheet `demo/family.css` | MIT |
 
-The flags in the demo are for the nations of the World Cups of 2022 and 2026: `AR AT AU BA BE BR CA CD CH CI CO CV DE DZ EC EG ES FR GB-ENG GH HR JP KR MA MX NL NO PL PT PY SE SN US ZA`. The package itself ships no flag, no logo and no data of the leagues.
+The flags in the demo are for the nations of the World Cups of 2022 and 2026 and of the made-up judo tournament: `AR AT AU AZ BA BE BR CA CD CH CI CO CU CV DE DZ EC EG ES FR GB-ENG GE GH HR HU IT JP KR MA MN MX NL NO PL PT PY SE SN US UZ ZA`. The package itself ships no flag, no logo and no data of the leagues.
 
 No code, text or picture was taken from the bracket libraries compared in [docs/compare.md](docs/compare.md); that page records what each says of itself.
 

package/README.md

@@ -11,7 +11,7 @@ Give it the games, series, two-legged ties or replays of a tournament and it wor
   <img alt="TypeScript" src="https://img.shields.io/badge/types-TypeScript-3178c6">
 </p>
 
-<p align="center"><a href="https://johnmorrisdotca.github.io/taisen-brackets/"><strong>Open the demo →</strong></a> · <a href="./docs/layout.md">Layout</a> · <a href="./docs/layouts.md">Layouts</a> · <a href="./docs/drawing.md">Drawing</a> · <a href="./docs/road.md">Road to the final</a> · <a href="./docs/backgrounds.md">Backgrounds</a> · <a href="./docs/formats.md">Formats</a> · <a href="./docs/compare.md">How it compares</a></p>
+<p align="center"><a href="https://johnmorrisdotca.github.io/taisen-brackets/"><strong>Open the demo →</strong></a> · <a href="./docs/layout.md">Layout</a> · <a href="./docs/layouts.md">Layouts</a> · <a href="./docs/drawing.md">Drawing</a> · <a href="./docs/road.md">Road to the final</a> · <a href="./docs/backgrounds.md">Backgrounds</a> · <a href="./docs/judo.md">Judo</a> · <a href="./docs/formats.md">Formats</a> · <a href="./docs/compare.md">How it compares</a></p>
 
 <p align="center">
 <picture>
@@ -238,6 +238,15 @@ console.log(ice.includes("tb-bgd"), mine.includes("#ff7ac8"), photo.includes('<i
 
 In the road look, `seeds: true` writes a small tag (`P1`, `WC2`) beside each team's mark, `codes: true` its three letters under the mark in a box of marks, `vs: true` a "v" between the two marks, and a team with no flag or logo is a tile with its letters. [docs/backgrounds.md](./docs/backgrounds.md) has the options, the contrast rules and the module the other packages of the family share.
 
+## Judo
+
+A judo contest is a tie with a `judo` result: ippon, waza-ari, yuko and shido as the IJF's current Sport and Organisation Rules score them (yuko is back since 2025), golden score, the contest time and how it was won. The box writes the marks (`I`, `W`, `Y`), the shido as yellow and red cards and a note under the two rows, in the five languages. `judoBracket` makes a weight category's bracket with the IJF's repechage and its two bronze medal contests. [docs/judo.md](./docs/judo.md) quotes the rules it follows.
+
+<p align="center"><picture>
+<source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/johnmorrisdotca/taisen-brackets/main/docs/images/judo-desk-dark.webp">
+<img alt="A made-up men's minus 66 kilogram judo tournament of 16 athletes with round flags, score marks, shido cards, how each contest was won and its time, and the repechage and bronze medal contests under the tree." src="https://raw.githubusercontent.com/johnmorrisdotca/taisen-brackets/main/docs/images/judo-desk-light.webp" width="720">
+</picture><br><em>Men's -66 kg, with the quarter-final repechage (invented names).</em></p>
+
 ## In 30 seconds
 
 ```sh
@@ -283,6 +292,7 @@ Put the string in a page (`element.innerHTML = svg`), write it to a file, or sen
 - **Team marks you supply**: a logo address or inline SVG, drawn round or square; a team with none is its initials on a colour. Round flags from [Hata](https://github.com/johnmorrisdotca/hata) go in as they are.
 - **The champion in the centre**, with a slot for your trophy: your own SVG or image, or an emblem from [Dougu Sports](https://github.com/johnmorrisdotca/dougu-sports) (a hockey cup, a basketball trophy, a globe) through an optional plug-in, with no dependency added.
 - **Accessible**: `role="img"` with a title and a description, a tooltip sentence on every tie, and `bracketTable`.
+- **Judo scoring**: `Matchup.judo` takes ippon, waza-ari, yuko, shido, hansoku-make, golden score and the contest time, checked against the IJF rules (`judoOutcome`); a box shows the marks, the shido cards and how the contest was won, and `judoBracket` adds the repechage and the two bronze medal contests ([docs/judo.md](./docs/judo.md)).
 - **Formats by era**: NHL, NBA, MLB, NFL, CFL, MLS and FIFA World Cup round names, series lengths and byes.
 - **Five languages**: English, French, Japanese, Spanish and German, for every word the drawing, the tooltips, the description and the table write, with the football terms of each language; countries named by `Intl` from their ISO code; numbers and dates by `Intl`. Add a language of your own.
 - **Deterministic**: no clock, no random number, no counter; the same input gives the same string, and ids come from a hash of the input.
@@ -642,6 +652,7 @@ Everything is exported from `@johnmorrisdotca/taisen-brackets`; the layout part
 - `singleElimination(teams, options?)`, `advanceWinners(matchups)`, `standardSeeds(size)`: brackets for any number of teams.
 - `matchupsFromGames(games, options)`: matchups from a flat list of games.
 - `resolveMatchup`, `collectTeams`, `describeTie`, `noteParts`, `noteLong`: one tie's result, the teams of a bracket, a tie in a sentence.
+- `judoOutcome(result, winner?)`, `judoBracket(athletes, options?)`, `judoPodium(input)`, `judoCategoryLabel(category, locale?)`, `JUDO_WEIGHT_CLASSES`, `judoSeconds(time)`, `judoClock(seconds)`: judo results checked against the IJF rules, the bracket with its repechage and two bronze medal contests, the medallists, a weight category as a heading ([docs/judo.md](./docs/judo.md)). `Matchup.judo` and `Matchup.stage` (`"repechage"`, `"bronze"`) carry them into `drawBracket`.
 - `playoffFormat(league, year)`, `playoffEras(league)`, `LEAGUES`: the formats by era (`nhl`, `nba`, `mlb`, `nfl`, `cfl`, `mls`, `worldcup`). `LEAGUE_EMBLEMS`: each league's default emblem id.
 - `isEmblemId(value)`, and the types `EmblemRenderer`, `EmblemRequest`, `EmblemStyle`: the trophy emblems (see "Emblems for the trophy").
 - `roundName(remaining)`, `roundNamesFor(count)`, `roundLabel(layout, round, names, words)`: round names.
@@ -700,6 +711,7 @@ console.log(svg.includes('lang="nl"')); // true
 | CFL | 1996 on | Division Semi-Final, Division Final, Grey Cup |
 | MLS | 2023 on | Wild Card Round, Round One (best of three), Conference Semifinals, Conference Finals, MLS Cup |
 | FIFA World Cup | every edition with a knockout, 1930 to 2026 (1950 had none) | Round of 32 (2026), Round of 16, Quarter-finals, Semi-finals, Final |
+| Judo (IJF rules of 21 January 2026) | any weight category: `judoBracket` with the quarter-final repechage or a direct knockout | Round of N … Final, repechage, two bronze medal contests |
 | Any other | single elimination for any number of teams | Round of N … Final |
 
 Each era was checked against English Wikipedia (facts only; the articles are cited in [docs/formats.md](./docs/formats.md)). The year is the year the playoffs are played in, except for the NFL, whose year is its season's, so 2024 is the season whose playoffs were played in January and February 2025. A season did something of its own (a strike, a pandemic) has its own entry, and a later one is not covered until it is checked.
@@ -732,6 +744,7 @@ Any current browser, and Node 22 or later. The package makes no network request
 
 ## Roadmap
 
+- Judo: a contest scoreboard drawing, a contest card and a mat queue board, the road to the final of a judoka, double and full repechage ([docs/judo.md](./docs/judo.md)).
 - Double elimination, and the group tables on one page with the knockout they lead to.
 - More languages (Portuguese, Italian, Korean, Chinese), and native review of the Spanish and German words.
 - A custom element and a React helper, as in the other packages of the family.

package/dist/index.d.ts

@@ -17,3 +17,5 @@ export type { ResolvedBackground } from "./background.ts";
 export { VERSION } from "./version.ts";
 export { playoffFormat, playoffEras, LEAGUES, LEAGUE_EMBLEMS } from "./presets.ts";
 export type { League, PlayoffFormat, PlayoffRound } from "./presets.ts";
+export { judoBracket, judoPodium, judoCategoryLabel, judoOutcome, judoSeconds, judoClock, JUDO_WEIGHT_CLASSES } from "./judo.ts";
+export type { JudoBracketOptions, JudoCategory, JudoMethod, JudoOutcome, JudoPodium, JudoResult, JudoSide, JudoSystem } from "./judo.ts";

package/dist/index.js

@@ -10,3 +10,4 @@ export { BACKGROUND_PRESETS, FAMILY_BACKGROUNDS_VERSION, backgroundSvg, contrast
 export { resolveBackground } from "./background.js";
 export { VERSION } from "./version.js";
 export { playoffFormat, playoffEras, LEAGUES, LEAGUE_EMBLEMS } from "./presets.js";
+export { judoBracket, judoPodium, judoCategoryLabel, judoOutcome, judoSeconds, judoClock, JUDO_WEIGHT_CLASSES } from "./judo.js";

package/dist/judo-model.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Judo results: the scores of one contest and what they come to under the IJF Sport and Organisation Rules (Refereeing Rules, version
+ * 21 January 2026, for the Olympic cycle to Los Angeles 2028). Pure and sport-specific; nothing here draws. The rules this follows, by
+ * article, are in docs/judo.md.
+ *
+ * - Article 7 and 15: osaekomi of 20 seconds is ippon, 10 to 19 seconds waza-ari, 5 to 9 seconds yuko.
+ * - Article 15: "Yuko scores are counted (1, 2, 3, etc.) but they do not add up to waza-ari."
+ * - Article 16: a second waza-ari is waza-ari-awasete-ippon, ippon.
+ * - Article 18: "Two shido can be awarded and the third will be hansoku-make"; "A contest cannot be decided by single or accumulated shido, until hansoku-make is reached."
+ * - Article 13: a level contest at the end of regular time (4 minutes) goes to golden score, which has no time limit and ends at the first score or hansoku-make.
+ */
+/** How a contest was won. `"score"` is a decision on the technical scores (the waza-ari, then the yuko, counted). */
+export type JudoMethod = "ippon" | "waza-ari-awasete-ippon" | "score" | "hansoku-make" | "fusen-gachi" | "kiken-gachi";
+/** What one side scored in a contest. Anything left out is none. */
+export interface JudoSide {
+    /** Ippon: the contest ends. */
+    ippon?: boolean;
+    /** Waza-ari, 0 to 2; a second one is waza-ari-awasete-ippon. */
+    wazaAri?: number;
+    /** Yuko: counted, never added up to a waza-ari. */
+    yuko?: number;
+    /** Shido (the penalties), 0 to 3; the third is hansoku-make (indirect). */
+    shido?: number;
+}
+/** The result of one judo contest, the sides in the order of the matchup's `sides`: the first is white, the second blue. */
+export interface JudoResult {
+    sides: readonly [JudoSide, JudoSide];
+    /** How it was won. Left out, it is worked out from the scores; fusen-gachi and kiken-gachi (no score can say so) need the matchup's `winner`. */
+    method?: JudoMethod;
+    /** The side (0 or 1) that was given a direct hansoku-make (a grave infringement): the other side wins by ippon. */
+    hansokuMake?: 0 | 1;
+    /** The contest went on to golden score, and the scores are the ones at its end. */
+    goldenScore?: boolean;
+    /** The contest time: seconds (`222`) or `"3:42"`. Regular time is 4 minutes; golden score runs past it. */
+    time?: number | string;
+}
+/** A result checked and worked out. */
+export interface JudoOutcome {
+    /** 0 or 1, the side that won; `null` while nothing has decided it (level scores: golden score is next). */
+    winner: 0 | 1 | null;
+    /** How it was won, or `null` while undecided. */
+    method: JudoMethod | null;
+    goldenScore: boolean;
+    /** The contest time in seconds, or `null`. */
+    seconds: number | null;
+    /** The two sides with every count filled in. */
+    sides: readonly [Required<JudoSide>, Required<JudoSide>];
+    /** The value on the scoreboard (Articles 4 and 15: ippon 100, waza-ari 10, yuko 1; two waza-ari are ippon). */
+    points: readonly [number, number];
+    /** Both sides were given the third shido: the contest is recorded 0-0 and nobody wins (Article 18.3.1). */
+    doubleHansokuMake: boolean;
+}
+/** The IJF's senior weight classes in kilograms, the lightest first: a number is "up to and including", a text starting `+` is "over". */
+export declare const JUDO_WEIGHT_CLASSES: Readonly<Record<"men" | "women", readonly string[]>>;
+/** A time as seconds: a number, or `"m:ss"`. */
+export declare function judoSeconds(time: number | string | undefined): number | null;
+/** Seconds as `m:ss`. */
+export declare const judoClock: (seconds: number) => string;
+/**
+ * Checks a result against the rules and works out who won and how. `winner` is the winner the matchup names (needed for fusen-gachi and
+ * kiken-gachi, which no score can show). Throws a `RangeError` for a count out of range, two ippon, a method the scores contradict, or a
+ * default with no winner.
+ */
+export declare function judoOutcome(result: JudoResult, winner?: 0 | 1 | null): JudoOutcome;
+/** Whether a result has any score or penalty at all (a contest still to be fought has none). */
+export declare const judoHasScore: (o: JudoOutcome) => boolean;

package/dist/judo-model.js

@@ -0,0 +1,102 @@
+/**
+ * Judo results: the scores of one contest and what they come to under the IJF Sport and Organisation Rules (Refereeing Rules, version
+ * 21 January 2026, for the Olympic cycle to Los Angeles 2028). Pure and sport-specific; nothing here draws. The rules this follows, by
+ * article, are in docs/judo.md.
+ *
+ * - Article 7 and 15: osaekomi of 20 seconds is ippon, 10 to 19 seconds waza-ari, 5 to 9 seconds yuko.
+ * - Article 15: "Yuko scores are counted (1, 2, 3, etc.) but they do not add up to waza-ari."
+ * - Article 16: a second waza-ari is waza-ari-awasete-ippon, ippon.
+ * - Article 18: "Two shido can be awarded and the third will be hansoku-make"; "A contest cannot be decided by single or accumulated shido, until hansoku-make is reached."
+ * - Article 13: a level contest at the end of regular time (4 minutes) goes to golden score, which has no time limit and ends at the first score or hansoku-make.
+ */
+/** The IJF's senior weight classes in kilograms, the lightest first: a number is "up to and including", a text starting `+` is "over". */
+export const JUDO_WEIGHT_CLASSES = Object.freeze({
+    men: Object.freeze(["-60", "-66", "-73", "-81", "-90", "-100", "+100"]),
+    women: Object.freeze(["-48", "-52", "-57", "-63", "-70", "-78", "+78"]),
+});
+const whole = (what, n, max) => {
+    const v = n === undefined ? 0 : n;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < 0 || v > max)
+        throw new RangeError(`taisen-brackets: ${what} is a whole number from 0 to ${max}, not ${JSON.stringify(v)}`);
+    return v;
+};
+function filled(side, k) {
+    const who = k === 0 ? "the white side's" : "the blue side's";
+    return {
+        ippon: side.ippon === true,
+        wazaAri: whole(`${who} waza-ari`, side.wazaAri, 2),
+        yuko: whole(`${who} yuko`, side.yuko, 99),
+        shido: whole(`${who} shido`, side.shido, 3),
+    };
+}
+/** A time as seconds: a number, or `"m:ss"`. */
+export function judoSeconds(time) {
+    if (time === undefined)
+        return null;
+    if (typeof time === "number") {
+        if (!Number.isFinite(time) || time < 0)
+            throw new RangeError(`taisen-brackets: a judo contest time is seconds from 0, not ${time}`);
+        return Math.round(time);
+    }
+    const m = /^(\d{1,3}):([0-5]\d)$/.exec(time.trim());
+    if (!m)
+        throw new RangeError(`taisen-brackets: a judo contest time is seconds or "m:ss" ("3:42"), not ${JSON.stringify(time)}`);
+    return Number(m[1]) * 60 + Number(m[2]);
+}
+/** Seconds as `m:ss`. */
+export const judoClock = (seconds) => `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
+const scoreboard = (s) => (s.ippon || s.wazaAri >= 2 ? 100 : s.wazaAri * 10 + s.yuko);
+/**
+ * Checks a result against the rules and works out who won and how. `winner` is the winner the matchup names (needed for fusen-gachi and
+ * kiken-gachi, which no score can show). Throws a `RangeError` for a count out of range, two ippon, a method the scores contradict, or a
+ * default with no winner.
+ */
+export function judoOutcome(result, winner = null) {
+    const sides = [filled(result.sides[0], 0), filled(result.sides[1], 1)];
+    const seconds = judoSeconds(result.time);
+    const points = [scoreboard(sides[0]), scoreboard(sides[1])];
+    const golden = result.goldenScore === true;
+    const out = (w, method, double = false) => ({ winner: w, method, goldenScore: golden, seconds, sides, points, doubleHansokuMake: double });
+    const other = (k) => (k === 0 ? 1 : 0);
+    if (sides[0].ippon && sides[1].ippon)
+        throw new RangeError("taisen-brackets: both sides of a judo contest cannot score ippon");
+    if (sides[0].wazaAri === 2 && sides[1].wazaAri === 2)
+        throw new RangeError("taisen-brackets: both sides of a judo contest cannot score waza-ari-awasete-ippon");
+    const given = result.method;
+    const agree = (derived) => {
+        if (given !== undefined && derived.method !== given)
+            throw new RangeError(`taisen-brackets: the judo method ${JSON.stringify(given)} does not fit the scores, which make ${JSON.stringify(derived.method)}`);
+        return derived;
+    };
+    if (given === "fusen-gachi" || given === "kiken-gachi") {
+        if (winner === null)
+            throw new RangeError(`taisen-brackets: a judo contest won by ${given} needs the matchup's winner`);
+        return out(winner, given);
+    }
+    if (result.hansokuMake !== undefined) {
+        if (result.hansokuMake !== 0 && result.hansokuMake !== 1)
+            throw new RangeError("taisen-brackets: hansokuMake is 0 or 1, the side that was penalised");
+        return agree(out(other(result.hansokuMake), "hansoku-make"));
+    }
+    if (sides[0].shido >= 3 && sides[1].shido >= 3)
+        return agree(out(null, "hansoku-make", true));
+    for (const k of [0, 1])
+        if (sides[k].shido >= 3)
+            return agree(out(other(k), "hansoku-make"));
+    for (const k of [0, 1]) {
+        if (sides[k].ippon)
+            return agree(out(k, "ippon"));
+        if (sides[k].wazaAri >= 2)
+            return agree(out(k, "waza-ari-awasete-ippon"));
+    }
+    const by = (a, b) => (a > b ? 0 : b > a ? 1 : null);
+    const decided = by(sides[0].wazaAri, sides[1].wazaAri) ?? by(sides[0].yuko, sides[1].yuko);
+    if (decided !== null)
+        return agree(out(decided, "score"));
+    if (given !== undefined)
+        throw new RangeError(`taisen-brackets: the judo method ${JSON.stringify(given)} does not fit scores that are level`);
+    // Level: nothing has decided it, though the matchup may name a winner (a contest recorded with no scores).
+    return out(null, null);
+}
+/** Whether a result has any score or penalty at all (a contest still to be fought has none). */
+export const judoHasScore = (o) => o.sides.some((s) => s.ippon || s.wazaAri > 0 || s.yuko > 0 || s.shido > 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,11 @@ 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",
 };
 const FR = {
     tbd: "À déterminer", bye: "exempt", walkover: "forfait", champion: "Champion", thirdPlace: "Match pour la troisième place", other: "Autres rencontres",
@@ -38,6 +43,11 @@ 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",
 };
 const JA = {
     tbd: "未定", bye: "シード", walkover: "不戦勝", champion: "優勝", thirdPlace: "3位決定戦", other: "その他の対戦",
@@ -55,6 +65,11 @@ 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: "女子",
 };
 const ES = {
     tbd: "Por definir", bye: "exento", walkover: "incomparecencia", champion: "Campeón", thirdPlace: "Partido por el tercer puesto", other: "Otros partidos",
@@ -72,6 +87,11 @@ 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",
 };
 const DE = {
     tbd: "offen", bye: "Freilos", walkover: "kampflos", champion: "Turniersieger", thirdPlace: "Spiel um Platz 3", other: "Weitere Begegnungen",
@@ -89,6 +109,11 @@ 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",
 };
 /**
  * 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;

package/dist/render.js

@@ -1,5 +1,6 @@
 import { layoutBracket } from "./layout.js";
 import { abbrOf, describeTie, noteParts } from "./matchup.js";
+import { shidoCards, sideScore } from "./judo-text.js";
 import { cleanSvg, drawEmblem, drawMark, hasTrophy as hasTrophyOf, isEmblemId, markDefs, safeHref, safeUrl } from "./marks.js";
 import { roundLabel } from "./rounds.js";
 import { styleFor } from "./theme.js";
@@ -115,7 +116,7 @@ export function drawBracket(input, options = {}) {
     const orientation = options.orientation && options.orientation !== "auto" ? options.orientation : kind === "series" || sizeName === "phone" || sizeName === "card" || (size.height !== null && size.width < size.height * 0.8) ? "vertical" : "horizontal";
     const road = options.look === "road";
     const hasBg = typeof options.background === "string" || (typeof options.background === "object" && options.background !== null);
-    const prefix = options.id ?? `tb-${hash(JSON.stringify([v.locale.code, layout.teams.map((t) => t.name), layout.ties.map((t) => [t.id, t.sides.map((s) => s?.id ?? null), t.winner, t.result.score, t.round]), options.size, orientation, options.detail, theme, options.title, options.subtitle, options.seeds, options.scores, options.champion, options.markShape, options.roundLabels, options.thirdPlace, options.trophy ? 1 : 0, road ? 1 : 0, options.highlightPath ?? null, options.flags ? 1 : 0, ...(hasBg ? [options.background, options.vs, options.codes, options.seeds] : []), ...(options.flagHref ? ["h"] : []), ...(kind !== "tree" ? [kind, options.at, options.standings, options.qualify] : []), ...(options.headers ? ["head"] : [])]))}`;
+    const prefix = options.id ?? `tb-${hash(JSON.stringify([v.locale.code, layout.teams.map((t) => t.name), layout.ties.map((t) => [t.id, t.sides.map((s) => s?.id ?? null), t.winner, t.result.score, t.round, ...(t.judo ? [t.judo.method, t.judo.goldenScore, t.judo.seconds, t.judo.sides] : [])]), options.size, orientation, options.detail, theme, options.title, options.subtitle, options.seeds, options.scores, options.champion, options.markShape, options.roundLabels, options.thirdPlace, options.trophy ? 1 : 0, road ? 1 : 0, options.highlightPath ?? null, options.flags ? 1 : 0, ...(hasBg ? [options.background, options.vs, options.codes, options.seeds] : []), ...(options.flagHref ? ["h"] : []), ...(kind !== "tree" ? [kind, options.at, options.standings, options.qualify] : []), ...(options.headers ? ["head"] : [])]))}`;
     const ctx = { radii: new Set(), symbols: new Map(), prefix, shape: options.markShape ?? "round", look: road ? "road" : "classic", flags: options.flags, flagHref: options.flagHref, theme: theme === "light" ? "light" : theme === "dark" || theme === "poster" ? "dark" : "inherit", flagCache: new Map(), defs: new Map() };
     const path = pathOf(layout, options.highlightPath);
     const linked = { count: 0 };
@@ -124,10 +125,10 @@ export function drawBracket(input, options = {}) {
     // The group tables and the play-in are not the tree: they plan and draw their own parts, and share the frame (the style, the background, the title) with it.
     const own = kind === "groups" ? drawGroups(layout, options, v, size, ctx, road, linked) : kind === "playin" ? drawPlayIn(layout, options, v, size, ctx, road, linked) : null;
     if (own)
-        return frame({ prefix, v, options, theme, road, kind, title, desc: own.desc ?? desc, width: own.width, height: own.height, followed: false, links: [], parts: [...own.body, ...own.texts], linkCount: linked.count, ctx });
+        return frame({ prefix, v, options, theme, road, kind, title, desc: own.desc ?? desc, width: own.width, height: own.height, followed: false, links: [], parts: [...own.body, ...own.texts], linkCount: linked.count, ctx, judo: layout.ties.some((t) => t.judo !== undefined) });
     const plan = planBracket(layout, options, v, size, orientation === "vertical", ctx, road, path, kind);
     const drawn = plan.boxes.map((b) => drawBox(b, plan, options, v, ctx, linked, layout.place[b.tie.index])); // draws the marks, so before the defs are written
-    return frame({ prefix, v, options, theme, road, kind, title, desc, width: plan.width, height: plan.height, followed: path.size > 0, links: plan.links, parts: [...drawn, ...plan.texts, ...plan.extras], linkCount: linked.count, ctx });
+    return frame({ prefix, v, options, theme, road, kind, title, desc, width: plan.width, height: plan.height, followed: path.size > 0, links: plan.links, parts: [...drawn, ...plan.texts, ...plan.extras], linkCount: linked.count, ctx, judo: layout.ties.some((t) => t.judo !== undefined) });
 }
 /** The drawing's frame: the root `<svg>` with its title, its style, the defs the marks wrote and the background, round the parts a layout drew. */
 function frame(f) {
@@ -135,7 +136,7 @@ function frame(f) {
     const picture = resolveBackground(options.background, theme, f.width, f.height, prefix);
     const defs = markDefs(ctx) + (picture?.defs ?? "");
     const scope = scopeOf(options, prefix);
-    const style = theme === "none" || options.style === false ? "" : `<style>${styleFor(`.${scope}`, theme, { road, links: f.linkCount > 0, follow: f.followed, bgAuto: picture?.auto, layout: f.kind !== "tree" || options.headers === true }, picture?.inks)}</style>`;
+    const style = theme === "none" || options.style === false ? "" : `<style>${styleFor(`.${scope}`, theme, { road, links: f.linkCount > 0, follow: f.followed, bgAuto: picture?.auto, layout: f.kind !== "tree" || options.headers === true, judo: f.judo }, picture?.inks)}</style>`;
     const bg = options.background === false ? "" : `<rect class="tb-bg" width="${num(f.width)}" height="${num(f.height)}"${theme === "none" ? ' fill="none"' : ""}/>${picture?.body ?? ""}`;
     return [
         `<svg xmlns="http://www.w3.org/2000/svg" lang="${esc(v.locale.code)}" class="taisen ${prefix}${scope !== prefix ? ` ${scope}` : ""}${road ? " tb-look-road" : ""}${f.followed ? " tb-follow" : ""}${options.className ? ` ${esc(options.className)}` : ""}" viewBox="0 0 ${num(f.width)} ${num(f.height)}" width="${num(f.width)}" height="${num(f.height)}" style="max-width:100%;height:auto" role="img" aria-labelledby="${prefix}-t ${prefix}-d">`,
@@ -168,7 +169,7 @@ export function bracketStyle(options) {
     if (theme === "none")
         return "";
     const picture = resolveBackground(options.background, theme, 100, 100, "x");
-    return styleFor(`.${scope}`, theme, { road: options.look === "road", links: typeof options.href === "function", follow: options.highlightPath !== undefined, bgAuto: picture?.auto, layout: (options.layout ?? "tree") !== "tree" || options.headers === true }, picture?.inks);
+    return styleFor(`.${scope}`, theme, { road: options.look === "road", links: typeof options.href === "function", follow: options.highlightPath !== undefined, bgAuto: picture?.auto, layout: (options.layout ?? "tree") !== "tree" || options.headers === true, judo: options.judo === true }, picture?.inks);
 }
 /** The groups' names with the east first, for the series card: the names the teams carry, ordered so that a name with "east" comes before one with "west". */
 function eastFirst(input) {
@@ -181,6 +182,8 @@ function eastFirst(input) {
 }
 // ---------------------------------------------------------------------------------------------- the plan
 function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
+    // The ties kept apart below the tree are a little taller in the road look when any of them has a note to write (a judo contest's method and time), so that the note has its line.
+    const OH = road && [...layout.other, ...layout.robin, ...layout.playIn].some((i) => noteParts(layout.ties[i], v).length > 0) ? 66 : OTHER_H;
     // The layouts that draw each tie their own way take the tree's places and lines, and fill the boxes themselves.
     const V = VARIANTS.includes(kind) ? kind : null;
     const pad = vertical ? 14 : 22;
@@ -238,7 +241,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
         const top = pad + titleH + (hasGroups ? groupRoom : 0) + labelRoom;
         others = othersOf(layout);
         ow = clamp(D * 1.1, 120, 200);
-        extraH0 = othersHeight(others.length, W0, pad, ow, OTHER_H) + thirdBlock;
+        extraH0 = othersHeight(others.length, W0, pad, ow, OH) + thirdBlock;
         const bodyH = size.height === null ? rows * 60 : size.height - top - pad - extraH0;
         rowStep = bodyH / rows;
         S = clamp(rowStep - (road ? 7 : 9), 24, road ? 132 : 104);
@@ -264,6 +267,8 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
     const tagW = tagsOn ? Math.max(...layout.ties.flatMap((t) => [tagOf(t, 0), tagOf(t, 1)]).map((x) => boldWidth(x, 8))) + 8 : 0;
     // The road look's marks and scores are large: they are scaled down together until a row fits its box, before a name is dropped for its abbreviation.
     const anyNotes = layout.ties.some((t) => noteParts(t, v).length > 0);
+    // The widest score a row may carry: two digits, or a judo contest's marks ("W2 Y3").
+    const probe = layout.ties.reduce((best, t) => [0, 1].reduce((b, k) => { const x = sideScore(t, k, v); return wide(x, 10) > wide(b, 10) ? x : b; }, best), "00");
     // The road look's boxes of marks alone carry each score under its mark, unless marks alone were asked for.
     const markScores = road && o.detail !== "mark" && (o.scores ?? true) && layout.ties.some((t) => t.result.score !== null);
     const fitOf = (w, h, named) => {
@@ -273,7 +278,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
         const anyPens = layout.ties.some((t) => t.result.pens !== null);
         const extra = (anyBye ? wide(v.words.bye, Math.max(font - 2, 8)) + 8 : 0) + (anyPens ? wide("(00)", Math.max(score * 0.55, 8)) + 5 : 0);
         const fixed = clamp(rowH * 0.16, 5, 12) + clamp(rowH * 0.18, 5, 10) + 8 + 10 + (tagW > 0 ? tagW + 3 : 0);
-        const varying = md + (named === "full" ? longest : longestAbbr) * (font / 13) + wide("00", score) + extra;
+        const varying = md + (named === "full" ? longest : longestAbbr) * (font / 13) + wide(probe, score) + extra;
         return Math.min(1, (w - fixed) / varying);
     };
     let fitNow = 1;
@@ -284,7 +289,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
         const anyBye = layout.sides.some((sd) => sd.boxes.some((b) => b.byes.length > 0));
         const anyPens = layout.ties.some((t) => t.result.pens !== null);
         const extra = (anyBye ? boldWidth(v.words.bye, Math.max(font - 2, 8)) + 8 : 0) + (anyPens ? boldWidth("(00)", Math.max(font - 2, 8)) + 3 : 0);
-        const needed = 6 + md + 5 + longest * (font / 13) + 8 + boldWidth("00", score) + extra + 14;
+        const needed = 6 + md + 5 + longest * (font / 13) + 8 + boldWidth(probe, score) + extra + 14;
         const named = o.detail && o.detail !== "auto" ? o.detail : w >= needed && h >= 36 ? "full" : w >= 76 && h >= 28 ? "compact" : "mark";
         return named === "mark" && o.markShape === "none" ? "compact" : named;
     };
@@ -389,7 +394,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
             dl = pick(wl, hl);
         const strays = othersOf(layout);
         const ows = Math.min(availW, 200);
-        const strayH = othersHeight(strays.length, W0, pad, ows, OTHER_H);
+        const strayH = othersHeight(strays.length, W0, pad, ows, OH);
         const labelH = showLabels ? 22 : 8;
         const content = (champ ? champH + 14 : 0) + labelH + hl + (withThird ? 8 + 18 + hl + 8 : 0) + strayH;
         const top0 = pad + titleH;
@@ -410,7 +415,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
             y += 8 + 18 + hl + 8;
         }
         if (strays.length > 0)
-            othersBlock(layout, strays, y + 6, W0, pad, ows, OTHER_H, v, road, boxes, texts);
+            othersBlock(layout, strays, y + 6, W0, pad, ows, OH, v, road, boxes, texts);
         texts.push(...headings(v, o, W0, pad, poster));
         return finish({ width: W0, height, boxes, links: [], texts, extras, detail: dl, vertical, road, path, fit: fitNow, notes: anyNotes, markScores, markCols, tags: tagsOn, codes: codesOn, variant: V, em: { full: longest / 13, abbr: longestAbbr / 13, tag: tagsOn ? Math.max(...layout.ties.flatMap((t) => [tagOf(t, 0), tagOf(t, 1)]).map((x) => boldWidth(x, 1))) : 0 } });
     }
@@ -518,7 +523,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
         }
         if (bottomThird)
             thirdAtFoot(layout, height - pad - extraH0 + 6, width / 2, ow, OTHER_H, v, road, boxes, texts);
-        othersBlock(layout, others, height - pad - extraH0 + thirdBlock + 6, width, pad, ow, OTHER_H, v, road, boxes, texts);
+        othersBlock(layout, others, height - pad - extraH0 + thirdBlock + 6, width, pad, ow, OH, v, road, boxes, texts);
         texts.push(...headings(v, o, width, pad, poster));
         return finish({ width, height, boxes, links: orderLinks(links), texts, extras, detail, vertical, road, path, fit: fitNow, notes: anyNotes, markScores, markCols, tags: tagsOn, codes: codesOn, variant: V, em: { full: longest / 13, abbr: longestAbbr / 13, tag: tagsOn ? Math.max(...layout.ties.flatMap((t) => [tagOf(t, 0), tagOf(t, 1)]).map((x) => boldWidth(x, 1))) : 0 } });
     }
@@ -531,7 +536,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
     const bandCount = halves ? 2 * bandsPerSide : nc + (champ ? 1 : 0);
     others = othersOf(layout);
     ow = Math.min(W0 - 2 * pad, 150);
-    const othersV = othersHeight(others.length, W0, pad, ow, OTHER_H);
+    const othersV = othersHeight(others.length, W0, pad, ow, OH);
     // The height the page needs for boxes `h` high with `gap` between the rounds, and what it keeps for the final's band and the third-place match.
     const needOf = (h, gap) => {
         const finalHere = V === "columns" ? Math.max(h, finalH) : detail === "mark" ? Math.max(h, 52) : h;
@@ -664,7 +669,7 @@ function planBracket(layout, o, v, size, vertical, ctx, road, path, kind) {
     }
     if (bottomThird)
         thirdAtFoot(layout, totalT - pad + 6, W0 / 2, Math.min(W0 - 2 * pad, road ? Math.max(boxW, 200) : 200), thirdH2, v, road, boxes, texts);
-    othersBlock(layout, others, totalT - pad + thirdBlockV + 6, W0, pad, ow, OTHER_H, v, road, boxes, texts);
+    othersBlock(layout, others, totalT - pad + thirdBlockV + 6, W0, pad, ow, OH, v, road, boxes, texts);
     texts.push(...headings(v, o, W0, pad, poster));
     return finish({ width: W0, height, boxes, links: orderLinks(links), texts, extras, detail, vertical, road, path, fit: fitNow, notes: anyNotes, markScores, markCols, tags: tagsOn, codes: codesOn, variant: V, em: { full: longest / 13, abbr: longestAbbr / 13, tag: tagsOn ? Math.max(...layout.ties.flatMap((t) => [tagOf(t, 0), tagOf(t, 1)]).map((x) => boldWidth(x, 1))) : 0 } });
 }
@@ -868,7 +873,10 @@ function othersBlock(layout, list, y0, width, pad, ow, oh, v, road, boxes, texts
         return;
     const cols = Math.max(1, Math.floor((width - 2 * pad + 10) / (ow + 10)));
     const x0 = pad + (width - 2 * pad - (Math.min(cols, list.length) * (ow + 10) - 10)) / 2;
-    texts.push(label(v, road, v.words.other, width / 2, y0 + 12, "middle"));
+    const stages = new Set(list.map((i) => layout.ties[i].stage ?? "other"));
+    const w = v.words;
+    const heading = stages.size === 1 && stages.has("repechage") ? w.judoRepechage : stages.size === 1 && stages.has("bronze") ? w.judoBronze : [...stages].every((x) => x === "repechage" || x === "bronze") ? w.judoRepechageBronze : w.other;
+    texts.push(label(v, road, heading, width / 2, y0 + 12, "middle"));
     list.forEach((i, n) => {
         const rect = { x: x0 + (n % cols) * (ow + 10), y: y0 + 24 + Math.floor(n / cols) * (oh + 10), w: ow, h: oh };
         boxes.push({ rect, tie: layout.ties[i], order: [0, 1], bye: null, byes: [], final: false, champion: false });
@@ -932,7 +940,7 @@ function drawBox(p, plan, o, v, ctx, linked, side) {
         const withScore = plan.markScores && scoresOn && r.score !== null;
         const tags = [0, 1].map((k) => (plan.tags ? tagOf(tie, k) : ""));
         const tagH = tags.some((t) => t !== "") ? 12 : 0;
-        const scoreOf = (k) => (withScore && r.score ? v.number(r.score[k]) : "");
+        const scoreOf = (k) => (withScore ? sideScore(tie, k, v) : "");
         const pensOf = (k) => (withScore && r.pens ? `(${v.number(r.pens[k])})` : "");
         const hasPens = withScore && r.pens !== null;
         const lay = (m) => {
@@ -1028,7 +1036,13 @@ function drawBox(p, plan, o, v, ctx, linked, side) {
                 rowParts.push(`<rect class="tb-tagbox" x="${num(tx)}" y="${num(cy - (tf + 4) / 2)}" width="${num(tw)}" height="${num(tf + 4)}" rx="${num((tf + 4) / 2)}"/><text class="tb-tag" x="${num(tx + tw / 2)}" y="${num(cy + tf * 0.35)}" font-size="${num(tf)}" text-anchor="middle">${esc(tag)}</text>`);
                 tx += tw + 3;
             }
-            const score = scoresOn && r.score ? v.number(r.score[k]) : "";
+            const score = scoresOn ? sideScore(tie, k, v) : "";
+            // A judo contest: a bar at the row's edge in the colour of the side (the first is white, the second blue) and its shido cards beside the score.
+            if (tie.judo)
+                rowParts.push(`<rect class="${k === 0 ? "tb-jw" : "tb-jb"}" x="${num(x + 1.5)}" y="${num(cy - rowH * 0.3)}" width="3" height="${num(rowH * 0.6)}" rx="1.5"/>`);
+            const cards = tie.judo && scoresOn ? shidoCards(tie, k) : [];
+            const cardSize = Math.max(5, Math.min(9, rowH * 0.3));
+            const cardsW = cards.length ? cards.length * (cardSize * 0.72 + 2) + 4 : 0;
             const pensText = scoresOn && r.pens ? `(${v.number(r.pens[k])})` : "";
             const bye = p.byes.includes(k);
             const right = x + w - padX;
@@ -1040,7 +1054,8 @@ function drawBox(p, plan, o, v, ctx, linked, side) {
             const byeFits = bye && right - tx - (scoreW + pensW) - (mw(v.words.bye, small2) + 6) - 6 >= mw(`${seed}${nm}`, font);
             const byeText = byeFits ? v.words.bye : "";
             const byeW = byeText ? mw(byeText, small2) : 0;
-            const avail = right - tx - (scoreW + pensW) - (byeW ? byeW + 6 : 0) - 6;
+            const cardsOn = cardsW > 0 && right - tx - (scoreW + pensW) - cardsW - 6 >= 36;
+            const avail = right - tx - (scoreW + pensW) - (byeW ? byeW + 6 : 0) - 6 - (cardsOn ? cardsW : 0);
             // A name that does not fit is set a little smaller before it is cut.
             let nameFont = font;
             while (nameFont > 9.5 && mw(`${seed}${nm}`, nameFont) > avail)
@@ -1049,6 +1064,10 @@ function drawBox(p, plan, o, v, ctx, linked, side) {
             rowParts.push(`<text class="tb-name${team ? "" : " tb-muted"}" x="${num(tx)}" y="${num(cy + nameFont * 0.35)}" font-size="${num(nameFont)}">${esc(text)}</text>`);
             if (score)
                 rowParts.push(`<text class="tb-score" x="${num(right)}" y="${num(cy + scoreFont * 0.35)}" font-size="${num(scoreFont)}" text-anchor="end" font-variant-numeric="tabular-nums">${esc(score)}</text>`);
+            if (cardsOn) {
+                const cw = cardSize * 0.72;
+                cards.forEach((c, n) => rowParts.push(`<rect class="${c === "r" ? "tb-sh-r" : "tb-sh-y"}" x="${num(right - scoreW - pensW - cardsW + 2 + n * (cw + 2))}" y="${num(cy - cardSize / 2)}" width="${num(cw)}" height="${num(cardSize)}" rx="1"/>`));
+            }
             if (pensText)
                 rowParts.push(`<text class="tb-muted" x="${num(right - scoreW - (road ? 4 : 3))}" y="${num(cy + small * 0.35)}" font-size="${num(small)}" text-anchor="end">${esc(pensText)}</text>`);
             if (byeText)
@@ -1059,7 +1078,7 @@ function drawBox(p, plan, o, v, ctx, linked, side) {
         if (noteH) {
             const f = road ? 9 : 9.5;
             const line = road ? v.upper(notes.join(" · ")) : notes.join(" · ");
-            parts.push(`<text class="tb-muted${road ? " tb-note" : ""}" x="${num(x + w / 2)}" y="${num(y + h - (road ? 5 : 4))}" font-size="${f}"${road ? ' font-weight="700" letter-spacing=".05em"' : ""} text-anchor="middle">${esc(fit(line, f * (road ? 1.1 : 1), w - 8))}</text>`);
+            parts.push(`<text class="tb-muted${road ? " tb-note" : ""}" x="${num(x + w / 2)}" y="${num(y + h - (road ? 5 : 4))}" font-size="${f}"${road ? ' font-weight="700" letter-spacing=".05em"' : ""} text-anchor="middle">${esc(fit(line, f * (road ? 1.1 : 1), w - 8, boldWidth))}</text>`);
         }
     }
     const extra = tieClassOf(o, tie);

package/dist/table.js

@@ -1,5 +1,6 @@
 import { layoutBracket } from "./layout.js";
 import { noteLong } from "./matchup.js";
+import { sideScore } from "./judo-text.js";
 import { fill, voiceOf } from "./locales.js";
 import { localizedLayout } from "./render.js";
 import { roundLabel } from "./rounds.js";
@@ -23,12 +24,12 @@ export function bracketTable(input, options = {}) {
         const text = team ? esc(team.name) : esc(w.tbd);
         return t.winner === k ? `<strong>${text}</strong>` : text;
     };
-    const score = (t) => (t.result.score ? fill(w.scoreText, { a: v.number(t.result.score[0]), b: v.number(t.result.score[1]) }) : "");
+    const score = (t) => (t.result.score ? fill(w.scoreText, { a: sideScore(t, 0, v), b: sideScore(t, 1, v) }) : "");
     // Where a side comes from, in words, when the tie says so: "Loser of A v B".
     const named = (i) => fill(w.tieVs, { a: layout.ties[i].sides[0]?.name ?? w.tbd, b: layout.ties[i].sides[1]?.name ?? w.tbd });
     const origins = (t) => (t.from ?? []).flatMap((s) => (s ? [fill(s.result === "loser" ? w.loserOf : w.winnerOf, { name: named(s.tie) })] : []));
     const rows = order.map((t) => {
-        const roundText = t.third ? w.thirdPlace : t.playIn ? w.playIn : t.round === 0 ? "" : roundLabel(layout, t.round, options.roundNames, v);
+        const roundText = t.third ? w.thirdPlace : t.stage === "repechage" ? w.judoRepechage : t.stage === "bronze" ? w.judoBronze : t.playIn ? w.playIn : t.round === 0 ? "" : roundLabel(layout, t.round, options.roundNames, v);
         const date = dated ? `<td>${esc(v.date(t.date) ?? "")}</td>` : "";
         return `<tr><th scope="row">${esc(roundText)}</th>${date}<td>${name(t, 0)}</td><td>${esc(score(t))}</td><td>${name(t, 1)}</td><td>${esc([...noteLong(t, v), ...origins(t)].join(w.noteJoin))}</td></tr>`;
     });

package/dist/theme.d.ts

@@ -36,7 +36,16 @@ export interface StyleParts {
     bgAuto?: boolean;
     /** The rules of the layouts of their own (slots, shields, conference colours, header tiles, arrows, group cards). */
     layout?: boolean;
+    /** A judo bracket: the white and blue side bars and the shido cards (`--tb-judo-white`, `--tb-judo-blue`, `--tb-shido`, `--tb-hansoku`). */
+    judo?: boolean;
 }
+/** The colours of a judo contest: the white and the blue judogi, the yellow shido card and the red hansoku-make card. */
+export declare const JUDO_COLORS: Readonly<{
+    white: "#ffffff";
+    blue: "#1f4fa8";
+    shido: "#f0c000";
+    hansoku: "#d3302a";
+}>;
 /** The colours of the two halves (conferences) of the layouts that colour them, each with white letters on it: `--tb-conf-a` and `--tb-conf-b`. Both read 5 to 1 or more against white. */
 export declare const CONFERENCE_COLORS: readonly [string, string];
 /** The colours a background says to draw in (`backgroundSvg`'s `ink`): what `styleFor` takes in place of a look's own palette. */

package/dist/theme.js

@@ -10,6 +10,8 @@ export const ROAD_THEMES = Object.freeze({
     poster: { ring: "#f6f1e3", edge: "rgba(0,0,0,.5)", panel: "#1b2766", spine: "#d9b24c" },
 });
 const FONT = 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Hiragino Sans", "Yu Gothic UI", "Noto Sans CJK JP", Meiryo, sans-serif';
+/** The colours of a judo contest: the white and the blue judogi, the yellow shido card and the red hansoku-make card. */
+export const JUDO_COLORS = Object.freeze({ white: "#ffffff", blue: "#1f4fa8", shido: "#f0c000", hansoku: "#d3302a" });
 /** The colours of the two halves (conferences) of the layouts that colour them, each with white letters on it: `--tb-conf-a` and `--tb-conf-b`. Both read 5 to 1 or more against white. */
 export const CONFERENCE_COLORS = Object.freeze(["#2457c5", "#b3261e"]);
 /** A palette and a road palette from a background's ink. */
@@ -59,6 +61,9 @@ function rules(p, r, poster, withFont, parts, side) {
         const [ca, cb] = CONFERENCE_COLORS;
         list.push([[".tb-slot"], `fill:${v("plain")};fill-opacity:.55;stroke:${v("edge")};stroke-width:1`], [[".tb-won .tb-slot"], `fill-opacity:.9;stroke:${v("win")};stroke-width:1.6`], [[".tb-lost .tb-slot"], "fill-opacity:.35"], [[".tb-emptybar"], `fill:${v("plain")};opacity:.8`], [[".tb-seed"], "font-variant-numeric:tabular-nums"], [[".tb-seedn"], `fill:${v("muted")};opacity:.85`], [[".tb-shield"], `fill:none;stroke:${v("edge")};stroke-width:1.4`], [[".tb-won .tb-shield"], `stroke:${v("win")};stroke-width:2.2`], [[".tb-shield.tb-empty"], `fill:${v("plain")};fill-opacity:.5`], [[".tb-vs", ".tb-code"], `fill:${v("muted")};font-weight:700`], [[".tb-c0 .tb-box"], `stroke:var(--tb-conf-a, ${ca});stroke-width:1.6`], [[".tb-c1 .tb-box"], `stroke:var(--tb-conf-b, ${cb});stroke-width:1.6`], [[".tb-atag"], `fill:${v("ink")}`], [[".tb-atag-t"], `fill:${v("bg")}`], [[".tb-c0 .tb-atag"], `fill:var(--tb-conf-a, ${ca})`], [[".tb-c1 .tb-atag"], `fill:var(--tb-conf-b, ${cb})`], [[".tb-c0 .tb-atag-t", ".tb-c1 .tb-atag-t"], "fill:#fff"], [[".tb-head"], `fill:${rv("panel", "panel")}`], [[".tb-head.tb-c0"], `fill:var(--tb-conf-a, ${ca})`], [[".tb-head.tb-c1"], `fill:var(--tb-conf-b, ${cb})`], [[".tb-head-t"], `fill:${v("ink")};font-weight:800`], [[".tb-head.tb-c0 + .tb-head-t", ".tb-head.tb-c1 + .tb-head-t"], "fill:#fff"], [[".tb-arrow"], `stroke:${v("line")};stroke-width:1.6;fill:none;stroke-linecap:round;stroke-linejoin:round`], [[".tb-arrow-loser"], "stroke-dasharray:5 4"], [[".tb-arrowhead"], `fill:${v("line")};stroke:none`], [[".tb-gcard"], `fill:${v("box")};stroke:${v("edge")};stroke-width:1`], [[".tb-gtile"], `fill:var(--tb-conf-a, ${ca})`], [[".tb-gtile-t"], "fill:#fff;font-weight:800"], [[".tb-ghead"], `fill:${v("muted")};font-weight:700`], [[".tb-gcell"], `fill:${v("ink")};font-variant-numeric:tabular-nums`], [[".tb-gcell-p"], "font-weight:800"], [[".tb-gname"], `fill:${v("ink")};font-weight:700`], [[".tb-qual"], `fill:${v("win")};fill-opacity:.16`], [[".tb-gsep"], `stroke:${v("edge")};stroke-width:1;stroke-opacity:.6`]);
     }
+    if (parts.judo === true) {
+        list.push([[".tb-jw"], `fill:var(--tb-judo-white, ${JUDO_COLORS.white});stroke:${v("edge")};stroke-width:.8`], [[".tb-jb"], `fill:var(--tb-judo-blue, ${JUDO_COLORS.blue});stroke:${v("edge")};stroke-width:.8`], [[".tb-sh-y"], `fill:var(--tb-shido, ${JUDO_COLORS.shido});stroke:rgba(0,0,0,.35);stroke-width:.6`], [[".tb-sh-r"], `fill:var(--tb-hansoku, ${JUDO_COLORS.hansoku});stroke:rgba(0,0,0,.35);stroke-width:.6`]);
+    }
     if (parts.follow === true) {
         list.push([[".tb-tie"], "opacity:.4"], [[".tb-tie.tb-on-path"], "opacity:1"], [[".tb-on-path .tb-box"], `stroke:${v("win")};stroke-width:2.2`], [[".tb-line"], "stroke-opacity:.25"], [[".tb-line.tb-path"], `stroke:${v("win")};stroke-width:4.5;stroke-opacity:1;stroke-linecap:round;stroke-dasharray:.1 9`]);
     }

package/dist/types.d.ts

@@ -2,6 +2,7 @@
  * The types of Taisen: what goes in (teams and matchups), what the layout works out (ties, rounds, halves) and what
  * the drawing takes as options. Nothing here runs; the functions are in `matchup.ts`, `layout.ts` and `render.ts`.
  */
+import type { JudoOutcome, JudoResult } from "./judo-model.ts";
 /** A side's key: a team code, a franchise id, anything that is unique within one bracket. */
 export type SideId = string | number;
 /** A side of a tie: a team, with the marks and labels a drawing needs. Only `id` and `name` are required. */
@@ -106,8 +107,13 @@ export interface Matchup {
     walkover?: boolean;
     /** This is the third-place match: it leads nowhere and is drawn apart. */
     third?: boolean;
-    /** `"play-in"`: a game of a play-in (the NBA's) that is outside the rounds of the tree: its winner (and loser, see `feeds`) goes on to a place the tree's ties name. Drawn by the `playin` layout and, apart, under the other layouts' trees. */
-    stage?: "play-in";
+    /**
+     * `"play-in"`: a game of a play-in (the NBA's) that is outside the rounds of the tree: its winner (and loser, see `feeds`) goes on to a place the tree's ties name. Drawn by the `playin` layout and, apart, under the other layouts' trees.
+     * `"repechage"` and `"bronze"`: a judo repechage contest and a bronze medal contest, fed by the losers of the tree's ties (`judoBracket` writes them); drawn apart under the tree.
+     */
+    stage?: "play-in" | "repechage" | "bronze";
+    /** A judo contest's scores: ippon, waza-ari, yuko, shido, hansoku-make, golden score and time. The first side is white, the second blue. The score, the winner and the notes come from it; see `judoOutcome`. */
+    judo?: JudoResult;
     /** The side playing at home (0 or 1), for the `at` wording of the `columns` layout: the home side is drawn second, after "AT". Left out, the second side. */
     home?: 0 | 1;
     note?: string;
@@ -151,8 +157,12 @@ export interface Tie {
     seeds?: readonly [string | number | null, string | number | null];
     /** Where each side comes from, when the matchup's `feeds` name it: another tie's winner or its loser. Left out for a tie that says nothing of the kind. */
     from?: readonly [Source | null, Source | null];
-    /** The tie is a play-in game (`Matchup.stage`). */
+    /** The tie is a play-in game, a judo repechage contest or a bronze medal contest (`Matchup.stage`). */
     playIn?: boolean;
+    /** The tie's `Matchup.stage`, when it has one. */
+    stage?: "play-in" | "repechage" | "bronze";
+    /** A judo contest's result, checked and worked out (`Matchup.judo`). */
+    judo?: JudoOutcome;
     /** The side at home (`Matchup.home`), when given. */
     home?: 0 | 1;
 }
@@ -342,6 +352,39 @@ export interface Words {
     /** `{name}`: a side that is the winner or loser of another tie, in a sentence or a table: "Loser of {name}". */
     winnerOf: string;
     loserOf: string;
+    /** Judo. The marks of the scores on a box (ippon, waza-ari, yuko), the same written out, and how a contest was won. */
+    judoIppon: string;
+    judoWazaAri: string;
+    judoYuko: string;
+    judoIpponLong: string;
+    judoWazaAriLong: string;
+    judoYukoLong: string;
+    judoMethodIppon: string;
+    judoMethodAwasete: string;
+    judoMethodScore: string;
+    judoMethodHansoku: string;
+    judoMethodFusen: string;
+    judoMethodKiken: string;
+    /** Golden score, short and in a sentence. */
+    judoGolden: string;
+    judoGoldenLong: string;
+    /** `{t}`: the contest time ("3:42"). */
+    judoTime: string;
+    /** `{name}`, `{n}`: a side's shido ("Kenji Nakamura: 2 shido"). */
+    judoShidoOf: string;
+    /** `{a}`, `{b}`: the sides' shido in a short note. */
+    judoShidoShort: string;
+    /** The headings over the repechage contests and the bronze medal contests, alone and together; the sides' colours. */
+    judoRepechage: string;
+    judoBronze: string;
+    judoRepechageBronze: string;
+    judoWhite: string;
+    judoBlue: string;
+    /** `{sex}`, `{w}` (the number of kilograms, no sign): a weight category up to and including that weight ("Men -66 kg"), one over it ("Women +78 kg"), and the two sexes' words. */
+    judoWeightClass: string;
+    judoWeightOver: string;
+    judoMen: string;
+    judoWomen: string;
 }
 /** A language: its words, the names of the rounds (by their English names), and the tag `Intl` formats numbers and dates for. */
 export interface Locale {
@@ -352,6 +395,7 @@ export interface Locale {
     /** Round names by their English name: `{ "Round of 16": "Huitièmes de finale" }`. A round with no entry keeps its name (or `roundOf`). */
     rounds: Readonly<Record<string, string>>;
 }
+export type { JudoMethod, JudoOutcome, JudoResult, JudoSide } from "./judo-model.ts";
 export type ThemeName = "auto" | "light" | "dark" | "poster" | "none";
 export type SizeName = "wide" | "square" | "phone" | "card";
 export interface Size {
@@ -434,6 +478,8 @@ export interface DrawOptions extends LayoutOptions {
     standings?: "points" | "record";
     /** In the `groups` layout, how many teams of each group go through: their rows are marked. Default 0, none. */
     qualify?: number;
+    /** For `bracketStyle`: include the judo rules (the white and blue side bars, the shido cards). `drawBracket` adds them by itself when a tie has judo scores. */
+    judo?: boolean;
     /** Write the `<style>` into the drawing. Default true; false leaves it out, for a second drawing of a page that shares the first's (`styleScope`, `bracketStyle`). */
     style?: boolean;
     /** A class that carries this drawing's rules in place of its own: two drawings with the same `styleScope` take their colours from one `<style>`, and the second can leave it out (`style: false`). A word of letters, digits, `-` and `_`. */

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.6.1";
+export declare const VERSION = "0.7.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.6.1";
+export const VERSION = "0.7.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/taisen-brackets",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Taisen Brackets 対戦, knockout brackets as SVG: from a list of ties (games, best-of series, two legs, replays, byes, a third-place match) it works out the rounds and halves and draws the bracket with the halves meeting at the final, or left to right, wide, square, as a tall card or for a phone, in a classic or a road look (large round flags, big scores, a team's dotted path, a link on every box), in light, dark or a gold-on-navy poster look, in eight layouts (the tree, rows, shields, a score-update card, tall columns, the NBA's play-in, a series card and group tables), on one of twenty-five poster backgrounds (the playing surfaces of five sports among them) or your own, with each team's logo or round flag, the champion in the centre, and an accessible table; and the road to the final of either finalist. NHL, NBA, MLB, NFL, CFL, MLS and World Cup formats by era, in English, French, Japanese, Spanish and German. Zero dependencies.",
   "keywords": [
     "bracket",