@johnmorrisdotca/kyogijo-stadiums 0.49.1 → 0.51.0

package/dist/circuits.draw.js

@@ -0,0 +1,265 @@
+import { pointAlong } from "./circuits.geo.js";
+import { circuitOf, circuitPlan, CIRCUIT_ATTRIBUTION } from "./circuits.js";
+import { KYOGIJO_CIRCUIT_STYLE } from "./circuits.style.js";
+import { CIRCUIT_WORDS } from "./circuits.words.js";
+import { metaMarkup, safeClass } from "./common.js";
+import { el, esc, hash, num } from "./format.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+import { fill } from "./strings.core.js";
+import { VERSION } from "./version.js";
+const path = (points, closed) => `M${points.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}${closed ? "Z" : ""}`;
+const right = ([dx, dy]) => [-dy, dx];
+const add = (a, b, k = 1) => [a[0] + b[0] * k, a[1] + b[1] * k];
+/** The metres of a length in the words' own way: one decimal of a kilometre. */
+const km = (metres, language) => (metres / 1000).toLocaleString(language === "ja" ? "ja-JP" : "en-US", { minimumFractionDigits: 3, maximumFractionDigits: 3 });
+/** The words of a circuit's drawing: its title and its description, sentence by sentence. */
+export function circuitText(plan, language, standing) {
+    const c = plan.circuit;
+    const w = CIRCUIT_WORDS[language];
+    const name = c.names[language];
+    const gap = language === "ja" ? "" : " ";
+    const parts = [
+        fill(w.lap, { name, km: km(c.length.value, language), measured: km(plan.measured, language) }),
+        c.direction.value === "counterclockwise" ? w.counterclockwise : w.clockwise,
+        fill(w.turns, { turns: c.corners.value }),
+        w.pit,
+        ...(plan.building === undefined ? [] : [w.building]),
+        ...(c.width.basis === "plausible" ? [fill(w.width, { width: c.width.value })] : []),
+        ...(standing === undefined || standing === "" ? [] : [standing]),
+        fill(w.credit, { credit: CIRCUIT_ATTRIBUTION }),
+    ];
+    return { title: fill(w.title, { name }), description: parts.join(gap) };
+}
+/** The badges of the turns' numbers: each beside the outside of its bend, then pushed apart where two would touch, in the same few steps every time. */
+function badgesOf(plan, r, k) {
+    const middle = [(plan.box.x0 + plan.box.x1) / 2, (plan.box.y0 + plan.box.y1) / 2];
+    const reach = plan.width / 2 + r + 4 * k;
+    const placed = plan.turns.map((t) => {
+        let normal = right(t.dir);
+        if (t.side === 1)
+            normal = right(t.dir);
+        else if (t.side === -1)
+            normal = [-normal[0], -normal[1]];
+        else if ((t.at[0] - middle[0]) * normal[0] + (t.at[1] - middle[1]) * normal[1] < 0)
+            normal = [-normal[0], -normal[1]];
+        return { n: t.n, at: add(t.at, normal, reach), r, from: t.at };
+    });
+    // Two badges that would touch are pushed apart along the line between them; a badge that would lie on the track is pushed off it.
+    for (let round = 0; round < 40; round += 1) {
+        let moved = false;
+        for (let i = 0; i < placed.length; i += 1) {
+            for (let j = i + 1; j < placed.length; j += 1) {
+                const [a, b] = [placed[i], placed[j]];
+                const dx = b.at[0] - a.at[0];
+                const dy = b.at[1] - a.at[1];
+                const d = Math.hypot(dx, dy);
+                const want = 2 * r + 2 * k;
+                if (d >= want)
+                    continue;
+                const [ux, uy] = d < 1e-6 ? [1, 0] : [dx / d, dy / d];
+                const push = (want - d) / 2 + 0.01;
+                a.at = [a.at[0] - ux * push, a.at[1] - uy * push];
+                b.at = [b.at[0] + ux * push, b.at[1] + uy * push];
+                moved = true;
+            }
+        }
+        for (const b of placed) {
+            for (let i = 0; i < plan.lap.length; i += 1) {
+                const p = plan.lap[i];
+                const q = plan.lap[(i + 1) % plan.lap.length];
+                const ex = q[0] - p[0];
+                const ey = q[1] - p[1];
+                const len2 = ex * ex + ey * ey || 1;
+                const t = Math.min(1, Math.max(0, ((b.at[0] - p[0]) * ex + (b.at[1] - p[1]) * ey) / len2));
+                const near = [p[0] + t * ex, p[1] + t * ey];
+                const d = Math.hypot(b.at[0] - near[0], b.at[1] - near[1]);
+                const want = plan.width / 2 + r + k;
+                if (d >= want || d < 1e-6)
+                    continue;
+                b.at = add(near, [(b.at[0] - near[0]) / d, (b.at[1] - near[1]) / d], want + 0.01);
+                moved = true;
+            }
+        }
+        if (!moved)
+            break;
+    }
+    return placed;
+}
+/** The finish line: two rows of squares across the track, black and white in turn, along the way the lap runs. */
+function chequer(at, dir, width) {
+    const cells = 6;
+    const s = width / cells;
+    const across = right(dir);
+    let out = "";
+    for (let row = 0; row < 2; row += 1) {
+        for (let i = 0; i < cells; i += 1) {
+            const o = add(add(at, across, -width / 2 + i * s), dir, (row - 1) * s);
+            const corners = [o, add(o, across, s), add(add(o, across, s), dir, s), add(o, dir, s)];
+            out += el("path", { class: (i + row) % 2 === 0 ? "ky-ci-check-a" : "ky-ci-check-b", d: path(corners, true) });
+        }
+    }
+    return el("g", { class: "ky-ci-finish" }, out);
+}
+/** The north arrow at `at`, pointing `north` degrees clockwise from the top of the page, `size` long, with an N drawn as strokes (no font). */
+function northArrow(at, north, size, label) {
+    const a = (north * Math.PI) / 180;
+    const u = [Math.sin(a), -Math.cos(a)];
+    const v = right(u);
+    const p = (along, side = 0) => {
+        const q = add(add(at, u, along * size), v, side * size);
+        return `${num(q[0])} ${num(q[1])}`;
+    };
+    const arrow = el("path", { class: "ky-ci-north", d: `M${p(-0.5)}L${p(0.5)}M${p(0.5)}L${p(0.18, 0.16)}L${p(0.18, -0.16)}Z`, "stroke-width": num(size * 0.06) });
+    // The N stands upright beside the arrow's tail, whichever way the arrow points.
+    const n = add(at, u, -0.5 * size - 0.32 * size);
+    const h = size * 0.16;
+    const letter = el("path", { class: "ky-ci-north-n", d: `M${num(n[0] - h * 0.75)} ${num(n[1] + h)}V${num(n[1] - h)}L${num(n[0] + h * 0.75)} ${num(n[1] + h)}V${num(n[1] - h)}`, "stroke-width": num(size * 0.055) });
+    return el("g", { class: "ky-ci-compass", "aria-label": label, role: "img" }, arrow + letter);
+}
+/** A scale bar of a round number of metres that is about a fifth of the drawing's width, at `at` (its left end), with its numbers. */
+function scaleBar(at, width, k, unit) {
+    const steps = [100, 200, 250, 500, 1000, 2000];
+    const metres = steps.reduce((best, s) => (Math.abs(s * FT - width / 5) < Math.abs(best * FT - width / 5) ? s : best), steps[0]);
+    const long = metres * FT;
+    const h = 5 * k;
+    const text = 15 * k;
+    let out = el("rect", { class: "ky-ci-scale-fill", x: at[0], y: at[1] - h, width: long / 2, height: h });
+    out += el("rect", { class: "ky-ci-scale", x: at[0], y: at[1] - h, width: long, height: h, "stroke-width": num(1.4 * k) });
+    for (const [x, label] of [[0, "0"], [long / 2, String(metres / 2)], [long, `${metres} ${unit}`]]) {
+        out += el("text", { class: "ky-ci-scale-text", x: at[0] + x, y: at[1] - h - 5 * k, "font-size": num(text), "text-anchor": x === 0 ? "start" : x === long ? "end" : "middle" }, esc(label));
+    }
+    return el("g", { class: "ky-ci-scalebar", "data-metres": metres }, out);
+}
+/** The arrows along the lap: a few, evenly round it, each pointing the way the lap runs. */
+function arrows(plan, k) {
+    const count = 8;
+    const total = plan.lap.reduce((sum, p, i) => sum + Math.hypot(plan.lap[(i + 1) % plan.lap.length][0] - p[0], plan.lap[(i + 1) % plan.lap.length][1] - p[1]), 0);
+    const size = Math.max(plan.width * 1.2, 15 * k);
+    let out = "";
+    for (let i = 0; i < count; i += 1) {
+        // Halfway between two of the evenly spaced places, so that none sits on the start.
+        const { at, dir } = pointAlong(plan.lap, plan.start.along + ((i + 0.5) * total) / count);
+        const side = right(dir);
+        const tip = add(at, dir, size * 0.6);
+        const back = add(at, dir, -size * 0.5);
+        out += el("path", { class: "ky-ci-arrow", d: path([tip, add(back, side, size * 0.45), add(at, dir, -size * 0.15), add(back, side, -size * 0.45)], true), "stroke-width": num(k * 0.8) });
+    }
+    return el("g", { class: "ky-ci-arrows" }, out);
+}
+/** A circuit's drawing and what was worked out to make it. */
+export function circuitDrawing(options) {
+    const circuit = circuitOf(options.circuit);
+    const language = options.language === "ja" ? "ja" : "en";
+    const words = CIRCUIT_WORDS[language];
+    const plan = circuitPlan(circuit);
+    const label = options.label !== false;
+    const showTurns = options.turns !== false;
+    const base = Math.max(plan.box.x1 - plan.box.x0, plan.box.y1 - plan.box.y0);
+    const k = base / 1000;
+    const pad = 46 * k;
+    const head = label ? 70 * k : 0;
+    const foot = 44 * k;
+    const viewBox = { x: plan.box.x0 - pad, y: plan.box.y0 - pad - head, w: plan.box.x1 - plan.box.x0 + 2 * pad, h: plan.box.y1 - plan.box.y0 + 2 * pad + head + foot };
+    const gid = safeClass(options.id).replace(/ /g, "-") || `ky-ci-${hash(JSON.stringify([options, VERSION]))}`;
+    const { title, description } = circuitText(plan, language);
+    const r = 13 * k;
+    const placed = badgesOf(plan, r, k);
+    let body = el("rect", { class: "ky-ci-ground", x: viewBox.x, y: viewBox.y, width: viewBox.w, height: viewBox.h });
+    body += el("path", { class: "ky-ci-area", d: path(plan.area, true), "stroke-width": num(1.2 * k) });
+    if (plan.building !== undefined)
+        body += el("path", { class: "ky-ci-building", d: path(plan.building.ring, true), "stroke-width": num(1.2 * k), "data-height": num(plan.building.height / FT) });
+    const lapD = path(plan.lap, true);
+    const pitD = path(plan.pitLane, false);
+    const edge = Math.max(plan.width * 0.14, 1.1 * k);
+    body += el("path", { class: "ky-ci-halo", d: lapD, "stroke-width": num(plan.width + 9 * k) });
+    body += el("path", { class: "ky-ci-edge ky-ci-pit-edge", d: pitD, "stroke-width": num(plan.pitWidth + 2 * edge) });
+    body += el("path", { class: "ky-ci-pit", d: pitD, "stroke-width": num(plan.pitWidth), "data-part": "pit-lane" });
+    body += el("path", { class: "ky-ci-edge", d: lapD, "stroke-width": num(plan.width + 2 * edge) });
+    body += el("path", { class: "ky-ci-track", d: lapD, "stroke-width": num(plan.width), "data-part": "lap" });
+    if (options.arrows !== false)
+        body += arrows(plan, k);
+    // The start line: one white line across the track; the finish: a chequered band across it.
+    const across = right(plan.start.dir);
+    const s0 = add(plan.start.at, across, -plan.width / 2);
+    const s1 = add(plan.start.at, across, plan.width / 2);
+    body += el("path", { class: "ky-ci-start", d: path([s0, s1], false), "stroke-width": num(Math.max(1.6 * FT, 1.2 * k)), "data-part": "start" });
+    body += chequer(plan.finish.at, plan.finish.dir, plan.width);
+    // The turns' numbers, each with a thin line to its bend.
+    let turns = "";
+    for (const b of showTurns ? placed : []) {
+        const toward = Math.hypot(b.at[0] - b.from[0], b.at[1] - b.from[1]);
+        const lead = toward < 1e-6 ? b.from : add(b.from, [(b.at[0] - b.from[0]) / toward, (b.at[1] - b.from[1]) / toward], plan.width / 2);
+        let inner = el("path", { class: "ky-ci-leader", d: path([lead, b.at], false), "stroke-width": num(1.1 * k) });
+        inner += el("circle", { class: "ky-ci-badge", cx: b.at[0], cy: b.at[1], r: b.r, "stroke-width": num(1.4 * k) });
+        inner += el("text", { class: "ky-ci-badge-n", x: b.at[0], y: b.at[1] + b.r * 0.4, "font-size": num(b.r * (b.n >= 10 ? 1.05 : 1.25)) }, String(b.n));
+        turns += el("g", { class: "ky-ci-turn", "data-turn": b.n, "aria-label": fill(words.turn, { n: b.n }) }, inner);
+    }
+    body += el("g", { class: "ky-ci-turns" }, turns);
+    // The name and the facts in the top left; the north arrow in the top right; the scale bar and the credit along the foot.
+    if (label) {
+        body += el("text", { class: "ky-ci-name", x: viewBox.x + pad * 0.6, y: viewBox.y + 36 * k, "font-size": num(26 * k) }, esc(circuit.names[language]));
+        body += el("text", { class: "ky-ci-facts", x: viewBox.x + pad * 0.6, y: viewBox.y + 60 * k, "font-size": num(16 * k) }, esc(fill(words.facts, { km: km(circuit.length.value, language), turns: circuit.corners.value })));
+    }
+    body += northArrow([viewBox.x + viewBox.w - pad * 0.6 - 20 * k, viewBox.y + (label ? 44 * k : pad)], plan.north, 40 * k, words.northArrow);
+    body += scaleBar([viewBox.x + pad * 0.6, viewBox.y + viewBox.h - 14 * k], viewBox.w, k, words.metres);
+    body += el("text", { class: "ky-ci-credit", x: viewBox.x + viewBox.w - pad * 0.6, y: viewBox.y + viewBox.h - 14 * k, "font-size": num(11 * k), "text-anchor": "end" }, esc(CIRCUIT_ATTRIBUTION));
+    const titleId = `${gid}-t`;
+    const descId = `${gid}-d`;
+    const css = options.css === "none" ? "" : `<style>${KYOGIJO_CIRCUIT_STYLE}</style>`;
+    const svg = el("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        class: `kyogijo ky-circuit${safeClass(options.className) === "" ? "" : ` ${safeClass(options.className)}`}`,
+        viewBox: `${num(viewBox.x)} ${num(viewBox.y)} ${num(viewBox.w)} ${num(viewBox.h)}`,
+        role: "img",
+        "aria-labelledby": `${titleId} ${descId}`,
+        "data-circuit": circuit.id,
+        "data-direction": circuit.direction.value,
+        "data-theme": options.theme === "light" || options.theme === "dark" ? options.theme : undefined,
+        "data-version": VERSION,
+    }, metaMarkup(titleId, title, descId, description) + css + body);
+    return { svg, plan, viewBox, k, badges: placed.map(({ n, at, r: radius }) => ({ n, at, r: radius })), title, description };
+}
+/**
+ * A circuit as one SVG string: the lap as a ribbon of the track's width on the ways OpenStreetMap maps for it, the pit lane and the circuit's ground with its pit building, the start and the chequered finish across the
+ * track, arrows the way the lap runs, each turn's number beside its bend where OpenStreetMap numbers it, a north arrow, a scale bar and the credit of the map's data. Light and dark follow the page.
+ * @example
+ * ```ts
+ * import { drawCircuit } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const svg = drawCircuit({ circuit: "las-vegas" });
+ * console.log(svg.startsWith("<svg"), svg.includes('data-turn="17"'), svg.includes("OpenStreetMap"));
+ * // true true true
+ * ```
+ */
+export function drawCircuit(options) {
+    return circuitDrawing(options).svg;
+}
+/**
+ * A circuit's facts as a table, each with its basis (a source's, or ours) and the length the drawn line measures: for a reader who cannot see the drawing, and for a page that wants the data.
+ * @example
+ * ```ts
+ * import { circuitTable } from "@johnmorrisdotca/kyogijo-stadiums/circuits";
+ * const table = circuitTable({ circuit: "las-vegas" });
+ * console.log(table.startsWith("<table"), table.includes("6.201 km"));
+ * // true true
+ * ```
+ */
+export function circuitTable(options) {
+    const language = options.language === "ja" ? "ja" : "en";
+    const w = CIRCUIT_WORDS[language].table;
+    const plan = circuitPlan(circuitOf(options.circuit));
+    const c = plan.circuit;
+    const basis = (b) => (b === "documented" ? w.documented : w.plausible);
+    const rows = [
+        [w.length, `${km(c.length.value, language)} km`, basis(c.length.basis)],
+        [w.measured, `${km(plan.measured, language)} km`, "OpenStreetMap"],
+        [w.corners, String(c.corners.value), basis(c.corners.basis)],
+        [w.direction, c.direction.value === "counterclockwise" ? w.counterclockwise : w.clockwise, basis(c.direction.basis)],
+        [w.opened, c.opened.value, basis(c.opened.basis)],
+        [w.width, `${c.width.value} m`, basis(c.width.basis)],
+        [w.pitLaneWidth, `${c.pitLaneWidth.value} m`, basis(c.pitLaneWidth.basis)],
+        [w.wikidata, c.wikidata, "Wikidata"],
+    ];
+    const head = `<thead><tr><th scope="col">${esc(w.fact)}</th><th scope="col">${esc(w.value)}</th><th scope="col">${esc(w.basis)}</th></tr></thead>`;
+    const body = rows.map(([a, b, d]) => `<tr><th scope="row">${esc(a)}</th><td>${esc(b)}</td><td>${esc(d)}</td></tr>`).join("");
+    return `<table class="ky-table" data-kind="circuit"><caption>${esc(fill(w.caption, { name: c.names[language] }))}</caption>${head}<tbody>${body}</tbody></table>`;
+}

