@sylad/cadence 1.8.0 → 1.10.0

package/dist/ref/evaluate.js

@@ -0,0 +1,241 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { RafError } from '../plan.js';
+import { TYPES, checkInventaire, readInventaire } from './check.js';
+const norm = (v) => {
+    const s = String(v ?? '').normalize('NFC').toLowerCase().replace(/\s+/g, ' ').trim();
+    return /^-?\d+(\.\d+)?$/.test(s) ? String(Number(s)) : s;
+};
+/** Le libellé d'un `texte` est verbatim : seuls les blancs sont normalisés, la casse compte (`120 KT` n'est pas `120 kt`). */
+const normTexte = (v) => String(v ?? '').normalize('NFC').replace(/\s+/g, ' ').trim();
+const noms = (xs, cle) => (Array.isArray(xs) ? xs.map((x) => norm(x?.[cle])) : []);
+/** Ce qui désigne un élément, indépendamment de son id, de sa zone et de sa confiance : deux lectures indépendantes numérotent à leur façon. */
+export function identite(e, parId) {
+    const cible = (id) => {
+        const t = typeof id === 'string' ? parId.get(id) : undefined;
+        return t ? `${t.type}:${identite(t, new Map())}` : '?';
+    };
+    switch (e.type) {
+        case 'ecran':
+            return 'ecran';
+        case 'composant':
+            return `${norm(e.role)}|${norm(e.contenu)}`;
+        case 'etat':
+            return `${norm(e.nom)}>${cible(e.cible)}`;
+        case 'texte':
+            return normTexte(e.libelle);
+        case 'statut':
+            return norm(e.libelle);
+        case 'jeton':
+            return `${norm(e.categorie)}=${norm(e.valeur)}`;
+        case 'table':
+            return e.colonnes.map(norm).join('|');
+        case 'gabarit':
+            return norm(e.nom);
+        case 'schema':
+            return noms(e.noeuds, 'libelle').sort().join('|');
+        case 'lien':
+            return norm(e.figure);
+        default:
+            return norm(e.question);
+    }
+}
+/** Ce que l'élément affirme une fois retrouvé : une identité juste avec une affirmation fausse est un faux lu, pas un rappel. */
+export function affirmation(e, parId) {
+    switch (e.type) {
+        case 'ecran':
+            return String(e.largeur_reference);
+        case 'texte':
+            return norm(e.role);
+        case 'table':
+            return JSON.stringify(e.lignes.map((l) => l.map(norm)));
+        case 'gabarit':
+            return JSON.stringify(e.champs.map((c) => [norm(c.nom), c.obligatoire, norm(c.format), c.min ?? null, c.max ?? null]));
+        case 'schema': {
+            const libelle = new Map(e.noeuds.map((n) => [n.id, norm(n.libelle)]));
+            return JSON.stringify(e.flux.map((f) => `${libelle.get(f.de)}>${libelle.get(f.vers)}:${norm(f.libelle)}:${f.direction}`).sort());
+        }
+        case 'lien':
+            return String(e.constat);
+        case 'statut':
+            return JSON.stringify(e.couvre.map((id) => {
+                const t = parId.get(id);
+                return t ? `${t.type}:${identite(t, new Map())}` : '?';
+            }).sort());
+        default:
+            return '';
+    }
+}
+const compteVide = () => ({ attendus: 0, lus: 0, justes: 0, sures: 0, faux_lu: 0 });
+const ratio = (a, b) => (b === 0 ? null : a / b);
+/** Apparie lus et attendus par type et identité, un attendu une seule fois ; les appariements à l'affirmation exacte passent d'abord. */
+export function evaluerCas(nom, attendu, lecture) {
+    const types = {};
+    const compte = (t) => (types[t] ??= compteVide());
+    const parIdAttendu = new Map(attendu.elements.map((e) => [e.id, e]));
+    const lus = lecture ? lecture.elements : [];
+    const parIdLu = new Map(lus.map((e) => [e.id, e]));
+    const trouve = new Set();
+    const juste = new Set();
+    const justeAtt = new Set();
+    const libre = new Set(attendu.elements);
+    const cle = (e, par) => `${e.type}\u0000${identite(e, par)}`;
+    const apparier = (exact) => {
+        for (const lu of lus) {
+            if (juste.has(lu) || trouve.has(lu))
+                continue;
+            for (const att of libre) {
+                if (cle(att, parIdAttendu) !== cle(lu, parIdLu))
+                    continue;
+                const pareil = affirmation(att, parIdAttendu) === affirmation(lu, parIdLu);
+                if (exact && !pareil)
+                    continue;
+                libre.delete(att);
+                trouve.add(lu);
+                if (pareil) {
+                    juste.add(lu);
+                    justeAtt.add(att);
+                }
+                break;
+            }
+        }
+    };
+    apparier(true);
+    apparier(false);
+    for (const e of attendu.elements)
+        compte(e.type).attendus++;
+    for (const lu of lus) {
+        const c = compte(lu.type);
+        c.lus++;
+        if (lu.confiance !== 'incertain')
+            c.sures++;
+        if (juste.has(lu))
+            c.justes++;
+        else if (lu.confiance !== 'incertain')
+            c.faux_lu++;
+    }
+    const parPiege = new Map();
+    for (const e of attendu.elements) {
+        if (typeof e.piege !== 'string')
+            continue;
+        const p = parPiege.get(e.piege) ?? { piege: e.piege, attendus: 0, trouves: 0 };
+        p.attendus++;
+        if (justeAtt.has(e))
+            p.trouves++;
+        parPiege.set(e.piege, p);
+    }
+    const tokens = typeof lecture?.usage?.tokens === 'number' && lecture.usage.tokens >= 0 ? lecture.usage.tokens : null;
+    return { cas: nom, lecture: lecture !== null, pages: Number.isInteger(attendu.pages) && attendu.pages > 0 ? attendu.pages : null, tokens, types, pieges: [...parPiege.values()] };
+}
+function taux(c) {
+    return { ...c, rappel: ratio(c.justes, c.attendus), precision: ratio(c.justes, c.lus), taux_faux_lu: ratio(c.faux_lu, c.sures) };
+}
+/** Additionne les cas : par type, au total, par piège (même nom d'un cas à l'autre) et en tokens par page (cas qui ont une mesure seulement). */
+export function agreger(cas) {
+    const types = {};
+    const total = compteVide();
+    const pieges = new Map();
+    let tokens = null;
+    let pages = 0;
+    const exclus = [];
+    for (const r of cas) {
+        for (const [t, c] of Object.entries(r.types)) {
+            const a = (types[t] ??= compteVide());
+            for (const k of Object.keys(a)) {
+                a[k] += c[k];
+                total[k] += c[k];
+            }
+        }
+        for (const p of r.pieges) {
+            const a = pieges.get(p.piege) ?? { piege: p.piege, attendus: 0, trouves: 0 };
+            a.attendus += p.attendus;
+            a.trouves += p.trouves;
+            pieges.set(p.piege, a);
+        }
+        if (r.tokens !== null && r.pages === null)
+            exclus.push(r.cas);
+        else if (r.tokens !== null && r.pages !== null) {
+            tokens = (tokens ?? 0) + r.tokens;
+            pages += r.pages;
+        }
+    }
+    const ordre = (t) => TYPES.indexOf(t);
+    const triee = Object.fromEntries(Object.entries(types).sort(([a], [b]) => ordre(a) - ordre(b)).map(([t, c]) => [t, taux(c)]));
+    return {
+        total: taux(total),
+        types: triee,
+        pieges: [...pieges.values()],
+        tokens: tokens === null || pages === 0 ? { total: null, pages: null, par_page: null, exclus } : { total: tokens, pages, par_page: tokens / pages, exclus },
+        cas,
+    };
+}
+const pct = (x) => (x === null ? 'n/a' : `${Number((x * 100).toFixed(1))} %`);
+export function formatEvaluation(ev) {
+    const t = ev.total;
+    const lignes = [
+        `${ev.cas.length} cas · ${t.attendus} éléments attendus · ${t.lus} lus`,
+        `rappel : ${pct(t.rappel)} (${t.justes}/${t.attendus}) · précision : ${pct(t.precision)} (${t.justes}/${t.lus})`,
+        `faux lu : ${pct(t.taux_faux_lu)} (${t.faux_lu}/${t.sures} sûrs)`,
+        ev.tokens.par_page === null ? 'tokens par page : non mesurés' : `tokens par page : ${Number(ev.tokens.par_page.toFixed(1))} (${ev.tokens.total} sur ${ev.tokens.pages} pages)`,
+    ];
+    if (ev.tokens.exclus.length > 0)
+        lignes.push(`tokens par page : ${ev.tokens.exclus.length} cas sans \`pages\` exclus (${ev.tokens.exclus.join(', ')})`);
+    lignes.push('par type :');
+    for (const [type, c] of Object.entries(ev.types))
+        lignes.push(`  ${type.padEnd(10)} rappel ${pct(c.rappel)} (${c.justes}/${c.attendus}) · précision ${pct(c.precision)} (${c.justes}/${c.lus}) · faux lu ${c.faux_lu}/${c.sures}`);
+    if (ev.pieges.length > 0) {
+        lignes.push('pièges :');
+        for (const p of ev.pieges)
+            lignes.push(`  ${p.trouves === p.attendus ? '✓' : '✗'} ${p.piege} : ${p.trouves}/${p.attendus}`);
+    }
+    const sans = ev.cas.filter((c) => !c.lecture).map((c) => c.cas);
+    if (sans.length > 0)
+        lignes.push(`sans lecture : ${sans.join(', ')}`);
+    return lignes;
+}
+function charger(path, genres, role) {
+    const doc = readInventaire(path);
+    const problems = checkInventaire(doc);
+    if (problems.length > 0)
+        throw new RafError(`ref eval : ${role} ${path} n'est pas valide (${problems.length} écart(s), voir cadence ref check) : ${problems[0]}`);
+    if (!genres.includes(doc.genre))
+        throw new RafError(`ref eval : ${role} ${path} doit être ${genres.length === 1 ? `un ${genres[0]}` : `une lecture ou un inventaire`}, pas « ${doc.genre} »`);
+    return doc;
+}
+/** Les cas d'un chemin : un fichier est un cas, un dossier en a un par sous-dossier qui porte `fichier` (ordre alphabétique). */
+function cheminsDeCas(chemin, fichier) {
+    if (!existsSync(chemin))
+        throw new RafError(`ref : fichier introuvable : ${chemin}`);
+    if (!statSync(chemin).isDirectory())
+        return [{ nom: 'document', fichier: chemin }];
+    return readdirSync(chemin)
+        .sort()
+        .filter((n) => existsSync(join(chemin, n, fichier)))
+        .map((n) => ({ nom: n, fichier: join(chemin, n, fichier) }));
+}
+/** `ref eval <attendu> <lecture>` : deux fichiers, ou deux dossiers (`<cas>/attendu.json`, `<cas>/lecture.json`). */
+export function evaluer(attendu, lecture) {
+    const attendus = cheminsDeCas(attendu, 'attendu.json');
+    const lecturesTrouvees = cheminsDeCas(lecture, 'lecture.json');
+    const dossier = statSync(attendu).isDirectory();
+    // un fichier contre un dossier ne s'apparie à aucun cas : la lecture serait ignorée, la mesure fausse
+    if (dossier !== statSync(lecture).isDirectory()) {
+        throw new RafError(`ref eval : combinaisons acceptées : deux fichiers (attendu.json lecture.json) ou deux dossiers (<cas>/attendu.json, <cas>/lecture.json) ; reçu ${dossier ? 'un dossier et un fichier' : 'un fichier et un dossier'}`);
+    }
+    if (dossier && attendus.length === 0)
+        throw new RafError(`ref eval : aucun attendu.json dans les sous-dossiers de ${attendu}`);
+    const lectures = new Map(lecturesTrouvees.map((c) => [c.nom, c.fichier]));
+    const cas = attendus.map((a) => {
+        const att = charger(a.fichier, ['inventaire'], "l'attendu");
+        const fichier = dossier ? lectures.get(a.nom) : lecture;
+        if (fichier === undefined)
+            return evaluerCas(a.nom, att, null);
+        const lu = charger(fichier, ['lecture', 'inventaire'], 'la lecture');
+        if (lu.document.slug !== att.document.slug)
+            throw new RafError(`ref eval : le slug de la lecture (${lu.document.slug}) n'est pas celui de l'attendu (${att.document.slug})`);
+        if (lu.document.sha256 !== att.document.sha256)
+            throw new RafError(`ref eval : l'empreinte de la lecture n'est pas celle de l'attendu pour ${att.document.slug} : pas la même version du document`);
+        return evaluerCas(a.nom, att, lu);
+    });
+    return agreger(cas);
+}

