@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.0

package/dist/budo/karate.js

@@ -0,0 +1,80 @@
+import { rectArea } from "./kit.js";
+import { emptyParts, grow, union } from "./parts.js";
+import { lay, seams, tatamiAreas, tint } from "./tatami.js";
+/** The mat of a karate area: 1 m by 1 m, a WKF-approved mat's size (ours: the rules do not give it). */
+export const KARATE_MAT = { length: 1, width: 1 };
+/** The plan of the karate area the options ask for. */
+export function karateParts(o) {
+    const { fig, across, down } = o;
+    const a = fig.area;
+    const gap = fig.between;
+    const width = across * a + (across - 1) * gap + 2 * fig.safety;
+    const height = down * a + (down - 1) * gap + 2 * fig.safety;
+    const mats = { x0: 0, y0: 0, x1: width, y1: height };
+    const areas = [];
+    for (let j = 0; j < down; j += 1)
+        for (let i = 0; i < across; i += 1)
+            areas.push({ x0: fig.safety + i * (a + gap), y0: fig.safety + j * (a + gap), x1: fig.safety + i * (a + gap) + a, y1: fig.safety + j * (a + gap) + a });
+    const inner = areas.map((b) => grow(b, -fig.band));
+    const parts = emptyParts();
+    const zones = [...inner.map((b) => ({ box: b, tone: 1 })), ...(fig.band > 0 ? areas.map((b) => ({ box: b, tone: 3 })) : [])];
+    const pieces = tint(lay(mats, KARATE_MAT, "x", false), zones, 2, KARATE_MAT);
+    parts.areas.push(...tatamiAreas("mats", pieces, { 1: "ky-bud-t1", 2: "ky-bud-t2", 3: "ky-bud-t3" }, { 1: "competition-area", 2: "safety-area", 3: "boundary-band" }));
+    if (o.seams)
+        parts.shapes.push(...seams("mats", pieces, 0.02));
+    // Kumite: the two mats turned over, red side up, 1 m from the centre, where the athletes stand, front and centre, facing each other.
+    if (fig.startMats !== null) {
+        const s = fig.startMats.size;
+        areas.forEach((b, k) => {
+            const cx = (b.x0 + b.x1) / 2;
+            const cy = (b.y0 + b.y1) / 2;
+            for (const [side, dx] of [["left", -1], ["right", 1]]) {
+                const near = cx + dx * fig.startMats.fromCentre;
+                const far = cx + dx * (fig.startMats.fromCentre + s);
+                parts.areas.push(rectArea(`start-mat-${k + 1}-${side}`, "start-mats", "ky-bud-t3", { x0: Math.min(near, far), y0: cy - s / 2, x1: Math.max(near, far), y1: cy + s / 2 }));
+            }
+        });
+    }
+    const desks = [];
+    const seats = [];
+    if (o.officials) {
+        for (const b of areas.filter((_, k) => k < across)) {
+            const cx = (b.x0 + b.x1) / 2;
+            desks.push({ x0: cx - 1.5, y0: -2.3, x1: cx + 1.5, y1: -1.5 });
+        }
+        desks.forEach((d, k) => parts.areas.push(rectArea(`table-${k + 1}`, "officials", "ky-bud-desk", d)));
+    }
+    // The judges sit about 1.5 m off the corners, in the safety area; the referee stands at the middle, 2 m inside the boundary on the near side.
+    if (o.judges) {
+        areas.forEach((b, k) => {
+            const d = fig.judges / Math.SQRT2;
+            const at = [[b.x0 - d, b.y0 - d], [b.x1 + d, b.y0 - d], [b.x0 - d, b.y1 + d], [b.x1 + d, b.y1 + d]];
+            at.forEach(([x, y], n) => {
+                const seat = { x0: x - 0.3, y0: y - 0.3, x1: x + 0.3, y1: y + 0.3 };
+                seats.push(seat);
+                parts.areas.push(rectArea(`judge-${k + 1}-${n + 1}`, "judges", "ky-bud-seat", seat));
+            });
+            const cx = (b.x0 + b.x1) / 2;
+            const ref = { x0: cx - 0.3, y0: b.y1 - fig.referee - 0.3, x1: cx + 0.3, y1: b.y1 - fig.referee + 0.3 };
+            seats.push(ref);
+            parts.areas.push({ id: `referee-${k + 1}`, feature: "referee", cls: "ky-bud-seat", ellipse: [cx, b.y1 - fig.referee, 0.3, 0.3] });
+        });
+    }
+    const first = areas[0];
+    const fx = (first.x0 + first.x1) / 2;
+    const marks = [];
+    marks.push({ id: "competition-area", x: fx, y: first.y0 + a * 0.28, side: "top" });
+    marks.push({ id: "safety-area", x: fx, y: fig.safety / 2, side: "top" });
+    if (fig.band > 0)
+        marks.push({ id: "boundary-band", x: first.x0 + a * 0.22, y: first.y1 - fig.band / 2, side: "bottom" });
+    if (fig.startMats !== null)
+        marks.push({ id: "start-mat", x: fx + fig.startMats.fromCentre + fig.startMats.size / 2, y: (first.y0 + first.y1) / 2, side: "bottom" });
+    if (o.judges) {
+        marks.push({ id: "referee", x: fx, y: first.y1 - fig.referee, side: "bottom" });
+        marks.push({ id: "judge", x: first.x1 + fig.judges / Math.SQRT2, y: first.y1 + fig.judges / Math.SQRT2, side: "bottom" });
+    }
+    if (across > 1)
+        marks.push({ id: "between-areas", x: first.x1 + gap / 2, y: (first.y0 + first.y1) / 2, side: "bottom" });
+    const extent = union([mats, ...desks.map((d) => grow(d, 0.3)), ...seats.map((d) => grow(d, 0.2))]);
+    return { parts, mats, extent, areas, inner, gap, pieces, marks };
+}

