@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/athletics/oval.d.ts

@@ -0,0 +1,57 @@
+import type { Area, Shape } from "../fields.types.ts";
+import type { AthleticsFigures } from "../leagues/athletics.ts";
+import { type Oval } from "./track.ts";
+/** A string of lane numbers painted on the track: the digits, how tall, where they are centred. They stand upright whatever way the page is turned. */
+export interface Digits {
+    id: string;
+    feature: string;
+    text: string;
+    x: number;
+    y: number;
+    h: number;
+    /** Drawn on a disc of the plate's colour, in the plate's ink, at a size that reads in a close-up (a tag), not painted on the track. */
+    tag?: boolean;
+    /** For a number behind a start line: the point of the line in this lane and the unit vector the athlete runs along, so that a tag can be moved back to clear the line. */
+    from?: readonly [x: number, y: number, fx: number, fy: number];
+}
+/** What a part of a plan adds: shapes and areas in painter's order, and digits. */
+export interface Parts {
+    areas: Area[];
+    shapes: Shape[];
+    digits: Digits[];
+}
+export declare const emptyParts: () => Parts;
+/** Add `more` to `into`. */
+export declare function addParts(into: Parts, more: Parts): void;
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin. */
+export declare const stadiumD: (s: number, r: number) => string;
+/**
+ * A lane line of the oval, cut where the straight's surface lies over its bends (the straight runs on beyond the oval's, and the Marking Plan draws only the straight's own lines there): the bottom
+ * straight between the bends, the east bend from where it leaves the straight's run-out round to the top, the top straight, and the west bend as far as the straight's starting area.
+ */
+export declare function laneLineD(o: Oval, r: number, straight: StraightPlan | undefined): string;
+/** The radius of the outer edge of an oval's last lane. */
+export declare const outerRadius: (o: Oval) => number;
+/** The straight's geometry: its first and last x (the starting area before the longest race, the run-out beyond the finish line), its lanes and how wide each is. */
+export interface StraightPlan {
+    lanes: number;
+    lane: number;
+    x0: number;
+    x1: number;
+    /** The start of the longest race of the straight, in metres before the finish line. */
+    longest: number;
+    /** The straight's inside edge (the top of lane 1) and its finish line, in the plan's frame: the oval's finish straight runs on, the covered track's lies inside it. */
+    y0: number;
+    finish: number;
+}
+/** The straight that runs on beyond the oval's finish straight (Manual 2.2.2.1): at least six lanes, a starting area of 3 m before its longest race and a run-out of 17 m. */
+export declare function straightOf(o: Oval, fig: AthleticsFigures, lanes: number, longest: number): StraightPlan;
+/**
+ * The straight of a covered track (Rules 41 to 43; the Marking Plan for the Standard Short Track): lanes 1.22 m wide inside the oval, parallel to its straights, with a starting area of 3 m before a
+ * 60 m start line and a run-out beyond the finish line. Its place in the infield is ours: the Rules and the plan give its lanes and its length, not where it lies.
+ */
+export declare function indoorStraightOf(o: Oval, fig: AthleticsFigures, lanes: number, length: number): StraightPlan;
+/** The infield straight of a covered track: its surface, its lane lines, its start area's and run-out's ends and its finish line, and the lane numbers before the finish. */
+export declare function indoorStraightParts(st: StraightPlan, numbers: boolean, w: number): Parts;
+/** The surface of the oval and of the straight, the kerb, the lane lines, the finish line and the numbers before it. */
+export declare function ovalParts(o: Oval, fig: AthleticsFigures, straight: StraightPlan | undefined, numbers: boolean, hole?: string): Parts;

package/dist/athletics/oval.js