package/dist/circuits.geo.d.ts

@@ -0,0 +1,29 @@
+import type { Pt } from "./crowd.ts";
+/** The length of a line, closed into a ring when `closed`. */
+export declare function lineLength(points: readonly Pt[], closed: boolean): number;
+/** An open line with the points that lie within `tolerance` of the line between their neighbours taken out (Douglas and Peucker); the two ends are kept. */
+export declare function simplifyLine(points: readonly Pt[], tolerance: number): Pt[];
+/** A ring (the first point not repeated) made simpler as a line from its first point round to it again, so that the first point, the start of a lap, stays where it is. */
+export declare function simplifyLoop(points: readonly Pt[], tolerance: number): Pt[];
+/** Where on a line (closed when `closed`) the point nearest `p` is: the segment it is on (from point `i` to the next), how far round from the first point that is, the point itself and the distance to it. */
+export declare function nearestOn(points: readonly Pt[], p: Pt, closed: boolean): {
+    i: number;
+    along: number;
+    at: Pt;
+    d: number;
+};
+/** The point and the unit direction of a ring `along` units round from its first point (wrapped round the lap). */
+export declare function pointAlong(points: readonly Pt[], along: number): {
+    at: Pt;
+    dir: Pt;
+};
+/**
+ * Which way a ring bends at `along`, worked out over `reach` either side: the unit direction of travel there and the side the bend turns to (`1` to the left of travel in a frame whose y grows down the page, as an SVG's does,
+ * `-1` to the right, `0` straight).
+ */
+export declare function bendAt(points: readonly Pt[], along: number, reach: number): {
+    dir: Pt;
+    side: -1 | 0 | 1;
+};
+/** The signed area of a ring (the shoelace sum, halved): positive when it runs clockwise on a page whose y grows down. */
+export declare function signedAreaOf(points: readonly Pt[]): number;

