@tricoteuses/senat 3.1.24 → 3.2.0

package/lib/src/index.d.ts

@@ -40,3 +40,4 @@ export { UNDEFINED_SESSION, sessionOptions, sessionOptionsOrAll, getSessionsFrom
 export { DivisionType } from "./other_types/texte.js";
 export type { DivisionTag, Version, DocumentMetadata, FlatTexte, Step, Division, Article, DivisionContent, Alinea, ExposeDesMotifs, } from "./other_types/texte.js";
 export type { CollaborateurSenat } from "./other_types/collaborateurs.js";
+export type { PlfBudgetType, PlfLigne, PlfProgramme, PlfMission, PlfCreditsSection } from "./other_types/plf.js";

package/lib/src/other_types/plf.d.ts

@@ -0,0 +1,21 @@
+export type PlfBudgetType = "budgetGeneral" | "budgetsAnnexes" | "comptesSpeciaux";
+export interface PlfLigne {
+    libelle: string;
+    autorisationEngagement?: number;
+    creditPaiement?: number;
+    autorisationEngagementAnnule?: number;
+    creditPaiementAnnule?: number;
+}
+export interface PlfProgramme extends PlfLigne {
+    lignes?: PlfLigne[];
+}
+export interface PlfMission extends PlfLigne {
+    budgetType: PlfBudgetType;
+    programmes: PlfProgramme[];
+}
+export interface PlfCreditsSection {
+    budgetType: PlfBudgetType;
+    libelle: string;
+    missions: PlfMission[];
+    total?: Omit<PlfLigne, "libelle">;
+}

package/lib/src/other_types/plf.js

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

package/lib/src/parsers/plf/credits.d.ts

@@ -0,0 +1,2 @@
+import { type PlfCreditsSection } from "../../other_types/plf.js";
+export declare function parsePlfCredits(document: Document): PlfCreditsSection[];

package/lib/src/parsers/plf/credits.js

@@ -0,0 +1,171 @@
+import { cleanText, classifyRow, detectEtatDSubSection, etatNumToBudgetType, etatNumToLibelle, isHeaderRow, parseLibelle, rowToMontants, SUBSECTION_DEFINITIONS, } from "./parser_utils.js";
+// ---------------------------------------------------------------------------
+// Table parsing
+// ---------------------------------------------------------------------------
+function parseCreditTable(table) {
+    const missions = [];
+    let currentMission = null;
+    let currentProgramme = null;
+    let tableTotal;
+    const rows = [...table.querySelectorAll("tr")];
+    // Skip header rows: the first row normally has colspan (the "(En euros)" row),
+    // and the second row has the column headers (bold, border-bottom).
+    let dataStartIndex = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const tds = rows[i].querySelectorAll("td");
+        if (tds.length < 2) {
+            dataStartIndex = i + 1;
+            continue;
+        }
+        // Check if this is a header row: border-bottom on first td, or contains header text
+        const firstTdStyle = (tds[0]?.getAttribute("style") ?? "").replace(/[\n\t\r]/g, " ");
+        if (/border-bottom\s*:\s*1px/.test(firstTdStyle) ||
+            isHeaderRow(tds)) {
+            dataStartIndex = i + 1;
+            continue;
+        }
+        // If we have enough td cells, assume we're past headers
+        if (tds.length >= 3) {
+            dataStartIndex = i;
+            break;
+        }
+        dataStartIndex = i + 1;
+    }
+    for (let i = dataStartIndex; i < rows.length; i++) {
+        const tr = rows[i];
+        const tds = tr.querySelectorAll("td");
+        if (tds.length < 3)
+            continue;
+        const kind = classifyRow(tr);
+        const nameText = cleanText(tds[0].textContent ?? "");
+        if (!nameText)
+            continue;
+        if (kind === "total") {
+            tableTotal = rowToMontants(tr);
+            continue;
+        }
+        if (kind === "ligne") {
+            if (currentProgramme) {
+                const ligneLibelle = parseLibelle(tds[0].textContent ?? "");
+                if (ligneLibelle === undefined)
+                    continue;
+                currentProgramme.lignes = currentProgramme.lignes || [];
+                currentProgramme.lignes.push({
+                    libelle: ligneLibelle,
+                    ...rowToMontants(tr),
+                });
+            }
+            continue;
+        }
+        if (kind === "mission") {
+            if (currentMission) {
+                missions.push(currentMission);
+            }
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined) {
+                currentMission = null;
+                currentProgramme = null;
+                continue;
+            }
+            currentMission = {
+                budgetType: "budgetGeneral",
+                libelle,
+                ...rowToMontants(tr),
+                programmes: [],
+            };
+            currentProgramme = null;
+            continue;
+        }
+        // programme row
+        if (currentMission) {
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined) {
+                currentProgramme = null;
+                continue;
+            }
+            currentProgramme = {
+                libelle,
+                ...rowToMontants(tr),
+            };
+            currentMission.programmes.push(currentProgramme);
+        }
+        else {
+            // If no mission is active, treat this as a mission with one programme
+            const libelle = parseLibelle(tds[0].textContent ?? "");
+            if (libelle === undefined)
+                continue;
+            currentMission = {
+                budgetType: "budgetGeneral",
+                libelle,
+                ...rowToMontants(tr),
+                programmes: [],
+            };
+        }
+    }
+    if (currentMission) {
+        missions.push(currentMission);
+    }
+    if (missions.length === 0)
+        return null;
+    return { missions, total: tableTotal };
+}
+// ---------------------------------------------------------------------------
+// Main parser
+// ---------------------------------------------------------------------------
+export function parsePlfCredits(document) {
+    const body = document.querySelector("body");
+    if (!body)
+        return [];
+    const etatArticles = [...body.querySelectorAll('article[class="etat"]')];
+    if (etatArticles.length === 0)
+        return [];
+    const results = [];
+    for (const article of etatArticles) {
+        const numEl = article.querySelector(":scope > num");
+        if (!numEl)
+            continue;
+        const num = cleanText(numEl.textContent ?? "");
+        const budgetType = etatNumToBudgetType(num);
+        if (!budgetType)
+            continue;
+        // Find all tables in this etat article
+        const tables = [...article.querySelectorAll("table.alinea-table.etat-tableau")];
+        if (tables.length === 0)
+            continue;
+        // For État D, handle CAS/CCF sub-sections
+        if (budgetType === "comptesSpeciaux") {
+            let fallbackCasIndex = 0;
+            for (const table of tables) {
+                const subsection = detectEtatDSubSection(table) ??
+                    (fallbackCasIndex === 0 ? "cas" : fallbackCasIndex === 1 ? "ccf" : undefined);
+                fallbackCasIndex++;
+                if (!subsection)
+                    continue;
+                const parsed = parseCreditTable(table);
+                if (!parsed)
+                    continue;
+                const def = SUBSECTION_DEFINITIONS[subsection];
+                results.push({
+                    budgetType,
+                    libelle: def.libelle,
+                    missions: parsed.missions.map((m) => ({ ...m, budgetType })),
+                    total: parsed.total,
+                });
+            }
+        }
+        else {
+            // État B or État C: single table
+            const parsed = parseCreditTable(tables[0]);
+            if (!parsed)
+                continue;
+            const libelle = etatNumToLibelle(num) ?? num;
+            results.push({
+                budgetType,
+                libelle,
+                missions: parsed.missions.map((m) => ({ ...m, budgetType })),
+                total: parsed.total,
+            });
+        }
+    }
+    return results;
+}