package/dist/budo/kendo.d.ts

@@ -0,0 +1,18 @@
+import type { KendoFigures } from "../leagues/budo.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+/** What a kendo plan is. */
+export interface KendoLayout {
+    parts: Parts;
+    /** The floor inside the boundary lines, the shiai-jo itself. */
+    floor: MBox;
+    extent: MBox;
+    side: number;
+    /** The centre, and the two kaishi-sen as lines. */
+    centre: [number, number];
+    starts: [MBox, MBox];
+    marks: MMark[];
+}
+/** The side the options ask for, held to 9 m to 11 m. */
+export declare const kendoSide: (asked: number | undefined, fig: KendoFigures) => number;
+/** The plan of the shiai-jo the options ask for. */
+export declare function kendoParts(fig: KendoFigures, side: number, seams: boolean): KendoLayout;

package/dist/budo/kendo.js

@@ -0,0 +1,44 @@
+import { box, line } from "../fields.kit.js";
+import { rectArea, within } from "./kit.js";
+import { emptyParts, grow } from "./parts.js";
+/** The width of a floorboard: 18 cm (ours; a sprung floor's boards are laid lengthwise). */
+const BOARD = 0.18;
+/** The side the options ask for, held to 9 m to 11 m. */
+export const kendoSide = (asked, fig) => (asked === undefined ? fig.side.drawn : within(asked, fig.side.min, fig.side.max, "The shiai-jo", "Article 2 of the FIK's Regulations"));
+/** The plan of the shiai-jo the options ask for. */
+export function kendoParts(fig, side, seams) {
+    const floor = { x0: 0, y0: 0, x1: side, y1: side };
+    const parts = emptyParts();
+    const w = fig.lineWidth.min;
+    const outer = grow(floor, fig.outside);
+    parts.areas.push(rectArea("outside", "outside", "ky-bud-free", outer));
+    parts.areas.push(rectArea("floor", "floor", "ky-bud-floor", floor));
+    const shapes = [];
+    // The boards run the length of the floor.
+    if (seams)
+        for (let y = BOARD; y < side - 1e-6; y += BOARD)
+            shapes.push(line("board", "boards", 0, y, side, y, { w: 0.008, cls: "ky-bud-seam", least: 0 }));
+    // The boundary lines, white, 5 cm wide and inside the 9 m to 11 m, so that the floor's size includes them.
+    shapes.push(box("boundary", "boundary-lines", w / 2, w / 2, side - w / 2, side - w / 2, { w, cls: "ky-bud-line" }));
+    const cx = side / 2;
+    const cy = side / 2;
+    const c = fig.cross.drawn / 2;
+    shapes.push(line("cross-a", "cross", cx - c, cy - c, cx + c, cy + c, { w, cls: "ky-bud-line" }), line("cross-b", "cross", cx - c, cy + c, cx + c, cy - c, { w, cls: "ky-bud-line" }));
+    const l = fig.startLine.length / 2;
+    const left = { x0: cx - fig.startLine.fromCentre - w / 2, y0: cy - l, x1: cx - fig.startLine.fromCentre + w / 2, y1: cy + l };
+    const right = { x0: cx + fig.startLine.fromCentre - w / 2, y0: cy - l, x1: cx + fig.startLine.fromCentre + w / 2, y1: cy + l };
+    for (const [k, b] of [left, right].entries())
+        shapes.push(line(`start-${k === 0 ? "left" : "right"}`, "start-lines", (b.x0 + b.x1) / 2, b.y0, (b.x0 + b.x1) / 2, b.y1, { w, cls: "ky-bud-line" }));
+    // The outer boundary, 1.5 m outside, as a dashed line (Figure 1).
+    shapes.push(box("outer-boundary", "outer-boundary", -fig.outside, -fig.outside, side + fig.outside, side + fig.outside, { w: 0.03, dash: [0.25, 0.2], cls: "ky-bud-ink", least: 0.03 }));
+    parts.shapes.push(...shapes);
+    const marks = [
+        { id: "boundary-line", x: side * 0.2, y: w / 2, side: "top" },
+        { id: "centre-cross", x: cx, y: cy - 0.5, side: "top" },
+        { id: "kaishi-sen", x: cx + fig.startLine.fromCentre, y: cy + l, side: "bottom" },
+        { id: "outer-boundary", x: side * 0.8, y: side + fig.outside, side: "bottom" },
+        { id: "shiai-jo", x: side * 0.5, y: side * 0.85, side: "bottom" },
+        { id: "floorboard", x: side * 0.2, y: side * 0.35, side: "top" },
+    ];
+    return { parts, floor, extent: grow(outer, 0.15), side, centre: [cx, cy], starts: [left, right], marks };
+}

