@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/skating/describe.js

@@ -0,0 +1,44 @@
+// What a skating drawing says of itself: its sentence about the rink, and what the options mark on it. Cheap (it reads the options, not the plan), so that a title and a description cost nothing.
+import { fill, KYOGIJO_STRINGS } from "../strings.js";
+import { raceById } from "./events.js";
+import { furnitureOf, racesOf, skatingLeague } from "./plan.js";
+import { longOval } from "./track.js";
+/** The words of a race in a language. */
+export const raceName = (id, language) => raceById(id)?.name[language] ?? id;
+/** The sentence about the rink, as a fragment: "a 400 m speed skating track with two lanes of 4 m...". */
+export function skatingAbout(o, language) {
+    const words = KYOGIJO_STRINGS[language].skating;
+    const league = skatingLeague(o);
+    const d = league.dimensions;
+    if (d.kind === "long-track") {
+        const oval = longOval(o.skating?.innerRadius, o.skating?.laneWidth, d);
+        return fill(words.longTrack, { radius: oval.a, outer: oval.w2, straight: Math.round(oval.straight * 100) / 100 });
+    }
+    if (d.kind === "short-track")
+        return fill(words.shortTrack, { length: o.skating?.rink?.length ?? d.rink.length, width: o.skating?.rink?.width ?? d.rink.width, tracks: o.skating?.tracks ?? 5 });
+    return fill(words.figure, { length: o.skating?.rink?.length ?? d.length.drawn, width: o.skating?.rink?.width ?? d.width.drawn });
+}
+/** The sentences that follow it: the races marked, the furniture of a figure skating rink and the close-up. Each starts after a gap. */
+export function skatingSentences(o, language) {
+    const words = KYOGIJO_STRINGS[language].skating;
+    const { gap } = KYOGIJO_STRINGS[language].said;
+    const sep = KYOGIJO_STRINGS[language].layers.listSep;
+    const discipline = skatingLeague(o).dimensions.kind;
+    const out = [];
+    if (discipline === "figure") {
+        const furniture = furnitureOf(o.skating);
+        if (furniture.length > 0)
+            out.push(fill(words.furniture, { list: furniture.map((f) => words.furnitureNames[f]).join(sep) }));
+    }
+    else {
+        const races = racesOf(o.skating, discipline);
+        if (races.length > 0)
+            out.push(fill(words.races, { list: races.map((r) => raceName(r, language)).join(sep) }));
+    }
+    const range = typeof o.range === "string" ? o.range : typeof o.range === "object" && o.range !== null && "name" in o.range ? o.range.name : undefined;
+    if (range === "start" && discipline !== "figure")
+        out.push(fill(words.start, { race: raceName(o.skating?.start ?? "500m", language) }));
+    if (range === "finish" && discipline !== "figure")
+        out.push(words.finish);
+    return out.map((t) => `${gap}${t}`).join("");
+}

package/dist/skating/events.d.ts

@@ -0,0 +1,24 @@
+import type { LongTrackRace, RaceInfo, ShortTrackRace, SkatingRace } from "./types.ts";
+/** The races of the long track, in the order a menu lists them. The mass start is 16 laps (6400 m); the team pursuit and the team sprint are marked by their lines in the middle of the straights. */
+export declare const LONG_TRACK_RACES: readonly RaceInfo[];
+/**
+ * The races of the short track: the individual 500, 1000 and 1500 m, the 3000 m of the World Cup, and the relays: the women's 3000 m, the men's 5000 m and the mixed 2000 m (Rule 281.1a, which gives the
+ * distances of the ISU Championships; the diagram of the tracks gives the laps of each distance).
+ */
+export declare const SHORT_TRACK_RACES: readonly RaceInfo[];
+/** Every race of both tracks, once by id. */
+export declare const RACES: readonly RaceInfo[];
+export declare const LONG_TRACK_RACE_IDS: readonly LongTrackRace[];
+export declare const SHORT_TRACK_RACE_IDS: readonly ShortTrackRace[];
+export declare const RACE_IDS: readonly SkatingRace[];
+/** A race by its id, or `undefined`. */
+export declare const raceById: (id: unknown) => RaceInfo | undefined;
+/** The kinds of element of a figure skating programme a mark can stand for. */
+export declare const ELEMENT_KINDS: readonly ["jump", "spin", "step-sequence", "choreographic-sequence", "lift", "spiral", "twizzle", "death-spiral", "throw"];
+export type ElementKind = (typeof ELEMENT_KINDS)[number];
+/** The words of a kind of element. */
+export declare const ELEMENT_NAMES: Readonly<Record<ElementKind, {
+    en: string;
+    ja: string;
+    fr: string;
+}>>;

