@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/atlas-entry.d.ts

@@ -1,4 +1,6 @@
-export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByName, surfaceOf } from "./atlas.ts";
+export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.ts";
 export { officialName, plainName } from "./names.ts";
+export { TENANTS, TENANT_JAPANESE_NAMES, nameJaOf } from "./tenants.ts";
 export type { PlaceAlias, PlaceNameKind } from "./names.ts";
-export type { AtlasFacets, Place, PlaceFilter, PlaceKind, PlaceSport, PlaceStatus } from "./atlas.ts";
+export type { AtlasFacets, Place, PlaceFilter, PlaceKind, PlaceSport, PlaceStatus, PlaceSurface, SurfaceSport, TenantFilter } from "./atlas.ts";
+export type { Tenant, TenantArticle, TenantNameJa, TenantNameKind, TenantSource, TenantSport } from "./tenants.ts";

package/dist/atlas-entry.js

@@ -1,3 +1,4 @@
-// The atlas: every ballpark and soccer ground with where it stands and when it was in use, and the filters over them.
-export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByName, surfaceOf } from "./atlas.js";
+// The atlas: every ballpark and soccer ground with where it stands, when it was in use and the clubs that played there, and the filters over them.
+export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.js";
 export { officialName, plainName } from "./names.js";
+export { TENANTS, TENANT_JAPANESE_NAMES, nameJaOf } from "./tenants.js";

package/dist/atlas.d.ts

@@ -1,4 +1,5 @@
 import type { PlaceAlias } from "./names.ts";
+import type { Tenant, TenantSport } from "./tenants.ts";
 /** What a place is: a ballpark (of `PARKS`) or a soccer ground (of `GROUNDS`). */
 export type PlaceKind = "park" | "ground";
 /** The sport a place is drawn for: baseball parks have a fence, soccer grounds a pitch. */
@@ -28,12 +29,14 @@ export interface Place {
         to: number;
     }[];
     sport: PlaceSport;
-    /** The leagues and competitions it is known for: `MLB`, `NPB`, `FIFA World Cup`, `FIFA Women's World Cup`. A club ground that staged none has none. */
+    /** The leagues and competitions it is known for: the leagues of the park's club and of every club that has played its home matches there (`CFL` and `MLS` for BC Place, `MLB` and `CFL` for Montreal's Olympic Stadium), then the World Cups it staged (`FIFA World Cup`, `FIFA Women's World Cup`). A ground with no tenant that staged none has none. */
     leagues: readonly string[];
+    /** The clubs that play, or played, their home matches there, with the league and the years of each (see `tenantsOf`): the current ones first. A place no club is known to have called home has none. */
+    tenants: readonly Tenant[];
     /** ISO 3166-1 alpha-2: `US`. */
     country: string;
     city: string;
-    /** The club that plays in a park (`Boston Red Sox`); soccer grounds have none. */
+    /** The club that plays in a park (`Boston Red Sox`); soccer grounds have none (see `tenants`). */
     team?: string;
     /** Wikidata's coordinates (P625, CC0), in degrees. */
     lat: number;