package/dist/budo/kimarite.d.ts

@@ -0,0 +1,19 @@
+/** The groups of the kimarite. */
+export type KimariteGroup = "kihon" | "kake" | "nage" | "hineri" | "sori" | "tokushu" | "hi";
+/** One kimarite. */
+export interface Kimarite {
+    key: string;
+    ja: string;
+    en: string;
+    group: KimariteGroup;
+}
+/** The kimarite, in the order of the groups: basic, leg tripping, throwing, twisting down, backwards body drop, special, and the non-techniques with the two other results. */
+export declare const KIMARITE: readonly Kimarite[];
+/** How many techniques there are, as the Association counts them. */
+export declare const KIMARITE_COUNT: number;
+/** The five non-techniques and the two other results. */
+export declare const KIMARITE_OTHERS: Kimarite[];
+/** The kimarite a key, a Japanese name or an English gloss names, or `undefined`. */
+export declare function kimariteOf(query: string): Kimarite | undefined;
+/** The name of a kimarite in a language: its Japanese name, or its key in capitals-first romanisation; text that is no kimarite is kept as it was written. */
+export declare function kimariteName(query: string, language: "en" | "ja"): string;

package/dist/budo/kimarite.js

@@ -0,0 +1,33 @@
+// The kimarite (決まり手), the winning techniques of sumo, as the Japan Sumo Association recognises them: 82 techniques in seven groups, the five non-techniques (a win because the opponent lost by his own
+// step or touch) and the two other results, a win by default and by foul. Each has its key (the romanisation, lower case, without macrons), its name in Japanese and its English gloss. The list
+// is read from English Wikipedia's article "Kimarite" (CC BY-SA 4.0) on 2026-10-14, which says the JSA has recognised 82 since 2001; no text of it is copied, only the names. Nothing here draws.
+const group = (g, rows) => rows.map(([key, ja, en]) => ({ key, ja, en, group: g }));
+/** The kimarite, in the order of the groups: basic, leg tripping, throwing, twisting down, backwards body drop, special, and the non-techniques with the two other results. */
+export const KIMARITE = Object.freeze([
+    ...group("kihon", [["abisetaoshi", "浴びせ倒し", "backward force down"], ["oshidashi", "押し出し", "frontal push out"], ["oshitaoshi", "押し倒し", "frontal push down"], ["tsukidashi", "突き出し", "frontal thrust out"], ["tsukitaoshi", "突き倒し", "frontal thrust down"], ["yorikiri", "寄り切り", "frontal force out"], ["yoritaoshi", "寄り倒し", "frontal crush out"]]),
+    ...group("kake", [["ashitori", "足取り", "leg pick"], ["chongake", "ちょん掛け", "pulling heel hook"], ["kawazugake", "河津掛け", "hooking backward counter throw"], ["kekaeshi", "蹴返し", "minor inner foot sweep"], ["ketaguri", "蹴手繰り", "pulling inside ankle sweep"], ["kirikaeshi", "切り返し", "twisting backward knee trip"], ["komatasukui", "小股掬い", "over thigh scooping body drop"], ["kozumatori", "小褄取り", "ankle pick"], ["mitokorozeme", "三所攻め", "triple attack force out"], ["nimaigeri", "二枚蹴り", "ankle kicking twist down"], ["omata", "大股", "thigh scooping body drop"], ["sotogake", "外掛け", "outside leg trip"], ["sotokomata", "外小股", "over thigh scooping body drop"], ["susoharai", "裾払い", "rear foot sweep"], ["susotori", "裾取り", "toe pick"], ["tsumatori", "褄取り", "rear ankle pick"], ["uchigake", "内掛け", "inside leg trip"], ["watashikomi", "渡し込み", "thigh grabbing push down"]]),
+    ...group("nage", [["ipponzeoi", "一本背負い", "one-armed shoulder throw"], ["kakenage", "掛け投げ", "hooking inner thigh throw"], ["koshinage", "腰投げ", "hip throw"], ["kotenage", "小手投げ", "armlock throw"], ["kubinage", "首投げ", "headlock throw"], ["nichonage", "二丁投げ", "body drop throw"], ["shitatedashinage", "下手出し投げ", "pulling underarm throw"], ["shitatenage", "下手投げ", "underarm throw"], ["sukuinage", "掬い投げ", "beltless arm throw"], ["tsukaminage", "つかみ投げ", "lifting throw"], ["uwatedashinage", "上手出し投げ", "pulling overarm throw"], ["uwatenage", "上手投げ", "overarm throw"], ["yaguranage", "櫓投げ", "inner thigh throw"]]),
+    ...group("hineri", [["amiuchi", "網打ち", "the fisherman's throw"], ["gasshohineri", "合掌捻り", "clasped hand twist down"], ["harimanage", "波離間投げ", "backward belt throw"], ["kainahineri", "腕捻り", "two-handed arm twist down"], ["katasukashi", "肩透かし", "under-shoulder swing down"], ["kotehineri", "小手捻り", "arm locking twist down"], ["kubihineri", "首捻り", "head twisting throw"], ["makiotoshi", "巻き落とし", "twist down"], ["osakate", "大逆手", "backward twisting overarm throw"], ["sabaori", "鯖折り", "forward force down"], ["sakatottari", "逆とったり", "arm bar throw counter"], ["shitatehineri", "下手捻り", "twisting underarm throw"], ["sotomuso", "外無双", "outer thigh propping twist down"], ["tokkurinage", "徳利投げ", "two handed head twist down"], ["tottari", "とったり", "arm bar throw"], ["tsukiotoshi", "突き落とし", "thrust down"], ["uchimuso", "内無双", "inner thigh propping twist down"], ["uwatehineri", "上手捻り", "twisting overarm throw"], ["zubuneri", "ずぶねり", "head pivot throw"]]),
+    ...group("sori", [["izori", "居反り", "backwards body drop"], ["kakezori", "掛け反り", "hooking backwards body drop"], ["shumokuzori", "撞木反り", "bell hammer backwards body drop"], ["sototasukizori", "外たすき反り", "outer reverse backwards body drop"], ["tasukizori", "たすき反り", "reverse backwards body drop"], ["tsutaezori", "伝え反り", "underarm forward body drop"]]),
+    ...group("tokushu", [["hatakikomi", "叩き込み", "slap down"], ["hikiotoshi", "引き落とし", "hand pull down"], ["hikkake", "引っ掛け", "arm grabbing force out"], ["kimedashi", "極め出し", "arm barring force out"], ["kimetaoshi", "極め倒し", "arm barring force down"], ["okuridashi", "送り出し", "rear push out"], ["okurigake", "送り掛け", "rear leg trip"], ["okurihikiotoshi", "送り引き落とし", "rear pull down"], ["okurinage", "送り投げ", "rear throw down"], ["okuritaoshi", "送り倒し", "rear push down"], ["okuritsuridashi", "送り吊り出し", "rear lift out"], ["okuritsuriotoshi", "送り吊り落とし", "rear lifting body slam"], ["sokubiotoshi", "素首落とし", "head chop down"], ["tsuridashi", "吊り出し", "frontal lift out"], ["tsuriotoshi", "吊り落とし", "frontal lifting body slam"], ["ushiromotare", "後ろもたれ", "backward lean out"], ["utchari", "うっちゃり", "backward pivot throw"], ["waridashi", "割り出し", "upper-arm force out"], ["yobimodoshi", "呼び戻し", "pulling body slam"]]),
+    ...group("hi", [["fumidashi", "踏み出し", "rear step out"], ["isamiashi", "勇み足", "forward step out"], ["koshikudake", "腰砕け", "inadvertent collapse"], ["tsukihiza", "つきひざ", "knee touch down"], ["tsukite", "つき手", "hand touch down"], ["fusen", "不戦勝", "default (absence)"], ["hansoku", "反則勝ち", "foul"]]),
+]);
+/** How many techniques there are, as the Association counts them. */
+export const KIMARITE_COUNT = KIMARITE.filter((k) => k.group !== "hi").length;
+/** The five non-techniques and the two other results. */
+export const KIMARITE_OTHERS = KIMARITE.filter((k) => k.group === "hi");
+const plain = (s) => s.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9ぁ-んァ-ヶ一-龠]/g, "");
+/** The kimarite a key, a Japanese name or an English gloss names, or `undefined`. */
+export function kimariteOf(query) {
+    const q = plain(query);
+    if (q === "")
+        return undefined;
+    return KIMARITE.find((k) => k.key === q || plain(k.ja) === q || plain(k.en) === q);
+}
+/** The name of a kimarite in a language: its Japanese name, or its key in capitals-first romanisation; text that is no kimarite is kept as it was written. */
+export function kimariteName(query, language) {
+    const k = kimariteOf(query);
+    if (k === undefined)
+        return query.trim();
+    return language === "ja" ? k.ja : k.key.charAt(0).toUpperCase() + k.key.slice(1);
+}

