layoutbridge-light 1.0.0 → 1.0.1

package/dist/src/mcp/pdf-postprocess.js

@@ -0,0 +1,798 @@
+/**
+ * Nachbearbeitung eines fertigen PDFs ohne InDesign (A-80, Sitzung 82,
+ * E-120 und E-121).
+ *
+ * 1. Ungetaggte Pfade als Artefakt: InDesign 21.6 schreibt Konturen und
+ *    Flaechen von Textrahmen und alle Tabellen-Zellkonturen ausserhalb jeder
+ *    markierten Sequenz (Live-Probe Sitzung 82; PAC: „Path object not
+ *    tagged“). Solche Pfadobjekte werden in `/Artifact BMC … EMC`
+ *    eingeschlossen.
+ * 2. PDF/UA-Kennung: `pdfuaid:part` im XMP des Dokuments (Entscheidung
+ *    des Anbieters 11.11.2026, Mittelweg).
+ *
+ * Beides als inkrementelle Aktualisierung (ISO 32000-1, 7.5.6): Die
+ * Originalbytes bleiben, neue Fassungen der geaenderten Objekte, ein neuer
+ * Querverweisabschnitt (Tabelle oder Stream wie im Original) und ein neuer
+ * Trailer werden angehaengt. Verschluesselte PDFs werden nicht angefasst.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { deflateSync, inflateSync } from 'node:zlib';
+export class PdfPostprocessError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+const WS = new Set([0x00, 0x09, 0x0a, 0x0c, 0x0d, 0x20]);
+const DELIM = new Set(['(', ')', '<', '>', '[', ']', '{', '}', '/', '%']);
+function isWs(src, i) {
+    return WS.has(src.charCodeAt(i));
+}
+function isRegular(ch) {
+    return ch !== undefined && !WS.has(ch.charCodeAt(0)) && !DELIM.has(ch);
+}
+export function skipWs(src, pos) {
+    let i = pos;
+    while (i < src.length) {
+        if (isWs(src, i)) {
+            i += 1;
+        }
+        else if (src[i] === '%') {
+            while (i < src.length && src[i] !== '\n' && src[i] !== '\r')
+                i += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return i;
+}
+function literalStringEnd(src, start) {
+    let depth = 0;
+    let i = start;
+    while (i < src.length) {
+        const ch = src[i];
+        if (ch === '\\') {
+            i += 2;
+            continue;
+        }
+        if (ch === '(')
+            depth += 1;
+        if (ch === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i + 1;
+        }
+        i += 1;
+    }
+    throw new PdfPostprocessError('Unterminated string in PDF.', 'pdf_syntax');
+}
+function regularEnd(src, start) {
+    let i = start;
+    while (i < src.length && isRegular(src[i]))
+        i += 1;
+    return i;
+}
+const NUMBER = /^[+-]?(\d+\.?\d*|\.\d+)$/;
+export function parseValue(src, pos) {
+    let i = skipWs(src, pos);
+    const ch = src[i];
+    if (ch === undefined)
+        throw new PdfPostprocessError('Unexpected end of PDF data.', 'pdf_syntax');
+    if (ch === '<' && src[i + 1] === '<') {
+        const entries = new Map();
+        i += 2;
+        for (;;) {
+            i = skipWs(src, i);
+            if (src[i] === '>' && src[i + 1] === '>')
+                return { value: { t: 'dict', entries }, end: i + 2 };
+            const key = parseValue(src, i);
+            if (key.value.t !== 'name')
+                throw new PdfPostprocessError('Dictionary key is no name.', 'pdf_syntax');
+            const value = parseValue(src, key.end);
+            entries.set(key.value.v, value.value);
+            i = value.end;
+        }
+    }
+    if (ch === '<') {
+        const end = src.indexOf('>', i);
+        if (end < 0)
+            throw new PdfPostprocessError('Unterminated hex string.', 'pdf_syntax');
+        return { value: { t: 'str', raw: src.slice(i, end + 1) }, end: end + 1 };
+    }
+    if (ch === '(') {
+        const end = literalStringEnd(src, i);
+        return { value: { t: 'str', raw: src.slice(i, end) }, end };
+    }
+    if (ch === '[') {
+        const items = [];
+        i += 1;
+        for (;;) {
+            i = skipWs(src, i);
+            if (src[i] === ']')
+                return { value: { t: 'arr', items }, end: i + 1 };
+            const item = parseValue(src, i);
+            items.push(item.value);
+            i = item.end;
+        }
+    }
+    if (ch === '/') {
+        const end = regularEnd(src, i + 1);
+        return { value: { t: 'name', v: src.slice(i + 1, end) }, end };
+    }
+    const end = regularEnd(src, i);
+    if (end === i)
+        throw new PdfPostprocessError('Unexpected character in PDF: ' + JSON.stringify(ch), 'pdf_syntax');
+    const word = src.slice(i, end);
+    if (NUMBER.test(word)) {
+        /* Verweis "n g R"? */
+        if (/^\d+$/.test(word)) {
+            const a = skipWs(src, end);
+            const bEnd = regularEnd(src, a);
+            const second = src.slice(a, bEnd);
+            if (/^\d+$/.test(second)) {
+                const c = skipWs(src, bEnd);
+                if (src[c] === 'R' && !isRegular(src[c + 1])) {
+                    return { value: { t: 'ref', n: Number(word), g: Number(second) }, end: c + 1 };
+                }
+            }
+        }
+        return { value: { t: 'num', raw: word }, end };
+    }
+    return { value: { t: 'kw', raw: word }, end };
+}
+export function serialize(value) {
+    switch (value.t) {
+        case 'name':
+            return '/' + value.v;
+        case 'num':
+        case 'str':
+        case 'kw':
+            return value.raw;
+        case 'ref':
+            return value.n + ' ' + value.g + ' R';
+        case 'arr':
+            return '[' + value.items.map(serialize).join(' ') + ']';
+        case 'dict': {
+            const parts = [];
+            for (const [key, entry] of value.entries)
+                parts.push('/' + key + ' ' + serialize(entry));
+            return '<<' + parts.join(' ') + '>>';
+        }
+    }
+}
+function dictOf(value, what) {
+    if (value === undefined || value.t !== 'dict')
+        throw new PdfPostprocessError(what + ' is no dictionary.', 'pdf_structure');
+    return value.entries;
+}
+function numberOf(value) {
+    return value !== undefined && value.t === 'num' ? Number(value.raw) : null;
+}
+export class PdfFile {
+    bytes;
+    src;
+    xref = new Map();
+    freed = new Set();
+    trailer = new Map();
+    lastXrefOffset = 0;
+    usesXrefStream = false;
+    objStmCache = new Map();
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.src = bytes.toString('latin1');
+        this.readXrefChain();
+    }
+    readXrefChain() {
+        const at = this.src.lastIndexOf('startxref');
+        if (at < 0)
+            throw new PdfPostprocessError('No startxref – not a complete PDF.', 'pdf_structure');
+        const offset = parseValue(this.src, at + 'startxref'.length);
+        if (offset.value.t !== 'num')
+            throw new PdfPostprocessError('startxref without offset.', 'pdf_structure');
+        this.lastXrefOffset = Number(offset.value.raw);
+        let next = this.lastXrefOffset;
+        const seen = new Set();
+        let first = true;
+        while (next !== null && !seen.has(next)) {
+            seen.add(next);
+            const trailer = this.readXrefSection(next, first);
+            if (first) {
+                this.trailer = trailer;
+                first = false;
+            }
+            const xrefStm = numberOf(trailer.get('XRefStm'));
+            if (xrefStm !== null && !seen.has(xrefStm)) {
+                seen.add(xrefStm);
+                this.readXrefSection(xrefStm, false);
+            }
+            next = numberOf(trailer.get('Prev'));
+        }
+    }
+    setEntry(num, entry) {
+        if (this.xref.has(num) || this.freed.has(num))
+            return;
+        if (entry === null)
+            this.freed.add(num);
+        else
+            this.xref.set(num, entry);
+    }
+    readXrefSection(offset, first) {
+        let i = skipWs(this.src, offset);
+        if (this.src.startsWith('xref', i)) {
+            i += 4;
+            for (;;) {
+                i = skipWs(this.src, i);
+                if (this.src.startsWith('trailer', i)) {
+                    const trailer = parseValue(this.src, i + 7);
+                    return dictOf(trailer.value, 'Trailer');
+                }
+                const start = parseValue(this.src, i);
+                const count = parseValue(this.src, start.end);
+                if (start.value.t !== 'num' || count.value.t !== 'num')
+                    throw new PdfPostprocessError('Broken xref table.', 'pdf_structure');
+                i = count.end;
+                const s = Number(start.value.raw);
+                const c = Number(count.value.raw);
+                for (let k = 0; k < c; k++) {
+                    i = skipWs(this.src, i);
+                    const line = this.src.slice(i, i + 18);
+                    const m = /^(\d{10}) (\d{5}) ([nf])/.exec(line);
+                    if (!m)
+                        throw new PdfPostprocessError('Broken xref entry.', 'pdf_structure');
+                    this.setEntry(s + k, m[3] === 'n' ? { type: 1, a: Number(m[1]), b: Number(m[2]) } : null);
+                    i += 18;
+                }
+            }
+        }
+        /* Querverweisstrom */
+        if (first)
+            this.usesXrefStream = true;
+        const obj = this.parseIndirectAt(offset);
+        const dict = dictOf(obj.value, 'XRef stream');
+        if (obj.stream === null)
+            throw new PdfPostprocessError('XRef stream without data.', 'pdf_structure');
+        const data = this.decodeStream(dict, obj.stream);
+        const w = dict.get('W');
+        if (w === undefined || w.t !== 'arr' || w.items.length !== 3)
+            throw new PdfPostprocessError('XRef stream without /W.', 'pdf_structure');
+        const widths = w.items.map((item) => numberOf(item) ?? 0);
+        const size = numberOf(dict.get('Size')) ?? 0;
+        const index = dict.get('Index');
+        const ranges = index !== undefined && index.t === 'arr' ? index.items.map((item) => numberOf(item) ?? 0) : [0, size];
+        const rowLength = widths[0] + widths[1] + widths[2];
+        let row = 0;
+        for (let r = 0; r + 1 < ranges.length; r += 2) {
+            const start = ranges[r];
+            const count = ranges[r + 1];
+            for (let k = 0; k < count; k++, row++) {
+                const base = row * rowLength;
+                if (base + rowLength > data.length)
+                    break;
+                const field = (from, width, fallback) => {
+                    if (width === 0)
+                        return fallback;
+                    let value = 0;
+                    for (let b = 0; b < width; b++)
+                        value = value * 256 + data[from + b];
+                    return value;
+                };
+                const type = field(base, widths[0], 1);
+                const a = field(base + widths[0], widths[1], 0);
+                const b = field(base + widths[0] + widths[1], widths[2], 0);
+                if (type === 1)
+                    this.setEntry(start + k, { type: 1, a, b });
+                else if (type === 2)
+                    this.setEntry(start + k, { type: 2, a, b });
+                else
+                    this.setEntry(start + k, null);
+            }
+        }
+        return dict;
+    }
+    /** Objekt "n g obj … endobj" an einem Byte-Versatz. */
+    parseIndirectAt(offset) {
+        const head = /^\s*(\d+)\s+(\d+)\s+obj/.exec(this.src.slice(offset, offset + 40));
+        if (!head)
+            throw new PdfPostprocessError('No object at offset ' + offset + '.', 'pdf_structure');
+        const gen = Number(head[2]);
+        const parsed = parseValue(this.src, offset + head[0].length);
+        let i = skipWs(this.src, parsed.end);
+        if (!this.src.startsWith('stream', i))
+            return { value: parsed.value, stream: null, gen };
+        i += 6;
+        if (this.src[i] === '\r')
+            i += 1;
+        if (this.src[i] === '\n')
+            i += 1;
+        const dict = dictOf(parsed.value, 'Stream');
+        let length = this.resolveNumber(dict.get('Length'));
+        if (length === null || !this.src.startsWith('endstream', skipWs(this.src, i + length))) {
+            /* Laenge passt nicht: bis endstream suchen. */
+            const end = this.src.indexOf('endstream', i);
+            if (end < 0)
+                throw new PdfPostprocessError('Stream without endstream.', 'pdf_structure');
+            length = end - i;
+            while (length > 0 && (this.src[i + length - 1] === '\n' || this.src[i + length - 1] === '\r'))
+                length -= 1;
+        }
+        return { value: parsed.value, stream: this.bytes.subarray(i, i + length), gen };
+    }
+    resolveNumber(value) {
+        if (value === undefined)
+            return null;
+        if (value.t === 'num')
+            return Number(value.raw);
+        if (value.t === 'ref')
+            return numberOf(this.getObject(value.n)?.value);
+        return null;
+    }
+    resolve(value) {
+        if (value !== undefined && value.t === 'ref')
+            return this.getObject(value.n)?.value;
+        return value;
+    }
+    generationOf(num) {
+        const entry = this.xref.get(num);
+        return entry !== undefined && entry.type === 1 ? entry.b : 0;
+    }
+    get maxObjectNumber() {
+        let max = 0;
+        for (const num of this.xref.keys())
+            max = Math.max(max, num);
+        return max;
+    }
+    getObject(num) {
+        const entry = this.xref.get(num);
+        if (entry === undefined)
+            return null;
+        if (entry.type === 1)
+            return this.parseIndirectAt(entry.a);
+        let stm = this.objStmCache.get(entry.a);
+        if (stm === undefined) {
+            const container = this.getObject(entry.a);
+            if (container === null || container.stream === null)
+                throw new PdfPostprocessError('Object stream ' + entry.a + ' missing.', 'pdf_structure');
+            const dict = dictOf(container.value, 'Object stream');
+            const data = this.decodeStream(dict, container.stream).toString('latin1');
+            const n = numberOf(dict.get('N')) ?? 0;
+            const firstOffset = numberOf(dict.get('First')) ?? 0;
+            const offsets = new Map();
+            let p = 0;
+            for (let k = 0; k < n; k++) {
+                const objNum = parseValue(data, p);
+                const objOff = parseValue(data, objNum.end);
+                p = objOff.end;
+                if (objNum.value.t === 'num' && objOff.value.t === 'num')
+                    offsets.set(Number(objNum.value.raw), firstOffset + Number(objOff.value.raw));
+            }
+            stm = { data, offsets };
+            this.objStmCache.set(entry.a, stm);
+        }
+        const at = stm.offsets.get(num);
+        if (at === undefined)
+            return null;
+        return { value: parseValue(stm.data, at).value, stream: null, gen: 0 };
+    }
+    /** Stream-Daten entschluesseln (nur FlateDecode, mit PNG-Praediktoren). */
+    decodeStream(dict, raw) {
+        const filter = this.resolve(dict.get('Filter'));
+        const filters = [];
+        if (filter !== undefined) {
+            if (filter.t === 'name')
+                filters.push(filter.v);
+            else if (filter.t === 'arr')
+                for (const item of filter.items)
+                    if (item.t === 'name')
+                        filters.push(item.v);
+        }
+        let data = raw;
+        for (const name of filters) {
+            if (name !== 'FlateDecode' && name !== 'Fl')
+                throw new PdfPostprocessError('Unsupported stream filter ' + name + '.', 'pdf_filter');
+            data = inflateSync(data);
+        }
+        let parms = this.resolve(dict.get('DecodeParms'));
+        if (parms !== undefined && parms.t === 'arr')
+            parms = this.resolve(parms.items[0]);
+        if (parms !== undefined && parms.t === 'dict') {
+            const predictor = numberOf(parms.entries.get('Predictor')) ?? 1;
+            if (predictor >= 10) {
+                const columns = numberOf(parms.entries.get('Columns')) ?? 1;
+                const colors = numberOf(parms.entries.get('Colors')) ?? 1;
+                const bpc = numberOf(parms.entries.get('BitsPerComponent')) ?? 8;
+                data = unpredictPng(data, Math.ceil((columns * colors * bpc) / 8), Math.max(1, Math.ceil((colors * bpc) / 8)));
+            }
+            else if (predictor !== 1) {
+                throw new PdfPostprocessError('Unsupported predictor ' + predictor + '.', 'pdf_filter');
+            }
+        }
+        return data;
+    }
+}
+export function unpredictPng(data, rowLength, bpp) {
+    const rows = Math.floor(data.length / (rowLength + 1));
+    const out = Buffer.alloc(rows * rowLength);
+    for (let r = 0; r < rows; r++) {
+        const type = data[r * (rowLength + 1)];
+        const src = r * (rowLength + 1) + 1;
+        const dst = r * rowLength;
+        for (let i = 0; i < rowLength; i++) {
+            const raw = data[src + i];
+            const left = i >= bpp ? out[dst + i - bpp] : 0;
+            const up = r > 0 ? out[dst - rowLength + i] : 0;
+            const upLeft = r > 0 && i >= bpp ? out[dst - rowLength + i - bpp] : 0;
+            let value;
+            if (type === 0)
+                value = raw;
+            else if (type === 1)
+                value = raw + left;
+            else if (type === 2)
+                value = raw + up;
+            else if (type === 3)
+                value = raw + Math.floor((left + up) / 2);
+            else if (type === 4) {
+                const p = left + up - upLeft;
+                const pa = Math.abs(p - left);
+                const pb = Math.abs(p - up);
+                const pc = Math.abs(p - upLeft);
+                value = raw + (pa <= pb && pa <= pc ? left : pb <= pc ? up : upLeft);
+            }
+            else
+                throw new PdfPostprocessError('Unknown PNG predictor row type ' + type + '.', 'pdf_filter');
+            out[dst + i] = value & 0xff;
+        }
+    }
+    return out;
+}
+/* ------------------------------------------------------- Inhaltsstroeme */
+const PATH_CONSTRUCTION = new Set(['m', 'l', 'c', 'v', 'y', 'h', 're']);
+const PATH_PAINTING = new Set(['S', 's', 'f', 'F', 'f*', 'B', 'B*', 'b', 'b*']);
+const CLIPPING = new Set(['W', 'W*']);
+/**
+ * Pfadobjekte (und Schattierungen `sh`) ausserhalb jeder markierten Sequenz.
+ * Liefert Bereiche [Anfang, Ende) im Inhaltsstrom.
+ */
+export function findUntaggedPaths(content) {
+    const ranges = [];
+    let depth = 0;
+    let inText = false;
+    let operandStart = null;
+    let pathStart = null;
+    let i = 0;
+    while (i < content.length) {
+        i = skipWs(content, i);
+        if (i >= content.length)
+            break;
+        const ch = content[i];
+        const tokenStart = i;
+        if (ch === '(' || ch === '<' || ch === '[' || ch === '/' || ch === '{' || ch === '}') {
+            if (ch === '{' || ch === '}') {
+                i += 1;
+            }
+            else {
+                i = parseValue(content, i).end;
+            }
+            if (operandStart === null)
+                operandStart = tokenStart;
+            continue;
+        }
+        if (ch === ']' || ch === '>' || ch === ')') {
+            /* Stoerzeichen ueberspringen, nicht deuten. */
+            i += 1;
+            continue;
+        }
+        const end = regularEnd(content, i);
+        const word = content.slice(i, end);
+        i = end;
+        if (NUMBER.test(word) || word === 'true' || word === 'false' || word === 'null') {
+            if (operandStart === null)
+                operandStart = tokenStart;
+            continue;
+        }
+        /* Operator */
+        const opStart = operandStart ?? tokenStart;
+        operandStart = null;
+        if (word === 'BI') {
+            /* Inline-Bild: bis ID, dann Binaerdaten bis EI. */
+            const id = content.indexOf('ID', i);
+            if (id < 0)
+                break;
+            const ei = /\sEI(?=[\s\x00]|$)/g;
+            ei.lastIndex = id + 3;
+            const match = ei.exec(content);
+            i = match === null ? content.length : match.index + 3;
+            pathStart = null;
+            continue;
+        }
+        if (PATH_CONSTRUCTION.has(word)) {
+            if (pathStart === null)
+                pathStart = opStart;
+            continue;
+        }
+        if (CLIPPING.has(word))
+            continue;
+        if (PATH_PAINTING.has(word)) {
+            if (pathStart !== null && depth === 0 && !inText)
+                ranges.push([pathStart, i]);
+            pathStart = null;
+            continue;
+        }
+        if (word === 'sh') {
+            if (depth === 0 && !inText)
+                ranges.push([opStart, i]);
+            pathStart = null;
+            continue;
+        }
+        pathStart = null;
+        if (word === 'BDC' || word === 'BMC')
+            depth += 1;
+        else if (word === 'EMC')
+            depth = Math.max(0, depth - 1);
+        else if (word === 'BT')
+            inText = true;
+        else if (word === 'ET')
+            inText = false;
+    }
+    return ranges;
+}
+export function wrapAsArtifacts(content, ranges) {
+    let out = '';
+    let last = 0;
+    for (const [start, end] of ranges) {
+        out += content.slice(last, start) + '\n/Artifact BMC\n' + content.slice(start, end) + '\nEMC\n';
+        last = end;
+    }
+    return out + content.slice(last);
+}
+/* ------------------------------------------------------------------- XMP */
+const PDFUA_NS = 'http://www.aiim.org/pdfua/ns/id/';
+export function addPdfUaIdentifier(xmp) {
+    if (/pdfuaid:part/.test(xmp))
+        return { xmp, existed: true };
+    const close = xmp.lastIndexOf('</rdf:RDF>');
+    if (close < 0)
+        throw new PdfPostprocessError('The XMP metadata has no rdf:RDF element.', 'xmp_structure');
+    const description = '<rdf:Description rdf:about="" xmlns:pdfuaid="' + PDFUA_NS + '">\n' +
+        '         <pdfuaid:part>1</pdfuaid:part>\n' +
+        '      </rdf:Description>\n   ';
+    return { xmp: xmp.slice(0, close) + description + xmp.slice(close), existed: false };
+}
+const XMP_SKELETON = '<?xpacket begin="\u00ef\u00bb\u00bf" id="W5M0MpCehiHzreSzNTczkc9d"?>\n' +
+    '<x:xmpmeta xmlns:x="adobe:ns:meta/">\n   <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">\n   </rdf:RDF>\n</x:xmpmeta>\n<?xpacket end="w"?>';
+function streamObject(dict, data, compress) {
+    const entries = new Map(dict);
+    entries.delete('Length');
+    entries.delete('Filter');
+    entries.delete('DecodeParms');
+    entries.delete('DL');
+    const payload = compress ? deflateSync(data) : data;
+    if (compress)
+        entries.set('Filter', { t: 'name', v: 'FlateDecode' });
+    entries.set('Length', { t: 'num', raw: String(payload.length) });
+    return serialize({ t: 'dict', entries }) + '\nstream\n' + payload.toString('latin1') + '\nendstream';
+}
+function incrementalUpdate(pdf, objects) {
+    const sorted = [...objects].sort((a, b) => a.num - b.num);
+    const parts = [];
+    let offset = pdf.bytes.length;
+    const lead = pdf.src.endsWith('\n') || pdf.src.endsWith('\r') ? '' : '\n';
+    parts.push(lead);
+    offset += lead.length;
+    const offsets = new Map();
+    for (const object of sorted) {
+        offsets.set(object.num, offset);
+        const text = object.num + ' ' + object.gen + ' obj\n' + object.body + '\nendobj\n';
+        parts.push(text);
+        offset += Buffer.byteLength(text, 'latin1');
+    }
+    const oldSize = numberOf(pdf.trailer.get('Size')) ?? pdf.maxObjectNumber + 1;
+    const keep = ['Root', 'Info', 'ID'];
+    const trailerEntries = new Map();
+    if (pdf.usesXrefStream) {
+        const xrefNum = Math.max(oldSize, ...sorted.map((o) => o.num + 1));
+        const all = [...sorted.map((o) => ({ num: o.num, gen: o.gen, at: offsets.get(o.num) })), { num: xrefNum, gen: 0, at: offset }];
+        const index = [];
+        for (const entry of all) {
+            const lastStart = index.length >= 2 ? index[index.length - 2] : -2;
+            const lastCount = index.length >= 2 ? index[index.length - 1] : 0;
+            if (lastStart + lastCount === entry.num)
+                index[index.length - 1] = lastCount + 1;
+            else
+                index.push(entry.num, 1);
+        }
+        const data = Buffer.alloc(all.length * 7);
+        all.forEach((entry, k) => {
+            data[k * 7] = 1;
+            data.writeUInt32BE(entry.at, k * 7 + 1);
+            data.writeUInt16BE(entry.gen, k * 7 + 5);
+        });
+        trailerEntries.set('Type', { t: 'name', v: 'XRef' });
+        trailerEntries.set('Size', { t: 'num', raw: String(xrefNum + 1) });
+        trailerEntries.set('Index', { t: 'arr', items: index.map((n) => ({ t: 'num', raw: String(n) })) });
+        trailerEntries.set('W', { t: 'arr', items: [1, 4, 2].map((n) => ({ t: 'num', raw: String(n) })) });
+        for (const key of keep) {
+            const value = pdf.trailer.get(key);
+            if (value !== undefined)
+                trailerEntries.set(key, value);
+        }
+        trailerEntries.set('Prev', { t: 'num', raw: String(pdf.lastXrefOffset) });
+        trailerEntries.set('Length', { t: 'num', raw: String(data.length) });
+        parts.push(xrefNum + ' 0 obj\n' + serialize({ t: 'dict', entries: trailerEntries }) + '\nstream\n' + data.toString('latin1') + '\nendstream\nendobj\n');
+        parts.push('startxref\n' + offset + '\n%%EOF\n');
+    }
+    else {
+        let table = 'xref\n';
+        let k = 0;
+        while (k < sorted.length) {
+            let run = 1;
+            while (k + run < sorted.length && sorted[k + run].num === sorted[k].num + run)
+                run += 1;
+            table += sorted[k].num + ' ' + run + '\n';
+            for (let r = 0; r < run; r++) {
+                const object = sorted[k + r];
+                table += String(offsets.get(object.num)).padStart(10, '0') + ' ' + String(object.gen).padStart(5, '0') + ' n\r\n';
+            }
+            k += run;
+        }
+        const size = Math.max(oldSize, ...sorted.map((o) => o.num + 1));
+        trailerEntries.set('Size', { t: 'num', raw: String(size) });
+        for (const key of keep) {
+            const value = pdf.trailer.get(key);
+            if (value !== undefined)
+                trailerEntries.set(key, value);
+        }
+        trailerEntries.set('Prev', { t: 'num', raw: String(pdf.lastXrefOffset) });
+        parts.push(table + 'trailer\n' + serialize({ t: 'dict', entries: trailerEntries }) + '\nstartxref\n' + offset + '\n%%EOF\n');
+    }
+    return Buffer.concat([pdf.bytes, Buffer.from(parts.join(''), 'latin1')]);
+}
+function pageList(pdf, root) {
+    const pages = [];
+    const seen = new Set();
+    const visit = (node, depth) => {
+        if (node === undefined || node.t !== 'ref' || depth > 64 || seen.has(node.n))
+            return;
+        seen.add(node.n);
+        const dict = pdf.resolve(node);
+        if (dict === undefined || dict.t !== 'dict')
+            return;
+        const type = dict.entries.get('Type');
+        const kids = pdf.resolve(dict.entries.get('Kids'));
+        if (kids !== undefined && kids.t === 'arr' && !(type !== undefined && type.t === 'name' && type.v === 'Page')) {
+            for (const kid of kids.items)
+                visit(kid, depth + 1);
+            return;
+        }
+        const refs = [];
+        let contents = dict.entries.get('Contents');
+        if (contents !== undefined && contents.t === 'ref') {
+            const target = pdf.getObject(contents.n);
+            if (target !== null && target.value.t === 'arr')
+                contents = target.value;
+        }
+        if (contents !== undefined && contents.t === 'ref')
+            refs.push(contents.n);
+        else if (contents !== undefined && contents.t === 'arr')
+            for (const item of contents.items)
+                if (item.t === 'ref')
+                    refs.push(item.n);
+        pages.push({ num: node.n, dict: dict.entries, contents: refs });
+    };
+    visit(root.get('Pages'), 0);
+    return pages;
+}
+/** Der Inhalt einer Seite als ein Text: die Teilstroeme gelten als aneinandergehaengt (ISO 32000-1, 7.8.2). */
+function pageContent(pdf, page) {
+    const parts = [];
+    for (const num of page.contents) {
+        const object = pdf.getObject(num);
+        if (object === null || object.stream === null || object.value.t !== 'dict')
+            return null;
+        parts.push(pdf.decodeStream(object.value.entries, object.stream).toString('latin1'));
+    }
+    return parts.join('\n');
+}
+export function postprocessPdf(path, options) {
+    const pdf = new PdfFile(readFileSync(path));
+    if (pdf.trailer.has('Encrypt'))
+        throw new PdfPostprocessError('The PDF is encrypted; it is left unchanged.', 'pdf_encrypted');
+    const rootRef = pdf.trailer.get('Root');
+    if (rootRef === undefined || rootRef.t !== 'ref')
+        throw new PdfPostprocessError('The PDF has no document catalog.', 'pdf_structure');
+    const rootObject = pdf.getObject(rootRef.n);
+    const root = dictOf(rootObject?.value, 'Catalog');
+    const tagged = root.has('StructTreeRoot');
+    const objects = [];
+    const result = {
+        bytes: pdf.bytes.length,
+        tagged,
+        pages: 0,
+        untagged_paths_found: 0,
+        untagged_paths_marked: 0,
+        content_streams_changed: 0,
+        pdfua_identifier_set: false,
+        pdfua_identifier_existed: false,
+    };
+    const pages = pageList(pdf, root);
+    result.pages = pages.length;
+    let nextNum = Math.max(numberOf(pdf.trailer.get('Size')) ?? 0, pdf.maxObjectNumber + 1);
+    for (const page of pages) {
+        const content = pageContent(pdf, page);
+        if (content === null)
+            continue;
+        const ranges = findUntaggedPaths(content);
+        result.untagged_paths_found += ranges.length;
+        if (options.artifactPaths && ranges.length > 0) {
+            const streamNum = nextNum++;
+            objects.push({ num: streamNum, gen: 0, body: streamObject(new Map(), Buffer.from(wrapAsArtifacts(content, ranges), 'latin1'), true) });
+            const newPage = new Map(page.dict);
+            newPage.set('Contents', { t: 'ref', n: streamNum, g: 0 });
+            objects.push({ num: page.num, gen: pdf.generationOf(page.num), body: serialize({ t: 'dict', entries: newPage }) });
+            result.untagged_paths_marked += ranges.length;
+            result.content_streams_changed += 1;
+        }
+    }
+    if (options.pdfua) {
+        const metaRef = root.get('Metadata');
+        let metaNum;
+        let metaDict = new Map([
+            ['Type', { t: 'name', v: 'Metadata' }],
+            ['Subtype', { t: 'name', v: 'XML' }],
+        ]);
+        let xmp = XMP_SKELETON;
+        if (metaRef !== undefined && metaRef.t === 'ref') {
+            metaNum = metaRef.n;
+            const meta = pdf.getObject(metaNum);
+            if (meta !== null && meta.stream !== null && meta.value.t === 'dict') {
+                metaDict = meta.value.entries;
+                xmp = pdf.decodeStream(meta.value.entries, meta.stream).toString('latin1');
+            }
+        }
+        else {
+            metaNum = nextNum++;
+            const newRoot = new Map(root);
+            newRoot.set('Metadata', { t: 'ref', n: metaNum, g: 0 });
+            objects.push({ num: rootRef.n, gen: pdf.generationOf(rootRef.n), body: serialize({ t: 'dict', entries: newRoot }) });
+        }
+        const added = addPdfUaIdentifier(xmp);
+        result.pdfua_identifier_existed = added.existed;
+        if (!added.existed) {
+            objects.push({ num: metaNum, gen: pdf.generationOf(metaNum), body: streamObject(metaDict, Buffer.from(added.xmp, 'latin1'), false) });
+        }
+        result.pdfua_identifier_set = true;
+    }
+    if (objects.length > 0) {
+        const updated = incrementalUpdate(pdf, objects);
+        writeFileSync(path, updated);
+        result.bytes = updated.length;
+    }
+    return result;
+}
+/** Nur lesen: PDF/UA-Kennung und Zahl ungetaggter Pfade (fuer Tests und Pruefungen). */
+export function inspectPdf(path) {
+    const pdf = new PdfFile(readFileSync(path));
+    const rootRef = pdf.trailer.get('Root');
+    const root = dictOf(rootRef === undefined ? undefined : pdf.resolve(rootRef), 'Catalog');
+    let part = null;
+    const metaRef = root.get('Metadata');
+    if (metaRef !== undefined && metaRef.t === 'ref') {
+        const meta = pdf.getObject(metaRef.n);
+        if (meta !== null && meta.stream !== null && meta.value.t === 'dict') {
+            const xmp = pdf.decodeStream(meta.value.entries, meta.stream).toString('latin1');
+            const m = /<pdfuaid:part>\s*(\d+)\s*<\/pdfuaid:part>|pdfuaid:part="(\d+)"/.exec(xmp);
+            if (m)
+                part = m[1] ?? m[2] ?? null;
+        }
+    }
+    const pages = pageList(pdf, root);
+    let untagged = 0;
+    for (const page of pages) {
+        const content = pageContent(pdf, page);
+        if (content !== null)
+            untagged += findUntaggedPaths(content).length;
+    }
+    return { pdfua_part: part, untagged_paths: untagged, pages: pages.length, tagged: root.has('StructTreeRoot') };
+}
+//# sourceMappingURL=pdf-postprocess.js.map