@@ -45,19 +48,21 @@ export interface Place {
     to?: number;
     /** The Wikidata item (`Q49136`): the key to join a place to other data. */
     wikidata: string;
+    /** True where Wikidata lists athletics among the sports of a soccer ground: a running track lies round its pitch (`drawKyogijo({ sport: "athletics", ground })`). Absent where Wikidata says nothing of it. */
+    track?: boolean;
 }
 /** What `placesBy` keeps: every field given must match. A list matches any of its members. */
 export interface PlaceFilter {
     sport?: PlaceSport | readonly PlaceSport[];
     kind?: PlaceKind | readonly PlaceKind[];
-    /** A league or competition from `Place.leagues`. */
+    /** A league or competition from `Place.leagues`: a tenant's league (`CFL`) or a tournament. */
     league?: string | readonly string[];
     /** ISO 3166-1 alpha-2. */
     country?: string | readonly string[];
     status?: PlaceStatus | readonly PlaceStatus[];
     /** Keep the places in use in this year. A year that is not known for a place (no `from`, no `to`) does not shut it out. */
     year?: number;
-    /** Words to find in any name (the everyday names, the aliases, the readings), the city or the club, ignoring case, accents, width and, in Japanese, hiragana or katakana; every word must be found. */
+    /** Words to find in any name (the everyday names, the aliases, the readings), the city or the club, or the name of a club that plays or played there (in English or in Japanese), ignoring case, accents, width and, in Japanese, hiragana or katakana; every word must be found. */
     text?: string;
 }
 /**
@@ -116,12 +121,50 @@ export interface AtlasFacets {
  * ```ts
  * import { atlasFacets } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
  * const { sports, leagues, countries, years } = atlasFacets();
- * console.log(sports.join(), leagues.join(), countries.length, years.min);
- * // baseball,soccer FIFA Women's World Cup,FIFA World Cup,MLB,NPB 23 1877
+ * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
+ * // baseball,soccer 83 true 23 1877
  * ```
  */
 export declare function atlasFacets(): AtlasFacets;
