@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/leagues.js

@@ -8,10 +8,14 @@ import { BASKETBALL_LEAGUES, courtInFeet } from "./leagues/basketball.js";
 import { FOOTBALL_LEAGUES } from "./leagues/football.js";
 import { HOCKEY_LEAGUES, rinkInFeet } from "./leagues/hockey.js";
 import { CURLING_LEAGUES, sheetInFeet } from "./leagues/curling.js";
-import { BADMINTON_LEAGUES, PICKLEBALL_LEAGUES, TABLE_TENNIS_LEAGUES, TENNIS_LEAGUES, VOLLEYBALL_LEAGUES, netInFeet } from "./leagues/courts.js";
+import { BADMINTON_LEAGUES, NETBALL_LEAGUES, PADEL_LEAGUES, PICKLEBALL_LEAGUES, RACQUETBALL_LEAGUES, ROUNDNET_LEAGUES, SEPAK_TAKRAW_LEAGUES, SQUASH_LEAGUES, TABLE_TENNIS_LEAGUES, TENNIS_LEAGUES, TEQBALL_LEAGUES, VOLLEYBALL_LEAGUES, netInFeet } from "./leagues/courts.js";
 import { AFL_LEAGUES, aflInFeet } from "./leagues/aussie.js";
 import { CRICKET_LEAGUES, cricketInFeet } from "./leagues/cricket.js";
 import { FIELD_HOCKEY_LEAGUES, fieldHockeyInFeet } from "./leagues/fieldhockey.js";
+import { ATHLETICS_LEAGUES, athleticsInFeet } from "./leagues/athletics.js";
+import { longOval, outerEdge } from "./skating/track.js";
+import { SKATING_LEAGUES, skatingInFeet } from "./leagues/skating.js";
+import { BUDO_LEAGUES, DOJO_LEAGUES, JUDO_LEAGUES, KARATE_LEAGUES, KENDO_LEAGUES, KYUDO_LEAGUES, SUMO_LEAGUES } from "./leagues/budo.js";
 import { GAELIC_LEAGUES, gaelicInFeet } from "./leagues/gaelic.js";
 import { HANDBALL_LEAGUES, handballInFeet } from "./leagues/handball.js";
 import { LACROSSE_LEAGUES, lacrosseInFeet } from "./leagues/lacrosse.js";
@@ -21,11 +25,14 @@ import { inFeet } from "./leagues/types.js";
 import { convertLength } from "./units.js";
 export { LEAGUE_SOURCES };
 export { AFL_GROUNDS } from "./leagues/aussie.js";
+export { WA_STANDARD_TRACK, WA_SHORT_TRACK, WA_STAGGER_TABLE, WA_SHORT_STAGGER_TABLE } from "./leagues/athletics.js";
+export { ISU_LONG_TRACK, ISU_SHORT_TRACK, ISU_FIGURE_RINK, ISU_LONG_TRACK_TABLE } from "./leagues/skating.js";
+export { AJJF_CONTEST, BUDO_LEAGUES, ENTEKI, FIK_SHIAI_JO, IJF_CONTEST, IJF_KATA, JSA_DOHYO, KINTEKI, WKF_KATA, WKF_KUMITE } from "./leagues/budo.js";
 /** The family of surface each sport draws; soccer's variants are its pitches (`pitch`), not leagues. */
