@the-inclusionist/engine 8.0.0 → 10.0.0

package/dist-pkg/render/viewports.js

@@ -1,59 +1,82 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// render/viewports — a FÁBRICA de imagem dos modos de visão acessível: como um MODO vira PIXEL.
+// render/viewports — the IMAGE FACTORY of the accessible vision modes: how a MODE becomes a PIXEL.
 //
-// Par de render/viz-setters, que levou a POLÍTICA ("qual modo vale onde": por jogador, global, overlays, painéis).
-// Aqui mora a outra metade — a produção do pixel em si, que a política consome:
-//   · `pixiFilterFor`  — modo → filtro GPU do viewport (daltonismo, cegueira, baixa visão)
-//   · `parallaxTexFor` — camada de fundo i, recolorida (ou não) para o modo
-//   · `treeTexFor`     — decoração de fundo, idem
-//   · `playerVizTex`   — quadro do jogador com contorno escuro no alto contraste
-//   · `lvOverlay*` / `renderVpOverlay` — a névoa/túnel/mancha de baixa visão DENTRO da render-texture do viewport
-// Os quatro primeiros entravam em viz-setters por injeção (`parallaxTexFor`/`treeTexFor`/`playerVizTex`/
-// `pixiFilterFor` no `VizSettersCtx`) enquanto ainda moravam no game.js; a partir daqui quem os fornece é este
-// módulo. Ver docs/5-Refactoring/plano-modularizacao-mapa.md (B2).
+// The pair of render/viz-setters, which holds the POLICY ("which mode counts where": per player, global, overlays,
+// panels). Here lives the other half — producing the pixel itself, which the policy consumes:
+//   · `pixiFilterFor`  — mode → the viewport's GPU filter (colour blindness, blindness, low vision)
+//   · `parallaxTexFor` — background layer i, recoloured (or not) for the mode
+//   · `treeTexFor`     — background decoration, likewise
+//   · `playerVizTex`   — the player's frame with a dark outline in high contrast
+//   · `lvOverlay*` / `renderVpOverlay` — low vision's haze/tunnel/spot INSIDE the viewport's render texture
 //
-// A DUPLICAÇÃO QUE ESTA EXTRAÇÃO CUROU: as seis matrizes de daltonismo estavam escritas duas vezes — como
-// `<feColorMatrix>` no app/index.html (caminho de tela única) e como `PIXI.ColorMatrixFilter` dentro de
-// `pixiFilterFor` (caminho multi-tela). Saíram para render/cvd-matrices (folha, zero deps); `pixiFilterFor` lê
-// de lá e `initViewports` GERA os `<filter>` do documento de lá também. O sintoma da divergência era silencioso
-// e de acessibilidade: a mesma pessoa daltônica veria cores diferentes em tela única e em multi-tela.
+// THE DUPLICATION THIS CURES: the six colour-blindness matrices were once written twice — as `<feColorMatrix>` in a
+// page's HTML (the single-screen path) and as a `PIXI.ColorMatrixFilter` (the multi-screen path). They live in
+// render/cvd-matrices (a leaf, zero deps); `pixiFilterFor` reads from there and `initViewports` GENERATES the document's
+// `<filter>`s from there too. A divergence would be silent and about accessibility: the same colour-blind person would
+// see different colours on one screen and on several.
 //
-// Fronteiras que este módulo NÃO reabre:
-//  · `parallaxTexNormal` e `treeTexNormal` (as texturas CRUAS, fonte do recolor) continuam nascendo no game.js
-//    — a primeira é preenchida por `setCenario` (carrega PNG por tema), a segunda pelo desenho procedural da
-//    árvore. Entram injetadas. `parallaxTexNormal` é `const` cujos ELEMENTOS `setCenario` troca in place → entra
-//    por VALOR (o array é o mesmo objeto); `vpTex` é `let` que `configureRender` REATRIBUI a cada troca de nº de
-//    telas → entra por GETTER.
-//  · `lvOverlaySpr` e o renderer são objetos PIXI criados no game.js e entram por interface ESTRUTURAL, para o
-//    módulo rodar no project `node` sem importar PIXI. Mesmo precedente de render/scene-sky e game/traffic.
-//  · `_lastSharedViz` NÃO é daqui (é o registro do render estático, fica no game.js) — ver o topo de viz-setters.
+// Boundaries this module does NOT reopen:
+//  · `parallaxTexNormal` and the tree texture (the RAW textures, the recolour's source) are born in the host — the
+//    first filled by the host's scenery loader (a PNG per theme), the second by its procedural drawing. They come in
+//    injected. `parallaxTexNormal` is an array whose ELEMENTS the host swaps in place → it comes in by VALUE (the array
+//    is the same object); the viewport textures are REASSIGNED whenever the number of screens changes → by GETTER.
+//  · The overlay sprite and the renderer are PIXI objects the host creates and come in through a STRUCTURAL
+//    interface, so the module runs in the `node` project without importing PIXI.
 //
