@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/athletics/stencil.js

@@ -0,0 +1,85 @@
+// Lane numbers painted on a track, as paths: a stencil face of our own, with no font and no file. A digit stands in a box 0.62 wide and 1 high (scaled by the figure's height `h`) and is a few thick
+// strokes with the gaps (bridges) a stencil has, so that it reads at a glance from far off. Written for this package; no typeface was used or looked at.
+/** A number to four places: a figure under a metre tall needs more than the drawing's two. */
+const num = (value) => {
+    const rounded = Math.round(value * 10000) / 10000;
+    return Object.is(rounded, -0) || rounded === 0 ? "0" : String(rounded);
+};
+/** The width of a digit over its height, and the gap between two digits over the height. */
+export const DIGIT_WIDTH = 0.62;
+export const DIGIT_GAP = 0.14;
+/** The thickness of a stroke over the height. */
+export const STROKE = 0.18;
+// A stroke is a path of the pen's centre line in the box: `M x y`, `L x y` and `A rx ry sweep x y` (an arc of less than a half turn). The ends are butt, so a gap is a gap.
+const xl = 0.09;
+const xr = 0.53;
+const xm = 0.31;
+const yt = 0.09;
+const yb = 0.91;
+/** A closed ellipse as two half turns, with no bridge: the loops of a 6, an 8 and a 9. */
+function loop(xc, yc, a, b) {
+    const f = (n) => String(Math.round(n * 1000) / 1000);
+    return `M${f(xc - a)} ${f(yc)}A${f(a)} ${f(b)} 0 0 1 ${f(xc + a)} ${f(yc)}A${f(a)} ${f(b)} 0 0 1 ${f(xc - a)} ${f(yc)}`;
+}
+const SIX = [`M0.5 ${yt}H0.31A0.22 0.2 0 0 0 ${xl} 0.29V0.68`, loop(xm, 0.68, 0.22, 0.23)];
+/** A glyph turned half a turn about the middle of its box: a 6 is a 9. */
+const turned = (strokes) => strokes.map((d) => d.replace(/([MLHVA])([^MLHVA]*)/g, (_m, cmd, rest) => {
+    const v = rest.trim().split(/[\s,]+/).filter((t) => t !== "").map(Number);
+    const f = (n) => String(Math.round(n * 1000) / 1000);
+    switch (cmd) {
+        case "M":
+        case "L":
+            return `${cmd}${f(DIGIT_WIDTH - v[0])} ${f(1 - v[1])}`;
+        case "H":
+            return `H${f(DIGIT_WIDTH - v[0])}`;
+        case "V":
+            return `V${f(1 - v[0])}`;
+        default:
+            return `A${v[0]} ${v[1]} 0 ${v[3]} ${v[4]} ${f(DIGIT_WIDTH - v[5])} ${f(1 - v[6])}`;
+    }
+}));
+const GLYPHS = {
+    "0": [`M0.27 ${yt}A0.18 0.22 0 0 0 ${xl} 0.31V0.69A0.18 0.22 0 0 0 0.27 ${yb}`, `M0.35 ${yt}A0.18 0.22 0 0 1 ${xr} 0.31V0.69A0.18 0.22 0 0 1 0.35 ${yb}`],
+    "1": [`M0.15 0.3L${xm} ${yt}V${yb}`],
+    "2": [`M${xl} 0.29A0.22 0.2 0 0 1 ${xr} 0.29L${xl} ${yb}H${xr}`],
+    "3": [`M${xl} ${yt}H0.30A0.23 0.19 0 0 1 0.30 0.455H0.2`, `M0.2 0.545H0.30A0.23 0.19 0 0 1 0.30 ${yb}H${xl}`],
+    "4": [`M0.4 ${yb}V${yt}L${xl} 0.65H0.55`],
+    "5": [`M${xr} ${yt}H${xl}V0.4`, `M0.19 0.45H0.30A0.23 0.23 0 0 1 0.30 ${yb}H${xl}`],
+    "6": SIX,
+    "7": [`M${xl} ${yt}H${xr}`, `M${xr} 0.18L0.26 ${yb}`],
+    "8": [loop(xm, 0.285, 0.2, 0.195), loop(xm, 0.715, 0.22, 0.195)],
+    "9": turned(SIX),
+};
+/** The width of a string of digits at the height `h`. */
+export const digitsWidth = (text, h) => (text.length * DIGIT_WIDTH + Math.max(0, text.length - 1) * DIGIT_GAP) * h;
+const scalePath = (d, h, ox, oy) => d.replace(/([MLHVA])([^MLHVA]*)/g, (_m, cmd, rest) => {
+    const v = rest.trim().split(/[\s,]+/).filter((s) => s !== "").map(Number);
+    switch (cmd) {
+        case "M":
+        case "L":
+            return `${cmd}${num(ox + v[0] * h)} ${num(oy + v[1] * h)}`;
+        case "H":
+            return `H${num(ox + v[0] * h)}`;
+        case "V":
+            return `V${num(oy + v[0] * h)}`;
+        default:
+            return `A${num(v[0] * h)} ${num(v[1] * h)} 0 ${v[3]} ${v[4]} ${num(ox + v[5] * h)} ${num(oy + v[6] * h)}`;
+    }
+});
+/**
+ * A string of digits as one path of strokes, centred on `(cx, cy)`, `h` tall, upright. `stroke-width` is `strokeWidth(h)`. Characters that are not digits are left out.
+ */
+export function digitsD(text, h, cx, cy) {
+    const digits = [...text].filter((c) => Object.prototype.hasOwnProperty.call(GLYPHS, c));
+    const width = digitsWidth(digits.join(""), h);
+    let x = cx - width / 2;
+    const top = cy - h / 2;
+    let out = "";
+    for (const c of digits) {
+        out += GLYPHS[c].map((d) => scalePath(d, h, x, top)).join("");
+        x += (DIGIT_WIDTH + DIGIT_GAP) * h;
+    }
+    return out;
+}
+/** The thickness of a stroke at the height `h`. */
+export const strokeWidth = (h) => STROKE * h;

