@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

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 };

package/dist/skating/plan.js

@@ -0,0 +1,197 @@
+import { ISU_FIGURE_RINK, ISU_LONG_TRACK, ISU_SHORT_TRACK, SKATING_LEAGUES } from "../leagues/skating.js";
+import { chooseLeague } from "../leagues.js";
+import { LONG_TRACK_RACE_IDS, LONG_TRACK_RACES, RACE_IDS, SHORT_TRACK_RACE_IDS, SHORT_TRACK_RACES, raceById } from "./events.js";
+import { figureParts, FURNITURE, furnitureBoxes } from "./figure.js";
+import { longParts, LONG_DEFAULTS, iceRadius, markRace } from "./long.js";
+import { grow, union } from "./parts.js";
+import { shortOval, shortParts, trackLines } from "./short.js";
+import { longOval, laneEdges, outerEdge } from "./track.js";
+const isSkatingLeague = (l) => typeof l === "object" && l !== null && l.family === "skating";
+/** The league a set of options asks for: the long track (the sport's own), the short track or the figure skating rink. */
+export function skatingLeague(o) {
+    const { league } = chooseLeague(o);
+    return isSkatingLeague(league) ? league : SKATING_LEAGUES[0];
+}
+/** The discipline of a set of options. */
+export const disciplineOf = (o) => skatingLeague(o).dimensions.kind;
+/** A size within the range the rules give, or the drawn one. @throws RangeError for a size outside it. */
+function sizeIn(asked, span, label, rule) {
+    if (asked === undefined)
+        return span.drawn;
+    if (typeof asked !== "number" || !Number.isFinite(asked))
+        throw new TypeError(`${label} is a number of metres`);
+    if (asked < span.min || asked > span.max)
+        throw new RangeError(`${label} of ${asked} m is outside what ${rule} allows: ${span.min} m to ${span.max} m`);
+    return asked;
+}
+/** 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 function racesOf(style, discipline) {
+    const asked = style?.races;
+    if (asked === undefined)
+        return [];
+    const own = discipline === "long-track" ? LONG_TRACK_RACE_IDS : discipline === "short-track" ? SHORT_TRACK_RACE_IDS : [];
+    if (asked === "all")
+        return [...own];
+    if (!Array.isArray(asked))
+        throw new TypeError('skating.races is "all" or a list of races');
+    for (const r of asked)
+        if (raceById(r) === undefined)
+            throw new Error(`Unknown race "${String(r)}": use one of ${RACE_IDS.join(", ")}`);
+    for (const r of asked)
+        if (!own.includes(r))
+            throw new RangeError(`The ${discipline} rink does not mark the ${String(r)}: use ${own.length === 0 ? "none: a figure skating rink has no races" : `one of ${own.join(", ")}`}`);
+    return own.filter((r) => asked.includes(r));
+}
+/** The furniture the options ask for. @throws Error for a name that is not furniture. */
+export function furnitureOf(style) {
+    const asked = style?.furniture;
+    if (asked === undefined || asked === true)
+        return [...FURNITURE];
+    if (asked === false)
+        return [];
+    if (!Array.isArray(asked))
+        throw new TypeError("skating.furniture is true, false or a list of judges, referee, technical-panel and kiss-and-cry");
+    for (const f of asked)
+        if (!FURNITURE.includes(f))
+            throw new Error(`Unknown furniture "${String(f)}": use one of ${FURNITURE.join(", ")}`);
+    return FURNITURE.filter((f) => asked.includes(f));
+}
+/** The width a line is drawn at unless the drawing is at true widths: a little under two thousandths of the surface, so that a lane line stays in sight in a drawing that holds the whole track. */
+const drawn = (box) => Math.max(0.1, Math.round((box.x1 - box.x0) * 0.0018 * 100) / 100);
+const flag = (v, def, label) => {
+    if (v === undefined)
+        return def;
+    if (typeof v !== "boolean")
+        throw new TypeError(`${label} is true or false`);
+    return v;
+};
+/** The skating plan the options ask for. */
+export function skatingPlan(o) {
+    const league = skatingLeague(o);
+    const style = o.skating;
+    const discipline = league.dimensions.kind;
+    const base = { sport: "skating", league: league.id, discipline, figures: league.dimensions };
+    const given = racesOf(style, discipline);
+    const start = style?.start ?? "500m";
+    // A close-up of a start marks the start's race, whether or not the options name it.
+    const named = typeof o.range === "string" ? o.range : typeof o.range === "object" && o.range !== null && "name" in o.range ? o.range.name : undefined;
+    const own = discipline === "long-track" ? LONG_TRACK_RACE_IDS : discipline === "short-track" ? SHORT_TRACK_RACE_IDS : [];
+    const asked = named === "start" && own.includes(start) && !given.includes(start) ? [...given, start] : given;
+    if (style?.start !== undefined && raceById(style.start) === undefined)
+        throw new Error(`Unknown race "${String(style.start)}": use one of ${RACE_IDS.join(", ")}`);
+    const blocks = flag(style?.blocks, LONG_DEFAULTS.blocks, "skating.blocks");
+    const padding = flag(style?.padding, LONG_DEFAULTS.padding, "skating.padding");
+    if (discipline === "long-track") {
+        const fig = league.dimensions;
+        if (style?.infield !== undefined && style.infield !== "floor" && style.infield !== "ice")
+            throw new Error('skating.infield is "floor" or "ice"');
+        const oval = longOval(style?.innerRadius, style?.laneWidth, fig);
+        const { parts, marks: races, box } = longParts(oval, { fig, warmUp: flag(style?.warmUp, LONG_DEFAULTS.warmUp, "skating.warmUp"), infield: style?.infield ?? LONG_DEFAULTS.infield, blocks, coaches: flag(style?.coaches, LONG_DEFAULTS.coaches, "skating.coaches"), padding, races: asked });
+        const plan = { ...base, oval, short: undefined, rink: undefined, box, extent: box, areas: parts.areas, shapes: parts.shapes, races, shortRaces: [], tracks: 5, furniture: [], lineWidth: fig.line, drawnLine: drawn(box), ranges: {}, marks: [], start };
+        return { ...plan, ranges: longRanges(plan), marks: longMarks(plan) };
+    }
+    if (discipline === "short-track") {
+        const fig = league.dimensions;
+        const tracks = style?.tracks ?? 5;
+        if (tracks !== 5 && tracks !== 7)
+            throw new RangeError("skating.tracks is 5 or 7");
+        const length = style?.rink?.length ?? fig.rink.length;
+        const width = style?.rink?.width ?? fig.rink.width;
+        if (typeof length !== "number" || length < fig.rink.length || length > 70)
+            throw new RangeError(`The rink's length of ${String(length)} m is outside what Rule 280 allows: at least ${fig.rink.length} m (and, for this drawing, at most 70 m)`);
+        if (typeof width !== "number" || width < fig.rink.width || width > 40)
+            throw new RangeError(`The rink's width of ${String(width)} m is outside what Rule 280 allows: at least ${fig.rink.width} m (and, for this drawing, at most 40 m)`);
+        const oval = shortOval(length, width, fig);
+        const { parts, box } = shortParts(oval, { fig, tracks, blocks, padding, races: asked, corner: 8.5 });
+        const plan = { ...base, oval: undefined, short: oval, rink: { length, width }, box, extent: box, areas: parts.areas, shapes: parts.shapes, races: [], shortRaces: asked, tracks, furniture: [], lineWidth: fig.line, drawnLine: drawn(box), ranges: {}, marks: [], start };
+        return { ...plan, ranges: shortRanges(plan), marks: shortMarks(plan) };
+    }
+    const fig = league.dimensions;
+    const length = sizeIn(style?.rink?.length, fig.length, "The rink's length", "Rule 342.1");
+    const width = sizeIn(style?.rink?.width, fig.width, "The rink's width", "Rule 342.1");
+    const rink = { length, width };
+    const furniture = furnitureOf(style);
+    const { parts, box, marks } = figureParts(rink, { fig, furniture });
+    const boards = { x0: -length / 2, y0: -width / 2, x1: length / 2, y1: width / 2 };
+    const extra = furniture.length === 0 ? [] : furniture.flatMap((k) => furnitureBoxes(rink, fig)[k]);
+    const plan = { ...base, oval: undefined, short: undefined, rink, box: boards, extent: union([box, ...extra.map((b) => grow(b, 0.3))]), areas: parts.areas, shapes: parts.shapes, races: [], shortRaces: [], tracks: 5, furniture, lineWidth: 0.05, drawnLine: drawn(box), ranges: {}, marks: [...marks, { id: "ice", x: 0, y: -width / 4, side: "top" }, { id: "boards", x: -length / 4, y: -width / 2, side: "top" }], start };
+    return { ...plan, ranges: figureRanges(plan) };
+}
+/** The ranges of the long track. */
+function longRanges(plan) {
+    const o = plan.oval;
+    const f = o.straight;
+    const edges = laneEdges(o, 4);
+    const out = outerEdge(o);
+    const R = iceRadius(o);
+    const r = {};
+    r["home-straight"] = { x0: -f / 2, y0: edges.inner - 2, x1: f / 2, y1: out + 2 };
+    r["crossing-straight"] = { x0: -f / 2, y0: -out - 2, x1: f / 2, y1: -edges.inner + 2 };
+    r["first-bend"] = { x0: f / 2, y0: -R, x1: f / 2 + R, y1: R };
+    r["second-bend"] = { x0: -f / 2 - R, y0: -R, x1: -f / 2, y1: R };
+    r.finish = { x0: -f / 2 + 100 - 18, y0: edges.inner - 2, x1: -f / 2 + 100 + 12, y1: out + 2 };
+    r.infield = { x0: -f / 2 - edges.warmUp, y0: -edges.warmUp, x1: f / 2 + edges.warmUp, y1: edges.warmUp };
+    const place = LONG_TRACK_RACE_IDS.includes(plan.start) ? markRace(o, plan.start) : undefined;
+    if (place !== undefined) {
+        const xs = place.starts.map((s) => s.x);
+        const ys = place.starts.map((s) => s.y);
+        r.start = { x0: Math.min(...xs) - 14, y0: Math.min(...ys, ...ys.map((y) => y)) - 6, x1: Math.max(...xs) + 14, y1: Math.max(...ys) + 6 };
+    }
+    else
+        r.start = { x0: -f / 2 - 14, y0: edges.inner - 6, x1: -f / 2 + 14, y1: out + 2 };
+    return r;
+}
+function longMarks(plan) {
+    const o = plan.oval;
+    const f = o.straight;
+    const edges = laneEdges(o, 4);
+    return [
+        { id: "finish-line", x: -f / 2 + 100, y: edges.outer, side: "bottom" },
+        { id: "inner-lane", x: -f / 4, y: (edges.inner + edges.between) / 2, side: "bottom" },
+        { id: "outer-lane", x: f / 4, y: (edges.between + edges.outer) / 2, side: "bottom" },
+        { id: "warm-up-lane", x: -f / 4, y: -(edges.warmUp + edges.inner) / 2, side: "top" },
+        { id: "crossing-straight", x: 0, y: -edges.outer, side: "top" },
+        { id: "padding", x: f / 4, y: -iceRadius(o), side: "top" },
+        { id: "infield", x: 0, y: 0, side: "top" },
+    ];
+}
+/** The ranges of the short track. */
+function shortRanges(plan) {
+    const o = plan.short;
+    const S = o.straight;
+    const W = o.width / 2;
+    const r = {};
+    r["home-straight"] = { x0: -S / 2 - 3, y0: o.blocks - 2, x1: S / 2 + 3, y1: W };
+    r["crossing-straight"] = { x0: -S / 2 - 3, y0: -W, x1: S / 2 + 3, y1: -o.blocks + 2 };
+    r["first-bend"] = { x0: S / 2, y0: -W, x1: S / 2 + o.radius + 3, y1: W };
+    r["second-bend"] = { x0: -S / 2 - o.radius - 3, y0: -W, x1: -S / 2, y1: W };
+    r.finish = { x0: -10, y0: o.blocks - 4, x1: 10, y1: W };
+    const lines = trackLines(plan.tracks);
+    r.start = { x0: Math.min(...lines) - 8, y0: -W, x1: Math.max(...lines) + 8, y1: -o.blocks + 4 };
+    r.infield = { x0: -S / 2 - o.blocks, y0: -o.blocks, x1: S / 2 + o.blocks, y1: o.blocks };
+    return r;
+}
+function shortMarks(plan) {
+    const o = plan.short;
+    const S = o.straight;
+    return [
+        { id: "finish-line", x: 0, y: o.width / 2, side: "bottom" },
+        { id: "blocks", x: S / 2 + o.blocks * 0.7071, y: -o.blocks * 0.7071, side: "top" },
+        { id: "track-line", x: -S / 4, y: o.radius, side: "bottom" },
+        { id: "start-lines", x: 0, y: -o.width / 2, side: "top" },
+        { id: "infield", x: 0, y: 0, side: "top" },
+    ];
+}
+/** The ranges of the figure skating rink. */
+function figureRanges(plan) {
+    const r = plan.rink;
+    const L = r.length / 2;
+    const W = r.width / 2;
+    const out = { half: { left: { x0: -L, y0: -W, x1: 0, y1: W }, right: { x0: 0, y0: -W, x1: L, y1: W } } };
+    const boxes = furnitureBoxes(r);
+    const judges = plan.furniture.includes("judges") ? union([...boxes.judges, ...(plan.furniture.includes("referee") ? boxes.referee : []), ...(plan.furniture.includes("technical-panel") ? boxes["technical-panel"] : [])].map((b) => grow(b, 1.5))) : { x0: -8, y0: W - 4, x1: 8, y1: W + 3 };
+    out.judges = { ...judges, y0: Math.min(judges.y0, W - 3) };
+    out["kiss-and-cry"] = grow(plan.furniture.includes("kiss-and-cry") ? boxes["kiss-and-cry"][0] : { x0: -L + 3, y0: W + 0.6, x1: -L + 6.5, y1: W + 2.2 }, 4);
+    return out;
+}
+export { LONG_TRACK_RACES, SHORT_TRACK_RACES, ISU_FIGURE_RINK, ISU_LONG_TRACK, ISU_SHORT_TRACK };