-// POR QUE `getTreeTexNormal`/`getLvOverlaySpr` são GETTERS e não valores, sendo os dois `const` no game.js:
-// não é reatribuição, é ORDEM DE BOOT. `clearParallaxTexCache` precisa existir dentro de `setCenario`, que o
-// game.js chama no topo do módulo (na restauração do cenário salvo) — bem ANTES de `treeTexNormal` e
-// `lvOverlaySpr` serem declarados. Com getters, `initViewports` pode ser chamado cedo o bastante para aquela
-// chamada não cair em TDZ; com valores, o `const` ainda não inicializado derrubaria a restauração do tema
-// dentro de um `try/catch` que apenas cai para 'cidade' — o jogador perderia o cenário escolhido em silêncio.
+// WHY `getTreeTexNormal`/`getLvOverlaySpr` are GETTERS and not values: BOOT ORDER, not reassignment. A host may call
+// `clearParallaxTexCache` while restoring a saved scenery before those objects exist; with getters, `initViewports`
+// can be called early enough for that call to work, where a value would be read before it exists — and a scenery
+// restore inside a `try/catch` that falls back to a default would lose the chosen scenery silently.
 //
-// SEM I/O no import: nada de makeCanvas/tex no corpo do módulo (precedente de render/textures). O único efeito
-// de `initViewports` é gerar os `<filter>` SVG, que é justamente o ponto da cura da duplicação.
+// NO I/O on import: no makeCanvas/tex in the module body. `initViewports`'s one effect is generating the SVG `<filter>`s,
+// which is precisely the point of curing the duplication.
 import { LOGICAL_W, LOGICAL_H } from '../core/constants.js';
 import { makeCanvas, tex } from './canvas.js';
-import { DIRECT_CFG, directBgTexture, directSpriteTexture } from './high-contrast.js';
+import { DIRECT_CFG } from './high-contrast.js';
 import { VIZ_BY_KEY } from './viz-modes.js';
+import { drawLowVision } from './low-vision-drawing.js';
 import { CVD_MATRIX, installCvdFilters } from './cvd-matrices.js';
