@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/arenas.js

@@ -0,0 +1,72 @@
+import { ARENA_DATA } from "./arenas.data.js";
+import { officialName, placesNamed } from "./names.js";
+const FEET_PER_METRE = 1 / 0.3048;
+const tenth = (feet) => Math.round(feet * 10) / 10;
+const inFeet = (size) => {
+    const k = size.unit === "m" ? FEET_PER_METRE : 1;
+    return { length: tenth(size.length * k), width: tenth(size.width * k) };
+};
+/** The size that held in a year: the one whose years cover it, else (with no year) the latest. */
+const sizeIn = (sizes, year) => {
+    if (sizes === undefined || sizes.length === 0)
+        return undefined;
+    if (year === undefined || !Number.isFinite(year))
+        return inFeet(sizes.find((size) => size.to === undefined) ?? sizes[sizes.length - 1]);
+    const found = sizes.find((size) => (size.from === undefined || size.from <= year) && (size.to === undefined || year <= size.to));
+    return found === undefined ? undefined : inFeet(found);
+};
+/**
+ * The size of an arena's rink in feet, in a year or today (the latest), when the sources publish one that differs from the NHL's; else `undefined` and the NHL's 200 by 85 feet
+ * is the rink.
+ * @example
+ * ```ts
+ * import { arenaById, arenaRinkIn } from "@johnmorrisdotca/kyogijo-stadiums/arenas";
+ * console.log(arenaRinkIn(arenaById("boston-garden")!), arenaRinkIn(arenaById("matthews-arena")!, 1926), arenaRinkIn(arenaById("td-garden")!));
+ * // { length: 190.9, width: 83 } { length: 220, width: 90 } undefined
+ * ```
+ */
+export const arenaRinkIn = (arena, year) => sizeIn(arena?.rink, year);
+/** The size of an arena's court in feet, in a year or today, when the sources publish one that differs from the NBA's 94 by 50 feet; else `undefined`. */
+export const arenaCourtIn = (arena, year) => sizeIn(arena?.court, year);
+/**
+ * Every arena by its key: the homes of the NHL's, the NBA's, the WNBA's and the PWHL's clubs, today's and the old ones, each with where it stands, when it was in use, its names,
+ * its seats for each sport and, where the sources publish one that differs from the league's, the size of its rink or its court.
+ * @example
+ * ```ts
+ * import { ARENAS } from "@johnmorrisdotca/kyogijo-stadiums/arenas";
+ * const garden = ARENAS["boston-garden"];
+ * console.log(garden.name, garden.city, garden.from, garden.to, garden.capacity?.hockey);
+ * // Boston Garden Boston 1928 1995 14448
+ * ```
+ */
+export const ARENAS = Object.freeze(Object.fromEntries(ARENA_DATA.map((data) => [data.id, data])));
+/** The keys of `ARENAS`, in the order of the data: the arenas in use first, then those of the past. */
+export const ARENA_IDS = Object.freeze(ARENA_DATA.map((data) => data.id));
+/** The arena with a key, or `undefined`. */
+export const arenaById = (id) => (id !== undefined && Object.prototype.hasOwnProperty.call(ARENAS, id) ? ARENAS[id] : undefined);
+/** The arenas that answer to a name, best match first (see `placesByName`): the everyday names, then the official and cited names, then the former names and the nicknames. */
+export const arenasByName = (name) => placesNamed(Object.values(ARENAS), name);
+/** The arena a name belongs to (the best match when several answer to it), or `undefined`. */
+export const arenaByName = (name) => arenasByName(name)[0];
+/** The arena whose Wikidata item is `Q894567`, or `undefined`. */
+export const arenaByWikidata = (wikidata) => Object.values(ARENAS).find((arena) => arena.wikidata === wikidata);
+/** The name an arena had in a year (the name of the time in English; in Japanese there is one name for every year). */
+export function arenaNameIn(arena, year, language = "en") {
+    if (language === "ja")
+        return arena.nameJa;
+    if (year === undefined || !Number.isFinite(year))
+        return arena.name;
+    const periods = (arena.names ?? []).filter((period) => period.from <= year && year <= period.to);
+    return periods.length === 0 ? arena.name : periods[periods.length - 1].name;
+}
+/** The name an arena officially has in a language, when it is not the everyday name; else `undefined`. */
+export function arenaOfficialName(arena, language = "en", year) {
+    const shown = arenaNameIn(arena, year, language);
+    if (year !== undefined && Number.isFinite(year) && language === "en" && shown !== arena.name)
+        return undefined;
+    return officialName(arena, language, shown, Number.isFinite(year) ? year : undefined);
+}
+/** The address of the revision of an article that an arena's facts were read from. */
+export function arenaSourceUrl(source, language = "en") {
+    return `https://${language}.wikipedia.org/w/index.php?title=${encodeURIComponent(source.title.replace(/ /g, "_"))}&oldid=${source.revision}`;
+}

package/dist/athletics/describe.d.ts