package/dist/budo/kit.d.ts

@@ -0,0 +1,16 @@
+import type { Area, BarShape, Shape } from "../fields.types.ts";
+import type { MBox } from "./parts.ts";
+/** The path of a box. */
+export declare const boxD: (b: MBox) => string;
+/** A painted rectangle. */
+export declare const rectArea: (id: string, feature: string, cls: Area["cls"], b: MBox) => Area;
+/** A painted ellipse. */
+export declare const discArea: (id: string, feature: string, cls: Area["cls"], cx: number, cy: number, rx: number, ry?: number) => Area;
+/** A piece of tape: a filled rectangle in a colour of the budō marks. */
+export declare const tapeBar: (id: string, feature: string, cls: NonNullable<BarShape["cls"]>, b: MBox) => Shape;
+/** The path of a ring (a circle between two radii), filled by the even-odd rule. */
+export declare const annulusD: (cx: number, cy: number, r0: number, r1: number) => string;
+/** A value held between two bounds. */
+export declare const clamp: (v: number, lo: number, hi: number) => number;
+/** The number of a size option held to the range a rule allows. @throws TypeError for a value that is not a number, RangeError for one outside the range. */
+export declare function within(value: unknown, lo: number, hi: number, label: string, rule: string): number;

package/dist/budo/kit.js