package/dist/athletics/track.d.ts

@@ -0,0 +1,54 @@
+/** An oval track: two straights of `straight` metres joined by two semicircles whose kerb radius is `radius` (Manual 2.2.1.1; Technical Rule 14.1). */
+export interface Oval {
+    /** The length of each straight, which is also the distance between the centres of the semicircles. */
+    straight: number;
+    /** The radius of the semicircles at the kerb: the track's inside edge. */
+    radius: number;
+    /** The width of a lane, the 50 mm line on its right included (Rule 14.4). */
+    lane: number;
+    /** How many lanes the oval has. */
+    lanes: number;
+    /** The width of the lines. */
+    line: number;
+    /** Where the running line is measured: lane 1's from the kerb, every other lane's from the outer edge of the line on its left (Rule 14.2). */
+    inner: number;
+    outer: number;
+}
+/** A point on the track and the way the athlete is facing there (radians, clockwise from the right, as the eye sees it: 0 faces right, π/2 down). */
+export interface Pose {
+    x: number;
+    y: number;
+    heading: number;
+}
+/** The radius of lane `n`'s running line (Rule 14.2, Manual 2.2.1.1): the kerb radius and 0.30 m for lane 1, and 0.20 m outside the line on the left for the others. */
+export declare const laneRadius: (o: Oval, n: number) => number;
+/** The radius of the outer edge of lane `n`'s line. */
+export declare const laneEdge: (o: Oval, n: number) => number;
+/** The length of lane `n`'s running line: one lap. */
+export declare const lap: (o: Oval, n: number) => number;
+/** A point on the running line of radius `r`, `s` metres from the finish line. A distance beyond a lap goes round again. */
+export declare function pose(o: Oval, r: number, s: number): Pose;
+/** The staggered start of a lane: how far ahead of lane 1's start line it is, for a race run in lanes round `bends` bends, `bends` half-turns of π(r - r₁) each (Manual Table 2.2.1.6a). */
+export declare function stagger(o: Oval, n: number, bends: number): number;
+/** The distance along the running line of radius `r` from the finish line of the point of it nearest to (x, y): the inverse of `pose`. */
+export declare function distanceOn(o: Oval, r: number, x: number, y: number): number;
+/** The bend the athletes run: `right` is the first, round CP2, and `left` the second, round CP1. */
+type Side = "right" | "left";
+/** The point of a bend's running line at the angle `f` (radians from the bend's entry), with the way the athlete faces. */
+export declare function bendPoint(o: Oval, side: Side, r: number, f: number): Pose;
+/**
+ * A point of an involute of the lane-1 running circle of a bend: the curve a tight wire makes when it is unwound from the pins round the kerb, which is how the Manual has the
+ * start lines and the breakline marked (2.2.1.6, "Marking for Curved Start Lines" and "Marking for the 800m Breakline"). Every point of it is the same distance from the finish by
+ * the shortest permitted route: a straight line to the circle and then round it. `wire` is the length of the wire already unwound where it touches the circle at the bend's entry
+ * (0 for a start on the bend, the distance back along the straight for one before it, 84.39 m for the 800 m breakline), and `f` the angle of the tangent point from the entry.
+ */
+export declare function involutePoint(o: Oval, side: Side, a: number, wire: number, f: number): [number, number];
+/**
+ * The start of a race of `distance` metres run in lanes' own staggers, and the breakline of the 800 m: the stagger of lane `n` over lane 1's, from the involute of the breakline
+ * (Manual Tables 2.2.1.6a and 2.2.1.6b). The breakline is the involute of lane 1's second-bend circle through the end of the first bend; a lane's runner is equal to lane 1's when
+ * the lane's run to the breakline is one semicircle of lane 1's length.
+ */
+export declare function breaklineStagger(o: Oval, n: number): number;
+/** The path of an arc of the circle (cx, cy, r) from the heading-free angle `a0` to `a1` (radians clockwise from the right as the eye sees it, y down). */
+export declare function arcD(cx: number, cy: number, r: number, a0: number, a1: number): string;
+export {};