package/dist/skating/short.d.ts

@@ -0,0 +1,47 @@
+import type { Shape } from "../fields.types.ts";
+import { type ShortTrackFigures } from "../leagues/skating.ts";
+import { type MBox, type Parts } from "./parts.ts";
+import type { ShortTrackRace } from "./types.ts";
+/** The oval of the standard track. */
+export interface ShortOval {
+    straight: number;
+    radius: number;
+    /** The radius of the blocks, 0.5 m inside the line of the track. */
+    blocks: number;
+    lap: number;
+    /** The rink: its length and width. */
+    length: number;
+    width: number;
+}
+/** The oval for a rink. */
+export declare function shortOval(length?: number, width?: number, fig?: ShortTrackFigures): ShortOval;
+/** The pose of a skater `v` metres along a lap that begins at the left end of the finishing straight (the bottom one), `out` metres outside the line of the track: the skaters go counter-clockwise. */
+export declare function shortPose(o: ShortOval, v: number, out?: number): {
+    x: number;
+    y: number;
+    heading: number;
+};
+/** Where each race starts: the half-lap races (500 m and 1500 m) on the starting lines of the straight opposite the finishing line, the others on the finishing line (the diagram's laps: 4 1/2, 9, 13 1/2, 18, 27 and 45). */
+export declare const startsOnOppositeStraight: (race: ShortTrackRace) => boolean;
+/** The x of the starting line of each of the tracks, from the one at the left: a track moved `shift` along the straight starts 2 x shift on from the standard track's line (the diagram). */
+export declare function trackLines(tracks: 5 | 7, fig?: ShortTrackFigures): number[];
+/** The starting positions of the 500 m and the 1000 m: five dots every 1.3 m, from 50 cm out from the inner side of the track (Rule 280.2c), on the line at `x` and the side `side` (-1 the top, 1 the bottom). */
+export declare function startingPositions(o: ShortOval, x: number, side: 1 | -1, fig?: ShortTrackFigures): {
+    x: number;
+    y: number;
+}[];
+export interface ShortOptions {
+    fig: ShortTrackFigures;
+    tracks: 5 | 7;
+    blocks: boolean;
+    padding: boolean;
+    races: readonly ShortTrackRace[];
+    /** The corner radius of the rink: ours. */
+    corner: number;
+}
+/** The parts of the short track. */
+export declare function shortParts(o: ShortOval, opt: ShortOptions): {
+    parts: Parts;
+    box: MBox;
+};
+export type { Shape };

