@johnmorrisdotca/kyogijo-stadiums 0.0.0-stage → 0.4.0

package/dist/road.model.d.ts

@@ -0,0 +1,63 @@
+import { type KyogijoWords } from "./strings.ts";
+import type { RoadDecided, RoadFinalist, RoadOptions, RoadTotals } from "./road.types.ts";
+import type { Language, Team } from "./types.ts";
+/** Who won a match, from the finalist's side. `unknown` when the score is not a pair of numbers. */
+export type Result = "win" | "loss" | "draw" | "unknown";
+/** A match as it is drawn: the two scores written, who won, and how it was decided. */
+export interface MatchView {
+    /** The round's key; empty for a match of the group stage. */
+    round: string;
+    opponent: Team;
+    /** The finalist's score and the opponent's, written. For a score that is one text that could not be split, `whole` is that text and the two are empty. */
+    mine: string;
+    theirs: string;
+    whole?: string;
+    result: Result;
+    decided: RoadDecided;
+    pens?: [string, string];
+    /** The words that replace the usual ones under the score, or undefined. */
+    note?: string;
+    /** Whether the usual words (FT, AET, the shoot-out) are written: always for a knockout match, only when asked for a group match. */
+    says: boolean;
+    homeFirst?: boolean;
+}
+/** The chart's data, ready to draw. */
+export interface Model {
+    language: Language;
+    words: KyogijoWords;
+    finalists: [Team, Team];
+    /** The matches of the group stage, for each finalist. */
+    group: [MatchView[], MatchView[]];
+    /** The knockout matches for each finalist, by round key. */
+    path: [Map<string, MatchView>, Map<string, MatchView>];
+    /** The rounds, the earliest first. */
+    rounds: string[];
+    /** The final, if played: the scores of the first finalist and the second. */
+    final?: MatchView;
+    label(key: string): string;
+    groupLabel: string;
+    title: string;
+    subtitle: string | undefined;
+}
+/** A number from a number or from text that is one, else undefined. */
+export declare function numeric(value: unknown): number | undefined;
+/** The rounds of two paths, the earliest first: a round both have is once, and a round only one has stays after the round before it. */
+export declare function mergeRounds(paths: readonly (readonly string[])[]): string[];
+/** Read and check what `roadToFinal` was given. */
+export declare function readModel(finalists: readonly RoadFinalist[], options: RoadOptions): Model;
+/** The words under a score: FT, AET or the shoot-out (the first side's numbers first), a note in their place, or nothing. */
+export declare function decidedWords(view: MatchView, w: KyogijoWords["road"], mineFirst: boolean): string;
+/** The score of a match as one text, the first side's first. */
+export declare function scoreText(view: MatchView, mineFirst?: boolean): string;
+/** The abbreviation written under a mark: the team's own, else made from its name. */
+export declare function codeOf(team: Team): string;
+/** The numbers behind the chart. */
+export declare function totalsOf(model: Model): RoadTotals;
+/** The chart's accessible name. */
+export declare function nameOf(model: Model): string;
+/** What the chart shows, in a sentence or two. */
+export declare function summaryOf(model: Model): string;
+/** One HTML table with a row for every match: the group stage, the knockout rounds in order, and the final. */
+export declare function tableOf(model: Model, options?: {
+    className?: string;
+}): string;

package/dist/road.model.js

