@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/restyle.js

@@ -8,7 +8,7 @@ const LINES = new Set(["ky-line", "ky-red", "ky-blue", "ky-band", "ky-crease"]);
 /** The dashes in the centre line of a rink are lines too, but they are dashes already. */
 const WIDTH = new Set([...LINES, "ky-dash"]);
 /** The classes of marks painted as a fill, which take an opacity. */
-const FILLS = new Set(["ky-fill-line", "ky-red-fill", "ky-blue-fill", "ky-num"]);
+const FILLS = new Set(["ky-fill-line", "ky-wall-line", "ky-red-fill", "ky-blue-fill", "ky-num"]);
 const finitePositive = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
 /**
  * The look of the lines the options ask for, or `undefined` when they ask for none of it. A width is a multiple of the width the lines are drawn at (`2`,

package/dist/score.js

@@ -142,6 +142,27 @@ export function glyph(sport) {
         case "tabletennis":
             // A table: the net across it and the centre line.
             return "M-16 -8H16V8H-16ZM0 -10V10M-16 0H16";
+        case "padel":
+            // A court: the net, the service lines and the central service line.
+            return "M-18 -10H18V10H-18ZM0 -10V10M-12.5 -10V10M12.5 -10V10M-12.5 0H12.5";
+        case "squash":
+            // A court, the front wall at the left: the short line, the half court line and the two service boxes.
+            return "M-18 -10H18V10H-18ZM2.3 -10V10M2.3 0H18M8.2 -10V-5H2.3M8.2 10V5H2.3";
+        case "racquetball":
+            // A court, the front wall at the left: the short line, the service line and the broken receiving line.
+            return "M-18 -10H18V10H-18ZM0 -10V10M-4.5 -10V10M4.5 -10V-8M4.5 -6V-4M4.5 -2V0M4.5 2V4M4.5 6V8";
+        case "sepaktakraw":
+            // A court: the centre line, the quarter circles at its ends and the service circles.
+            return "M-18 -10H18V10H-18ZM0 -10V10M-3 -10A3 3 0 0 0 0 -7A3 3 0 0 0 3 -10M-3 10A3 3 0 0 1 0 7A3 3 0 0 1 3 10M-12.9 0A1.5 1.5 0 1 0 -9.9 0A1.5 1.5 0 1 0 -12.9 0M9.9 0A1.5 1.5 0 1 0 12.9 0A1.5 1.5 0 1 0 9.9 0";
+        case "teqball":
+            // A court: the halfway line and the service lines, and the table.
+            return "M-18 -10H18V10H-18ZM0 -10V10M-7.9 -10V10M7.9 -10V10M-3.4 -1.3H3.4V1.3H-3.4Z";
+        case "roundnet":
+            // A court: the serving line and the no hit zone line round the set, and the marks at the four service positions.
+            return "M-10 -10H10V10H-10ZM-8 0A8 8 0 1 0 8 0A8 8 0 1 0 -8 0M-2.8 0A2.8 2.8 0 1 0 2.8 0A2.8 2.8 0 1 0 -2.8 0M-1.2 0A1.2 1.2 0 1 0 1.2 0A1.2 1.2 0 1 0 -1.2 0M-9 0H-7M7 0H9M0 -9V-7M0 7V9";
+        case "netball":
+            // A court: the transverse lines, the centre circle and the goal circles.
+            return "M-18 -10H18V10H-18ZM-6 -10V10M6 -10V10M-1 0A1 1 0 1 0 1 0A1 1 0 1 0 -1 0M-18 -6.4A6.4 6.4 0 0 1 -18 6.4M18 -6.4A6.4 6.4 0 0 0 18 6.4";
         case "lacrosse":
             // A field: the centre line, the goal circles and the restraining lines.
             return "M-18 -10H18V10H-18ZM0 -10V10M-12 0A3 3 0 1 0 -6 0A3 3 0 1 0 -12 0M12 0A3 3 0 1 0 6 0A3 3 0 1 0 12 0M-7 -10V10M7 -10V10";
@@ -163,6 +184,24 @@ export function glyph(sport) {
         case "handball":
             // A court: the centre line, and the goal areas with their arcs.
             return "M-18 -10H18V10H-18ZM0 -10V10M-18 -6A6 6 0 0 1 -12 0A6 6 0 0 1 -18 6M18 -6A6 6 0 0 0 12 0A6 6 0 0 0 18 6";
+        case "swimming":
+            // A pool: the lane ropes, and the cross lines at the ends of the lane markings.
+            return "M-18 -10H18V10H-18ZM-18 -5H18M-18 0H18M-18 5H18M-14 -7.5V-2.5M14 -7.5V-2.5M-14 2.5V7.5M14 2.5V7.5";
+        case "waterpolo":
+            // A field: the half distance line, the 2 and 6 metre lines, and a goal at each end.
+            return "M-18 -10H18V10H-18ZM0 -10V10M-14 -10V10M14 -10V10M-18 -3H-21V3H-18M18 -3H21V3H18M-9 -10V10M9 -10V10";
+        case "diving":
+            // A well: the boards along one wall, and the lines across the well.
+            return "M-18 -10H18V10H-18ZM-18 -7H-9V-5H-18ZM-18 -1H-12V1H-18ZM-18 5H-9V7H-18ZM0 -9V9M6 -9V9M12 -9V9";
+        case "artisticswimming":
+            // An area: the lines along the floor, and the judges' platform on one side.
+            return "M-18 -10H18V10H-18ZM-18 -5H18M-18 0H18M-18 5H18M-10 -13H10";
+        case "skating":
+            // A rink: the oval of a track inside the boards, and the finishing line.
+            return "M-18 -10H18V10H-18ZM-9 -6H9A6 6 0 0 1 9 6H-9A6 6 0 0 1 -9 -6ZM-9 -3.5H9A3.5 3.5 0 0 1 9 3.5H-9A3.5 3.5 0 0 1 -9 -3.5ZM4 3.5V10";
+        case "athletics":
+            // A track: the oval's outer edge, a lane line and the kerb, and the finish line across the straight.
+            return "M-9 -10H9A10 10 0 0 1 9 10H-9A10 10 0 0 1 -9 -10ZM-9 -8.2H9A8.2 8.2 0 0 1 9 8.2H-9A8.2 8.2 0 0 1 -9 -8.2ZM-9 -6.4H9A6.4 6.4 0 0 1 9 6.4H-9A6.4 6.4 0 0 1 -9 -6.4ZM9 6.4V10";
     }
 }
 /** The state each of two scores puts its team in. */