@@ -0,0 +1,116 @@
+// The oval, the straight that runs on beyond it and the finish: the surface of the track between its kerb and its outer edge, the lane lines, the kerb, the finish line and the lane numbers
+// before it. Every figure is the Track and Field Facilities Manual's (2019 edition, 2.2.1 and 2.2.2) or Technical Rule 14's of Book C2.1, in metres. Nothing here draws SVG: it makes the shapes.
+import { line, path } from "../fields.kit.js";
+import { num } from "../format.js";
+import { laneEdge } from "./track.js";
+export const emptyParts = () => ({ areas: [], shapes: [], digits: [] });
+/** Add `more` to `into`. */
+export function addParts(into, more) {
+    into.areas.push(...more.areas);
+    into.shapes.push(...more.shapes);
+    into.digits.push(...more.digits);
+}
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin. */
+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 lane line of the oval, cut where the straight's surface lies over its bends (the straight runs on beyond the oval's, and the Marking Plan draws only the straight's own lines there): the bottom
+ * straight between the bends, the east bend from where it leaves the straight's run-out round to the top, the top straight, and the west bend as far as the straight's starting area.
+ */
+export function laneLineD(o, r, straight) {
+    if (straight === undefined)
+        return stadiumD(o.straight, r);
+    const S = o.straight;
+    const R = o.radius;
+    const wEast = straight.x1 - S / 2;
+    const wWest = -S / 2 - straight.x0;
+    // East bend, from the bottom (f = 0): inside the straight while its depth below the kerb line is positive and it is no further out than the run-out.
+    const fEast = Math.min(Math.acos(Math.min(1, R / r)), Math.asin(Math.min(1, wEast / r)));
+    // West bend, from the top: inside the straight from where it comes back below the kerb line and within the starting area.
+    const fWest = Math.max(Math.PI - Math.acos(Math.min(1, R / r)), Math.PI - Math.asin(Math.min(1, wWest / r)));
+    const e = [S / 2 + r * Math.sin(fEast), r * Math.cos(fEast)];
+    const w = [-S / 2 - r * Math.sin(fWest), -r * Math.cos(fWest)];
+    return `M${num(e[0])} ${num(e[1])}A${num(r)} ${num(r)} 0 0 0 ${num(S / 2)} ${num(-r)}H${num(-S / 2)}A${num(r)} ${num(r)} 0 0 0 ${num(w[0])} ${num(w[1])}M${num(-S / 2)} ${num(r)}H${num(S / 2)}`;
+}
+/** The radius of the outer edge of an oval's last lane. */
+export const outerRadius = (o) => laneEdge(o, o.lanes);
+/** The straight that runs on beyond the oval's finish straight (Manual 2.2.2.1): at least six lanes, a starting area of 3 m before its longest race and a run-out of 17 m. */
+export function straightOf(o, fig, lanes, longest) {
+    return { lanes, lane: fig.straightLane, x0: o.straight / 2 - longest - fig.startArea, x1: o.straight / 2 + fig.runOut, longest, y0: o.radius, finish: o.straight / 2 };
+}
+/**
+ * The straight of a covered track (Rules 41 to 43; the Marking Plan for the Standard Short Track): lanes 1.22 m wide inside the oval, parallel to its straights, with a starting area of 3 m before a
+ * 60 m start line and a run-out beyond the finish line. Its place in the infield is ours: the Rules and the plan give its lanes and its length, not where it lies.
+ */
+export function indoorStraightOf(o, fig, lanes, length) {
+    const total = fig.startArea + length + fig.runOut;
+    const x0 = -total / 2;
+    const width = lanes * fig.straightLane;
+    return { lanes, lane: fig.straightLane, x0, x1: x0 + total, longest: length, y0: -width / 2, finish: x0 + fig.startArea + length };
+}
+/** The infield straight of a covered track: its surface, its lane lines, its start area's and run-out's ends and its finish line, and the lane numbers before the finish. */
+export function indoorStraightParts(st, numbers, w) {
+    const parts = emptyParts();
+    const edge = st.y0 + st.lanes * st.lane;
+    parts.areas.push({ id: "infield-straight", feature: "track", cls: "ky-ath-track", d: `M${num(st.x0)} ${num(st.y0)}H${num(st.x1)}V${num(edge)}H${num(st.x0)}Z` });
+    for (let k = 0; k <= st.lanes; k += 1) {
+        const y = k === 0 ? st.y0 : st.y0 + k * st.lane - w / 2;
+        parts.shapes.push(line_("straight-line", st.x0, y, st.x1, y, w));
+    }
+    parts.shapes.push(line_("straight-end", st.x0, st.y0, st.x0, edge, w), line_("straight-end", st.x1, st.y0, st.x1, edge, w));
+    parts.shapes.push(line_("finish-line", st.finish, st.y0, st.finish, edge, w));
+    for (let n = 1; n <= st.lanes; n += 1) {
+        const y = st.y0 + (n - 0.5) * st.lane;
+        parts.shapes.push(line("finish-tick", "finish-line", st.finish - 1, y - 0.4, st.finish - 1, y + 0.4, { w: 0.03, least: 0.08 }));
+        if (numbers)
+            parts.digits.push({ id: "finish-number", feature: "lane-numbers", text: String(n), x: st.finish - 2.6, y, h: Math.min(0.6, st.lane * 0.55) });
+    }
+    return parts;
+}
+const line_ = (id, x0, y0, x1, y1, w) => line(id, "lane-lines", x0, y0, x1, y1, { w });
+/** The surface of the oval and of the straight, the kerb, the lane lines, the finish line and the numbers before it. */
+export function ovalParts(o, fig, straight, numbers, hole) {
+    const parts = emptyParts();
+    const S = o.straight;
+    const R = o.radius;
+    const Rout = outerRadius(o);
+    const w = o.line;
+    // The surface: the ring between the kerb and the outer edge, and the straight's.
+    // The surface is one shape: the oval's outer edge less the turf's (or, with none, the kerb's) outline, so that the synthetic surface of the segments joins the oval's with no seam.
+    parts.areas.push({ id: "track", feature: "track", cls: "ky-ath-track", d: stadiumD(S, Rout) + (hole ?? stadiumD(S, R)), evenodd: true });
+    if (straight !== undefined) {
+        const edge = R + straight.lanes * straight.lane;
+        parts.areas.push({ id: "straight", feature: "track", cls: "ky-ath-track", d: `M${num(straight.x0)} ${num(R)}H${num(straight.x1)}V${num(edge)}H${num(straight.x0)}Z` });
+    }
+    // The lane lines: the line on the right of each lane, whose outer edge is at the lane's edge (Rule 14.4), so that a line's middle is half its width inside.
+    for (let k = 1; k <= o.lanes; k += 1)
+        parts.shapes.push(path(`lane-line-${k}`, "lane-lines", laneLineD(o, laneEdge(o, k) - w / 2, straight), { w }));
+    // The kerb, 50 mm wide at the least (Rule 14.1); the rules allow it as wide as 250 mm, and it is drawn a little wider than the lines when the drawing is not at true widths.
+    parts.shapes.push(path("kerb", "kerb", stadiumD(S, R - fig.kerb / 2), { w: fig.kerb, least: fig.kerb * 3 }));
+    if (straight !== undefined) {
+        const sl = straight.lane;
+        for (let k = 0; k <= straight.lanes; k += 1) {
+            // The inside line of lane 1 is the straight's inside edge; each other line is the outer edge of the lane before it.
+            const y = k === 0 ? R : R + k * sl - w / 2;
+            if (k <= o.lanes && sl === o.lane) {
+                // Between the bends these are the oval's own lines; the straight's run on beyond them.
+                parts.shapes.push(line(`straight-line-${k}`, "lane-lines", straight.x0, y, -S / 2, y, { w }), line(`straight-line-${k}`, "lane-lines", S / 2, y, straight.x1, y, { w }));
+            }
+            else
+                parts.shapes.push(line(`straight-line-${k}`, "lane-lines", straight.x0, y, straight.x1, y, { w }));
+        }
+        // The ends of the straight, across it.
+        parts.shapes.push(line("straight-end", "lane-lines", straight.x0, R, straight.x0, R + straight.lanes * sl, { w }), line("straight-end", "lane-lines", straight.x1, R, straight.x1, R + straight.lanes * sl, { w }));
+    }
+    // The finish line: all lanes, at right angles to the lane lines, on the axis through the centre of the second semicircle (Manual 2.2.1.1).
+    const lanesAt = straight === undefined ? o.lanes : straight.lanes;
+    const sl = straight === undefined ? o.lane : straight.lane;
+    parts.shapes.push(line("finish-line", "finish-line", S / 2, R, S / 2, R + lanesAt * sl, { w }));
+    // A white line 0.03 m wide and 0.80 m long may be marked in each lane 1 m before the finish line (Manual 2.2.1.6, "Finish Line").
+    for (let n = 1; n <= lanesAt; n += 1) {
+        const y = R + (n - 0.5) * sl;
+        parts.shapes.push(line("finish-tick", "finish-line", S / 2 - 1, y - 0.4, S / 2 - 1, y + 0.4, { w: 0.03, least: 0.08 }));
+        if (numbers)
+            parts.digits.push({ id: "finish-number", feature: "lane-numbers", text: String(n), x: S / 2 - 2.6, y, h: Math.min(0.6, sl * 0.55) });
+    }
+    return parts;
+}