-export const FAMILY_OF = Object.freeze({ nfl: "football", cfl: "football", ifaf: "football", nhl: "hockey", nba: "basketball", mlb: "baseball", soccer: undefined, curling: "curling", tennis: "tennis", volleyball: "volleyball", badminton: "badminton", pickleball: "pickleball", tabletennis: "tabletennis", lacrosse: "lacrosse", rugby: "rugby", afl: "afl", gaelic: "gaelic", cricket: "cricket", fieldhockey: "fieldhockey", handball: "handball" });
+export const FAMILY_OF = Object.freeze({ nfl: "football", cfl: "football", ifaf: "football", nhl: "hockey", nba: "basketball", mlb: "baseball", soccer: undefined, curling: "curling", tennis: "tennis", volleyball: "volleyball", badminton: "badminton", pickleball: "pickleball", tabletennis: "tabletennis", padel: "padel", squash: "squash", racquetball: "racquetball", sepaktakraw: "sepaktakraw", teqball: "teqball", roundnet: "roundnet", netball: "netball", lacrosse: "lacrosse", rugby: "rugby", afl: "afl", gaelic: "gaelic", cricket: "cricket", fieldhockey: "fieldhockey", handball: "handball", swimming: undefined, waterpolo: undefined, diving: undefined, artisticswimming: undefined, athletics: "athletics", skating: "skating", judo: "judo", karate: "karate", kendo: "kendo", sumo: "sumo", kyudo: "kyudo", dojo: "dojo" });
 /**
  * The leagues each sport can draw, in the order a menu lists them, the sport's own first (the three football sports share their
- * list, the football leagues). Soccer has none.
+ * list, the football leagues). Soccer and the pools have none.
  */
 export const LEAGUES = Object.freeze({
     nba: BASKETBALL_LEAGUES,
@@ -41,6 +48,13 @@ export const LEAGUES = Object.freeze({
     badminton: BADMINTON_LEAGUES,
     pickleball: PICKLEBALL_LEAGUES,
     tabletennis: TABLE_TENNIS_LEAGUES,
+    padel: PADEL_LEAGUES,
+    squash: SQUASH_LEAGUES,
+    racquetball: RACQUETBALL_LEAGUES,
+    sepaktakraw: SEPAK_TAKRAW_LEAGUES,
+    teqball: TEQBALL_LEAGUES,
+    roundnet: ROUNDNET_LEAGUES,
+    netball: NETBALL_LEAGUES,
     lacrosse: LACROSSE_LEAGUES,
     rugby: RUGBY_LEAGUES,
     afl: AFL_LEAGUES,
@@ -48,9 +62,22 @@ export const LEAGUES = Object.freeze({
     cricket: CRICKET_LEAGUES,
     fieldhockey: FIELD_HOCKEY_LEAGUES,
     handball: HANDBALL_LEAGUES,
+    // The pools have one rulebook, World Aquatics', and no leagues.
+    swimming: [],
+    waterpolo: [],
+    diving: [],
+    artisticswimming: [],
+    athletics: ATHLETICS_LEAGUES,
+    skating: SKATING_LEAGUES,
+    judo: JUDO_LEAGUES,
+    karate: KARATE_LEAGUES,
+    kendo: KENDO_LEAGUES,
+    sumo: SUMO_LEAGUES,
+    kyudo: KYUDO_LEAGUES,
+    dojo: DOJO_LEAGUES,
 });
 /** Every league of every family, once each. */
-export const VARIANTS = Object.freeze([...BASKETBALL_LEAGUES, ...HOCKEY_LEAGUES, ...FOOTBALL_LEAGUES, ...BASEBALL_LEAGUES, ...CURLING_LEAGUES, ...TENNIS_LEAGUES, ...VOLLEYBALL_LEAGUES, ...BADMINTON_LEAGUES, ...PICKLEBALL_LEAGUES, ...TABLE_TENNIS_LEAGUES, ...LACROSSE_LEAGUES, ...RUGBY_LEAGUES, ...AFL_LEAGUES, ...GAELIC_LEAGUES, ...CRICKET_LEAGUES, ...FIELD_HOCKEY_LEAGUES, ...HANDBALL_LEAGUES]);
+export const VARIANTS = Object.freeze([...BASKETBALL_LEAGUES, ...HOCKEY_LEAGUES, ...FOOTBALL_LEAGUES, ...BASEBALL_LEAGUES, ...CURLING_LEAGUES, ...TENNIS_LEAGUES, ...VOLLEYBALL_LEAGUES, ...BADMINTON_LEAGUES, ...PICKLEBALL_LEAGUES, ...TABLE_TENNIS_LEAGUES, ...PADEL_LEAGUES, ...SQUASH_LEAGUES, ...RACQUETBALL_LEAGUES, ...SEPAK_TAKRAW_LEAGUES, ...TEQBALL_LEAGUES, ...ROUNDNET_LEAGUES, ...NETBALL_LEAGUES, ...LACROSSE_LEAGUES, ...RUGBY_LEAGUES, ...AFL_LEAGUES, ...GAELIC_LEAGUES, ...CRICKET_LEAGUES, ...FIELD_HOCKEY_LEAGUES, ...HANDBALL_LEAGUES, ...ATHLETICS_LEAGUES, ...BUDO_LEAGUES]);
 /** The ids of a sport's leagues. */
 export const leagueIds = (sport) => LEAGUES[sport].map((league) => league.id);
 /** A league by its sport and id, or `undefined`. */
@@ -160,7 +187,7 @@ export const courtOf = (league, year) => courtInFeet(leagueAtOf(league, year).fi
 export const rinkOf = (league, year) => rinkInFeet(leagueAtOf(league, year).figures, figuresUnit(league));
 /** A curling sheet of a league, in feet. A sheet has no history; a year is ignored. */
 export const sheetOf = (league = CURLING_LEAGUES[0]) => sheetInFeet(league.dimensions, league.figuresUnit ?? league.unit);
-/** A net sport's court of a league (tennis, volleyball and beach volleyball, badminton, pickleball, table tennis), in feet. These courts have no history; a year is ignored. */
+/** A net sport's court of a league (tennis, volleyball, beach and sitting volleyball, badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet and netball), in feet. These courts have no history; a year is ignored. */
 export const netOf = (league) => netInFeet(league.dimensions, figuresUnit(league));
 /** A lacrosse surface of a league, in feet (the box floor, or a field). These have no history; a year is ignored. */
 export const lacrosseOf = (league) => lacrosseInFeet(league.dimensions, figuresUnit(league));
@@ -174,6 +201,10 @@ export const gaelicOf = (league) => gaelicInFeet(league.dimensions, figuresUnit(
 export const cricketOf = (league) => cricketInFeet(league.dimensions, figuresUnit(league));
 /** A field hockey pitch, in feet. */
 export const fieldHockeyOf = (league) => fieldHockeyInFeet(league.dimensions, figuresUnit(league));
+/** A skating rink of a league, in feet. */
+export const skatingOf = (league) => skatingInFeet(league.dimensions, figuresUnit(league));
+/** An athletics track of a league, in feet. */
+export const athleticsOf = (league) => athleticsInFeet(league.dimensions, figuresUnit(league));
 /** A handball court, in feet. */
 export const handballOf = (league) => handballInFeet(league.dimensions, figuresUnit(league));
 /** A football field of a league in a season: the spec, in feet. */
@@ -215,6 +246,13 @@ export function leagueSize(sport, id, unit) {
         case "badminton":
         case "pickleball":
         case "tabletennis":
+        case "padel":
+        case "squash":
+        case "racquetball":
+        case "sepaktakraw":
+        case "teqball":
+        case "roundnet":
+        case "netball":
             feet = netOf(league);
             break;
         case "football": {
@@ -245,6 +283,57 @@ export function leagueSize(sport, id, unit) {
             feet = { length: 2 * f.boundary.drawn, width: 2 * f.boundary.drawn };
             break;
         }
+        case "athletics": {
+            // The oval's outer edge with its last lane drawn: two semicircles and a straight long, a diameter wide.
+            const f = athleticsOf(league);
+            const outer = f.radius + f.lanes.drawn * f.lane;
+            feet = { length: f.straight + 2 * outer, width: 2 * outer };
+            break;
+        }
+        case "skating": {
+            // The long track: the ice out to the padding; the others: the rink.
+            const d = league.dimensions;
+            const m = d.kind === "long-track" ? (() => { const o = longOval(undefined, undefined, d); const R = outerEdge(o) + d.padding.clear; return { length: o.straight + 2 * R, width: 2 * R }; })() : d.kind === "short-track" ? d.rink : { length: d.length.drawn, width: d.width.drawn };
+            feet = { length: convertLength(m.length, league.unit, "ft"), width: convertLength(m.width, league.unit, "ft") };
+            break;
+        }
+        case "judo": {
+            // The contest area with its safety area all round it, in metres.
+            const d = league.dimensions;
+            const m = d.contest.drawn + 2 * d.safety.drawn;
+            feet = { length: convertLength(m, "m", "ft"), width: convertLength(m, "m", "ft") };
+            break;
+        }
+        case "karate": {
+            const d = league.dimensions;
+            const m = d.area + 2 * d.safety;
+            feet = { length: convertLength(m, "m", "ft"), width: convertLength(m, "m", "ft") };
+            break;
+        }
+        case "kendo": {
+            const m = league.dimensions.side.drawn;
+            feet = { length: convertLength(m, "m", "ft"), width: convertLength(m, "m", "ft") };
+            break;
+        }
+        case "sumo": {
+            const m = league.dimensions.platform;
+            feet = { length: convertLength(m, "m", "ft"), width: convertLength(m, "m", "ft") };
+            break;
+        }
+        case "kyudo": {
+            // The shajō from its back wall to the back of the azuchi, and the width of its frontage with the judges' side.
+            const d = league.dimensions;
+            const frontage = (d.count - 1) * d.step.drawn + 2 * d.hall.side + d.hall.judges;
+            const length = d.hall.rear + d.hall.depth - d.hall.front + d.distance - 1 + d.azuchi.depth;
+            feet = { length: convertLength(length, "m", "ft"), width: convertLength(frontage, "m", "ft") };
+            break;
+        }
+        case "dojo": {
+            // The usual 20 jō: 5 mats' widths across and 8 along.
+            const d = league.dimensions;
+            feet = { length: convertLength(8 * d.mat.width, "m", "ft"), width: convertLength(5 * d.mat.width, "m", "ft") };
+            break;
+        }
         default:
             throw new Error(`No fixed size for the ${league.family} league "${id}": a diamond's size is its fence`);
     }
@@ -356,6 +445,69 @@ export function leagueFigures(league) {
                 ["lines", `${w(t.edgeLine)} at the edges, a ${w(t.centreLine)} centre line`],
             ];
         }
+        case "padel": {
+            const p = netOf(league);
+            return [
+                ["court", `${w(p.length)} by ${w(p.width)}, inside its walls`],
+                ["service line", `${w(p.serviceLine)} from the net`],
+                ["net", `${w(p.net.heightCentre)} at the centre, ${w(p.net.heightEnds)} at the ends, ${w(p.net.length)} long`],
+                ["walls", `the end walls ${w(p.enclosure.endHeight)} high, the side walls ${w(p.enclosure.sideWall)} long at each end`],
+            ];
+        }
+        case "squash": {
+            const q = netOf(league);
+            return [
+                ["court", `${w(q.length)} by ${w(q.width)}`],
+                ["short line", `${w(q.shortLine)} from the back wall to its nearest edge`],
+                ["service box", `${w(q.serviceBox)} square inside its lines`],
+                ["front wall", `the tin ${w(q.wall.tin)}, the service line ${w(q.wall.serviceLine)} and the front wall line ${w(q.wall.frontWallLine)} up`],
+            ];
+        }
+        case "racquetball": {
+            const r = netOf(league);
+            return [
+                ["court", `${w(r.length)} by ${w(r.width)}, ${w(r.height)} high`],
+                ["short line", `${w(r.shortLine)} from the back wall to its back edge`],
+                ["service line", `${w(r.serviceLine)} in front of the short line`],
+                ["receiving line", `${w(r.receiving.behind)} behind the short line`],
+            ];
+        }
+        case "sepaktakraw": {
+            const t = netOf(league);
+            return [
+                ["court", `${w(t.length)} by ${w(t.width)}`],
+                ["quarter circles", `${w(t.quarterCircle)} radius, at the ends of the centre line`],
+                ["service circles", `${w(t.serviceCircle.radius)} radius, ${w(t.serviceCircle.fromBack)} from the back line`],
+                ["net", `${w(t.net.heightMen)} high at the centre (women's ${w(t.net.heightWomen)})`],
+            ];
+        }
+        case "teqball": {
+            const t = netOf(league);
+            return [
+                ["court", `at least ${w(t.length)} by ${w(t.width)}`],
+                ["table", `${w(t.table.length)} by ${w(t.table.width)}`],
+                ["service line", `${w(t.serviceLine)} from the middle of the table`],
+                ["net", `${w(t.net.width)} wide, ${w(t.net.height)} high`],
+            ];
+        }
+        case "roundnet": {
+            const t = netOf(league);
+            return [
+                ["court", `at least ${w(t.length)} by ${w(t.width)}, with no out of bounds`],
+                ["set", `${w(t.set.diameter)} across`],
+                ["serving line", `a circle of ${w(t.servingRadius)} radius`],
+                ["no hit zone", `a circle of ${w(t.noHitRadius)} radius`],
+            ];
+        }
+        case "netball": {
+            const n = netOf(league);
+            return [
+                ["court", `${w(n.length)} by ${w(n.width)}`],
+                ["centre circle", `${w(n.centreCircle)} across`],
+                ["goal circles", `semicircles of ${w(n.goalCircle)} radius`],
+                ["goalposts", `${w(n.post.height)} high, at the middle of each goal line`],
+            ];
+        }
         case "football": {
             const f = fieldOf(league);
             return [
@@ -439,6 +591,40 @@ export function leagueFigures(league) {
                 ["goal", `${w(f.goalWidth)} wide and ${w(f.goalHeight)} high`],
             ];
         }
+        case "skating": {
+            const f = skatingOf(league);
+            if (f.kind === "long-track") {
+                return [
+                    ["track", `a lap of ${w(f.lap)} measured ${w(f.measure)} outside the inner edge, the inner curve ${w(f.innerRadius.min)} to ${w(f.innerRadius.max)} in radius`],
+                    ["lanes", `an inner lane of ${w(f.innerLane)} and an outer lane of at least ${w(f.outerLane.min)}, the warm-up lane at least ${w(f.warmUpLane)} wide`],
+                    ["blocks", `${w(f.blocks.near)} apart for the first ${w(f.blocks.nearLength)} of a curve, ${w(f.blocks.far)} after`],
+                    ["coaches' area", `a line ${w(f.coaches.offset)} from the outside edge, from ${w(f.coaches.after)} after the end of a curve to ${w(f.coaches.before)} before the next`],
+                    ["padding", `${w(f.padding.thick)} thick, nothing fixed within ${w(f.padding.clear)} of the edge`],
+                ];
+            }
+            if (f.kind === "short-track") {
+                return [
+                    ["oval", `a lap of ${w(f.lap)}: straights of ${w(f.straight)} between the centres of the curves, a track line of ${w(f.radius)} radius`],
+                    ["blocks", `${f.blocksPerCurve} in each curve, on a radius of ${w(f.blocks)}`],
+                    ["rink", `at least ${w(f.rink.length)} by ${w(f.rink.width)}`],
+                    ["tracks", `5 (${w(f.tracks.five.shift)} apart, starting lines ${w(f.tracks.five.lines)} apart) or 7 (${w(f.tracks.seven.shift)} and ${w(f.tracks.seven.lines)})`],
+                    ["starting positions", `${f.dots.count} dots every ${w(f.dots.step)}, from ${w(f.dots.from)} out from the inner side`],
+                ];
+            }
+            return [
+                ["rink", `${w(f.length.max)} by ${w(f.width.max)} if possible, at least ${w(f.length.min)} by ${w(f.width.min)}`],
+            ];
+        }
+        case "athletics": {
+            const f = athleticsOf(league);
+            return [
+                ["track", `two straights of ${w(f.straight)} and two bends of ${w(f.radius)} radius at the kerb`],
+                ["lanes", `${f.lanes.drawn} of ${w(f.lane)} (${f.lanes.min} to ${f.lanes.max})`],
+                ["running line", `${w(f.inner)} outside the kerb in lane 1, ${w(f.outer)} outside the line in the others`],
+                ["straight", `${f.straightLanes.min} to ${f.straightLanes.max} lanes of ${w(f.straightLane)}, a starting area of ${w(f.startArea)} and a run-out of ${w(f.runOut)}`],
+                ["banking", f.banking === null ? "none" : `${f.banking} degrees`],
+            ];
+        }
         case "handball": {
             const f = handballOf(league);
             return [
@@ -448,6 +634,61 @@ export function leagueFigures(league) {
                 ["goal", `${w(f.goalWidth)} wide and ${w(f.goalHeight)} high`],
             ];
         }
+        case "judo": {
+            const f = league.dimensions;
+            return [
+                ["contest area", `${w(convertLength(f.contest.min, "m", "ft"))} to ${w(convertLength(f.contest.max, "m", "ft"))} square (${f.contest.drawn} m drawn)`],
+                ["safety area", `at least ${w(convertLength(f.safety.min, "m", "ft"))} wide; at least ${w(convertLength(f.common, "m", "ft"))} between two areas`],
+                ["tatami", `${f.tatami.length} m by ${f.tatami.width} m by ${f.tatami.thickness * 100} cm`],
+                ["free zone", `at least ${f.freeZone * 100} cm round the competition area`],
+                ["platform", `${f.platform} m wider and longer than the tatami`],
+                ["start tape", f.marks === null ? "none" : `${f.marks.width * 100} cm by ${f.marks.length * 100} cm, ${f.marks.fromCentre} m from the centre`],
+            ];
+        }
+        case "karate": {
+            const f = league.dimensions;
+            return [
+                ["area", `${f.area} m square, measured from the outside`],
+                ["boundary band", f.band === 0 ? "none" : `the outer ${f.band} m in another colour`],
+                ["safety area", `${f.safety} m, and ${f.between} m between areas`],
+                ["start mats", f.startMats === null ? "none" : `${f.startMats.fromCentre} m from the centre`],
+                ["referee", `${f.referee} m from the boundary; each judge ${f.judges} m off a corner`],
+            ];
+        }
+        case "kendo": {
+            const f = league.dimensions;
+            return [
+                ["shiai-jo", `${f.side.min} m to ${f.side.max} m a side, wooden floor`],
+                ["lines", `${f.lineWidth.min * 100} cm to ${f.lineWidth.max * 100} cm, white`],
+                ["centre cross", `${f.cross.min * 100} cm to ${f.cross.max * 100} cm`],
+                ["kaishi-sen", `${f.startLine.length * 100} cm long, ${f.startLine.fromCentre} m from the centre`],
+                ["outside", `${f.outside} m kept clear`],
+            ];
+        }
+        case "sumo": {
+            const f = league.dimensions;
+            return [
+                ["platform", `${f.platform} m square, ${f.height.min * 100} cm to ${f.height.max * 100} cm high`],
+                ["ring", `${f.circle} m across, ${f.tawara.count} tawara (${f.tawara.tokuda} tokudawara)`],
+                ["shikiri-sen", `${f.shikiri.length * 100} cm long, ${f.shikiri.width * 100} cm wide, ${f.shikiri.apart * 100} cm apart`],
+            ];
+        }
+        case "kyudo": {
+            const f = league.dimensions;
+            return [
+                ["distance", `${f.distance} m from the shooting position to the target`],
+                ["target", `${f.target.diameter * 100} cm across, its centre ${f.target.centre * 100} cm up, tilted ${f.target.tilt} degrees`],
+                ["shooters", `${f.step.drawn} m apart (${f.step.min} m to ${f.step.max} m), ${f.honza} m from the shooting position to the honza`],
+                ["shajō", `${f.hall.depth} m deep, ${f.hall.side} m from the end shooters to the walls, ceiling ${f.ceiling} m`],
+            ];
+        }
+        case "dojo": {
+            const f = league.dimensions;
+            return [
+                ["tatami", `${f.mat.length} m by ${f.mat.width} m (${f.region.en})`],
+                ["area of a mat", `${Math.round(f.mat.length * f.mat.width * 1000) / 1000} square metres`],
+            ];
+        }
         default: {
             const d = diamondOf(league);
             const f = d.fence;

package/dist/lineup.codes.d.ts

@@ -0,0 +1,23 @@
+import type { Formation, FormationPosition, FormationSport, LineupPlayer } from "./team.types.ts";
+/** The positions a short code may stand for, by sport, in the order a player takes them: a code that is also an id of the formation is that place first. */
+export declare const LINEUP_CODES: Readonly<Record<FormationSport, Readonly<Record<string, readonly string[]>>>>;
+/** A code as the table has it: upper case, with no spaces, dots or hyphens. */
+export declare const codeOf: (pos: unknown) => string;
+/** The ids a player's code may stand for in a formation of a sport, best first: the id itself, then the table's. A second line's ids end in its number. */
+export declare function candidates(sport: FormationSport, player: LineupPlayer, ids: ReadonlySet<string>): string[];
+/** The places of a formation that a lineup may fill: the side on the surface and, beside it, the places it only lists. */
+export declare const spotsOf: (f: Formation) => FormationPosition[];
+/** Where each player of a lineup stands in a formation, by the index of the player; the places taken; and the players with none. */
+export interface Assignment {
+    /** The id of the position of each player, or undefined. */
+    of: (string | undefined)[];
+    placed: number;
+    /** How many took the place their own code names, which settles a tie between formations. */
+    exact: number;
+}
+/** Players to places. Those whose code is a place's id take it first, then the others take the first free place their code may stand for; a volleyball team turns by `rotation`. */
+export declare function assign(f: Formation, players: readonly LineupPlayer[], rotation?: number): Assignment;
+/** The formations that may hold a lineup on a surface, in table order. */
+export declare const formationsFor: (sports: readonly FormationSport[]) => Formation[];
+/** The formation that places the most of the players: the first of the table on a tie. */
+export declare function bestFormation(candidatesList: readonly Formation[], players: readonly LineupPlayer[], rotation?: number): Formation | undefined;

package/dist/lineup.codes.js

@@ -0,0 +1,122 @@
+// How a lineup finds a player's place: the short codes a team sheet uses (`CB`, `D`, `OF`, `PR`, the scorer's numbers 1 to 9) are matched to the ids of a formation's positions,
+// and each player takes the first free place of the codes that fit. Written for this package; the codes are the conventional ones of each sport and are listed in docs/team-shape.md.
+import { FORMATIONS } from "./formations.js";
+/** The positions a short code may stand for, by sport, in the order a player takes them: a code that is also an id of the formation is that place first. */
+export const LINEUP_CODES = Object.freeze({
+    soccer: {
+        GOALKEEPER: ["GK"], G: ["GK"],
+        CB: ["CB", "RCB", "LCB"], D: ["CB", "RCB", "LCB"], DF: ["CB", "RCB", "LCB"],
+        RB: ["RB", "RWB"], LB: ["LB", "LWB"], RWB: ["RWB", "RB"], LWB: ["LWB", "LB"],
+        DM: ["CDM", "RDM", "LDM"], CDM: ["CDM", "RDM", "LDM"], RDM: ["RDM", "CDM"], LDM: ["LDM", "CDM"],
+        CM: ["CM", "RCM", "LCM"], M: ["CM", "RCM", "LCM"], RCM: ["RCM", "CM"], LCM: ["LCM", "CM"],
+        AM: ["CAM", "RAM", "LAM"], CAM: ["CAM", "RAM", "LAM"], RAM: ["RAM", "CAM"], LAM: ["LAM", "CAM"],
+        RM: ["RM", "RW"], LM: ["LM", "LW"], RW: ["RW", "RM"], LW: ["LW", "LM"],
+        ST: ["ST", "RS", "LS"], CF: ["ST", "RS", "LS"], S: ["ST", "RS", "LS"], FW: ["ST", "RS", "LS", "RW", "LW"], RS: ["RS", "ST"], LS: ["LS", "ST"],
+    },
+    nhl: {
+        GOALIE: ["G"], GK: ["G"], D: ["LD", "RD"], W: ["LW", "RW"], F: ["C", "LW", "RW"],
+        G2: ["G"],
+    },
+    nba: { G: ["PG", "SG"], F: ["SF", "PF"], GF: ["SG", "SF"], FC: ["PF", "C"] },
+    nfl: {
+        WR: ["WR1", "WR2", "WR3"], RB: ["HB", "FB"], OG: ["LG", "RG"], OT: ["LT", "RT"], T: ["LT", "RT"], G: ["LG", "RG"],
+        DE: ["LDE", "RDE"], DT: ["LDT", "RDT", "NT"], NT: ["NT"], CB: ["LCB", "RCB"], S: ["FS", "SS"],
+        LB: ["MLB", "LLB", "RLB", "LOLB", "LILB", "RILB", "ROLB"], OLB: ["LOLB", "ROLB", "LLB", "RLB"], ILB: ["LILB", "RILB", "MLB"],
+    },
+    mlb: {
+        "1": ["P"], "2": ["C"], "3": ["1B"], "4": ["2B"], "5": ["3B"], "6": ["SS"], "7": ["LF"], "8": ["CF"], "9": ["RF"],
+        PITCHER: ["P"], CATCHER: ["C"], OF: ["LF", "CF", "RF"], IF: ["1B", "2B", "SS", "3B"], DESIGNATEDHITTER: ["DH"],
+    },
+    rugby: {
+        LHP: ["1"], PR: ["1", "3"], HK: ["2"], HO: ["2"], THP: ["3"], LK: ["4", "5"], LO: ["4", "5"], L: ["4", "5"], FL: ["6", "7"], BF: ["6"], OF: ["7"], N8: ["8"], NO8: ["8"],
+        SH: ["9"], FH: ["10"], SO: ["10"], IC: ["12"], OC: ["13"], CTB: ["12", "13"], C: ["12", "13"], W: ["11", "14"], WG: ["11", "14"], WTB: ["11", "14"], LW: ["11"], RW: ["14"], FB: ["15"],
+    },
+    afl: {
+        BP: ["BPL", "BPR"], HB: ["HBFL", "CHB", "HBFR"], HBF: ["HBFL", "HBFR"], W: ["WL", "WR"], HF: ["HFFL", "CHF", "HFFR"], HFF: ["HFFL", "HFFR"], FP: ["FPL", "FPR"],
+        R: ["RUC"], RK: ["RUC"], RUCK: ["RUC"], RUCKROVER: ["RR"], ROVER: ["ROV"], RO: ["ROV"],
+    },
+    cricket: {
+        BOWLER: ["BWL"], KEEPER: ["WK"], SL: ["SL1", "SL2", "SL3"], SLIP: ["SL1", "SL2", "SL3"], GULLY: ["GU"], POINT: ["PT"], COVER: ["CV"], MIDOFF: ["MO"], MIDON: ["MN"],
+        MIDWICKET: ["MW"], SQUARELEG: ["SQ"], FINELEG: ["FL"], THIRDMAN: ["TM"], LONGOFF: ["LO"], LONGON: ["LN"], DEEPCOVER: ["DC"], DEEPMIDWICKET: ["DM"],
+    },
+    volleyball: { "1": ["P1"], "2": ["P2"], "3": ["P3"], "4": ["P4"], "5": ["P5"], "6": ["P6"] },
+    handball: { G: ["GK"], P: ["PV"], PIVOT: ["PV"], LINE: ["PV"], W: ["LW", "RW"], B: ["LB", "CB", "RB"] },
+    waterpolo: { G: ["GK"], W: ["LW", "RW"], D: ["LD", "RD"], FLAT: ["LD", "RD"], HS: ["CF"], HOLE: ["CF"], H: ["CF"], PT: ["CB"], POINT: ["CB"] },
+    fieldhockey: {
+        G: ["GK"], FB: ["RB", "LB"], CB: ["CB", "RCB", "LCB"], D: ["CB", "RCB", "LCB"], M: ["CM", "RCM", "LCM"], CM: ["CM", "RCM", "LCM"], RM: ["RM", "RW"], LM: ["LM", "LW"],
+        F: ["CF", "RW", "LW"], ST: ["CF"], RW: ["RW", "RM"], LW: ["LW", "LM"],
+    },
+    netball: {},
+});
+/** A code as the table has it: upper case, with no spaces, dots or hyphens. */
+export const codeOf = (pos) => String(typeof pos === "number" || typeof pos === "string" ? pos : "").trim().toUpperCase().replace(/[\s.\-_]+/g, "");
+/** The ids a player's code may stand for in a formation of a sport, best first: the id itself, then the table's. A second line's ids end in its number. */
+export function candidates(sport, player, ids) {
+    const own = typeof player.pos === "string" ? player.pos.trim() : String(player.pos);
+    const code = codeOf(player.pos);
+    const line = typeof player.line === "number" && Number.isInteger(player.line) && player.line > 1 ? String(player.line) : "";
+    const listed = Object.prototype.hasOwnProperty.call(LINEUP_CODES[sport], code) ? LINEUP_CODES[sport][code] : [];
+    const base = [own, code, ...listed];
+    const wanted = line === "" ? base : base.map((id) => `${id}${line}`);
+    return [...new Set(wanted)].filter((id) => ids.has(id));
+}
+/** The places of a formation that a lineup may fill: the side on the surface and, beside it, the places it only lists. */
+export const spotsOf = (f) => [...f.positions, ...(f.extra ?? [])];
+/** Players to places. Those whose code is a place's id take it first, then the others take the first free place their code may stand for; a volleyball team turns by `rotation`. */
+export function assign(f, players, rotation = 1) {
+    const ids = new Set(spotsOf(f).map((p) => p.id));
+    const turned = f.sport === "volleyball" ? players.map((p) => zoneAfter(p, rotation)) : players;
+    const of = new Array(turned.length).fill(undefined);
+    const taken = new Set();
+    const lists = turned.map((p) => (typeof p === "object" && p !== null ? candidates(f.sport, p, ids) : []));
+    // The exact codes first, so that a CB on the sheet cannot take the place an RCB has asked for by name.
+    let exact = 0;
+    turned.forEach((p, i) => {
+        if (typeof p !== "object" || p === null)
+            return;
+        const line = typeof p.line === "number" && p.line > 1 ? String(p.line) : "";
+        const own = lists[i].find((id) => id === `${typeof p.pos === "string" ? p.pos.trim() : String(p.pos)}${line}` || id === `${codeOf(p.pos)}${line}`);
+        if (own !== undefined && !taken.has(own)) {
+            of[i] = own;
+            taken.add(own);
+            exact += 1;
+        }
+    });
+    turned.forEach((_, i) => {
+        if (of[i] !== undefined)
+            return;
+        const free = lists[i].find((id) => !taken.has(id));
+        if (free !== undefined) {
+            of[i] = free;
+            taken.add(free);
+        }
+    });
+    return { of, placed: of.filter((id) => id !== undefined).length, exact };
+}
+/** A volleyball player after the rotations: each moves one place clockwise, from 2 to 1, 1 to 6, 6 to 5, 5 to 4, 4 to 3 and 3 to 2. */
+function zoneAfter(p, rotation) {
+    if (typeof p !== "object" || p === null)
+        return p;
+    const code = codeOf(p.pos).replace(/^P/, "");
+    if (!/^[1-6]$/.test(code))
+        return p;
+    const turns = Number.isInteger(rotation) && rotation >= 1 ? (rotation - 1) % 6 : 0;
+    const zone = ((((Number(code) - 1 - turns) % 6) + 6) % 6) + 1;
+    return { ...p, pos: `P${zone}` };
+}
+/** The formations that may hold a lineup on a surface, in table order. */
+export const formationsFor = (sports) => Object.values(FORMATIONS).filter((f) => sports.includes(f.sport));
+/** The formation that places the most of the players: the first of the table on a tie. */
+export function bestFormation(candidatesList, players, rotation = 1) {
+    let best;
+    let score = -1;
+    for (const f of candidatesList) {
+        const a = assign(f, players, rotation);
+        const n = a.placed * 1000 + a.exact;
+        if (n > score) {
+            best = f;
+            score = n;
+        }
+    }
+    return best;
+}

package/dist/logo.d.ts

@@ -0,0 +1,25 @@
+/** What a caller says about the team an emblem stands for: its colours and letters, so a crest id takes them; and the theme of the drawing it goes in. */
+export interface EmblemContext {
+    color?: string;
+    accent?: string;
+    initials?: string;
+    theme?: "inherit" | "auto" | "light" | "dark";
+}
+/**
+ * The SVG document for a value that names an emblem (`"trophy:cup"`, `"crest:shield"`, `"sport:nhl/line"`), or `undefined` when it does not or when no renderer is plugged in. Drawn for an image: the theme is `auto` unless
+ * the context says otherwise. A crest takes the context's colours and letters.
+ */
+export declare function emblemDocument(value: unknown, context?: EmblemContext): string | undefined;
+/**
+ * A logo as it may be written into an image's `href`, or `undefined`. An `https:` or `http:` address, a relative path, an image `data:` address, an SVG document as text (written as an image, which cannot
+ * run scripts), or, with a renderer of emblems plugged in, the id of an emblem (`"trophy:cup"`, `"medal:gold"`, `"sport:nhl"`, `"crest:shield"`, a trophy or award by its short name such as `"cup"`, with `/line`
+ * for the outline style), drawn for an image with the outline in dark or pale ink by the device's setting. The second argument gives a crest the team's colours and letters. With a renderer, a name that is
+ * an emblem's id is the emblem, not a file of that name: write `./cup` for the file. Without one, an id is an address like any other, and `"trophy:cup"` is refused.
+ * @example
+ * ```ts
+ * import { safeLogo } from "@johnmorrisdotca/kyogijo-stadiums";
+ * console.log(safeLogo("https://example.com/gulls.svg"), safeLogo("javascript:alert(1)"));
+ * // https://example.com/gulls.svg undefined
+ * ```
+ */
+export declare function safeLogo(value: unknown, context?: EmblemContext): string | undefined;

package/dist/logo.js

@@ -0,0 +1,47 @@
+// The one path every logo, flag, emblem and mark takes into a drawing: an address, an image `data:` address, an SVG document as text, or, when a renderer of ready-made emblems is plugged in
+// (`useEmblems`, or the `emblems` option), the id of one (`"trophy:cup"`, `"crest:shield"`, `"sport:hockey/line"`). The result is an address that may be written into an image's `href`, or `undefined`.
+import { safePicture } from "./colour.js";
+import { GROUPED_ID, emblemRenderer, renderedEmblem } from "./emblems-source.js";
+let told = false;
+/** Once, in development: an id with its group was given and nothing is plugged in to draw it. */
+function hint(value) {
+    if (told || typeof value !== "string" || !GROUPED_ID.test(value.trim()))
+        return;
+    const process = globalThis.process;
+    if (process?.env?.NODE_ENV === "production")
+        return;
+    told = true;
+    console.warn(`[kyogijo-stadiums] "${value.trim().slice(0, 40)}" is the id of an emblem, but no emblem renderer is plugged in, so it was ignored. Plug in Dougu Sports once: import { renderEmblem } from "@johnmorrisdotca/dougu-sports/emblems"; useEmblems(renderEmblem); (or pass emblems: renderEmblem). See https://johnmorrisdotca.github.io/kyogijo-stadiums/docs/emblems.html`);
+}
+/**
+ * The SVG document for a value that names an emblem (`"trophy:cup"`, `"crest:shield"`, `"sport:nhl/line"`), or `undefined` when it does not or when no renderer is plugged in. Drawn for an image: the theme is `auto` unless
+ * the context says otherwise. A crest takes the context's colours and letters.
+ */
+export function emblemDocument(value, context) {
+    const crest = typeof value === "string" && value.trim().startsWith("crest:");
+    return renderedEmblem(value, {
+        theme: context?.theme ?? "auto",
+        ...(crest ? { tint: context?.color, accent: context?.accent, initials: context?.initials } : {}),
+    });
+}
+/**
+ * A logo as it may be written into an image's `href`, or `undefined`. An `https:` or `http:` address, a relative path, an image `data:` address, an SVG document as text (written as an image, which cannot
+ * run scripts), or, with a renderer of emblems plugged in, the id of an emblem (`"trophy:cup"`, `"medal:gold"`, `"sport:nhl"`, `"crest:shield"`, a trophy or award by its short name such as `"cup"`, with `/line`
+ * for the outline style), drawn for an image with the outline in dark or pale ink by the device's setting. The second argument gives a crest the team's colours and letters. With a renderer, a name that is
+ * an emblem's id is the emblem, not a file of that name: write `./cup` for the file. Without one, an id is an address like any other, and `"trophy:cup"` is refused.
+ * @example
+ * ```ts
+ * import { safeLogo } from "@johnmorrisdotca/kyogijo-stadiums";
+ * console.log(safeLogo("https://example.com/gulls.svg"), safeLogo("javascript:alert(1)"));
+ * // https://example.com/gulls.svg undefined
+ * ```
+ */
+export function safeLogo(value, context) {
+    const emblem = emblemDocument(value, context);
+    if (emblem !== undefined)
+        return safePicture(emblem);
+    const picture = safePicture(value);
+    if (picture === undefined && emblemRenderer() === undefined)
+        hint(value);
+    return picture;
+}

package/dist/look.d.ts

@@ -1,10 +1,10 @@
 import type { LookName, Sport } from "./types.ts";
 /** The parts of a palette, each a custom property of the stylesheet. */
-export type PaletteKey = "ink" | "line" | "apron" | "surface" | "alt" | "zone" | "boards" | "red" | "blue" | "dirt" | "foul" | "infield" | "crease" | "key" | "court" | "post" | "pylon" | "rgo" | "rgm" | "rgi" | "rgb" | "hog" | "hack" | "fgz" | "pebble" | "free" | "net" | "area";
+export type PaletteKey = "ink" | "line" | "apron" | "surface" | "alt" | "zone" | "boards" | "red" | "blue" | "dirt" | "foul" | "infield" | "crease" | "key" | "court" | "post" | "pylon" | "rgo" | "rgm" | "rgi" | "rgb" | "hog" | "hack" | "fgz" | "pebble" | "free" | "net" | "area" | "ropeg" | "ropeb" | "ropey" | "roper" | "ropew" | "pad" | "block" | "track" | "sand" | "mat" | "water" | "concrete" | "trackpad" | "markY" | "markB" | "markG" | "markR";
 /** Colours by part. */
 export type Palette = Partial<Record<PaletteKey, string>>;
 /** The surfaces that are painted alike: football's three fields are one. */
-export type Group = "football" | "nhl" | "nba" | "mlb" | "soccer" | "curling" | "net";
+export type Group = "football" | "nhl" | "nba" | "mlb" | "soccer" | "curling" | "net" | "pool" | "athletics";
 /** One mode of a look: a palette for every sport, and what a group of sports changes in it. */
 export interface Mode {
     base: Palette;
@@ -26,7 +26,7 @@ export declare const groupOf: (sport: Sport | string) => Group | undefined;
  * import { LOOKS, drawKyogijo } from "@johnmorrisdotca/kyogijo-stadiums";
  * const svg = drawKyogijo({ sport: "nhl", look: "chalkboard" });
  * console.log(Object.keys(LOOKS).length, svg.includes('data-palette="chalkboard"'));
- * // 7 true
+ * // 8 true
  * ```
  */
 export declare const LOOKS: Readonly<Record<LookName, Look>>;