package/dist/circuits.geo.js

@@ -0,0 +1,105 @@
+/** The length of a line, closed into a ring when `closed`. */
+export function lineLength(points, closed) {
+    let sum = 0;
+    const last = closed ? points.length : points.length - 1;
+    for (let i = 0; i < last; i += 1) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        sum += Math.hypot(q[0] - p[0], q[1] - p[1]);
+    }
+    return sum;
+}
+/** The distance from `p` to the segment from `a` to `b`, and how far along it (0 to 1) the nearest point is. */
+function toSegment(p, a, b) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const len2 = dx * dx + dy * dy;
+    const t = len2 === 0 ? 0 : Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2));
+    return { d: Math.hypot(a[0] + t * dx - p[0], a[1] + t * dy - p[1]), t };
+}
+/** An open line with the points that lie within `tolerance` of the line between their neighbours taken out (Douglas and Peucker); the two ends are kept. */
+export function simplifyLine(points, tolerance) {
+    if (points.length < 3)
+        return [...points];
+    const keep = new Array(points.length).fill(false);
+    keep[0] = true;
+    keep[points.length - 1] = true;
+    const stack = [[0, points.length - 1]];
+    while (stack.length > 0) {
+        const [from, to] = stack.pop();
+        let at = -1;
+        let most = tolerance;
+        for (let i = from + 1; i < to; i += 1) {
+            const { d } = toSegment(points[i], points[from], points[to]);
+            if (d > most)
+                [at, most] = [i, d];
+        }
+        if (at >= 0) {
+            keep[at] = true;
+            stack.push([from, at], [at, to]);
+        }
+    }
+    return points.filter((_, i) => keep[i]);
+}
+/** A ring (the first point not repeated) made simpler as a line from its first point round to it again, so that the first point, the start of a lap, stays where it is. */
+export function simplifyLoop(points, tolerance) {
+    const line = simplifyLine([...points, points[0]], tolerance);
+    return line.slice(0, -1);
+}
+/** Where on a line (closed when `closed`) the point nearest `p` is: the segment it is on (from point `i` to the next), how far round from the first point that is, the point itself and the distance to it. */
+export function nearestOn(points, p, closed) {
+    let best = { i: 0, along: 0, at: points[0], d: Infinity };
+    let walked = 0;
+    const last = closed ? points.length : points.length - 1;
+    for (let i = 0; i < last; i += 1) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const { d, t } = toSegment(p, a, b);
+        if (d < best.d)
+            best = { i, along: walked + t * long, at: [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])], d };
+        walked += long;
+    }
+    return best;
+}
+/** The point and the unit direction of a ring `along` units round from its first point (wrapped round the lap). */
+export function pointAlong(points, along) {
+    const total = lineLength(points, true);
+    let left = ((along % total) + total) % total;
+    for (let i = 0; i < points.length; i += 1) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (left <= long || i === points.length - 1) {
+            const t = long === 0 ? 0 : Math.min(1, left / long);
+            return { at: [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])], dir: long === 0 ? [1, 0] : [(b[0] - a[0]) / long, (b[1] - a[1]) / long] };
+        }
+        left -= long;
+    }
+    return { at: points[0], dir: [1, 0] };
+}
+/**
+ * Which way a ring bends at `along`, worked out over `reach` either side: the unit direction of travel there and the side the bend turns to (`1` to the left of travel in a frame whose y grows down the page, as an SVG's does,
+ * `-1` to the right, `0` straight).
+ */
+export function bendAt(points, along, reach) {
+    const before = pointAlong(points, along - reach).at;
+    const here = pointAlong(points, along);
+    const after = pointAlong(points, along + reach).at;
+    const a = [here.at[0] - before[0], here.at[1] - before[1]];
+    const b = [after[0] - here.at[0], after[1] - here.at[1]];
+    const cross = a[0] * b[1] - a[1] * b[0];
+    const scale = Math.hypot(...a) * Math.hypot(...b);
+    const side = scale === 0 || Math.abs(cross / scale) < 0.02 ? 0 : cross < 0 ? 1 : -1;
+    return { dir: here.dir, side };
+}
+/** The signed area of a ring (the shoelace sum, halved): positive when it runs clockwise on a page whose y grows down. */
+export function signedAreaOf(points) {
+    let sum = 0;
+    for (let i = 0; i < points.length; i += 1) {
+        const p = points[i];
+        const q = points[(i + 1) % points.length];
+        sum += p[0] * q[1] - q[0] * p[1];
+    }
+    return sum / 2;
+}