@@ -0,0 +1,215 @@
+// The road chart's data, read and checked: the scores split into the two sides, who won each match, the words under each score, the rounds in the order played, and
+// the sentences and the table that say the same in words. Nothing here draws.
+import { esc } from "./format.js";
+import { safeClass } from "./common.js";
+import { KYOGIJO_STRINGS, fill } from "./strings.js";
+import { abbreviate } from "./text.js";
+const own = (object, key) => object !== undefined && Object.prototype.hasOwnProperty.call(object, key);
+/** A number from a number or from text that is one, else undefined. */
+export function numeric(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value === "string" && /^\s*-?\d+(?:\.\d+)?\s*$/.test(value))
+        return Number(value);
+    return undefined;
+}
+const written = (value) => (value === undefined || value === null ? "" : String(value).trim());
+/** The two sides of a score. */
+function split(score) {
+    if (Array.isArray(score) && score.length === 2)
+        return { mine: written(score[0]), theirs: written(score[1]) };
+    const text = written(score);
+    const parts = /^(\S+?)\s*[-–—:]\s*(\S+)$/.exec(text);
+    if (parts !== null)
+        return { mine: parts[1], theirs: parts[2] };
+    return { mine: "", theirs: "", whole: text };
+}
+function resultOf(mine, theirs, pens) {
+    const a = numeric(mine);
+    const b = numeric(theirs);
+    if (a === undefined || b === undefined)
+        return "unknown";
+    if (a !== b)
+        return a > b ? "win" : "loss";
+    const p = pens === undefined ? undefined : [numeric(pens[0]), numeric(pens[1])];
+    if (p !== undefined && p[0] !== undefined && p[1] !== undefined && p[0] !== p[1])
+        return p[0] > p[1] ? "win" : "loss";
+    return "draw";
+}
+function pensOf(value) {
+    return Array.isArray(value) && value.length === 2 && written(value[0]) !== "" && written(value[1]) !== "" ? [written(value[0]), written(value[1])] : undefined;
+}
+function viewOf(m, opponent, round, knockout) {
+    const { mine, theirs, whole } = split(m.score);
+    const pens = pensOf(m.pens);
+    const decided = m.decidedBy === "aet" || m.decidedBy === "pens" || m.decidedBy === "ft" ? m.decidedBy : pens !== undefined ? "pens" : "ft";
+    const note = typeof m.note === "string" ? m.note.trim() : undefined;
+    return {
+        round,
+        opponent,
+        mine,
+        theirs,
+        ...(whole === undefined ? {} : { whole }),
+        result: resultOf(mine, theirs, pens),
+        decided,
+        ...(pens === undefined ? {} : { pens }),
+        ...(note === undefined ? {} : { note }),
+        says: knockout || m.decidedBy !== undefined || pens !== undefined,
+        ...("homeFirst" in m && typeof m.homeFirst === "boolean" ? { homeFirst: m.homeFirst } : {}),
+    };
+}
+/** The rounds of two paths, the earliest first: a round both have is once, and a round only one has stays after the round before it. */
+export function mergeRounds(paths) {
+    const out = [];
+    for (const path of paths) {
+        let at = 0;
+        for (const key of path) {
+            const found = out.indexOf(key);
+            if (found >= 0)
+                at = found + 1;
+            else {
+                out.splice(at, 0, key);
+                at += 1;
+            }
+        }
+    }
+    return out;
+}
+const isTeam = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.name === "string";
+/** Read and check what `roadToFinal` was given. */
+export function readModel(finalists, options) {
+    if (!Array.isArray(finalists) || finalists.length !== 2)
+        throw new TypeError("roadToFinal takes the two finalists as a list of two teams, each with a path");
+    const language = options.language === "ja" ? "ja" : "en";
+    const words = KYOGIJO_STRINGS[language];
+    const w = words.road;
+    const teams = finalists;
+    for (const [i, f] of teams.entries()) {
+        if (!isTeam(f))
+            throw new TypeError(`Finalist ${i + 1} is a team with a name`);
+        if (!Array.isArray(f.path))
+            throw new TypeError(`Finalist ${i + 1} (${f.name}) needs a path: the list of its matches before the final`);
+        if (f.group !== undefined && !Array.isArray(f.group))
+            throw new TypeError(`The group of ${f.name} is a list of matches`);
+        for (const m of [...f.path, ...(f.group ?? [])]) {
+            if (typeof m !== "object" || m === null || !isTeam(m.opponent) || m.score === undefined || m.score === null)
+                throw new TypeError(`Every match of ${f.name} has an opponent (a team with a name) and a score`);
+        }
+        for (const m of f.path)
+            if (typeof m.round !== "string" || m.round.trim() === "")
+                throw new TypeError(`Every match of the path of ${f.name} has a round`);
+    }
+    const path = teams.map((f) => {
+        const map = new Map();
+        for (const m of f.path)
+            map.set(m.round.trim(), viewOf(m, m.opponent, m.round.trim(), true));
+        return map;
+    });
+    const group = teams.map((f) => (f.group ?? []).map((m) => viewOf(m, m.opponent, "", false)));
+    const rounds = mergeRounds(teams.map((f) => f.path.map((m) => m.round.trim())));
+    const labels = options.labels;
+    const model = {
+        language,
+        words,
+        finalists: teams,
+        group,
+        path,
+        rounds,
+        label: (key) => (own(labels, key) && typeof labels?.[key] === "string" ? labels[key] : own(w.rounds, key) ? w.rounds[key] : key),
+        groupLabel: typeof options.groupLabel === "string" && options.groupLabel.trim() !== "" ? options.groupLabel.trim() : w.group,
+        title: typeof options.title === "string" && options.title.trim() !== "" ? options.title.trim() : w.title,
+        subtitle: typeof options.subtitle === "string" && options.subtitle.trim() !== "" ? options.subtitle.trim() : typeof options.title === "string" && options.title.trim() !== "" ? w.title : undefined,
+    };
+    if (options.final !== undefined) {
+        if (typeof options.final !== "object" || options.final === null || options.final.score === undefined || options.final.score === null)
+            throw new TypeError("The final is { score }: the first finalist's score first");
+        model.final = viewOf(options.final, teams[1], "final", true);
+    }
+    return model;
+}
+/** The words under a score: FT, AET or the shoot-out (the first side's numbers first), a note in their place, or nothing. */
+export function decidedWords(view, w, mineFirst) {
+    if (view.note !== undefined)
+        return view.note;
+    if (!view.says)
+        return "";
+    if (view.decided === "aet")
+        return w.aet;
+    if (view.decided === "pens" && view.pens !== undefined)
+        return fill(w.pens, mineFirst ? { a: view.pens[0], b: view.pens[1] } : { a: view.pens[1], b: view.pens[0] });
+    return view.decided === "pens" ? w.aet : w.ft;
+}
+/** The score of a match as one text, the first side's first. */
+export function scoreText(view, mineFirst = true) {
+    if (view.whole !== undefined)
+        return view.whole;
+    return mineFirst ? `${view.mine}-${view.theirs}` : `${view.theirs}-${view.mine}`;
+}
+/** The abbreviation written under a mark: the team's own, else made from its name. */
+export function codeOf(team) {
+    return (typeof team.abbr === "string" && team.abbr.trim() !== "" ? team.abbr.trim() : abbreviate(String(team.name ?? ""))).slice(0, 5).toLocaleUpperCase("en");
+}
+function record(f, group, path) {
+    const all = [...group, ...path.values()];
+    let scored = 0;
+    let conceded = 0;
+    for (const v of all) {
+        const a = numeric(v.mine);
+        const b = numeric(v.theirs);
+        if (a !== undefined && b !== undefined) {
+            scored += a;
+            conceded += b;
+        }
+    }
+    return { name: f.name, matches: all.length, won: all.filter((v) => v.result === "win").length, drawn: all.filter((v) => v.result === "draw").length, lost: all.filter((v) => v.result === "loss").length, scored, conceded };
+}
+/** The numbers behind the chart. */
+export function totalsOf(model) {
+    const [a, b] = model.finalists;
+    const final = model.final;
+    const champion = final === undefined || final.result === "unknown" || final.result === "draw" ? null : final.result === "win" ? a.name : b.name;
+    return { finalists: [record(a, model.group[0], model.path[0]), record(b, model.group[1], model.path[1])], rounds: [...model.rounds], played: final !== undefined, champion };
+}
+/** The chart's accessible name. */
+export function nameOf(model) {
+    const heading = [model.title, model.subtitle].filter((part) => part !== undefined).join(model.words.said.sep);
+    return fill(model.words.road.name, { a: model.finalists[0].name, b: model.finalists[1].name, title: heading });
+}
+/** What the chart shows, in a sentence or two. */
+export function summaryOf(model) {
+    const w = model.words.road;
+    const [a, b] = model.finalists;
+    const t = totalsOf(model);
+    const parts = [fill(w.summary, { a: a.name, b: b.name, an: t.finalists[0].matches, bn: t.finalists[1].matches })];
+    const final = model.final;
+    if (final === undefined)
+        parts.push(w.toPlay);
+    else {
+        parts.push(fill(w.final, { a: a.name, b: b.name, score: scoreText(final), how: decidedWords(final, w, true) || w.ft }));
+        if (t.champion !== null)
+            parts.push(fill(w.champion, { name: t.champion }));
+    }
+    return parts.join(model.words.said.gap);
+}
+/** One HTML table with a row for every match: the group stage, the knockout rounds in order, and the final. */
+export function tableOf(model, options = {}) {
+    const w = model.words.road;
+    const cls = safeClass(options.className) || "ky-table";
+    const [a, b] = model.finalists;
+    const result = (r) => (r === "win" ? w.won : r === "loss" ? w.lost : r === "draw" ? w.drew : "");
+    const row = (team, round, v) => `<tr><th scope="row">${esc(team.name)}</th><td>${esc(round)}</td><td>${esc(v.opponent.name)}</td><td>${esc(scoreText(v))}</td><td>${esc(decidedWords(v, w, true))}</td><td>${esc(result(v.result))}</td></tr>`;
+    const rows = [];
+    for (const [i, team] of [a, b].entries()) {
+        for (const v of model.group[i])
+            rows.push(row(team, model.groupLabel, v));
+        for (const key of model.rounds) {
+            const v = model.path[i].get(key);
+            if (v !== undefined)
+                rows.push(row(team, model.label(key), v));
+        }
+    }
+    if (model.final !== undefined)
+        rows.push(row(a, model.label("final"), { ...model.final, opponent: b }));
+    const head = [w.tableTeam, w.tableRound, w.tableOpponent, w.tableScore, w.tableDecided, w.tableResult].map((name) => `<th scope="col">${esc(name)}</th>`).join("");
+    return `<table class="${cls}" data-kind="road"><caption>${esc(fill(w.caption, { a: a.name, b: b.name }))}</caption><thead><tr>${head}</tr></thead><tbody>${rows.join("")}</tbody></table>`;
+}