package/dist/skating/events.js

@@ -0,0 +1,47 @@
+const race = (r) => Object.freeze(r);
+/** The races of the long track, in the order a menu lists them. The mass start is 16 laps (6400 m); the team pursuit and the team sprint are marked by their lines in the middle of the straights. */
+export const LONG_TRACK_RACES = Object.freeze([
+    race({ id: "500m", distance: 500, name: { en: "500 m", ja: "500m", fr: "500\u00a0m" } }),
+    race({ id: "1000m", distance: 1000, name: { en: "1000 m", ja: "1000m", fr: "1000\u00a0m" } }),
+    race({ id: "1500m", distance: 1500, name: { en: "1500 m", ja: "1500m", fr: "1500\u00a0m" } }),
+    race({ id: "3000m", distance: 3000, name: { en: "3000 m", ja: "3000m", fr: "3000\u00a0m" } }),
+    race({ id: "5000m", distance: 5000, name: { en: "5000 m", ja: "5000m", fr: "5000\u00a0m" } }),
+    race({ id: "10000m", distance: 10000, name: { en: "10,000 m", ja: "10000m", fr: "10\u00a0000\u00a0m" } }),
+    race({ id: "mass-start", distance: 6400, name: { en: "Mass start", ja: "マススタート", fr: "Départ groupé" } }),
+    race({ id: "team-pursuit", distance: 3200, name: { en: "Team pursuit", ja: "チームパシュート", fr: "Poursuite par équipes" } }),
+    race({ id: "team-sprint", distance: 1200, name: { en: "Team sprint", ja: "チームスプリント", fr: "Sprint par équipes" } }),
+]);
+/**
+ * The races of the short track: the individual 500, 1000 and 1500 m, the 3000 m of the World Cup, and the relays: the women's 3000 m, the men's 5000 m and the mixed 2000 m (Rule 281.1a, which gives the
+ * distances of the ISU Championships; the diagram of the tracks gives the laps of each distance).
+ */
+export const SHORT_TRACK_RACES = Object.freeze([
+    race({ id: "500m", distance: 500, name: { en: "500 m", ja: "500m", fr: "500\u00a0m" } }),
+    race({ id: "1000m", distance: 1000, name: { en: "1000 m", ja: "1000m", fr: "1000\u00a0m" } }),
+    race({ id: "1500m", distance: 1500, name: { en: "1500 m", ja: "1500m", fr: "1500\u00a0m" } }),
+    race({ id: "3000m", distance: 3000, name: { en: "3000 m", ja: "3000m", fr: "3000\u00a0m" } }),
+    race({ id: "3000m-relay", distance: 3000, name: { en: "3000 m relay", ja: "3000mリレー", fr: "Relais 3000\u00a0m" } }),
+    race({ id: "5000m-relay", distance: 5000, name: { en: "5000 m relay", ja: "5000mリレー", fr: "Relais 5000\u00a0m" } }),
+    race({ id: "2000m-mixed-relay", distance: 2000, name: { en: "2000 m mixed relay", ja: "2000m混合リレー", fr: "Relais mixte 2000\u00a0m" } }),
+]);
+/** Every race of both tracks, once by id. */
+export const RACES = Object.freeze([...LONG_TRACK_RACES, ...SHORT_TRACK_RACES.filter((r) => !LONG_TRACK_RACES.some((l) => l.id === r.id))]);
+export const LONG_TRACK_RACE_IDS = Object.freeze(LONG_TRACK_RACES.map((r) => r.id));
+export const SHORT_TRACK_RACE_IDS = Object.freeze(SHORT_TRACK_RACES.map((r) => r.id));
+export const RACE_IDS = Object.freeze(RACES.map((r) => r.id));
+/** A race by its id, or `undefined`. */
+export const raceById = (id) => RACES.find((r) => r.id === id);
+/** The kinds of element of a figure skating programme a mark can stand for. */
+export const ELEMENT_KINDS = Object.freeze(["jump", "spin", "step-sequence", "choreographic-sequence", "lift", "spiral", "twizzle", "death-spiral", "throw"]);
+/** The words of a kind of element. */
+export const ELEMENT_NAMES = Object.freeze({
+    jump: { en: "Jump", ja: "ジャンプ", fr: "Saut" },
+    spin: { en: "Spin", ja: "スピン", fr: "Pirouette" },
+    "step-sequence": { en: "Step sequence", ja: "ステップシークエンス", fr: "Séquence de pas" },
+    "choreographic-sequence": { en: "Choreographic sequence", ja: "コレオシークエンス", fr: "Séquence chorégraphique" },
+    lift: { en: "Lift", ja: "リフト", fr: "Levée" },
+    spiral: { en: "Spiral", ja: "スパイラル", fr: "Spirale" },
+    twizzle: { en: "Twizzle", ja: "ツイズル", fr: "Twizzle" },
+    "death-spiral": { en: "Death spiral", ja: "デススパイラル", fr: "Spirale de la mort" },
+    throw: { en: "Throw jump", ja: "スロージャンプ", fr: "Saut lancé" },
+});

