@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/layers.js

@@ -3,12 +3,14 @@
 // table that stands for the drawing. Every mark is a plain SVG element in the drawing's own frame, so the same options always give
 // the same string. Written for this package; mplsoccer and hockey_rink were read for the list of charts to match, and nothing of
 // either is used.
-import { safeColour, safeLogo } from "./colour.js";
+import { safeColour } from "./colour.js";
+import { withEmblems } from "./emblems-source.js";
+import { safeLogo } from "./logo.js";
 import { FRAMES } from "./frames.js";
 import { KYOGIJO_HEAT_STYLE, KYOGIJO_TEAM_STYLE } from "./style.js";
 import { drawTeam, isTeamLayer, teamTables } from "./team.layers.js";
 import { drawHeat, drawLegend, heatTable } from "./heat.js";
-import { clamp01, envFor, isNum, newMade, opacityOf, own, place, toArray, unitOfLayer } from "./layers.env.js";
+import { clamp01, envFor, isNum, markAttrs, newMade, opacityOf, own, place, toArray, unitOfLayer } from "./layers.env.js";
 import { safeClass } from "./common.js";
 import { esc, num } from "./format.js";
 import { curveBetween, curvePath, headPath, isPolygon, polylinePath, rampColour, shapePath, taperPath, wavePath, } from "./layers.marks.js";
@@ -136,12 +138,12 @@ function drawPoints(layer, env) {
         const w = (isNum(d.size) && d.size > 0 ? d.size * k : sizeFn === undefined ? fixed : Math.max(0.05, sizeFn(d.value) * k)) * (outcome.scale ?? 1);
         const { cls, css } = colourAttrs(colourFor(style.fill, d, NEUTRAL, domain), layerExpr, NEUTRAL);
         const classes = `${cls}${outcome.hollow === true ? `${cls === "" ? "" : " "}ky-hol` : ""}`;
-        const open = attrs(classes, css, opacityOf(d.opacity));
+        const open = attrs(classes, css, opacityOf(d.opacity)) + markAttrs(env, d.id, i, [x, y]);
         const role = d.team === "home" ? "home" : d.team === "away" ? "away" : undefined;
         const logo = shape === "logo" ? safeLogo(d.logo) ?? (role === undefined ? undefined : safeLogo(style.logos?.[role]) ?? env.logos[role]) : undefined;
         if (logo !== undefined) {
             const side = w * 1.8;
-            out.push(titled("image", `${open} href="${esc(logo)}" x="${num(x - side / 2)}" y="${num(y - side / 2)}" width="${num(side)}" height="${num(side)}" preserveAspectRatio="xMidYMid meet"${env.turned ? ` transform="rotate(-90 ${num(x)} ${num(y)})"` : ""}`, d.title));
+            out.push(titled("image", `${open} href="${esc(logo)}" x="${num(x - side / 2)}" y="${num(y - side / 2)}" width="${num(side)}" height="${num(side)}" preserveAspectRatio="xMidYMid meet"${env.back !== 0 ? ` transform="rotate(${num(env.back)} ${num(x)} ${num(y)})"` : ""}`, d.title));
         }
         else if (shape !== "logo" && isPolygon(shape))
             out.push(titled("path", `${open} d="${shapePath(shape, x, y, w, env.turned)}"`, d.title));
@@ -258,13 +260,15 @@ function drawLines(layer, env, index) {
         const headEl = head === "" ? "" : `<path class="${headKind === "open" ? "ky-ln" : "ky-ah"}" d="${head}"${headKind === "open" ? ` stroke-width="${num(w)}"` : ""}/>`;
         const title = typeof d.title === "string" && d.title !== "" ? `<title>${esc(d.title)}</title>` : "";
         const opacity = opacityOf(d.opacity);
+        // Where it starts is its zone; where it ends is `data-zone-end`.
+        const marks = env.marks ? markAttrs(env, d.id, i, first) + (env.zone(last[0], last[1]) === undefined ? "" : ` data-zone-end="${esc(env.zone(last[0], last[1]))}"`) : "";
         // A line with a head is a group (its colour and opacity on the group); a line alone carries them itself.
         const wrap = headEl !== "";
         const pathClass = [shaftClass, wrap ? "" : cls].filter((c) => c !== "").join(" ");
         const pathStyle = [wrap ? "" : css, gradient].filter((c) => c !== "").join(";");
-        const pathOpen = `${attrs(pathClass, pathStyle, wrap ? undefined : opacity)} d="${shaft}"${tapered === undefined ? strokeWidth + dashes : ""}`;
+        const pathOpen = `${attrs(pathClass, pathStyle, wrap ? undefined : opacity)}${wrap ? "" : marks} d="${shaft}"${tapered === undefined ? strokeWidth + dashes : ""}`;
         if (wrap)
-            out.push(`<g${attrs(cls, css, opacity)}>${title}<path${pathOpen}/>${headEl}</g>`);
+            out.push(`<g${attrs(cls, css, opacity)}${marks}>${title}<path${pathOpen}/>${headEl}</g>`);
         else
             out.push(title === "" ? `<path${pathOpen}/>` : `<path${pathOpen}>${title}</path>`);
     });