@@ -0,0 +1,8 @@
+import type { Language, SurfaceOptions } from "../types.ts";
+/** The words of a race or a field event in a language. */
+export declare const raceName: (id: string, language: Language) => string;
+export declare const fieldEventName: (id: string, language: Language) => string;
+/** The sentence about the track, as a fragment: "an athletics track of 400 metres with 8 lanes...". */
+export declare function athleticsAbout(o: Pick<SurfaceOptions, "sport" | "league" | "athletics">, language: Language): string;
+/** The sentences that follow it: the infield, the events and the races marked, the close-up and the layout. Each starts after a gap. */
+export declare function athleticsSentences(o: Pick<SurfaceOptions, "sport" | "league" | "athletics" | "range">, language: Language): string;

package/dist/athletics/describe.js

@@ -0,0 +1,41 @@
+// What an athletics drawing says of itself: its sentence about the track, 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 { fieldEventById, raceById } from "./events.js";
+import { athleticsLanes, athleticsLeague, eventsOf, racesOf } from "./plan.js";
+/** The words of a race or a field event in a language. */
+export const raceName = (id, language) => raceById(id)?.name[language] ?? id;
+export const fieldEventName = (id, language) => fieldEventById(id)?.name[language] ?? id;
+/** The sentence about the track, as a fragment: "an athletics track of 400 metres with 8 lanes...". */
+export function athleticsAbout(o, language) {
+    const words = KYOGIJO_STRINGS[language].athletics;
+    const league = athleticsLeague(o);
+    return fill(league.dimensions.banking === null ? words.track400 : words.track200, { lanes: athleticsLanes(o) });
+}
+/** The sentences that follow it: the infield, the events and the races marked, the close-up and the layout. Each starts after a gap. */
+export function athleticsSentences(o, language) {
+    const words = KYOGIJO_STRINGS[language].athletics;
+    const { gap } = KYOGIJO_STRINGS[language].said;
+    const sep = KYOGIJO_STRINGS[language].layers.listSep;
+    const style = o.athletics;
+    const league = athleticsLeague(o);
+    const indoor = league.dimensions.banking !== null;
+    const out = [];
+    if (style?.layout !== undefined)
+        return `${gap}${fill(words.layout, { event: fieldEventName(style.layout, language) })}`;
+    const infield = style?.infield ?? (indoor ? "none" : "pitch");
+    out.push(infield === "pitch" ? words.infieldPitch : infield === "grass" ? words.infieldGrass : words.infieldNone);
+    if (!indoor) {
+        const events = eventsOf(style);
+        if (events.length > 0)
+            out.push(fill(words.events, { list: events.map((e) => fieldEventName(e, language)).join(sep) }));
+    }
+    const races = racesOf(style, indoor);
+    if (races.length > 0)
+        out.push(fill(words.races, { list: races.map((r) => r.name[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")
+        out.push(fill(words.start, { race: raceName(style?.start ?? "400m", language) }));
+    if (range === "finish")
+        out.push(words.finish);
+    return out.map((t) => `${gap}${t}`).join("");
+}

package/dist/athletics/events.d.ts

@@ -0,0 +1,17 @@
+import type { AthleticsFieldEvent, AthleticsRace, FieldEventInfo, RaceInfo } from "./types.ts";
+/**
+ * The races, in the order a menu lists them. `kind` says how the start is made: `straight` (the sprints and the sprint hurdles, on the finish straight), `stagger` (the lanes' staggers of Table
+ * 2.2.1.6a: `bends` half-turns in lanes), `curved` (a curved start line, the waterfall, for a race run without lanes) and `steeplechase` (the water jump's lap). The breakline (Rule 17.5.1) is the
+ * 800 m's and the 4 x 400 m's; the group starts (Rule 17.5.2) are those of the races over 1000 m.
+ */
+export declare const RACES: readonly RaceInfo[];
+/** The ids of the races. */
+export declare const RACE_IDS: readonly AthleticsRace[];
+/** A race by its id, or `undefined`. */
+export declare const raceById: (id: unknown) => RaceInfo | undefined;
+/** The field events, in the order a menu lists them: the jumps and then the throws. */
+export declare const FIELD_EVENTS: readonly FieldEventInfo[];
+/** The ids of the field events. */
+export declare const FIELD_EVENT_IDS: readonly AthleticsFieldEvent[];
+/** A field event by its id, or `undefined`. */
+export declare const fieldEventById: (id: unknown) => FieldEventInfo | undefined;

package/dist/athletics/events.js

@@ -0,0 +1,48 @@
+const race = (r) => Object.freeze(r);
+/**
+ * The races, in the order a menu lists them. `kind` says how the start is made: `straight` (the sprints and the sprint hurdles, on the finish straight), `stagger` (the lanes' staggers of Table
+ * 2.2.1.6a: `bends` half-turns in lanes), `curved` (a curved start line, the waterfall, for a race run without lanes) and `steeplechase` (the water jump's lap). The breakline (Rule 17.5.1) is the
+ * 800 m's and the 4 x 400 m's; the group starts (Rule 17.5.2) are those of the races over 1000 m.
+ */
+export const RACES = Object.freeze([
+    race({ id: "60m", distance: 60, kind: "straight", indoor: true, name: { en: "60 m", ja: "60m", fr: "60\u00a0m" } }),
+    race({ id: "60m-hurdles", distance: 60, kind: "straight", hurdles: true, indoor: true, name: { en: "60 m hurdles", ja: "60mハードル", fr: "60\u00a0m haies" } }),
+    race({ id: "100m", distance: 100, kind: "straight", name: { en: "100 m", ja: "100m", fr: "100\u00a0m" } }),
+    race({ id: "100m-hurdles", distance: 100, kind: "straight", hurdles: true, name: { en: "100 m hurdles", ja: "100mハードル", fr: "100\u00a0m haies" } }),
+    race({ id: "110m-hurdles", distance: 110, kind: "straight", hurdles: true, name: { en: "110 m hurdles", ja: "110mハードル", fr: "110\u00a0m haies" } }),
+    race({ id: "200m", distance: 200, kind: "stagger", bends: 1, name: { en: "200 m", ja: "200m", fr: "200\u00a0m" } }),
+    race({ id: "400m", distance: 400, kind: "stagger", bends: 2, name: { en: "400 m", ja: "400m", fr: "400\u00a0m" } }),
+    race({ id: "400m-hurdles", distance: 400, kind: "stagger", bends: 2, hurdles: true, name: { en: "400 m hurdles", ja: "400mハードル", fr: "400\u00a0m haies" } }),
+    race({ id: "800m", distance: 800, kind: "stagger", bends: 1, breakline: true, name: { en: "800 m", ja: "800m", fr: "800\u00a0m" } }),
+    race({ id: "1000m", distance: 1000, kind: "curved", group: true, name: { en: "1000 m", ja: "1000m", fr: "1000\u00a0m" } }),
+    race({ id: "1500m", distance: 1500, kind: "curved", name: { en: "1500 m", ja: "1500m", fr: "1500\u00a0m" } }),
+    race({ id: "mile", distance: 1609.344, kind: "curved", name: { en: "Mile", ja: "1マイル", fr: "Mile" } }),
+    race({ id: "2000m", distance: 2000, kind: "curved", group: true, name: { en: "2000 m", ja: "2000m", fr: "2000\u00a0m" } }),
+    race({ id: "3000m", distance: 3000, kind: "curved", group: true, name: { en: "3000 m", ja: "3000m", fr: "3000\u00a0m" } }),
+    race({ id: "5000m", distance: 5000, kind: "curved", group: true, name: { en: "5000 m", ja: "5000m", fr: "5000\u00a0m" } }),
+    race({ id: "10000m", distance: 10000, kind: "curved", group: true, name: { en: "10,000 m", ja: "10000m", fr: "10\u00a0000\u00a0m" } }),
+    race({ id: "2000m-steeplechase", distance: 2000, kind: "steeplechase", name: { en: "2000 m steeplechase", ja: "2000m障害物競走", fr: "2000\u00a0m steeple" } }),
+    race({ id: "3000m-steeplechase", distance: 3000, kind: "steeplechase", group: true, name: { en: "3000 m steeplechase", ja: "3000m障害物競走", fr: "3000\u00a0m steeple" } }),
+    race({ id: "4x100m", distance: 400, kind: "stagger", bends: 2, legs: [100, 100, 100, 100], name: { en: "4 x 100 m relay", ja: "4×100mリレー", fr: "Relais 4\u00a0×\u00a0100\u00a0m" } }),
+    race({ id: "4x400m", distance: 1600, kind: "stagger", bends: 3, breakline: true, legs: [400, 400, 400, 400], name: { en: "4 x 400 m relay", ja: "4×400mリレー", fr: "Relais 4\u00a0×\u00a0400\u00a0m" } }),
+]);
+/** The ids of the races. */
+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);
+const field = (f) => Object.freeze(f);
+/** The field events, in the order a menu lists them: the jumps and then the throws. */
+export const FIELD_EVENTS = Object.freeze([
+    field({ id: "high-jump", name: { en: "High jump", ja: "走高跳", fr: "Saut en hauteur" } }),
+    field({ id: "pole-vault", name: { en: "Pole vault", ja: "棒高跳", fr: "Saut à la perche" } }),
+    field({ id: "long-jump", name: { en: "Long jump", ja: "走幅跳", fr: "Saut en longueur" } }),
+    field({ id: "triple-jump", name: { en: "Triple jump", ja: "三段跳", fr: "Triple saut" } }),
+    field({ id: "shot-put", name: { en: "Shot put", ja: "砲丸投", fr: "Lancer du poids" } }),
+    field({ id: "discus-throw", name: { en: "Discus throw", ja: "円盤投", fr: "Lancer du disque" } }),
+    field({ id: "hammer-throw", name: { en: "Hammer throw", ja: "ハンマー投", fr: "Lancer du marteau" } }),
+    field({ id: "javelin-throw", name: { en: "Javelin throw", ja: "やり投", fr: "Lancer du javelot" } }),
+]);
+/** The ids of the field events. */
+export const FIELD_EVENT_IDS = Object.freeze(FIELD_EVENTS.map((f) => f.id));
+/** A field event by its id, or `undefined`. */
+export const fieldEventById = (id) => FIELD_EVENTS.find((f) => f.id === id);

package/dist/athletics/facilities.d.ts

@@ -0,0 +1,80 @@
+import type { Area, Shape } from "../fields.types.ts";
+import type { Parts } from "./oval.ts";
+import type { AthleticsFieldEvent } from "./types.ts";
+/** A point in the plan. */
+type Pt = readonly [number, number];
+/** What a facility is, as data: where it stands, which way it throws or jumps, and the figures that say how big it is. */
+export interface Facility {
+    id: string;
+    event: AthleticsFieldEvent;
+    /** The throw's circle centre, the javelin arc's centre point, the high jump's bar centre, the pole vault's box, the jump's take-off board. */
+    x: number;
+    y: number;
+    /** The direction of the throw or the jump, in radians clockwise from the right as the eye sees it. */
+    heading: number;
+    /** A box round all of it, for the ranges. */
+    box: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+    /** The length of the sector, or the runway, or the run-up. */
+    reach?: number;
+}
+/** The angle of a throw's sector: 34.92 degrees (Rule 32, landing sector; Manual 2.4.1.4). Its lines are 12 m apart (the chord) 20 m from the circle's centre, 0.60 m more for each metre further: 2 asin(0.3). */
+export declare const SECTOR_ANGLE: number;
+/** The javelin sector's half angle: the arc's radius is 8 m and the runway 4 m wide, so the lines through the arc's ends make 28.96 degrees (Rule 32, landing sector; Figure 2.4.3.2). */
+export declare const JAVELIN_HALF: number;
+/** A rectangle in the plan, `w` along `heading` and `h` across it, centred at `c`, as an area. */
+export declare function rectArea(id: string, cls: Area["cls"], feature: string, c: Pt, heading: number, w: number, h: number): Area;
+/** The outline of the same rectangle as a line. */
+export declare function rectLine(id: string, feature: string, c: Pt, heading: number, w: number, h: number, wLine: number): Shape;
+/** The sector of a throw: its two lines from the circle's rim to the arc, and the arc, 50 mm wide, the inner edges through the circle's centre (Rule 32, landing sector). */
+export declare function sectorShapes(id: string, feature: string, c: Pt, heading: number, rim: number, reach: number, half?: number): Shape[];
+/** A throwing circle (Rule 32, throwing circle, and 32.8; Manual 2.4.1.2): the concrete inside the rim, the rim, the 0.75 m lines at right angles to the sector's axis, the centre. `d` is the inside diameter. */
+export declare function circleParts(id: string, event: AthleticsFieldEvent, c: Pt, heading: number, d: number, rim?: number): Parts;
+/** The shot put's stop board (Rule 33.2; Manual 2.4.4.3): an arc on the circle's inside edge, 1.21 m long (the chord), 0.112 m wide, centred on the sector's axis. */
+export declare function stopBoard(id: string, c: Pt, heading: number, d: number): Area;
+/**
+ * A discus or hammer cage in plan (Rules 35 and 37; Manual 2.4.1.3, Figure 2.4.1.2): U-shaped, its mouth 6 m wide and 7 m in front of the circle's centre, the netting no nearer than 3 m behind it. The
+ * mouth and the line the sides take to it are the rules'; the rear is drawn as an arc about the centre, which is ours.
+ */
+export declare function cageShapes(id: string, c: Pt, heading: number): Shape[];
+/** The javelin's runway and arc (Rule 32, javelin throw runway; Manual 2.4.3.2 and 2.4.3.3), about the centre point of the arc and the throwing direction `heading` (0 throws right). */
+export declare function javelinParts(id: string, c: Pt, heading: number, runway?: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/** The box round some points. */
+export declare function bounds(points: readonly Pt[]): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * A high jump facility (Rule 27; Manual 2.3.3): the uprights 4.02 m apart (Rule 27.6: 4.00 to 4.04 m), the crossbar, the landing mat of 6 m by 4 m at the least (Rule 27, landing area; Manual 2.3.3.4) with the bar's
+ * plane 0.5 m inside its front edge, the 50 mm line 3 m outside each upright (Rule 27.2, note) and the run-up: a 16 m wide area, 15 m long (Rule 27.3: 25 m for the major competitions), drawn
+ * as a dashed outline cut by the arc of the 15 m radius. `heading` is the way the athlete jumps; the facility is about the bar's middle.
+ */
+export declare function highJumpParts(id: string, c: Pt, heading: number, runup?: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/**
+ * A pole vault's box and 0-line at the end of a runway (Rule 28; Manual 2.3.4.2): the box 1.00 m long, 0.60 m wide at the front and 0.15 m at the stop board, set so that the top inside
+ * edge of the stop board is on the 0-line, which is 10 mm wide and runs on past the uprights (5.20 m apart at the least). `c` is the middle of the stop board and `heading` the way the athlete
+ * runs; the landing mat of 6.00 m by 6.00 m at the least with front pieces 2 m long (Rule 28; Manual 2.3.4.4) lies beyond, its front 0.10 to 0.15 m from the box.
+ */
+export declare function poleVaultEnd(id: string, c: Pt, heading: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/** The runway of a jump: two lines 1.22 m apart (Rule 29; Manual 2.3.1.2) from `from` to `to` along `heading`, as lines. */
+export declare function runwayLines(id: string, event: AthleticsFieldEvent, from: Pt, to: Pt, width?: number): Shape[];
+/** A landing pit (Rule 30; Manual 2.3.1.4): the sand with its white border, `length` long along the jump and `width` across it, centred at `c`. */
+export declare function pitParts(id: string, event: AthleticsFieldEvent, c: Pt, heading: number, length: number, width: number): Parts;
+/** A take-off board (Rule 29, take-off board; Manual 2.3.1.3): 1.22 m by 0.20 m, white, whose edge nearer the pit is the take-off line, `d` metres from the pit's near end. `pitEdge` is that end's middle. */
+export declare function takeOffBoard(id: string, event: AthleticsFieldEvent, pitEdge: Pt, heading: number, d: number): Area;
+export {};

package/dist/athletics/facilities.js

@@ -0,0 +1,176 @@
+// The field events' facilities, each at the size the World Athletics Track and Field Facilities Manual (2019 edition, 2.3 and 2.4, Figures 2.3.1.1a, 2.3.2.1, 2.3.3.1, 2.3.4.1, 2.4.1.1 to 2.4.4.2)
+// and Technical Rules 25 to 38 of Book C2.1 give, in metres, and each made about its own origin and the direction of its throw or its run: a circle, a runway, a pit, a mat, a sector. The standard
+// stadium's places for them (Figure 2.5a and the Marking Plan) are in infield.ts. Nothing here draws SVG.
+import { arc, line, path, poly, ring } from "../fields.kit.js";
+import { num } from "../format.js";
+import { arcD } from "./track.js";
+import { emptyParts } from "./oval.js";
+/** The angle of a throw's sector: 34.92 degrees (Rule 32, landing sector; Manual 2.4.1.4). Its lines are 12 m apart (the chord) 20 m from the circle's centre, 0.60 m more for each metre further: 2 asin(0.3). */
+export const SECTOR_ANGLE = 2 * Math.asin(0.3);
+/** The javelin sector's half angle: the arc's radius is 8 m and the runway 4 m wide, so the lines through the arc's ends make 28.96 degrees (Rule 32, landing sector; Figure 2.4.3.2). */
+export const JAVELIN_HALF = Math.asin(2 / 8);
+const f = (n) => num(n);
+const at = (c, theta, k, side = 0) => [c[0] + k * Math.cos(theta) - side * Math.sin(theta), c[1] + k * Math.sin(theta) + side * Math.cos(theta)];
+/** The path of a closed polygon filled as an area. */
+const polyArea = (id, cls, feature, points) => ({ id, feature, cls, d: `M${points.map(([x, y]) => `${f(x)} ${f(y)}`).join("L")}Z` });
+/** A rectangle in the plan, `w` along `heading` and `h` across it, centred at `c`, as an area. */
+export function rectArea(id, cls, feature, c, heading, w, h) {
+    return polyArea(id, cls, feature, [at(c, heading, -w / 2, -h / 2), at(c, heading, w / 2, -h / 2), at(c, heading, w / 2, h / 2), at(c, heading, -w / 2, h / 2)]);
+}
+/** The outline of the same rectangle as a line. */
+export function rectLine(id, feature, c, heading, w, h, wLine) {
+    return poly(id, feature, [at(c, heading, -w / 2, -h / 2), at(c, heading, w / 2, -h / 2), at(c, heading, w / 2, h / 2), at(c, heading, -w / 2, h / 2)], { closed: true, w: wLine });
+}
+/** The sector of a throw: its two lines from the circle's rim to the arc, and the arc, 50 mm wide, the inner edges through the circle's centre (Rule 32, landing sector). */
+export function sectorShapes(id, feature, c, heading, rim, reach, half = SECTOR_ANGLE / 2) {
+    const a = heading - half;
+    const b = heading + half;
+    const p0 = at(c, a, rim);
+    const p1 = at(c, a, reach);
+    const q0 = at(c, b, rim);
+    const q1 = at(c, b, reach);
+    const thin = { cls: "ky-ath-s", least: 0.07 };
+    return [poly(`${id}-sector-line`, feature, [p0, p1], thin), poly(`${id}-sector-line`, feature, [q0, q1], thin), path(`${id}-sector-arc`, feature, arcD(c[0], c[1], reach, a, b), thin)];
+}
+/** A throwing circle (Rule 32, throwing circle, and 32.8; Manual 2.4.1.2): the concrete inside the rim, the rim, the 0.75 m lines at right angles to the sector's axis, the centre. `d` is the inside diameter. */
+export function circleParts(id, event, c, heading, d, rim = 0.06) {
+    const parts = emptyParts();
+    const r = d / 2;
+    parts.areas.push({ id: `${id}-circle`, feature: event, cls: "ky-ath-concrete", d: `M${f(c[0] - r)} ${f(c[1])}A${f(r)} ${f(r)} 0 1 0 ${f(c[0] + r)} ${f(c[1])}A${f(r)} ${f(r)} 0 1 0 ${f(c[0] - r)} ${f(c[1])}Z` });
+    parts.shapes.push(ring(`${id}-rim`, event, c[0], c[1], r + rim / 2, r + rim / 2, { w: rim }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0, side * (r + rim));
+        const q = at(c, heading, 0, side * (r + rim + 0.75));
+        parts.shapes.push(line(`${id}-circle-line`, event, p[0], p[1], q[0], q[1], { w: 0.05 }));
+    }
+    return parts;
+}
+/** The shot put's stop board (Rule 33.2; Manual 2.4.4.3): an arc on the circle's inside edge, 1.21 m long (the chord), 0.112 m wide, centred on the sector's axis. */
+export function stopBoard(id, c, heading, d) {
+    const r = d / 2;
+    const half = Math.asin(1.21 / 2 / r);
+    const inner = r;
+    const outer = r + 0.112;
+    const p = (k, th) => at(c, th, k);
+    const a = heading - half;
+    const b = heading + half;
+    const [i0, i1, o0, o1] = [p(inner, a), p(inner, b), p(outer, a), p(outer, b)];
+    return { id: `${id}-stop-board`, feature: "shot-put", cls: "ky-ath-board", d: `M${f(i0[0])} ${f(i0[1])}A${f(inner)} ${f(inner)} 0 0 1 ${f(i1[0])} ${f(i1[1])}L${f(o1[0])} ${f(o1[1])}A${f(outer)} ${f(outer)} 0 0 0 ${f(o0[0])} ${f(o0[1])}Z` };
+}
+/**
+ * A discus or hammer cage in plan (Rules 35 and 37; Manual 2.4.1.3, Figure 2.4.1.2): U-shaped, its mouth 6 m wide and 7 m in front of the circle's centre, the netting no nearer than 3 m behind it. The
+ * mouth and the line the sides take to it are the rules'; the rear is drawn as an arc about the centre, which is ours.
+ */
+export function cageShapes(id, c, heading) {
+    const mouth = [7, 3];
+    const wide = 4.4;
+    const pts = (u, v) => at(c, heading, u, v);
+    const back = 4.4;
+    const left = [pts(mouth[0], -mouth[1]), pts(0, -wide)];
+    const right = [pts(mouth[0], mouth[1]), pts(0, wide)];
+    const a0 = heading - Math.PI / 2;
+    const a1 = heading + Math.PI / 2;
+    const rear = arcD(c[0], c[1], back, a0 + Math.PI, a1 + Math.PI);
+    return [poly(`${id}-cage`, "cage", [left[0], left[1]], { w: 0.12, cls: "ky-ath-k" }), poly(`${id}-cage`, "cage", [right[0], right[1]], { w: 0.12, cls: "ky-ath-k" }), path(`${id}-cage`, "cage", rear, { w: 0.12, cls: "ky-ath-k" })];
+}
+/** The javelin's runway and arc (Rule 32, javelin throw runway; Manual 2.4.3.2 and 2.4.3.3), about the centre point of the arc and the throwing direction `heading` (0 throws right). */
+export function javelinParts(id, c, heading, runway = 36.5) {
+    const parts = emptyParts();
+    const xe = 8 * Math.cos(JAVELIN_HALF);
+    const w = 2;
+    // The runway: two lines 4 m apart from the ends of the arc back `runway` metres, the arc, and the 0.75 m lines at right angles to the runway at the arc's ends.
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, xe, side * w);
+        const q = at(c, heading, xe - runway, side * w);
+        parts.shapes.push(line(`${id}-runway-line`, "javelin-throw", p[0], p[1], q[0], q[1], { w: 0.05 }));
+        const m0 = at(c, heading, xe, side * w);
+        const m1 = at(c, heading, xe, side * (w + 0.75));
+        parts.shapes.push(line(`${id}-arc-mark`, "javelin-throw", m0[0], m0[1], m1[0], m1[1], { w: 0.07 }));
+        // Two white squares of 0.05 m beside the runway, 4 m back from the ends of the arc.
+        const sq = at(c, heading, xe - 4, side * (w + 0.12));
+        parts.shapes.push(line(`${id}-square`, "javelin-throw", sq[0], sq[1], sq[0], sq[1], { w: 0.05 }));
+    }
+    parts.shapes.push(arc(`${id}-arc`, "javelin-throw", c[0], c[1], 8, (heading - JAVELIN_HALF) * (180 / Math.PI), (heading + JAVELIN_HALF) * (180 / Math.PI), { w: 0.07 }));
+    parts.shapes.push(...sectorShapes(id, "javelin-throw", c, heading, 8, 100, JAVELIN_HALF));
+    const end = at(c, heading, xe - runway, 0);
+    const box = bounds([end, at(c, heading, 100, -25), at(c, heading, 100, 25), at(c, heading, 0, 0), at(c, heading, 100, 0)]);
+    return { parts, facility: { id, event: "javelin-throw", x: c[0], y: c[1], heading, box, reach: 100 } };
+}
+/** The box round some points. */
+export function bounds(points) {
+    const xs = points.map((p) => p[0]);
+    const ys = points.map((p) => p[1]);
+    return { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
+}
+/**
+ * A high jump facility (Rule 27; Manual 2.3.3): the uprights 4.02 m apart (Rule 27.6: 4.00 to 4.04 m), the crossbar, the landing mat of 6 m by 4 m at the least (Rule 27, landing area; Manual 2.3.3.4) with the bar's
+ * plane 0.5 m inside its front edge, the 50 mm line 3 m outside each upright (Rule 27.2, note) and the run-up: a 16 m wide area, 15 m long (Rule 27.3: 25 m for the major competitions), drawn
+ * as a dashed outline cut by the arc of the 15 m radius. `heading` is the way the athlete jumps; the facility is about the bar's middle.
+ */
+export function highJumpParts(id, c, heading, runup = 15) {
+    const parts = emptyParts();
+    parts.areas.push(rectArea(`${id}-mat`, "ky-ath-mat", "high-jump", at(c, heading, 1.5), heading, 4, 6));
+    parts.shapes.push(rectLine(`${id}-mat-edge`, "high-jump", at(c, heading, 1.5), heading, 4, 6, 0.05));
+    const a = at(c, heading, 0, -5.01);
+    const b = at(c, heading, 0, 5.01);
+    parts.shapes.push(line(`${id}-take-off-line`, "high-jump", a[0], a[1], b[0], b[1], { w: 0.05 }));
+    const bar0 = at(c, heading, 0, -2.01);
+    const bar1 = at(c, heading, 0, 2.01);
+    parts.shapes.push(line(`${id}-crossbar`, "high-jump", bar0[0], bar0[1], bar1[0], bar1[1], { w: 0.04, cls: "ky-ath-k" }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0, side * 2.01);
+        parts.shapes.push({ kind: "dot", id: `${id}-upright`, feature: "high-jump", cx: p[0], cy: p[1], r: 0.1, paint: "post" });
+    }
+    // The run-up: 8 m either side of the middle of the bar, to 15 m back, rounded by the arc of 15 m about the bar's middle.
+    const half = 8;
+    const x = Math.sqrt(runup * runup - half * half);
+    const [p0, p1] = [at(c, heading, 0, -half), at(c, heading, -x, -half)];
+    const [q0, q1] = [at(c, heading, -x, half), at(c, heading, 0, half)];
+    const sweep = 0;
+    const d = `M${f(p0[0])} ${f(p0[1])}L${f(p1[0])} ${f(p1[1])}A${f(runup)} ${f(runup)} 0 0 ${sweep} ${f(q0[0])} ${f(q0[1])}L${f(q1[0])} ${f(q1[1])}`;
+    parts.shapes.push(path(`${id}-run-up`, "high-jump", d, { w: 0.04, dash: [0.6, 0.6], least: 0.04 }));
+    const box = bounds([at(c, heading, 4.5, -3.2), at(c, heading, 4.5, 3.2), at(c, heading, -runup, -half), at(c, heading, -runup, half)]);
+    return { parts, facility: { id, event: "high-jump", x: c[0], y: c[1], heading, box, reach: runup } };
+}
+/**
+ * A pole vault's box and 0-line at the end of a runway (Rule 28; Manual 2.3.4.2): the box 1.00 m long, 0.60 m wide at the front and 0.15 m at the stop board, set so that the top inside
+ * edge of the stop board is on the 0-line, which is 10 mm wide and runs on past the uprights (5.20 m apart at the least). `c` is the middle of the stop board and `heading` the way the athlete
+ * runs; the landing mat of 6.00 m by 6.00 m at the least with front pieces 2 m long (Rule 28; Manual 2.3.4.4) lies beyond, its front 0.10 to 0.15 m from the box.
+ */
+export function poleVaultEnd(id, c, heading) {
+    const parts = emptyParts();
+    parts.areas.push(polyArea(`${id}-box`, "ky-ath-pad", "pole-vault", [at(c, heading, -1, -0.3), at(c, heading, 0, -0.075), at(c, heading, 0, 0.075), at(c, heading, -1, 0.3)]));
+    parts.areas.push(rectArea(`${id}-mat`, "ky-ath-mat", "pole-vault", at(c, heading, 0.15 + 4), heading, 8, 6));
+    parts.shapes.push(rectLine(`${id}-mat-edge`, "pole-vault", at(c, heading, 0.15 + 4), heading, 8, 6, 0.05));
+    const a = at(c, heading, 0, -2.8);
+    const b = at(c, heading, 0, 2.8);
+    parts.shapes.push(line(`${id}-zero-line`, "pole-vault", a[0], a[1], b[0], b[1], { w: 0.03, least: 0.08, cls: "ky-ath-r" }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0.1, side * 2.6);
+        parts.shapes.push({ kind: "dot", id: `${id}-upright`, feature: "pole-vault", cx: p[0], cy: p[1], r: 0.1, paint: "post" });
+    }
+    const box = bounds([at(c, heading, -45, -0.7), at(c, heading, -45, 0.7), at(c, heading, 8.2, -3), at(c, heading, 8.2, 3)]);
+    return { parts, facility: { id, event: "pole-vault", x: c[0], y: c[1], heading, box, reach: 45 } };
+}
+/** The runway of a jump: two lines 1.22 m apart (Rule 29; Manual 2.3.1.2) from `from` to `to` along `heading`, as lines. */
+export function runwayLines(id, event, from, to, width = 1.22) {
+    const heading = Math.atan2(to[1] - from[1], to[0] - from[0]);
+    return [-1, 1].map((side) => {
+        const a = at(from, heading, 0, (side * width) / 2);
+        const b = at(to, heading, 0, (side * width) / 2);
+        return line(`${id}-runway-line`, event, a[0], a[1], b[0], b[1], { w: 0.05 });
+    });
+}
+/** A landing pit (Rule 30; Manual 2.3.1.4): the sand with its white border, `length` long along the jump and `width` across it, centred at `c`. */
+export function pitParts(id, event, c, heading, length, width) {
+    const parts = emptyParts();
+    parts.areas.push(rectArea(`${id}-pit`, "ky-ath-sand", event, c, heading, length, width));
+    parts.shapes.push(rectLine(`${id}-pit-border`, event, c, heading, length, width, 0.05));
+    return parts;
+}
+/** A take-off board (Rule 29, take-off board; Manual 2.3.1.3): 1.22 m by 0.20 m, white, whose edge nearer the pit is the take-off line, `d` metres from the pit's near end. `pitEdge` is that end's middle. */
+export function takeOffBoard(id, event, pitEdge, heading, d) {
+    // The board lies behind the take-off line, away from the pit: along the run, `d` from the pit's near end is the line and the board is the 0.20 m before it.
+    const line0 = at(pitEdge, heading, -d);
+    return rectArea(id, "ky-ath-board", event, at(line0, heading, -0.1), heading, 0.2, 1.22);
+}

package/dist/athletics/infield.d.ts

@@ -0,0 +1,79 @@
+import type { Shape } from "../fields.types.ts";
+import { type Facility } from "./facilities.ts";
+import { type Parts } from "./oval.ts";
+import type { Oval } from "./track.ts";
+import type { AthleticsFieldEvent } from "./types.ts";
+/** The sectors' lengths (Manual 2.1.1.3 and Figures 2.4.1.1, 2.4.2.1, 2.4.3.1, 2.4.4.1): the shot's 25 m, the discus's 80 m, the hammer's 90 m, the javelin's 100 m. */
+export declare const SECTOR_REACH: {
+    readonly "shot-put": 25;
+    readonly "discus-throw": 80;
+    readonly "hammer-throw": 90;
+    readonly "javelin-throw": 100;
+};
+/** Where the standard stadium puts each facility, in metres from the centre of the semicircle of its segment (CP1 at the left, CP2 at the right), read from the Marking Plan. */
+export declare const ARENA: {
+    /** The synthetic surface of a segment ends, and the turf of the infield begins, this far from the semicircle's centre along the straights' axis (Marking Plan; 108.39 m of turf between: a 105 m pitch fits). */
+    readonly turf: 12;
+    /** The javelin arc's apex is this far beyond the segment's centre; the centre point is 8 m behind it. */
+    readonly javelinApex: number;
+    /** The shot put circles: from the segment's centre outward along the axis, and the distance up or down. */
+    readonly shotWest: {
+        readonly out: 13.5;
+        readonly across: 18.15;
+    };
+    readonly shotEast: {
+        readonly out: 14.2;
+        readonly across: 18.5;
+    };
+    /** The combined discus and hammer circle of the second segment. */
+    readonly discus: {
+        readonly out: 20.4;
+        readonly across: -24.1;
+        readonly heading: number;
+    };
+    /** The two pole vault runways of the first segment: their middle lines, the boxes' places and the length, from the axis. */
+    readonly vaultA: {
+        readonly out: 23.26;
+        readonly box: 16.5;
+    };
+    readonly vaultB: {
+        readonly out: 15.82;
+        readonly box: 20.7;
+    };
+    readonly vaultReach: 26;
+    /** The high jumps: the bar's distance beyond the segment's centre and the distance of each from the axis (the spacing of two sets of uprights is 12 to 15 m: 13.5 m). */
+    readonly highJump: {
+        readonly out: 15;
+        readonly across: 6.75;
+    };
+    /** The long and triple jump beyond the back straight (Figure 2.5a, Marking Plan): the strip, the two runways' middle lines, and the pits' places along the straight. */
+    readonly strip: {
+        readonly x0: -45.6;
+        readonly x1: 46.2;
+        readonly y0: -56.6;
+    };
+    readonly rows: readonly [{
+        readonly y: -54.2;
+        readonly west: readonly [-39.7, -31.7];
+        readonly east: readonly [23, 31.1];
+    }, {
+        readonly y: -50.4;
+        readonly west: readonly [-30.9, -22.9];
+        readonly east: readonly [31.9, 40];
+    }];
+};
+/** What the infield is made of: shapes and areas, the facilities as data, and the box of what lies beyond the oval. */
+export interface Infield {
+    parts: Parts;
+    facilities: Facility[];
+}
+/** The standard stadium's field events, those asked for. */
+export declare function infieldParts(o: Oval, events: ReadonlySet<AthleticsFieldEvent>): Infield;
+/** The strip beyond the back straight where the long and the triple jumps are, as a box, when they are drawn. */
+export declare const jumpStrip: () => {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export type { Shape };