package/dist/skating/figure.d.ts

@@ -0,0 +1,24 @@
+import { type FigureRinkFigures } from "../leagues/skating.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+import type { SkatingFurniture } from "./types.ts";
+/** The rink: its length and width. */
+export interface FigureRink {
+    length: number;
+    width: number;
+}
+/** The furniture of a figure skating rink, in painter's order. */
+export declare const FURNITURE: readonly SkatingFurniture[];
+/** The seats of a panel of judges, side by side at the rinkboard: nine, as at the Olympic Winter Games (ours: the Rules fix the number elsewhere), 1 m apart. */
+export declare const JUDGES = 9;
+/** Where the furniture stands outside the boards of the rink on its long side at the bottom (and the kiss and cry at the end), as boxes in metres. */
+export declare function furnitureBoxes(r: FigureRink, fig?: FigureRinkFigures): Record<SkatingFurniture, MBox[]>;
+export interface FigureOptions {
+    fig: FigureRinkFigures;
+    furniture: readonly SkatingFurniture[];
+}
+/** The parts of the rink. */
+export declare function figureParts(r: FigureRink, opt: FigureOptions): {
+    parts: Parts;
+    box: MBox;
+    marks: MMark[];
+};

package/dist/skating/figure.js

@@ -0,0 +1,37 @@
+import { ISU_FIGURE_RINK } from "../leagues/skating.js";
+import { emptyParts } from "./parts.js";
+/** The furniture of a figure skating rink, in painter's order. */
+export const FURNITURE = Object.freeze(["judges", "referee", "technical-panel", "kiss-and-cry"]);
+/** The seats of a panel of judges, side by side at the rinkboard: nine, as at the Olympic Winter Games (ours: the Rules fix the number elsewhere), 1 m apart. */
+export const JUDGES = 9;
+/** Where the furniture stands outside the boards of the rink on its long side at the bottom (and the kiss and cry at the end), as boxes in metres. */
+export function furnitureBoxes(r, fig = ISU_FIGURE_RINK) {
+    const y = r.width / 2 + fig.boards + 0.6;
+    const seat = (x) => ({ x0: x - 0.4, y0: y, x1: x + 0.4, y1: y + 0.8 });
+    return {
+        judges: Array.from({ length: JUDGES }, (_, i) => seat((i - (JUDGES - 1) / 2) * 1)),
+        referee: [seat(-(JUDGES - 1) / 2 - 2)],
+        "technical-panel": [{ x0: (JUDGES - 1) / 2 + 1.5, y0: y + 1.2, x1: (JUDGES - 1) / 2 + 5.5, y1: y + 2.4 }],
+        "kiss-and-cry": [{ x0: -r.length / 2 + 3, y0: y, x1: -r.length / 2 + 6.5, y1: y + 1.6 }],
+    };
+}
+/** The parts of the rink. */
+export function figureParts(r, opt) {
+    const { fig } = opt;
+    const parts = emptyParts();
+    const Lh = r.length / 2;
+    const W = r.width / 2;
+    const rd = (n) => Math.round(n * 100) / 100;
+    const roundD = (hx, hy, k) => `M${rd(-hx + k)} ${rd(-hy)}H${rd(hx - k)}A${k} ${k} 0 0 1 ${rd(hx)} ${rd(-hy + k)}V${rd(hy - k)}A${k} ${k} 0 0 1 ${rd(hx - k)} ${rd(hy)}H${rd(-hx + k)}A${k} ${k} 0 0 1 ${rd(-hx)} ${rd(hy - k)}V${rd(-hy + k)}A${k} ${k} 0 0 1 ${rd(-hx + k)} ${rd(-hy)}Z`;
+    parts.areas.push({ id: "ice", feature: "ice", cls: "ky-ska-ice", d: roundD(Lh, W, fig.corner) });
+    parts.areas.push({ id: "boards", feature: "boards", cls: "ky-boards", d: `${roundD(Lh + fig.boards, W + fig.boards, fig.corner + fig.boards)}${roundD(Lh, W, fig.corner)}`, evenodd: true });
+    const boxes = furnitureBoxes(r, fig);
+    const marks = [];
+    for (const kind of opt.furniture) {
+        boxes[kind].forEach((b, i) => parts.areas.push({ id: `${kind}-${i + 1}`, feature: kind, cls: kind === "kiss-and-cry" ? "ky-ska-kiss" : "ky-ska-desk", rect: [b.x0, b.y0, b.x1, b.y1] }));
+        const b = boxes[kind][Math.floor(boxes[kind].length / 2)];
+        marks.push({ id: kind, x: (b.x0 + b.x1) / 2, y: b.y1, side: "bottom" });
+    }
+    const extra = opt.furniture.length === 0 ? 0 : 3.4;
+    return { parts, box: { x0: -Lh - fig.boards, y0: -W - fig.boards, x1: Lh + fig.boards, y1: W + fig.boards + extra }, marks };
+}