@@ -307,14 +311,19 @@ function drawText(layer, env) {
         const { cls, css } = colourAttrs(colourFor(style.color, d, INK, domain), layerExpr, INK);
         const anchor = d.anchor === "start" || d.anchor === "middle" || d.anchor === "end" ? d.anchor : base;
         // The letters are turned back by the quarter the surface was turned, so that they read upright, and by the caller's own turn on top.
-        const angle = (env.turned ? -90 : 0) + (isNum(d.rotate) ? d.rotate : 0);
+        const angle = env.back + (isNum(d.rotate) ? d.rotate : 0);
         const classes = ["ky-lt", style.halo === false ? "ky-nh" : "", cls].filter((c) => c !== "").join(" ");
-        const open = `${attrs(classes, `${s === size ? "" : `font-size:${num(s)}px`}${s !== size && css !== "" ? ";" : ""}${css}`, opacityOf(d.opacity))}${anchor === base ? "" : ` text-anchor="${anchor}"`} x="${num(x)}" y="${num(y + s * 0.36)}"${angle === 0 ? "" : ` transform="rotate(${num(angle)} ${num(x)} ${num(y)})"`}`;
+        const open = `${attrs(classes, `${s === size ? "" : `font-size:${num(s)}px`}${s !== size && css !== "" ? ";" : ""}${css}`, opacityOf(d.opacity))}${markAttrs(env, d.id, i, [x, y])}${anchor === base ? "" : ` text-anchor="${anchor}"`} x="${num(x)}" y="${num(y + s * 0.36)}"${angle === 0 ? "" : ` transform="rotate(${num(angle)} ${num(x)} ${num(y)})"`}`;
         out.push(`<text${open}>${esc(String(d.text))}${typeof d.title === "string" && d.title !== "" ? `<title>${esc(d.title)}</title>` : ""}</text>`);
     });
     made.marks = out.join("");
     return made;
 }
+/**
+ * True when a datum of the layer has an `id`: the caller means to find its marks again. Not for the team layers, whose data have always had an `id` of their own (the player's, for a label and a table),
+ * so that a drawing made before the marks had ids is the same text now.
+ */
+const hasIds = (layer) => !isTeamLayer(layer) && Array.isArray(layer.data) && (layer.data).some((d) => typeof d === "object" && d !== null && d.id !== undefined);
 const plural = (words, kind, n) => words[`${kind === "lines" ? "line" : kind === "arrows" ? "arrow" : kind === "text" ? "text" : "point"}${n === 1 ? "One" : "Many"}`];
 const tidy = (text) => text.replace(/[.。]\s*$/, "");
 /** A list of counts, `goal 3, shot 21`, the most first. */
@@ -348,12 +357,16 @@ function summarise(layer, made, words, stop, gap) {
     return { title, description: parts.join(gap) };
 }
 /** The layers of a drawing as markup, and a sentence for each. `turned` says whether the surface group is turned a quarter. */