package/dist/ref/figures.js

@@ -0,0 +1,252 @@
+const WORDS = {
+    figure: { kind: 'figure', word: 'Figure' },
+    figures: { kind: 'figure', word: 'Figure' },
+    fig: { kind: 'figure', word: 'Figure' },
+    figs: { kind: 'figure', word: 'Figure' },
+    table: { kind: 'table', word: 'Table' },
+    tables: { kind: 'table', word: 'Table' },
+    tableau: { kind: 'table', word: 'Tableau' },
+    tableaux: { kind: 'table', word: 'Tableau' },
+    planche: { kind: 'planche', word: 'Planche' },
+    planches: { kind: 'planche', word: 'Planche' },
+};
+const NUMBER = String.raw `[A-Z]{0,2}[-.]?\d+(?:[.-](?:\d+|[A-Z](?![a-z])))*[a-z]?`;
+/** Ce qui joint les deux bornes d'une plage : « 4 to 6 », « 4 à 6 », « 2–4 » (demi-cadratin collé aux numéros). Un tiret entouré d'espaces ou un cadratin (« 3—10 stations ») est une incise de prose. */
+const RANGE = String.raw `(?:\s+(?:to|à)\s+|–)`;
+/** Ce qui sépare deux numéros d'une énumération au pluriel : « 2, 3 », « 2 and 3 », plus les plages. */
+const SEPARATOR = String.raw `(?:\s*,\s*(?:(?:and|et)\s+)?|\s+(?:and|et|&)\s+|${RANGE})`;
+const REFERENCE = new RegExp(String.raw `\b(Figures?|Figs?|Tables?|Tableaux|Tableau|Planches?)\.?\s+(${NUMBER}(?:${SEPARATOR}${NUMBER})*)(?![\w])`, 'gi');
+const PLURAL = /^(?:figures|figs|tables|tableaux|planches)$/i;
+const NUMBER_ONLY = new RegExp(NUMBER, 'g');
+/** Ce qui précède une référence qui n'en est pas une : « code figure 3 », « indicator figures 1 to 6 » des normes OMM sont des valeurs de code, pas des figures. */
+const CODE_FIGURE = /\b(?:code|indicator)\s+$/i;
+/** « code figure 17 » plus haut dans la même phrase (la phrase finit à un point, un point-virgule ou un deux-points suivi d'un blanc) : il porte une plage au demi-cadratin (« … over figures 20–49 »). */
+const CODE_FIGURE_IN_SENTENCE = /\bcode\s+figures?\b/i;
+const SENTENCE_END = /[.;:!?]\s/;
+/** « Figure n » en début de ligne, puis le séparateur éventuel (tiret, deux-points, point) et le reste de la ligne. */
+const CAPTION = new RegExp(String.raw `^(Figure|Fig|Table|Tableau|Planche)\.?\s+(${NUMBER})(?![\w])\s*([:.–—-])?\s*(.*)$`, 'i');
+/** Le reste d'une ligne qui n'est qu'une parenthèse fermée : « (in accordance with 4.3.11) ». */
+const WHOLE_PARENTHESIS = /^\([^()]*\)$/;
+const DEICTIC = /\b(as shown (?:below|above)|shown (?:below|above)|illustrated (?:below|above)|ci-(?:dessous|dessus))\b/i;
+/** Points de conduite d'un sommaire : « Figure 1 Titre ..... 12 ». */
+const LEADER = /\.{4,}|(?:\.\s){4,}/;
+/** Numéro de page en fin de titre d'un sommaire sans points de conduite : « Figure 1 Titre 12 » (le titre est « Titre 12 », le numéro de la figure n'en est pas un). */
+const TRAILING_PAGE = /(?:^|\s)(\d{1,4})\s*$/;
+/** Lignes courantes du document : en-têtes et pieds de page, c'est-à-dire les deux premières et les deux dernières lignes d'une page, chiffres mis à part, qui reviennent sur trois pages au moins. */
+function runningLines(pages) {
+    const normal = (text) => text.trim().replace(/\d+/g, '#');
+    const pagesOf = new Map();
+    for (const p of pages)
+        for (const t of new Set([...p.lines.slice(0, 2), ...p.lines.slice(-2)].map((l) => normal(l.text))))
+            pagesOf.set(t, (pagesOf.get(t) ?? 0) + 1);
+    return (text) => (pagesOf.get(normal(text)) ?? 0) >= 3;
+}
+/**
+ * Dernière ligne de texte avant la ligne `i` de la page `pi`, sans les lignes courantes ni les lignes vides ; elle remonte sur la page
+ * qui précède immédiatement (numéro consécutif) : « code » peut finir une page, suivi de son pied de page et de l'en-tête de la suivante.
+ */
+function precedingText(pages, pi, i, running) {
+    let page = pages[pi];
+    for (let k = pi, j = i - 1;; j--) {
+        if (j < 0) {
+            const prev = pages[k - 1];
+            if (!prev || prev.n !== page.n - 1)
+                return '';
+            page = prev;
+            k--;
+            j = prev.lines.length - 1;
+            if (j < 0)
+                continue;
+        }
+        const text = page.lines[j].text;
+        if (text.trim() !== '' && !running(text))
+            return text;
+    }
+}
+const labelOf = (word, num) => {
+    const w = WORDS[word.toLowerCase()];
+    return { label: `${w.word} ${num}`, kind: w.kind };
+};
+const key = (label) => label.toLowerCase();
+/**
+ * Une ligne a la forme d'une légende quand elle COMMENCE par « Figure n » / « Table n » et que ce qui suit n'est pas une phrase en
+ * cours. Après un séparateur (« Figure 1 — titre en minuscule », « Table 2: codes ») c'est une légende quelle que soit la casse ;
+ * sans séparateur, une minuscule (« Figure 3 shows … »), une virgule ou une parenthèse (« Figure 5, which … », « Figure 5 (page 4) and … »)
+ * en font une citation. Un séparateur suivi d'un titre vide (« figure 24. » en fin de phrase) n'est pas une légende non plus.
+ * Exception : une ligne faite UNIQUEMENT du numéro et d'une parenthèse fermée (« Table IV.3 (in accordance with 4.3.11) ») a la forme
+ * d'une légende, `parenthetical` ; `indexText` ne la retient que si aucune autre ligne ne l'est pour ce numéro.
+ * « Table 2 The WMO … » a la forme d'une légende : `indexText` la départage des autres lignes de même forme.
+ */
+function captionForm(text) {
+    const m = CAPTION.exec(text.trim());
+    if (!m)
+        return null;
+    const parenthetical = m[3] === undefined && WHOLE_PARENTHESIS.test(m[4]);
+    if (m[3] === undefined && !parenthetical && /^[a-zà-ÿ,;(\[]/.test(m[4]))
+        return null;
+    if (m[3] !== undefined && m[4] === '')
+        return null;
+    return { ...labelOf(m[1], m[2]), separated: m[3] !== undefined, parenthetical, title: m[4] };
+}
+/**
+ * Lignes d'une page qui sont des entrées de sommaire (liste des figures, des tables). Une ligne à points de conduite (sur elle ou
+ * sur la suivante, titre coupé) en est une. Un numéro final ne suffit jamais : « Table 4.1. … presented in Chapter 4 » est une
+ * vraie légende ; il ne compte que dans une page de sommaire, où plus de la moitié des lignes (deux au moins) sont des entrées à
+ * points de conduite ou des lignes de forme de légende qui finissent par un numéro de page possible. Toutes les lignes d'une page
+ * de sommaire en sont.
+ */
+function tocLines(page, lastPage) {
+    const leaders = page.lines.map((l, i) => LEADER.test(l.text) || LEADER.test(page.lines[i + 1]?.text ?? ''));
+    const numbered = page.lines.map((l) => {
+        const number = TRAILING_PAGE.exec(captionForm(l.text)?.title ?? '')?.[1];
+        return number !== undefined && Number(number) <= lastPage;
+    });
+    const candidates = page.lines.filter((_, i) => leaders[i] || numbered[i]).length;
+    const contents = candidates >= 2 && candidates * 2 > page.lines.length;
+    return leaders.map((e) => e || contents);
+}
+const RANGE_ONLY = new RegExp(`^${RANGE}$`, 'i');
+const named = (num) => ({ num, interior: false });
+/** Un numéro divisé en préfixe (« 1.B. », « 3- », « A- », « A ») et chiffres finaux. */
+const TRAILING_DIGITS = /^(.*\D)?(\d+)$/;
+/**
+ * Numéros d'une plage : « 4 » et « 6 » donnent 4, 5, 6 (« 01 » et « 03 » donnent 01, 02, 03 : le zéro de tête de la première borne fixe la largeur) ; « 1.1 » et « 1.3 » donnent 1.1, 1.2, 1.3, de même « 3-1 »/« 3-3 » et « A1 »/« A3 ». Les bornes sont nommées, le milieu non.
+ * Sinon les bornes seules : préfixes différents, plage décroissante, 50 numéros ou plus. Une borne nue après une borne à préfixe
+ * (« 4.8–10 », « A3–1 ») n'est pas une figure à part : seule la première est gardée.
+ */
+function expand(from, to) {
+    const a = TRAILING_DIGITS.exec(from);
+    const b = TRAILING_DIGITS.exec(to);
+    if (b && b[1] === undefined && a && a[1] !== undefined)
+        return [named(from)];
+    if (!a || !b || (a[1] ?? '') !== (b[1] ?? ''))
+        return [named(from), named(to)];
+    const [lo, hi] = [Number(a[2]), Number(b[2])];
+    if (hi < lo || hi - lo >= 50)
+        return [named(from), named(to)];
+    return Array.from({ length: hi - lo + 1 }, (_, i) => ({ num: `${a[1] ?? ''}${String(lo + i).padStart(a[2].length, '0')}`, interior: i > 0 && i < hi - lo }));
+}
+/** Numéros nommés par une référence : le seul numéro au singulier ; au pluriel la liste, chaque plage (« 4 to 6 », « 2–4 ») développée quand ses bornes le permettent. */
+function numbersOf(head, list) {
+    const found = [...list.matchAll(NUMBER_ONLY)];
+    if (!PLURAL.test(head))
+        return found.slice(0, 1).map((m) => named(m[0]));
+    const out = [];
+    found.forEach((m, i) => {
+        const prev = found[i - 1];
+        if (prev && RANGE_ONLY.test(list.slice(prev.index + prev[0].length, m.index)))
+            out.splice(out.length - 1, 1, ...expand(prev[0], m[0]));
+        else
+            out.push(named(m[0]));
+    });
+    return out;
+}
+/**
+ * Légendes, citations et liens non résolus, d'après le texte seul ; les images viennent après (`attachRegions`).
+ * Une légende est une ligne de forme de légende (`captionForm`) qui n'est pas une entrée de sommaire ; une entrée de sommaire ne
+ * cite rien non plus. Quand plusieurs lignes ont la forme de la légende d'une même figure, on ne garde que celles qui ont un titre
+ * (« Figure 5 Jet speed » plutôt que « Figure 5 » seul), s'il y en a ; parmi elles la première qui est sur une page portant une image
+ * (`imagePages`), à défaut la première qui a un séparateur (« Table 3 — Mapping… » contre « Table 3 Identifies… »), à défaut la
+ * première du document.
+ */
+export function indexText(pages, imagePages = new Set()) {
+    const last = pages.reduce((m, p) => Math.max(m, p.n), 0);
+    const toc = new Map(pages.map((p) => [p.n, tocLines(p, last)]));
+    const candidates = new Map();
+    for (const p of pages) {
+        p.lines.forEach((l, i) => {
+            const c = toc.get(p.n)[i] ? null : captionForm(l.text);
+            if (!c)
+                return;
+            const list = candidates.get(key(c.label)) ?? [];
+            list.push({ ...c, page: p.n, line: i + 1, text: l.text.trim(), box: { x: l.x, y: l.y, l: l.l, h: l.h } });
+            candidates.set(key(c.label), list);
+        });
+    }
+    const chosen = [...candidates.values()]
+        .map((candidatesOfLabel) => {
+        // une ligne « Table n (…) » n'est une légende que si elle est la seule ligne de forme de légende de ce numéro
+        const all = candidatesOfLabel.filter((c) => !c.parenthetical || candidatesOfLabel.length === 1);
+        if (all.length === 0)
+            return null;
+        const list = all.some((c) => c.title !== '') ? all.filter((c) => c.title !== '') : all;
+        return list.find((c) => imagePages.has(c.page)) ?? list.find((c) => c.separated) ?? list[0];
+    })
+        .filter((c) => c !== null)
+        .sort((a, b) => a.page - b.page || a.line - b.line);
+    const figures = new Map(chosen.map((c) => [key(c.label), { label: c.label, kind: c.kind, page: c.page, line: c.line, caption: c.text, box: c.box, regions: [], citations: [] }]));
+    const captionLine = new Set(chosen.map((c) => `${c.page}:${c.line}`));
+    const unresolved = [];
+    const running = runningLines(pages);
+    for (const [pi, p] of pages.entries()) {
+        const captions = [...figures.values()].filter((f) => f.page === p.n);
+        p.lines.forEach((l, i) => {
+            if (toc.get(p.n)[i])
+                return;
+            const line = i + 1;
+            const own = captionLine.has(`${p.n}:${line}`);
+            const seen = new Set();
+            for (const m of l.text.matchAll(REFERENCE)) {
+                // la légende ne se cite pas elle-même
+                if (own && m.index === 0)
+                    continue;
+                // « code » peut finir la ligne précédente : l'extrait PDF coupe les lignes, pas le texte
+                const head = l.text.slice(0, m.index);
+                const carried = head.trim() === '' ? `${precedingText(pages, pi, i, running)} ${head}` : head;
+                if (labelOf(m[1], '').kind === 'figure' && (CODE_FIGURE.test(carried) || (m[2].includes('–') && CODE_FIGURE_IN_SENTENCE.test(carried.split(SENTENCE_END).pop()))))
+                    continue;
+                for (const { num, interior } of numbersOf(m[1], m[2])) {
+                    const { label } = labelOf(m[1], num);
+                    const fig = figures.get(key(label));
+                    // le milieu d'une plage sans légende n'est pas un lien à résoudre (« figures 11–20 » n'en désigne aucune) et ne masque pas
+                    // une citation explicite du même numéro plus loin sur la ligne
+                    if (interior && !fig)
+                        continue;
+                    if (seen.has(key(label)))
+                        continue;
+                    seen.add(key(label));
+                    if (fig)
+                        fig.citations.push({ page: p.n, line, extrait: l.text.trim(), type: 'nommee' });
+                    else
+                        unresolved.push({ label, page: p.n, extrait: l.text.trim() });
+                }
+            }
+            const d = DEICTIC.exec(l.text);
+            if (!d)
+                return;
+            const nearest = captions.reduce((best, f) => (best === null || Math.abs(f.line - line) < Math.abs(best.line - line) ? f : best), null);
+            if (nearest)
+                nearest.citations.push({ page: p.n, line, extrait: l.text.trim(), type: 'designee' });
+            else
+                unresolved.push({ label: d[1].toLowerCase(), page: p.n, extrait: l.text.trim() });
+        });
+    }
+    // une figure que rien ne cite est aussi à résoudre
+    for (const f of figures.values())
+        if (f.citations.length === 0)
+            unresolved.push({ label: f.label, page: f.page, extrait: f.caption });
+    return { figures: [...figures.values()], unresolved };
+}
+/** Pages à rendre en plus de celles visées : celles des figures que les pages visées citent par leur nom. */
+export function citedPages(index, wanted) {
+    const out = new Set();
+    for (const f of index.figures)
+        if (f.citations.some((c) => c.type === 'nommee' && wanted.has(c.page)))
+            out.add(f.page);
+    return out;
+}
+const centre = (b) => b.y + b.h / 2;
+/** Relie chaque image à la légende de sa page la plus proche (en hauteur) ; une page sans région connue ne la donne qu'à sa seule légende. Une image sur une page sans légende est un lien non résolu. */
+export function attachRegions(index, images) {
+    images.forEach((img, rank) => {
+        const captions = index.figures.filter((f) => f.page === img.page);
+        const target = img.box
+            ? captions.reduce((best, f) => (best === null || Math.abs(centre(f.box) - centre(img.box)) < Math.abs(centre(best.box) - centre(img.box)) ? f : best), null)
+            : captions.length === 1
+                ? captions[0]
+                : null;
+        target?.regions.push(rank);
+        if (captions.length === 0)
+            index.unresolved.push({ label: 'image sans légende', page: img.page, extrait: '' });
+    });
+}