package/dist/road.style.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The rules of the road-to-the-final chart (`roadToFinal`): the ground, the ink and the quiet ink in light and dark, the panel behind a round's name, the road down the
+ * middle, and the classes of the title, the names, the scores and the small words under them. The colours are custom properties on the chart (`--ky-road-bg`,
+ * `--ky-road-ink`, `--ky-road-muted`, `--ky-road-panel`, `--ky-road-spine`, `--ky-road-left`, `--ky-road-right`), so a page can set them. A chart writes these rules in,
+ * with the round mark's (`KYOGIJO_MARK_STYLE`); `KYOGIJO_STYLE` has them for a page that draws with `style: "none"`.
+ */
+export declare const KYOGIJO_ROAD_STYLE: string;

package/dist/road.style.js

@@ -0,0 +1,26 @@
+/**
+ * The rules of the road-to-the-final chart (`roadToFinal`): the ground, the ink and the quiet ink in light and dark, the panel behind a round's name, the road down the
+ * middle, and the classes of the title, the names, the scores and the small words under them. The colours are custom properties on the chart (`--ky-road-bg`,
+ * `--ky-road-ink`, `--ky-road-muted`, `--ky-road-panel`, `--ky-road-spine`, `--ky-road-left`, `--ky-road-right`), so a page can set them. A chart writes these rules in,
+ * with the round mark's (`KYOGIJO_MARK_STYLE`); `KYOGIJO_STYLE` has them for a page that draws with `style: "none"`.
+ */
+export const KYOGIJO_ROAD_STYLE = `
+:where(.kyogijo-road){--ky-road-bg:#f6f4ee;--ky-road-ink:#1d2421;--ky-road-muted:#5a655f;--ky-road-panel:#e7e3d6;--ky-road-spine:#c4bfae;--ky-road-left:#2f6db0;--ky-road-right:#b5452c;--ky-road-plain:#8b948f;--ky-mark-ring:#fff;--ky-mark-edge:rgba(0,0,0,.3);--ky-mark-plain:#fff;--ky-font:system-ui,-apple-system,"Segoe UI","Hiragino Sans","Noto Sans JP",sans-serif;display:block;width:100%;height:auto;font-family:var(--ky-font)}
+@media (prefers-color-scheme:dark){:where(html:not([data-theme=light]) .kyogijo-road:not([data-theme=light])){--ky-road-bg:#131716;--ky-road-ink:#ece8dc;--ky-road-muted:#a9b2ac;--ky-road-panel:#252b28;--ky-road-spine:#3d4541;--ky-road-left:#6aa9f0;--ky-road-right:#f59a5b;--ky-mark-ring:#e9ece6;--ky-mark-edge:rgba(0,0,0,.6);--ky-mark-plain:#2a302d}}
+:where(html[data-theme=dark] .kyogijo-road,.kyogijo-road[data-theme=dark]){--ky-road-bg:#131716;--ky-road-ink:#ece8dc;--ky-road-muted:#a9b2ac;--ky-road-panel:#252b28;--ky-road-spine:#3d4541;--ky-road-left:#6aa9f0;--ky-road-right:#f59a5b;--ky-mark-ring:#e9ece6;--ky-mark-edge:rgba(0,0,0,.6);--ky-mark-plain:#2a302d}
+.kyogijo-road .ky-r-bg{fill:var(--ky-road-bg)}
+.kyogijo-road text{font-family:var(--ky-font);font-variant-numeric:tabular-nums}
+.kyogijo-road .ky-r-t{fill:var(--ky-road-ink);font-weight:800}
+.kyogijo-road .ky-r-s,.kyogijo-road .ky-r-e{fill:var(--ky-road-muted);font-weight:600}
+.kyogijo-road .ky-r-name{fill:var(--ky-road-ink);font-weight:800}
+.kyogijo-road .ky-r-panel{fill:var(--ky-road-panel)}
+.kyogijo-road .ky-r-lab{fill:var(--ky-road-ink);font-weight:700}
+.kyogijo-road .ky-r-spine{stroke:var(--ky-road-spine);fill:none;stroke-linecap:round}
+.kyogijo-road .ky-r-n{fill:var(--ky-road-ink);font-weight:800}
+.kyogijo-road .ky-r-n.ky-r-low,.kyogijo-road .ky-r-dash{fill:var(--ky-road-muted);font-weight:700}
+.kyogijo-road .ky-r-sub,.kyogijo-road .ky-r-code{fill:var(--ky-road-muted);font-weight:700}
+.kyogijo-road .ky-r-vs{fill:var(--ky-road-muted);font-weight:700}
+.kyogijo-road .ky-r-dim{opacity:.5}
+.kyogijo-road .ky-r-left{--c:var(--ky-road-left)}
+.kyogijo-road .ky-r-right{--c:var(--ky-road-right)}
+.kyogijo-road .ky-r-plain{--c:var(--ky-road-plain)}`.trim();