package/dist/skating/short.js

@@ -0,0 +1,89 @@
+// The short track: the rink, the padding, the oval of 111.12 m with its seven blocks in each curve, the finishing line, the starting lines of the tracks laid out beside the standard one, and the starting
+// positions of the 500 m and the 1000 m. Every figure is the ISU's (Special Regulations and Technical Rules Short Track Speed Skating, Rule 280 and its diagram), in metres. Nothing here draws SVG.
+import { line } from "../fields.kit.js";
+import { ISU_SHORT_TRACK } from "../leagues/skating.js";
+import { addParts, curvePoint, emptyParts, stadiumD } from "./parts.js";
+/** The oval for a rink. */
+export function shortOval(length = ISU_SHORT_TRACK.rink.length, width = ISU_SHORT_TRACK.rink.width, fig = ISU_SHORT_TRACK) {
+    return { straight: fig.straight, radius: fig.radius, blocks: fig.blocks, lap: 2 * fig.straight + 2 * Math.PI * fig.radius, length, width };
+}
+/** The pose of a skater `v` metres along a lap that begins at the left end of the finishing straight (the bottom one), `out` metres outside the line of the track: the skaters go counter-clockwise. */
+export function shortPose(o, v, out = 0) {
+    const S = o.straight;
+    const r = o.radius + out;
+    const L = 2 * S + 2 * Math.PI * o.radius;
+    let s = ((v % L) + L) % L;
+    if (s < S)
+        return { x: -S / 2 + s, y: r, heading: 0 };
+    s -= S;
+    const half = Math.PI * o.radius;
+    if (s < half) {
+        const t = s / o.radius;
+        const [x, y] = curvePoint(S, "right", r, t);
+        return { x, y, heading: -t };
+    }
+    s -= half;
+    if (s < S)
+        return { x: S / 2 - s, y: -r, heading: Math.PI };
+    s -= S;
+    const t = s / o.radius;
+    const [x, y] = curvePoint(S, "left", r, t);
+    return { x, y, heading: Math.PI - t };
+}
+/** Where each race starts: the half-lap races (500 m and 1500 m) on the starting lines of the straight opposite the finishing line, the others on the finishing line (the diagram's laps: 4 1/2, 9, 13 1/2, 18, 27 and 45). */
+export const startsOnOppositeStraight = (race) => race === "500m" || race === "1500m";
+/** The x of the starting line of each of the tracks, from the one at the left: a track moved `shift` along the straight starts 2 x shift on from the standard track's line (the diagram). */
+export function trackLines(tracks, fig = ISU_SHORT_TRACK) {
+    const t = tracks === 5 ? fig.tracks.five : fig.tracks.seven;
+    return Array.from({ length: tracks }, (_, i) => (i - (tracks - 1) / 2) * t.lines);
+}
+/** The starting positions of the 500 m and the 1000 m: five dots every 1.3 m, from 50 cm out from the inner side of the track (Rule 280.2c), on the line at `x` and the side `side` (-1 the top, 1 the bottom). */
+export function startingPositions(o, x, side, fig = ISU_SHORT_TRACK) {
+    return Array.from({ length: fig.dots.count }, (_, i) => ({ x, y: side * (o.blocks + fig.dots.from + i * fig.dots.step) }));
+}
+/** The parts of the short track. */
+export function shortParts(o, opt) {
+    const { fig } = opt;
+    const parts = emptyParts();
+    const S = o.straight;
+    const W = o.width / 2;
+    const Lh = o.length / 2;
+    const roundD = (hx, hy, r) => `M${-hx + r} ${-hy}H${hx - r}A${r} ${r} 0 0 1 ${hx} ${-hy + r}V${hy - r}A${r} ${r} 0 0 1 ${hx - r} ${hy}H${-hx + r}A${r} ${r} 0 0 1 ${-hx} ${hy - r}V${-hy + r}A${r} ${r} 0 0 1 ${-hx + r} ${-hy}Z`;
+    const rd = (n) => Math.round(n * 100) / 100;
+    parts.areas.push({ id: "ice", feature: "ice", cls: "ky-ska-ice", d: roundD(rd(Lh), rd(W), opt.corner) });
+    if (opt.padding)
+        parts.areas.push({ id: "padding", feature: "padding", cls: "ky-ska-pad", d: `${roundD(rd(Lh + 0.5), rd(W + 0.5), opt.corner + 0.5)}${roundD(rd(Lh), rd(W), opt.corner)}`, evenodd: true });
+    // The inner surface of the track, when it is coloured: inside the blocks by the finishing line's extra 1.5 m (Rule 280.2d and the diagram).
+    parts.areas.push({ id: "inner", feature: "infield", cls: "ky-ska-warm", d: stadiumD(S, o.blocks - fig.inner) });
+    // The line of the standard track, 111.12 m round, and the line between the last block of a curve and the first of the next (Rule 280.1g).
+    parts.shapes.push({ kind: "path", id: "track-line", feature: "track-line", d: stadiumD(S, o.radius), w: 0.02, cls: "ky-ska-b" });
+    for (const side of [-1, 1])
+        parts.shapes.push(line(`straight-line-${side}`, "track-line", -S / 2, side * o.blocks, S / 2, side * o.blocks, { w: 0.02, cls: "ky-ska-k" }));
+    // The blocks: seven in each curve (Rule 280.4), the first and the last at the ends of the straights and the apex in the middle, 30 degrees apart.
+    if (opt.blocks) {
+        for (const side of ["right", "left"]) {
+            for (let k = 0; k < fig.blocksPerCurve; k += 1) {
+                const [cx, cy] = curvePoint(S, side, o.blocks, (k * Math.PI) / (fig.blocksPerCurve - 1));
+                parts.shapes.push({ kind: "dot", id: `block-${side}-${k}`, feature: "blocks", cx, cy, r: 0.12, paint: k === 0 || k === 3 ? "cone" : "block" });
+            }
+        }
+    }
+    // The finishing line, from the barrier across the width of the straight and 1.5 m more (Rule 280.2b), 2 cm wide.
+    parts.shapes.push(line("finish-line", "finish-line", 0, W, 0, o.blocks - fig.finishExtra, { w: fig.line, cls: "ky-ska-r" }));
+    // The starting lines of the half-lap races, one for each track, from the barrier across the width of the straight (Rule 280.2b).
+    const lines = trackLines(opt.tracks, fig);
+    const wanted = opt.races.some(startsOnOppositeStraight);
+    if (wanted)
+        lines.forEach((x, i) => parts.shapes.push(line(`start-line-${i + 1}`, "start-lines", x, -W, x, -o.blocks, { w: fig.line, cls: "ky-ska-r" })));
+    // The starting positions of the 500 m (on the standard track's line) and of the 1000 m (at the finishing line): five dots.
+    const dotsFor = (x, side, id) => {
+        for (const [i, p] of startingPositions(o, x, side, fig).entries())
+            parts.shapes.push({ kind: "dot", id: `${id}-${i + 1}`, feature: "start-positions", cx: p.x, cy: p.y, r: 0.1, paint: "block" });
+    };
+    if (opt.races.includes("500m"))
+        dotsFor(0, -1, "position-500m");
+    if (opt.races.includes("1000m"))
+        dotsFor(0, 1, "position-1000m");
+    void addParts;
+    return { parts, box: { x0: -Lh - 0.5, y0: -W - 0.5, x1: Lh + 0.5, y1: W + 0.5 } };
+}