package/dist/skating/long.d.ts

@@ -0,0 +1,54 @@
+import type { Shape } from "../fields.types.ts";
+import { type LongTrackFigures } from "../leagues/skating.ts";
+import { LONG_TRACK_RACES } from "./events.ts";
+import { addParts, type MBox, type Parts } from "./parts.ts";
+import { laneRadius, type Lane, type LongOval } from "./track.ts";
+import type { LongTrackRace, SkatingInfield } from "./types.ts";
+/** Where a skater starts: the lane (or `both` for a line across both lanes) and the point of the start. */
+export interface StartPlacement {
+    lane: Lane | "both";
+    /** The coordinate along the skater's own way, from the beginning of the finishing straight of the lap the start is in. */
+    v0: number;
+    x: number;
+    y: number;
+    heading: number;
+}
+/** What a race marks: the lines where it starts, the finishing line it ends at, and how its first straight is skated. */
+export interface RaceMarks {
+    race: LongTrackRace;
+    /** The finishing line: the 400 m mark at the end of the finishing straight or the 1000 m mark in the middle of it. */
+    finish: "400m" | "1000m";
+    /** True when the first straight keeps its lane (the 1000 m and the 1500 m, Rule 254.5b). */
+    noChange: boolean;
+    /** The starting lines: one for each lane, or one across both. */
+    starts: StartPlacement[];
+}
+/** The marks of a race on the oval. */
+export declare function markRace(o: LongOval, race: LongTrackRace): RaceMarks;
+/** What the long track adds: everything from the ice to the lines. */
+export interface LongOptions {
+    fig: LongTrackFigures;
+    warmUp: boolean;
+    infield: SkatingInfield;
+    blocks: boolean;
+    coaches: boolean;
+    padding: boolean;
+    races: readonly LongTrackRace[];
+}
+export declare const LONG_DEFAULTS: {
+    warmUp: boolean;
+    infield: SkatingInfield;
+    blocks: boolean;
+    coaches: boolean;
+    padding: boolean;
+};
+/** The ice's outer radius: the outer edge of the outer lane and the 3 m the Rules keep clear (Rule 228.2). */
+export declare const iceRadius: (o: LongOval, fig?: LongTrackFigures) => number;
+/** The parts of the long track. */
+export declare function longParts(o: LongOval, opt: LongOptions): {
+    parts: Parts;
+    marks: RaceMarks[];
+    box: MBox;
+};
+export { addParts, laneRadius, LONG_TRACK_RACES };
+export type { Shape };

package/dist/skating/long.js