package/dist/athletics/track.js

@@ -0,0 +1,105 @@
+// The geometry of an oval athletics track, in metres, as plain data. Nothing here draws: the plan (plan.ts) and the drawing (surfaces/athletics.ts) read it, and the tests check the figures
+// the World Athletics Track and Field Facilities Manual (2019 edition, 2.2.1) prints against it.
+//
+// The frame: the origin is the middle of the track, x runs along the straights (to the right, as the oval is drawn wide) and y across them, down the page. The athletes run
+// counter-clockwise as the eye sees it (left-hand inside, Technical Rule 17.2.1), so the finish straight is the bottom one, running to the right, and the finish line A stands on
+// the axis through the right-hand semicircle's centre CP2 (Manual 2.2.1.4: "the prolongation of diameter D-A"). A lane's own length `s` is measured along its running line from the
+// finish line, forward.
+import { num } from "../format.js";
+/** The radius of lane `n`'s running line (Rule 14.2, Manual 2.2.1.1): the kerb radius and 0.30 m for lane 1, and 0.20 m outside the line on the left for the others. */
+export const laneRadius = (o, n) => (n <= 1 ? o.radius + o.inner : o.radius + (n - 1) * o.lane + o.outer);
+/** The radius of the outer edge of lane `n`'s line. */
+export const laneEdge = (o, n) => o.radius + n * o.lane;
+/** The length of lane `n`'s running line: one lap. */
+export const lap = (o, n) => 2 * o.straight + 2 * Math.PI * laneRadius(o, n);
+/** A point on the running line of radius `r`, `s` metres from the finish line. A distance beyond a lap goes round again. */
+export function pose(o, r, s) {
+    const S = o.straight;
+    const L = 2 * S + 2 * Math.PI * r;
+    const d = ((s % L) + L) % L;
+    const bend = Math.PI * r;
+    if (d <= bend) {
+        const f = d / r;
+        return { x: S / 2 + r * Math.sin(f), y: r * Math.cos(f), heading: -f };
+    }
+    if (d <= bend + S)
+        return { x: S / 2 - (d - bend), y: -r, heading: Math.PI };
+    if (d <= 2 * bend + S) {
+        const f = (d - bend - S) / r;
+        return { x: -S / 2 - r * Math.sin(f), y: -r * Math.cos(f), heading: Math.PI - f };
+    }
+    return { x: -S / 2 + (d - 2 * bend - S), y: r, heading: 0 };
+}
+/** The staggered start of a lane: how far ahead of lane 1's start line it is, for a race run in lanes round `bends` bends, `bends` half-turns of π(r - r₁) each (Manual Table 2.2.1.6a). */
+export function stagger(o, n, bends) {
+    return bends * Math.PI * (laneRadius(o, n) - laneRadius(o, 1));
+}
+/** The distance along the running line of radius `r` from the finish line of the point of it nearest to (x, y): the inverse of `pose`. */
+export function distanceOn(o, r, x, y) {
+    const S = o.straight;
+    const bend = Math.PI * r;
+    if (x >= S / 2)
+        return r * Math.atan2(x - S / 2, y);
+    if (x <= -S / 2)
+        return bend + S + r * Math.atan2(-(x + S / 2), -y);
+    return y < 0 ? bend + (S / 2 - x) : 2 * bend + S + (x + S / 2);
+}
+/** The point of a bend's running line at the angle `f` (radians from the bend's entry), with the way the athlete faces. */
+export function bendPoint(o, side, r, f) {
+    const S = o.straight;
+    return side === "right"
+        ? { x: S / 2 + r * Math.sin(f), y: r * Math.cos(f), heading: -f }
+        : { x: -S / 2 - r * Math.sin(f), y: -r * Math.cos(f), heading: Math.PI - f };
+}
+/**
+ * A point of an involute of the lane-1 running circle of a bend: the curve a tight wire makes when it is unwound from the pins round the kerb, which is how the Manual has the
+ * start lines and the breakline marked (2.2.1.6, "Marking for Curved Start Lines" and "Marking for the 800m Breakline"). Every point of it is the same distance from the finish by
+ * the shortest permitted route: a straight line to the circle and then round it. `wire` is the length of the wire already unwound where it touches the circle at the bend's entry
+ * (0 for a start on the bend, the distance back along the straight for one before it, 84.39 m for the 800 m breakline), and `f` the angle of the tangent point from the entry.
+ */
+export function involutePoint(o, side, a, wire, f) {
+    const T = bendPoint(o, side, a, f);
+    const l = wire + a * f;
+    return [T.x - l * Math.cos(T.heading), T.y - l * Math.sin(T.heading)];
+}
+/**
+ * The start of a race of `distance` metres run in lanes' own staggers, and the breakline of the 800 m: the stagger of lane `n` over lane 1's, from the involute of the breakline
+ * (Manual Tables 2.2.1.6a and 2.2.1.6b). The breakline is the involute of lane 1's second-bend circle through the end of the first bend; a lane's runner is equal to lane 1's when
+ * the lane's run to the breakline is one semicircle of lane 1's length.
+ */
+export function breaklineStagger(o, n) {
+    const a = laneRadius(o, 1);
+    const r = laneRadius(o, n);
+    if (n <= 1)
+        return 0;
+    // The breakline: tangent points of the second bend's circle, wire 84.39 m at the bend's entry C. Find where it meets lane n's circle about CP2 (the first bend's).
+    const S = o.straight;
+    const lo0 = 0;
+    const f = (t) => {
+        const [x, y] = involutePoint(o, "left", a, S, t);
+        return Math.hypot(x - S / 2, y) - r;
+    };
+    let lo = lo0;
+    let hi = 1.5;
+    // The radius from CP2 grows with t: bisect.
+    for (let i = 0; i < 80; i += 1) {
+        const mid = (lo + hi) / 2;
+        if (f(mid) < 0)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    const t = (lo + hi) / 2;
+    const [x, y] = involutePoint(o, "left", a, S, t);
+    // The angle of the point about CP2 from the top (the end of the first bend), growing towards the finish line (so that a point beyond the line of the diameter is negative).
+    const behind = Math.atan2(x - S / 2, -y);
+    const arc = r * (Math.PI - behind);
+    return arc - Math.PI * a;
+}
+/** The path of an arc of the circle (cx, cy, r) from the heading-free angle `a0` to `a1` (radians clockwise from the right as the eye sees it, y down). */
+export function arcD(cx, cy, r, a0, a1) {
+    const p = (a) => `${num(cx + r * Math.cos(a))} ${num(cy + r * Math.sin(a))}`;
+    const large = Math.abs(a1 - a0) > Math.PI ? 1 : 0;
+    const sweep = a1 > a0 ? 1 : 0;
+    return `M${p(a0)}A${num(r)} ${num(r)} 0 ${large} ${sweep} ${p(a1)}`;
+}

package/dist/athletics/types.d.ts

@@ -0,0 +1,77 @@
+import type { SoccerPitchId, SoccerSize } from "../surfaces/soccer-spec.ts";
+/** The races a drawing can mark: where each starts, how it is staggered or curved, its hurdles or its exchange zones. A race is named by its distance, in kebab case. */
+export type AthleticsRace = "60m" | "60m-hurdles" | "100m" | "100m-hurdles" | "110m-hurdles" | "200m" | "400m" | "400m-hurdles" | "800m" | "1000m" | "1500m" | "mile" | "2000m" | "3000m" | "5000m" | "10000m" | "2000m-steeplechase" | "3000m-steeplechase" | "4x100m" | "4x400m";
+/** The field events a drawing can mark in the infield, and alone at a large scale (`layout`). */
+export type AthleticsFieldEvent = "high-jump" | "pole-vault" | "long-jump" | "triple-jump" | "shot-put" | "discus-throw" | "hammer-throw" | "javelin-throw";
+/** What lies inside the track: the soccer pitch the package draws (`pitch`), plain mown grass, or nothing but the track's own surface. */
+export type AthleticsInfield = "pitch" | "grass" | "none";
+/** The colour of the track: Mondo red (the usual), Berlin's blue (the 2009 World Championships), the terracotta of a club track, or green. A colour of your own is `colors.surface`... or `colors.track`. */
+export type AthleticsTrackLook = "red" | "blue" | "terracotta" | "green";
+/** Where the steeplechase's water jump is: inside the second bend, outside it, or not drawn. */
+export type WaterJump = "inside" | "outside" | "none";
+/** The kind of a race's start, which says how its lines are made. */
+export type StartKind = "straight" | "stagger" | "curved" | "steeplechase";
+/**
+ * What an athletics drawing takes beyond a surface: the number of lanes, the colour of the track, what is in the infield, which races and which field events are marked.
+ * Every part is optional; the standard 400 m track of World Athletics, with eight lanes, a red track, a soccer pitch inside it and every field event in its usual place, is drawn without any.
+ */
+export interface AthleticsStyle {
+    /** The lanes of the oval: 4 to 9 outdoors (8 by default; the Manual says nine is the most there should be), 4 to 6 on the indoor track (6 by default). */
+    lanes?: number;
+    /** The lanes of the straight that runs on beyond the oval's, 6 to 10 (the oval's number by default), as the straight of a 10-lane stadium is built (Manual 2.2.2). */
+    straightLanes?: number;
+    /** The colour of the track: `red` (the default), `blue`, `terracotta` or `green`. */
+    track?: AthleticsTrackLook;
+    /** What is inside the track: `pitch` (the default outdoors: a soccer pitch laid out as the package draws it), `grass` or `none`. */
+    infield?: AthleticsInfield;
+    /** The pitch inside the track when `infield` is `pitch`: a preset or a size, as the soccer `pitch` option. 105 by 68 metres by default. */
+    pitch?: SoccerPitchId | SoccerSize;
+    /** The field events drawn, each in its usual place in the standard stadium: all by default, `false` for none, or a list. */
+    events?: boolean | readonly AthleticsFieldEvent[];
+    /** The races whose starts and marks are drawn: the finish line and the lane numbers always are. `all` marks every race; a list marks those. None by default. */
+    races?: "all" | readonly AthleticsRace[];
+    /** The race of a close-up of a start (`range: "start"`): the 400 m by default. The race's start is marked whether or not it is in `races`. */
+    start?: AthleticsRace;
+    /** One field event alone, drawn at a large scale from the rulebook's own diagram: its runway or circle, its pit or sector, and its landing area. */
+    layout?: AthleticsFieldEvent;
+    /** The steeplechase's water jump: `inside` the second bend (the default) or `outside` it. Drawn with the steeplechase races. */
+    waterJump?: WaterJump;
+    /** The lane numbers painted on the track at the start and the finish lines: on by default. */
+    numbers?: boolean;
+    /** Draw the oval's lanes in the straight's numbers as well as the oval's, on the finish straight: on by default. */
+    straightNumbers?: boolean;
+}
+/** A race, as the package knows it. */
+export interface RaceInfo {
+    id: AthleticsRace;
+    /** The distance in metres (the legs of a relay are in `legs`). */
+    distance: number;
+    kind: StartKind;
+    /** The legs of a relay, in metres. */
+    legs?: readonly number[];
+    /** The bends run in lanes (a stagger's), for a race that starts staggered. */
+    bends?: number;
+    /** True for a race with a breakline, which the athletes may leave their lanes after. */
+    breakline?: boolean;
+    /** True for a race that is run over hurdles. */
+    hurdles?: boolean;
+    /** True for a race of the covered track only: the 60 m and its hurdles, on the infield straight. */
+    indoor?: boolean;
+    /** True for a race with a group start, which an outer half of the track may start on a line of its own. */
+    group?: boolean;
+    /** The words of its name, in English, Japanese and French. */
+    name: {
+        en: string;
+        ja: string;
+        fr: string;
+    };
+}
+/** A field event, as the package knows it. */
+export interface FieldEventInfo {
+    id: AthleticsFieldEvent;
+    name: {
+        en: string;
+        ja: string;
+        fr: string;
+    };
+}

package/dist/athletics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/athletics-entry.d.ts

@@ -0,0 +1,17 @@
+export { laneDraw, raceResults, raceReplay, fieldMarks, formatTime, distanceRun } from "./charts.athletics.ts";
+export type { AthleticsEntry, AthleticsResult, AthleticsRaceOptions, AthleticsRunner, FieldAttempt, FieldMarksOptions, FieldTotals, LaneDrawTotals, RaceReplay, RaceReplayOptions, ResultsTotals } from "./charts.athletics.ts";
+export { FIELD_EVENTS, FIELD_EVENT_IDS, RACES, RACE_IDS, fieldEventById, raceById } from "./athletics/events.ts";
+export { athleticsLeague, athleticsPlan, eventsOf, racesOf, INDOOR_RACES } from "./athletics/plan.ts";
+export type { AthleticsPlan, MBox, MMark, MRange } from "./athletics/plan.ts";
+export { breaklineStagger, distanceOn, laneEdge, laneRadius, lap, pose, stagger } from "./athletics/track.ts";
+export type { Oval, Pose } from "./athletics/track.ts";
+export { firstStart, markRace, staggerOf } from "./athletics/races.ts";
+export type { RaceMarks, StartPlacement } from "./athletics/races.ts";
+export { ARENA, SECTOR_REACH } from "./athletics/infield.ts";
+export { JAVELIN_HALF, SECTOR_ANGLE } from "./athletics/facilities.ts";
+export type { Facility } from "./athletics/facilities.ts";
+export { HURDLE as STEEPLECHASE_HURDLE, INSIDE as STEEPLECHASE_INSIDE, OUTSIDE as STEEPLECHASE_OUTSIDE, scPose } from "./athletics/steeplechase.ts";
+export { ATHLETICS_LEAGUES, WA_SHORT_STAGGER_TABLE, WA_SHORT_TRACK, WA_STAGGER_TABLE, WA_STANDARD_TRACK } from "./leagues/athletics.ts";
+export type { AthleticsFigures, AthleticsLeague } from "./leagues/athletics.ts";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE, TRACK_COLOURS } from "./athletics.style.ts";
+export type { AthleticsFieldEvent, AthleticsInfield, AthleticsRace, AthleticsStyle, AthleticsTrackLook, FieldEventInfo, RaceInfo, WaterJump } from "./athletics/types.ts";