package/dist/circuits.js

@@ -0,0 +1,73 @@
+import { CIRCUIT_DATA } from "./circuits.data.js";
+import { CIRCUIT_OSM } from "./circuits.osm.data.js";
+import { bendAt, lineLength, nearestOn } from "./circuits.geo.js";
+import { FEET_PER_METRE as FT } from "./geometry.js";
+import { metresFrom, northOn, smallestBox, turnedTo } from "./venues.geo.js";
+/** The credit a drawing made from OpenStreetMap's data carries (the same words as the venues'). */
+export const CIRCUIT_ATTRIBUTION = "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright";
+/** Every circuit, in the order of the data. */
+export const CIRCUITS = Object.freeze(CIRCUIT_DATA.map((c) => {
+    const osm = CIRCUIT_OSM[c.id];
+    if (osm === undefined)
+        throw new Error(`the circuit ${c.id} has no OpenStreetMap record`);
+    return Object.freeze({ ...c, osm });
+}));
+/** The keys of the circuits. */
+export const CIRCUIT_IDS = Object.freeze(CIRCUITS.map((c) => c.id));
+/** A circuit by its key, or `undefined`. */
+export const circuitById = (id) => CIRCUITS.find((c) => c.id === id);
+const points = (osm) => [...osm.lap, ...osm.pitLane.line, ...osm.area.ring, ...(osm.pitBuilding?.ring ?? [])];
+/** A circuit's plan: its lap, pit lane, ground, pit building, turns, start and finish in the drawing's frame. */
+export function circuitPlan(circuit) {
+    const osm = circuit.osm;
+    const all = points(osm);
+    const lons = all.map((p) => p[0]);
+    const lats = all.map((p) => p[1]);
+    const origin = [(Math.min(...lons) + Math.max(...lons)) / 2, (Math.min(...lats) + Math.max(...lats)) / 2];
+    const lapMetres = metresFrom(origin, osm.lap);
+    const heading = smallestBox(lapMetres).heading;
+    const frame = (ring) => metresFrom(origin, ring).map((p) => {
+        const [x, y] = turnedTo(heading, p);
+        return [x * FT, y * FT];
+    });
+    const lap = frame(osm.lap);
+    const place = (at) => {
+        const near = nearestOn(lap, frame([at])[0], true);
+        const bend = bendAt(lap, near.along, 30 * FT);
+        return { at: near.at, dir: bend.dir, along: near.along };
+    };
+    const turns = osm.turns.map((t) => {
+        const near = nearestOn(lap, frame([t.at])[0], true);
+        const bend = bendAt(lap, near.along, 40 * FT);
+        return { n: t.n, at: near.at, along: near.along, dir: bend.dir, side: bend.side };
+    });
+    const pitLane = frame(osm.pitLane.line);
+    const area = frame(osm.area.ring);
+    const building = osm.pitBuilding === undefined ? undefined : { ring: frame(osm.pitBuilding.ring), height: osm.pitBuilding.height * FT };
+    const xs = [...lap, ...pitLane, ...area, ...(building?.ring ?? [])].map((p) => p[0]);
+    const ys = [...lap, ...pitLane, ...area, ...(building?.ring ?? [])].map((p) => p[1]);
+    return {
+        circuit,
+        origin,
+        heading,
+        north: northOn(heading),
+        lap,
+        measured: lineLength(lapMetres, true),
+        pitLane,
+        area,
+        ...(building === undefined ? {} : { building }),
+        turns,
+        start: place(osm.start.at),
+        finish: place(osm.finish.at),
+        width: circuit.width.value * FT,
+        pitWidth: circuit.pitLaneWidth.value * FT,
+        box: { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) },
+    };
+}
+/** The circuit a set of options names, or an error that lists the keys. */
+export function circuitOf(id) {
+    const found = circuitById(id);
+    if (found === undefined)
+        throw new Error(`no circuit "${String(id)}": the circuits are ${CIRCUIT_IDS.join(", ")}`);
+    return found;
+}