-export function renderLayers(o, layers, turned, range) {
+export function renderLayers(o, layers, turned, range, upright, zone) {
+    return withEmblems(o.emblems, () => renderedLayers(o, layers, turned, range, upright, zone));
+}
+function renderedLayers(o, layers, turned, range, upright, zone) {
     if (layers === undefined || layers.length === 0)
         return { svg: "", summaries: [] };
     if (!Array.isArray(layers))
         throw new TypeError("layers is a list of layers");
-    const env = envFor(o, turned, range);
+    const env = envFor(o, turned, range, upright, zone);
+    const markedBy = env.marks;
     const clipId = `${env.id}-lc`;
     const { stop, gap } = env.words.said;
     const said = [];
@@ -366,6 +379,8 @@ export function renderLayers(o, layers, turned, range) {
     layers.forEach((layer, index) => {
         if (typeof layer !== "object" || layer === null)
             throw new TypeError(`layer ${index} is not a layer`);
+        // The marks are written with their ids, indexes and zones when the layer or the drawing asks, or when the caller gave a datum an id of its own.
+        env.marks = typeof layer.marks === "boolean" ? layer.marks : markedBy || hasIds(layer);
         const name = safeClass(layer.id).replace(/ /g, "-");
         const gid = name === "" ? `${env.id}-l${index}` : `${env.id}-${name}`;
         const finish = (made) => {
@@ -375,7 +390,8 @@ export function renderLayers(o, layers, turned, range) {
                 return;
             const { title, description } = summarise(layer, made, env.words.layers, stop, gap);
             said[index] = description === "" ? `${tidy(title)}${stop}` : `${tidy(title)}${stop}${gap}${description}`;
-            const clip = layer.clip !== "none" && layer.kind !== "legend";
+            // A lineup is not cut to the outline unless it is asked to be: a fielder at the foul line or a catcher behind the plate would lose half a jersey.
+            const clip = layer.kind !== "legend" && (layer.clip === "surface" || (layer.clip !== "none" && layer.kind !== "lineup"));
             clipped = clipped || clip;
             const cls = made.cls ?? (layer.kind === "points" ? "ky-pts" : layer.kind === "text" ? "ky-txt" : "ky-lns");
             // Cropped to a range, a clipped layer is also cut to the range: its group is held by a group with the range's clip.
@@ -403,6 +419,7 @@ export function renderLayers(o, layers, turned, range) {
                 return;
             case "network":
             case "formation":
+            case "lineup":
             case "voronoi":
             case "delaunay":
             case "hull":
@@ -415,7 +432,7 @@ export function renderLayers(o, layers, turned, range) {
                 slots[index] = () => finish(drawLegend(layer, env, gid, known));
                 return;
             default:
-                throw new TypeError(`layer ${index} has the kind "${String(layer.kind)}": use points, lines, arrows, text, network, formation, voronoi, delaunay, hull, flow, sonar, heatmap, hexbin, zones, contour or legend`);
+                throw new TypeError(`layer ${index} has the kind "${String(layer.kind)}": use points, lines, arrows, text, network, formation, lineup, voronoi, delaunay, hull, flow, sonar, heatmap, hexbin, zones, contour or legend`);
         }
     });
     slots.forEach((later) => later?.());
@@ -491,7 +508,7 @@ export function layerTable(layers, options = {}) {
             return render(heatTable(layer, surfaceEnv), layer.kind);
         if (surfaceEnv !== undefined && isTeamLayer(layer))
             return teamTables(layer, surfaceEnv).map((t) => render(t, layer.kind)).join("");
-        const data = layer.kind === "formation" ? (layer.data ?? []) : toArray(layer.data, `layer ${index}`);
+        const data = layer.kind === "formation" ? (layer.data ?? []) : layer.kind === "lineup" ? (layer.players ?? []) : toArray(layer.data, `layer ${index}`);
         const columns = [];
         const has = (key) => data.some((d) => typeof d === "object" && d !== null && d[key] !== undefined && d[key] !== null);
         const t = words.team;
@@ -501,6 +518,8 @@ export function layerTable(layers, options = {}) {
             columns.push([t.tableFrom, "from", (d) => d.from], [t.tableTo, "to", (d) => d.to]);
         if (layer.kind === "formation")
             columns.push([t.tablePosition, "position", (d) => d.position], [t.tableNumber, "number", (d) => d.number], [t.tableName, "name", (d) => d.name]);
+        else if (layer.kind === "lineup")
+            columns.push([t.tablePosition, "pos", (d) => d.pos], [t.tableNumber, "number", (d) => d.number], [t.tableName, "name", (d) => d.name]);
         else {
             columns.push([w.tableX, "x", (d) => d.x]);
             columns.push([w.tableY, "y", (d) => d.y]);

package/dist/layers.types.d.ts

@@ -1,7 +1,7 @@
 import type { ScoreOptions, SurfaceOptions } from "./types.ts";
 import type { Frame, Attacking, Landmark, SurfaceSize } from "./frames.ts";
 import type { ContourLayer, HeatmapLayer, HexbinLayer, LegendLayer, ZonesLayer } from "./heat.types.ts";
-import type { DelaunayLayer, FlowLayer, FormationLayer, HullLayer, NetworkLayer, SonarLayer, VoronoiLayer } from "./team.types.ts";
+import type { DelaunayLayer, FlowLayer, FormationLayer, HullLayer, LineupLayer, NetworkLayer, SonarLayer, VoronoiLayer } from "./team.types.ts";
 import type { Unit } from "./units.ts";
 /** The shapes a point can be drawn as. A team's logo is `logo`. */
 export type MarkShape = "circle" | "square" | "triangle" | "diamond" | "cross" | "x" | "star";
@@ -45,6 +45,8 @@ export interface OutcomeStyle {
 }
 /** What every mark can carry. */
 export interface MarkDatum {
+    /** Your id for the mark: written on it as `data-mark-id`, so that a listener can link it to a row of your table. The mark's index is written when there is none. */
+    id?: string | number;
     /** The tooltip, and what a screen reader reads for the mark. */
     title?: string;
     /** `home`, `away` or another team. */
@@ -189,6 +191,11 @@ export interface LayerBase {
     clip?: "surface" | "none";
     /** Hide the layer. It is still in `layerTable`. */
     hidden?: boolean;
+    /**
+     * Write `data-mark-id`, `data-index` and `data-zone` on every mark of the layer (and draw each cell of a heat map or hexbin as a path of its own), so that one listener can link a mark to a table.
+     * Off by default, to keep a drawing compact; on by itself when a datum has an `id`, and when the drawing is made with `marks: true` or `pointer: true`. `false` turns it off for this layer.
+     */
+    marks?: boolean;
 }
 export interface PointsLayer extends LayerBase {
     kind: "points";
@@ -211,7 +218,7 @@ export interface TextLayer extends LayerBase {
     style?: TextStyle;
 }
 /** A layer of data on a surface. */
-export type Layer = PointsLayer | LinesLayer | ArrowsLayer | TextLayer | HeatmapLayer | HexbinLayer | ZonesLayer | ContourLayer | LegendLayer | NetworkLayer | FormationLayer | VoronoiLayer | DelaunayLayer | HullLayer | FlowLayer | SonarLayer;
+export type Layer = PointsLayer | LinesLayer | ArrowsLayer | TextLayer | HeatmapLayer | HexbinLayer | ZonesLayer | ContourLayer | LegendLayer | NetworkLayer | FormationLayer | LineupLayer | VoronoiLayer | DelaunayLayer | HullLayer | FlowLayer | SonarLayer;
 /** The kinds of layer. */
 export type LayerKind = Layer["kind"];
 /** What `layerTable` takes. */

package/dist/leagues/athletics.d.ts

@@ -0,0 +1,63 @@
+import { type Unit } from "../units.ts";
+import type { LeagueBase } from "./types.ts";
+/** The figures of an oval track, in metres. */
+export interface AthleticsFigures {
+    /** The length of each straight (the distance between the centres of the semicircles, for the outdoor track's). */
+    straight: number;
+    /** The radius of each bend at the inside of the track, where the kerb is. */
+    radius: number;
+    /** The width of a lane, the line on its right included. */
+    lane: number;
+    /** The least, the most and the drawn number of lanes of the oval. */
+    lanes: {
+        min: number;
+        max: number;
+        drawn: number;
+    };
+    /** The width of the painted lines. */
+    line: number;
+    /** The width of the kerb, as it is drawn (the rules allow 50 to 250 mm). */
+    kerb: number;
+    /** Where the running line is measured: from the kerb in lane 1, from the line on the left in the other lanes. */
+    inner: number;
+    outer: number;
+    /** The obstacle-free zone inside the kerb and outside the track, at least. */
+    safety: number;
+    /** The lane width of the straight that runs on beyond the oval's. */
+    straightLane: number;
+    /** The least and the most lanes of that straight, and the lengths round it: the starting area and the run-out. */
+    straightLanes: {
+        min: number;
+        max: number;
+    };
+    startArea: number;
+    runOut: number;
+    /** True for a covered track: its bends are banked, at this angle in degrees. */
+    banking: number | null;
+}
+/** The figures in feet, as the drawing's units are: the lengths only, not the counts of lanes or the angle of the banking. */
+export declare function athleticsInFeet(figures: AthleticsFigures, unit: Unit): AthleticsFigures;
+/** A league with an athletics track of its own. */
+export type AthleticsLeague = LeagueBase<"athletics", AthleticsFigures>;
+/**
+ * The 400 m Standard Track (Manual 2.2.1.1, Table 2.2.1.1): two semicircles of 36.50 m radius at the kerb joined by two straights of 84.39 m, lanes 1.22 m wide including the 50 mm line on the
+ * right (Rule 14.4), the running line 0.30 m outside the kerb in lane 1 and 0.20 m outside the line on the left in every other lane (Rule 14.2), eight lanes at least for the big competitions (Rule
+ * 14.5) and nine at the most (Manual 2.2.1.1). A straight of at least six lanes runs on beyond the oval's with a starting area of 3 m and a run-out of 17 m (Manual 2.2.2.1), and has no most (2.2.2.1).
+ * The safety zones are 1.00 m wide (2.2.1.5). The kerb is drawn 0.05 m wide, the narrowest the rules allow (Rule 14.1: 50 to 250 mm).
+ */
+export declare const WA_STANDARD_TRACK: AthleticsFigures;
+/**
+ * The 200 m Standard Short Track (Marking Plan for the World Athletics Standard Short Track, 1 January 2026; Rules 41 to 44): the bends have a construction radius of 17.205 m at the kerb and the
+ * centres of the banked bends are 44.983 m apart; lanes are 1.000 m wide on the oval and 1.220 m on the infield straight, four to six of them (Rule 43: 0.90 to 1.22 m, a minimum of four lanes and
+ * a maximum of six); the bends are banked at 10.000 degrees. The plan's own transitions (the ascending and descending sections) are drawn here as one circular bend of the same radius, which is ours.
+ */
+export declare const WA_SHORT_TRACK: AthleticsFigures;
+/** The staggers of the lanes of the 400 m Standard Track as the Manual prints them (Table 2.2.1.6a), in metres on the running line, for lanes 2 to 8: 200 m, 400 m, 800 m and 4 x 400 m. */
+export declare const WA_STAGGER_TABLE: Readonly<Record<"200m" | "400m" | "800m" | "4x400m", readonly number[]>>;
+/**
+ * The staggers of the lanes of the 200 m Standard Short Track (Marking Plan, 1 January 2026), in metres measured 0.20 m out from the lane line, for lanes 2 to 6. The first row serves the 200 m, 400 m,
+ * 800 m, 4 x 400 m and 4 x 800 m (two bends in lanes), the second the 4 x 200 m (three bends in lanes), the third the second leg of the 4 x 200 m (one bend).
+ */
+export declare const WA_SHORT_STAGGER_TABLE: Readonly<Record<"two-bends" | "three-bends" | "one-bend", readonly number[]>>;
+/** The athletics leagues: the outdoor track (the sport's own) and the covered one. */
+export declare const ATHLETICS_LEAGUES: readonly AthleticsLeague[];

package/dist/leagues/athletics.js

@@ -0,0 +1,87 @@
+// The athletics track: World Athletics' 400 m Standard Track (Track and Field Facilities Manual, 2019 edition, 2.2.1, and Technical Rule 14 of Book C2.1) and its 200 m Standard Short Track
+// for covered stadia (Technical Rules 41 to 44, and the Marking Plan for the Standard Short Track of 1 January 2026), with the figures of each in metres. Nothing here draws.
+import { convertLength } from "../units.js";
+/** The figures in feet, as the drawing's units are: the lengths only, not the counts of lanes or the angle of the banking. */
+export function athleticsInFeet(figures, unit) {
+    const k = (v) => convertLength(v, unit, "ft");
+    return {
+        straight: k(figures.straight),
+        radius: k(figures.radius),
+        lane: k(figures.lane),
+        lanes: { ...figures.lanes },
+        line: k(figures.line),
+        kerb: k(figures.kerb),
+        inner: k(figures.inner),
+        outer: k(figures.outer),
+        safety: k(figures.safety),
+        straightLane: k(figures.straightLane),
+        straightLanes: { ...figures.straightLanes },
+        startArea: k(figures.startArea),
+        runOut: k(figures.runOut),
+        banking: figures.banking,
+    };
+}
+/**
+ * The 400 m Standard Track (Manual 2.2.1.1, Table 2.2.1.1): two semicircles of 36.50 m radius at the kerb joined by two straights of 84.39 m, lanes 1.22 m wide including the 50 mm line on the
+ * right (Rule 14.4), the running line 0.30 m outside the kerb in lane 1 and 0.20 m outside the line on the left in every other lane (Rule 14.2), eight lanes at least for the big competitions (Rule
+ * 14.5) and nine at the most (Manual 2.2.1.1). A straight of at least six lanes runs on beyond the oval's with a starting area of 3 m and a run-out of 17 m (Manual 2.2.2.1), and has no most (2.2.2.1).
+ * The safety zones are 1.00 m wide (2.2.1.5). The kerb is drawn 0.05 m wide, the narrowest the rules allow (Rule 14.1: 50 to 250 mm).
+ */
+export const WA_STANDARD_TRACK = {
+    straight: 84.39,
+    radius: 36.5,
+    lane: 1.22,
+    lanes: { min: 4, max: 9, drawn: 8 },
+    line: 0.05,
+    kerb: 0.05,
+    inner: 0.3,
+    outer: 0.2,
+    safety: 1,
+    straightLane: 1.22,
+    straightLanes: { min: 6, max: 10 },
+    startArea: 3,
+    runOut: 17,
+    banking: null,
+};
+/**
+ * The 200 m Standard Short Track (Marking Plan for the World Athletics Standard Short Track, 1 January 2026; Rules 41 to 44): the bends have a construction radius of 17.205 m at the kerb and the
+ * centres of the banked bends are 44.983 m apart; lanes are 1.000 m wide on the oval and 1.220 m on the infield straight, four to six of them (Rule 43: 0.90 to 1.22 m, a minimum of four lanes and
+ * a maximum of six); the bends are banked at 10.000 degrees. The plan's own transitions (the ascending and descending sections) are drawn here as one circular bend of the same radius, which is ours.
+ */
+export const WA_SHORT_TRACK = {
+    straight: 44.983,
+    radius: 17.205,
+    lane: 1,
+    lanes: { min: 4, max: 6, drawn: 6 },
+    line: 0.05,
+    kerb: 0.05,
+    inner: 0.3,
+    outer: 0.2,
+    safety: 1,
+    straightLane: 1.22,
+    straightLanes: { min: 4, max: 6 },
+    startArea: 3,
+    runOut: 10,
+    banking: 10,
+};
+/** The staggers of the lanes of the 400 m Standard Track as the Manual prints them (Table 2.2.1.6a), in metres on the running line, for lanes 2 to 8: 200 m, 400 m, 800 m and 4 x 400 m. */
+export const WA_STAGGER_TABLE = Object.freeze({
+    "200m": [3.519, 7.351, 11.184, 15.017, 18.85, 22.682, 26.515],
+    "400m": [7.037, 14.703, 22.368, 30.034, 37.699, 45.365, 53.03],
+    "800m": [3.526, 7.384, 11.259, 15.151, 19.06, 22.987, 26.93],
+    "4x400m": [10.563, 22.086, 33.627, 45.185, 56.76, 68.352, 79.96],
+});
+/**
+ * The staggers of the lanes of the 200 m Standard Short Track (Marking Plan, 1 January 2026), in metres measured 0.20 m out from the lane line, for lanes 2 to 6. The first row serves the 200 m, 400 m,
+ * 800 m, 4 x 400 m and 4 x 800 m (two bends in lanes), the second the 4 x 200 m (three bends in lanes), the third the second leg of the 4 x 200 m (one bend).
+ */
+export const WA_SHORT_STAGGER_TABLE = Object.freeze({
+    "two-bends": [5.597, 11.821, 18.051, 24.285, 30.523],
+    "three-bends": [8.407, 17.781, 27.188, 36.626, 46.092],
+    "one-bend": [2.81, 5.959, 9.137, 12.341, 15.57],
+});
+/** The athletics leagues: the outdoor track (the sport's own) and the covered one. */
+export const ATHLETICS_LEAGUES = [
+    { id: "world-athletics", family: "athletics", name: { en: "World Athletics 400 m standard track", ja: "ワールドアスレティックスの400m標準トラック" }, unit: "m", dimensions: WA_STANDARD_TRACK, sources: ["wa-facilities-manual", "wa-technical-rules"], builtIn: true },
+    { id: "world-athletics-short", family: "athletics", name: { en: "World Athletics 200 m standard short track", ja: "ワールドアスレティックスの200m標準トラック（ショート・トラック）" }, unit: "m", dimensions: WA_SHORT_TRACK, sources: ["wa-short-track-plan", "wa-technical-rules"] },
+];

package/dist/leagues/budo.d.ts

@@ -0,0 +1,196 @@
+import { type Span } from "./fields.ts";
+import type { LeagueBase } from "./types.ts";
+/** A mat: its length and width in metres. */
+export interface Mat {
+    length: number;
+    width: number;
+}
+/** The figures of a judo contest area (a competition tatami), in metres. */
+export interface JudoFigures {
+    kind: "judo";
+    /** The contest area, a square: 8 m to 10 m a side (IJF SOR 8.7); 10 m at the Olympic Games, the World Championships and the Masters, which is the size drawn. */
+    contest: Span;
+    /** The safety area round it: at least 3 m (SOR 8.7). At the Games it is 4 m (the common and the exterior one); that is drawn. The rules give no greatest, so the drawing allows up to 6 m (ours). */
+    safety: Span;
+    /** The distance between two adjoining contest areas: a common safe zone of at least 4 m may serve (SOR 8.7). */
+    common: number;
+    /** The free zone kept round the whole competition area: at least 0.5 m (SOR 8.7). */
+    freeZone: number;
+    /** The tatami: 1 m by 2 m by 5 cm of pressed foam (SOR 8.7); the AJJF's own is 182 cm by 91 cm, 5 or 6 cm thick (guidebook 2-1). */
+    tatami: Mat & {
+        thickness: number;
+    };
+    /** A solid platform under the tatami is one metre wider and longer than the tatami (SOR 8.7), with an exterior safety area of 4 m. */
+    platform: number;
+    /** The tape that marks where the contestants start: 10 cm by 50 cm (SOR 2020 18.1), and how far each is from the centre. */
+    marks: {
+        width: number;
+        length: number;
+        fromCentre: number;
+    } | null;
+    /** The domestic red tatami of the danger zone, as wide as one tatami, inside the contest area; none in an IJF contest area (the guidebook 2-3 allows it at events other than the Games, the Worlds and the Masters). */
+    danger: boolean;
+    /** A kata area: two white tapes 5 cm by 50 cm, 3 m from the centre either side, and a safety area of 2 m (SOR B1.8). */
+    kata: boolean;
+}
+/** The figures of a karate competition area, in metres. */
+export interface KarateFigures {
+    kind: "karate";
+    /** The matted square, 8 m a side measured from the outside (WKF Kumite 1.1, Kata 1.1). */
+    area: number;
+    /** Kumite: the outer 1 m of the square is in another colour, marking the boundary (1.1). None for kata. */
+    band: number;
+    /** The safety area round the square: 2 m (1.1). */
+    safety: number;
+    /** The least distance between two competition areas: 2 m (1.2). */
+    between: number;
+    /** Kumite: the two mats turned over, red side up, 1 m from the centre (1.5). The mat's size is not in the rules: 1 m by 1 m (ours, the size of a WKF-approved mat). */
+    startMats: {
+        size: number;
+        fromCentre: number;
+    } | null;
+    /** The referee stands at the middle, 2 m from the boundary (1.6); each judge sits about 1.5 m off a corner in the safety area (1.6). */
+    referee: number;
+    judges: number;
+}
+/** The figures of a kendo shiai-jo, in metres. */
+export interface KendoFigures {
+    kind: "kendo";
+    /** A square or a rectangle of 9 m to 11 m a side, inclusive of the width of the line (Article 2). 10 m is drawn: the middle (ours). */
+    side: Span;
+    /** The lines are 5 cm to 10 cm wide and white as a rule (Subsidiary Rules, Article 1). */
+    lineWidth: Span;
+    /** The cross at the centre: 30 cm to 40 cm (Figure 1). */
+    cross: Span;
+    /** The two kaishi-sen, each 50 cm long and 1.4 m from the centre (Figure 1). */
+    startLine: {
+        length: number;
+        fromCentre: number;
+    };
+    /** A space of at least 1.5 m is kept outside the shiai-jo (Subsidiary Rules, Article 1). */
+    outside: number;
+}
+/** The figures of a sumo dohyō, in metres. */
+export interface SumoFigures {
+    kind: "sumo";
+    /** The clay square: 6.7 m a side (Sumo Rules, Dohyō Regulations, Article 1). */
+    platform: number;
+    /** Its height: 34 cm to 60 cm for a public dohyō (Article 1); 55 cm is drawn (ours). */
+    height: Span;
+    /** The circle of tawara: 4.55 m, 15 shaku (Article 1). Taken as the inside of the ring, where the wrestlers stand (ours: the rule does not say which edge). */
+    circle: number;
+    /** The tawara of the circle: 20, which are 4 tokudawara and 4 between each of them (Quiz No. 355). */
+    tawara: {
+        count: number;
+        tokuda: number;
+        between: number;
+    };
+    /** The shikiri-sen: two white lines 90 cm long, 6 cm wide and 70 cm apart (Quiz No. 1091). */
+    shikiri: {
+        length: number;
+        width: number;
+        apart: number;
+    };
+    /** The width of a tawara's cross-section and how far a tokudawara stands out from the circle: the rules give neither (ours). */
+    bale: {
+        width: number;
+        out: number;
+    };
+    /** The band of sand, the jano-me, outside the tawara: the rules give no width (ours). */
+    jano: number;
+}
+/** The figures of a kyūdōjō, in metres. */
+export interface KyudoFigures {
+    kind: "kyudo";
+    /** The distance from the shooting position (射位) to the face of the target: 28 m (kinteki) or 60 m (enteki) (Wakayama 2015; ANKF manual 4). */
+    distance: number;
+    /** The target: 36 cm across (a kasumi-mato) for kinteki, 100 cm for enteki; its centre 27 cm above the azuchi's base and tilted 5 degrees, or 97 cm above the ground and tilted 15 degrees. */
+    target: {
+        diameter: number;
+        centre: number;
+        tilt: number;
+    };
+    /** The shooters' places: 1.8 m apart (1.6 m to 2.0 m) for kinteki and 1.6 m (1.4 m to 1.8 m) for enteki, a line of 5 (ANKF manual 6). */
+    step: Span;
+    count: number;
+    /** The distance from the shooting position back to the honza (本座): 2.0 m for kinteki and 1.1 m for enteki (ANKF manual 6). */
+    honza: number;
+    /** The ceiling of the shajō: 4.0 m, at least 3.8 m (ANKF manual 6). */
+    ceiling: number;
+    /** The shooters stand to one side or the other of the door: the distance to the wall behind the last shooter, at least 1.4 m, and the least distance from the honza to the officials' seats behind (3.0 m for kinteki, 4.0 m for enteki). */
+    behind: {
+        wall: number;
+        officials: number;
+    };
+    /**
+     * The shajō in the manual's figures (Figures II-1 and II-3): 9.0 m from the front edge to the row of the officials' seats, with the shooting positions 2.1 m behind the front edge; 2.7 m (kinteki) or 2.2 m (enteki) from the first and the
+     * last shooter to the side walls, so that the frontage of 5 shooters is 12.6 m or 10.8 m; 3.6 m more for the judges' side. How far the back wall stands beyond the officials' row is not given: 1.5 m (ours).
+     */
+    hall: {
+        front: number;
+        depth: number;
+        side: number;
+        judges: number;
+        rear: number;
+    };
+    /** The distance from the honza back to the row of the officials' seats: 4.9 m (kinteki) and 5.8 m (enteki), Figures II-1 and II-3. */
+    row: number;
+    /** The width of the yamichi beyond the line of targets on each side, and the depth, the height and the margin of the azuchi: the rules give none (ours). */
+    yamichi: {
+        margin: number;
+    };
+    azuchi: {
+        depth: number;
+        height: number;
+        margin: number;
+    };
+}
+/** The figures of a dojo's mat: one tatami of a region. */
+export interface DojoFigures {
+    kind: "dojo";
+    /** One mat, a jō (畳), twice as long as it is wide. */
+    mat: Mat;
+    /** Where the standard is used. */
+    region: {
+        en: string;
+        ja: string;
+    };
+}
+/** The figures of a budō league. */
+export type BudoFigures = JudoFigures | KarateFigures | KendoFigures | SumoFigures | KyudoFigures | DojoFigures;
+/** The leagues of each budō sport. */
+export type JudoLeague = LeagueBase<"judo", JudoFigures>;
+export type KarateLeague = LeagueBase<"karate", KarateFigures>;
+export type KendoLeague = LeagueBase<"kendo", KendoFigures>;
+export type SumoLeague = LeagueBase<"sumo", SumoFigures>;
+export type KyudoLeague = LeagueBase<"kyudo", KyudoFigures>;
+export type DojoLeague = LeagueBase<"dojo", DojoFigures>;
+/** A league with a budō surface of its own. */
+export type BudoLeague = JudoLeague | KarateLeague | KendoLeague | SumoLeague | KyudoLeague | DojoLeague;
+/** The IJF's contest area (Sport and Organisation Rules 8.7, version of 21 January 2026) as drawn for the Games, the Worlds and the Masters. */
+export declare const IJF_CONTEST: JudoFigures;
+/** The All Japan Judo Federation's: the tatami of 182 cm by 91 cm, the red tatami of the danger zone, and the red and white tape 4 m (2 ken) apart (Tournament Management Guidebook 2023, 2-1, 2-3, 2-4). */
+export declare const AJJF_CONTEST: JudoFigures;
+/** The kata area (SOR B1.8): 10 m for the World Championships and 8 m for other events, a safety area of 2 m, two white tapes of 5 cm by 50 cm, 3 m from the centre. */
+export declare const IJF_KATA: JudoFigures;
+/** The WKF's kumite area (Kumite Competition Rules 2026.01, Article 1). */
+export declare const WKF_KUMITE: KarateFigures;
+/** The WKF's kata area (Kata Competition Rules 2026, Article 1): the same square, with no band and no start mats. */
+export declare const WKF_KATA: KarateFigures;
+/** The kendo shiai-jo (FIK Regulations, Article 2, the Subsidiary Rules' Article 1 and Figure 1). */
+export declare const FIK_SHIAI_JO: KendoFigures;
+/** The dohyō of the Japan Sumo Association (Sumo Rules, Dohyō Regulations, Article 1, and the Association's quizzes). */
+export declare const JSA_DOHYO: SumoFigures;
+/** The kyūdōjō for kinteki (近的), the 28 m range of a competition (ANKF competition manual 6 and the National Sports Festival's rules). */
+export declare const KINTEKI: KyudoFigures;
+/** The kyūdōjō for enteki (遠的), 60 m, with the target of 1 m. */
+export declare const ENTEKI: KyudoFigures;
+/** The budō leagues: for each sport the rulebook's own first. */
+export declare const JUDO_LEAGUES: readonly JudoLeague[];
+export declare const KARATE_LEAGUES: readonly KarateLeague[];
+export declare const KENDO_LEAGUES: readonly KendoLeague[];
+export declare const SUMO_LEAGUES: readonly SumoLeague[];
+export declare const KYUDO_LEAGUES: readonly KyudoLeague[];
+export declare const DOJO_LEAGUES: readonly DojoLeague[];
+/** Every budō league, once each. */
+export declare const BUDO_LEAGUES: readonly BudoLeague[];

package/dist/leagues/budo.js

@@ -0,0 +1,105 @@
+// The surfaces of the budō (武道): the contest areas of judo and karate, the shiai-jo of kendo, the dohyō of sumo, the kyūdōjō, and the tatami of a dojo, each from the rulebook or the
+// federation's own page it was read in, with every figure in metres. A figure that no rule gives is said so in its comment (ours). Nothing here draws.
+import { span } from "./fields.js";
+/** The IJF's contest area (Sport and Organisation Rules 8.7, version of 21 January 2026) as drawn for the Games, the Worlds and the Masters. */
+export const IJF_CONTEST = {
+    kind: "judo",
+    contest: span(8, 10, 10),
+    safety: span(3, 6, 4),
+    common: 4,
+    freeZone: 0.5,
+    tatami: { length: 2, width: 1, thickness: 0.05 },
+    platform: 1,
+    marks: { width: 0.1, length: 0.5, fromCentre: 2 },
+    danger: false,
+    kata: false,
+};
+/** The All Japan Judo Federation's: the tatami of 182 cm by 91 cm, the red tatami of the danger zone, and the red and white tape 4 m (2 ken) apart (Tournament Management Guidebook 2023, 2-1, 2-3, 2-4). */
+export const AJJF_CONTEST = {
+    ...IJF_CONTEST,
+    contest: span(8, 10, 8),
+    safety: span(3, 6, 3),
+    tatami: { length: 1.82, width: 0.91, thickness: 0.06 },
+    danger: true,
+};
+/** The kata area (SOR B1.8): 10 m for the World Championships and 8 m for other events, a safety area of 2 m, two white tapes of 5 cm by 50 cm, 3 m from the centre. */
+export const IJF_KATA = {
+    ...IJF_CONTEST,
+    contest: span(8, 10, 10),
+    safety: span(2, 6, 2),
+    marks: { width: 0.05, length: 0.5, fromCentre: 3 },
+    kata: true,
+};
+/** The WKF's kumite area (Kumite Competition Rules 2026.01, Article 1). */
+export const WKF_KUMITE = { kind: "karate", area: 8, band: 1, safety: 2, between: 2, startMats: { size: 1, fromCentre: 1 }, referee: 2, judges: 1.5 };
+/** The WKF's kata area (Kata Competition Rules 2026, Article 1): the same square, with no band and no start mats. */
+export const WKF_KATA = { kind: "karate", area: 8, band: 0, safety: 2, between: 2, startMats: null, referee: 2, judges: 1.5 };
+/** The kendo shiai-jo (FIK Regulations, Article 2, the Subsidiary Rules' Article 1 and Figure 1). */
+export const FIK_SHIAI_JO = { kind: "kendo", side: span(9, 11, 10), lineWidth: span(0.05, 0.1, 0.05), cross: span(0.3, 0.4, 0.35), startLine: { length: 0.5, fromCentre: 1.4 }, outside: 1.5 };
+/** The dohyō of the Japan Sumo Association (Sumo Rules, Dohyō Regulations, Article 1, and the Association's quizzes). */
+export const JSA_DOHYO = {
+    kind: "sumo",
+    platform: 6.7,
+    height: span(0.34, 0.6, 0.55),
+    circle: 4.55,
+    tawara: { count: 20, tokuda: 4, between: 4 },
+    shikiri: { length: 0.9, width: 0.06, apart: 0.7 },
+    bale: { width: 0.2, out: 0.2 },
+    jano: 0.5,
+};
+/** The kyūdōjō for kinteki (近的), the 28 m range of a competition (ANKF competition manual 6 and the National Sports Festival's rules). */
+export const KINTEKI = {
+    kind: "kyudo",
+    distance: 28,
+    target: { diameter: 0.36, centre: 0.27, tilt: 5 },
+    step: span(1.6, 2, 1.8),
+    count: 5,
+    honza: 2,
+    ceiling: 4,
+    behind: { wall: 1.4, officials: 3 },
+    hall: { front: 2.1, depth: 9, side: 2.7, judges: 3.6, rear: 1.5 },
+    row: 4.9,
+    yamichi: { margin: 1.2 },
+    azuchi: { depth: 2.4, height: 1.5, margin: 1.8 },
+};
+/** The kyūdōjō for enteki (遠的), 60 m, with the target of 1 m. */
+export const ENTEKI = {
+    kind: "kyudo",
+    distance: 60,
+    target: { diameter: 1, centre: 0.97, tilt: 15 },
+    step: span(1.4, 1.8, 1.6),
+    count: 5,
+    honza: 1.1,
+    ceiling: 4,
+    behind: { wall: 1.4, officials: 4 },
+    hall: { front: 2.1, depth: 9, side: 2.2, judges: 3.6, rear: 1.5 },
+    row: 5.8,
+    yamichi: { margin: 1.6 },
+    azuchi: { depth: 3, height: 1.8, margin: 2.4 },
+};
+const mat = (length, width, en, ja) => ({ kind: "dojo", mat: { length, width }, region: { en, ja } });
+/** The budō leagues: for each sport the rulebook's own first. */
+export const JUDO_LEAGUES = [
+    { id: "ijf", family: "judo", name: { en: "IJF contest area", ja: "国際柔道連盟の試合場" }, unit: "m", dimensions: IJF_CONTEST, sources: ["ijf-sor", "ijf-sor-2020"], builtIn: true },
+    { id: "ajjf", family: "judo", name: { en: "AJJF contest area", ja: "全日本柔道連盟の試合場" }, unit: "m", dimensions: AJJF_CONTEST, sources: ["ajjf-guide", "ijf-sor"] },
+    { id: "ijf-kata", family: "judo", name: { en: "IJF kata area", ja: "国際柔道連盟の形の試合場" }, unit: "m", dimensions: IJF_KATA, sources: ["ijf-sor"] },
+];
+export const KARATE_LEAGUES = [
+    { id: "wkf-kumite", family: "karate", name: { en: "WKF kumite area", ja: "世界空手連盟の組手の試合場" }, unit: "m", dimensions: WKF_KUMITE, sources: ["wkf-kumite"], builtIn: true },
+    { id: "wkf-kata", family: "karate", name: { en: "WKF kata area", ja: "世界空手連盟の形の試合場" }, unit: "m", dimensions: WKF_KATA, sources: ["wkf-kata"] },
+];
+export const KENDO_LEAGUES = [{ id: "fik", family: "kendo", name: { en: "FIK shiai-jo", ja: "国際剣道連盟の試合場" }, unit: "m", dimensions: FIK_SHIAI_JO, sources: ["fik-regulations"], builtIn: true }];
+export const SUMO_LEAGUES = [{ id: "jsa", family: "sumo", name: { en: "Japan Sumo Association dohyō", ja: "日本相撲協会の土俵" }, unit: "m", dimensions: JSA_DOHYO, sources: ["jsa-dohyo", "jsa-quiz", "wikipedia-dohyo"], builtIn: true }];
+export const KYUDO_LEAGUES = [
+    { id: "kinteki", family: "kyudo", name: { en: "Kyūdōjō for kinteki, 28 m", ja: "近的の弓道場（28m）" }, unit: "m", dimensions: KINTEKI, sources: ["znkr-unei", "wakayama-kyudo-2015"], builtIn: true },
+    { id: "enteki", family: "kyudo", name: { en: "Kyūdōjō for enteki, 60 m", ja: "遠的の弓道場（60m）" }, unit: "m", dimensions: ENTEKI, sources: ["znkr-unei", "wakayama-kyudo-2015"] },
+];
+export const DOJO_LEAGUES = [
+    { id: "chukyoma", family: "dojo", name: { en: "Chūkyōma tatami, 1820 by 910 mm", ja: "中京間の畳（1820×910mm）" }, unit: "m", dimensions: mat(1.82, 0.91, "Nagoya and the Chūbu region", "名古屋・中部"), sources: ["tatami-sizes", "ajjf-guide"], builtIn: true },
+    { id: "kyoma", family: "dojo", name: { en: "Kyōma tatami, 1910 by 955 mm", ja: "京間の畳（1910×955mm）" }, unit: "m", dimensions: mat(1.91, 0.955, "Kyoto and the Kansai region", "京都・関西"), sources: ["tatami-sizes"] },
+    { id: "edoma", family: "dojo", name: { en: "Edoma tatami, 1760 by 880 mm", ja: "江戸間の畳（1760×880mm）" }, unit: "m", dimensions: mat(1.76, 0.88, "Edo (Tokyo) and the Kantō region", "江戸・関東"), sources: ["tatami-sizes"] },
+    { id: "danchima", family: "dojo", name: { en: "Danchima tatami, 1700 by 850 mm", ja: "団地間の畳（1700×850mm）" }, unit: "m", dimensions: mat(1.7, 0.85, "housing complexes", "団地"), sources: ["tatami-sizes"] },
+    { id: "judo-2x1", family: "dojo", name: { en: "Judo tatami, 2 m by 1 m", ja: "柔道畳（2m×1m）" }, unit: "m", dimensions: mat(2, 1, "the IJF's standard", "国際柔道連盟の標準"), sources: ["ijf-sor", "ajjf-guide"] },
+];
+/** Every budō league, once each. */
+export const BUDO_LEAGUES = Object.freeze([...JUDO_LEAGUES, ...KARATE_LEAGUES, ...KENDO_LEAGUES, ...SUMO_LEAGUES, ...KYUDO_LEAGUES, ...DOJO_LEAGUES]);