@@ -0,0 +1,24 @@
+import { num } from "../format.js";
+/** The path of a box. */
+export const boxD = (b) => `M${num(b.x0)} ${num(b.y0)}H${num(b.x1)}V${num(b.y1)}H${num(b.x0)}Z`;
+/** A painted rectangle. */
+export const rectArea = (id, feature, cls, b) => ({ id, feature, cls, rect: [b.x0, b.y0, b.x1, b.y1] });
+/** A painted ellipse. */
+export const discArea = (id, feature, cls, cx, cy, rx, ry = rx) => ({ id, feature, cls, ellipse: [cx, cy, rx, ry] });
+/** A piece of tape: a filled rectangle in a colour of the budō marks. */
+export const tapeBar = (id, feature, cls, b) => ({ kind: "bar", id, feature, cls, x0: b.x0, y0: b.y0, x1: b.x1, y1: b.y1 });
+/** The path of a ring (a circle between two radii), filled by the even-odd rule. */
+export const annulusD = (cx, cy, r0, r1) => {
+    const c = (r) => `M${num(cx - r)} ${num(cy)}A${num(r)} ${num(r)} 0 1 0 ${num(cx + r)} ${num(cy)}A${num(r)} ${num(r)} 0 1 0 ${num(cx - r)} ${num(cy)}Z`;
+    return `${c(r1)}${r0 > 0 ? c(r0) : ""}`;
+};
+/** A value held between two bounds. */
+export const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** The number of a size option held to the range a rule allows. @throws TypeError for a value that is not a number, RangeError for one outside the range. */
+export function within(value, lo, hi, label, rule) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new TypeError(`${label} is a number of metres`);
+    if (value < lo - 1e-9 || value > hi + 1e-9)
+        throw new RangeError(`${label} of ${value} m is outside what ${rule} allows: ${lo} m to ${hi} m`);
+    return value;
+}

package/dist/budo/kyudo.d.ts

@@ -0,0 +1,28 @@
+import type { KyudoFigures } from "../leagues/budo.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+/** What a kyūdōjō plan is. */
+export interface KyudoLayout {
+    parts: Parts;
+    /** The whole range: the shajō, the yamichi and the azuchi. */
+    range: MBox;
+    extent: MBox;
+    /** The shajō's floor (with the judges' side), the yamichi, the azuchi's footprint. */
+    shajo: MBox;
+    yamichi: MBox;
+    azuchi: MBox;
+    /** The x of the shooting positions, of the honza and of the targets' faces, and the y of each shooter. */
+    shooting: number;
+    honza: number;
+    target: number;
+    lanes: number[];
+    shooters: number;
+    marks: MMark[];
+}
+/** The number of shooters the options ask for, 1 to 12. @throws RangeError for a number outside it. */
+export declare function shootersOf(asked: number | undefined, fig: KyudoFigures): number;
+/** The plan of the kyūdōjō the options ask for. */
+export declare function kyudoParts(fig: KyudoFigures, o: {
+    shooters: number;
+    targets: boolean;
+    roof: boolean;
+}): KyudoLayout;

package/dist/budo/kyudo.js