package/dist/circuits.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { CircuitOsm } from "./circuits.types.ts";
+export declare const CIRCUIT_OSM: Record<string, CircuitOsm>;

package/dist/circuits.osm.data.js

@@ -0,0 +1,188 @@
+export const CIRCUIT_OSM = {
+    "las-vegas": {
+        "source": "relation/16696508",
+        "read": "2026-11-03",
+        "base": "2026-11-03T08:11:25Z",
+        "licence": "ODbL-1.0",
+        "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "points": 228,
+        "tolerance": 0.5,
+        "start": { "source": "node/13016217986", "at": [-115.161882, 36.109284] },
+        "finish": { "source": "node/13016217985", "at": [-115.16256, 36.108665] },
+        "turns": [
+            { "n": 1, "source": "node/11348753612", "at": [-115.160364, 36.1107] },
+            { "n": 2, "source": "node/11348753615", "at": [-115.160527, 36.111068] },
+            { "n": 3, "source": "node/11348753622", "at": [-115.162922, 36.110443] },
+            { "n": 4, "source": "node/5717585567", "at": [-115.163928, 36.111154] },
+            { "n": 5, "source": "node/137743393", "at": [-115.163995, 36.119208] },
+            { "n": 6, "source": "node/12626696512", "at": [-115.161185, 36.119173] },
+            { "n": 7, "source": "node/12638889512", "at": [-115.160113, 36.120741] },
+            { "n": 8, "source": "node/12638889528", "at": [-115.160671, 36.120939] },
+            { "n": 9, "source": "node/12059212382", "at": [-115.160406, 36.122236] },
+            { "n": 10, "source": "node/137402143", "at": [-115.165999, 36.123073] },
+            { "n": 11, "source": "node/13250780586", "at": [-115.166888, 36.124717] },
+            { "n": 12, "source": "node/1490596713", "at": [-115.169378, 36.125559] },
+            { "n": 13, "source": "node/1598856720", "at": [-115.172521, 36.120102] },
+            { "n": 14, "source": "node/2852160857", "at": [-115.173152, 36.108811] },
+            { "n": 15, "source": "node/2852160859", "at": [-115.172805, 36.108527] },
+            { "n": 16, "source": "node/2852160864", "at": [-115.171797, 36.10798] },
+            { "n": 17, "source": "node/13341696778", "at": [-115.163901, 36.10797] },
+        ],
+        "pitLane": { "source": "way/1223479152", "line": [
+                [-115.163901, 36.10797],
+                [-115.163719, 36.108128],
+                [-115.163534, 36.108211],
+                [-115.163399, 36.108284],
+                [-115.163327, 36.108348],
+                [-115.163159, 36.108544],
+                [-115.163088, 36.108588],
+                [-115.163006, 36.108606],
+                [-115.162864, 36.108617],
+                [-115.162772, 36.108643],
+                [-115.160585, 36.110632],
+                [-115.160527, 36.110733],
+                [-115.160525, 36.110799],
+                [-115.160546, 36.110885],
+                [-115.160615, 36.110975],
+                [-115.160786, 36.111152],
+            ] },
+        "area": { "source": "way/233786564", "ring": [
+                [-115.159474, 36.108123],
+                [-115.159465, 36.109009],
+                [-115.159463, 36.111419],
+                [-115.163831, 36.111463],
+                [-115.16387, 36.111421],
+                [-115.163831, 36.108924],
+                [-115.16384, 36.108175],
+                [-115.163275, 36.108185],
+                [-115.163113, 36.108111],
+            ] },
+        "pitBuilding": { "source": "way/1198427833", "height": 19.5, "levels": 4, "ring": [
+                [-115.160882, 36.110929],
+                [-115.160837, 36.110969],
+                [-115.160746, 36.110905],
+                [-115.160791, 36.110864],
+                [-115.160627, 36.110748],
+                [-115.162844, 36.108712],
+                [-115.16312, 36.108908],
+                [-115.162957, 36.109058],
+                [-115.163191, 36.108998],
+                [-115.163351, 36.109117],
+                [-115.162718, 36.109277],
+                [-115.16103, 36.110828],
+                [-115.161186, 36.11098],
+                [-115.161052, 36.111078],
+                [-115.160911, 36.111007],
+                [-115.160944, 36.110973],
+            ] },
+        "lap": [
+            [-115.161882, 36.109284],
+            [-115.160457, 36.110584],
+            [-115.160364, 36.1107],
+            [-115.160339, 36.110795],
+            [-115.160346, 36.110874],
+            [-115.160416, 36.110984],
+            [-115.160527, 36.111068],
+            [-115.160644, 36.111116],
+            [-115.160786, 36.111152],
+            [-115.160999, 36.111176],
+            [-115.161206, 36.111167],
+            [-115.161388, 36.111125],
+            [-115.161573, 36.111048],
+            [-115.16184, 36.110903],
+            [-115.162253, 36.110584],
+            [-115.162388, 36.110509],
+            [-115.162551, 36.110465],
+            [-115.162753, 36.110441],
+            [-115.162922, 36.110443],
+            [-115.163104, 36.110489],
+            [-115.163265, 36.11054],
+            [-115.163431, 36.110615],
+            [-115.163611, 36.11074],
+            [-115.163758, 36.110892],
+            [-115.163928, 36.111154],
+            [-115.163941, 36.111772],
+            [-115.163941, 36.11265],
+            [-115.163969, 36.114338],
+            [-115.163963, 36.115729],
+            [-115.163995, 36.119208],
+            [-115.162977, 36.119205],
+            [-115.161185, 36.119173],
+            [-115.160922, 36.119319],
+            [-115.160561, 36.119603],
+            [-115.1604, 36.119784],
+            [-115.160199, 36.120147],
+            [-115.160142, 36.120366],
+            [-115.160112, 36.120615],
+            [-115.160113, 36.120741],
+            [-115.160393, 36.120792],
+            [-115.160477, 36.120812],
+            [-115.160518, 36.12083],
+            [-115.160612, 36.120889],
+            [-115.160671, 36.120939],
+            [-115.160701, 36.120982],
+            [-115.160739, 36.121078],
+            [-115.160746, 36.121199],
+            [-115.160715, 36.121326],
+            [-115.160619, 36.121508],
+            [-115.160428, 36.121821],
+            [-115.160418, 36.121862],
+            [-115.160406, 36.122236],
+            [-115.161621, 36.122255],
+            [-115.163038, 36.122292],
+            [-115.16404, 36.12229],
+            [-115.164161, 36.122469],
+            [-115.164789, 36.122495],
+            [-115.165233, 36.122578],
+            [-115.165486, 36.122681],
+            [-115.165771, 36.122882],
+            [-115.165999, 36.123073],
+            [-115.166099, 36.123197],
+            [-115.166263, 36.123475],
+            [-115.166719, 36.124462],
+            [-115.1668, 36.124594],
+            [-115.166888, 36.124717],
+            [-115.166993, 36.124807],
+            [-115.167403, 36.125109],
+            [-115.167607, 36.125224],
+            [-115.167978, 36.125335],
+            [-115.168348, 36.125409],
+            [-115.169152, 36.125532],
+            [-115.169378, 36.125559],
+            [-115.170175, 36.124296],
+            [-115.170827, 36.123304],
+            [-115.1716, 36.122216],
+            [-115.172014, 36.121456],
+            [-115.17229, 36.120739],
+            [-115.172521, 36.120102],
+            [-115.172634, 36.119746],
+            [-115.172763, 36.119258],
+            [-115.172829, 36.118921],
+            [-115.172938, 36.118154],
+            [-115.172984, 36.117475],
+            [-115.172992, 36.115944],
+            [-115.172983, 36.11477],
+            [-115.17303, 36.114029],
+            [-115.173048, 36.113017],
+            [-115.173134, 36.110958],
+            [-115.173145, 36.109883],
+            [-115.173142, 36.109147],
+            [-115.173152, 36.108811],
+            [-115.172561, 36.108329],
+            [-115.172342, 36.108166],
+            [-115.172192, 36.108065],
+            [-115.172108, 36.108025],
+            [-115.172026, 36.108002],
+            [-115.171915, 36.107986],
+            [-115.171283, 36.107967],
+            [-115.170195, 36.107965],
+            [-115.168707, 36.10795],
+            [-115.164027, 36.107952],
+            [-115.163901, 36.10797],
+            [-115.163509, 36.10809],
+            [-115.163145, 36.108223],
+            [-115.162981, 36.108306],
+            [-115.162837, 36.108412],
+        ],
+    },
+};