@@ -0,0 +1,111 @@
+// The long track: the ice, the padding, the lanes and the warm-up lane, the blocks of the curves, the coaches' area, the finishing lines and the starting lines of each race. Every figure is the ISU's
+// (Special Regulations and Technical Rules Speed Skating, Rules 203, 205, 226, 227, 228, 253, 254 and 256 to 257, and "H. Track"), in metres. Nothing here draws SVG: it makes the shapes.
+import { line, poly } from "../fields.kit.js";
+import { ISU_LONG_TRACK } from "../leagues/skating.js";
+import { LONG_TRACK_RACES } from "./events.js";
+import { addParts, blocksOf, emptyParts, stadiumD } from "./parts.js";
+import { finishAt, laneEdges, laneRadius, outerEdge, pose, startOf } from "./track.js";
+/** How each race starts. `at` is the finishing line's mark, `middle` a start in the middle of the straights (Rules 256 and 257). */
+const SPEC = {
+    "500m": { finish: "400m", distance: 500, noChange: false },
+    "1000m": { finish: "1000m", distance: 1000, noChange: true },
+    "1500m": { finish: "400m", distance: 1500, noChange: true },
+    "3000m": { finish: "400m", distance: 3000, noChange: false },
+    "5000m": { finish: "400m", distance: 5000, noChange: false },
+    "10000m": { finish: "400m", distance: 10000, noChange: false },
+    "mass-start": { finish: "400m", distance: 0, noChange: false, start: "middle" },
+    "team-pursuit": { finish: "1000m", distance: 0, noChange: false, start: "both-straights" },
+    "team-sprint": { finish: "1000m", distance: 0, noChange: false, start: "both-straights" },
+};
+/** The marks of a race on the oval. */
+export function markRace(o, race) {
+    const spec = SPEC[race];
+    const finish = finishAt(o, spec.finish);
+    const place = (lane, v0, p) => ({ lane, v0, x: p.x, y: p.y, heading: p.heading });
+    if (spec.start === "middle") {
+        const p = pose(o, 0, o.straight / 2);
+        return { race, finish: spec.finish, noChange: false, starts: [place("both", o.straight / 2, { ...p, y: o.d })] };
+    }
+    if (spec.start === "both-straights") {
+        const bottom = pose(o, 0, o.straight / 2);
+        const top = pose(o, 0, o.straight + Math.PI * o.d + o.crossing / 2);
+        return { race, finish: spec.finish, noChange: false, starts: [place(0, o.straight / 2, bottom), place(0, 0, { ...top, y: -o.d })] };
+    }
+    const starts = [0, 1].map((lane) => {
+        const s = startOf(o, lane, spec.distance, finish, spec.noChange);
+        return place(lane, s.v0, s.pose);
+    });
+    // A line across both lanes where the two lanes start at the same place (the 500 m, the 10,000 m).
+    const same = Math.abs(starts[0].x - starts[1].x) < 1e-6 && Math.abs(starts[0].y * starts[1].y) > 0 && Math.sign(starts[0].y) === Math.sign(starts[1].y);
+    return { race, finish: spec.finish, noChange: spec.noChange, starts: same ? [{ ...starts[0], lane: "both" }] : starts };
+}
+/** The y-range of a lane's band on the top or the bottom side at x, from the edges' radii: on a straight the band is the radii themselves; past the end of a curve's start, the circle's. */
+function bandAt(f, x, rA, rB, side) {
+    const out = Math.abs(x) - f / 2;
+    const y = (r) => (out <= 0 ? r : Math.sqrt(Math.max(0, r * r - out * out)));
+    return [side * y(rA), side * y(rB)];
+}
+export const LONG_DEFAULTS = { warmUp: true, infield: "floor", blocks: true, coaches: true, padding: true };
+/** The ice's outer radius: the outer edge of the outer lane and the 3 m the Rules keep clear (Rule 228.2). */
+export const iceRadius = (o, fig = ISU_LONG_TRACK) => outerEdge(o) + fig.padding.clear;
+/** The parts of the long track. */
+export function longParts(o, opt) {
+    const { fig } = opt;
+    const f = o.straight;
+    const edges = laneEdges(o, opt.warmUp ? fig.warmUpLane : 0);
+    const R = iceRadius(o, fig);
+    const parts = emptyParts();
+    const L = fig.line;
+    // The ice, the infield and the padding: the ice out to the padding, the padding a band 0.3 m thick at its edge, and what lies inside the warm-up lane.
+    parts.areas.push({ id: "ice", feature: "ice", cls: "ky-ska-ice", d: stadiumD(f, R) });
+    if (opt.padding)
+        parts.areas.push({ id: "padding", feature: "padding", cls: "ky-ska-pad", d: `${stadiumD(f, R + fig.padding.thick)}${stadiumD(f, R)}`, evenodd: true });
+    if (opt.warmUp)
+        parts.areas.push({ id: "warm-up", feature: "warm-up", cls: "ky-ska-warm", d: `${stadiumD(f, edges.inner)}${stadiumD(f, edges.warmUp)}`, evenodd: true });
+    parts.areas.push({ id: "infield", feature: "infield", cls: opt.infield === "ice" ? "ky-ska-ice" : "ky-ska-floor", d: stadiumD(f, edges.warmUp) });
+    // The lanes' lines (Rule 226): fully painted, 5 cm wide, in the straights and in the curves.
+    const radii = [...(opt.warmUp ? [edges.warmUp] : []), edges.inner, edges.between, edges.outer];
+    radii.forEach((r, i) => parts.shapes.push({ kind: "path", id: `lane-line-${i}`, feature: "lane-lines", d: stadiumD(f, r), w: L, cls: "ky-ska-b" }));
+    // The blocks (Rule 226): inside the painted lines of the inner lane's edge and of the line between the lanes, 50 cm apart for the first 15 m of a curve and 2 m after.
+    if (opt.blocks) {
+        for (const [name, r] of [["inner", edges.inner], ["between", edges.between]]) {
+            const rb = r - L - fig.blocks.height;
+            for (const side of ["right", "left"])
+                parts.shapes.push(...blocksOf(`blocks-${name}-${side}`, f, side, rb, fig.blocks.near, fig.blocks.nearLength, fig.blocks.far, 0.12));
+        }
+    }
+    // The coaches' area (Rule 227.3): a line 2 cm wide, 1 m from the outside edge of the track, from 25 m after the end of the curve to 10 m before the next, on the crossing straight.
+    if (opt.coaches) {
+        const y = -(edges.outer + fig.coaches.offset);
+        parts.shapes.push(line("coaches-area", "coaches-area", f / 2 - fig.coaches.after, y, -f / 2 + fig.coaches.before, y, { w: 0.02, cls: "ky-ska-r" }));
+    }
+    // The finishing lines and the last 5 m before them, marked by the metre (Rule 227.2).
+    const marks = opt.races.map((r) => markRace(o, r));
+    const finishes = new Set(["400m"]);
+    for (const m of marks)
+        finishes.add(m.finish);
+    const bottom = bandAt(f, 0, edges.inner, edges.outer, 1);
+    for (const which of finishes) {
+        const x = -f / 2 + finishAt(o, which);
+        parts.shapes.push(line(`finish-${which}`, "finish-line", x, bottom[0], x, bottom[1], { w: L, cls: "ky-ska-r" }));
+        for (let m = 1; m <= fig.finishMetres; m += 1)
+            parts.shapes.push(line(`finish-${which}-metre-${m}`, "finish-marks", x - m, bottom[0], x - m, bottom[1], { w: 0.02, cls: "ky-ska-b" }));
+    }
+    // The starting lines, each 2 m after a pre-start line (Rule 227.2 and 253.3): across the lane, or across both lanes.
+    for (const m of marks) {
+        for (const s of m.starts) {
+            const side = s.y >= 0 ? 1 : -1;
+            const lanes = s.lane === "both" ? [edges.inner, edges.outer] : s.lane === 0 ? [edges.inner, edges.between] : [edges.between, edges.outer];
+            const [y0, y1] = bandAt(f, s.x, lanes[0], lanes[1], side);
+            parts.shapes.push(line(`start-${m.race}-${String(s.lane)}`, "start-lines", s.x, y0, s.x, y1, { w: L, cls: "ky-ska-r" }));
+            // Behind the line: to the left on the finishing straight, to the right on the crossing straight.
+            const px = s.x + (side === 1 ? -fig.preStart : fig.preStart);
+            const [q0, q1] = bandAt(f, px, lanes[0], lanes[1], side);
+            parts.shapes.push(line(`pre-start-${m.race}-${String(s.lane)}`, "pre-start-lines", px, q0, px, q1, { w: 0.02, cls: "ky-ska-b" }));
+        }
+    }
+    void poly;
+    const out = R + fig.padding.thick;
+    return { parts, marks, box: { x0: -f / 2 - out, y0: -out, x1: f / 2 + out, y1: out } };
+}
+export { addParts, laneRadius, LONG_TRACK_RACES };