package/lib/src/parsers/plf/index.d.ts

@@ -0,0 +1 @@
+export { parsePlfCredits } from "./credits.js";

package/lib/src/parsers/plf/index.js

@@ -0,0 +1 @@
+export { parsePlfCredits } from "./credits.js";

package/lib/src/parsers/plf/parser_utils.d.ts

@@ -0,0 +1,18 @@
+import { type PlfBudgetType, type PlfLigne } from "../../other_types/plf.js";
+export declare function cleanText(text: string): string;
+export declare function hasBorderTop(style: string): boolean;
+export declare function hasFontWeightBold(style: string): boolean;
+export declare function hasFontStyleItalic(style: string): boolean;
+export declare function normalizeAmount(text: string): number | undefined;
+export declare function parseLibelle(text: string): string | undefined;
+export declare function etatNumToBudgetType(num: string): PlfBudgetType | undefined;
+export declare function etatNumToLibelle(num: string): string | undefined;
+export type RowKind = "mission" | "programme" | "ligne" | "total" | "unknown";
+export declare function classifyRow(tr: Element): RowKind;
+export declare function rowToMontants(tr: Element): Omit<PlfLigne, "libelle">;
+export declare function isHeaderRow(tds: Iterable<Element>): boolean;
+export type EtatDSubSection = "cas" | "ccf";
+export declare const SUBSECTION_DEFINITIONS: Record<EtatDSubSection, {
+    libelle: string;
+}>;
+export declare function detectEtatDSubSection(table: Element): EtatDSubSection | undefined;

