@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/geometry.d.ts

@@ -5,6 +5,7 @@ import { ICC_MEN_GROUND } from "./leagues/cricket.ts";
 import { FIH_PITCH } from "./leagues/fieldhockey.ts";
 import { GAA_FOOTBALL_FIELD } from "./leagues/gaelic.ts";
 import { IHF_COURT } from "./leagues/handball.ts";
+import { ARTISTIC, DIVING, SWIMMING, WATER_POLO } from "./pool.figures.ts";
 import { WORLD_MEN_FIELD } from "./leagues/lacrosse.ts";
 import { WORLD_RUGBY_FIELD } from "./leagues/rugby.ts";
 import type { Sport } from "./types.ts";
@@ -185,6 +186,14 @@ export declare const BEACH_VOLLEYBALL: import("./leagues.ts").VolleyballFigures;
 export declare const BADMINTON: import("./leagues.ts").BadmintonFigures;
 export declare const PICKLEBALL: import("./leagues.ts").PickleballFigures;
 export declare const TABLE_TENNIS: import("./leagues.ts").TableTennisFigures;
+export declare const SITTING_VOLLEYBALL: import("./leagues.ts").VolleyballFigures;
+export declare const PADEL: import("./leagues.ts").PadelFigures;
+export declare const SQUASH: import("./leagues.ts").SquashFigures;
+export declare const RACQUETBALL: import("./leagues.ts").RacquetballFigures;
+export declare const SEPAK_TAKRAW: import("./leagues.ts").SepakTakrawFigures;
+export declare const TEQBALL: import("./leagues.ts").TeqballFigures;
+export declare const ROUNDNET: import("./leagues.ts").RoundnetFigures;
+export declare const NETBALL: import("./leagues.ts").NetballFigures;
 /** The baseball field, from rules 2.01 to 2.05 of the Official Baseball Rules. */
 export declare const MLB: {
     readonly base: 90;
@@ -283,6 +292,13 @@ export declare function dimensionsOf(sport: "volleyball", unit?: Unit): Scaled<t
 export declare function dimensionsOf(sport: "badminton", unit?: Unit): Scaled<typeof BADMINTON>;
 export declare function dimensionsOf(sport: "pickleball", unit?: Unit): Scaled<typeof PICKLEBALL>;
 export declare function dimensionsOf(sport: "tabletennis", unit?: Unit): Scaled<typeof TABLE_TENNIS>;
+export declare function dimensionsOf(sport: "padel", unit?: Unit): Scaled<typeof PADEL>;
+export declare function dimensionsOf(sport: "squash", unit?: Unit): Scaled<typeof SQUASH>;
+export declare function dimensionsOf(sport: "racquetball", unit?: Unit): Scaled<typeof RACQUETBALL>;
+export declare function dimensionsOf(sport: "sepaktakraw", unit?: Unit): Scaled<typeof SEPAK_TAKRAW>;
+export declare function dimensionsOf(sport: "teqball", unit?: Unit): Scaled<typeof TEQBALL>;
+export declare function dimensionsOf(sport: "roundnet", unit?: Unit): Scaled<typeof ROUNDNET>;
+export declare function dimensionsOf(sport: "netball", unit?: Unit): Scaled<typeof NETBALL>;
 export declare function dimensionsOf(sport: "lacrosse", unit?: Unit): Scaled<typeof WORLD_MEN_FIELD>;
 export declare function dimensionsOf(sport: "rugby", unit?: Unit): Scaled<typeof WORLD_RUGBY_FIELD>;
 export declare function dimensionsOf(sport: "afl", unit?: Unit): Scaled<typeof AFL_GROUND>;
@@ -290,6 +306,10 @@ export declare function dimensionsOf(sport: "gaelic", unit?: Unit): Scaled<typeo
 export declare function dimensionsOf(sport: "cricket", unit?: Unit): Scaled<typeof ICC_MEN_GROUND>;
 export declare function dimensionsOf(sport: "fieldhockey", unit?: Unit): Scaled<typeof FIH_PITCH>;
 export declare function dimensionsOf(sport: "handball", unit?: Unit): Scaled<typeof IHF_COURT>;
+export declare function dimensionsOf(sport: "swimming", unit?: Unit): Scaled<typeof SWIMMING>;
+export declare function dimensionsOf(sport: "waterpolo", unit?: Unit): Scaled<typeof WATER_POLO>;
+export declare function dimensionsOf(sport: "diving", unit?: Unit): Scaled<typeof DIVING>;
+export declare function dimensionsOf(sport: "artisticswimming", unit?: Unit): Scaled<typeof ARTISTIC>;
 export declare function dimensionsOf(sport: Sport, unit?: Unit): unknown;
 /** A fence's points with each distance in another unit; the angles stay as they are. Feet are the default for `from`. */
 export declare function fenceIn(points: readonly FencePoint[], to: Unit, from?: Unit): FencePoint[];

package/dist/geometry.js

@@ -3,12 +3,13 @@
 // hold a key distance to the rulebook.
 import { SURFACE_UNITS, convertLength, lengthsIn } from "./units.js";
 import { SOCCER, soccerSpec } from "./surfaces/soccer-spec.js";
-import { BWF_BADMINTON, FIVB_BEACH, FIVB_INDOOR, ITF_TENNIS, ITTF_TABLE, USAP_PICKLEBALL, netInFeet } from "./leagues/courts.js";
+import { BWF_BADMINTON, FIP_PADEL, FITEQ_TEQBALL, FIVB_BEACH, FIVB_INDOOR, IRF_RACQUETBALL, IRF_ROUNDNET, ISTAF_SEPAK_TAKRAW, ITF_TENNIS, ITTF_TABLE, USAP_PICKLEBALL, WN_NETBALL, WPV_SITTING, WSF_SQUASH, netInFeet } from "./leagues/courts.js";
 import { AFL_GROUND } from "./leagues/aussie.js";
 import { ICC_MEN_GROUND } from "./leagues/cricket.js";
 import { FIH_PITCH } from "./leagues/fieldhockey.js";
 import { GAA_FOOTBALL_FIELD } from "./leagues/gaelic.js";
 import { IHF_COURT } from "./leagues/handball.js";
+import { ARTISTIC, DIVING, SWIMMING, SWIMMING_WIDTHS, WATER_POLO } from "./pool.figures.js";
 import { WORLD_MEN_FIELD } from "./leagues/lacrosse.js";
 import { WORLD_RUGBY_FIELD } from "./leagues/rugby.js";
 export const FEET_PER_YARD = 3;
@@ -126,6 +127,14 @@ export const BEACH_VOLLEYBALL = netInFeet(FIVB_BEACH, "m");
 export const BADMINTON = netInFeet(BWF_BADMINTON, "m");
 export const PICKLEBALL = netInFeet(USAP_PICKLEBALL, "ft");
 export const TABLE_TENNIS = netInFeet(ITTF_TABLE, "m");
+export const SITTING_VOLLEYBALL = netInFeet(WPV_SITTING, "m");
+export const PADEL = netInFeet(FIP_PADEL, "m");
+export const SQUASH = netInFeet(WSF_SQUASH, "m");
+export const RACQUETBALL = netInFeet(IRF_RACQUETBALL, "ft");
+export const SEPAK_TAKRAW = netInFeet(ISTAF_SEPAK_TAKRAW, "m");
+export const TEQBALL = netInFeet(FITEQ_TEQBALL, "m");
+export const ROUNDNET = netInFeet(IRF_ROUNDNET, "m");
+export const NETBALL = netInFeet(WN_NETBALL, "m");
 /** The baseball field, from rules 2.01 to 2.05 of the Official Baseball Rules. */
 export const MLB = {
     base: 90,
@@ -274,6 +283,34 @@ export function surfaceSize(sport, unit = SURFACE_UNITS[sport]) {
             length = TABLE_TENNIS.length;
             width = TABLE_TENNIS.width;
             break;
+        case "padel":
+            length = PADEL.length;
+            width = PADEL.width;
+            break;
+        case "squash":
+            length = SQUASH.length;
+            width = SQUASH.width;
+            break;
+        case "racquetball":
+            length = RACQUETBALL.length;
+            width = RACQUETBALL.width;
+            break;
+        case "sepaktakraw":
+            length = SEPAK_TAKRAW.length;
+            width = SEPAK_TAKRAW.width;
+            break;
+        case "teqball":
+            length = TEQBALL.length;
+            width = TEQBALL.width;
+            break;
+        case "roundnet":
+            length = ROUNDNET.length;
+            width = ROUNDNET.width;
+            break;
+        case "netball":
+            length = NETBALL.length;
+            width = NETBALL.width;
+            break;
         case "lacrosse":
             length = convertLength(WORLD_MEN_FIELD.length.drawn, "m", "ft");
             width = convertLength(WORLD_MEN_FIELD.width.drawn, "m", "ft");
@@ -304,6 +341,23 @@ export function surfaceSize(sport, unit = SURFACE_UNITS[sport]) {
             length = convertLength(IHF_COURT.length.drawn, "m", "ft");
             width = convertLength(IHF_COURT.width.drawn, "m", "ft");
             break;
+        // The pools, as drawn without options: the 50 by 25 m pool of eight lanes, the water polo pool (the field and the 0.30 m behind each goal line), a diving well and the Olympic artistic swimming area.
+        case "swimming":
+            length = convertLength(SWIMMING.longCourse, "m", "ft");
+            width = convertLength(SWIMMING_WIDTHS.permanent, "m", "ft");
+            break;
+        case "waterpolo":
+            length = convertLength(WATER_POLO.length + 2 * WATER_POLO.goal.netClear, "m", "ft");
+            width = convertLength(WATER_POLO.width, "m", "ft");
+            break;
+        case "diving":
+            length = convertLength(DIVING.well.length, "m", "ft");
+            width = convertLength(DIVING.well.width, "m", "ft");
+            break;
+        case "artisticswimming":
+            length = convertLength(ARTISTIC.olympic.length, "m", "ft");
+            width = convertLength(ARTISTIC.olympic.width, "m", "ft");
+            break;
         default:
             throw new Error(`No fixed size for "${String(sport)}": a ballpark's size is its fence`);
     }
@@ -336,6 +390,20 @@ export function dimensionsOf(sport, unit = SURFACE_UNITS[sport]) {
             return lengthsIn(PICKLEBALL, unit);
         case "tabletennis":
             return lengthsIn(TABLE_TENNIS, unit);
+        case "padel":
+            return lengthsIn(PADEL, unit);
+        case "squash":
+            return lengthsIn(SQUASH, unit);
+        case "racquetball":
+            return lengthsIn(RACQUETBALL, unit);
+        case "sepaktakraw":
+            return lengthsIn(SEPAK_TAKRAW, unit);
+        case "teqball":
+            return lengthsIn(TEQBALL, unit);
+        case "roundnet":
+            return lengthsIn(ROUNDNET, unit);
+        case "netball":
+            return lengthsIn(NETBALL, unit);
         // The field sports: the figures of the league a drawing has without a `league` (`LEAGUES` has the others), kept in the unit their rulebook prints them in.
         case "lacrosse":
             return lengthsIn(WORLD_MEN_FIELD, unit, "m");
@@ -351,6 +419,15 @@ export function dimensionsOf(sport, unit = SURFACE_UNITS[sport]) {
             return lengthsIn(FIH_PITCH, unit, "m");
         case "handball":
             return lengthsIn(IHF_COURT, unit, "m");
+        // The pools' figures, kept in metres as World Aquatics prints them.
+        case "swimming":
+            return lengthsIn(SWIMMING, unit, "m");
+        case "waterpolo":
+            return lengthsIn(WATER_POLO, unit, "m");
+        case "diving":
+            return lengthsIn(DIVING, unit, "m");
+        case "artisticswimming":
+            return lengthsIn(ARTISTIC, unit, "m");
         default:
             throw new Error(`Unknown sport "${String(sport)}"`);
     }

package/dist/grounds.d.ts

@@ -54,6 +54,10 @@ export interface GroundData {
     /** The year it opened, and for a past ground the year it closed. */
     from?: number;
     to?: number;
+    /** True where Wikidata lists athletics among the ground's sports (property P641): a running track lies round the pitch, which `drawKyogijo({ sport: "athletics", ground })` draws. Absent for a ground Wikidata says nothing of, which may still have one. */
+    track?: boolean;
+    /** Where `track` was read. */
+    trackSource?: string;
     /** The first capacity the article's infobox gives, when it gives a number. */
     capacity?: number;
     /** `published` when the article gives the pitch's length and width, `default` when it does not: the ground is then drawn at the international 105 by 68 m. */

package/dist/grounds.data.js

@@ -298,6 +298,8 @@ export const GROUND_DATA = [
     {
         "id": "olympiastadion-munich",
         "wikidata": "Q131610",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Munich Olympic Stadium",
         "nameJa": "ミュンヘン・オリンピアシュタディオン",
         "localName": "Olympiastadion München",
@@ -391,6 +393,8 @@ export const GROUND_DATA = [
     {
         "id": "stadio-olimpico-rome",
         "wikidata": "Q159884",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Stadio Olimpico",
         "names": [
             { "name": "Stadio dei Cipressi", "from": 1928, "to": 1953 },
@@ -450,6 +454,8 @@ export const GROUND_DATA = [
     {
         "id": "stade-de-france",
         "wikidata": "Q13205",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Stade de France",
         "nameJa": "スタッド・ド・フランス",
         "localName": "Stade de France",
@@ -476,6 +482,8 @@ export const GROUND_DATA = [
     {
         "id": "nissan-stadium-yokohama",
         "wikidata": "Q116601",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Nissan Stadium",
         "names": [
             { "name": "International Stadium Yokohama", "from": 1998, "to": 2004 }
@@ -570,6 +578,8 @@ export const GROUND_DATA = [
     {
         "id": "luzhniki",
         "wikidata": "Q202163",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Luzhniki Stadium",
         "names": [
             { "name": "Central Lenin Stadium", "from": 1956, "to": 1992 }
@@ -1092,6 +1102,8 @@ export const GROUND_DATA = [
     {
         "id": "dignity-health-sports-park",
         "wikidata": "Q200684",
+        "track": true,
+        "trackSource": "Wikidata, property P641 (sport) lists athletics",
         "name": "Dignity Health Sports Park",
         "names": [
             { "name": "Home Depot Center", "from": 2003, "to": 2013 },

package/dist/hardwood.d.ts

@@ -0,0 +1,31 @@
+import type { CourtStyle } from "./types.ts";
+/** The options of a hardwood floor, read: every part has its value. */
+export interface Hardwood {
+    seed: number;
+    /** True for the seams, ends, grain, soft shadows, table and benches; false for broad boards and one shadow. */
+    fine: boolean;
+    /** The width of a board, in feet. */
+    board: number;
+    stain: number;
+    sheen: number;
+    hoops: boolean;
+    bench: boolean;
+}
+/** The width of a drawing in pixels when the options say it (`480` or `"480px"`), else `undefined` (a percentage or an em says nothing of the screen). */
+export declare function pixelWidth(width: unknown): number | undefined;
+/** The width in pixels under which a drawing is a thumbnail, and its boards a blur: the `auto` detail is `plain` below it. */
+export declare const HARDWOOD_SMALL = 480;
+/** The hardwood the options ask for, or `undefined` for the usual clean floor. `simple` is the drawing's `detail: "simple"`; `width` its `width` option. */
+export declare function resolveHardwood(court: CourtStyle | undefined, simple: boolean, width: unknown): Hardwood | undefined;
+/** A small, fast generator (mulberry32): the same seed gives the same numbers on every machine. */
+export declare function generator(seed: number): () => number;
+/** The width of a tile, in feet: longer than any court of the package, so that the boards do not repeat along it. */
+export declare const TILE = 96;
+/** The two tiles of a floor and the size they are laid at: the tones and grain (under the paint) and the seams and ends (over it). */
+export declare function floorTiles(h: Hardwood): {
+    height: number;
+    under: string;
+    over: string;
+};
+/** The rules of the hardwood floor's classes, written into a drawing that has one (and in `KYOGIJO_STYLE`, for a page that supplies the stylesheet). */
+export declare const KYOGIJO_HARDWOOD_STYLE: string;

package/dist/hardwood.js

@@ -0,0 +1,157 @@
+// The realistic basketball floor (`court.hardwood`): the options read once, and the boards. A maple strip floor is laid in boards of one width that run the length of the
+// court, each row's boards ending at different places so that no two neighbours' ends line up; each board has a tone of its own and a little grain. All of it is made here
+// from a seed with a small generator of our own (no `Math.random`), so the same options give the same floor, and it is written as two tiles of a pattern (the tones and
+// grain under the paint, the seams and ends over it), so that the SVG holds a few shapes however large the court is. Written for this package from the way a strip floor
+// is laid; no photograph or other drawing was copied.
+import { el, num } from "./format.js";
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const clamp = (value, low, high) => Math.min(high, Math.max(low, value));
+/** The width of a drawing in pixels when the options say it (`480` or `"480px"`), else `undefined` (a percentage or an em says nothing of the screen). */
+export function pixelWidth(width) {
+    if (finite(width))
+        return width > 0 ? width : undefined;
+    const match = typeof width === "string" ? /^\s*(\d+(?:\.\d+)?)(?:px)?\s*$/.exec(width) : null;
+    return match === null ? undefined : Number(match[1]);
+}
+/** The width in pixels under which a drawing is a thumbnail, and its boards a blur: the `auto` detail is `plain` below it. */
+export const HARDWOOD_SMALL = 480;
+/** The hardwood the options ask for, or `undefined` for the usual clean floor. `simple` is the drawing's `detail: "simple"`; `width` its `width` option. */
+export function resolveHardwood(court, simple, width) {
+    const given = court?.hardwood;
+    if (given === undefined || given === false)
+        return undefined;
+    const o = given === true ? {} : given;
+    const px = pixelWidth(width);
+    const fine = o.detail === "fine" || (o.detail !== "plain" && !simple && (px === undefined || px >= HARDWOOD_SMALL));
+    return {
+        seed: finite(o.seed) ? Math.trunc(o.seed) : 1,
+        fine,
+        board: clamp(finite(o.board) ? o.board : 2.25, 1.5, 6) / 12,
+        stain: clamp(finite(o.stain) ? o.stain : 0.82, 0.3, 1),
+        sheen: clamp(finite(o.sheen) ? o.sheen : 1, 0, 1.5),
+        hoops: o.hoops !== false,
+        bench: o.bench !== false && fine,
+    };
+}
+/** A small, fast generator (mulberry32): the same seed gives the same numbers on every machine. */
+export function generator(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** The width of a tile, in feet: longer than any court of the package, so that the boards do not repeat along it. */
+export const TILE = 96;
+const WARM = "#fff0c4";
+const DEEP = "#4a280b";
+const TONES = [
+    { colour: WARM, opacity: 0.19, upTo: 90 },
+    { colour: WARM, opacity: 0.1, upTo: 310 },
+    { colour: DEEP, opacity: 0.1, upTo: 520 },
+    { colour: DEEP, opacity: 0.2, upTo: 640 },
+];
+/** The least two ends of boards in neighbouring rows come to one another, in feet. */
+const APART = 1.2;
+/** True when an end at `x` is within `APART` of any end of the rows given, going round the tile. */
+const near = (x, rows) => rows.some((row) => row?.some((end) => {
+    const d = Math.abs(x - end) % TILE;
+    return Math.min(d, TILE - d) < APART;
+}) === true);
+/** An end moved on, a little at a time, until it is clear of the ends of the rows next to it (and of its own row's, `own`). */
+function clear(x, rows, own, least) {
+    let at = x;
+    for (let tries = 0; tries < 40 && (near(at, rows) || own.some((end) => Math.abs(at - end) < least)); tries += 1)
+        at += 0.6;
+    return at;
+}
+/**
+ * The rows of boards of a tile: for each row the places its boards end, going round the tile. A row's ends are at random distances apart, between `lengths`, and are
+ * moved on until none is within a foot of an end in the row above or the one above that, as boards are laid so that no joint lines up with a neighbour's.
+ */
+function rows(count, lengths, next) {
+    const [low, high] = lengths;
+    const made = [];
+    for (let r = 0; r < count; r += 1) {
+        // The rows next to it: the two above, and for the last rows the first ones, which lie under them when the tile repeats.
+        const above = [made[r - 1], made[r - 2], ...(r >= count - 2 ? made.slice(0, r === count - 1 ? 2 : 1) : [])];
+        const start = next() * high;
+        const ends = [clear(start, above, [], low)];
+        for (let at = ends[0] + low + next() * (high - low); at < start + TILE - low * 0.6; at += low + next() * (high - low)) {
+            const placed = clear(at, above, ends, low * 0.6);
+            ends.push(placed);
+            at = placed;
+        }
+        made.push(ends.map((end) => end % TILE).sort((x, y) => x - y));
+    }
+    return made;
+}
+/** A number for a path: one decimal, no leading zero's loss (`.5`), never `-0`. */
+const n1 = (value) => {
+    const text = (Math.round(value * 10) / 10).toString();
+    return text === "-0" ? "0" : text;
+};
+/** The pieces of one row's board between two ends, going round the tile: one piece, or two when the board crosses its edge. */
+function spans(from, to) {
+    return to > from ? [[from, to]] : [[from, TILE], [0, to]];
+}
+/** The two tiles of a floor and the size they are laid at: the tones and grain (under the paint) and the seams and ends (over it). */
+export function floorTiles(h) {
+    const next = generator(h.seed);
+    const pitch = h.fine ? h.board : h.board * 4;
+    const count = Math.max(4, Math.round(6 / pitch));
+    const height = count * pitch;
+    const ends = rows(count, h.fine ? [5, 12] : [10, 26], next);
+    // Each board's tone: a stroke across the whole width of its row, so that the rows meet with no gap.
+    const byTone = TONES.map(() => []);
+    ends.forEach((row, r) => {
+        const y = num((r + 0.5) * pitch);
+        for (let i = 0; i < row.length; i += 1) {
+            const pick = next() * 1000;
+            const tone = TONES.findIndex((t) => pick < t.upTo);
+            if (tone < 0)
+                continue;
+            for (const [a, b] of spans(row[i], row[(i + 1) % row.length]))
+                byTone[tone].push(`M${n1(a)} ${y}h${n1(b - a)}`);
+        }
+    });
+    let under = "";
+    TONES.forEach((tone, i) => {
+        if (byTone[i].length > 0)
+            under += el("path", { d: byTone[i].join(""), stroke: tone.colour, "stroke-opacity": tone.opacity, "stroke-width": num(pitch + 0.004), fill: "none" });
+    });
+    if (!h.fine)
+        return { height, under, over: "" };
+    // The grain: fine streaks along the boards, short and faint, a few of them bowed.
+    const grain = [];
+    for (let i = 0; i < 70; i += 1) {
+        const x = next() * TILE;
+        const y = (Math.floor(next() * count) + 0.15 + next() * 0.7) * pitch;
+        const length = 1.2 + next() * 5.5;
+        const bow = (next() - 0.5) * pitch * 0.5;
+        grain.push(i % 4 === 0 ? `M${n1(x)} ${num(y)}q${n1(length / 2)} ${num(bow)} ${n1(length)} 0` : `M${n1(x)} ${num(y)}h${n1(length)}`);
+    }
+    under += el("path", { d: grain.join(""), stroke: DEEP, "stroke-opacity": 0.2, "stroke-width": num(pitch * 0.09), fill: "none", "stroke-linecap": "round" });
+    // The seams between the boards and the butt joints where they end.
+    const seam = [];
+    for (let r = 0; r < count; r += 1)
+        seam.push(`M0 ${num(r * pitch)}H${TILE}`);
+    ends.forEach((row, r) => {
+        for (const x of row)
+            seam.push(`M${n1(x)} ${num(r * pitch)}v${num(pitch)}`);
+    });
+    const over = el("path", { d: seam.join(""), stroke: "#2a1506", "stroke-opacity": 0.3, "stroke-width": num(pitch * 0.17), fill: "none" });
+    return { height, under, over };
+}
+/** The rules of the hardwood floor's classes, written into a drawing that has one (and in `KYOGIJO_STYLE`, for a page that supplies the stylesheet). */
+export const KYOGIJO_HARDWOOD_STYLE = `
+.kyogijo .ky-hw-end-l{fill:var(--ky-hw-end-left,var(--ky-boards))}
+.kyogijo .ky-hw-end-r{fill:var(--ky-hw-end-right,var(--ky-boards))}
+.kyogijo .ky-hw-pad{fill:var(--ky-hw-pad,#2c333c);stroke:#fff;stroke-opacity:.2;stroke-width:.1}
+.kyogijo .ky-hw-arm{fill:var(--ky-hw-arm,#454d58);stroke:#fff;stroke-opacity:.15;stroke-width:.06}
+.kyogijo .ky-hw-glass{fill:#eef4f8;stroke:#7d8791;stroke-width:.06}
+.kyogijo .ky-hw-net{fill:none;stroke:#fff;stroke-opacity:.7}
+.kyogijo .ky-hw-furniture{fill:#7b838c;fill-opacity:.35;stroke:#7b838c;stroke-opacity:.35;stroke-width:.18;stroke-linejoin:round}`.trim();

package/dist/heat.js

@@ -330,8 +330,8 @@ function formatter(percent, decimals) {
 }
 /** The legend's marks: a plate, the heading, the steps as a bar and the ticks. Laid out as the eye sees it, then placed on the surface and turned back when the surface is turned. */
 function legendMarks(env, spec) {
-    const box = env.shown;
-    const b = env.base;
+    const box = spec.region ?? env.shown;
+    const b = spec.region === undefined ? env.base : Math.max(box.w, box.h) * 0.013;
     const fs = b * 1.1;
     const barH = b * 1.3;
     const pad = b * 1;
@@ -518,6 +518,7 @@ export function drawHeat(layer, env, gid, known) {
             title: legend.title ?? c.stat,
             ticks: legend.ticks ?? 5,
             position: legend.position ?? (env.o.sport === "mlb" ? "bottom-right" : "bottom"),
+            region: legend.region,
             format: formatter(c.percent, undefined),
             at: contour === undefined || contour.levels.length > 6 ? undefined : contour.levels.map((l) => 100 * l.label),
         }));
@@ -566,7 +567,7 @@ export function drawLegend(layer, env, gid, known) {
     const title = typeof layer.name === "string" && layer.name.trim() !== "" ? layer.name.trim() : target?.stat ?? words.stat.custom;
     made.cls = "ky-hm";
     made.opacity = opacityOf(layer.opacity);
-    made.marks = legendMarks(env, { colours, title, ticks: layer.ticks ?? 5, position: layer.position ?? (env.o.sport === "mlb" ? "bottom-right" : "bottom"), format: formatter(percent, undefined) });
+    made.marks = legendMarks(env, { colours, title, ticks: layer.ticks ?? 5, position: layer.position ?? (env.o.sport === "mlb" ? "bottom-right" : "bottom"), region: layer.region, format: formatter(percent, undefined) });
     made.css = darkRules(colours, [gid]);
     made.title = fill(words.legendTitle, { name: title });
     made.text = fill(words.range, { min: formatter(percent, undefined)(colours.domain[0]), max: formatter(percent, undefined)(colours.domain[1]) });

package/dist/heat.types.d.ts

@@ -2,6 +2,7 @@ import type { HeatRamp } from "./heat.colour.ts";
 import type { HexOrientation, Reducer, StatisticName } from "./heat.stats.ts";
 import type { ZoneSetId } from "./heat.zones.ts";
 import type { LayerBase, MarkDatum } from "./layers.types.ts";
+import type { Box } from "./types.ts";
 export type { HeatRamp, HeatRampName } from "./heat.colour.ts";
 export type { HexOrientation, Reducer, StatisticName } from "./heat.stats.ts";
 export type { ZoneSetId } from "./heat.zones.ts";
@@ -33,6 +34,8 @@ export interface HeatLegend {
     ticks?: number;
     /** The opacity of the legend, 0 to 1. */
     opacity?: number;
+    /** Size and place the legend against this part of the surface, in feet in the drawing's frame (x along the surface, y across it), instead of the whole of what is shown: the half of a curling sheet that is drawn, say. */
+    region?: Box;
 }
 /** What the heat layers take beyond a layer's places. */
 export interface HeatBase extends LayerBase {
@@ -142,4 +145,6 @@ export interface LegendLayer extends Omit<LayerBase, "from" | "attacking" | "sur
     ticks?: number;
     /** The opacity of the legend, 0 to 1. */
     opacity?: number;
+    /** Size and place the legend against this part of the surface, as `HeatLegend.region` does. */
+    region?: Box;
 }

package/dist/heat.zones.d.ts

@@ -2,7 +2,7 @@ import type { Outline } from "./outline.ts";
 import type { KyogijoWords } from "./strings.ts";
 import type { Sport, SurfaceOptions } from "./types.ts";
 /** The zone sets. */
-export type ZoneSetId = "field-thirds" | "cricket-ground" | "soccer-positional" | "soccer-thirds" | "soccer-channels" | "soccer-18" | "nba-shot" | "nhl-slot" | "nhl-home-plate" | "baseball-spray" | "baseball-retrosheet" | "football-pass" | "curling-house" | "net-court";
+export type ZoneSetId = "field-thirds" | "cricket-ground" | "soccer-positional" | "soccer-thirds" | "soccer-channels" | "soccer-18" | "nba-shot" | "nhl-slot" | "nhl-home-plate" | "baseball-spray" | "baseball-retrosheet" | "football-pass" | "athletics-track" | "skating-track" | "curling-house" | "net-court" | "wall-court" | "roundnet-rings" | "pool-lanes" | "water-polo-areas" | "pool-thirds";
 type Pt = readonly [number, number];
 /** One zone: its shape on the surface and whether a point lies in it. */
 export interface ZoneShape {
@@ -30,7 +30,7 @@ export interface ZoneSet {
 }
 /** What a zone set needs to know about the drawing and the layer. */
 export interface ZoneContext {
-    o: Pick<SurfaceOptions, "sport" | "pitch" | "units"> & Partial<Pick<SurfaceOptions, "league" | "net" | "field">>;
+    o: Pick<SurfaceOptions, "sport" | "pitch" | "units"> & Partial<Pick<SurfaceOptions, "league" | "net" | "field" | "pool" | "athletics" | "skating">>;
     outline: Outline;
     /** The way the team attacks as the surface is drawn wide: names the sides and counts the bands from the team's own end. `right` by default. */
     direction: "left" | "right";