package/dist/skating/parts.d.ts

@@ -0,0 +1,43 @@
+import { path, line, poly } from "../fields.kit.ts";
+import type { Area, Shape } from "../fields.types.ts";
+/** What a part of a plan adds. */
+export interface Parts {
+    areas: Area[];
+    shapes: Shape[];
+}
+export declare const emptyParts: () => Parts;
+/** Add `more` to `into`. */
+export declare function addParts(into: Parts, more: Parts): void;
+/** A box in metres. */
+export interface MBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** A named part of the plan to crop to, in metres: one box, or one at each end (`left` and `right` as the rink is drawn wide). */
+export type MRange = MBox | {
+    left: MBox;
+    right: MBox;
+};
+/** A part of the plan to label (`landmarks`): where it is, in metres, and the side of the drawing its label stands on. */
+export interface MMark {
+    id: string;
+    x: number;
+    y: number;
+    side: "top" | "bottom";
+}
+export declare const grow: (b: MBox, m: number) => MBox;
+export declare const union: (boxes: readonly MBox[]) => MBox;
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin, drawn from the top left, clockwise as the eye sees it. */
+export declare const stadiumD: (s: number, r: number) => string;
+/** A point of a curve of the oval: `side` is the right-hand curve (centre at x = s/2, entered at the bottom) or the left-hand one (centre at x = -s/2, entered at the top); `t` the angle from the entrance. */
+export declare function curvePoint(s: number, side: "right" | "left", r: number, t: number): [number, number];
+/** The path of an arc of a curve of the oval from the angle `t0` to `t1`, in the way the skaters go (counter-clockwise as the eye sees it). */
+export declare function curveD(s: number, side: "right" | "left", r: number, t0: number, t1: number): string;
+/**
+ * The blocks of a curve as dots: a dashed path with a zero dash and round caps, so that a dot of the line's width stands every `near` metres for the first `nearLength` metres from the entrance and
+ * every `far` metres after, the cone at the entrance a dot of its own (Rule 226).
+ */
+export declare function blocksOf(id: string, s: number, side: "right" | "left", r: number, near: number, nearLength: number, far: number, width: number): Shape[];
+export { line, poly, path };