package/dist/skating/track.d.ts

@@ -0,0 +1,66 @@
+import { type LongTrackFigures } from "../leagues/skating.ts";
+/** The lane of a skater on the finishing straight: the inner or the outer (the one on the left, nearer the infield). */
+export type Lane = 0 | 1;
+/** The shape of a long track, from the radius of the inner edge, the width of the outer lane and the lap. */
+export interface LongOval {
+    /** The radius of the inner edge of the inner lane (a in the table). */
+    a: number;
+    /** The widths of the inner lane and of the outer lane. */
+    w1: number;
+    w2: number;
+    /** The radii of the lines each lane is measured on (d and e in the table): 0.5 m outside the inner edge of the lane. */
+    d: number;
+    e: number;
+    /** The length of each straight, from the end of one curve to the beginning of the next (f in the table). */
+    straight: number;
+    /** The crossing: from the inner lane's line at one end of the straight to the outer lane's at the other. */
+    crossing: number;
+    lap: number;
+}
+/**
+ * The track for an inner radius `a` and an outer lane `w2` wide: the straight is the one that makes a lap 400 m, f + sqrt(f^2 + w1^2) + pi (d + e) = lap, where f is the straight skated twice a lap (once
+ * on the finishing straight and once crossing). For a = 25 m, 25.5 m and 26 m with lanes of 4 m this is the table's 113.57 m, 112.00 m and 110.43 m.
+ * @throws RangeError for a radius or a lane outside what Rule 203 allows.
+ */
+export declare function longOval(a?: number, w2?: number, fig?: LongTrackFigures): LongOval;
+/** The radius of the line a lane is measured on: 0 inner, 1 outer. */
+export declare const laneRadius: (o: LongOval, lane: Lane) => number;
+/** The radius of the edges of the lanes, from the inner edge of the warm-up lane out to the outer edge of the outer lane: the warm-up lane's inner edge, the inner edge, the line between the lanes, the outer edge. */
+export declare const laneEdges: (o: LongOval, warmUp: number) => {
+    warmUp: number;
+    inner: number;
+    between: number;
+    outer: number;
+};
+/** The radius of the outer edge of the outer lane. */
+export declare const outerEdge: (o: LongOval) => number;
+/** Where a skater is: a point of the track, the heading (0 is to the right, growing clockwise as the eye sees it), the part of the lap and how far across the lanes (0 on the inner line, 1 on the outer). */
+export interface Pose {
+    x: number;
+    y: number;
+    heading: number;
+    part: "finishing-straight" | "first-curve" | "crossing" | "second-curve";
+    /** The lap's number, from the lap the coordinate zero begins. */
+    lap: number;
+    /** 0 on the inner lane's line, 1 on the outer's, between on the crossing. */
+    across: number;
+}
+/**
+ * The pose `v` metres along the skater's own way, `v` measured from the beginning of the finishing straight (its left end, x = -f/2) of the lap the skater starts in, the lap 0. `lane` is the skater's
+ * lane there; it alternates every lap (Rule 254.5a). In a lap the skater skates the finishing straight and the first curve in the lap's lane, the crossing from it to the other lane, and the second
+ * curve in the other. With `noChange` the crossing of the lap 0 keeps the lane, as the first straight of the 1000 m and the 1500 m does (Rule 254.5b): the lap 0 has one lane, and the laps alternate on.
+ */
+export declare function pose(o: LongOval, lane: Lane, v: number, noChange?: boolean): Pose;
+/** The coordinate of the finishing line on the lap 0's finishing straight, from the straight's beginning: the 400 m mark is 100 m on (Rule 227.2 and the layout plan: h = f - 100). */
+export declare const finishAt: (o: LongOval, line: "400m" | "1000m") => number;
+/** The x of a coordinate on a straight of the lap 0 (the finishing straight), or `undefined` where it is not on it. */
+export declare const xOfFinishing: (o: LongOval, u: number) => number;
+/**
+ * Where a skater in lane `lane` starts a race of `distance` metres that finishes at `finish` metres along the finishing straight (`finishAt`): back from the finishing line along the skater's own way.
+ * `noChange` says the race's first straight keeps its lane (the 1000 m and the 1500 m, Rule 254.5b). Returns the skater's coordinate `v0` at the start, inside the lap it starts in, and the pose there; a
+ * skater who has skated `s` metres is at `pose(o, lane, v0 + s, noChange)`.
+ */
+export declare function startOf(o: LongOval, lane: Lane, distance: number, finish: number, noChange?: boolean): {
+    v0: number;
+    pose: Pose;
+};