@@ -0,0 +1,66 @@
+import { box, dot, line } from "../fields.kit.js";
+import { discArea, rectArea } from "./kit.js";
+import { emptyParts, grow } from "./parts.js";
+/** The width of the path beside the yamichi, for fetching the arrows (ours). */
+const PATH = 1;
+/** The number of shooters the options ask for, 1 to 12. @throws RangeError for a number outside it. */
+export function shootersOf(asked, fig) {
+    if (asked === undefined)
+        return fig.count;
+    if (!Number.isInteger(asked) || asked < 1 || asked > 12)
+        throw new RangeError("budo.shooters is a whole number of 1 to 12");
+    return asked;
+}
+/** The plan of the kyūdōjō the options ask for. */
+export function kyudoParts(fig, o) {
+    const n = o.shooters;
+    const step = fig.step.drawn;
+    const h = fig.hall;
+    // The frontage is the shooters' line and the side room at each end: 12.6 m for five at 1.8 m, 10.8 m at 1.6 m with 2.2 m to the walls.
+    const frontage = (n - 1) * step + 2 * h.side;
+    const rearX = 0;
+    const frontX = h.rear + h.depth;
+    const shooting = frontX - h.front;
+    const honza = shooting - fig.honza;
+    const target = shooting + fig.distance;
+    const lanes = Array.from({ length: n }, (_, i) => h.side + i * step);
+    const parts = emptyParts();
+    const shajo = { x0: rearX, y0: 0, x1: frontX, y1: frontage + h.judges };
+    const azuchiW = (n - 1) * step + 2 * fig.azuchi.margin;
+    const cy = h.side + ((n - 1) * step) / 2;
+    const azuchi = { x0: target - 1, y0: cy - azuchiW / 2, x1: target + fig.azuchi.depth - 1, y1: cy + azuchiW / 2 };
+    const yamichi = { x0: frontX, y0: lanes[0] - fig.yamichi.margin, x1: azuchi.x0, y1: lanes[n - 1] + fig.yamichi.margin };
+    // The yamichi lies open to the sky; the path for the arrows runs beside it on the left as the archers face the targets (the north side).
+    parts.areas.push(rectArea("yamichi", "yamichi", "ky-bud-yamichi", yamichi));
+    parts.areas.push(rectArea("yatori-michi", "yatori-michi", "ky-bud-lane", { x0: yamichi.x0, y0: yamichi.y0 - PATH, x1: yamichi.x1, y1: yamichi.y0 }));
+    parts.areas.push(rectArea("shajo", "shajo", "ky-bud-floor", shajo));
+    parts.areas.push(rectArea("azuchi", "azuchi", "ky-bud-azuchi", azuchi));
+    parts.shapes.push(box("hall", "shajo", shajo.x0, shajo.y0, shajo.x1, shajo.y1, { w: 0.08, cls: "ky-bud-ink", least: 0.08 }));
+    // The judges' side: the officials' row at the back of the hall (the figure's dashed line) is not drawn; the judges' room beside the shooters is the floor's last 3.6 m.
+    parts.shapes.push(line("judges-line", "shajo", shajo.x0, frontage, shajo.x1, frontage, { w: 0.03, dash: [0.3, 0.25], cls: "ky-bud-ink", least: 0.03 }));
+    lanes.forEach((y, i) => {
+        parts.shapes.push(dot(`shooting-${i + 1}`, "shooting-positions", shooting, y, 0.1));
+        parts.shapes.push(dot(`honza-${i + 1}`, "honza", honza, y, 0.07));
+        if (o.targets)
+            parts.areas.push(discArea(`mato-${i + 1}`, "targets", "ky-bud-mato", target, y, fig.target.diameter / 2));
+    });
+    // The line of the shooting positions and of the honza, drawn faint; and the line of the targets' faces.
+    parts.shapes.push(line("shooting-line", "shooting-positions", shooting, 0.4, shooting, frontage - 0.4, { w: 0.03, dash: [0.2, 0.2], cls: "ky-bud-line", least: 0.03 }));
+    parts.shapes.push(line("honza-line", "honza", honza, 0.4, honza, frontage - 0.4, { w: 0.03, dash: [0.12, 0.3], cls: "ky-bud-line", least: 0.03 }));
+    if (o.roof) {
+        parts.shapes.push(box("roof-shajo", "roofs", rearX - 0.4, -0.4, frontX + 0.5, frontage + h.judges + 0.4, { w: 0.05, dash: [0.5, 0.35], cls: "ky-bud-ink", least: 0.05 }));
+        parts.shapes.push(box("roof-matoba", "roofs", azuchi.x0 - 2.2, azuchi.y0 - 0.5, azuchi.x1 + 0.4, azuchi.y1 + 0.5, { w: 0.05, dash: [0.5, 0.35], cls: "ky-bud-ink", least: 0.05 }));
+    }
+    const range = { x0: 0, y0: Math.min(0, yamichi.y0 - PATH, azuchi.y0), x1: azuchi.x1, y1: Math.max(shajo.y1, azuchi.y1) };
+    const marks = [
+        { id: "shajo", x: shajo.x0 + 1.5, y: 0.8, side: "top" },
+        { id: "shooting-position", x: shooting, y: lanes[0], side: "top" },
+        { id: "honza", x: honza, y: lanes[n - 1], side: "bottom" },
+        { id: "yamichi", x: (yamichi.x0 + yamichi.x1) / 2, y: yamichi.y1 - 0.4, side: "bottom" },
+        { id: "yatori-michi", x: yamichi.x0 + (yamichi.x1 - yamichi.x0) * 0.35, y: yamichi.y0 - PATH / 2, side: "top" },
+        { id: "azuchi", x: azuchi.x1 - 0.6, y: azuchi.y1 - 0.8, side: "bottom" },
+    ];
+    if (o.targets)
+        marks.push({ id: "mato", x: target, y: lanes[0], side: "top" });
+    return { parts, range, extent: grow(range, 0.6), shajo, yamichi, azuchi, shooting, honza, target, lanes, shooters: n, marks };
+}