package/dist/skating/parts.js

@@ -0,0 +1,40 @@
+// What a part of a skating plan adds, as shapes and areas in painter's order, in metres, and the small functions the parts are made of. Nothing here draws SVG.
+import { path, line, poly } from "../fields.kit.js";
+import { num } from "../format.js";
+export const emptyParts = () => ({ areas: [], shapes: [] });
+/** Add `more` to `into`. */
+export function addParts(into, more) {
+    into.areas.push(...more.areas);
+    into.shapes.push(...more.shapes);
+}
+export const grow = (b, m) => ({ x0: b.x0 - m, y0: b.y0 - m, x1: b.x1 + m, y1: b.y1 + m });
+export const union = (boxes) => ({ x0: Math.min(...boxes.map((b) => b.x0)), y0: Math.min(...boxes.map((b) => b.y0)), x1: Math.max(...boxes.map((b) => b.x1)), y1: Math.max(...boxes.map((b) => b.y1)) });
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin, drawn from the top left, clockwise as the eye sees it. */
+export const stadiumD = (s, r) => `M${num(-s / 2)} ${num(-r)}H${num(s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(s / 2)} ${num(r)}H${num(-s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(-s / 2)} ${num(-r)}Z`;
+/** A point of a curve of the oval: `side` is the right-hand curve (centre at x = s/2, entered at the bottom) or the left-hand one (centre at x = -s/2, entered at the top); `t` the angle from the entrance. */
+export function curvePoint(s, side, r, t) {
+    return side === "right" ? [s / 2 + r * Math.sin(t), r * Math.cos(t)] : [-s / 2 - r * Math.sin(t), -r * Math.cos(t)];
+}
+/** The path of an arc of a curve of the oval from the angle `t0` to `t1`, in the way the skaters go (counter-clockwise as the eye sees it). */
+export function curveD(s, side, r, t0, t1) {
+    const [x0, y0] = curvePoint(s, side, r, t0);
+    const [x1, y1] = curvePoint(s, side, r, t1);
+    return `M${num(x0)} ${num(y0)}A${num(r)} ${num(r)} 0 ${t1 - t0 > Math.PI ? 1 : 0} 0 ${num(x1)} ${num(y1)}`;
+}
+/**
+ * The blocks of a curve as dots: a dashed path with a zero dash and round caps, so that a dot of the line's width stands every `near` metres for the first `nearLength` metres from the entrance and
+ * every `far` metres after, the cone at the entrance a dot of its own (Rule 226).
+ */
+export function blocksOf(id, s, side, r, near, nearLength, far, width) {
+    const out = [];
+    const tNear = Math.min(Math.PI, nearLength / r);
+    out.push(path(`${id}-near`, "blocks", curveD(s, side, r, 0, tNear), { w: width, dash: [0, near], cls: "ky-ska-blocks", least: 0.4 }));
+    // The far part starts a step after the near one stops, so that no block stands twice.
+    const start = tNear + far / r;
+    if (start < Math.PI + 1e-9)
+        out.push(path(`${id}-far`, "blocks", curveD(s, side, r, start, Math.PI), { w: width, dash: [0, far], cls: "ky-ska-blocks", least: 0.4 }));
+    const [cx, cy] = curvePoint(s, side, r, 0);
+    out.push({ kind: "dot", id: `${id}-cone`, feature: "cones", cx, cy, r: width * 1.3, paint: "cone" });
+    return out;
+}
+export { line, poly, path };