@@ -171,6 +210,12 @@ export function stateOf(winner, role) {
         return "none";
     return winner === role ? "win" : "lose";
 }
+/** The least gap between a team's code and its score in the badge, and the least size of the code and of the score before the flag is left out. */
+const BADGE_GAP = 10;
+const BADGE_MEASURE_SCORE = 1.12;
+const BADGE_MEASURE_CODE = 1.2;
+const BADGE_ABBR_LEAST = 12;
+const BADGE_SCORE_LEAST = 16;
 /** The badge: one strip, [logo abbreviation score] [picture and status] [score abbreviation logo]. */
 export function badgeMarkup(left, right, o) {
     const W = 440;
@@ -183,18 +228,38 @@ export function badgeMarkup(left, right, o) {
         const isLeft = team.side === "left";
         const logoSize = 40;
         const logoX = isLeft ? 12 : W - 12 - logoSize;
-        const textStart = isLeft ? (team.logo === undefined ? 14 : 60) : W - (team.logo === undefined ? 14 : 60);
         const scoreEdge = isLeft ? block - 14 : W - block + 14;
-        const scoreSize = Math.min(32, (block * 0.42) / Math.max(1, textWidth(team.score)));
-        const room = Math.abs(scoreEdge - textStart) - textWidth(team.score) * scoreSize - 8;
-        const abbrSize = Math.max(8, Math.min(22, room / Math.max(1, textWidth(team.abbr))));
+        // The code and the score each keep to their own room, with a gap between them: the score is measured, and when the two do not fit the code shrinks to the least that reads, then the score does,
+        // and then the flag is left out to give them its room. A short score in a roomy block is laid out as it always was.
+        const fit = (withLogo) => {
+            const textStart = isLeft ? (withLogo ? 60 : 14) : W - (withLogo ? 60 : 14);
+            const avail = Math.abs(scoreEdge - textStart);
+            // The measure is an estimate, under what a bold face draws (by a tenth for digits, a fifth for capitals): the layout allows for that.
+            const ws = Math.max(1, textWidth(team.score) * BADGE_MEASURE_SCORE);
+            const wa = Math.max(1, textWidth(team.abbr) * BADGE_MEASURE_CODE);
+            let scoreSize = Math.min(32, (block * 0.42) / ws);
+            let abbrSize = Math.min(22, (avail - ws * scoreSize - BADGE_GAP) / wa);
+            if (abbrSize < BADGE_ABBR_LEAST) {
+                abbrSize = BADGE_ABBR_LEAST;
+                scoreSize = Math.min(scoreSize, (avail - BADGE_GAP - abbrSize * wa) / ws);
+            }
+            return { textStart, scoreSize, abbrSize, ok: scoreSize >= BADGE_SCORE_LEAST };
+        };
+        const withLogo = team.logo !== undefined;
+        let laid = fit(withLogo);
+        const logoShown = withLogo && (laid.ok || !fit(false).ok);
+        if (withLogo && !logoShown)
+            laid = fit(false);
+        const { textStart } = laid;
+        const scoreSize = Math.max(laid.scoreSize, 8);
+        const abbrSize = Math.max(laid.abbrSize, 8);
         // The hammer: a small stone in the corner of the team's block.
         if (team.hammer === true)
             out += el("g", { class: `ky-badge-hammer ky-badge-hammer-${team.side}`, transform: `translate(${isLeft ? block - 11 : W - block + 11} 11)` }, el("circle", { class: "ky-hammer", r: 6 }) + el("circle", { class: "ky-hammer-in", r: 2.6 }));
         // The ball of the team that is serving, in the same corner.
         if (team.serving === true)
             out += el("g", { transform: `translate(${isLeft ? block - 11 : W - block + 11} 11)` }, el("circle", { class: "ky-serve", r: 6 }) + el("path", { class: "ky-serve-seam", d: "M-4.7 -1.8Q0 1.8 4.7 -1.8", "stroke-width": 0.9 }));
-        out += el("g", { class: `ky-badge-team ky-badge-${team.side} ky-${team.state}`, part: part(o.parts, `team ${team.role}`) }, (team.logo === undefined
+        out += el("g", { class: `ky-badge-team ky-badge-${team.side} ky-${team.state}`, part: part(o.parts, `team ${team.role}`) }, (!logoShown || team.logo === undefined
             ? ""
             : team.round === true
                 ? roundMarkup({ id: `${o.id ?? "ky"}-mk-${team.role}`, cx: logoX + logoSize / 2, cy: 12 + logoSize / 2, r: logoSize / 2, href: team.logo, fit: team.fit, ring: 2 })

package/dist/sheet.d.ts

@@ -9,6 +9,9 @@ export interface SheetPlan {
     guardZone: boolean;
     show: SheetShow;
     end: "left" | "right";
+    /** `show: "folded"`: what each enlarged panel holds, and the shape of the frame it fills. */
+    panels: "half" | "house";
+    fit: number;
 }
 /**
  * The sheet the options ask for. A `league` picks the rulebook (World Curling's by default); `sheet.length` and `sheet.width` are in `units`

package/dist/sheet.js

@@ -5,7 +5,7 @@ import { CURLING_LEAGUES } from "./leagues/curling.js";
 import { lengthUnit } from "./common.js";
 import { parseRange } from "./ranges.names.js";
 import { convertLength } from "./units.js";
-const SHOWS = ["sheet", "half", "house"];
+const SHOWS = ["sheet", "half", "house", "folded"];
 const FEET = (feet) => String(Math.round(feet * 100) / 100);
 /**
  * The sheet the options ask for. A `league` picks the rulebook (World Curling's by default); `sheet.length` and `sheet.width` are in `units`
@@ -33,6 +33,10 @@ export function sheetFor(o) {
     const ranged = o.sport === "curling" ? parseRange(o) : undefined;
     const named = ranged !== undefined && ranged.kind === "name" ? ranged : undefined;
     const show = named !== undefined ? named.name : SHOWS.includes(asked.show) ? asked.show : "sheet";
-    const end = named?.asked !== undefined ? named.asked : asked.end === "right" ? "right" : "left";
-    return { league, spec: { ...base, length, width }, pebble: asked.pebble === true, guardZone: asked.guardZone === true, show, end };
+    const end = named?.asked !== undefined ? named.asked : asked.end === "right" || asked.end === "bottom" ? "right" : "left";
+    const panels = asked.panels === "house" ? "house" : "half";
+    if (asked.fit !== undefined && !(typeof asked.fit === "number" && asked.fit >= 0.5 && asked.fit <= 2))
+        throw new RangeError(`The folded sheet's fit is its width over its height, 0.5 to 2: ${String(asked.fit)} is not`);
+    const fit = asked.fit ?? 1;
+    return { league, spec: { ...base, length, width }, pebble: asked.pebble === true, guardZone: asked.guardZone === true, show, end, panels, fit };
 }

package/dist/skating/describe.d.ts

@@ -0,0 +1,7 @@
+import type { Language, SurfaceOptions } from "../types.ts";
+/** The words of a race in a language. */
+export declare const raceName: (id: string, language: Language) => string;
+/** The sentence about the rink, as a fragment: "a 400 m speed skating track with two lanes of 4 m...". */
+export declare function skatingAbout(o: Pick<SurfaceOptions, "sport" | "league" | "skating">, language: Language): string;
+/** The sentences that follow it: the races marked, the furniture of a figure skating rink and the close-up. Each starts after a gap. */
+export declare function skatingSentences(o: Pick<SurfaceOptions, "sport" | "league" | "skating" | "range">, language: Language): string;

package/dist/skating/describe.js

@@ -0,0 +1,44 @@
+// What a skating drawing says of itself: its sentence about the rink, and what the options mark on it. Cheap (it reads the options, not the plan), so that a title and a description cost nothing.
+import { fill, KYOGIJO_STRINGS } from "../strings.js";
+import { raceById } from "./events.js";
+import { furnitureOf, racesOf, skatingLeague } from "./plan.js";
+import { longOval } from "./track.js";
+/** The words of a race in a language. */
+export const raceName = (id, language) => raceById(id)?.name[language] ?? id;
+/** The sentence about the rink, as a fragment: "a 400 m speed skating track with two lanes of 4 m...". */
+export function skatingAbout(o, language) {
+    const words = KYOGIJO_STRINGS[language].skating;
+    const league = skatingLeague(o);
+    const d = league.dimensions;
+    if (d.kind === "long-track") {
+        const oval = longOval(o.skating?.innerRadius, o.skating?.laneWidth, d);
+        return fill(words.longTrack, { radius: oval.a, outer: oval.w2, straight: Math.round(oval.straight * 100) / 100 });
+    }
+    if (d.kind === "short-track")
+        return fill(words.shortTrack, { length: o.skating?.rink?.length ?? d.rink.length, width: o.skating?.rink?.width ?? d.rink.width, tracks: o.skating?.tracks ?? 5 });
+    return fill(words.figure, { length: o.skating?.rink?.length ?? d.length.drawn, width: o.skating?.rink?.width ?? d.width.drawn });
+}
+/** The sentences that follow it: the races marked, the furniture of a figure skating rink and the close-up. Each starts after a gap. */
+export function skatingSentences(o, language) {
+    const words = KYOGIJO_STRINGS[language].skating;
+    const { gap } = KYOGIJO_STRINGS[language].said;
+    const sep = KYOGIJO_STRINGS[language].layers.listSep;
+    const discipline = skatingLeague(o).dimensions.kind;
+    const out = [];
+    if (discipline === "figure") {
+        const furniture = furnitureOf(o.skating);
+        if (furniture.length > 0)
+            out.push(fill(words.furniture, { list: furniture.map((f) => words.furnitureNames[f]).join(sep) }));
+    }
+    else {
+        const races = racesOf(o.skating, discipline);
+        if (races.length > 0)
+            out.push(fill(words.races, { list: races.map((r) => raceName(r, language)).join(sep) }));
+    }
+    const range = typeof o.range === "string" ? o.range : typeof o.range === "object" && o.range !== null && "name" in o.range ? o.range.name : undefined;
+    if (range === "start" && discipline !== "figure")
+        out.push(fill(words.start, { race: raceName(o.skating?.start ?? "500m", language) }));
+    if (range === "finish" && discipline !== "figure")
+        out.push(words.finish);
+    return out.map((t) => `${gap}${t}`).join("");
+}

package/dist/skating/events.d.ts

@@ -0,0 +1,24 @@
+import type { LongTrackRace, RaceInfo, ShortTrackRace, SkatingRace } from "./types.ts";
+/** The races of the long track, in the order a menu lists them. The mass start is 16 laps (6400 m); the team pursuit and the team sprint are marked by their lines in the middle of the straights. */
+export declare const LONG_TRACK_RACES: readonly RaceInfo[];
+/**
+ * The races of the short track: the individual 500, 1000 and 1500 m, the 3000 m of the World Cup, and the relays: the women's 3000 m, the men's 5000 m and the mixed 2000 m (Rule 281.1a, which gives the
+ * distances of the ISU Championships; the diagram of the tracks gives the laps of each distance).
+ */
+export declare const SHORT_TRACK_RACES: readonly RaceInfo[];
+/** Every race of both tracks, once by id. */
+export declare const RACES: readonly RaceInfo[];
+export declare const LONG_TRACK_RACE_IDS: readonly LongTrackRace[];
+export declare const SHORT_TRACK_RACE_IDS: readonly ShortTrackRace[];
+export declare const RACE_IDS: readonly SkatingRace[];
+/** A race by its id, or `undefined`. */
+export declare const raceById: (id: unknown) => RaceInfo | undefined;
+/** The kinds of element of a figure skating programme a mark can stand for. */
+export declare const ELEMENT_KINDS: readonly ["jump", "spin", "step-sequence", "choreographic-sequence", "lift", "spiral", "twizzle", "death-spiral", "throw"];
+export type ElementKind = (typeof ELEMENT_KINDS)[number];
+/** The words of a kind of element. */
+export declare const ELEMENT_NAMES: Readonly<Record<ElementKind, {
+    en: string;
+    ja: string;
+    fr: string;
+}>>;

package/dist/skating/events.js

@@ -0,0 +1,47 @@
+const race = (r) => Object.freeze(r);
+/** The races of the long track, in the order a menu lists them. The mass start is 16 laps (6400 m); the team pursuit and the team sprint are marked by their lines in the middle of the straights. */
+export const LONG_TRACK_RACES = Object.freeze([
+    race({ id: "500m", distance: 500, name: { en: "500 m", ja: "500m", fr: "500\u00a0m" } }),
+    race({ id: "1000m", distance: 1000, name: { en: "1000 m", ja: "1000m", fr: "1000\u00a0m" } }),
+    race({ id: "1500m", distance: 1500, name: { en: "1500 m", ja: "1500m", fr: "1500\u00a0m" } }),
+    race({ id: "3000m", distance: 3000, name: { en: "3000 m", ja: "3000m", fr: "3000\u00a0m" } }),
+    race({ id: "5000m", distance: 5000, name: { en: "5000 m", ja: "5000m", fr: "5000\u00a0m" } }),
+    race({ id: "10000m", distance: 10000, name: { en: "10,000 m", ja: "10000m", fr: "10\u00a0000\u00a0m" } }),
+    race({ id: "mass-start", distance: 6400, name: { en: "Mass start", ja: "マススタート", fr: "Départ groupé" } }),
+    race({ id: "team-pursuit", distance: 3200, name: { en: "Team pursuit", ja: "チームパシュート", fr: "Poursuite par équipes" } }),
+    race({ id: "team-sprint", distance: 1200, name: { en: "Team sprint", ja: "チームスプリント", fr: "Sprint par équipes" } }),
+]);
+/**
+ * The races of the short track: the individual 500, 1000 and 1500 m, the 3000 m of the World Cup, and the relays: the women's 3000 m, the men's 5000 m and the mixed 2000 m (Rule 281.1a, which gives the
+ * distances of the ISU Championships; the diagram of the tracks gives the laps of each distance).
+ */
+export const SHORT_TRACK_RACES = Object.freeze([
+    race({ id: "500m", distance: 500, name: { en: "500 m", ja: "500m", fr: "500\u00a0m" } }),
+    race({ id: "1000m", distance: 1000, name: { en: "1000 m", ja: "1000m", fr: "1000\u00a0m" } }),
+    race({ id: "1500m", distance: 1500, name: { en: "1500 m", ja: "1500m", fr: "1500\u00a0m" } }),
+    race({ id: "3000m", distance: 3000, name: { en: "3000 m", ja: "3000m", fr: "3000\u00a0m" } }),
+    race({ id: "3000m-relay", distance: 3000, name: { en: "3000 m relay", ja: "3000mリレー", fr: "Relais 3000\u00a0m" } }),
+    race({ id: "5000m-relay", distance: 5000, name: { en: "5000 m relay", ja: "5000mリレー", fr: "Relais 5000\u00a0m" } }),
+    race({ id: "2000m-mixed-relay", distance: 2000, name: { en: "2000 m mixed relay", ja: "2000m混合リレー", fr: "Relais mixte 2000\u00a0m" } }),
+]);
+/** Every race of both tracks, once by id. */
+export const RACES = Object.freeze([...LONG_TRACK_RACES, ...SHORT_TRACK_RACES.filter((r) => !LONG_TRACK_RACES.some((l) => l.id === r.id))]);
+export const LONG_TRACK_RACE_IDS = Object.freeze(LONG_TRACK_RACES.map((r) => r.id));
+export const SHORT_TRACK_RACE_IDS = Object.freeze(SHORT_TRACK_RACES.map((r) => r.id));
+export const RACE_IDS = Object.freeze(RACES.map((r) => r.id));
+/** A race by its id, or `undefined`. */
+export const raceById = (id) => RACES.find((r) => r.id === id);
+/** The kinds of element of a figure skating programme a mark can stand for. */
+export const ELEMENT_KINDS = Object.freeze(["jump", "spin", "step-sequence", "choreographic-sequence", "lift", "spiral", "twizzle", "death-spiral", "throw"]);
+/** The words of a kind of element. */
+export const ELEMENT_NAMES = Object.freeze({
+    jump: { en: "Jump", ja: "ジャンプ", fr: "Saut" },
+    spin: { en: "Spin", ja: "スピン", fr: "Pirouette" },
+    "step-sequence": { en: "Step sequence", ja: "ステップシークエンス", fr: "Séquence de pas" },
+    "choreographic-sequence": { en: "Choreographic sequence", ja: "コレオシークエンス", fr: "Séquence chorégraphique" },
+    lift: { en: "Lift", ja: "リフト", fr: "Levée" },
+    spiral: { en: "Spiral", ja: "スパイラル", fr: "Spirale" },
+    twizzle: { en: "Twizzle", ja: "ツイズル", fr: "Twizzle" },
+    "death-spiral": { en: "Death spiral", ja: "デススパイラル", fr: "Spirale de la mort" },
+    throw: { en: "Throw jump", ja: "スロージャンプ", fr: "Saut lancé" },
+});

package/dist/skating/figure.d.ts

@@ -0,0 +1,24 @@
+import { type FigureRinkFigures } from "../leagues/skating.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+import type { SkatingFurniture } from "./types.ts";
+/** The rink: its length and width. */
+export interface FigureRink {
+    length: number;
+    width: number;
+}
+/** The furniture of a figure skating rink, in painter's order. */
+export declare const FURNITURE: readonly SkatingFurniture[];
+/** The seats of a panel of judges, side by side at the rinkboard: nine, as at the Olympic Winter Games (ours: the Rules fix the number elsewhere), 1 m apart. */
+export declare const JUDGES = 9;
+/** Where the furniture stands outside the boards of the rink on its long side at the bottom (and the kiss and cry at the end), as boxes in metres. */
+export declare function furnitureBoxes(r: FigureRink, fig?: FigureRinkFigures): Record<SkatingFurniture, MBox[]>;
+export interface FigureOptions {
+    fig: FigureRinkFigures;
+    furniture: readonly SkatingFurniture[];
+}
+/** The parts of the rink. */
+export declare function figureParts(r: FigureRink, opt: FigureOptions): {
+    parts: Parts;
+    box: MBox;
+    marks: MMark[];
+};

package/dist/skating/figure.js

@@ -0,0 +1,37 @@
+import { ISU_FIGURE_RINK } from "../leagues/skating.js";
+import { emptyParts } from "./parts.js";
+/** The furniture of a figure skating rink, in painter's order. */
+export const FURNITURE = Object.freeze(["judges", "referee", "technical-panel", "kiss-and-cry"]);
+/** The seats of a panel of judges, side by side at the rinkboard: nine, as at the Olympic Winter Games (ours: the Rules fix the number elsewhere), 1 m apart. */
+export const JUDGES = 9;
+/** Where the furniture stands outside the boards of the rink on its long side at the bottom (and the kiss and cry at the end), as boxes in metres. */
+export function furnitureBoxes(r, fig = ISU_FIGURE_RINK) {
+    const y = r.width / 2 + fig.boards + 0.6;
+    const seat = (x) => ({ x0: x - 0.4, y0: y, x1: x + 0.4, y1: y + 0.8 });
+    return {
+        judges: Array.from({ length: JUDGES }, (_, i) => seat((i - (JUDGES - 1) / 2) * 1)),
+        referee: [seat(-(JUDGES - 1) / 2 - 2)],
+        "technical-panel": [{ x0: (JUDGES - 1) / 2 + 1.5, y0: y + 1.2, x1: (JUDGES - 1) / 2 + 5.5, y1: y + 2.4 }],
+        "kiss-and-cry": [{ x0: -r.length / 2 + 3, y0: y, x1: -r.length / 2 + 6.5, y1: y + 1.6 }],
+    };
+}
+/** The parts of the rink. */
+export function figureParts(r, opt) {
+    const { fig } = opt;
+    const parts = emptyParts();
+    const Lh = r.length / 2;
+    const W = r.width / 2;
+    const rd = (n) => Math.round(n * 100) / 100;
+    const roundD = (hx, hy, k) => `M${rd(-hx + k)} ${rd(-hy)}H${rd(hx - k)}A${k} ${k} 0 0 1 ${rd(hx)} ${rd(-hy + k)}V${rd(hy - k)}A${k} ${k} 0 0 1 ${rd(hx - k)} ${rd(hy)}H${rd(-hx + k)}A${k} ${k} 0 0 1 ${rd(-hx)} ${rd(hy - k)}V${rd(-hy + k)}A${k} ${k} 0 0 1 ${rd(-hx + k)} ${rd(-hy)}Z`;
+    parts.areas.push({ id: "ice", feature: "ice", cls: "ky-ska-ice", d: roundD(Lh, W, fig.corner) });
+    parts.areas.push({ id: "boards", feature: "boards", cls: "ky-boards", d: `${roundD(Lh + fig.boards, W + fig.boards, fig.corner + fig.boards)}${roundD(Lh, W, fig.corner)}`, evenodd: true });
+    const boxes = furnitureBoxes(r, fig);
+    const marks = [];
+    for (const kind of opt.furniture) {
+        boxes[kind].forEach((b, i) => parts.areas.push({ id: `${kind}-${i + 1}`, feature: kind, cls: kind === "kiss-and-cry" ? "ky-ska-kiss" : "ky-ska-desk", rect: [b.x0, b.y0, b.x1, b.y1] }));
+        const b = boxes[kind][Math.floor(boxes[kind].length / 2)];
+        marks.push({ id: kind, x: (b.x0 + b.x1) / 2, y: b.y1, side: "bottom" });
+    }
+    const extra = opt.furniture.length === 0 ? 0 : 3.4;
+    return { parts, box: { x0: -Lh - fig.boards, y0: -W - fig.boards, x1: Lh + fig.boards, y1: W + fig.boards + extra }, marks };
+}

package/dist/skating/long.d.ts

@@ -0,0 +1,54 @@
+import type { Shape } from "../fields.types.ts";
+import { type LongTrackFigures } from "../leagues/skating.ts";
+import { LONG_TRACK_RACES } from "./events.ts";
+import { addParts, type MBox, type Parts } from "./parts.ts";
+import { laneRadius, type Lane, type LongOval } from "./track.ts";
+import type { LongTrackRace, SkatingInfield } from "./types.ts";
+/** Where a skater starts: the lane (or `both` for a line across both lanes) and the point of the start. */
+export interface StartPlacement {
+    lane: Lane | "both";
+    /** The coordinate along the skater's own way, from the beginning of the finishing straight of the lap the start is in. */
+    v0: number;
+    x: number;
+    y: number;
+    heading: number;
+}
+/** What a race marks: the lines where it starts, the finishing line it ends at, and how its first straight is skated. */
+export interface RaceMarks {
+    race: LongTrackRace;
+    /** The finishing line: the 400 m mark at the end of the finishing straight or the 1000 m mark in the middle of it. */
+    finish: "400m" | "1000m";
+    /** True when the first straight keeps its lane (the 1000 m and the 1500 m, Rule 254.5b). */
+    noChange: boolean;
+    /** The starting lines: one for each lane, or one across both. */
+    starts: StartPlacement[];
+}
+/** The marks of a race on the oval. */
+export declare function markRace(o: LongOval, race: LongTrackRace): RaceMarks;
+/** What the long track adds: everything from the ice to the lines. */
+export interface LongOptions {
+    fig: LongTrackFigures;
+    warmUp: boolean;
+    infield: SkatingInfield;
+    blocks: boolean;
+    coaches: boolean;
+    padding: boolean;
+    races: readonly LongTrackRace[];
+}
+export declare const LONG_DEFAULTS: {
+    warmUp: boolean;
+    infield: SkatingInfield;
+    blocks: boolean;
+    coaches: boolean;
+    padding: boolean;
+};
+/** The ice's outer radius: the outer edge of the outer lane and the 3 m the Rules keep clear (Rule 228.2). */
+export declare const iceRadius: (o: LongOval, fig?: LongTrackFigures) => number;
+/** The parts of the long track. */
+export declare function longParts(o: LongOval, opt: LongOptions): {
+    parts: Parts;
+    marks: RaceMarks[];
+    box: MBox;
+};
+export { addParts, laneRadius, LONG_TRACK_RACES };
+export type { Shape };

package/dist/skating/long.js

@@ -0,0 +1,111 @@
+// The long track: the ice, the padding, the lanes and the warm-up lane, the blocks of the curves, the coaches' area, the finishing lines and the starting lines of each race. Every figure is the ISU's
+// (Special Regulations and Technical Rules Speed Skating, Rules 203, 205, 226, 227, 228, 253, 254 and 256 to 257, and "H. Track"), in metres. Nothing here draws SVG: it makes the shapes.
+import { line, poly } from "../fields.kit.js";
+import { ISU_LONG_TRACK } from "../leagues/skating.js";
+import { LONG_TRACK_RACES } from "./events.js";
+import { addParts, blocksOf, emptyParts, stadiumD } from "./parts.js";
+import { finishAt, laneEdges, laneRadius, outerEdge, pose, startOf } from "./track.js";
+/** How each race starts. `at` is the finishing line's mark, `middle` a start in the middle of the straights (Rules 256 and 257). */
+const SPEC = {
+    "500m": { finish: "400m", distance: 500, noChange: false },
+    "1000m": { finish: "1000m", distance: 1000, noChange: true },
+    "1500m": { finish: "400m", distance: 1500, noChange: true },
+    "3000m": { finish: "400m", distance: 3000, noChange: false },
+    "5000m": { finish: "400m", distance: 5000, noChange: false },
+    "10000m": { finish: "400m", distance: 10000, noChange: false },
+    "mass-start": { finish: "400m", distance: 0, noChange: false, start: "middle" },
+    "team-pursuit": { finish: "1000m", distance: 0, noChange: false, start: "both-straights" },
+    "team-sprint": { finish: "1000m", distance: 0, noChange: false, start: "both-straights" },
+};
+/** The marks of a race on the oval. */
+export function markRace(o, race) {
+    const spec = SPEC[race];
+    const finish = finishAt(o, spec.finish);
+    const place = (lane, v0, p) => ({ lane, v0, x: p.x, y: p.y, heading: p.heading });
+    if (spec.start === "middle") {
+        const p = pose(o, 0, o.straight / 2);
+        return { race, finish: spec.finish, noChange: false, starts: [place("both", o.straight / 2, { ...p, y: o.d })] };
+    }
+    if (spec.start === "both-straights") {
+        const bottom = pose(o, 0, o.straight / 2);
+        const top = pose(o, 0, o.straight + Math.PI * o.d + o.crossing / 2);
+        return { race, finish: spec.finish, noChange: false, starts: [place(0, o.straight / 2, bottom), place(0, 0, { ...top, y: -o.d })] };
+    }
+    const starts = [0, 1].map((lane) => {
+        const s = startOf(o, lane, spec.distance, finish, spec.noChange);
+        return place(lane, s.v0, s.pose);
+    });
+    // A line across both lanes where the two lanes start at the same place (the 500 m, the 10,000 m).
+    const same = Math.abs(starts[0].x - starts[1].x) < 1e-6 && Math.abs(starts[0].y * starts[1].y) > 0 && Math.sign(starts[0].y) === Math.sign(starts[1].y);
+    return { race, finish: spec.finish, noChange: spec.noChange, starts: same ? [{ ...starts[0], lane: "both" }] : starts };
+}
+/** The y-range of a lane's band on the top or the bottom side at x, from the edges' radii: on a straight the band is the radii themselves; past the end of a curve's start, the circle's. */
+function bandAt(f, x, rA, rB, side) {
+    const out = Math.abs(x) - f / 2;
+    const y = (r) => (out <= 0 ? r : Math.sqrt(Math.max(0, r * r - out * out)));
+    return [side * y(rA), side * y(rB)];
+}
+export const LONG_DEFAULTS = { warmUp: true, infield: "floor", blocks: true, coaches: true, padding: true };
+/** The ice's outer radius: the outer edge of the outer lane and the 3 m the Rules keep clear (Rule 228.2). */
+export const iceRadius = (o, fig = ISU_LONG_TRACK) => outerEdge(o) + fig.padding.clear;
+/** The parts of the long track. */
+export function longParts(o, opt) {
+    const { fig } = opt;
+    const f = o.straight;
+    const edges = laneEdges(o, opt.warmUp ? fig.warmUpLane : 0);
+    const R = iceRadius(o, fig);
+    const parts = emptyParts();
+    const L = fig.line;
+    // The ice, the infield and the padding: the ice out to the padding, the padding a band 0.3 m thick at its edge, and what lies inside the warm-up lane.
+    parts.areas.push({ id: "ice", feature: "ice", cls: "ky-ska-ice", d: stadiumD(f, R) });
+    if (opt.padding)
+        parts.areas.push({ id: "padding", feature: "padding", cls: "ky-ska-pad", d: `${stadiumD(f, R + fig.padding.thick)}${stadiumD(f, R)}`, evenodd: true });
+    if (opt.warmUp)
+        parts.areas.push({ id: "warm-up", feature: "warm-up", cls: "ky-ska-warm", d: `${stadiumD(f, edges.inner)}${stadiumD(f, edges.warmUp)}`, evenodd: true });
+    parts.areas.push({ id: "infield", feature: "infield", cls: opt.infield === "ice" ? "ky-ska-ice" : "ky-ska-floor", d: stadiumD(f, edges.warmUp) });
+    // The lanes' lines (Rule 226): fully painted, 5 cm wide, in the straights and in the curves.
+    const radii = [...(opt.warmUp ? [edges.warmUp] : []), edges.inner, edges.between, edges.outer];
+    radii.forEach((r, i) => parts.shapes.push({ kind: "path", id: `lane-line-${i}`, feature: "lane-lines", d: stadiumD(f, r), w: L, cls: "ky-ska-b" }));
+    // The blocks (Rule 226): inside the painted lines of the inner lane's edge and of the line between the lanes, 50 cm apart for the first 15 m of a curve and 2 m after.
+    if (opt.blocks) {
+        for (const [name, r] of [["inner", edges.inner], ["between", edges.between]]) {
+            const rb = r - L - fig.blocks.height;
+            for (const side of ["right", "left"])
+                parts.shapes.push(...blocksOf(`blocks-${name}-${side}`, f, side, rb, fig.blocks.near, fig.blocks.nearLength, fig.blocks.far, 0.12));
+        }
+    }
+    // The coaches' area (Rule 227.3): a line 2 cm wide, 1 m from the outside edge of the track, from 25 m after the end of the curve to 10 m before the next, on the crossing straight.
+    if (opt.coaches) {
+        const y = -(edges.outer + fig.coaches.offset);
+        parts.shapes.push(line("coaches-area", "coaches-area", f / 2 - fig.coaches.after, y, -f / 2 + fig.coaches.before, y, { w: 0.02, cls: "ky-ska-r" }));
+    }
+    // The finishing lines and the last 5 m before them, marked by the metre (Rule 227.2).
+    const marks = opt.races.map((r) => markRace(o, r));
+    const finishes = new Set(["400m"]);
+    for (const m of marks)
+        finishes.add(m.finish);
+    const bottom = bandAt(f, 0, edges.inner, edges.outer, 1);
+    for (const which of finishes) {
+        const x = -f / 2 + finishAt(o, which);
+        parts.shapes.push(line(`finish-${which}`, "finish-line", x, bottom[0], x, bottom[1], { w: L, cls: "ky-ska-r" }));
+        for (let m = 1; m <= fig.finishMetres; m += 1)
+            parts.shapes.push(line(`finish-${which}-metre-${m}`, "finish-marks", x - m, bottom[0], x - m, bottom[1], { w: 0.02, cls: "ky-ska-b" }));
+    }
+    // The starting lines, each 2 m after a pre-start line (Rule 227.2 and 253.3): across the lane, or across both lanes.
+    for (const m of marks) {
+        for (const s of m.starts) {
+            const side = s.y >= 0 ? 1 : -1;
+            const lanes = s.lane === "both" ? [edges.inner, edges.outer] : s.lane === 0 ? [edges.inner, edges.between] : [edges.between, edges.outer];
+            const [y0, y1] = bandAt(f, s.x, lanes[0], lanes[1], side);
+            parts.shapes.push(line(`start-${m.race}-${String(s.lane)}`, "start-lines", s.x, y0, s.x, y1, { w: L, cls: "ky-ska-r" }));
+            // Behind the line: to the left on the finishing straight, to the right on the crossing straight.
+            const px = s.x + (side === 1 ? -fig.preStart : fig.preStart);
+            const [q0, q1] = bandAt(f, px, lanes[0], lanes[1], side);
+            parts.shapes.push(line(`pre-start-${m.race}-${String(s.lane)}`, "pre-start-lines", px, q0, px, q1, { w: 0.02, cls: "ky-ska-b" }));
+        }
+    }
+    void poly;
+    const out = R + fig.padding.thick;
+    return { parts, marks, box: { x0: -f / 2 - out, y0: -out, x1: f / 2 + out, y1: out } };
+}
+export { addParts, laneRadius, LONG_TRACK_RACES };

package/dist/skating/parts.d.ts

@@ -0,0 +1,43 @@
+import { path, line, poly } from "../fields.kit.ts";
+import type { Area, Shape } from "../fields.types.ts";
+/** What a part of a plan adds. */
+export interface Parts {
+    areas: Area[];
+    shapes: Shape[];
+}
+export declare const emptyParts: () => Parts;
+/** Add `more` to `into`. */
+export declare function addParts(into: Parts, more: Parts): void;
+/** A box in metres. */
+export interface MBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** A named part of the plan to crop to, in metres: one box, or one at each end (`left` and `right` as the rink is drawn wide). */
+export type MRange = MBox | {
+    left: MBox;
+    right: MBox;
+};
+/** A part of the plan to label (`landmarks`): where it is, in metres, and the side of the drawing its label stands on. */
+export interface MMark {
+    id: string;
+    x: number;
+    y: number;
+    side: "top" | "bottom";
+}
+export declare const grow: (b: MBox, m: number) => MBox;
+export declare const union: (boxes: readonly MBox[]) => MBox;
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin, drawn from the top left, clockwise as the eye sees it. */
+export declare const stadiumD: (s: number, r: number) => string;
+/** A point of a curve of the oval: `side` is the right-hand curve (centre at x = s/2, entered at the bottom) or the left-hand one (centre at x = -s/2, entered at the top); `t` the angle from the entrance. */
+export declare function curvePoint(s: number, side: "right" | "left", r: number, t: number): [number, number];
+/** The path of an arc of a curve of the oval from the angle `t0` to `t1`, in the way the skaters go (counter-clockwise as the eye sees it). */
+export declare function curveD(s: number, side: "right" | "left", r: number, t0: number, t1: number): string;
+/**
+ * The blocks of a curve as dots: a dashed path with a zero dash and round caps, so that a dot of the line's width stands every `near` metres for the first `nearLength` metres from the entrance and
+ * every `far` metres after, the cone at the entrance a dot of its own (Rule 226).
+ */
+export declare function blocksOf(id: string, s: number, side: "right" | "left", r: number, near: number, nearLength: number, far: number, width: number): Shape[];
+export { line, poly, path };

package/dist/skating/parts.js

@@ -0,0 +1,40 @@
+// What a part of a skating plan adds, as shapes and areas in painter's order, in metres, and the small functions the parts are made of. Nothing here draws SVG.
+import { path, line, poly } from "../fields.kit.js";
+import { num } from "../format.js";
+export const emptyParts = () => ({ areas: [], shapes: [] });
+/** Add `more` to `into`. */
+export function addParts(into, more) {
+    into.areas.push(...more.areas);
+    into.shapes.push(...more.shapes);
+}
+export const grow = (b, m) => ({ x0: b.x0 - m, y0: b.y0 - m, x1: b.x1 + m, y1: b.y1 + m });
+export const union = (boxes) => ({ x0: Math.min(...boxes.map((b) => b.x0)), y0: Math.min(...boxes.map((b) => b.y0)), x1: Math.max(...boxes.map((b) => b.x1)), y1: Math.max(...boxes.map((b) => b.y1)) });
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin, drawn from the top left, clockwise as the eye sees it. */
+export const stadiumD = (s, r) => `M${num(-s / 2)} ${num(-r)}H${num(s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(s / 2)} ${num(r)}H${num(-s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(-s / 2)} ${num(-r)}Z`;
+/** A point of a curve of the oval: `side` is the right-hand curve (centre at x = s/2, entered at the bottom) or the left-hand one (centre at x = -s/2, entered at the top); `t` the angle from the entrance. */
+export function curvePoint(s, side, r, t) {
+    return side === "right" ? [s / 2 + r * Math.sin(t), r * Math.cos(t)] : [-s / 2 - r * Math.sin(t), -r * Math.cos(t)];
+}
+/** The path of an arc of a curve of the oval from the angle `t0` to `t1`, in the way the skaters go (counter-clockwise as the eye sees it). */
+export function curveD(s, side, r, t0, t1) {
+    const [x0, y0] = curvePoint(s, side, r, t0);
+    const [x1, y1] = curvePoint(s, side, r, t1);
+    return `M${num(x0)} ${num(y0)}A${num(r)} ${num(r)} 0 ${t1 - t0 > Math.PI ? 1 : 0} 0 ${num(x1)} ${num(y1)}`;
+}
+/**
+ * The blocks of a curve as dots: a dashed path with a zero dash and round caps, so that a dot of the line's width stands every `near` metres for the first `nearLength` metres from the entrance and
+ * every `far` metres after, the cone at the entrance a dot of its own (Rule 226).
+ */
+export function blocksOf(id, s, side, r, near, nearLength, far, width) {
+    const out = [];
+    const tNear = Math.min(Math.PI, nearLength / r);
+    out.push(path(`${id}-near`, "blocks", curveD(s, side, r, 0, tNear), { w: width, dash: [0, near], cls: "ky-ska-blocks", least: 0.4 }));
+    // The far part starts a step after the near one stops, so that no block stands twice.
+    const start = tNear + far / r;
+    if (start < Math.PI + 1e-9)
+        out.push(path(`${id}-far`, "blocks", curveD(s, side, r, start, Math.PI), { w: width, dash: [0, far], cls: "ky-ska-blocks", least: 0.4 }));
+    const [cx, cy] = curvePoint(s, side, r, 0);
+    out.push({ kind: "dot", id: `${id}-cone`, feature: "cones", cx, cy, r: width * 1.3, paint: "cone" });
+    return out;
+}
+export { line, poly, path };