package/dist/road.types.d.ts

@@ -0,0 +1,122 @@
+import type { Language, Team } from "./types.ts";
+/** A match's score from the finalist's side: `[for, against]` (numbers, or text such as a series' `4`), or one text, `"4-2"`, that is split at its dash. */
+export type RoadScore = readonly [number | string, number | string] | string;
+/** How a match was decided: `ft` (full time, the default), `aet` (after extra time) or `pens` (a shoot-out after extra time). */
+export type RoadDecided = "ft" | "aet" | "pens";
+/** One match on a finalist's way. */
+export interface RoadMatch {
+    /** The round, as a key. `round-of-32`, `round-of-16`, `quarter-final` and `semi-final` have words in English and Japanese; any other key is written as it is, or as `options.labels` names it. */
+    round: string;
+    /** The team it played: its name, abbreviation, `logo` (the flag or the crest) and `color`. */
+    opponent: Team;
+    /** The score, the finalist's first: `[2, 1]` is a 2-1 win. */
+    score: RoadScore;
+    /** How it was decided: `ft` by default, or `pens` when `pens` is given. Written under the score: FT, AET, or the shoot-out. */
+    decidedBy?: RoadDecided;
+    /** The shoot-out, the finalist's first: `[4, 3]`. */
+    pens?: readonly [number | string, number | string];
+    /** The order of the pair, left to right: `true` the finalist first, `false` its opponent first. By default the finalist is at the outer edge of its side, so that the two paths mirror each other. */
+    homeFirst?: boolean;
+    /** Words to write under the score in place of FT, AET or the shoot-out (`Game 6`, `OT`). An empty text writes nothing. */
+    note?: string;
+}
+/** One match of the group stage: as a knockout match, without a round. */
+export type RoadGroupMatch = Omit<RoadMatch, "round"> & {
+    round?: string;
+};
+/** A finalist: a team and the matches it played on the way, the earliest first. */
+export interface RoadFinalist extends Team {
+    /** The knockout matches before the final, the earliest first. */
+    path: readonly RoadMatch[];
+    /** The group stage, in the order played. A row of small marks, codes and scores at the foot. */
+    group?: readonly RoadGroupMatch[];
+}
+/** The final, when it has been played. */
+export interface RoadFinal {
+    /** The score, the first finalist's first. */
+    score: RoadScore;
+    decidedBy?: RoadDecided;
+    /** The shoot-out, the first finalist's first. */
+    pens?: readonly [number | string, number | string];
+    note?: string;
+}
+/** The sizes of the chart: `card` 1080 by 1350 (a tall post), `square` 1080 by 1080, `wide` 1200 by 675 (the finalists at the two ends) and `phone` 390 wide and as tall as it needs. */
+export type RoadSize = "card" | "square" | "wide" | "phone";
+/** What `roadToFinal` takes besides the finalists. */
+export interface RoadOptions {
+    /** The words of the chart: its title, the rounds' names, how a match was decided and the table. English by default. */
+    language?: Language;
+    /** A prefix for the ids inside the drawing. Made from the chart when missing, so that two charts on a page do not share ids. */
+    id?: string;
+    /** The tournament, set large at the top. "Road to the final" when missing. */
+    title?: string;
+    /** The line under it. "Road to the final" when a `title` is given. */
+    subtitle?: string;
+    /** The final, if it has been played: its score is written between the two big marks, the winner is brighter, and the table has a row for it. */
+    final?: RoadFinal;
+    /** The names of the rounds, by key, over the package's own words. Any key a match uses may be named here: `{ "first-round": "First round" }`. */
+    labels?: Readonly<Record<string, string>>;
+    /** The group stage's name, over the package's own. */
+    groupLabel?: string;
+    /** `card` (the default), `square`, `wide` or `phone`. */
+    size?: RoadSize;
+    /** `light` or `dark` to force one; `auto` (the default) follows the device and the page. */
+    theme?: "auto" | "light" | "dark";
+    /** Who is brighter: `auto` (the default) the side that won each match, `none` nobody. */
+    winner?: "auto" | "none";
+    /** Write the opponent's three-letter code under its mark. On by default. */
+    codes?: boolean;
+    /** A line at the foot: a source, a credit, "Made-up results". */
+    endnote?: string;
+    /** A class for the root. */
+    className?: string;
+    /** `none` leaves the stylesheet to the page (`KYOGIJO_STYLE` has every rule). */
+    style?: "embed" | "none";
+}
+/** One finalist's record on the way. */
+export interface RoadRecord {
+    name: string;
+    /** Matches played in the group and the knockout rounds (not the final), and how many it won, drew and lost. */
+    matches: number;
+    won: number;
+    drawn: number;
+    lost: number;
+    /** The goals it scored and let in over the matches whose score is a pair of numbers. */
+    scored: number;
+    conceded: number;
+}
+/** The numbers behind a road chart. */
+export interface RoadTotals {
+    finalists: [RoadRecord, RoadRecord];
+    /** The rounds of the chart, the earliest first, as keys. */
+    rounds: string[];
+    /** The final has a score. */
+    played: boolean;
+    /** The winner of the final, or null when it has not been played or is level. */
+    champion: string | null;
+}
+/** The size in pixels a size draws at, and what it is for. */
+export interface RoadSizeInfo {
+    readonly width: number;
+    /** `undefined` for a size that is as tall as the rounds need. */
+    readonly height: number | undefined;
+    readonly about: string;
+}
+/** What `roadToFinal` gives back. */
+export interface RoadChart {
+    /** The options the chart was made with, with the finalists: pass changes to `draw`. */
+    options: RoadOptions;
+    /** The chart's accessible name, in the chart's language. */
+    title: string;
+    /** What the chart shows, in a sentence or two, for a caption. */
+    summary: string;
+    /** The numbers behind it. */
+    totals: RoadTotals;
+    /** The drawing as an SVG string. `extra` is laid over the options (`size`, `theme`, `language`, `labels`, `final`...). */
+    draw(extra?: Partial<RoadOptions>): string;
+    /** One HTML table with a row for every match: the table that stands for the drawing for a screen reader. */
+    table(options?: {
+        className?: string;
+        language?: Language;
+    }): string;
+}