package/dist/skating/track.js

@@ -0,0 +1,94 @@
+// The geometry of the standard 400 m speed skating track as the ISU's Special Regulations and Technical Rules Speed Skating lay it out (Rules 203, 226, 227 and 254 and "H. Track": the layout plan and the
+// measurements of standard 400 m speed skating tracks), in metres. The origin is the middle of the track, x along the straights (positive to the right as the track is drawn wide), y down the page. The
+// skaters go counter-clockwise (Rule 254.1): to the right along the finishing straight at the bottom, round the right-hand curve, to the left along the crossing straight at the top. A skater changes lanes
+// once a lap, on the crossing straight (Rule 254.5a), so that a lap is a straight, an inner curve, a straight, an outer curve and the crossing, 400 m on the line measured 0.5 m outside each lane's inner
+// edge (Rule 227.1). Nothing here draws.
+import { ISU_LONG_TRACK } from "../leagues/skating.js";
+/**
+ * The track for an inner radius `a` and an outer lane `w2` wide: the straight is the one that makes a lap 400 m, f + sqrt(f^2 + w1^2) + pi (d + e) = lap, where f is the straight skated twice a lap (once
+ * on the finishing straight and once crossing). For a = 25 m, 25.5 m and 26 m with lanes of 4 m this is the table's 113.57 m, 112.00 m and 110.43 m.
+ * @throws RangeError for a radius or a lane outside what Rule 203 allows.
+ */
+export function longOval(a = ISU_LONG_TRACK.innerRadius.drawn, w2 = ISU_LONG_TRACK.outerLane.drawn, fig = ISU_LONG_TRACK) {
+    if (typeof a !== "number" || !Number.isFinite(a) || a < fig.innerRadius.min || a > fig.innerRadius.max)
+        throw new RangeError(`The inner radius of ${String(a)} m is outside what Rule 203 allows: ${fig.innerRadius.min} m to ${fig.innerRadius.max} m`);
+    if (typeof w2 !== "number" || !Number.isFinite(w2) || w2 < fig.outerLane.min || w2 > fig.outerLane.max)
+        throw new RangeError(`The outer lane of ${String(w2)} m is outside what Rule 203 allows: ${fig.outerLane.min} m to ${fig.outerLane.max} m`);
+    const w1 = fig.innerLane;
+    const d = a + fig.measure;
+    const e = a + w1 + fig.measure;
+    const need = fig.lap - Math.PI * (d + e);
+    // f + sqrt(f^2 + w1^2) rises with f: bisect.
+    let lo = 1;
+    let hi = fig.lap;
+    for (let i = 0; i < 80; i += 1) {
+        const mid = (lo + hi) / 2;
+        if (mid + Math.hypot(mid, w1) < need)
+            lo = mid;
+        else
+            hi = mid;
+    }
+    const f = (lo + hi) / 2;
+    return { a, w1, w2, d, e, straight: f, crossing: Math.hypot(f, w1), lap: fig.lap };
+}
+/** The radius of the line a lane is measured on: 0 inner, 1 outer. */
+export const laneRadius = (o, lane) => (lane === 0 ? o.d : o.e);
+/** The radius of the edges of the lanes, from the inner edge of the warm-up lane out to the outer edge of the outer lane: the warm-up lane's inner edge, the inner edge, the line between the lanes, the outer edge. */
+export const laneEdges = (o, warmUp) => ({ warmUp: o.a - warmUp, inner: o.a, between: o.a + o.w1, outer: o.a + o.w1 + o.w2 });
+/** The radius of the outer edge of the outer lane. */
+export const outerEdge = (o) => o.a + o.w1 + o.w2;
+const mod2 = (n) => (((n % 2) + 2) % 2);
+/**
+ * The pose `v` metres along the skater's own way, `v` measured from the beginning of the finishing straight (its left end, x = -f/2) of the lap the skater starts in, the lap 0. `lane` is the skater's
+ * lane there; it alternates every lap (Rule 254.5a). In a lap the skater skates the finishing straight and the first curve in the lap's lane, the crossing from it to the other lane, and the second
+ * curve in the other. With `noChange` the crossing of the lap 0 keeps the lane, as the first straight of the 1000 m and the 1500 m does (Rule 254.5b): the lap 0 has one lane, and the laps alternate on.
+ */
+export function pose(o, lane, v, noChange = false) {
+    const f = o.straight;
+    const laneOfLap = (j) => (noChange ? (j <= 0 ? lane : mod2(lane + j - 1)) : mod2(lane + j));
+    const first = laneRadius(o, lane);
+    // The lap 0 of a noChange race is two straights and two curves in one lane; every other lap is the standard 400 m.
+    const L0 = noChange ? 2 * f + 2 * Math.PI * first : o.lap;
+    const lapNo = v < L0 ? 0 : 1 + Math.floor((v - L0) / o.lap);
+    let s = lapNo === 0 ? v : v - L0 - (lapNo - 1) * o.lap;
+    const laneIn = laneOfLap(lapNo);
+    const laneOut = laneOfLap(lapNo + 1);
+    const rIn = laneRadius(o, laneIn);
+    const rOut = laneRadius(o, laneOut);
+    const across = (r) => (r === o.d ? 0 : 1);
+    if (s < f)
+        return { x: -f / 2 + s, y: rIn, heading: 0, part: "finishing-straight", lap: lapNo, across: across(rIn) };
+    s -= f;
+    if (s < Math.PI * rIn) {
+        const t = s / rIn;
+        return { x: f / 2 + rIn * Math.sin(t), y: rIn * Math.cos(t), heading: -t, part: "first-curve", lap: lapNo, across: across(rIn) };
+    }
+    s -= Math.PI * rIn;
+    const cross = rIn === rOut ? f : o.crossing;
+    if (s < cross) {
+        const t = s / cross;
+        return { x: f / 2 - f * t, y: -(rIn + (rOut - rIn) * t), heading: Math.PI + Math.atan2(rIn - rOut, f) * -1, part: "crossing", lap: lapNo, across: across(rIn) + (across(rOut) - across(rIn)) * t };
+    }
+    s -= cross;
+    const t = Math.min(Math.PI, s / rOut);
+    return { x: -f / 2 - rOut * Math.sin(t), y: -rOut * Math.cos(t), heading: Math.PI - t, part: "second-curve", lap: lapNo, across: across(rOut) };
+}
+/** The coordinate of the finishing line on the lap 0's finishing straight, from the straight's beginning: the 400 m mark is 100 m on (Rule 227.2 and the layout plan: h = f - 100). */
+export const finishAt = (o, line) => (line === "400m" ? 100 : o.straight / 2);
+/** The x of a coordinate on a straight of the lap 0 (the finishing straight), or `undefined` where it is not on it. */
+export const xOfFinishing = (o, u) => -o.straight / 2 + u;
+/**
+ * Where a skater in lane `lane` starts a race of `distance` metres that finishes at `finish` metres along the finishing straight (`finishAt`): back from the finishing line along the skater's own way.
+ * `noChange` says the race's first straight keeps its lane (the 1000 m and the 1500 m, Rule 254.5b). Returns the skater's coordinate `v0` at the start, inside the lap it starts in, and the pose there; a
+ * skater who has skated `s` metres is at `pose(o, lane, v0 + s, noChange)`.
+ */
+export function startOf(o, lane, distance, finish, noChange = false) {
+    const L0 = noChange ? 2 * o.straight + 2 * Math.PI * laneRadius(o, lane) : o.lap;
+    // The finishing line is on the finishing straight of the lap n, which begins at T(n); the start is `distance` before it.
+    const T = (n) => (n === 0 ? 0 : L0 + o.lap * (n - 1));
+    let n = 0;
+    while (T(n) + finish - distance < 0)
+        n += 1;
+    const v0 = T(n) + finish - distance;
+    return { v0, pose: pose(o, lane, v0, noChange) };
+}