package/dist/budo/looks.d.ts

@@ -0,0 +1,28 @@
+import type { BudoKind } from "./types.ts";
+/** What a look sets: the properties of the stylesheet its sport's surface is painted with. */
+export interface BudoLook {
+    /** The first tone of the mats (the contest area, the mats of a dojo), the second (the safety area, the other mats of a checker floor) and the third (a danger zone, a border: the sheet's `--ky-red`). */
+    surface: string;
+    alt: string;
+    red: string;
+    /** The ground round the surface, the free zone round the mats, and the floor of the hall: wood, the boards of a kendo floor, the walls. */
+    apron: string;
+    free: string;
+    floor: string;
+    boards: string;
+    /** The clay of a dohyō, the sand of its jano-me, the straw of its tawara. */
+    dirt?: string;
+    sand?: string;
+    straw?: string;
+}
+interface Pair {
+    light: BudoLook;
+    dark: BudoLook;
+}
+/** The looks of each sport: the names, the default first, and the colours. */
+export declare const BUDO_LOOKS: Readonly<Record<BudoKind, Readonly<Record<string, Pair>>>>;
+/** The names of a sport's looks, the default first. */
+export declare const lookNames: (sport: BudoKind) => string[];
+/** The look a name asks for, or the sport's first. @throws Error for a name the sport has no look of. */
+export declare function lookOf(sport: BudoKind, name: unknown): string;
+export {};

package/dist/budo/looks.js

