@flowselections/layout-maker 1.3.3 → 1.6.5

package/dist-lib/lib/htmlPdf.server.js

@@ -0,0 +1,1009 @@
+// ============================================================================
+// src/lib/htmlPdf.server.ts — eigen documentmaker (HTML -> PDF) op de server.
+// ----------------------------------------------------------------------------
+// Geen externe dienst en geen browser nodig: dit bestand bevat een compacte
+// opmaakmotor die de print-HTML van de layoutmodule (pakbon, sticker,
+// verzendlabel, productiebon, vrije layouts) tekent op echte PDF-pagina's.
+// De motor kent precies de bouwstenen die de renderers gebruiken: blokken,
+// rijen naast elkaar, tabellen met vaste kolombreedtes, kaders, lijnen,
+// afbeeldingen, barcodes en QR-vlakken.
+// ============================================================================
+import { PDFDocument, StandardFonts, rgb, } from "pdf-lib";
+export const MM = 2.834645669291339; // punten per millimeter
+const LEEG = new Set(["img", "br", "hr", "col", "meta", "link", "input"]);
+function decodeer(t) {
+    return t
+        .replace(/ /g, " ")
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&euro;/g, "\u20ac");
+}
+function leesAttrs(rauw) {
+    const out = {};
+    const re = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>]+))/g;
+    let m;
+    while ((m = re.exec(rauw)))
+        out[m[1].toLowerCase()] = decodeer(m[3] ?? m[4] ?? m[5] ?? "");
+    return out;
+}
+/** Zet HTML om naar een boom. Alleen de <body> wordt gebruikt. */
+export function ontleedHtml(html) {
+    const body = /<body[^>]*>([\s\S]*?)<\/body>/i.exec(html)?.[1] ?? html;
+    const wortel = { tag: "body", attrs: {}, kinderen: [] };
+    const stapel = [wortel];
+    const re = /<!--[\s\S]*?-->|<\/?\s*([a-zA-Z][a-zA-Z0-9]*)([^>]*)>|([^<]+)/g;
+    let m;
+    while ((m = re.exec(body))) {
+        const stuk = m[0];
+        if (stuk.startsWith("<!--"))
+            continue;
+        const huidig = stapel[stapel.length - 1];
+        if (m[3] !== undefined) {
+            const tekst = decodeer(m[3]).replace(/\s+/g, " ");
+            if (tekst.trim().length || (tekst === " " && huidig.kinderen.length))
+                huidig.kinderen.push({ tag: "#tekst", attrs: {}, kinderen: [], tekst });
+            continue;
+        }
+        const tag = (m[1] ?? "").toLowerCase();
+        if (!tag)
+            continue;
+        if (stuk.startsWith("</")) {
+            for (let i = stapel.length - 1; i > 0; i--) {
+                if (stapel[i].tag === tag) {
+                    stapel.length = i;
+                    break;
+                }
+            }
+            continue;
+        }
+        if (tag === "style" || tag === "script") {
+            const eind = new RegExp(`</\\s*${tag}\\s*>`, "i");
+            const rest = body.slice(re.lastIndex);
+            const p = rest.search(eind);
+            re.lastIndex += p >= 0 ? p + rest.slice(p).indexOf(">") + 1 : 0;
+            continue;
+        }
+        const knoop = { tag, attrs: leesAttrs(m[2] ?? ""), kinderen: [] };
+        huidig.kinderen.push(knoop);
+        if (!LEEG.has(tag) && !stuk.endsWith("/>"))
+            stapel.push(knoop);
+    }
+    return wortel;
+}
+const GRIJS = rgb(0.42, 0.45, 0.5);
+const DONKER = rgb(0.07, 0.09, 0.15);
+const LIJN = rgb(0.82, 0.84, 0.86);
+function klassen(n) {
+    return String(n.attrs["class"] ?? "").split(/\s+/).filter(Boolean);
+}
+const heeft = (n, k) => klassen(n).includes(k);
+function inline(n) {
+    const out = {};
+    for (const deel of String(n.attrs["style"] ?? "").split(";")) {
+        const i = deel.indexOf(":");
+        if (i > 0)
+            out[deel.slice(0, i).trim().toLowerCase()] = deel.slice(i + 1).trim();
+    }
+    return out;
+}
+function hexNaarRgb(v) {
+    const m = /^#?([0-9a-f]{6})$/i.exec(v.trim());
+    if (m) {
+        const n = parseInt(m[1], 16);
+        return rgb(((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255);
+    }
+    const k = /^#?([0-9a-f]{3})$/i.exec(v.trim());
+    if (k) {
+        const s = k[1];
+        return rgb(parseInt(s[0] + s[0], 16) / 255, parseInt(s[1] + s[1], 16) / 255, parseInt(s[2] + s[2], 16) / 255);
+    }
+    if (/^white$/i.test(v))
+        return rgb(1, 1, 1);
+    if (/^black$/i.test(v))
+        return rgb(0, 0, 0);
+    return null;
+}
+/** Lengte in punten uit een css-waarde (mm, pt, px of %). */
+function lengte(v, basis = 0) {
+    if (!v)
+        return null;
+    const m = /^(-?[\d.]+)\s*(mm|pt|px|%)?$/.exec(v.trim());
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    if (!Number.isFinite(n))
+        return null;
+    switch (m[2]) {
+        case "mm":
+            return n * MM;
+        case "pt":
+            return n;
+        case "px":
+            return n * 0.75;
+        case "%":
+            return (n / 100) * basis;
+        default:
+            return n;
+    }
+}
+function stijlVan(n, ouder) {
+    const s = { ...ouder };
+    const cl = klassen(n);
+    if (n.tag === "th" || cl.includes("vet") || n.tag === "b" || n.tag === "strong")
+        s.vet = true;
+    if (cl.includes("sectitel")) {
+        s.grootte = ouder.grootte * 0.9;
+        s.vet = true;
+        s.kleur = GRIJS;
+    }
+    if (cl.includes("klein") || cl.includes("meta") || cl.includes("k")) {
+        s.grootte = ouder.grootte * (cl.includes("meta") ? 0.88 : 0.85);
+        s.kleur = GRIJS;
+    }
+    if (n.tag === "th") {
+        s.grootte = ouder.grootte * 0.9;
+        s.kleur = GRIJS;
+    }
+    if (cl.includes("bundel"))
+        s.vet = true;
+    if (cl.includes("karkop") || cl.includes("laagkop") || cl.includes("totalen"))
+        s.vet = true;
+    const st = inline(n);
+    const fs = st["font-size"];
+    if (fs) {
+        const g = /%$/.test(fs) ? (parseFloat(fs) / 100) * ouder.grootte : lengte(fs);
+        if (g && g > 0)
+            s.grootte = g;
+    }
+    if (st["font-weight"])
+        s.vet = Number(st["font-weight"]) >= 600 || st["font-weight"] === "bold";
+    const kl = st["color"] ? hexNaarRgb(st["color"]) : null;
+    if (kl)
+        s.kleur = kl;
+    const ta = st["text-align"];
+    if (ta === "left" || ta === "center" || ta === "right")
+        s.uitlijning = ta;
+    return s;
+}
+// --- 3. tekenhulp -----------------------------------------------------------
+const NORMALISEER = {
+    "\u2013": "-",
+    "\u2014": "-",
+    "\u2018": "'",
+    "\u2019": "'",
+    "\u201c": '"',
+    "\u201d": '"',
+    "\u2022": "-",
+    "\u00a0": " ",
+    "\u2026": "...",
+    "\u20ac": "EUR",
+    "\u2192": "->",
+    "\u2713": "v",
+    "\u00d7": "x",
+};
+function veiligeTekst(t) {
+    let out = "";
+    for (const c of t) {
+        const v = NORMALISEER[c] ?? c;
+        out += v.charCodeAt(0) > 255 ? "?" : v;
+    }
+    return out;
+}
+class Tekenaar {
+    constructor(pdf, breedte, hoogte, marge, normaal, vet) {
+        this.pdf = pdf;
+        this.breedte = breedte;
+        this.hoogte = hoogte;
+        this.marge = marge;
+        this.normaal = normaal;
+        this.vet = vet;
+        this.paginas = [];
+        this.voetHoogte = 0;
+        this.voetTekenaar = null;
+        this.pagina = pdf.addPage([breedte, hoogte]);
+        this.paginas.push(this.pagina);
+        this.y = hoogte - marge;
+    }
+    font(s) {
+        return s.vet ? this.vet : this.normaal;
+    }
+    breedteVan(t, s) {
+        return this.font(s).widthOfTextAtSize(veiligeTekst(t), s.grootte);
+    }
+    get bodem() {
+        return this.marge + this.voetHoogte;
+    }
+    get ruimte() {
+        return this.y - this.bodem;
+    }
+    zetVoet(hoogte, teken) {
+        this.voetHoogte = hoogte;
+        this.voetTekenaar = teken;
+    }
+    nieuwePagina() {
+        this.pagina = this.pdf.addPage([this.breedte, this.hoogte]);
+        this.paginas.push(this.pagina);
+        this.y = this.hoogte - this.marge;
+    }
+    zorgVoor(h) {
+        if (h <= this.ruimte || this.y >= this.hoogte - this.marge - 0.01)
+            return;
+        this.nieuwePagina();
+    }
+    /** Tekent op een wegwerp-pagina om de exacte hoogte te meten. */
+    async meet(teken) {
+        const bewaard = { pagina: this.pagina, y: this.y, paginas: this.paginas, voet: this.voetHoogte };
+        const hoog = 20000;
+        const tijdelijk = this.pdf.addPage([this.breedte, hoog]);
+        this.pagina = tijdelijk;
+        this.paginas = [tijdelijk];
+        this.y = hoog - this.marge;
+        this.voetHoogte = 0;
+        try {
+            await teken();
+        }
+        catch {
+            // meten mag nooit het document blokkeren
+        }
+        const hoogte = hoog - this.marge - this.y;
+        for (const p of this.paginas) {
+            const i = this.pdf.getPages().indexOf(p);
+            if (i >= 0)
+                this.pdf.removePage(i);
+        }
+        this.pagina = bewaard.pagina;
+        this.y = bewaard.y;
+        this.paginas = bewaard.paginas;
+        this.voetHoogte = bewaard.voet;
+        return hoogte;
+    }
+    rondAf() {
+        if (!this.voetTekenaar)
+            return;
+        for (const p of this.paginas)
+            this.voetTekenaar(p);
+    }
+}
+function regelHoogte(s) {
+    return s.grootte * 1.35;
+}
+/** Breekt tekst af op de beschikbare breedte. */
+function breekAf(tk, tekst, s, breedte) {
+    const woorden = veiligeTekst(tekst).split(/\s+/).filter((w) => w.length);
+    if (!woorden.length)
+        return [];
+    const regels = [];
+    let huidig = "";
+    for (const w of woorden) {
+        const kandidaat = huidig ? `${huidig} ${w}` : w;
+        if (tk.breedteVan(kandidaat, s) <= breedte || !huidig)
+            huidig = kandidaat;
+        else {
+            regels.push(huidig);
+            huidig = w;
+        }
+    }
+    if (huidig)
+        regels.push(huidig);
+    return regels;
+}
+function tekenRegel(tk, regel, x, breedte, y, s) {
+    const t = veiligeTekst(regel);
+    const w = tk.breedteVan(t, s);
+    const dx = s.uitlijning === "right" ? breedte - w : s.uitlijning === "center" ? (breedte - w) / 2 : 0;
+    tk.pagina.drawText(t, {
+        x: x + Math.max(0, dx),
+        y,
+        size: s.grootte,
+        font: tk.font(s),
+        color: s.kleur,
+    });
+}
+const inlineTags = new Set(["#tekst", "span", "b", "strong", "em", "i", "small", "a"]);
+function isInline(n) {
+    if (!inlineTags.has(n.tag))
+        return false;
+    const st = inline(n);
+    return !st["height"] && !st["width"];
+}
+/** Verzamelt de platte tekst van een knoop (met spatie tussen losse stukjes). */
+function plattTekst(n) {
+    if (n.tag === "#tekst")
+        return n.tekst ?? "";
+    let uit = "";
+    for (const k of n.kinderen) {
+        const deel = plattTekst(k);
+        if (!deel)
+            continue;
+        if (uit && !/\s$/.test(uit) && !/^\s/.test(deel))
+            uit += " ";
+        uit += deel;
+    }
+    return uit;
+}
+/** Meet de exacte hoogte van een knoop door hem op een wegwerp-pagina te tekenen. */
+async function meetHoogte(ctx, n, vak, s) {
+    const meetCtx = { ...ctx, meten: true };
+    return ctx.tk.meet(async () => {
+        await tekenKinderen(meetCtx, { tag: "div", attrs: {}, kinderen: [n] }, vak, s);
+    });
+}
+function rijenVan(tabel) {
+    const rijen = [];
+    const loop = (k) => {
+        for (const c of k.kinderen) {
+            if (c.tag === "tr")
+                rijen.push(c);
+            else if (c.tag === "thead" || c.tag === "tbody" || c.tag === "tfoot")
+                loop(c);
+        }
+    };
+    loop(tabel);
+    return rijen;
+}
+function kolomBreedtes(tabel, rijen, totaal) {
+    const cols = [];
+    for (const c of tabel.kinderen)
+        if (c.tag === "colgroup")
+            cols.push(...c.kinderen.filter((x) => x.tag === "col"));
+    const eerste = rijen[0];
+    const aantal = Math.max(cols.length, eerste ? eerste.kinderen.filter((c) => c.tag === "td" || c.tag === "th").length : 1);
+    if (!aantal)
+        return [totaal];
+    if (cols.length === aantal) {
+        const rauw = cols.map((c) => lengte(inline(c)["width"] ?? c.attrs["width"], totaal));
+        const som = rauw.reduce((a, b) => a + (b ?? 0), 0);
+        if (som > 1) {
+            const factor = totaal / som;
+            return rauw.map((v) => (v ?? 0) * factor);
+        }
+    }
+    return Array.from({ length: aantal }, () => totaal / aantal);
+}
+async function tekenBlok(ctx, n, vak, ouderStijl) {
+    const tk = ctx.tk;
+    const s = stijlVan(n, ouderStijl);
+    const st = inline(n);
+    const cl = klassen(n);
+    if (n.tag === "#tekst") {
+        const regels = breekAf(tk, n.tekst ?? "", s, vak.breedte);
+        for (const r of regels) {
+            tk.zorgVoor(regelHoogte(s));
+            tk.y -= regelHoogte(s);
+            tekenRegel(tk, r, vak.x, vak.breedte, tk.y + s.grootte * 0.25, s);
+        }
+        return;
+    }
+    if (n.tag === "br") {
+        tk.y -= regelHoogte(s);
+        return;
+    }
+    if (n.tag === "hr" || cl.includes("lijn")) {
+        tk.zorgVoor(2 * MM);
+        tk.y -= 1.2 * MM;
+        tk.pagina.drawLine({
+            start: { x: vak.x, y: tk.y },
+            end: { x: vak.x + vak.breedte, y: tk.y },
+            thickness: 0.7,
+            color: LIJN,
+        });
+        tk.y -= 1.2 * MM;
+        return;
+    }
+    if (cl.includes("balk")) {
+        tk.zorgVoor(3 * MM);
+        tk.y -= 1.5 * MM + 1 * MM;
+        tk.pagina.drawRectangle({
+            x: vak.x,
+            y: tk.y,
+            width: vak.breedte,
+            height: 1 * MM,
+            color: rgb(0.22, 0.25, 0.3),
+        });
+        tk.y -= 1.5 * MM;
+        return;
+    }
+    if (n.tag === "img") {
+        await tekenAfbeelding(ctx, n, vak, s);
+        return;
+    }
+    if (cl.includes("qr")) {
+        const g = lengte(st["width"]) ?? 25 * MM;
+        tk.zorgVoor(g + 1 * MM);
+        tk.y -= g;
+        tk.pagina.drawRectangle({
+            x: vak.x,
+            y: tk.y,
+            width: g,
+            height: g,
+            borderWidth: 0.7,
+            borderColor: GRIJS,
+        });
+        tk.y -= 1 * MM;
+        return;
+    }
+    if (cl.includes("streepjes")) {
+        const h = lengte(st["height"]) ?? 15 * MM;
+        const b = Math.min(45 * MM, vak.breedte);
+        tk.zorgVoor(h + 1 * MM);
+        tk.y -= h;
+        for (let x = 0; x < b - 1; x += 1.9) {
+            tk.pagina.drawRectangle({
+                x: vak.x + x,
+                y: tk.y,
+                width: 0.9,
+                height: h,
+                color: DONKER,
+            });
+        }
+        tk.y -= 1 * MM;
+        return;
+    }
+    if (cl.includes("lijnveld")) {
+        const extra = cl.includes("hoog") ? 10 * MM : 3 * MM;
+        tk.zorgVoor(regelHoogte(s) * 2 + extra);
+        tk.y -= 4 * MM;
+        const tekst = plattTekst(n).trim();
+        if (tekst) {
+            tk.y -= regelHoogte(s);
+            tekenRegel(tk, tekst, vak.x, vak.breedte, tk.y + s.grootte * 0.25, s);
+        }
+        tk.y -= extra;
+        tk.pagina.drawLine({
+            start: { x: vak.x, y: tk.y },
+            end: { x: vak.x + vak.breedte, y: tk.y },
+            thickness: 0.7,
+            color: GRIJS,
+        });
+        return;
+    }
+    if (n.tag === "table") {
+        await tekenTabel(ctx, n, vak, s);
+        return;
+    }
+    if (n.tag === "ul" || n.tag === "ol") {
+        let i = 1;
+        for (const li of n.kinderen.filter((k) => k.tag === "li")) {
+            const bullet = n.tag === "ol" ? `${i++}.` : "-";
+            const binnen = { x: vak.x + 4 * MM, breedte: vak.breedte - 4 * MM };
+            const voor = tk.y;
+            await tekenKinderen(ctx, li, binnen, s);
+            tekenRegel(tk, bullet, vak.x, 4 * MM, Math.min(voor, tk.y + regelHoogte(s)) - regelHoogte(s) + s.grootte * 0.25, s);
+        }
+        return;
+    }
+    // kader / achtergrond
+    const kader = cl.includes("kader") || cl.includes("rand") || cl.includes("omkaderd");
+    const achtergrond = st["background"] ? hexNaarRgb(st["background"].split(" ")[0] ?? "") : null;
+    const padding = kader ? 1.5 * MM : 0;
+    if (cl.includes("breekvoor") && tk.y < tk.hoogte - tk.marge - 1)
+        tk.nieuwePagina();
+    const binnenVak = { x: vak.x + padding, breedte: vak.breedte - padding * 2 };
+    if (!ctx.meten && (cl.includes("heelhouden") || achtergrond)) {
+        const nodig = (await meetHoogte(ctx, n, binnenVak, s)) + padding * 2;
+        if (cl.includes("heelhouden") && nodig > tk.ruimte && nodig < tk.hoogte - tk.marge * 2) {
+            tk.nieuwePagina();
+        }
+        if (achtergrond) {
+            // achtergrondvlak eerst tekenen, anders valt het over de tekst heen
+            tk.pagina.drawRectangle({
+                x: vak.x,
+                y: Math.max(tk.bodem, tk.y - nodig),
+                width: vak.breedte,
+                height: Math.min(nodig, tk.y - tk.bodem),
+                color: achtergrond,
+            });
+        }
+    }
+    const startY = tk.y;
+    const startPagina = tk.pagina;
+    if (kader || achtergrond)
+        tk.y -= padding;
+    await tekenKinderen(ctx, n, binnenVak, s);
+    if (kader || achtergrond)
+        tk.y -= padding;
+    if (kader && tk.pagina === startPagina && startY - tk.y > 0) {
+        startPagina.drawRectangle({
+            x: vak.x,
+            y: tk.y,
+            width: vak.breedte,
+            height: startY - tk.y,
+            borderWidth: 0.6,
+            borderColor: LIJN,
+        });
+    }
+    if (cl.includes("onder") || cl.includes("laagkop")) {
+        tk.pagina.drawLine({
+            start: { x: vak.x, y: tk.y + 0.6 * MM },
+            end: { x: vak.x + vak.breedte, y: tk.y + 0.6 * MM },
+            thickness: 0.5,
+            color: LIJN,
+        });
+    }
+    if (cl.includes("totalen")) {
+        tk.pagina.drawLine({
+            start: { x: vak.x, y: startY },
+            end: { x: vak.x + vak.breedte, y: startY },
+            thickness: 0.7,
+            color: LIJN,
+        });
+    }
+    if (cl.includes("blok") || cl.includes("groep") || cl.includes("karblok") || cl.includes("laag"))
+        tk.y -= 1.6 * MM;
+}
+async function tekenAfbeelding(ctx, n, vak, s) {
+    const tk = ctx.tk;
+    const src = n.attrs["src"] ?? "";
+    const afb = ctx.afbeeldingen.get(src);
+    const hoogte = lengte(inline(n)["height"]) ?? 18 * MM;
+    if (!afb) {
+        tk.y -= hoogte + 1 * MM;
+        return;
+    }
+    const schaal = hoogte / afb.height;
+    const breedte = Math.min(afb.width * schaal, vak.breedte);
+    const echteHoogte = (breedte / afb.width) * afb.height;
+    tk.zorgVoor(echteHoogte + 1 * MM);
+    tk.y -= echteHoogte;
+    const dx = s.uitlijning === "right"
+        ? vak.breedte - breedte
+        : s.uitlijning === "center"
+            ? (vak.breedte - breedte) / 2
+            : 0;
+    tk.pagina.drawImage(afb, { x: vak.x + Math.max(0, dx), y: tk.y, width: breedte, height: echteHoogte });
+    tk.y -= 1 * MM;
+}
+async function tekenTabel(ctx, tabel, vak, s) {
+    const tk = ctx.tk;
+    const rijen = rijenVan(tabel);
+    if (!rijen.length)
+        return;
+    const breedtes = kolomBreedtes(tabel, rijen, vak.breedte);
+    const compact = heeft(tabel, "compact");
+    const padY = compact ? 0.3 * MM : 0.7 * MM;
+    const padX = compact ? 0.8 * MM : 1 * MM;
+    const randen = heeft(tabel, "rand");
+    const kopRij = rijen.find((r) => r.kinderen.some((c) => c.tag === "th")) ?? null;
+    const tekenRij = (rij, herhaald = false) => {
+        const cellen = rij.kinderen.filter((c) => c.tag === "td" || c.tag === "th");
+        const cellenStijl = cellen.map((c) => stijlVan(c, s));
+        const teksten = cellen.map((c, i) => breekAf(tk, plattTekst(c), cellenStijl[i], Math.max(4, (breedtes[i] ?? 20) - padX * 2)));
+        const hoogte = Math.max(1, ...teksten.map((t) => t.length)) * regelHoogte(cellenStijl[0] ?? s) + padY * 2;
+        if (hoogte > tk.ruimte) {
+            tk.nieuwePagina();
+            if (kopRij && !herhaald && rij !== kopRij)
+                tekenRij(kopRij, true);
+        }
+        const bovenY = tk.y;
+        const zebra = heeft(rij, "zebra");
+        if (zebra) {
+            tk.pagina.drawRectangle({
+                x: vak.x,
+                y: bovenY - hoogte,
+                width: vak.breedte,
+                height: hoogte,
+                color: rgb(0.95, 0.96, 0.97),
+            });
+        }
+        let x = vak.x;
+        cellen.forEach((c, i) => {
+            const b = breedtes[i] ?? 20;
+            const cs = { ...cellenStijl[i], uitlijning: cellenStijl[i].uitlijning };
+            let y = bovenY - padY;
+            for (const regel of teksten[i]) {
+                y -= regelHoogte(cs);
+                tekenRegel(tk, regel, x + padX, b - padX * 2, y + cs.grootte * 0.25, cs);
+            }
+            if (randen) {
+                tk.pagina.drawRectangle({
+                    x,
+                    y: bovenY - hoogte,
+                    width: b,
+                    height: hoogte,
+                    borderWidth: 0.5,
+                    borderColor: LIJN,
+                });
+            }
+            x += b;
+        });
+        if (!randen && (rij === kopRij || heeft(rij, "onder"))) {
+            tk.pagina.drawLine({
+                start: { x: vak.x, y: bovenY - hoogte },
+                end: { x: vak.x + vak.breedte, y: bovenY - hoogte },
+                thickness: 0.5,
+                color: LIJN,
+            });
+        }
+        tk.y = bovenY - hoogte;
+    };
+    for (const rij of rijen)
+        tekenRij(rij);
+    tk.y -= 1 * MM;
+}
+/** Tekent een element dat met vaste coördinaten geplaatst is (position:absolute). */
+async function tekenAbsoluut(ctx, n, s) {
+    const tk = ctx.tk;
+    const st = inline(n);
+    const eigen = stijlVan(n, s);
+    const x = lengte(st["left"]) ?? 0;
+    const top = lengte(st["top"]) ?? 0;
+    const breedte = lengte(st["width"]) ?? tk.breedte - x;
+    const hoogte = lengte(st["height"]) ?? regelHoogte(eigen);
+    const yBoven = tk.hoogte - top;
+    const yOnder = yBoven - hoogte;
+    const gradientKind = zoekGradient(n);
+    if (gradientKind) {
+        const gebied = gradientKind === "streepjes" ? hoogte * 0.72 : Math.min(breedte, hoogte);
+        const top = yBoven;
+        if (gradientKind === "streepjes") {
+            for (let bx = 0; bx < breedte - 1; bx += 2.2) {
+                tk.pagina.drawRectangle({ x: x + bx, y: top - gebied, width: 1, height: gebied, color: DONKER });
+            }
+        }
+        else {
+            const stap = Math.max(2, gebied / 12);
+            for (let ix = 0; ix < gebied - 1; ix += stap * 2) {
+                for (let iy = 0; iy < gebied - 1; iy += stap * 2) {
+                    tk.pagina.drawRectangle({
+                        x: x + ix,
+                        y: top - gebied + iy,
+                        width: Math.min(stap, gebied - ix),
+                        height: Math.min(stap, gebied - iy),
+                        color: DONKER,
+                    });
+                }
+            }
+        }
+        const onderschrift = plattTekst(n).trim();
+        if (onderschrift && gradientKind === "streepjes") {
+            const kleinStijl = { ...eigen, grootte: Math.min(eigen.grootte, 7), uitlijning: "center" };
+            tekenRegel(tk, onderschrift, x, breedte, yOnder + 1, kleinStijl);
+        }
+        return;
+    }
+    const achtergrondCss = st["background"] ?? st["background-color"] ?? "";
+    const isStreepjes = /repeating-linear-gradient/i.test(achtergrondCss);
+    const isRaster = /repeating-conic-gradient/i.test(achtergrondCss);
+    const vlak = hexNaarRgb(achtergrondCss.split(/\s+/)[0] ?? "");
+    const randDeel = /(\d*\.?\d+)mm\s+(?:solid|dashed)\s+(#[0-9a-f]{3,6})/i.exec(st["border"] ?? st["border-bottom"] ?? "");
+    if (isStreepjes) {
+        for (let bx = 0; bx < breedte - 1; bx += 2.2) {
+            tk.pagina.drawRectangle({ x: x + bx, y: yOnder, width: 1, height: hoogte, color: DONKER });
+        }
+    }
+    else if (isRaster) {
+        const stap = Math.max(2, Math.min(breedte, hoogte) / 12);
+        for (let ix = 0; ix < breedte - 1; ix += stap * 2) {
+            for (let iy = 0; iy < hoogte - 1; iy += stap * 2) {
+                tk.pagina.drawRectangle({
+                    x: x + ix,
+                    y: yOnder + iy,
+                    width: Math.min(stap, breedte - ix),
+                    height: Math.min(stap, hoogte - iy),
+                    color: DONKER,
+                });
+            }
+        }
+    }
+    else if (vlak) {
+        tk.pagina.drawRectangle({ x, y: yOnder, width: breedte, height: Math.max(hoogte, 0.4), color: vlak });
+    }
+    if (randDeel) {
+        const dikte = Number(randDeel[1]) * MM || 0.5;
+        const kleur = hexNaarRgb(randDeel[2] ?? "") ?? DONKER;
+        if (st["border-bottom"] && !st["border"]) {
+            tk.pagina.drawLine({
+                start: { x, y: yOnder },
+                end: { x: x + breedte, y: yOnder },
+                thickness: dikte,
+                color: kleur,
+            });
+        }
+        else {
+            tk.pagina.drawRectangle({
+                x,
+                y: yOnder,
+                width: breedte,
+                height: hoogte,
+                borderWidth: dikte,
+                borderColor: kleur,
+            });
+        }
+    }
+    const tabel = zoekTag(n, "table");
+    if (tabel) {
+        const bewaardY = tk.y;
+        tk.y = yBoven;
+        await tekenTabel(ctx, tabel, { x, breedte }, eigen);
+        tk.y = bewaardY;
+        return;
+    }
+    const afbeelding = zoekTag(n, "img");
+    if (afbeelding) {
+        const bron = afbeelding.attrs["src"] ?? "";
+        const beeld = ctx.afbeeldingen.get(bron);
+        if (beeld) {
+            const schaal = Math.min(breedte / beeld.width, hoogte / beeld.height);
+            const b = beeld.width * schaal;
+            const h = beeld.height * schaal;
+            tk.pagina.drawImage(beeld, {
+                x: x + (breedte - b) / 2,
+                y: yOnder + (hoogte - h) / 2,
+                width: b,
+                height: h,
+            });
+        }
+        return;
+    }
+    const tekst = plattTekst(n).trim();
+    if (!tekst)
+        return;
+    const regels = breekAf(tk, tekst, eigen, breedte - 1);
+    const padding = lengte(st["padding"]) ?? 0;
+    const gecentreerd = /center/.test(st["align-items"] ?? "") || /center/.test(st["justify-content"] ?? "");
+    const blokHoogte = regels.length * regelHoogte(eigen);
+    let y = yBoven - padding - (gecentreerd ? Math.max(0, (hoogte - blokHoogte) / 2) : 0);
+    for (const r of regels) {
+        y -= regelHoogte(eigen);
+        if (y < yOnder - regelHoogte(eigen))
+            break;
+        tekenRegel(tk, r, x + padding, breedte - padding * 2, y + eigen.grootte * 0.25, eigen);
+    }
+}
+/** Zoekt een streepjes- of blokjespatroon (barcode/QR) in de knoop of kinderen. */
+function zoekGradient(n) {
+    const css = `${inline(n)["background"] ?? ""} ${inline(n)["background-image"] ?? ""}`;
+    if (/repeating-linear-gradient/i.test(css))
+        return "streepjes";
+    if (/repeating-conic-gradient/i.test(css))
+        return "raster";
+    for (const k of n.kinderen) {
+        const diep = zoekGradient(k);
+        if (diep)
+            return diep;
+    }
+    return null;
+}
+function zoekTag(n, tag) {
+    for (const k of n.kinderen) {
+        if (k.tag === tag)
+            return k;
+        const diep = zoekTag(k, tag);
+        if (diep)
+            return diep;
+    }
+    return null;
+}
+/** Kinderen van een blok: tekst inline samenvoegen, rijen naast elkaar zetten. */
+async function tekenKinderen(ctx, n, vak, s) {
+    const tk = ctx.tk;
+    const cl = klassen(n);
+    const alle = n.kinderen.filter((k) => k.tag !== "#tekst" || (k.tekst ?? "").trim().length);
+    const absolute = alle.filter((k) => /absolute/.test(inline(k)["position"] ?? ""));
+    for (const k of absolute)
+        await tekenAbsoluut(ctx, k, s);
+    const kinderen = alle.filter((k) => !absolute.includes(k));
+    if (!kinderen.length)
+        return;
+    const tweeKolommen = cl.includes("grid2") || cl.includes("tweekolom");
+    const rijModus = cl.includes("kv") ||
+        cl.includes("karkop") ||
+        cl.includes("laagkop") ||
+        cl.includes("meta") ||
+        cl.includes("totalen") ||
+        cl.includes("regelrij");
+    if (tweeKolommen) {
+        const gap = 6 * MM;
+        const kolomBreedte = (vak.breedte - gap) / 2;
+        const links = kinderen.filter((_, i) => i % 2 === 0);
+        const rechts = kinderen.filter((_, i) => i % 2 === 1);
+        const startY = tk.y;
+        let eindL = startY;
+        for (const k of links) {
+            await tekenBlok(ctx, k, { x: vak.x, breedte: kolomBreedte }, s);
+            eindL = tk.y;
+        }
+        const naL = tk.y;
+        tk.y = startY;
+        let eindR = startY;
+        for (const k of rechts) {
+            await tekenBlok(ctx, k, { x: vak.x + kolomBreedte + gap, breedte: kolomBreedte }, s);
+            eindR = tk.y;
+        }
+        tk.y = Math.min(naL, eindL, eindR, tk.y);
+        return;
+    }
+    if (rijModus) {
+        const stukken = kinderen.map((k) => ({ knoop: k, stijl: stijlVan(k, s), tekst: plattTekst(k) }));
+        const breedtesTekst = stukken.map((p) => tk.breedteVan(p.tekst, p.stijl));
+        const hoogte = Math.max(...stukken.map((p) => regelHoogte(p.stijl)), regelHoogte(s));
+        const totaalTekst = breedtesTekst.reduce((a, b) => a + b, 0);
+        const gap = 3 * MM;
+        tk.zorgVoor(hoogte);
+        tk.y -= hoogte;
+        const yTekst = tk.y + s.grootte * 0.3;
+        const spreiden = (cl.includes("kv") || cl.includes("karkop") || cl.includes("laagkop")) && stukken.length > 1;
+        const rechtsUit = cl.includes("totalen") && inline(n)["justify-content"] === "flex-end";
+        if (spreiden) {
+            let x = vak.x;
+            stukken.forEach((p, i) => {
+                const laatste = i === stukken.length - 1;
+                const b = breedtesTekst[i];
+                const px = laatste ? vak.x + vak.breedte - b : x;
+                tekenRegel(tk, p.tekst, px, b, yTekst, p.stijl);
+                x += b + gap;
+            });
+        }
+        else {
+            const start = rechtsUit
+                ? vak.x + vak.breedte - (totaalTekst + gap * (stukken.length - 1))
+                : vak.x;
+            let x = Math.max(vak.x, start);
+            stukken.forEach((p, i) => {
+                tekenRegel(tk, p.tekst, x, breedtesTekst[i], yTekst, p.stijl);
+                x += breedtesTekst[i] + gap;
+            });
+        }
+        return;
+    }
+    // gewone blokstroom, met inline-tekst samengevoegd
+    let buffer = [];
+    const leegBuffer = async () => {
+        if (!buffer.length)
+            return;
+        const tekst = buffer.map(plattTekst).join("");
+        const eersteVet = buffer[0] && heeft(buffer[0], "vet");
+        const stijl = eersteVet && buffer.length === 1 ? stijlVan(buffer[0], s) : s;
+        buffer = [];
+        if (tekst.trim().length) {
+            await tekenBlok(ctx, { tag: "#tekst", attrs: {}, kinderen: [], tekst }, vak, stijl);
+        }
+    };
+    for (const k of kinderen) {
+        if (isInline(k))
+            buffer.push(k);
+        else {
+            await leegBuffer();
+            await tekenBlok(ctx, k, vak, s);
+        }
+    }
+    await leegBuffer();
+}
+// --- 5. afbeeldingen ophalen ------------------------------------------------
+function base64NaarBytes(b64) {
+    const bin = typeof atob === "function" ? atob(b64) : Buffer.from(b64, "base64").toString("binary");
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+function verzamelBronnen(n, uit) {
+    if (n.tag === "img" && n.attrs["src"])
+        uit.add(n.attrs["src"]);
+    for (const k of n.kinderen)
+        verzamelBronnen(k, uit);
+}
+async function laadAfbeeldingen(pdf, wortel) {
+    const bronnen = new Set();
+    verzamelBronnen(wortel, bronnen);
+    const uit = new Map();
+    await Promise.all([...bronnen].slice(0, 20).map(async (src) => {
+        try {
+            let bytes;
+            let png = /\.png(\?|$)/i.test(src);
+            if (src.startsWith("data:")) {
+                const komma = src.indexOf(",");
+                png = /image\/png/i.test(src.slice(0, komma));
+                bytes = base64NaarBytes(src.slice(komma + 1));
+            }
+            else if (/^https?:/i.test(src)) {
+                const res = await fetch(src);
+                if (!res.ok)
+                    return;
+                const type = res.headers.get("content-type") ?? "";
+                png = /png/i.test(type) || png;
+                bytes = new Uint8Array(await res.arrayBuffer());
+            }
+            else
+                return;
+            const afb = png ? await pdf.embedPng(bytes) : await pdf.embedJpg(bytes);
+            uit.set(src, afb);
+        }
+        catch {
+            // afbeelding overslaan: het document moet altijd afdrukbaar blijven
+        }
+    }));
+    return uit;
+}
+/** Zet print-HTML om naar een PDF en levert die als base64 (zonder prefix). */
+export async function htmlNaarPdfBytes(opties) {
+    const bMm = Number(opties.breedteMm ?? 210);
+    const hMm = Number(opties.hoogteMm ?? 297);
+    const marge = Number(opties.margeMm ?? 10) * MM;
+    const breedte = (opties.landschap ? Math.max(bMm, hMm) : Math.min(bMm, hMm)) * MM;
+    const hoogte = (opties.landschap ? Math.min(bMm, hMm) : Math.max(bMm, hMm)) * MM;
+    const pdf = await PDFDocument.create();
+    const normaal = await pdf.embedFont(StandardFonts.Helvetica);
+    const vet = await pdf.embedFont(StandardFonts.HelveticaBold);
+    const wortel = ontleedHtml(opties.html);
+    const afbeeldingen = await laadAfbeeldingen(pdf, wortel);
+    const basis = basisGrootte(opties.html);
+    const tk = new Tekenaar(pdf, breedte, hoogte, marge, normaal, vet);
+    const ctx = { tk, afbeeldingen };
+    const stijl = { grootte: basis, vet: false, kleur: DONKER, uitlijning: "left" };
+    // vaste paginavoet (bijv. totalen op elke pagina)
+    const voetKnoop = zoekVoet(wortel);
+    if (voetKnoop) {
+        verwijder(wortel, voetKnoop);
+        tk.zetVoet(regelHoogte(stijl) + 2 * MM, () => { });
+    }
+    await tekenKinderen(ctx, wortel, { x: marge, breedte: breedte - marge * 2 }, stijl);
+    if (voetKnoop) {
+        const tekst = plattTekst(voetKnoop).trim();
+        for (const p of tk.paginas) {
+            p.drawLine({
+                start: { x: marge, y: marge + regelHoogte(stijl) + 1.5 * MM },
+                end: { x: breedte - marge, y: marge + regelHoogte(stijl) + 1.5 * MM },
+                thickness: 0.6,
+                color: LIJN,
+            });
+            p.drawText(veiligeTekst(tekst).slice(0, 300), {
+                x: marge,
+                y: marge + 2,
+                size: stijl.grootte,
+                font: normaal,
+                color: DONKER,
+            });
+        }
+    }
+    if (opties.paginanummers !== false && tk.paginas.length > 1) {
+        tk.paginas.forEach((p, i) => {
+            const t = `Pagina ${i + 1} van ${tk.paginas.length}`;
+            p.drawText(t, {
+                x: breedte - marge - normaal.widthOfTextAtSize(t, 7),
+                y: marge / 2,
+                size: 7,
+                font: normaal,
+                color: GRIJS,
+            });
+        });
+    }
+    tk.rondAf();
+    return pdf.save();
+}
+function basisGrootte(html) {
+    const m = /body\s*\{[^}]*font-size:\s*([\d.]+)pt/i.exec(html);
+    const n = m ? Number(m[1]) : NaN;
+    return Number.isFinite(n) && n > 3 && n < 30 ? n : 8.5;
+}
+function zoekVoet(n) {
+    for (const k of n.kinderen) {
+        if (heeft(k, "paginavoet"))
+            return k;
+        const diep = zoekVoet(k);
+        if (diep)
+            return diep;
+    }
+    return null;
+}
+function verwijder(n, doel) {
+    const i = n.kinderen.indexOf(doel);
+    if (i >= 0) {
+        n.kinderen.splice(i, 1);
+        return true;
+    }
+    return n.kinderen.some((k) => verwijder(k, doel));
+}
+export function bytesNaarBase64(bytes) {
+    let bin = "";
+    const stap = 0x8000;
+    for (let i = 0; i < bytes.length; i += stap) {
+        bin += String.fromCharCode(...bytes.subarray(i, i + stap));
+    }
+    if (typeof btoa === "function")
+        return btoa(bin);
+    return Buffer.from(bin, "binary").toString("base64");
+}