package/dist/skating/types.d.ts

@@ -0,0 +1,57 @@
+/** The disciplines a drawing can be of: the standard 400 m speed skating track, the short track oval or the figure skating rink. `league` says it too: `isu-long-track`, `isu-short-track`, `isu-figure`. */
+export type SkatingDiscipline = "long-track" | "short-track" | "figure";
+/** The races of the long track whose lines are marked: the distances, the mass start and the two team races. A race is named by its distance, in kebab case. */
+export type LongTrackRace = "500m" | "1000m" | "1500m" | "3000m" | "5000m" | "10000m" | "mass-start" | "team-pursuit" | "team-sprint";
+/** The races of the short track whose lines are marked. */
+export type ShortTrackRace = "500m" | "1000m" | "1500m" | "3000m" | "3000m-relay" | "5000m-relay" | "2000m-mixed-relay";
+/** Every race a drawing can mark. */
+export type SkatingRace = LongTrackRace | ShortTrackRace;
+/** The things that stand at the rink of a figure skating competition: the judges and the referee at the rinkboard, the technical panel, and the kiss and cry. */
+export type SkatingFurniture = "judges" | "referee" | "technical-panel" | "kiss-and-cry";
+/** What lies inside the long track: the ice of the warm-up lane carried on to the infield, or the floor of the arena. */
+export type SkatingInfield = "floor" | "ice";
+/**
+ * What a skating drawing takes beyond a surface. Every part is optional: the standard 400 m track with an inner radius of 25 m, two lanes of 4 m, the warm-up lane, the blocks and the padding is drawn
+ * without any, and so are the short track's standard oval with its five tracks and the figure skating rink of 60 m by 30 m.
+ */
+export interface SkatingStyle {
+    /** Long track: the radius of the inner edge of the inner lane, 25 m to 26 m (25 m by default). The straight follows, so that a lap is 400 m. */
+    innerRadius?: number;
+    /** Long track: the width of the outer lane, 4 m or more (4 m by default). */
+    laneWidth?: number;
+    /** Long track: the warm-up lane inside the competition lanes. On by default. */
+    warmUp?: boolean;
+    /** Long track: what lies inside the warm-up lane. `floor` by default. */
+    infield?: SkatingInfield;
+    /** Long and short track: the blocks of the curves. On by default. */
+    blocks?: boolean;
+    /** Long track: the coaches' area on the crossing straight. On by default. */
+    coaches?: boolean;
+    /** The padding round the track. On by default. */
+    padding?: boolean;
+    /** The races whose starting and finishing lines are drawn: none by default, `all` or a list. The finishing line is always drawn. */
+    races?: "all" | readonly SkatingRace[];
+    /** The race of a close-up of a start (`range: "start"`): the 500 m by default. */
+    start?: SkatingRace;
+    /** Short track: the number of tracks laid out beside the standard one, 5 or 7 (5 by default). */
+    tracks?: 5 | 7;
+    /** Short track and figure skating: the size of the rink, within what the Rules allow. */
+    rink?: {
+        length?: number;
+        width?: number;
+    };
+    /** Figure skating: the furniture drawn: all by default, `false` for none or a list. */
+    furniture?: boolean | readonly SkatingFurniture[];
+}
+/** A race, as the package knows it. */
+export interface RaceInfo {
+    id: SkatingRace;
+    /** The distance in metres; the mass start's is its laps (16 laps of 400 m). */
+    distance: number;
+    /** The words of its name, in English, Japanese and French. */
+    name: {
+        en: string;
+        ja: string;
+        fr: string;
+    };
+}