@@ -0,0 +1,58 @@
+/** A colour darkened by a share, 0 to 1, towards black. */
+function dim(hex, k) {
+    const n = Number.parseInt(hex.slice(1), 16);
+    const c = [(n >> 16) & 255, (n >> 8) & 255, n & 255].map((v) => Math.round(v * (1 - k)));
+    return `#${c.map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+}
+/** A look made from its light colours: the dark one is the same hues dimmed. */
+function pair(light, k = 0.34) {
+    const dark = { ...light };
+    for (const key of Object.keys(light)) {
+        const v = light[key];
+        if (v !== undefined)
+            dark[key] = key === "apron" ? "#1c1e1d" : key === "free" ? dim(v, 0.5) : dim(v, k);
+    }
+    return { light, dark };
+}
+const FLOOR = "#c9a26a";
+const WALLS = "#7d756a";
+const COMMON = { apron: "#d6d3cb", free: "#e8e4d8", floor: FLOOR, boards: WALLS };
+const MATS = {
+    "yellow-red": pair({ ...COMMON, surface: "#f4c430", alt: "#c9343b", red: "#b32a2f" }),
+    "yellow-blue": pair({ ...COMMON, surface: "#f2c230", alt: "#2f6db3", red: "#b32a2f" }),
+    "blue-grey": pair({ ...COMMON, surface: "#3a74c2", alt: "#9aa4ad", red: "#b32a2f" }),
+    "green-beige": pair({ ...COMMON, surface: "#7da157", alt: "#d6c595", red: "#b32a2f" }),
+    "green-red": pair({ ...COMMON, surface: "#8bb561", alt: "#5a8a46", red: "#c0392b" }),
+    "black-red": pair({ ...COMMON, surface: "#2d2f33", alt: "#b8323a", red: "#b8323a" }),
+};
+/** The dojo's own two: pale yellow contest areas on green mats (the Kodokan's main dojo as it is now), and green mats of one tone with red-orange border mats (as it was). Ours, from the owner's photographs. */
+const DOJO_ONLY = {
+    "yellow-green": pair({ ...COMMON, surface: "#e8d98e", alt: "#5f9a52", red: "#c8462a" }),
+    "green-orange": pair({ ...COMMON, surface: "#6fa352", alt: "#69a04f", red: "#d4572a" }),
+};
+/** The looks of each sport: the names, the default first, and the colours. */
+export const BUDO_LOOKS = Object.freeze({
+    judo: MATS,
+    dojo: { "green-beige": MATS["green-beige"], "yellow-red": MATS["yellow-red"], "yellow-blue": MATS["yellow-blue"], "blue-grey": MATS["blue-grey"], "black-red": MATS["black-red"], "green-red": MATS["green-red"], ...DOJO_ONLY },
+    karate: {
+        "blue-red": pair({ ...COMMON, surface: "#2b66b9", alt: "#1f4a85", red: "#c43a3a" }),
+        "blue-black": pair({ ...COMMON, surface: "#2b66b9", alt: "#26282b", red: "#c43a3a" }),
+        "green-beige": pair({ ...COMMON, surface: "#7da157", alt: "#d6c595", red: "#c43a3a" }),
+    },
+    kendo: {
+        wood: pair({ ...COMMON, surface: "#c8955a", alt: "#b98650", red: "#b32a2f", floor: "#c8955a", free: "#e6dccb" }),
+        blond: pair({ ...COMMON, surface: "#e0bf8a", alt: "#d3b27c", red: "#b32a2f", floor: "#e0bf8a", free: "#ece4d3" }),
+    },
+    sumo: { clay: pair({ ...COMMON, surface: "#b0794a", alt: "#a06c40", red: "#b32a2f", dirt: "#b0794a", sand: "#e8dcc2", straw: "#c8a45c" }) },
+    kyudo: { wood: pair({ ...COMMON, surface: "#9db57d", alt: "#d8cfb0", red: "#b32a2f", floor: "#b98c58", dirt: "#c9ad7a" }) },
+});
+/** The names of a sport's looks, the default first. */
+export const lookNames = (sport) => Object.keys(BUDO_LOOKS[sport]);
+/** The look a name asks for, or the sport's first. @throws Error for a name the sport has no look of. */
+export function lookOf(sport, name) {
+    if (name === undefined)
+        return lookNames(sport)[0];
+    if (typeof name !== "string" || !Object.prototype.hasOwnProperty.call(BUDO_LOOKS[sport], name))
+        throw new Error(`Unknown look "${String(name)}" for "${sport}": use one of ${lookNames(sport).join(", ")}`);
+    return name;
+}

package/dist/budo/parts.d.ts

@@ -0,0 +1,32 @@
+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 surface 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;
+export declare const boxOf: (cx: number, cy: number, w: number, h: number) => MBox;
+export declare const shifted: (b: MBox, dx: number, dy: number) => MBox;

package/dist/budo/parts.js

@@ -0,0 +1,10 @@
+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)) });
+export const boxOf = (cx, cy, w, h) => ({ x0: cx - w / 2, y0: cy - h / 2, x1: cx + w / 2, y1: cy + h / 2 });
+export const shifted = (b, dx, dy) => ({ x0: b.x0 + dx, y0: b.y0 + dy, x1: b.x1 + dx, y1: b.y1 + dy });

package/dist/budo/plan.d.ts

@@ -0,0 +1,64 @@
+import type { Area, Shape } from "../fields.types.ts";
+import { type BudoFigures, type BudoLeague } from "../leagues/budo.ts";
+import type { SurfaceOptions } from "../types.ts";
+import { type DojoLayout } from "./dojo.ts";
+import { type JudoLayout } from "./judo.ts";
+import { type KarateLayout } from "./karate.ts";
+import { type KendoLayout } from "./kendo.ts";
+import { type KyudoLayout } from "./kyudo.ts";
+import { boxD } from "./kit.ts";
+import { type MBox, type MMark, type MRange } from "./parts.ts";
+import { type SumoLayout } from "./sumo.ts";
+import type { BudoKind } from "./types.ts";
+export type { MBox, MMark, MRange };
+/** The apothem of the Nippon Budokan's arena, an octagon 55 m across the flats (the Budokan's leaflet). */
+export declare const BUDOKAN_ARENA = 27.5;
+/** What a budō drawing is. */
+export interface BudoPlan {
+    sport: BudoKind;
+    league: string;
+    figures: BudoFigures;
+    /** The look (the colours of the mats and the floor). */
+    look: string;
+    /** The mats are drawn with the weave of rice straw. */
+    texture: boolean;
+    /** The playing surface: the mats of a competition area, the shiai-jo's floor, the dohyō's clay, the whole range of a kyūdōjō, a dojo's floor. The data frame's own box. */
+    box: MBox;
+    /** Everything drawn: the box and what lies beyond it (the free zone, the furniture). */
+    extent: MBox;
+    areas: Area[];
+    shapes: Shape[];
+    /** 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 arena floor under the surface, for the Nippon Budokan. */
+    hall: "budokan" | undefined;
+    /** The centre of the surface and the radius of the circle a pageant's emblem lies in, in metres. */
+    centre: {
+        x: number;
+        y: number;
+        r: number;
+    };
+    /** The layout of the sport: one of these is set. */
+    judo?: JudoLayout;
+    karate?: KarateLayout;
+    kendo?: KendoLayout;
+    sumo?: SumoLayout;
+    kyudo?: KyudoLayout;
+    dojo?: DojoLayout;
+}
+/** The sports of the budō family. */
+export declare const BUDO_SPORTS: readonly BudoKind[];
+/** True for a sport of the budō family. */
+export declare const isBudoSport: (sport: string) => sport is BudoKind;
+/** The league a set of options asks for: a rulebook's, else the sport's own. */
+export declare function budoLeague(o: Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo">): BudoLeague;
+/** The octagon of the Budokan's arena as a path, centred on (cx, cy). */
+export declare function octagonD(cx: number, cy: number, a: number): string;
+/** True when a point lies inside the Budokan's octagon about (cx, cy). */
+export declare const inOctagon: (cx: number, cy: number, a: number, x: number, y: number) => boolean;
+/** The budō plan the options ask for. */
+export declare function budoPlan(o: Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo" | "range" | "detail">): BudoPlan;
+export { boxD };