-/** The options `drawKyogijo` takes to draw a place's surface: a park's fence or a ground's pitch at its own size. */
+/** The options `drawKyogijo` takes to draw a surface a place offers. */
+export type PlaceSurface = {
+    sport: "mlb";
+    park: string;
+} | {
+    sport: "soccer";
+    ground?: string;
+} | {
+    sport: "nfl" | "cfl" | "nba" | "nhl" | "afl" | "cricket";
+} | {
+    sport: "rugby";
+    league?: "nrl";
+};
+/** The sports `surfaceOf` can be asked for. */
+export type SurfaceSport = PlaceSurface["sport"];
+/**
+ * Every surface a place offers, the place's own first: a park's fence (`mlb` with the park) or a ground's pitch at its size (`soccer` with the ground), then one for each
+ * sport a tenant plays that the package draws (a CFL field for BC Place, an NFL field for MetLife Stadium, the rugby league field for Stadium Australia), each once. A ground
+ * offers no ballpark, since its fence is not known; a park that a soccer club has played in offers the pitch at the international size, since its length and width are not known.
+ * @example
+ * ```ts
+ * import { placeById, surfacesOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(surfacesOf(placeById("bc-place")!).map((surface) => surface.sport).join());
+ * // soccer,cfl
+ * ```
+ */
+export declare function surfacesOf(place: Place): PlaceSurface[];
+/**
+ * The options `drawKyogijo` takes to draw a place's surface. With no sport, the place's own: a park's fence or a ground's pitch at its own size. With a sport (the `sport` of
+ * `drawKyogijo`: `cfl`, `nfl`, `mlb`, `soccer`, `nba`, `nhl`, `rugby`, `afl`, `cricket`), the surface the place offers for it (`surfacesOf`), or `undefined` when no club that plays
+ * that sport has played there: `surfaceOf(bcPlace, "cfl")` is `{ sport: "cfl" }` and `surfaceOf(fenwayPark, "cfl")` is `undefined`.
+ * @example
+ * ```ts
+ * import { placeById, surfaceOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const bcPlace = placeById("bc-place")!;
+ * console.log(surfaceOf(bcPlace), surfaceOf(bcPlace, "cfl"), surfaceOf(bcPlace, "mlb"));
+ * // { sport: 'soccer', ground: 'bc-place' } { sport: 'cfl' } undefined
+ * ```
+ */
 export declare function surfaceOf(place: Place): {
     sport: "mlb";
     park: string;
@@ -129,3 +172,36 @@ export declare function surfaceOf(place: Place): {
     sport: "soccer";
     ground: string;
 };
+export declare function surfaceOf(place: Place, sport: SurfaceSport): PlaceSurface | undefined;
+/** What `tenantsOf` keeps: every field given must match. */
+export interface TenantFilter {
+    /** Keep the clubs that played there in this year. A bound the data does not give does not shut a club out. */
+    year?: number;
+    league?: string | readonly string[];
+    sport?: TenantSport | readonly TenantSport[];
+    /** `true` keeps the clubs that play there still (no last year), `false` those that have left. */
+    current?: boolean;
+}
+/**
+ * The clubs that play, or played, their home matches in a place, the current ones first (by the year they came) and then those that have left (the latest to leave first).
+ * Give a place, or its key.
+ * @example
+ * ```ts
+ * import { placeById, tenantsOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const expos = tenantsOf("olympic-stadium-montreal").map((t) => `${t.club} (${t.league}) ${t.from}-${t.to ?? ""}`);
+ * console.log(expos[0], tenantsOf(placeById("bc-place")!, { current: true }).map((t) => t.club).join(", "));
+ * // Montreal Expos (MLB) 1977-2004 BC Lions, Vancouver Whitecaps FC
+ * ```
+ */
+export declare function tenantsOf(place: Place | string | undefined, filter?: TenantFilter): Tenant[];
+/**
+ * The places a club plays, or played, its home matches in, best match first: a club whose name is the one given (ignoring case, accents, spaces and punctuation, width, and in
+ * Japanese hiragana or katakana), then a club whose name has every word given in it (`whitecaps`, `lions`, `ライオンズ`); the names are the club's in English and in Japanese.
+ * @example
+ * ```ts
+ * import { placesByClub } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(placesByClub("BC Lions").map((place) => place.id).join(), placesByClub("Montreal Expos").map((place) => place.id).join());
+ * // bc-place jarry-park-stadium,olympic-stadium-montreal
+ * ```
+ */
+export declare function placesByClub(name: string | undefined): Place[];

package/dist/atlas.js

@@ -1,6 +1,7 @@
 import { GROUNDS, GROUND_IDS } from "./grounds.js";
 import { nameContainsAll, placesNamed, plainName } from "./names.js";
 import { PARKS, PARK_IDS } from "./parks.js";
+import { SURFACE_OF_SPORT, TENANTS, hasSurface, leaguesOf, playedIn } from "./tenants.js";
 const leaguesOfGround = (ground) => {
     const leagues = [];
     if (ground.tournaments.some((t) => t.competition === "world-cup"))
@@ -9,7 +10,9 @@ const leaguesOfGround = (ground) => {
         leagues.push("FIFA Women's World Cup");
     return leagues;
 };
+const withoutRepeats = (...lists) => [...new Set(lists.flat())];
 const fromPark = (park) => {
+    const tenants = TENANTS[park.id] ?? [];
     const from = park.from ?? park.opened;
     const to = park.to ?? park.closed;
     return {
@@ -21,7 +24,8 @@ const fromPark = (park) => {
         ...(park.localName === undefined ? {} : { localName: park.localName, localLanguage: park.localLanguage }),
         aliases: park.aliases ?? [],
         sport: "baseball",
-        leagues: [park.league],
+        leagues: withoutRepeats([park.league], leaguesOf(tenants)),
+        tenants,
         country: park.country,
         city: park.city,
         team: park.team,
@@ -44,7 +48,8 @@ const fromGround = (ground) => ({
     aliases: ground.aliases ?? [],
     ...(ground.names === undefined ? {} : { names: ground.names }),
     sport: "soccer",
-    leagues: leaguesOfGround(ground),
+    leagues: withoutRepeats(leaguesOf(TENANTS[ground.id] ?? []), leaguesOfGround(ground)),
+    tenants: TENANTS[ground.id] ?? [],
     country: ground.country,
     city: ground.city,
     lat: ground.lat,
@@ -53,6 +58,7 @@ const fromGround = (ground) => ({
     ...(ground.from === undefined ? {} : { from: ground.from }),
     ...(ground.status === "past" && ground.to !== undefined ? { to: ground.to } : {}),
     wikidata: ground.wikidata,
+    ...(ground.track === true ? { track: true } : {}),
 });
 /**
  * Every place the package draws, parks first and then grounds, each in the order of its own list: the ballparks of
@@ -118,7 +124,9 @@ export function placesBy(filter = {}) {
             return false;
         if (words.length > 0) {
             const haystack = plain([place.city, place.team, place.country].filter(Boolean).join(" "));
-            if (!words.every((word) => haystack.includes(word) || nameContainsAll(place, [word])))
+            // A word may be in the name of any one club that played there.
+            const clubs = place.tenants.map((tenant) => plain([tenant.club, tenant.clubJa, ...(tenant.aliasesJa ?? [])].filter(Boolean).join(" ")));
+            if (!words.every((word) => haystack.includes(word) || nameContainsAll(place, [word]) || clubs.some((club) => club.includes(word))))
                 return false;
         }
         return true;
@@ -130,8 +138,8 @@ export function placesBy(filter = {}) {
  * ```ts
  * import { atlasFacets } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
  * const { sports, leagues, countries, years } = atlasFacets();
- * console.log(sports.join(), leagues.join(), countries.length, years.min);
- * // baseball,soccer FIFA Women's World Cup,FIFA World Cup,MLB,NPB 23 1877
+ * console.log(sports.join(), leagues.length, leagues.includes("CFL"), countries.length, years.min);
+ * // baseball,soccer 83 true 23 1877
  * ```
  */
 export function atlasFacets() {
@@ -143,7 +151,99 @@ export function atlasFacets() {
         years: { min: Math.min(...years), max: Math.max(...years) },
     };
 }
-/** The options `drawKyogijo` takes to draw a place's surface: a park's fence or a ground's pitch at its own size. */
-export function surfaceOf(place) {
-    return place.kind === "park" ? { sport: "mlb", park: place.id } : { sport: "soccer", ground: place.id };
+/**
+ * Every surface a place offers, the place's own first: a park's fence (`mlb` with the park) or a ground's pitch at its size (`soccer` with the ground), then one for each
+ * sport a tenant plays that the package draws (a CFL field for BC Place, an NFL field for MetLife Stadium, the rugby league field for Stadium Australia), each once. A ground
+ * offers no ballpark, since its fence is not known; a park that a soccer club has played in offers the pitch at the international size, since its length and width are not known.
+ * @example
+ * ```ts
+ * import { placeById, surfacesOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(surfacesOf(placeById("bc-place")!).map((surface) => surface.sport).join());
+ * // soccer,cfl
+ * ```
+ */
+export function surfacesOf(place) {
+    const own = place.kind === "park" ? { sport: "mlb", park: place.id } : { sport: "soccer", ground: place.id };
+    const out = [own];
+    for (const tenant of place.tenants) {
+        const drawn = SURFACE_OF_SPORT[tenant.sport];
+        if (drawn === undefined || !hasSurface(tenant))
+            continue;
+        // A baseball club's fence is a park's: a ground has none to draw.
+        if (drawn.sport === "mlb")
+            continue;
+        const surface = drawn.sport === "soccer" ? { sport: "soccer" } : drawn.sport === "rugby" ? { sport: "rugby", ...(drawn.league === undefined ? {} : { league: drawn.league }) } : { sport: drawn.sport };
+        if (out.some((have) => have.sport === surface.sport && (have.sport !== "rugby" || have.league === surface.league)))
+            continue;
+        out.push(surface);
+    }
+    return out;
+}
+export function surfaceOf(place, sport) {
+    if (sport === undefined)
+        return place.kind === "park" ? { sport: "mlb", park: place.id } : { sport: "soccer", ground: place.id };
+    return surfacesOf(place).find((surface) => surface.sport === sport);
+}
+/**
+ * The clubs that play, or played, their home matches in a place, the current ones first (by the year they came) and then those that have left (the latest to leave first).
+ * Give a place, or its key.
+ * @example
+ * ```ts
+ * import { placeById, tenantsOf } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * const expos = tenantsOf("olympic-stadium-montreal").map((t) => `${t.club} (${t.league}) ${t.from}-${t.to ?? ""}`);
+ * console.log(expos[0], tenantsOf(placeById("bc-place")!, { current: true }).map((t) => t.club).join(", "));
+ * // Montreal Expos (MLB) 1977-2004 BC Lions, Vancouver Whitecaps FC
+ * ```
+ */
+export function tenantsOf(place, filter = {}) {
+    const found = typeof place === "string" ? BY_ID.get(place) : place;
+    if (found === undefined)
+        return [];
+    const leagues = many(filter.league);
+    const sports = many(filter.sport);
+    const year = filter.year !== undefined && Number.isFinite(filter.year) ? filter.year : undefined;
+    return found.tenants.filter((tenant) => {
+        if (leagues !== undefined && !leagues.includes(tenant.league))
+            return false;
+        if (sports !== undefined && !sports.includes(tenant.sport))
+            return false;
+        if (filter.current !== undefined && (tenant.to === undefined) !== filter.current)
+            return false;
+        return year === undefined || playedIn(tenant, year);
+    });
+}
+/**
+ * The places a club plays, or played, its home matches in, best match first: a club whose name is the one given (ignoring case, accents, spaces and punctuation, width, and in
+ * Japanese hiragana or katakana), then a club whose name has every word given in it (`whitecaps`, `lions`, `ライオンズ`); the names are the club's in English and in Japanese.
+ * @example
+ * ```ts
+ * import { placesByClub } from "@johnmorrisdotca/kyogijo-stadiums/atlas";
+ * console.log(placesByClub("BC Lions").map((place) => place.id).join(), placesByClub("Montreal Expos").map((place) => place.id).join());
+ * // bc-place jarry-park-stadium,olympic-stadium-montreal
+ * ```
+ */
+export function placesByClub(name) {
+    if (name === undefined)
+        return [];
+    const wanted = plain(name);
+    const words = name.split(/\s+/).map(plain).filter(Boolean);
+    if (wanted === "")
+        return [];
+    const ranked = [];
+    PLACES.forEach((place, index) => {
+        let best;
+        for (const tenant of place.tenants) {
+            for (const club of [tenant.club, tenant.clubJa, ...(tenant.aliasesJa ?? [])]) {
+                if (club === undefined)
+                    continue;
+                const own = plain(club);
+                const rank = own === wanted ? 0 : words.every((word) => own.includes(word)) ? 1 : undefined;
+                if (rank !== undefined && (best === undefined || rank < best))
+                    best = rank;
+            }
+        }
+        if (best !== undefined)
+            ranked.push([best, index, place]);
+    });
+    return ranked.sort((a, b) => a[0] - b[0] || a[1] - b[1]).map((row) => row[2]);
 }

package/dist/charts-entry.d.ts

@@ -2,9 +2,14 @@ export { nbaShotChart, nflPassChart, nhlShotMap } from "./charts.ts";
 export { mlbSprayChart } from "./charts.baseball.ts";
 export { soccerGoalMouth, soccerShotMap } from "./charts.soccer.ts";
 export { CURLING_COLORS, curlingScore, curlingStones } from "./charts.curling.ts";
+export { curlingHeat } from "./charts.curling.heat.ts";
+export { CURLING_HIT_TYPES, curlingEndStats, curlingFreeGuards, curlingGuardScores, curlingHammers, curlingInPlay, curlingIsHit, curlingShotStats } from "./curling.stats.ts";
+export type { CurlingEndRecord, CurlingEndScore, CurlingEndStats, CurlingGuardEnd, CurlingGuardScores, CurlingGuards, CurlingHammerStats, CurlingInPlay, CurlingShot, CurlingShotLine, CurlingShotStats, CurlingSide, CurlingStealStats, CurlingTeamEnds } from "./curling.stats.ts";
+export { splitsChart } from "./charts.pool.ts";
+export type { SplitRow, SplitsOptions, SplitsTotals, SwimmerSplits } from "./charts.pool.ts";
 export { passNetwork } from "./charts.network.ts";
 export type { PassNetworkOptions, PassNetworkPass, PassNetworkTotals } from "./charts.network.ts";
-export type { Ball, Chart, ChartOptions, CurlingOptions, CurlingStone, CurlingStoneResult, CurlingTotals, GoalMouth, GoalMouthOptions, KeyItem, MlbSprayOptions, MlbTotals, NbaShot, NbaShotOptions, NbaTotals, NflPass, NflPassOptions, NflTotals, NhlShot, NhlShotOptions, NhlTotals, SoccerChart, SoccerShot, SoccerShotOptions, SoccerTotals, ZoneTotal } from "./charts.types.ts";
+export type { Ball, Chart, ChartOptions, CurlingHeatOptions, CurlingHeatTotals, CurlingOptions, CurlingStone, CurlingStoneResult, CurlingTotals, GoalMouth, GoalMouthOptions, KeyItem, MlbSprayOptions, MlbTotals, NbaShot, NbaShotOptions, NbaTotals, NflPass, NflPassOptions, NflTotals, NhlShot, NhlShotOptions, NhlTotals, SoccerChart, SoccerShot, SoccerShotOptions, SoccerTotals, ZoneTotal } from "./charts.types.ts";
 export { ROAD_SIZES, roadToFinal } from "./road.ts";
 export { KYOGIJO_ROAD_STYLE } from "./road.style.ts";
 export type { RoadChart, RoadDecided, RoadFinal, RoadFinalist, RoadGroupMatch, RoadMatch, RoadOptions, RoadRecord, RoadScore, RoadSize, RoadSizeInfo, RoadTotals } from "./road.types.ts";

package/dist/charts-entry.js

@@ -3,6 +3,9 @@ export { nbaShotChart, nflPassChart, nhlShotMap } from "./charts.js";
 export { mlbSprayChart } from "./charts.baseball.js";
 export { soccerGoalMouth, soccerShotMap } from "./charts.soccer.js";
 export { CURLING_COLORS, curlingScore, curlingStones } from "./charts.curling.js";
+export { curlingHeat } from "./charts.curling.heat.js";
+export { CURLING_HIT_TYPES, curlingEndStats, curlingFreeGuards, curlingGuardScores, curlingHammers, curlingInPlay, curlingIsHit, curlingShotStats } from "./curling.stats.js";
+export { splitsChart } from "./charts.pool.js";
 export { passNetwork } from "./charts.network.js";
 export { ROAD_SIZES, roadToFinal } from "./road.js";
 export { KYOGIJO_ROAD_STYLE } from "./road.style.js";

package/dist/charts.athletics.d.ts

@@ -0,0 +1,183 @@
+import type { Chart, ChartOptions, KeyItem } from "./charts.types.ts";
+import type { AthleticsFieldEvent, AthleticsRace } from "./athletics/types.ts";
+import type { ReplayLook, ReplayTimeline } from "./replay.types.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** An athlete in a lane. */
+export interface AthleticsEntry {
+    /** The lane, from 1. */
+    lane: number;
+    name: string;
+    /** The country's code or name, for the table. */
+    country?: string;
+    /** The flag: an SVG document as text, or an `https:` or relative address, as a team's `logo`. */
+    flag?: string;
+    bib?: string | number;
+}
+/** One athlete's result in a race. Times are in seconds from the gun. */
+export interface AthleticsResult extends AthleticsEntry {
+    /** The place, from 1. A runner who did not finish has none. */
+    place?: number;
+    /** The time in seconds from the gun, or `null` for one who did not finish. */
+    time?: number | null;
+    /** The reaction time in seconds (the time from the gun to the athlete's feet leaving the blocks), for a race with blocks. */
+    reaction?: number;
+    /** The times, from the gun, at distances along the way: `{ distance: 100, time: 10.4 }` is the time at 100 m. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+    /** `DQ`, `DNF`, `DNS` or a note of your own, for the table. */
+    note?: string;
+}
+/** What `laneDraw`, `raceResults` and `raceReplay` take beyond a chart's options. */
+export interface AthleticsRaceOptions extends ChartOptions {
+    /** The race. The 400 m by default. */
+    race?: AthleticsRace;
+}
+/** The numbers behind a lane draw. */
+export interface LaneDrawTotals {
+    athletes: number;
+    /** The first and the last lane drawn. */
+    firstLane: number;
+    lastLane: number;
+}
+/** The numbers behind results. */
+export interface ResultsTotals {
+    athletes: number;
+    finished: number;
+    /** The winner's name and time, or null when nobody has a place. */
+    winner: {
+        name: string;
+        time: number;
+    } | null;
+    /** The quickest reaction, in seconds. */
+    quickestReaction: number | null;
+}
+/** An attempt in a jump or a throw. */
+export interface FieldAttempt {
+    athlete?: string;
+    /** The mark in metres: from the inside edge of the circle (or the javelin's arc) for a throw, from the take-off line for a jump. A foul has none. */
+    distance?: number | null;
+    /** A throw's direction, in degrees from the sector's axis (positive to the right of the throw as the athlete faces it), or a jump's sideways place in metres from the runway's middle line. 0 by default. */
+    across?: number;
+    /** False for a foul. True by default when there is a distance. */
+    valid?: boolean;
+    /** The round of the trial, from 1. */
+    round?: number;
+    /** `home` or `away`, which take the layer's two colours, or any other text. */
+    team?: string;
+    /** The tooltip, and what a screen reader reads. */
+    title?: string;
+}
+/** What `fieldMarks` takes. */
+export interface FieldMarksOptions extends ChartOptions {
+    /** The facility of the event that the marks are on, by its id (`javelin-west`, `jump-0-west`): the event's first by default. */
+    facility?: string;
+    /** Write each mark's distance beside it, not only the best's. Off by default. */
+    labels?: boolean;
+    /** For the triple jump: the take-off line is the women's (11 m from the pit) and not the men's (13 m). */
+    women?: boolean;
+}
+/** The numbers behind a field event's marks. */
+export interface FieldTotals {
+    attempts: number;
+    valid: number;
+    fouls: number;
+    best: {
+        distance: number;
+        athlete: string | undefined;
+    } | null;
+}
+/** A time in seconds as it is written: `9.58`, `1:40.91`, `2:03:59.40`. */
+export declare function formatTime(seconds: number, places?: number): string;
+/**
+ * The lane draw of a race: each athlete's name and flag on the lane of the start, behind the lane's number, for the close-up of the start (`range: "start"`, the drawing's default). The positions are the
+ * start lines' as the Manual marks them: the stagger of the 200, 400 and 800 m and the 4 x 400 m, the straight line of the sprints, the curved line of a race run without lanes.
+ * @example
+ * ```ts
+ * import { laneDraw } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = laneDraw([{ lane: 4, name: "M. Jacobs", country: "ITA" }, { lane: 5, name: "F. Kerley", country: "USA" }], { race: "100m" });
+ * console.log(chart.totals.athletes, chart.title);
+ * // 2 Lane draw, 100 m
+ * ```
+ */
+export declare function laneDraw(entries: readonly AthleticsEntry[], options?: AthleticsRaceOptions): Chart<LaneDrawTotals> & {
+    key: KeyItem[];
+};
+/**
+ * The results of a race on the finish line's close-up: after the line, in each lane, a disc with the place (gold, silver and bronze for the first three), the athlete's name and time; the reaction time
+ * behind the start line and the splits along the lane as small marks with their times; and a table of all of it. Times are in seconds from the gun.
+ * @example
+ * ```ts
+ * import { raceResults } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = raceResults([{ lane: 4, name: "M. Jacobs", place: 1, time: 9.8 }, { lane: 5, name: "F. Kerley", place: 2, time: 9.84 }], { race: "100m" });
+ * console.log(chart.totals.winner?.name, chart.summary);
+ * // M. Jacobs M. Jacobs won the 100 m in 9.80.
+ * ```
+ */
+export declare function raceResults(results: readonly AthleticsResult[], options?: AthleticsRaceOptions & {
+    splits?: boolean;
+    reactions?: boolean;
+}): Chart<ResultsTotals> & {
+    key: KeyItem[];
+};
+/** One runner of a replay. */
+export interface AthleticsRunner extends AthleticsEntry {
+    /** The time, in seconds from the gun, at which the runner finishes. */
+    time: number;
+    /** The reaction time, in seconds; the runner stays on the blocks until then. 0.15 by default. */
+    reaction?: number;
+    /** Times, from the gun, at distances along the way, which the runner's pace follows; without them the pace is even. */
+    splits?: readonly {
+        distance: number;
+        time: number;
+    }[];
+}
+/** What `raceReplay` takes. */
+export interface RaceReplayOptions extends AthleticsRaceOptions {
+    /** Seconds between two frames. 0.2 by default. */
+    step?: number;
+    /** How far past the finish line the runners go on, in metres. 8 by default. */
+    runOut?: number;
+}
+/** What `raceReplay` gives back: the timeline, the drawing's options to lay it on, a look for it and a sentence. */
+export interface RaceReplay {
+    timeline: ReplayTimeline;
+    /** The drawing's options: the stadium with the race marked. Pass them with the timeline to `drawFrame`, `createReplay` or `replayElement`. */
+    options: SurfaceOptions;
+    /** A look for the frames: the runners drawn larger, no trails, the lane numbers on them. */
+    look: ReplayLook;
+    title: string;
+    summary: string;
+    /** The time of the last runner to finish, in seconds. */
+    duration: number;
+}
+/** The distance a runner has run at a time, by the reaction time, the splits and the finish: straight lines between them, standing until the reaction. */
+export declare function distanceRun(runner: AthleticsRunner, total: number, t: number): number;
+/**
+ * A replay of a race: every runner, from the gun, on the curve of the lane (the stagger of the start as the Manual's table has it), in the pace of the reaction time, the splits and the finish time,
+ * to the line and on to a stop. A race that leaves its lanes (the 800 m after its breakline, the long races from the start) is drawn with the runners moving in to the inside. The positions are in
+ * the athletics frame (metres from the middle of the track), so the timeline is for the stadium drawn whole or close up. The relays are not replayed.
+ * @example
+ * ```ts
+ * import { raceReplay } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const replay = raceReplay([{ lane: 1, name: "A", time: 10.1 }, { lane: 2, name: "B", time: 10.3 }], { race: "100m" });
+ * console.log(replay.timeline.frames.length > 40, replay.duration);
+ * // true 10.3
+ * ```
+ */
+export declare function raceReplay(runners: readonly AthleticsRunner[], options?: RaceReplayOptions): RaceReplay;
+/**
+ * The attempts of a field event as marks: each valid throw in its sector at its distance and direction, each jump in its pit at its distance from the take-off line, the best of them picked out with
+ * a ring and its distance written beside it. A foul has no mark and is in the table. Put them on the stadium (`athletics: { events: [event] }`) or on the event alone (`athletics: { layout: event }`).
+ * @example
+ * ```ts
+ * import { fieldMarks } from "@johnmorrisdotca/kyogijo-stadiums/athletics";
+ * const chart = fieldMarks("javelin-throw", [{ athlete: "A", distance: 84.2 }, { athlete: "A", distance: 88.1, across: -3 }, { athlete: "A", valid: false }]);
+ * console.log(chart.totals.best?.distance, chart.totals.fouls);
+ * // 88.1 1
+ * ```
+ */
+export declare function fieldMarks(event: AthleticsFieldEvent, attempts: readonly FieldAttempt[], options?: FieldMarksOptions): Chart<FieldTotals> & {
+    key: KeyItem[];
+};