package/dist/athletics/plan.d.ts

@@ -0,0 +1,97 @@
+import type { Area, Shape } from "../fields.types.ts";
+import { WA_SHORT_TRACK, WA_STANDARD_TRACK, type AthleticsFigures, type AthleticsLeague } from "../leagues/athletics.ts";
+import { type SoccerSpec } from "../surfaces/soccer-spec.ts";
+import type { SurfaceOptions } from "../types.ts";
+import type { Facility } from "./facilities.ts";
+import { type Digits, type StraightPlan } from "./oval.ts";
+import { type RaceMarks } from "./races.ts";
+import { type Oval } from "./track.ts";
+import type { AthleticsFieldEvent, AthleticsInfield, AthleticsRace, AthleticsStyle, AthleticsTrackLook, RaceInfo, WaterJump } from "./types.ts";
+/** 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 stadium 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";
+}
+/** What an athletics drawing is. */
+export interface AthleticsPlan {
+    sport: "athletics";
+    league: string;
+    /** True for the covered 200 m track. */
+    indoor: boolean;
+    figures: AthleticsFigures;
+    oval: Oval;
+    lanes: number;
+    straight: StraightPlan | undefined;
+    track: AthleticsTrackLook;
+    infield: AthleticsInfield;
+    /** The playing surface: the outer edge of the oval. The data frame's own box. */
+    box: MBox;
+    /** Everything drawn: the box and what lies beyond it (the jump strip, the runways' ends, the straight). */
+    extent: MBox;
+    areas: Area[];
+    shapes: Shape[];
+    digits: Digits[];
+    /** The turf: its outline and the lighter bands, for the mown look. */
+    turf: {
+        d: string;
+        stripes: string;
+    } | undefined;
+    /** The soccer pitch laid inside the track, and where its corner is. */
+    pitch: {
+        spec: SoccerSpec;
+        x: number;
+        y: number;
+    } | undefined;
+    facilities: Facility[];
+    races: RaceMarks[];
+    /** The steeplechase's lap, when it is drawn. */
+    waterJump: WaterJump | undefined;
+    events: AthleticsFieldEvent[];
+    /** The width the ordinary line is painted at by the rules, and the width it is drawn at unless `exactLines` says otherwise. */
+    lineWidth: number;
+    drawnLine: number;
+    ranges: Readonly<Record<string, MRange>>;
+    marks: MMark[];
+    /** The race a close-up of a start (`range: "start"`) shows. */
+    start: AthleticsRace;
+    /** The close-up of the start of that race, when the options ask for one (`range: "start"`): where it is turned about, and the part shown, in the frame in which the athletes run to the right. */
+    startView: {
+        pivot: {
+            x: number;
+            y: number;
+            heading: number;
+        };
+        window: MBox;
+    } | undefined;
+    /** True when the lane numbers are painted. */
+    numbers: boolean;
+    /** The field event drawn alone at a large scale, when the options ask for one: its facility is the whole plan. */
+    layout?: AthleticsFieldEvent;
+}
+/** The league a set of options asks for: the outdoor standard track, or the covered one. */
+export declare function athleticsLeague(o: Pick<SurfaceOptions, "sport" | "league">): AthleticsLeague;
+/** The field events the options ask for: all of them, none, or a list. @throws Error for a name that is not a field event. */
+export declare function eventsOf(style: AthleticsStyle | undefined): AthleticsFieldEvent[];
+/** The races the options ask to be marked. @throws Error for a name that is not a race. */
+export declare function racesOf(style: AthleticsStyle | undefined, indoor?: boolean): RaceInfo[];
+/** The races the covered track marks: the 60 m and its hurdles on the infield straight, and the races of 200 m to 5000 m on the oval. */
+export declare const INDOOR_RACES: readonly AthleticsRace[];
+/** The number of lanes of the oval the options ask for. */
+export declare function athleticsLanes(o: Pick<SurfaceOptions, "sport" | "league" | "athletics">): number;
+/** The standard track and everything the options ask to be marked on it, as a plan. */
+export declare function athleticsPlan(o: Pick<SurfaceOptions, "sport" | "league" | "athletics" | "units" | "pitch" | "detail"> & Partial<Pick<SurfaceOptions, "range" | "ground">>): AthleticsPlan;
+export { WA_SHORT_TRACK, WA_STANDARD_TRACK };