package/dist/athletics-entry.js

@@ -0,0 +1,11 @@
+// The athletics stadium: the races and the field events, the plan of the track and what is marked on it, the oval's geometry (a point of a lane, the stagger of each lane's start), and the data: lane draws, results, a replay and the marks of throws and jumps.
+export { laneDraw, raceResults, raceReplay, fieldMarks, formatTime, distanceRun } from "./charts.athletics.js";
+export { FIELD_EVENTS, FIELD_EVENT_IDS, RACES, RACE_IDS, fieldEventById, raceById } from "./athletics/events.js";
+export { athleticsLeague, athleticsPlan, eventsOf, racesOf, INDOOR_RACES } from "./athletics/plan.js";
+export { breaklineStagger, distanceOn, laneEdge, laneRadius, lap, pose, stagger } from "./athletics/track.js";
+export { firstStart, markRace, staggerOf } from "./athletics/races.js";
+export { ARENA, SECTOR_REACH } from "./athletics/infield.js";
+export { JAVELIN_HALF, SECTOR_ANGLE } from "./athletics/facilities.js";
+export { HURDLE as STEEPLECHASE_HURDLE, INSIDE as STEEPLECHASE_INSIDE, OUTSIDE as STEEPLECHASE_OUTSIDE, scPose } from "./athletics/steeplechase.js";
+export { ATHLETICS_LEAGUES, WA_SHORT_STAGGER_TABLE, WA_SHORT_TRACK, WA_STAGGER_TABLE, WA_STANDARD_TRACK } from "./leagues/athletics.js";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE, TRACK_COLOURS } from "./athletics.style.js";