+/**
+ * The modes a COLOUR MATRIX draws, besides colour vision (which reads the single source, `CVD_MATRIX`). Blindness is
+ * brightness 0 NOT multiplied — black, not darkened; the cataract's haze is contrast lowered and THEN a multiplied
+ * brightness, and the order is the effect.
+ */
+const MATRIX_OF = {
+    blind: (c) => { c.brightness(0, false); },
+    'lv-haze': (c) => { c.contrast(-0.45, false); c.brightness(1.12, true); },
+};
+/** The modes a BLUR draws, and how strong. The tunnel and the spots are also drawn as a texture on top (`renderVpOverlay`). */
+const BLUR_OF = { 'lv-blur': 5, 'lv-tunnel': 1.5, 'lv-diabetic': 2, 'lv-macular': 2 };
+/**
+ * A mode's viewport filter, or `null` for a mode with none — and for one whose PIXI constructor is missing, which falls back
+ * to no filter instead of throwing. High contrast is never here: it is a texture, not a filter.
+ */
+function filterFor(mode, CM, BL) {
+    const cvd = CVD_MATRIX[mode]; // the single source: the SAME numbers that build the HTML `<feColorMatrix>`
+    // a COPY of the matrix: holding the module's array, the filter's own calls would rewrite the source every mode reads
+    const paint = cvd ? (c) => { c.matrix = cvd.slice(); } : MATRIX_OF[mode];
+    if (paint)
+        return CM ? [matrixWith(CM, paint)] : null;
+    const strength = BLUR_OF[mode];
+    return strength !== undefined && BL ? [new BL(strength)] : null;
+}
+function matrixWith(CM, paint) {
+    const c = new CM();
+    paint(c);
+    return c;
+}
 export function initViewports(ctx) {
-    // Gera os seis <filter> de daltonismo do documento a partir de render/cvd-matrices — a MESMA fonte que
-    // pixiFilterFor lê logo abaixo. É por isso que tela única e multi-tela não podem mais divergir.
+    // Generates the document's six colour-blindness <filter>s from render/cvd-matrices — the SAME source pixiFilterFor
+    // reads just below. That is why one screen and several can no longer diverge.
     installCvdFilters(ctx.cvdDefsHost);
-    /* ===================== fundo: parallax e decoração ===================== */
+    /* ===================== background: parallax and decoration ===================== */
     const _parallaxTexHC = {}; // {mode: [tex,tex,tex]}
     function parallaxTexFor(i, mode) {
         if (DIRECT_CFG[mode]) {
             (_parallaxTexHC[mode] = _parallaxTexHC[mode] || []);
             if (!_parallaxTexHC[mode][i])
-                _parallaxTexHC[mode][i] = directBgTexture(ctx.parallaxTexNormal[i], mode);
-            return _parallaxTexHC[mode][i]; // direto: fundo recua
+                _parallaxTexHC[mode][i] = ctx.hc.directBgTexture(ctx.parallaxTexNormal[i], mode);
+            return _parallaxTexHC[mode][i]; // direct: the background steps back
         }
         return ctx.parallaxTexNormal[i];
     }
@@ -63,14 +86,14 @@ export function initViewports(ctx) {
     function treeTexFor(mode) {
         if (DIRECT_CFG[mode]) {
             if (!_treeTexHC[mode])
-                _treeTexHC[mode] = directBgTexture(ctx.getTreeTexNormal(), mode);
-            return _treeTexHC[mode]; // direto: decoração recua
+                _treeTexHC[mode] = ctx.hc.directBgTexture(ctx.getTreeTexNormal(), mode);
+            return _treeTexHC[mode]; // direct: the decoration steps back
         }
         return ctx.getTreeTexNormal();
     }
-    /* ===================== frente: o jogador ===================== */
-    // {mode: Map<texturaBase, texturaComContorno>} — chaveado pela textura de ORIGEM porque o jogador troca de
-    // quadro toda frame; um Map por modo evita recontornar o mesmo quadro a cada volta da animação.
+    /* ===================== foreground: the player ===================== */
+    // {mode: Map<baseTexture, outlinedTexture>} — keyed by the SOURCE texture because the player changes frame every tick;
+    // a Map per mode avoids outlining the same frame again on every loop of the animation.
     let _playerDirect = {};
     function playerVizTex(base, mode) {
         if (!base)
@@ -78,94 +101,40 @@ export function initViewports(ctx) {
         if (DIRECT_CFG[mode]) {
             const mm = (_playerDirect[mode] = _playerDirect[mode] || new Map());
             if (!mm.has(base))
-                mm.set(base, directSpriteTexture(base, mode));
-            return mm.get(base); // direto: player com contorno escuro → salta
+                mm.set(base, ctx.hc.directSpriteTexture(base, mode));
+            return mm.get(base); // direct: the player with a dark outline → it jumps out
         }
         return base;
     }
     function clearPlayerDirectCache() { _playerDirect = {}; }
-    /* ===================== o filtro do viewport ===================== */
-    // Cacheado por MODO e por identidade: o mesmo array de filtros volta sempre, então trocar de viewport não
-    // reconstrói o filtro (nem invalida o shader do PIXI). Guarda `null` também — `mode in cache` e não
-    // `cache[mode]` — para que modo sem filtro (normal, hc-*) não seja reprocessado a cada frame.
+    /* ===================== the viewport's filter ===================== */
+    // Cached per MODE and by identity: the same filter array always comes back, so switching viewport does not rebuild the
+    // filter (nor invalidate PIXI's shader). It keeps `null` too — `mode in cache` and not `cache[mode]` — so a mode with
+    // no filter (normal, hc-*) is not reprocessed every frame.
     const _vpFilterCache = {};
     function pixiFilterFor(mode) {
         if (mode in _vpFilterCache)
             return _vpFilterCache[mode];
-        let f = null;
-        const CM = ctx.ColorMatrixFilter, BL = ctx.BlurFilter;
-        const cvd = CVD_MATRIX[mode]; // fonte única: os MESMOS números que geram o <feColorMatrix> do HTML
-        if (cvd && CM) {
-            const c = new CM();
-            c.matrix = cvd.slice();
-            f = [c];
-        } // slice: o filtro não fica com o array do módulo
-        else if (mode === 'blind' && CM) {
-            const c = new CM();
-            c.brightness(0, false);
-            f = [c];
-        }
-        else if (mode === 'lv-blur' && BL) {
-            f = [new BL(5)];
-        }
-        else if (mode === 'lv-haze' && CM) {
-            const c = new CM();
-            c.contrast(-0.45, false);
-            c.brightness(1.12, true);
-            f = [c];
-        }
-        else if ((mode === 'lv-tunnel' || mode === 'lv-diabetic' || mode === 'lv-macular') && BL) {
-            f = [new BL(mode === 'lv-tunnel' ? 1.5 : 2)];
-        }
-        return _vpFilterCache[mode] = f;
+        return _vpFilterCache[mode] = filterFor(mode, ctx.ColorMatrixFilter, ctx.BlurFilter);
     }
-    /* ===================== baixa visão: o overlay como textura ===================== */
-    // O que o filtro GPU não sabe fazer: névoa de catarata, o túnel do glaucoma, a mancha central da degeneração
-    // macular e as manchas espalhadas da retinopatia. São desenho, não transformação de cor — vêm como textura.
+    /* ===================== low vision: the overlay as a texture ===================== */
+    // What the GPU filter cannot do: a cataract's haze, glaucoma's tunnel, macular degeneration's central spot and
+    // retinopathy's scattered spots. They are drawing, not a colour transform — they come as a texture.
     function lvOverlayCanvas(lv) {
-        const W = LOGICAL_W, H = LOGICAL_H, cv = makeCanvas(W, H), c = cv.getContext('2d'), cx = W / 2, cy = H / 2;
-        if (lv === 'haze') {
-            c.fillStyle = 'rgba(244,246,250,0.42)';
-            c.fillRect(0, 0, W, H);
-        }
-        else if (lv === 'tunnel') {
-            const g = c.createRadialGradient(cx, cy, H * 0.12, cx, cy, H * 0.6);
-            g.addColorStop(0, 'rgba(0,0,0,0)');
-            g.addColorStop(.5, 'rgba(0,0,0,.55)');
-            g.addColorStop(1, 'rgba(0,0,0,.99)');
-            c.fillStyle = g;
-            c.fillRect(0, 0, W, H);
-        }
-        else if (lv === 'macular') {
-            const g = c.createRadialGradient(cx, cy, 2, cx, cy, H * 0.34);
-            g.addColorStop(0, 'rgba(12,12,15,.95)');
-            g.addColorStop(.55, 'rgba(12,12,15,.5)');
-            g.addColorStop(1, 'rgba(12,12,15,0)');
-            c.fillStyle = g;
-            c.fillRect(0, 0, W, H);
-        }
-        else if (lv === 'diabetic') {
-            for (const [fx, fy, fr] of [[.22, .3, .1], [.64, .22, .075], [.8, .58, .11], [.4, .7, .085], [.16, .8, .07], [.54, .48, .06]]) {
-                const x = fx * W, y = fy * H, r = fr * W, g = c.createRadialGradient(x, y, 1, x, y, r);
-                g.addColorStop(0, 'rgba(10,10,14,.95)');
-                g.addColorStop(.5, 'rgba(10,10,14,.7)');
-                g.addColorStop(1, 'rgba(10,10,14,0)');
-                c.fillStyle = g;
-                c.fillRect(x - r, y - r, 2 * r, 2 * r);
-            }
-        }
+        const W = LOGICAL_W, H = LOGICAL_H, cv = makeCanvas(ctx.doc, W, H), c = cv.getContext('2d');
+        drawLowVision(c, lv, W, H); // one drawing for the viewports and for the world `createGame` declares (issue #182)
         return cv;
     }
     const _lvOverlayTex = {};
     function lvOverlayTex(lv) {
         if (lv === 'blur')
-            return null; // desfoque é filtro puro, não tem o que carimbar
+            return null; // blur is a pure filter, there is nothing to stamp
         if (!_lvOverlayTex[lv])
             _lvOverlayTex[lv] = tex(lvOverlayCanvas(lv));
         return _lvOverlayTex[lv];
     }
-    // Overlay DENTRO da render-texture (a bolinha indicadora do viewport fica por cima, FORA do filtro — é por
-    // isso que ela continua visível no modo cegueira; ver updateVpDots em render/viz-setters).
+    // The overlay INSIDE the render texture (the viewport's indicator dot sits on top, OUTSIDE the filter — which is why
+    // it stays visible in blindness mode; see updateVpDots in render/viz-setters).
     function renderVpOverlay(i, mode) {
         const m = VIZ_BY_KEY[mode];
         if (!m || m.kind !== 'lowvision')
@@ -174,7 +143,7 @@ export function initViewports(ctx) {
         if (t) {
             const spr = ctx.getLvOverlaySpr();
             spr.texture = t;
-            ctx.renderizarEm(spr, ctx.getVpTex()[i], false);
+            ctx.renderInto(spr, ctx.getVpTex()[i], false);
         }
     }
     return {

package/dist-pkg/render/viz-axes-labels.d.ts

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { type Theme, type Correction, type VisualState } from './viz-axes.js';
+/** Each theme's label. An i18n key — whoever shows it resolves it, like the rest of the menu. */
+export declare const THEME_LABEL: Readonly<Record<Theme, string>>;
+/** Each colour correction's label. */
+export declare const CORRECTION_LABEL: Readonly<Record<Correction, string>>;
+/**
+ * The SHORT labels, for the quick bar's icons — «7:1», «deuteranopia».
+ *
+ * ⚠️ THEY ARE THE KEYS THAT ALREADY EXISTED (`contrast.*`, `cvd.*`), rekeyed per axis. The quick bar speaks short
+ * because it announces ONE icon at a time, and the panel speaks in full because the child is reading a list — the
+ * difference is one of context. Reusing instead of translating again keeps the same word in both places.
+ */
+export declare const SHORT_THEME: Readonly<Record<Theme, string>>;
+export declare const SHORT_CORRECTION: Readonly<Record<Correction, string>>;
+/** The two axes, as the panel identifies them in the DOM (stored values, and so Portuguese). */
+export type VisualAxis = 'tema' | 'correcao';
+/** A translator, the same the rest of the interface gets. */
+export type Translator = (key: string, params?: Record<string, string | number>) => string;
+/**
+ * ONE axis's rows, in the radio shape the panel already uses.
+ *
+ * ⚠️ A RADIO AND NOT SEVEN BUTTONS: WITHIN an axis the values stay exclusive — one theme at a time, one correction at a
+ * time. What stopped being exclusive is the relation BETWEEN the axes, which is why they become two radios instead of
+ * one.
+ *
+ * ⚠️ AND THE VISIBLE-ROW SHAPE STAYS, not a `<select>`. The visual panel records the mistake the Dev caught on the first
+ * attempt: inside a closed box, a control whose reason to exist is to be FOUND by whoever sees poorly becomes «quase o
+ * mesmo que não ter movido».
+ */
+export declare function axisRows(axisName: VisualAxis, options: readonly string[], optionLabels: Readonly<Record<string, string>>, selected: string, t: Translator): string;
+/**
+ * The TWO axes, one after the other, with a title each.
+ *
+ * The title exists because two unnamed radios in a row are one radio of eight for whoever reads fast — and that reading
+ * is exactly the misunderstanding the split exists to undo.
+ */
+export declare function axesHtml(v: VisualState, t: Translator): string;
+/** What a click on a panel button means. `null` when the button belongs to no axis. */
+export interface AxisChoice {
+    readonly axis: VisualAxis;
+    readonly value: string;
+}
+export declare function buttonChoice(dataset: {
+    eixo?: string;
+    valor?: string;
+}): AxisChoice | null;

package/dist-pkg/render/viz-axes-labels.js

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// render/viz-axes-labels — THE VISUAL MENU WITH TWO CONTROLS (ADR-0076, issue #104), the pure half.
+//
+// ========================= WHY TWO CONTROLS AND NOT ONE =========================
+// A SINGLE control was the honest way to state a REAL exclusivity while `p.viz` kept ONE value: two separate controls
+// would overwrite each other silently — the child would pick the correction, then the contrast, and lose the correction
+// with nothing saying so. ⚠️ THAT REASON IS GONE: `p.viz` keeps two axes plus the simulation, and the per-axis writers
+// (`setPlayerTheme`/`setPlayerCorrection`) change one without touching the other. Keeping the single control would state
+// an exclusivity that no longer exists — and keep denying both to whoever needs both.
+//
+// ========================= THE DEFAULTS' NAMES ARE A DECISION, NOT ROUTINE =========================
+// ⚠️ «Tema padrão» and «Visão tricromática», and ADR-0076 closes its *definition of done* with the rule that chose them:
+// **no default label diagnoses the reader**. `modo sem deficiência visual` was offered and refused — it tells the child
+// what they are NOT, in the menu they opened to be able to play. A default is named by what it IS.
+//
+// And `Modo padrão` (`viz.normal`) does not serve here: it was the SHARED neutral from when the two axes were one. With
+// two controls, a «padrão» that does not say the default of WHAT is ambiguous in both.
+//
+// A pure module: it returns HTML and i18n keys and touches no document. `render/viz-setters`, in the same layer,
+// mounts it (issue #167).
+import { THEMES, CORRECTIONS } from './viz-axes.js';
+/** Each theme's label. An i18n key — whoever shows it resolves it, like the rest of the menu. */
+export const THEME_LABEL = Object.freeze({
+    padrao: 'eixo.tema.padrao',
+    hc3: 'viz.hc-direto',
+    hc45: 'viz.hc-direto-45',
+    hc7: 'viz.hc-direto-7',
+});
+/** Each colour correction's label. */
+export const CORRECTION_LABEL = Object.freeze({
+    tricro: 'eixo.correcao.tricro',
+    protan: 'viz.fix-protan',
+    deuter: 'viz.fix-deuter',
+    tritan: 'viz.fix-tritan',
+});
+/**
+ * The SHORT labels, for the quick bar's icons — «7:1», «deuteranopia».
+ *
+ * ⚠️ THEY ARE THE KEYS THAT ALREADY EXISTED (`contrast.*`, `cvd.*`), rekeyed per axis. The quick bar speaks short
+ * because it announces ONE icon at a time, and the panel speaks in full because the child is reading a list — the
+ * difference is one of context. Reusing instead of translating again keeps the same word in both places.
+ */
+export const SHORT_THEME = Object.freeze({
+    padrao: 'contrast.off', hc3: 'contrast.3', hc45: 'contrast.45', hc7: 'contrast.7',
+});
+export const SHORT_CORRECTION = Object.freeze({
+    tricro: 'cvd.off', protan: 'cvd.protan', deuter: 'cvd.deuter', tritan: 'cvd.tritan',
+});
+/**
+ * ONE axis's rows, in the radio shape the panel already uses.
+ *
+ * ⚠️ A RADIO AND NOT SEVEN BUTTONS: WITHIN an axis the values stay exclusive — one theme at a time, one correction at a
+ * time. What stopped being exclusive is the relation BETWEEN the axes, which is why they become two radios instead of
+ * one.
+ *
+ * ⚠️ AND THE VISIBLE-ROW SHAPE STAYS, not a `<select>`. The visual panel records the mistake the Dev caught on the first
+ * attempt: inside a closed box, a control whose reason to exist is to be FOUND by whoever sees poorly becomes «quase o
+ * mesmo que não ter movido».
+ */
+export function axisRows(axisName, options, optionLabels, selected, t) {
+    return options.map((valueName) => {
+        const sel = valueName === selected;
+        return `<div class="ctrl-row"><span><strong>${t(optionLabels[valueName])}</strong></span>`
+            + `<button class="mode-btn${sel ? ' is-on' : ''}" role="radio" aria-checked="${sel}"`
+            + ` data-eixo="${axisName}" data-valor="${valueName}" type="button">${sel ? t('viz.escolhido') : t('viz.escolher')}</button></div>`;
+    }).join('');
+}
+/**
+ * The TWO axes, one after the other, with a title each.
+ *
+ * The title exists because two unnamed radios in a row are one radio of eight for whoever reads fast — and that reading
+ * is exactly the misunderstanding the split exists to undo.
+ */
+export function axesHtml(v, t) {
+    return `<h3 class="opt-sub">${t('eixo.tema.titulo')}</h3>`
+        + axisRows('tema', THEMES, THEME_LABEL, v.tema, t)
+        + `<h3 class="opt-sub">${t('eixo.correcao.titulo')}</h3>`
+        + axisRows('correcao', CORRECTIONS, CORRECTION_LABEL, v.correcao, t);
+}
+export function buttonChoice(dataset) {
+    const { eixo: axisName, valor: valueName } = dataset;
+    if (axisName !== 'tema' && axisName !== 'correcao')
+        return null;
+    if (!valueName)
+        return null;
+    const allowed = axisName === 'tema' ? THEMES : CORRECTIONS;
+    return allowed.includes(valueName) ? { axis: axisName, value: valueName } : null;
+}