package/dist/athletics/plan.js

@@ -0,0 +1,355 @@
+// What an athletics surface is for a set of options: the track's geometry, the infield, the races and the field events marked, and where each can be cropped to, all as plain data in metres, in
+// the frame of track.ts (the origin the middle of the track, x along the straights, y down the page). Kept apart from the drawing so that the outline, the description, the ranges, the replay,
+// the tests and the drawing agree: a test reads a figure from the plan, not from the markup. Nothing here draws.
+import { lengthUnit } from "../common.js";
+import { num } from "../format.js";
+import { ATHLETICS_LEAGUES, WA_SHORT_TRACK, WA_STANDARD_TRACK } from "../leagues/athletics.js";
+import { chooseLeague } from "../leagues.js";
+import { groundById } from "../grounds.js";
+import { soccerSpec } from "../surfaces/soccer-spec.js";
+import { FIELD_EVENT_IDS, RACES, RACE_IDS, raceById } from "./events.js";
+import { infieldParts, jumpStrip, ARENA } from "./infield.js";
+import { addParts, emptyParts, indoorStraightOf, indoorStraightParts, outerRadius, ovalParts, stadiumD, straightOf } from "./oval.js";
+import { layoutOf } from "./layout.js";
+import { markRace, startPivot, startPoints } from "./races.js";
+import { parseRange } from "../ranges.names.js";
+import { steeplechaseParts, waterPitBox } from "./steeplechase.js";
+import { laneEdge } from "./track.js";
+const isAthleticsLeague = (l) => typeof l === "object" && l !== null && l.family === "athletics";
+/** The league a set of options asks for: the outdoor standard track, or the covered one. */
+export function athleticsLeague(o) {
+    const { league } = chooseLeague(o);
+    return isAthleticsLeague(league) ? league : ATHLETICS_LEAGUES[0];
+}
+const TRACKS = ["red", "blue", "terracotta", "green"];
+const INFIELDS = ["pitch", "grass", "none"];
+/** A whole number of lanes within a range, or the drawn one. @throws RangeError for a number outside the range the rules allow. */
+function lanesIn(asked, range, drawn, label) {
+    if (asked === undefined)
+        return drawn;
+    if (typeof asked !== "number" || !Number.isInteger(asked))
+        throw new RangeError(`${label} must be a whole number`);
+    if (asked < range.min || asked > range.max)
+        throw new RangeError(`${label} of ${asked} is outside what the rules allow: ${range.min} to ${range.max}`);
+    return asked;
+}
+/** The field events the options ask for: all of them, none, or a list. @throws Error for a name that is not a field event. */
+export function eventsOf(style) {
+    const asked = style?.events;
+    if (asked === undefined || asked === true)
+        return [...FIELD_EVENT_IDS];
+    if (asked === false)
+        return [];
+    if (!Array.isArray(asked))
+        throw new TypeError("athletics.events is true, false or a list of field events");
+    for (const e of asked)
+        if (!FIELD_EVENT_IDS.includes(e))
+            throw new Error(`Unknown field event "${String(e)}": use one of ${FIELD_EVENT_IDS.join(", ")}`);
+    return FIELD_EVENT_IDS.filter((e) => asked.includes(e));
+}
+/** The races the options ask to be marked. @throws Error for a name that is not a race. */
+export function racesOf(style, indoor = false) {
+    const asked = style?.races;
+    if (asked === undefined)
+        return [];
+    const here = (r) => (indoor ? INDOOR_RACES.includes(r.id) : r.indoor !== true);
+    if (asked === "all")
+        return RACES.filter(here);
+    if (!Array.isArray(asked))
+        throw new TypeError('athletics.races is "all" or a list of races');
+    for (const r of asked)
+        if (raceById(r) === undefined)
+            throw new Error(`Unknown race "${String(r)}": use one of ${RACE_IDS.join(", ")}`);
+    const list = RACES.filter((r) => asked.includes(r.id));
+    for (const r of list)
+        if (!here(r))
+            throw new RangeError(indoor ? `The covered 200 m track does not mark the ${r.id}: use one of ${INDOOR_RACES.join(", ")}` : `The ${r.id} is run on the covered track: the 400 m track marks the other races`);
+    return list;
+}
+/** The races the covered track marks: the 60 m and its hurdles on the infield straight, and the races of 200 m to 5000 m on the oval. */
+export const INDOOR_RACES = Object.freeze(["60m", "60m-hurdles", "200m", "400m", "800m", "1000m", "1500m", "mile", "3000m", "5000m"]);
+/** Round a box out by `m`. */
+const grow = (b, m) => ({ x0: b.x0 - m, y0: b.y0 - m, x1: b.x1 + m, y1: b.y1 + m });
+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 lighter bands of the mown turf, aligned to a pitch of 105 m in 19 bands, so that the grass round a pitch is mown as the pitch is (the soccer builder's `bands`). */
+function turfBands(x0, x1, y0, y1) {
+    const band = 105 / 19;
+    const left = -52.5;
+    let d = "";
+    for (let i = -3; i < 22; i += 1) {
+        if (Math.abs(i) % 2 !== 1)
+            continue;
+        const a = left + i * band;
+        const b = a + band;
+        if (b <= x0 || a >= x1)
+            continue;
+        d += `M${num(Math.max(a, x0))} ${num(y0)}H${num(Math.min(b, x1))}V${num(y1)}H${num(Math.max(a, x0))}Z`;
+    }
+    return d;
+}
+/** The turf of the standard stadium: the oval's inside, cut off at each end where the synthetic surface of the segments begins (Marking Plan; Manual 2.2.1.1). */
+function turfOf(o) {
+    const S = o.straight;
+    const R = o.radius;
+    const xg = S / 2 + ARENA.turf;
+    const yc = Math.sqrt(R * R - ARENA.turf * ARENA.turf);
+    const d = `M${num(-xg)} ${num(-yc)}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(xg)} ${num(-yc)}V${num(yc)}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(-xg)} ${num(yc)}Z`;
+    return { d };
+}
+/** The number of lanes of the oval the options ask for. */
+export function athleticsLanes(o) {
+    const fig = athleticsLeague(o).dimensions;
+    return lanesIn(o.athletics?.lanes, fig.lanes, fig.lanes.drawn, "The number of lanes");
+}
+/** The standard track and everything the options ask to be marked on it, as a plan. */
+export function athleticsPlan(o) {
+    const league = athleticsLeague(o);
+    const fig = league.dimensions;
+    const indoor = fig.banking !== null;
+    const style = o.athletics;
+    const lanes = lanesIn(style?.lanes, fig.lanes, fig.lanes.drawn, "The number of lanes");
+    const straightLanes = lanesIn(style?.straightLanes, fig.straightLanes, Math.max(lanes, fig.straightLanes.min), "The number of lanes of the straight");
+    const track = style?.track === undefined ? "red" : style.track;
+    if (!TRACKS.includes(track))
+        throw new Error(`Unknown track look "${String(track)}": use one of ${TRACKS.join(", ")}`);
+    const infield = style?.infield === undefined ? (indoor ? "none" : "pitch") : style.infield;
+    if (!INFIELDS.includes(infield))
+        throw new Error(`Unknown infield "${String(infield)}": use one of ${INFIELDS.join(", ")}`);
+    const layoutEvent = style?.layout;
+    if (layoutEvent !== undefined && !FIELD_EVENT_IDS.includes(layoutEvent))
+        throw new Error(`Unknown field event "${String(layoutEvent)}": use one of ${FIELD_EVENT_IDS.join(", ")}`);
+    const events = indoor ? [] : eventsOf(style);
+    const races = racesOf(style, indoor);
+    const startRace = style?.start === undefined ? "400m" : style.start;
+    if (raceById(startRace) === undefined)
+        throw new Error(`Unknown race "${String(startRace)}": use one of ${RACE_IDS.join(", ")}`);
+    const wj = style?.waterJump === undefined ? "inside" : style.waterJump;
+    if (wj !== "inside" && wj !== "outside" && wj !== "none")
+        throw new Error(`Unknown water jump "${String(wj)}": use inside, outside or none`);
+    const numbers = style?.numbers !== false;
+    const parsed = o.range === undefined ? undefined : parseRange({ sport: "athletics", league: o.league, range: o.range });
+    const closeUp = parsed?.kind === "name" && parsed.name === "start";
+    const oval = { straight: fig.straight, radius: fig.radius, lane: fig.lane, lanes, line: fig.line, inner: fig.inner, outer: fig.outer };
+    if (layoutEvent !== undefined)
+        return layoutPlan(layoutEvent, league, oval, lanes, track, numbers);
+    const R = oval.radius;
+    const S = oval.straight;
+    const Rout = outerRadius(oval);
+    const longest = indoor ? 60 : 110;
+    const straight = indoor ? indoorStraightOf(oval, fig, straightLanes, 60) : straightOf(oval, fig, straightLanes, longest);
+    const parts = emptyParts();
+    const D = turfOf(oval);
+    // The ground inside the track: the synthetic surface of the segments, and the turf between them (Marking Plan).
+    addParts(parts, ovalParts(oval, fig, indoor ? undefined : straight, numbers, indoor ? undefined : D.d));
+    if (indoor) {
+        // The covered track's bends are banked (Rule 43): shaded, as a plan shows a slope.
+        const rr = Rout;
+        parts.areas.push({ id: "banking-east", feature: "banking", cls: "ky-ath-bank", d: `M${num(S / 2)} ${num(-rr)}A${num(rr)} ${num(rr)} 0 0 1 ${num(S / 2)} ${num(rr)}V${num(R)}A${num(R)} ${num(R)} 0 0 0 ${num(S / 2)} ${num(-R)}Z` }, { id: "banking-west", feature: "banking", cls: "ky-ath-bank", d: `M${num(-S / 2)} ${num(rr)}A${num(rr)} ${num(rr)} 0 0 1 ${num(-S / 2)} ${num(-rr)}V${num(-R)}A${num(R)} ${num(R)} 0 0 0 ${num(-S / 2)} ${num(R)}Z` });
+        addParts(parts, indoorStraightParts(straight, numbers, fig.line));
+    }
+    const turf = infield === "none" || indoor ? undefined : { d: D.d, stripes: turfBands(-S / 2 - ARENA.turf, S / 2 + ARENA.turf, -R, R) };
+    // The pitch inside the track: the options', else the size the ground's article publishes, else the international 105 by 68 m.
+    const ground = groundById(o.ground);
+    const groundPitch = ground === undefined || ground.pitchSize === "default" ? undefined : { ...ground.pitch, unit: "m" };
+    const spec = soccerSpec(o.athletics?.pitch ?? o.pitch ?? groundPitch, "m");
+    let pitch = infield === "pitch" && !indoor ? { spec, x: -spec.length / 2, y: -spec.width / 2 } : undefined;
+    void lengthUnit;
+    // The races: the starts and marks of each.
+    const raceMarks = [];
+    const ctx = { oval, fig, lanes, straight, numbers, numberHeight: 0.95 };
+    const sc = races.filter((r) => r.kind === "steeplechase");
+    const raceIds = new Set(races.map((r) => r.id));
+    if (!raceIds.has(startRace) && (o.athletics?.start !== undefined || closeUp))
+        raceIds.add(startRace);
+    for (const race of RACES) {
+        if (!raceIds.has(race.id))
+            continue;
+        if (race.kind === "steeplechase")
+            continue;
+        raceMarks.push(markRace(ctx, race));
+    }
+    let waterJump;
+    if (sc.length > 0 && wj !== "none") {
+        waterJump = wj;
+        let first = true;
+        for (const race of sc) {
+            const made = steeplechaseParts(ctx, wj, race, first);
+            first = false;
+            addParts(parts, made.parts);
+        }
+    }
+    for (const r of raceMarks)
+        addParts(parts, r.parts);
+    let startView;
+    if (closeUp) {
+        const marks = raceMarks.find((r) => r.race.id === startRace);
+        if (marks !== undefined) {
+            const pivot = startPivot(oval, marks);
+            const pts = startPoints(oval, marks, straight);
+            const c = Math.cos(pivot.heading);
+            const sn = Math.sin(pivot.heading);
+            const rot = pts.map(([x, y]) => [(x - pivot.x) * c + (y - pivot.y) * sn, -(x - pivot.x) * sn + (y - pivot.y) * c]);
+            const xs = rot.map((p) => p[0]);
+            const ys = rot.map((p) => p[1]);
+            const side = marks.race.kind === "straight" ? 0.8 : 3;
+            const win = { x0: Math.min(...xs) - (marks.race.kind === "straight" ? 7 : 9), x1: Math.max(...xs) + (marks.race.kind === "straight" ? 7 : 9), y0: Math.min(...ys) - side, y1: Math.max(...ys) + side };
+            startView = { pivot, window: win };
+            // The pitch is left out of a close-up that does not reach it.
+            if (pitch !== undefined) {
+                const corners = [[win.x0, win.y0], [win.x1, win.y0], [win.x1, win.y1], [win.x0, win.y1]].map(([x, y]) => [pivot.x + x * c - y * sn, pivot.y + x * sn + y * c]);
+                const gx0 = Math.min(...corners.map((p) => p[0]));
+                const gx1 = Math.max(...corners.map((p) => p[0]));
+                const gy0 = Math.min(...corners.map((p) => p[1]));
+                const gy1 = Math.max(...corners.map((p) => p[1]));
+                if (gx1 < pitch.x || gx0 > pitch.x + pitch.spec.length || gy1 < pitch.y || gy0 > pitch.y + pitch.spec.width)
+                    pitch = undefined;
+            }
+            // On a bend the numbers painted on the track would be specks beside the fan of the starts: they become tags that read at the size of the view.
+            if (marks.race.kind !== "straight") {
+                // A tag's disc is 1.56 times its figure's height across and must sit inside a lane (1.22 m): the figure is 0.66 m, a disc of 1.03 m.
+                const tag = 0.66;
+                for (const d of marks.parts.digits) {
+                    if (d.id !== "start-number")
+                        continue;
+                    const back = tag * 0.78 + 0.35;
+                    const at = d.from === undefined ? [d.x, d.y] : [d.from[0] - d.from[2] * back, d.from[1] - d.from[3] * back];
+                    Object.assign(d, { h: tag, tag: true, x: at[0], y: at[1] });
+                }
+            }
+        }
+    }
+    // The field events.
+    const inf = indoor ? { parts: emptyParts(), facilities: [] } : infieldParts(oval, new Set(events));
+    addParts(parts, inf.parts);
+    const box = { x0: -S / 2 - Rout, y0: -Rout, x1: S / 2 + Rout, y1: Rout };
+    let extent = grow(box, 1);
+    const edgeStraight = R + straight.lanes * straight.lane;
+    if (!indoor)
+        extent = union([extent, { x0: straight.x0, y0: -Rout, x1: straight.x1, y1: edgeStraight }]);
+    if (events.includes("long-jump") || events.includes("triple-jump"))
+        extent = union([extent, jumpStrip()]);
+    if (events.includes("javelin-throw"))
+        extent = union([extent, ...inf.facilities.filter((f) => f.event === "javelin-throw").map((f) => f.box)].map((b) => ({ x0: Math.max(b.x0, -S / 2 - Rout - 6), y0: b.y0, x1: Math.min(b.x1, S / 2 + Rout + 6), y1: b.y1 })));
+    extent = grow(extent, 0);
+    const plan = {
+        sport: "athletics",
+        league: league.id,
+        indoor,
+        figures: fig,
+        oval,
+        lanes,
+        straight,
+        track,
+        infield,
+        box,
+        extent,
+        areas: parts.areas,
+        shapes: parts.shapes,
+        digits: parts.digits,
+        turf,
+        pitch,
+        facilities: inf.facilities,
+        races: raceMarks,
+        waterJump,
+        events,
+        lineWidth: fig.line,
+        drawnLine: Math.max(fig.line, (box.x1 - box.x0) * 0.0009),
+        ranges: {},
+        marks: [],
+        start: startRace,
+        startView,
+        numbers,
+    };
+    plan.ranges = rangesOf(plan);
+    plan.marks.push(...marksOf(plan));
+    return plan;
+}
+/** The plan of one field event alone, at a large scale: its facility in its own frame (the athlete throws or jumps to the right from the origin), with the box round it as the playing surface. */
+function layoutPlan(event, league, oval, lanes, track, numbers) {
+    const lay = layoutOf(event);
+    const box = grow(lay.box, 0);
+    const width = box.x1 - box.x0;
+    const plan = {
+        sport: "athletics",
+        league: league.id,
+        indoor: false,
+        figures: league.dimensions,
+        oval,
+        lanes,
+        straight: undefined,
+        track,
+        infield: "none",
+        box,
+        extent: box,
+        areas: lay.parts.areas,
+        shapes: lay.parts.shapes.map((sh) => (sh.kind !== "dot" && sh.kind !== "bar" && sh.cls === "ky-ath-s" ? { ...sh, least: Math.max(0.07, width * 0.0011) } : sh)),
+        digits: [],
+        turf: undefined,
+        pitch: undefined,
+        facilities: [lay.facility],
+        races: [],
+        waterJump: undefined,
+        events: [event],
+        lineWidth: 0.05,
+        drawnLine: Math.max(0.05, width * 0.0016),
+        ranges: {},
+        marks: lay.marks,
+        start: "400m",
+        startView: undefined,
+        numbers,
+        layout: event,
+    };
+    return plan;
+}
+/** The union of the boxes of the facilities of one event on one side of the stadium. */
+function facilityBox(plan, event, side) {
+    const list = plan.facilities.filter((f) => f.event === event && (side === "all" || (side === "left" ? f.x < 0 : f.x >= 0)));
+    return list.length === 0 ? undefined : grow(union(list.map((f) => f.box)), 1.5);
+}
+/** The named ranges of the plan, in metres. */
+function rangesOf(plan) {
+    const o = plan.oval;
+    const S = o.straight;
+    const R = o.radius;
+    const Rout = plan.box.y1;
+    const out = {};
+    const outer = plan.indoor || plan.straight === undefined;
+    const edge = outer ? R + plan.lanes * o.lane : R + plan.straight.lanes * plan.straight.lane;
+    out.bend = { left: { x0: -S / 2 - Rout, y0: -Rout, x1: -S / 2, y1: Rout }, right: { x0: S / 2, y0: -Rout, x1: S / 2 + Rout, y1: Rout } };
+    out["home-straight"] = outer ? { x0: -S / 2, y0: R - 1, x1: S / 2, y1: edge + 1 } : { x0: plan.straight.x0, y0: R - 1, x1: plan.straight.x1, y1: edge + 1 };
+    out["back-straight"] = { x0: -S / 2, y0: -Rout, x1: S / 2, y1: -R + 1 };
+    out.finish = { x0: S / 2 - 20, y0: R - 2, x1: S / 2 + 10, y1: edge + 2 };
+    out.infield = { x0: -S / 2 - R, y0: -R, x1: S / 2 + R, y1: R };
+    for (const e of FIELD_EVENT_IDS) {
+        const left = facilityBox(plan, e, "left");
+        const right = facilityBox(plan, e, "right");
+        if (left !== undefined && right !== undefined)
+            out[e] = { left, right };
+        else if (left !== undefined || right !== undefined)
+            out[e] = (left ?? right);
+    }
+    // The water jump's pit, wherever the jump is (the steeplechase's lap is drawn only when a steeplechase is marked): the inside one by default.
+    const wj = plan.waterJump ?? "inside";
+    const pit = waterPitBox(plan.oval, wj);
+    out["water-jump"] = grow(pit, 5);
+    void laneEdge;
+    void stadiumD;
+    return out;
+}
+/** The parts of the plan to label. */
+function marksOf(plan) {
+    const o = plan.oval;
+    const S = o.straight;
+    const R = o.radius;
+    const marks = [
+        { id: "finish-line", x: S / 2, y: R + 0.6 * o.lane, side: "bottom" },
+        { id: "kerb", x: -S / 4, y: -R, side: "top" },
+        { id: "lane-lines", x: -S / 4, y: R + o.lane, side: "bottom" },
+        { id: "bend", x: S / 2 + R * 0.7071 + 2, y: -R * 0.7071, side: "top" },
+        { id: "straight", x: 0, y: -R - 3, side: "top" },
+    ];
+    if (plan.pitch !== undefined)
+        marks.push({ id: "infield-pitch", x: 0, y: -plan.pitch.spec.width / 2, side: "top" });
+    return marks;
+}
+export { WA_SHORT_TRACK, WA_STANDARD_TRACK };