package/dist/skating/plan.d.ts

@@ -0,0 +1,55 @@
+import type { Area, Shape } from "../fields.types.ts";
+import { ISU_FIGURE_RINK, ISU_LONG_TRACK, ISU_SHORT_TRACK, type SkatingFigures, type SkatingLeague } from "../leagues/skating.ts";
+import type { SurfaceOptions } from "../types.ts";
+import { LONG_TRACK_RACES, SHORT_TRACK_RACES } from "./events.ts";
+import { type FigureRink } from "./figure.ts";
+import { type RaceMarks } from "./long.ts";
+import { type MBox, type MMark, type MRange } from "./parts.ts";
+import { type ShortOval } from "./short.ts";
+import { type LongOval } from "./track.ts";
+import type { ShortTrackRace, SkatingDiscipline, SkatingFurniture, SkatingRace, SkatingStyle } from "./types.ts";
+export type { MBox, MMark, MRange };
+/** What a skating drawing is. */
+export interface SkatingPlan {
+    sport: "skating";
+    league: string;
+    discipline: SkatingDiscipline;
+    figures: SkatingFigures;
+    /** The oval of the long track, or `undefined`. */
+    oval: LongOval | undefined;
+    /** The short track's oval and rink, or `undefined`. */
+    short: ShortOval | undefined;
+    /** The figure skating rink, or `undefined`. */
+    rink: FigureRink | undefined;
+    /** The playing surface: the ice out to the padding (the long track), the rink (the others). The data frame's own box. */
+    box: MBox;
+    /** Everything drawn: the box and what lies beyond it (the furniture of a figure skating rink). */
+    extent: MBox;
+    areas: Area[];
+    shapes: Shape[];
+    /** The long track's races marked, with where each starts. */
+    races: RaceMarks[];
+    /** The short track's races marked. */
+    shortRaces: ShortTrackRace[];
+    /** The number of tracks of the short track. */
+    tracks: 5 | 7;
+    furniture: SkatingFurniture[];
+    /** The width the ordinary line is painted at by the rules, and the width it is drawn at unless `exactLines` says otherwise. */
+    lineWidth: number;
+    drawnLine: number;
+    ranges: Readonly<Record<string, MRange>>;
+    marks: MMark[];
+    /** The race a close-up of a start (`range: "start"`) shows. */
+    start: SkatingRace;
+}
+/** The league a set of options asks for: the long track (the sport's own), the short track or the figure skating rink. */
+export declare function skatingLeague(o: Pick<SurfaceOptions, "sport" | "league">): SkatingLeague;
+/** The discipline of a set of options. */
+export declare const disciplineOf: (o: Pick<SurfaceOptions, "sport" | "league">) => SkatingDiscipline;
+/** The races the options ask to be marked, for a discipline. @throws Error for a name that is not a race, RangeError for one the discipline does not have. */
+export declare function racesOf(style: SkatingStyle | undefined, discipline: SkatingDiscipline): SkatingRace[];
+/** The furniture the options ask for. @throws Error for a name that is not furniture. */
+export declare function furnitureOf(style: SkatingStyle | undefined): SkatingFurniture[];
+/** The skating plan the options ask for. */
+export declare function skatingPlan(o: Pick<SurfaceOptions, "sport" | "league" | "skating" | "range" | "detail">): SkatingPlan;
+export { LONG_TRACK_RACES, SHORT_TRACK_RACES, ISU_FIGURE_RINK, ISU_LONG_TRACK, ISU_SHORT_TRACK };