package/dist/athletics.style.d.ts

@@ -0,0 +1,16 @@
+import type { AthleticsTrackLook } from "./athletics/types.ts";
+/** The colours of each track look, light and dark. */
+export declare const TRACK_COLOURS: Readonly<Record<AthleticsTrackLook, {
+    light: string;
+    dark: string;
+}>>;
+/** The rules of an athletics drawing's colours. A drawing that names its track (`athletics.track`) has its `data-track`, whose rules come after a look's so that the track wins. */
+export declare const KYOGIJO_ATHLETICS_STYLE: string;
+/** The rules of a named track: its colour in light and dark, and, on a blue track, red where the rules say blue (the 4 x 400 m's marks and the 110 m hurdles). */
+export declare function trackStyle(track: AthleticsTrackLook): string;
+/** The rules of every named track, for a page that draws with `style: "none"`. */
+export declare const KYOGIJO_TRACK_STYLE: string;
+/** The base rules a drawing of this sport writes into its stylesheet: nothing for another sport. */
+export declare const athleticsStyle: (sport: string) => string;
+/** The rules of the track the options name, written after a look's so that the track wins: nothing for another sport or a track not named. */
+export declare const athleticsTrackRules: (sport: string, track: AthleticsTrackLook | undefined) => string;

package/dist/athletics.style.js