package/dist/road.types.js

@@ -0,0 +1 @@
+export {};

package/dist/scene-entry.d.ts

@@ -0,0 +1,7 @@
+export { sceneFromSvg, sceneOf } from "./scene.ts";
+export { sceneToSvg } from "./scene.flat.ts";
+export type { FlatOptions } from "./scene.flat.ts";
+export { pathCommands } from "./scene.path.ts";
+export { parseSvg, writeSvg } from "./scene.xml.ts";
+export type { SvgNode } from "./scene.xml.ts";
+export type { Matrix, Paint, PathCommand, Scene, SceneBase, SceneCircle, SceneClip, SceneEllipse, SceneGradient, SceneImage, SceneItem, SceneLine, SceneOptions, ScenePath, ScenePattern, ScenePoly, SceneRect, SceneShape, SceneSource, SceneStyle, SceneText } from "./scene.types.ts";

package/dist/scene-entry.js

@@ -0,0 +1,5 @@
+// A drawing as plain data: the shapes it is painted with, in order, their colours worked out for light or dark; and the SVG that needs no stylesheet.
+export { sceneFromSvg, sceneOf } from "./scene.js";
+export { sceneToSvg } from "./scene.flat.js";
+export { pathCommands } from "./scene.path.js";
+export { parseSvg, writeSvg } from "./scene.xml.js";