package/lib/src/parsers/plf/parser_utils.js

@@ -0,0 +1,172 @@
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function cleanText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function hasBorderTop(style) {
+    return /border-top\s*:\s*1px/.test(style);
+}
+export function hasFontWeightBold(style) {
+    return /font-weight\s*:\s*bold/.test(style);
+}
+export function hasFontStyleItalic(style) {
+    return /font-style\s*:\s*italic/.test(style);
+}
+export function normalizeAmount(text) {
+    let cleaned = cleanText(text)
+        .replace(/[\u2212\u2011]/g, "-")
+        // Remove literal " " artefact from double-escaped XML entities
+        .replace(/ /gi, "")
+        // Remove actual non-breaking spaces
+        .replace(/\u00A0/g, "")
+        .replace(/\s/g, "")
+        .replace(/[^0-9,.-]/g, "");
+    const commaCount = (cleaned.match(/,/g) ?? []).length;
+    if (commaCount > 1)
+        return undefined;
+    const normalized = commaCount === 1 ? cleaned.replace(/\./g, "").replace(",", ".") : cleaned;
+    if (!/^-?\d+(?:\.\d+)?$/.test(normalized))
+        return undefined;
+    const n = Number(normalized);
+    return Number.isNaN(n) ? undefined : n;
+}
+export function parseLibelle(text) {
+    // Remove any HTML tags (e.g. literal "<br>" from double-escaped XML entities)
+    const libelle = cleanText(text)
+        .replace(/<[^>]*>/g, " ")
+        .replace(/(?:\s*\.){2,}\s*$/g, "")
+        .trim();
+    if (/\(\s*ligne\s+supprim(?:ée|ee)\s*\)\s*$/i.test(libelle)) {
+        return undefined;
+    }
+    return libelle.replace(/\s*\(\s*ligne\s+nouvelle\s*\)\s*$/i, "").trim();
+}
+export function etatNumToBudgetType(num) {
+    switch (num) {
+        case "État B":
+            return "budgetGeneral";
+        case "État C":
+            return "budgetsAnnexes";
+        case "État D":
+            return "comptesSpeciaux";
+        default:
+            return undefined;
+    }
+}
+export function etatNumToLibelle(num) {
+    switch (num) {
+        case "État B":
+            return "Budget général";
+        case "État C":
+            return "Budgets annexes";
+        case "État D":
+            return "Comptes spéciaux";
+        default:
+            return undefined;
+    }
+}
+export function classifyRow(tr) {
+    const trClass = (tr.getAttribute("class") ?? "").trim().toLowerCase();
+    if (trClass === "mission")
+        return "mission";
+    if (trClass === "programme")
+        return "programme";
+    if (trClass === "lgncred")
+        return "ligne";
+    if (trClass === "total")
+        return "total";
+    // Fallback: style-based heuristics
+    const firstTd = tr.querySelector("td");
+    if (!firstTd)
+        return "unknown";
+    const style = (firstTd.getAttribute("style") ?? "").replace(/[\n\t\r]/g, " ");
+    const text = cleanText(firstTd.textContent ?? "");
+    if (/^total/i.test(text))
+        return "total";
+    const isBold = hasFontWeightBold(style);
+    const isItalic = hasFontStyleItalic(style);
+    const hasBorder = hasBorderTop(style);
+    if (isItalic && !isBold) {
+        // "Dont titre 2" style rows
+        if (/dont\s+titre/i.test(text))
+            return "ligne";
+    }
+    if (isBold && hasBorder)
+        return "mission";
+    return "programme";
+}
+// ---------------------------------------------------------------------------
+// Amount extraction (3 or 5 columns)
+// ---------------------------------------------------------------------------
+export function rowToMontants(tr) {
+    const tds = [...tr.querySelectorAll("td")];
+    const ae = normalizeAmount(tds[1]?.textContent ?? "");
+    const cp = normalizeAmount(tds[2]?.textContent ?? "");
+    if (tds.length >= 5) {
+        return {
+            autorisationEngagement: ae,
+            creditPaiement: cp,
+            autorisationEngagementAnnule: normalizeAmount(tds[3]?.textContent ?? ""),
+            creditPaiementAnnule: normalizeAmount(tds[4]?.textContent ?? ""),
+        };
+    }
+    return { autorisationEngagement: ae, creditPaiement: cp };
+}
+export function isHeaderRow(tds) {
+    const fullRowText = [...tds]
+        .map((td) => cleanText(td.textContent ?? ""))
+        .join(" ");
+    if (/mission\s*\/\s*programme/i.test(fullRowText))
+        return true;
+    if (/cr[ée]dits?\s+de\s+paiement/i.test(fullRowText))
+        return true;
+    return false;
+}
+export const SUBSECTION_DEFINITIONS = {
+    cas: { libelle: "Comptes d'affectation spéciale" },
+    ccf: { libelle: "Comptes de concours financiers" },
+};
+export function detectEtatDSubSection(table) {
+    let current = table;
+    // Navigate up: table → content → alinea → parent alinea
+    while (current && current.tagName !== "alinea") {
+        current = current.parentElement;
+    }
+    if (!current)
+        return undefined;
+    const innerAlinea = current;
+    const outerAlinea = innerAlinea.parentElement;
+    if (!outerAlinea || outerAlinea.tagName !== "alinea")
+        return undefined;
+    // Look for <content><p> in outerAlinea AFTER the inner alinea
+    let foundInner = false;
+    for (const child of [...outerAlinea.children]) {
+        if (child === innerAlinea) {
+            foundInner = true;
+            continue;
+        }
+        if (!foundInner)
+            continue;
+        if (child.tagName === "content") {
+            const p = child.querySelector(":scope > p");
+            if (!p) {
+                // Try direct text
+                const text = cleanText(child.textContent ?? "");
+                if (text.length > 0) {
+                    if (/COMPTES\s+D['\u2019]AFFECTATION\s+SP[EÉ]CIALE/i.test(text))
+                        return "cas";
+                    if (/COMPTES\s+DE\s+CONCOURS\s+FINANCIERS/i.test(text))
+                        return "ccf";
+                }
+                continue;
+            }
+            const pText = cleanText(p.textContent ?? "");
+            if (/COMPTES\s+D['\u2019]AFFECTATION\s+SP[EÉ]CIALE/i.test(pText))
+                return "cas";
+            if (/COMPTES\s+DE\s+CONCOURS\s+FINANCIERS/i.test(pText))
+                return "ccf";
+        }
+    }
+    return undefined;
+}

package/lib/src/parsers/texte.d.ts

@@ -1,7 +1,5 @@
 import { ExposeDesMotifs, FlatTexte } from "../other_types/texte.js";
 export declare function transformTexte(document: Document): FlatTexte | null;
 export declare function transformExposeDesMotifs(document: Document): ExposeDesMotifs | null;
-export declare function parseTexte(texteXml: string): FlatTexte | null;
-export declare function parseTexteFromFile(xmlFilePath: string): Promise<FlatTexte | null>;
+export declare function parseTexte(texteXml: string, dom?: Document): FlatTexte | null;
 export declare function parseExposeDesMotifs(exposeDesMotifsHtml: string): ExposeDesMotifs | null;
-export declare function parseExposeDesMotifsFromFile(htmlFilePath: string): Promise<ExposeDesMotifs | null>;

package/lib/src/parsers/texte.js

@@ -51,14 +51,67 @@ function buildAlinea(contentNode, alineaNode) {
         text: alineaNode.querySelector("num")?.textContent ?? null,
     };
     const pastille = alineaNode.getAttribute("data:pastille") ?? null;
+    const rawHtml = contentNode.innerHTML?.trim() ?? null;
+    const rawText = contentNode.textContent?.trim() ?? null;
+    const { text, html } = normalizeDoubleEscapedMarkup(rawText, rawHtml);
     return {
         eId,
         heading,
-        text: contentNode.textContent?.trim() ?? null,
-        html: contentNode.innerHTML?.trim() ?? null,
+        text,
+        html,
         pastille,
     };
 }
+// The Sénat XML sometimes double-escapes inner block markup: a cell/paragraph
+// whose text is literally "<p>…</p><p>…</p>" (e.g. the italic footnote block in
+// the article liminaire of the PLF). Unescape it so the blocks render as real
+// paragraphs instead of showing literal "<p>" characters.
+function normalizeDoubleEscapedMarkup(text, html) {
+    if (html != null && html.includes("&lt;")) {
+        return {
+            html: html.replace(/&lt;/g, "<").replace(/&gt;/g, ">"),
+            text: html
+                .replace(/&lt;/g, "<")
+                .replace(/&gt;/g, ">")
+                .replace(/<[^>]*>/g, " ")
+                .replace(/\s+/g, " ")
+                .trim(),
+        };
+    }
+    return { text, html };
+}
+function buildDivisionalAlinea(node, index) {
+    const eId = node.getAttribute("eId");
+    const numNode = node.querySelector("num");
+    const contentNode = Array.from(node.childNodes).find((childNode) => childNode.nodeName === "content");
+    const numText = numNode?.textContent?.trim() ?? null;
+    const contentText = contentNode?.textContent?.trim() ?? null;
+    const contentHtml = contentNode?.innerHTML?.trim() ?? null;
+    const headings = [];
+    if (numText)
+        headings.push({ text: numText, html: numText });
+    if (contentText)
+        headings.push({ text: contentText, html: contentHtml });
+    return {
+        index,
+        eId,
+        tag: "alinea",
+        level: DivisionType["alinea"],
+        headings,
+    };
+}
+function isArticleAlinea(alineaNode) {
+    let ancestor = alineaNode.parentElement;
+    while (ancestor) {
+        const tag = ancestor.nodeName;
+        if (tag === "article")
+            return true;
+        if (DivisionType[tag] != null && tag !== "alinea")
+            return false;
+        ancestor = ancestor.parentElement;
+    }
+    return false;
+}
 function buildEmptyArticle(index) {
     return {
         index: index,
@@ -105,6 +158,12 @@ function splitTexte(texteContentRoot) {
                 // https://github.com/jsdom/jsdom/issues/2998
                 .filter((alineaChildNode) => alineaChildNode.nodeName === "content")
                 .forEach((alineaContentNode) => {
+                if (!isArticleAlinea(node)) {
+                    // Divisional alinea (e.g. `aldiv_*` headings inside a title/part):
+                    // a structural heading of a subdivision, not an article alinea.
+                    divisions.push(buildDivisionalAlinea(node, divisionIndex++));
+                    return;
+                }
                 // Hypothesis: alineas should always be enclosed in articles
                 let lastArticle = divisions.findLast((division) => division.tag === "article");
                 if (!lastArticle) {
@@ -189,23 +248,9 @@ export function transformExposeDesMotifs(document) {
     }
     return null;
 }
-export function parseTexte(texteXml) {
+export function parseTexte(texteXml, dom) {
     try {
-        const { document } = new JSDOM(texteXml, {
-            contentType: "text/xml",
-        }).window;
-        return transformTexte(document);
-    }
-    catch (error) {
-        console.error(`Could not parse texte with error ${error.message}`);
-    }
-    return null;
-}
-// Prevent from memory leak
-// https://github.com/jsdom/jsdom/issues/2583#issuecomment-559520814
-export async function parseTexteFromFile(xmlFilePath) {
-    try {
-        const { document } = (await JSDOM.fromFile(xmlFilePath, { contentType: "text/xml" })).window;
+        const document = dom ?? new JSDOM(texteXml, { contentType: "text/xml" }).window.document;
         return transformTexte(document);
     }
     catch (error) {
@@ -225,15 +270,3 @@ export function parseExposeDesMotifs(exposeDesMotifsHtml) {
     }
     return null;
 }
-// Prevent from memory leak
-// https://github.com/jsdom/jsdom/issues/2583#issuecomment-559520814
-export async function parseExposeDesMotifsFromFile(htmlFilePath) {
-    try {
-        const { document } = (await JSDOM.fromFile(htmlFilePath, { contentType: "text/html" })).window;
-        return transformExposeDesMotifs(document);
-    }
-    catch (error) {
-        console.error(`Could not parse exposé des motifs with error ${error.message}`);
-    }
-    return null;
-}

package/lib/src/scripts/extract_plf_fixtures.d.ts

@@ -0,0 +1 @@
+export declare function extractEtats(srcPath: string): Promise<Element[]>;

package/lib/src/scripts/extract_plf_fixtures.js

@@ -0,0 +1,101 @@
+import fs from "fs-extra";
+import { JSDOM } from "jsdom";
+import path from "path";
+import { commonOptions } from "./shared/cli_helpers.js";
+const optionsDefinitions = [
+    { name: "src", type: String },
+    {
+        help: [
+            "extract the 'etat' articles of a real Sénat AKN XML into a minimal fixture",
+            "named <name>.xml under tests/fixtures/plf/",
+        ].join(" "),
+        name: "name",
+        type: String,
+    },
+    {
+        help: "keep only the parsed budget states (B, C, D); drop the large A/G tables",
+        name: "only-parsed",
+        type: Boolean,
+    },
+    ...commonOptions,
+];
+const KEEP_DATA_ROWS = 6;
+function trimTable(table) {
+    const rows = [...table.querySelectorAll("tr")];
+    // Les 2 premières lignes sont les en-têtes réels : « (En euros) » puis « Mission / Programme ».
+    const headerCount = Math.min(2, rows.length);
+    const dataRows = rows.slice(headerCount);
+    const dataStartIndex = rows.length - dataRows.length;
+    const totalRows = dataRows.filter((row) => {
+        const firstTd = row.querySelector("td");
+        return /^total/i.test(firstTd?.textContent?.trim() ?? "");
+    });
+    const totalIndexes = new Set(totalRows.map((row) => rows.indexOf(row)));
+    let kept = 0;
+    for (const row of rows) {
+        const index = rows.indexOf(row);
+        if (index < dataStartIndex)
+            continue; // en-têtes conservés
+        if (totalIndexes.has(index))
+            continue; // lignes Total conservées
+        if (kept < KEEP_DATA_ROWS) {
+            kept++;
+            continue;
+        }
+        row.parentNode?.removeChild(row);
+    }
+}
+export async function extractEtats(srcPath) {
+    const xml = await fs.readFile(srcPath, "utf-8");
+    const { document } = new JSDOM(xml, { contentType: "text/xml" }).window;
+    const body = document.querySelector("body");
+    if (!body)
+        throw new Error(`No <body> found in ${srcPath}`);
+    return [...body.querySelectorAll('article[class="etat"]')];
+}
+async function main() {
+    const commandLineArgs = (await import("command-line-args")).default;
+    const options = commandLineArgs(optionsDefinitions);
+    const srcPath = options.src;
+    const fixtureName = options.name;
+    if (!srcPath)
+        throw new Error("Missing <src> path to a Sénat AKN XML");
+    if (!fixtureName)
+        throw new Error("Missing --name");
+    const etatArticles = await extractEtats(srcPath);
+    const kept = options["only-parsed"]
+        ? etatArticles.filter((article) => {
+            const num = article.querySelector(":scope > num")?.textContent?.trim();
+            return num === "État B" || num === "État C" || num === "État D";
+        })
+        : etatArticles;
+    if (kept.length === 0)
+        throw new Error(`No B/C/D etat articles found in ${srcPath}`);
+    for (const article of kept) {
+        for (const table of article.querySelectorAll("table.alinea-table.etat-tableau")) {
+            trimTable(table);
+        }
+    }
+    const outDir = path.join("tests", "fixtures", "plf");
+    await fs.ensureDir(outDir);
+    const outPath = path.join(outDir, `${fixtureName}.xml`);
+    const fixture = `<?xml version="1.0" encoding="UTF-8"?>
+<akomaNtoso xmlns="http://docs.oasis-open.org/legaldocml/ns/akn/3.0" xmlns:data="http://data.parlement.fr/v1">
+  <bill contains="singleVersion" name="plf">
+    <body>${kept.map((el) => el.outerHTML).join("\n")}</body>
+  </bill>
+</akomaNtoso>
+`;
+    await fs.writeFile(outPath, fixture);
+    if (!options.silent) {
+        const sizeKb = (Buffer.byteLength(fixture) / 1024).toFixed(1);
+        console.log(`Wrote ${outPath} (${kept.length} etat articles, ${sizeKb} KB)`);
+    }
+}
+if (process.argv[1].endsWith("extract_plf_fixtures.ts")) {
+    main()
+        .catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}