@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/heat.zones.js

@@ -11,6 +11,12 @@ import { fill } from "./strings.js";
 import { lengthUnit } from "./common.js";
 import { courtFor, courtSize } from "./court.js";
 import { fieldPlan } from "./fields.js";
+import { WATER_POLO } from "./pool.figures.js";
+import { swimPlan } from "./pool.js";
+import { athleticsLanes, athleticsLeague } from "./athletics/plan.js";
+import { skatingPlan } from "./skating/plan.js";
+import { laneEdges } from "./skating/track.js";
+import { iceRadius } from "./skating/long.js";
 import { LEAGUES, chooseLeague, cricketOf } from "./leagues.js";
 /** Every zone set, with the sports it is for, the source of its definition and its title. */
 export const ZONE_SETS = Object.freeze({
@@ -24,8 +30,15 @@ export const ZONE_SETS = Object.freeze({
     "baseball-spray": { sports: ["mlb"], title: "Spray zones: pull, centre, opposite by infield and outfield", source: "docs/sources.md#zone-sets" },
     "baseball-retrosheet": { sports: ["mlb"], title: "Retrosheet hit locations as the nearest sector", source: "https://www.retrosheet.org/location.htm" },
     "curling-house": { sports: ["curling"], title: "The house: the button, the 4-, 8- and 12-foot rings, and the free guard zone", source: "docs/sources.md#zone-sets" },
-    "net-court": { sports: ["tennis", "volleyball", "badminton", "pickleball", "tabletennis"], title: "Each side of the net: the front court and the back court, split by the court's own line", source: "docs/sources.md#zone-sets" },
-    "field-thirds": { sports: ["lacrosse", "rugby", "afl", "gaelic", "fieldhockey", "handball"], title: "Thirds: defensive, middle and attacking", source: "docs/sources.md#zone-sets" },
+    "net-court": { sports: ["tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "sepaktakraw", "teqball"], title: "Each side of the net: the front court and the back court, split by the court's own line", source: "docs/sources.md#zone-sets" },
+    "wall-court": { sports: ["squash", "racquetball"], title: "The front court and the back court, split by the short line", source: "docs/sources.md#zone-sets" },
+    "roundnet-rings": { sports: ["roundnet"], title: "The no hit zone, the ring out to the serving line, and the rest of the court", source: "docs/sources.md#zone-sets" },
+    "pool-lanes": { sports: ["swimming"], title: "Lanes: each lane of the pool, the whole length of it", source: "docs/sources.md#zone-sets" },
+    "water-polo-areas": { sports: ["waterpolo"], title: "The goal area, the ground from 2 to 6 m, and the rest of the field, at each end", source: "docs/sources.md#zone-sets" },
+    "pool-thirds": { sports: ["diving", "artisticswimming"], title: "Thirds along the pool, from the wall the boards or the judges stand at", source: "docs/sources.md#zone-sets" },
+    "field-thirds": { sports: ["lacrosse", "rugby", "afl", "gaelic", "fieldhockey", "handball", "netball"], title: "Thirds: defensive, middle and attacking", source: "docs/sources.md#zone-sets" },
+    "skating-track": { sports: ["skating"], title: "The rink in parts: the finish straight, the first curve, the crossing straight, the second curve and the infield (a figure skating rink in thirds)", source: "docs/sources.md#zone-sets" },
+    "athletics-track": { sports: ["athletics"], title: "The track in parts: the finish straight, the first bend, the back straight, the second bend, and the infield", source: "docs/sources.md#zone-sets" },
     "cricket-ground": { sports: ["cricket"], title: "The pitch, the ground inside the fielding circle, and the outfield", source: "docs/sources.md#zone-sets" },
     "football-pass": { sports: ["nfl", "cfl", "ifaf"], title: "Pass grid: short and deep by left, middle and right", source: "https://nflreadr.nflverse.com/articles/dictionary_pbp.html" },
 });
@@ -346,14 +359,15 @@ function curlingZones(ctx) {
 }
 /**
  * The court of a net sport on each side of the net: the front court, between the net and the line that the sport's own rules draw there, and the back court behind it.
- * That line is tennis's service line (21 ft), volleyball's attack line (3 m), badminton's short service line (1.98 m) and pickleball's non-volley zone line (7 ft); beach
- * volleyball and table tennis have none, so each side is one zone. The zones are ours: the rules name the lines, not the areas.
+ * That line is tennis's service line (21 ft), volleyball's attack line (3 m; sitting volleyball's 2 m), badminton's short service line (1.98 m), pickleball's non-volley zone
+ * line (7 ft), padel's service line (6.95 m) and teqball's service line (3.5 m); beach volleyball, table tennis and sepak takraw have none, so each side is one zone. The
+ * zones are ours: the rules name the lines, not the areas.
  */
 function netZones(ctx) {
     const plan = courtFor({ sport: ctx.o.sport, league: ctx.o.league, net: ctx.o.net });
     const { length: L, width: W } = courtSize(plan);
     const w = ctx.words;
-    const front = plan.sport === "tennis" ? plan.figures.serviceLine : plan.sport === "volleyball" ? plan.figures.attackLine : plan.sport === "badminton" ? plan.figures.shortServiceLine : plan.sport === "pickleball" ? plan.figures.nonVolley : null;
+    const front = plan.sport === "tennis" || plan.sport === "padel" || plan.sport === "teqball" ? plan.figures.serviceLine : plan.sport === "volleyball" ? plan.figures.attackLine : plan.sport === "badminton" ? plan.figures.shortServiceLine : plan.sport === "pickleball" ? plan.figures.nonVolley : null;
     const cx = L / 2;
     const both = ctx.end === "both";
     const ends = ctx.end === "both" ? ["left", "right"] : [ctx.end];
@@ -375,6 +389,37 @@ function netZones(ctx) {
     }
     return out;
 }
+/**
+ * A squash or racquetball court in two: the front court, from the front wall to the short line, and the back court behind it. The split is the short line's axis. The zones are
+ * ours: the rules name the lines, not the areas.
+ */
+function wallZones(ctx) {
+    const plan = courtFor({ sport: ctx.o.sport, league: ctx.o.league, net: ctx.o.net });
+    const { length: L, width: W } = courtSize(plan);
+    const w = ctx.words;
+    const split = plan.sport === "squash" || plan.sport === "racquetball" ? L - plan.figures.shortLine - plan.figures.lineWidth / 2 : L / 2;
+    return [rect("front-court", w.frontCourt, 0, 0, split, W, false, true), rect("back-court", w.backCourt, split, 0, L, W, true, true)];
+}
+/**
+ * A roundnet court in three: the no hit zone (the circle of 0.9 m), the ring from it out to the serving line (the circle of 2.6 m), and the rest of the court. The zones are ours:
+ * the rules name the lines, not the areas.
+ */
+function roundnetZones(ctx) {
+    const plan = courtFor({ sport: "roundnet", league: ctx.o.league, net: ctx.o.net });
+    const { length: L, width: W } = courtSize(plan);
+    if (plan.sport !== "roundnet")
+        return [];
+    const [cx, cy] = [L / 2, W / 2];
+    const { noHitRadius: n, servingRadius: R } = plan.figures;
+    const w = ctx.words;
+    const circle = (r) => `M${num(cx - r)} ${num(cy)}a${num(r)} ${num(r)} 0 1 0 ${num(2 * r)} 0a${num(r)} ${num(r)} 0 1 0 ${num(-2 * r)} 0Z`;
+    const dist = (x, y) => Math.hypot(x - cx, y - cy);
+    return [
+        { id: "outside-circles", name: w.outsideCircles, d: rectPath(0, 0, L, W) + circle(R), label: [cx, (cy + R + W) / 2], room: [L * 0.8, W / 2 - R], has: (x, y) => x >= 0 && x <= L && y >= 0 && y <= W && dist(x, y) > R },
+        { id: "serving-ring", name: w.servingRing, d: circle(R) + circle(n), label: [cx, cy - (R + n) / 2], room: [R - n, R - n], has: (x, y) => dist(x, y) > n && dist(x, y) <= R },
+        { id: "no-hit-zone", name: w.noHitZone, d: circle(n), label: [cx, cy], room: [2 * n, 2 * n], has: (x, y) => dist(x, y) <= n },
+    ];
+}
 /** The surface in thirds along it, counted from the team's own end: the same for every field sport with ends. */
 function fieldThirds(ctx) {
     const { box } = ctx.outline;
@@ -408,6 +453,109 @@ function cricketZones(ctx) {
     out.push({ id: "pitch", name: w.pitchZone, d: rectPath(px0, py0, px1, py1), label: [cx, cy], room: [px1 - px0, py1 - py0], has: inPitch });
     return out;
 }
+/** A swimming pool in lanes: each lane across the whole length of the pool, from the top of the drawing down. The lane's edges are the ropes'. */
+function poolLanes(ctx) {
+    const plan = swimPlan({ sport: "swimming", pool: ctx.o.pool });
+    const L = ctx.outline.box.w;
+    const per = FEET_PER_METRE;
+    const lanes = plan.lanes;
+    return lanes.map((lane, i) => rect(`lane-${lane.number}`, fill(ctx.words.poolLane, { n: lane.number }), 0, i === 0 ? 0 : lane.top * per, L, i === lanes.length - 1 ? ctx.outline.box.h : lane.bottom * per, true, i === lanes.length - 1));
+}
+/**
+ * A water polo field at each end: the goal area (to the 2 m line), the ground from 2 to 6 m (where the penalty foul applies), and the rest, split at the half distance line. The marks are the rules' (Part Six,
+ * Appendix 4); the zones are ours.
+ */
+function waterPoloAreas(ctx) {
+    const { box } = ctx.outline;
+    const L = box.w;
+    const W = box.h;
+    const w = ctx.words;
+    const post = WATER_POLO.goal.netClear * FEET_PER_METRE;
+    const two = WATER_POLO.twoMetre * FEET_PER_METRE;
+    const six = WATER_POLO.sixMetre * FEET_PER_METRE;
+    const goalLeft = post;
+    const goalRight = L - post;
+    return [
+        rect("goal-area-left", `${w.poloGoalArea} (${w.endLeft})`, 0, 0, goalLeft + two, W, false, true),
+        rect("two-to-six-left", `${w.poloTwoToSix} (${w.endLeft})`, goalLeft + two, 0, goalLeft + six, W, false, true),
+        rect("beyond-six-left", `${w.poloBeyondSix} (${w.endLeft})`, goalLeft + six, 0, L / 2, W, false, true),
+        rect("beyond-six-right", `${w.poloBeyondSix} (${w.endRight})`, L / 2, 0, goalRight - six, W, false, true),
+        rect("two-to-six-right", `${w.poloTwoToSix} (${w.endRight})`, goalRight - six, 0, goalRight - two, W, false, true),
+        rect("goal-area-right", `${w.poloGoalArea} (${w.endRight})`, goalRight - two, 0, L, W, true, true),
+    ];
+}
+/** The pool in thirds along its length. */
+function poolThirds(ctx) {
+    const { box } = ctx.outline;
+    const w = ctx.words;
+    return [w.poolNear, w.poolMiddle, w.poolFar].map((name, i) => rect(["near", "middle", "far"][i] + "-third", name, (box.w * i) / 3, 0, (box.w * (i + 1)) / 3, box.h, i === 2, true));
+}
+/**
+ * The athletics track in parts, each a part of the oval as the Manual lays it out (2.2.1.1): the finish straight and the back straight between the centres of the semicircles, the first bend (the right-hand one, which
+ * the athletes enter from the finish line) and the second, and the infield inside the kerb. The zones are ours: the rules name no area of the track. Lane by lane is the lane lines' business, not a zone's.
+ */
+function athleticsZones(ctx) {
+    const league = athleticsLeague({ sport: "athletics", league: ctx.o.league });
+    const fig = league.dimensions;
+    const lanes = athleticsLanes({ sport: "athletics", league: ctx.o.league, athletics: ctx.o.athletics });
+    const k = FEET_PER_METRE;
+    const { box } = ctx.outline;
+    const cx = box.w / 2;
+    const cy = box.h / 2;
+    const S = fig.straight;
+    const R = fig.radius;
+    const Ro = R + lanes * fig.lane;
+    const w = ctx.words;
+    const p = (u, v) => `${num(cx + u * k)} ${num(cy + v * k)}`;
+    const arc = (r, sweep) => `A${num(r * k)} ${num(r * k)} 0 0 ${sweep}`;
+    const inside = (u, v, r) => Math.abs(v) <= r && (Math.abs(u) <= S / 2 || Math.hypot(Math.abs(u) - S / 2, v) <= r);
+    const m = (x, y) => [(x - cx) / k, (y - cy) / k];
+    const onTrack = (u, v) => inside(u, v, Ro) && !inside(u, v, R);
+    const stadium = (r) => `M${p(-S / 2, -r)}H${num(cx + (S / 2) * k)}${arc(r, 1)} ${p(S / 2, r)}H${num(cx - (S / 2) * k)}${arc(r, 1)} ${p(-S / 2, -r)}Z`;
+    const east = `M${p(S / 2, -Ro)}${arc(Ro, 1)} ${p(S / 2, Ro)}V${num(cy + R * k)}${arc(R, 0)} ${p(S / 2, -R)}Z`;
+    const west = `M${p(-S / 2, Ro)}${arc(Ro, 1)} ${p(-S / 2, -Ro)}V${num(cy - R * k)}${arc(R, 0)} ${p(-S / 2, R)}Z`;
+    return [
+        { id: "infield", name: w.trackInfield, d: stadium(R), label: [cx, cy], room: [S * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return inside(u, v, R); } },
+        { id: "home-straight", name: w.homeStraight, d: `M${p(-S / 2, R)}H${num(cx + (S / 2) * k)}V${num(cy + Ro * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy + ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && Math.abs(u) <= S / 2 && v > 0; } },
+        { id: "first-bend", name: w.firstBend, d: east, label: [cx + (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && u > S / 2; } },
+        { id: "back-straight", name: w.backStraight, d: `M${p(-S / 2, -Ro)}H${num(cx + (S / 2) * k)}V${num(cy - R * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy - ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && Math.abs(u) <= S / 2 && v < 0; } },
+        { id: "second-bend", name: w.secondBend, d: west, label: [cx - (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onTrack(u, v) && u < -S / 2; } },
+    ];
+}
+/**
+ * The skating rink in parts: for a track, the infield inside the inner edge, the finish straight, the first curve, the crossing straight and the second curve between the centres of the curves, each as the
+ * plan lays it out (the long track's ice out to its padding, the short track's rink); for a figure skating rink, its length in thirds. The zones are ours: the Rules name no area of the ice.
+ */
+function skatingZones(ctx) {
+    const plan = skatingPlan({ sport: "skating", league: ctx.o.league, skating: ctx.o.skating });
+    const k = FEET_PER_METRE;
+    const { box } = ctx.outline;
+    const w = ctx.words;
+    const cx = box.w / 2;
+    const cy = box.h / 2;
+    if (plan.discipline === "figure") {
+        const part = (i, id, name) => rect(id, name, (box.w * i) / 3, 0, (box.w * (i + 1)) / 3, box.h, i === 2, true);
+        return [part(0, "left", w.rinkLeft), part(1, "middle", w.rinkMiddle), part(2, "right", w.rinkRight)];
+    }
+    const S = plan.oval === undefined ? plan.short.straight : plan.oval.straight;
+    const R = plan.oval === undefined ? plan.short.blocks : laneEdges(plan.oval, 0).inner;
+    const Ro = plan.oval === undefined ? plan.short.width / 2 : iceRadius(plan.oval);
+    const p = (u, v) => `${num(cx + u * k)} ${num(cy + v * k)}`;
+    const arc = (r, sweep) => `A${num(r * k)} ${num(r * k)} 0 0 ${sweep}`;
+    const inside = (u, v, r) => Math.abs(v) <= r && (Math.abs(u) <= S / 2 || Math.hypot(Math.abs(u) - S / 2, v) <= r);
+    const m = (x, y) => [(x - cx) / k, (y - cy) / k];
+    const onIce = (u, v) => inside(u, v, Ro) && !inside(u, v, R);
+    const stadium = (r) => `M${p(-S / 2, -r)}H${num(cx + (S / 2) * k)}${arc(r, 1)} ${p(S / 2, r)}H${num(cx - (S / 2) * k)}${arc(r, 1)} ${p(-S / 2, -r)}Z`;
+    const east = `M${p(S / 2, -Ro)}${arc(Ro, 1)} ${p(S / 2, Ro)}V${num(cy + R * k)}${arc(R, 0)} ${p(S / 2, -R)}Z`;
+    const west = `M${p(-S / 2, Ro)}${arc(Ro, 1)} ${p(-S / 2, -Ro)}V${num(cy - R * k)}${arc(R, 0)} ${p(-S / 2, R)}Z`;
+    return [
+        { id: "infield", name: w.trackInfield, d: stadium(R), label: [cx, cy], room: [S * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return inside(u, v, R); } },
+        { id: "home-straight", name: w.finishStraight, d: `M${p(-S / 2, R)}H${num(cx + (S / 2) * k)}V${num(cy + Ro * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy + ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && Math.abs(u) <= S / 2 && v > 0; } },
+        { id: "first-curve", name: w.firstCurve, d: east, label: [cx + (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && u > S / 2; } },
+        { id: "crossing-straight", name: w.crossingStraight, d: `M${p(-S / 2, -Ro)}H${num(cx + (S / 2) * k)}V${num(cy - R * k)}H${num(cx - (S / 2) * k)}Z`, label: [cx, cy - ((R + Ro) / 2) * k], room: [S * k, (Ro - R) * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && Math.abs(u) <= S / 2 && v < 0; } },
+        { id: "second-curve", name: w.secondCurve, d: west, label: [cx - (S / 2 + (R + Ro) / 2) * k, cy], room: [(Ro - R) * k, R * k], has: (x, y) => { const [u, v] = m(x, y); return onIce(u, v) && u < -S / 2; } },
+    ];
+}
 /** The zones of a set on the surface the context describes. Throws for a set that is not for the surface's sport. */
 export function buildZoneSet(id, ctx) {
     if (!Object.prototype.hasOwnProperty.call(ZONE_SETS, id))
@@ -419,6 +567,6 @@ export function buildZoneSet(id, ctx) {
         const { zones, which } = retrosheetZones(ctx);
         return { id, zones, which };
     }
-    const zones = id === "field-thirds" ? fieldThirds(ctx) : id === "cricket-ground" ? cricketZones(ctx) : id.startsWith("soccer") ? soccerZones(id, ctx) : id === "nba-shot" ? nbaZones(ctx) : id.startsWith("nhl") ? nhlZones(id, ctx) : id === "baseball-spray" ? baseballSpray(ctx) : id === "curling-house" ? curlingZones(ctx) : id === "net-court" ? netZones(ctx) : footballPass(ctx);
+    const zones = id === "skating-track" ? skatingZones(ctx) : id === "athletics-track" ? athleticsZones(ctx) : id === "field-thirds" ? fieldThirds(ctx) : id === "cricket-ground" ? cricketZones(ctx) : id.startsWith("soccer") ? soccerZones(id, ctx) : id === "nba-shot" ? nbaZones(ctx) : id.startsWith("nhl") ? nhlZones(id, ctx) : id === "baseball-spray" ? baseballSpray(ctx) : id === "curling-house" ? curlingZones(ctx) : id === "net-court" ? netZones(ctx) : id === "wall-court" ? wallZones(ctx) : id === "roundnet-rings" ? roundnetZones(ctx) : id === "pool-lanes" ? poolLanes(ctx) : id === "water-polo-areas" ? waterPoloAreas(ctx) : id === "pool-thirds" ? poolThirds(ctx) : footballPass(ctx);
     return { id, zones, which: lastWins(zones) };
 }

package/dist/homeside.js

@@ -10,6 +10,11 @@ export const HOME_FIRST = Object.freeze({
     fieldhockey: true,
     handball: true,
     cricket: true,
+    // Water polo lists the home team first. A swimming, diving or artistic swimming dual meet follows the North American convention: the visitor is listed first.
+    waterpolo: true,
+    swimming: false,
+    diving: false,
+    artisticswimming: false,
     // North American professional and college leagues, and the leagues that follow them: the visitor is listed first.
     lacrosse: false,
     nfl: false,
@@ -25,6 +30,18 @@ export const HOME_FIRST = Object.freeze({
     badminton: false,
     pickleball: false,
     tabletennis: false,
+    padel: false,
+    squash: false,
+    racquetball: false,
+    sepaktakraw: false,
+    teqball: false,
+    roundnet: false,
+    // Netball is scored as a goals sport, not in sets, and is listed "home v away" in the Commonwealth countries where it is played most: the home team is first, on the left.
+    netball: true,
+    // A track meeting has no home and away.
+    athletics: false,
+    // A skating race has no home and away.
+    skating: false,
 });
 /** The leagues whose convention is not their sport's: the international federation's lacrosse lists the home team first. */
 export const HOME_FIRST_LEAGUES = Object.freeze({

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { COLOR_PROPERTIES, SPORTS, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.ts";
+export { COLOR_PROPERTIES, SPORTS, crowdStands, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.ts";
 export { HOME_FIRST, HOME_FIRST_LEAGUES, homeSideFor } from "./homeside.ts";
 export { inkOn, luminance, rgbOf, safeColour, safeLogo } from "./colour.ts";
 export { OUTCOMES, drawLayers, layerTable } from "./layers.ts";
@@ -6,8 +6,16 @@ export { RANGES } from "./ranges.names.ts";
 export { BACKGROUND_OPACITY, BACKGROUND_PATTERNS, KYOGIJO_BACKGROUND_STYLE } from "./background.ts";
 export type { Background, BackgroundFit, BackgroundOptions, BackgroundPattern } from "./background.ts";
 export { FIELD_SPORTS, fieldPlan, isFieldSport } from "./fields.ts";
+export { POOL_SPORTS, isPoolSport, poolPlan, swimPlan, venueLayout } from "./pool.ts";
+export type { ArtisticPlan, Board, DivePlan, LanePlan, PoloPlan, PoolPlan, Rope, RopeColour, SwimPlan, VenueItem, VenueLayout } from "./pool.ts";
+export { formatTime, parseTime } from "./pool.race.ts";
+export type { DeckLook, DivingPlatform, PaceOptions, PoolKind, PoolLook, PoolRace, PoolSection, RaceShow, Swimmer, SwimmerStatus, VenueOptions, VenuePool } from "./pool.types.ts";
 export type { Area as FieldArea, FieldPlan, GoalPlan as FieldGoalPlan, Outline as FieldOutline, Shape as FieldShape } from "./fields.types.ts";
 export { KYOGIJO_FIELDS_STYLE } from "./fields.style.ts";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE } from "./athletics.style.ts";
+export { KYOGIJO_SKATING_STYLE } from "./skating.style.ts";
+export type { SkatingDiscipline, SkatingFurniture, SkatingInfield, SkatingRace, SkatingStyle } from "./skating/types.ts";
+export type { AthleticsFieldEvent, AthleticsInfield, AthleticsRace, AthleticsStyle, AthleticsTrackLook, WaterJump } from "./athletics/types.ts";
 export type { RangeInfo } from "./ranges.names.ts";
 export { rampColour } from "./layers.marks.ts";
 export { HEAT_RAMPS, HEAT_RAMP_NAMES } from "./heat.colour.ts";
@@ -17,7 +25,13 @@ export type { ArrowsLayer, Comet, Layer, LayerBase, LayerKind, LayerTeam, LineDa
 export { KYOGIJO_STRINGS } from "./strings.ts";
 export type { KyogijoWords } from "./strings.ts";
 export { KYOGIJO_COURTS_STYLE } from "./courts.style.ts";
+export { HARDWOOD_SMALL, KYOGIJO_HARDWOOD_STYLE } from "./hardwood.ts";
+export { KYOGIJO_CROWD_STYLE } from "./crowd.draw.ts";
+export { GRIDIRON_GROUNDS, WALL_SEATS, outlinePath, outlinePoints } from "./crowd.ts";
+export type { CrowdStands, StandGap, StandRing, StandSector, Outline as StandOutline } from "./crowd.ts";
 export { KYOGIJO_MARK_STYLE } from "./mark.ts";
+export { KYOGIJO_PAGEANT_MOTION, KYOGIJO_PAGEANT_STYLE } from "./pageant.style.ts";
+export { KYOGIJO_POOL_STYLE } from "./pool.style.ts";
 export { KYOGIJO_CURLING_STYLE, KYOGIJO_HEAT_STYLE, KYOGIJO_NOTE_STYLE, KYOGIJO_STYLE, KYOGIJO_TEAM_STYLE, KYOGIJO_WALLS_STYLE } from "./style.ts";
 export { KYOGIJO_LOOK_STYLE, LOOKS, LOOK_NAMES, LOOK_PAIRS, contrastOf, groupOf, lookPalette, lookStyle } from "./look.ts";
 export type { Group as LookGroup, Look, Palette as LookPalette, PaletteKey as LookPaletteKey } from "./look.ts";
@@ -44,4 +58,4 @@ export type { SoccerPitchClass, SoccerPitchId, SoccerSize, SoccerSpec } from "./
 export { SOCCER_PROVIDER_IDS, SOCCER_PROVIDERS, frameMatrix, rescale, soccerFrame, soccerLandmarks } from "./surfaces/soccer-providers.ts";
 export type { Rescaler, SoccerFrame, SoccerProvider, SoccerProviderId } from "./surfaces/soccer-providers.ts";
 export { VERSION } from "./version.ts";
-export type { AxesOptions, Box, Colors, CourtStyle, Detail, DirectionOptions, FieldSport, FieldStyle, Fence, GoalInfo, GoalStyle, Language, NetStyle, LineDash, LineWidth, LookName, Orientation, QuirkName, QuirkOptions, RangeBox, RangeName, RangeNamed, ScoreOptions, Side, Size, Sport, StatusWord, StripePattern, SurfaceOptions, Team, TeamMark, Theme, WallOptions, } from "./types.ts";
+export type { AxesOptions, Box, Colors, CourtStyle, CrowdOptions, CrowdShape, Detail, DirectionOptions, FieldSport, FieldStyle, Fence, GoalInfo, GoalStyle, HardwoodOptions, Language, NetStyle, LineDash, LineWidth, LookName, Orientation, PoolSport, PoolStyle, QuirkName, QuirkOptions, RangeBox, PageantOptions, PageantStyle, RangeName, RangeNamed, ScoreOptions, Side, Size, Sport, StatusWord, StripePattern, SurfaceOptions, Team, TeamMark, Theme, WallOptions, } from "./types.ts";

package/dist/index.js

@@ -1,18 +1,27 @@
 // Kyogijo Stadiums 競技場: sports surfaces as SVG, drawn to scale, with the teams and the score on them.
-export { COLOR_PROPERTIES, SPORTS, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.js";
+export { COLOR_PROPERTIES, SPORTS, crowdStands, describe, drawBadge, drawKyogijo, drawScore, drawSurface, isPortrait, statusLabel, statusText, winnerOf } from "./draw.js";
 export { HOME_FIRST, HOME_FIRST_LEAGUES, homeSideFor } from "./homeside.js";
 export { inkOn, luminance, rgbOf, safeColour, safeLogo } from "./colour.js";
 export { OUTCOMES, drawLayers, layerTable } from "./layers.js";
 export { RANGES } from "./ranges.names.js";
 export { BACKGROUND_OPACITY, BACKGROUND_PATTERNS, KYOGIJO_BACKGROUND_STYLE } from "./background.js";
 export { FIELD_SPORTS, fieldPlan, isFieldSport } from "./fields.js";
+export { POOL_SPORTS, isPoolSport, poolPlan, swimPlan, venueLayout } from "./pool.js";
+export { formatTime, parseTime } from "./pool.race.js";
 export { KYOGIJO_FIELDS_STYLE } from "./fields.style.js";
+export { KYOGIJO_ATHLETICS_STYLE, KYOGIJO_TRACK_STYLE } from "./athletics.style.js";
+export { KYOGIJO_SKATING_STYLE } from "./skating.style.js";
 export { rampColour } from "./layers.marks.js";
 export { HEAT_RAMPS, HEAT_RAMP_NAMES } from "./heat.colour.js";
 export { ZONE_SETS, ZONE_SET_IDS } from "./heat.zones.js";
 export { KYOGIJO_STRINGS } from "./strings.js";
 export { KYOGIJO_COURTS_STYLE } from "./courts.style.js";
+export { HARDWOOD_SMALL, KYOGIJO_HARDWOOD_STYLE } from "./hardwood.js";
+export { KYOGIJO_CROWD_STYLE } from "./crowd.draw.js";
+export { GRIDIRON_GROUNDS, WALL_SEATS, outlinePath, outlinePoints } from "./crowd.js";
 export { KYOGIJO_MARK_STYLE } from "./mark.js";
+export { KYOGIJO_PAGEANT_MOTION, KYOGIJO_PAGEANT_STYLE } from "./pageant.style.js";
+export { KYOGIJO_POOL_STYLE } from "./pool.style.js";
 export { KYOGIJO_CURLING_STYLE, KYOGIJO_HEAT_STYLE, KYOGIJO_NOTE_STYLE, KYOGIJO_STYLE, KYOGIJO_TEAM_STYLE, KYOGIJO_WALLS_STYLE } from "./style.js";
 export { KYOGIJO_LOOK_STYLE, LOOKS, LOOK_NAMES, LOOK_PAIRS, contrastOf, groupOf, lookPalette, lookStyle } from "./look.js";
 export { FEATURES, FEATURE_INFO, KYOGIJO_FEATURE_STYLE } from "./features.js";

package/dist/layers.d.ts

@@ -11,7 +11,7 @@ export interface RenderedLayers {
     summaries: string[];
 }
 /** The layers of a drawing as markup, and a sentence for each. `turned` says whether the surface group is turned a quarter. */
-export declare function renderLayers(o: SurfaceOptions | ScoreOptions, layers: readonly Layer[] | undefined, turned?: boolean, range?: Box): RenderedLayers;
+export declare function renderLayers(o: SurfaceOptions | ScoreOptions, layers: readonly Layer[] | undefined, turned?: boolean, range?: Box, upright?: number): RenderedLayers;
 /**
  * The layers of a drawing as one SVG group, in the surface's own frame, for a caller who composes the drawing's parts. Put it inside the
  * surface's group (the one with the quarter turn, when the drawing is tall) and the marks lie on the surface, cut to its outline, with

package/dist/layers.env.d.ts

@@ -14,6 +14,8 @@ export interface Env {
     o: SurfaceOptions | ScoreOptions;
     id: string;
     turned: boolean;
+    /** The turn, in degrees, that texts and logos are given to read upright: the quarter back (-90) when the surface is turned a quarter, else 0, or the surface's own (a close-up of an athletics start is turned to any angle). */
+    back: number;
     unit: Unit;
     outline: Outline;
     /**
@@ -69,4 +71,4 @@ export declare function place(layer: LayerBase, env: Env, points: readonly P[],
 /** The inverse of `place`: places on the surface, in feet, as the layer's own coordinates (its frame and unit). */
 export declare function placeBack(layer: LayerBase, env: Env, points: readonly P[], unit: Unit): P[];
 export declare function newMade(): Made;
-export declare function envFor(o: SurfaceOptions | ScoreOptions, turned: boolean | undefined, range?: Box): Env;
+export declare function envFor(o: SurfaceOptions | ScoreOptions, turned: boolean | undefined, range?: Box, upright?: number): Env;

package/dist/layers.env.js

@@ -60,14 +60,16 @@ export function placeBack(layer, env, points, unit) {
 export function newMade() {
     return { marks: "", defs: "", style: "", attr: "", opacity: undefined, drawn: 0, skipped: 0, outcomes: new Map(), teams: new Map(), low: Infinity, high: -Infinity };
 }
-export function envFor(o, turned, range) {
+export function envFor(o, turned, range, upright) {
     const language = o.language === "ja" ? "ja" : "en";
     const outline = outlineOf(o);
     const teams = o;
+    const quarter = turned ?? (isPortrait(o) && o.sport !== "mlb");
     return {
         o,
         id: drawingId(o),
-        turned: turned ?? (isPortrait(o) && o.sport !== "mlb"),
+        turned: quarter,
+        back: upright ?? (quarter ? -90 : 0),
         unit: lengthUnit(o),
         outline,
         shown: range ?? outline.box,

package/dist/layers.js

@@ -141,7 +141,7 @@ function drawPoints(layer, env) {
         const logo = shape === "logo" ? safeLogo(d.logo) ?? (role === undefined ? undefined : safeLogo(style.logos?.[role]) ?? env.logos[role]) : undefined;
         if (logo !== undefined) {
             const side = w * 1.8;
-            out.push(titled("image", `${open} href="${esc(logo)}" x="${num(x - side / 2)}" y="${num(y - side / 2)}" width="${num(side)}" height="${num(side)}" preserveAspectRatio="xMidYMid meet"${env.turned ? ` transform="rotate(-90 ${num(x)} ${num(y)})"` : ""}`, d.title));
+            out.push(titled("image", `${open} href="${esc(logo)}" x="${num(x - side / 2)}" y="${num(y - side / 2)}" width="${num(side)}" height="${num(side)}" preserveAspectRatio="xMidYMid meet"${env.back !== 0 ? ` transform="rotate(${num(env.back)} ${num(x)} ${num(y)})"` : ""}`, d.title));
         }
         else if (shape !== "logo" && isPolygon(shape))
             out.push(titled("path", `${open} d="${shapePath(shape, x, y, w, env.turned)}"`, d.title));
@@ -307,7 +307,7 @@ function drawText(layer, env) {
         const { cls, css } = colourAttrs(colourFor(style.color, d, INK, domain), layerExpr, INK);
         const anchor = d.anchor === "start" || d.anchor === "middle" || d.anchor === "end" ? d.anchor : base;
         // The letters are turned back by the quarter the surface was turned, so that they read upright, and by the caller's own turn on top.
-        const angle = (env.turned ? -90 : 0) + (isNum(d.rotate) ? d.rotate : 0);
+        const angle = env.back + (isNum(d.rotate) ? d.rotate : 0);
         const classes = ["ky-lt", style.halo === false ? "ky-nh" : "", cls].filter((c) => c !== "").join(" ");
         const open = `${attrs(classes, `${s === size ? "" : `font-size:${num(s)}px`}${s !== size && css !== "" ? ";" : ""}${css}`, opacityOf(d.opacity))}${anchor === base ? "" : ` text-anchor="${anchor}"`} x="${num(x)}" y="${num(y + s * 0.36)}"${angle === 0 ? "" : ` transform="rotate(${num(angle)} ${num(x)} ${num(y)})"`}`;
         out.push(`<text${open}>${esc(String(d.text))}${typeof d.title === "string" && d.title !== "" ? `<title>${esc(d.title)}</title>` : ""}</text>`);
@@ -348,12 +348,12 @@ function summarise(layer, made, words, stop, gap) {
     return { title, description: parts.join(gap) };
 }
 /** The layers of a drawing as markup, and a sentence for each. `turned` says whether the surface group is turned a quarter. */
-export function renderLayers(o, layers, turned, range) {
+export function renderLayers(o, layers, turned, range, upright) {
     if (layers === undefined || layers.length === 0)
         return { svg: "", summaries: [] };
     if (!Array.isArray(layers))
         throw new TypeError("layers is a list of layers");
-    const env = envFor(o, turned, range);
+    const env = envFor(o, turned, range, upright);
     const clipId = `${env.id}-lc`;
     const { stop, gap } = env.words.said;
     const said = [];

package/dist/leagues/athletics.d.ts

@@ -0,0 +1,63 @@
+import { type Unit } from "../units.ts";
+import type { LeagueBase } from "./types.ts";
+/** The figures of an oval track, in metres. */
+export interface AthleticsFigures {
+    /** The length of each straight (the distance between the centres of the semicircles, for the outdoor track's). */
+    straight: number;
+    /** The radius of each bend at the inside of the track, where the kerb is. */
+    radius: number;
+    /** The width of a lane, the line on its right included. */
+    lane: number;
+    /** The least, the most and the drawn number of lanes of the oval. */
+    lanes: {
+        min: number;
+        max: number;
+        drawn: number;
+    };
+    /** The width of the painted lines. */
+    line: number;
+    /** The width of the kerb, as it is drawn (the rules allow 50 to 250 mm). */
+    kerb: number;
+    /** Where the running line is measured: from the kerb in lane 1, from the line on the left in the other lanes. */
+    inner: number;
+    outer: number;
+    /** The obstacle-free zone inside the kerb and outside the track, at least. */
+    safety: number;
+    /** The lane width of the straight that runs on beyond the oval's. */
+    straightLane: number;
+    /** The least and the most lanes of that straight, and the lengths round it: the starting area and the run-out. */
+    straightLanes: {
+        min: number;
+        max: number;
+    };
+    startArea: number;
+    runOut: number;
+    /** True for a covered track: its bends are banked, at this angle in degrees. */
+    banking: number | null;
+}
+/** The figures in feet, as the drawing's units are: the lengths only, not the counts of lanes or the angle of the banking. */
+export declare function athleticsInFeet(figures: AthleticsFigures, unit: Unit): AthleticsFigures;
+/** A league with an athletics track of its own. */
+export type AthleticsLeague = LeagueBase<"athletics", AthleticsFigures>;
+/**
+ * The 400 m Standard Track (Manual 2.2.1.1, Table 2.2.1.1): two semicircles of 36.50 m radius at the kerb joined by two straights of 84.39 m, lanes 1.22 m wide including the 50 mm line on the
+ * right (Rule 14.4), the running line 0.30 m outside the kerb in lane 1 and 0.20 m outside the line on the left in every other lane (Rule 14.2), eight lanes at least for the big competitions (Rule
+ * 14.5) and nine at the most (Manual 2.2.1.1). A straight of at least six lanes runs on beyond the oval's with a starting area of 3 m and a run-out of 17 m (Manual 2.2.2.1), and has no most (2.2.2.1).
+ * The safety zones are 1.00 m wide (2.2.1.5). The kerb is drawn 0.05 m wide, the narrowest the rules allow (Rule 14.1: 50 to 250 mm).
+ */
+export declare const WA_STANDARD_TRACK: AthleticsFigures;
+/**
+ * The 200 m Standard Short Track (Marking Plan for the World Athletics Standard Short Track, 1 January 2026; Rules 41 to 44): the bends have a construction radius of 17.205 m at the kerb and the
+ * centres of the banked bends are 44.983 m apart; lanes are 1.000 m wide on the oval and 1.220 m on the infield straight, four to six of them (Rule 43: 0.90 to 1.22 m, a minimum of four lanes and
+ * a maximum of six); the bends are banked at 10.000 degrees. The plan's own transitions (the ascending and descending sections) are drawn here as one circular bend of the same radius, which is ours.
+ */
+export declare const WA_SHORT_TRACK: AthleticsFigures;
+/** The staggers of the lanes of the 400 m Standard Track as the Manual prints them (Table 2.2.1.6a), in metres on the running line, for lanes 2 to 8: 200 m, 400 m, 800 m and 4 x 400 m. */
+export declare const WA_STAGGER_TABLE: Readonly<Record<"200m" | "400m" | "800m" | "4x400m", readonly number[]>>;
+/**
+ * The staggers of the lanes of the 200 m Standard Short Track (Marking Plan, 1 January 2026), in metres measured 0.20 m out from the lane line, for lanes 2 to 6. The first row serves the 200 m, 400 m,
+ * 800 m, 4 x 400 m and 4 x 800 m (two bends in lanes), the second the 4 x 200 m (three bends in lanes), the third the second leg of the 4 x 200 m (one bend).
+ */
+export declare const WA_SHORT_STAGGER_TABLE: Readonly<Record<"two-bends" | "three-bends" | "one-bend", readonly number[]>>;
+/** The athletics leagues: the outdoor track (the sport's own) and the covered one. */
+export declare const ATHLETICS_LEAGUES: readonly AthleticsLeague[];

package/dist/leagues/athletics.js

@@ -0,0 +1,87 @@
+// The athletics track: World Athletics' 400 m Standard Track (Track and Field Facilities Manual, 2019 edition, 2.2.1, and Technical Rule 14 of Book C2.1) and its 200 m Standard Short Track
+// for covered stadia (Technical Rules 41 to 44, and the Marking Plan for the Standard Short Track of 1 January 2026), with the figures of each in metres. Nothing here draws.
+import { convertLength } from "../units.js";
+/** The figures in feet, as the drawing's units are: the lengths only, not the counts of lanes or the angle of the banking. */
+export function athleticsInFeet(figures, unit) {
+    const k = (v) => convertLength(v, unit, "ft");
+    return {
+        straight: k(figures.straight),
+        radius: k(figures.radius),
+        lane: k(figures.lane),
+        lanes: { ...figures.lanes },
+        line: k(figures.line),
+        kerb: k(figures.kerb),
+        inner: k(figures.inner),
+        outer: k(figures.outer),
+        safety: k(figures.safety),
+        straightLane: k(figures.straightLane),
+        straightLanes: { ...figures.straightLanes },
+        startArea: k(figures.startArea),
+        runOut: k(figures.runOut),
+        banking: figures.banking,
+    };
+}
+/**
+ * The 400 m Standard Track (Manual 2.2.1.1, Table 2.2.1.1): two semicircles of 36.50 m radius at the kerb joined by two straights of 84.39 m, lanes 1.22 m wide including the 50 mm line on the
+ * right (Rule 14.4), the running line 0.30 m outside the kerb in lane 1 and 0.20 m outside the line on the left in every other lane (Rule 14.2), eight lanes at least for the big competitions (Rule
+ * 14.5) and nine at the most (Manual 2.2.1.1). A straight of at least six lanes runs on beyond the oval's with a starting area of 3 m and a run-out of 17 m (Manual 2.2.2.1), and has no most (2.2.2.1).
+ * The safety zones are 1.00 m wide (2.2.1.5). The kerb is drawn 0.05 m wide, the narrowest the rules allow (Rule 14.1: 50 to 250 mm).
+ */
+export const WA_STANDARD_TRACK = {
+    straight: 84.39,
+    radius: 36.5,
+    lane: 1.22,
+    lanes: { min: 4, max: 9, drawn: 8 },
+    line: 0.05,
+    kerb: 0.05,
+    inner: 0.3,
+    outer: 0.2,
+    safety: 1,
+    straightLane: 1.22,
+    straightLanes: { min: 6, max: 10 },
+    startArea: 3,
+    runOut: 17,
+    banking: null,
+};
+/**
+ * The 200 m Standard Short Track (Marking Plan for the World Athletics Standard Short Track, 1 January 2026; Rules 41 to 44): the bends have a construction radius of 17.205 m at the kerb and the
+ * centres of the banked bends are 44.983 m apart; lanes are 1.000 m wide on the oval and 1.220 m on the infield straight, four to six of them (Rule 43: 0.90 to 1.22 m, a minimum of four lanes and
+ * a maximum of six); the bends are banked at 10.000 degrees. The plan's own transitions (the ascending and descending sections) are drawn here as one circular bend of the same radius, which is ours.
+ */
+export const WA_SHORT_TRACK = {
+    straight: 44.983,
+    radius: 17.205,
+    lane: 1,
+    lanes: { min: 4, max: 6, drawn: 6 },
+    line: 0.05,
+    kerb: 0.05,
+    inner: 0.3,
+    outer: 0.2,
+    safety: 1,
+    straightLane: 1.22,
+    straightLanes: { min: 4, max: 6 },
+    startArea: 3,
+    runOut: 10,
+    banking: 10,
+};
+/** The staggers of the lanes of the 400 m Standard Track as the Manual prints them (Table 2.2.1.6a), in metres on the running line, for lanes 2 to 8: 200 m, 400 m, 800 m and 4 x 400 m. */
+export const WA_STAGGER_TABLE = Object.freeze({
+    "200m": [3.519, 7.351, 11.184, 15.017, 18.85, 22.682, 26.515],
+    "400m": [7.037, 14.703, 22.368, 30.034, 37.699, 45.365, 53.03],
+    "800m": [3.526, 7.384, 11.259, 15.151, 19.06, 22.987, 26.93],
+    "4x400m": [10.563, 22.086, 33.627, 45.185, 56.76, 68.352, 79.96],
+});
+/**
+ * The staggers of the lanes of the 200 m Standard Short Track (Marking Plan, 1 January 2026), in metres measured 0.20 m out from the lane line, for lanes 2 to 6. The first row serves the 200 m, 400 m,
+ * 800 m, 4 x 400 m and 4 x 800 m (two bends in lanes), the second the 4 x 200 m (three bends in lanes), the third the second leg of the 4 x 200 m (one bend).
+ */
+export const WA_SHORT_STAGGER_TABLE = Object.freeze({
+    "two-bends": [5.597, 11.821, 18.051, 24.285, 30.523],
+    "three-bends": [8.407, 17.781, 27.188, 36.626, 46.092],
+    "one-bend": [2.81, 5.959, 9.137, 12.341, 15.57],
+});
+/** The athletics leagues: the outdoor track (the sport's own) and the covered one. */
+export const ATHLETICS_LEAGUES = [
+    { id: "world-athletics", family: "athletics", name: { en: "World Athletics 400 m standard track", ja: "ワールドアスレティックスの400m標準トラック" }, unit: "m", dimensions: WA_STANDARD_TRACK, sources: ["wa-facilities-manual", "wa-technical-rules"], builtIn: true },
+    { id: "world-athletics-short", family: "athletics", name: { en: "World Athletics 200 m standard short track", ja: "ワールドアスレティックスの200m標準トラック（ショート・トラック）" }, unit: "m", dimensions: WA_SHORT_TRACK, sources: ["wa-short-track-plan", "wa-technical-rules"] },
+];