package/dist/scene.css.d.ts

@@ -0,0 +1,44 @@
+/** An element as the selectors see it. */
+export interface CssNode {
+    name: string;
+    attrs: Readonly<Record<string, string>>;
+    parent?: CssNode;
+}
+interface Simple {
+    tag?: string;
+    classes: string[];
+    attrs: {
+        name: string;
+        value?: string;
+    }[];
+    where: Complex[][];
+    not: Complex[][];
+}
+/** Compounds from the leftmost to the rightmost, with the combinator that joins each to the one before. */
+type Complex = {
+    combinator: " " | ">" | "";
+    simple: Simple;
+}[];
+interface Rule {
+    selector: Complex;
+    specificity: number;
+    order: number;
+    declarations: [string, string][];
+}
+/** A stylesheet's rules for one theme: those under `prefers-color-scheme` are in when the theme is that one, and the other media are out. */
+export interface Stylesheet {
+    rules: Rule[];
+}
+/** Read a stylesheet. `theme` decides which `@media (prefers-color-scheme:…)` blocks count. */
+export declare function parseStylesheet(css: string, theme: "light" | "dark", into?: Stylesheet): Stylesheet;
+/** The declarations that apply to an element, lowest priority first (by weight, then by order). */
+export declare function matched(sheet: Stylesheet, node: CssNode): [string, string][];
+/** The declarations of a `style` attribute. */
+export declare const inlineStyle: (text: string | undefined) => [string, string][];
+/** Replace every `var(--name, fallback)` in a value. A name with no value and no fallback makes the whole value `undefined` (the property is not set). */
+export declare function substitute(value: string, vars: Readonly<Record<string, string>>, depth?: number): string | undefined;
+/** A value with its lengths worked out: `px` dropped, `em` multiplied by the font size, and every `calc()` replaced by its number. */
+export declare function evaluate(value: string, fontSize: number): string;
+/** A length or a number as a number of user units: `3`, `3px`, `.14em` (of the font size), and `calc()` of a product, sum or difference of those. */
+export declare function lengthOf(value: string | undefined, fontSize: number): number | undefined;
+export {};