package/dist/skating/types.js

@@ -0,0 +1,3 @@
+// The types of the ice skating surfaces: the three disciplines, the races whose start and finish lines a drawing can mark, the furniture of a figure skating rink and the options that say what is drawn.
+// Plain data only.
+export {};

package/dist/skating-entry.d.ts

@@ -0,0 +1,17 @@
+export { skatingPairs, skatingGrid, skatingResults, skatingReplay, figureElements, formatTime, distanceSkated } from "./charts.skating.ts";
+export type { DrawTotals, ElementTotals, FigureElementsOptions, SkatingElement, SkatingEntry, SkatingPair, SkatingRaceOptions, SkatingReplay, SkatingReplayOptions, SkatingResult, SkatingResultsTotals, SkatingRunner, SkatingStarter } from "./charts.skating.ts";
+export { ELEMENT_KINDS, ELEMENT_NAMES, LONG_TRACK_RACES, LONG_TRACK_RACE_IDS, RACES, RACE_IDS, SHORT_TRACK_RACES, SHORT_TRACK_RACE_IDS, raceById } from "./skating/events.ts";
+export type { ElementKind } from "./skating/events.ts";
+export { disciplineOf, furnitureOf, racesOf, skatingLeague, skatingPlan } from "./skating/plan.ts";
+export type { MBox, MMark, MRange, SkatingPlan } from "./skating/plan.ts";
+export { finishAt, laneEdges, laneRadius, longOval, outerEdge, pose, startOf } from "./skating/track.ts";
+export type { Lane, LongOval, Pose } from "./skating/track.ts";
+export { markRace } from "./skating/long.ts";
+export type { RaceMarks, StartPlacement } from "./skating/long.ts";
+export { shortOval, shortPose, startingPositions, startsOnOppositeStraight, trackLines } from "./skating/short.ts";
+export type { ShortOval } from "./skating/short.ts";
+export { FURNITURE, JUDGES, furnitureBoxes } from "./skating/figure.ts";
+export { ISU_FIGURE_RINK, ISU_LONG_TRACK, ISU_LONG_TRACK_TABLE, ISU_SHORT_TRACK, SKATING_LEAGUES } from "./leagues/skating.ts";
+export type { FigureRinkFigures, LongTrackFigures, ShortTrackFigures, SkatingFigures, SkatingLeague } from "./leagues/skating.ts";
+export { KYOGIJO_SKATING_STYLE } from "./skating.style.ts";
+export type { LongTrackRace, RaceInfo, ShortTrackRace, SkatingDiscipline, SkatingFurniture, SkatingInfield, SkatingRace, SkatingStyle } from "./skating/types.ts";