@@ -0,0 +1,51 @@
+const MARKS_LIGHT = "--ky-ath-y:#f2c230;--ky-ath-b:#1d4ed8;--ky-ath-g:#1f9d4c;--ky-ath-k:#1c1f1d;--ky-ath-r:#d6342a;--ky-sand:#e3cf9d;--ky-mat:#3d6fb5;--ky-water:#7cc4ee;--ky-concrete:#a9adb0;--ky-pad:#40454a";
+const MARKS_DARK = "--ky-ath-y:#f2c230;--ky-ath-b:#6f95ff;--ky-ath-g:#43c06d;--ky-ath-k:#0f1210;--ky-ath-r:#ef6c60;--ky-sand:#a89568;--ky-mat:#2c528a;--ky-water:#4d8fb8;--ky-concrete:#6e7377;--ky-pad:#1f2326";
+/** The colours of each track look, light and dark. */
+export const TRACK_COLOURS = {
+    red: { light: "#c05a46", dark: "#9a4636" },
+    blue: { light: "#2f65b4", dark: "#264f8c" },
+    terracotta: { light: "#c9744a", dark: "#a45b3a" },
+    green: { light: "#3b8a62", dark: "#2d6b4c" },
+};
+const GROUND = {
+    light: { track: TRACK_COLOURS.red.light, surface: "#4c9b56", alt: "#438f4d", apron: "#d9d6c8" },
+    dark: { track: TRACK_COLOURS.red.dark, surface: "#2d6c3e", alt: "#276136", apron: "#1b1f1c" },
+};
+const base = (c, marks) => `--ky-track:${c.track};--ky-surface:${c.surface};--ky-surface-alt:${c.alt};--ky-apron:${c.apron};${marks}`;
+/** The rules of an athletics drawing's colours. A drawing that names its track (`athletics.track`) has its `data-track`, whose rules come after a look's so that the track wins. */
+export const KYOGIJO_ATHLETICS_STYLE = [
+    `:where(.kyogijo[data-sport=athletics]){${base(GROUND.light, MARKS_LIGHT)}}`,
+    `@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .kyogijo[data-sport=athletics]:not([data-theme=light])){${base(GROUND.dark, MARKS_DARK)}}}`,
+    `:where(html[data-theme=dark] .kyogijo[data-sport=athletics],.kyogijo[data-theme=dark][data-sport=athletics]){${base(GROUND.dark, MARKS_DARK)}}`,
+    ".kyogijo .ky-ath-track{fill:var(--ky-track)}",
+    ".kyogijo .ky-ath-grass{fill:var(--ky-surface)}",
+    ".kyogijo .ky-ath-sand{fill:var(--ky-sand)}",
+    ".kyogijo .ky-ath-mat{fill:var(--ky-mat)}",
+    ".kyogijo .ky-ath-water{fill:var(--ky-water)}",
+    ".kyogijo .ky-ath-concrete{fill:var(--ky-concrete)}",
+    ".kyogijo .ky-ath-pad{fill:var(--ky-pad)}",
+    ".kyogijo .ky-ath-board{fill:var(--ky-line)}",
+    ".kyogijo .ky-ath-bank{fill:var(--ky-ath-k);fill-opacity:.12}",
+    ".kyogijo .ky-ath-y{stroke:var(--ky-ath-y);fill:none}.kyogijo .ky-ath-b{stroke:var(--ky-ath-b);fill:none}.kyogijo .ky-ath-g{stroke:var(--ky-ath-g);fill:none}.kyogijo .ky-ath-k{stroke:var(--ky-ath-k);fill:none}.kyogijo .ky-ath-r{stroke:var(--ky-ath-r);fill:none}.kyogijo .ky-ath-s{stroke:var(--ky-line);stroke-opacity:.8;fill:none}",
+    ".kyogijo .ky-ath-y-fill{fill:var(--ky-ath-y)}.kyogijo .ky-ath-b-fill{fill:var(--ky-ath-b)}.kyogijo .ky-ath-g-fill{fill:var(--ky-ath-g)}.kyogijo .ky-ath-k-fill{fill:var(--ky-ath-k)}.kyogijo .ky-ath-r-fill{fill:var(--ky-ath-r)}",
+    ".kyogijo .ky-ath-num{fill:none;stroke:var(--ky-line);stroke-linejoin:round}",
+    ".kyogijo .ky-ath-tag{fill:var(--ky-plate)}.kyogijo .ky-ath-tagnum{fill:none;stroke:var(--ky-plate-ink);stroke-linejoin:round}",
+].join("\n");
+/** The rules of a named track: its colour in light and dark, and, on a blue track, red where the rules say blue (the 4 x 400 m's marks and the 110 m hurdles). */
+export function trackStyle(track) {
+    const c = TRACK_COLOURS[track];
+    const at = `[data-track=${track}]`;
+    const red = track === "blue" ? ";--ky-ath-b:#e0342b" : "";
+    const redDark = track === "blue" ? ";--ky-ath-b:#ff7a6e" : "";
+    return [
+        `:where(.kyogijo${at}){--ky-track:${c.light}${red}}`,
+        `@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .kyogijo${at}:not([data-theme=light])){--ky-track:${c.dark}${redDark}}}`,
+        `:where(html[data-theme=dark] .kyogijo${at},.kyogijo[data-theme=dark]${at}){--ky-track:${c.dark}${redDark}}`,
+    ].join("\n");
+}
+/** The rules of every named track, for a page that draws with `style: "none"`. */
+export const KYOGIJO_TRACK_STYLE = Object.keys(TRACK_COLOURS).map(trackStyle).join("\n");
+/** The base rules a drawing of this sport writes into its stylesheet: nothing for another sport. */
+export const athleticsStyle = (sport) => (sport === "athletics" ? KYOGIJO_ATHLETICS_STYLE : "");
+/** The rules of the track the options name, written after a look's so that the track wins: nothing for another sport or a track not named. */
+export const athleticsTrackRules = (sport, track) => (sport === "athletics" && track !== undefined ? trackStyle(track) : "");

package/dist/atlas-entry.d.ts

@@ -1,4 +1,8 @@
-export { PLACES, atlasFacets, placeById, placeByName, placesBy, placesByName, surfaceOf } from "./atlas.ts";
+export { PLACES, atlasFacets, hallSurfaces, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.ts";
+export { HALLS } from "./halls.ts";
+export type { Hall, HallBasis, HallSurface } from "./halls.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,5 @@
-// 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, soccer ground and hockey and basketball arena, and the famous halls of the budō, with where it stands, when it was in use and the clubs that played there, and the filters over them.
+export { PLACES, atlasFacets, hallSurfaces, placeById, placeByName, placesBy, placesByClub, placesByName, surfaceOf, surfacesOf, tenantsOf } from "./atlas.js";
+export { HALLS } from "./halls.js";
 export { officialName, plainName } from "./names.js";
+export { TENANTS, TENANT_JAPANESE_NAMES, nameJaOf } from "./tenants.js";