@patrickdk77/pdf-defuse 0.2.3 → 0.2.4

package/dist/walker.js

@@ -47,6 +47,7 @@ const sniff_1 = require("./sniff");
 const types_1 = require("./types");
 const uri_1 = require("./uri");
 const writer_1 = require("./writer");
+const xfa_1 = require("./xfa");
 const ACTION_TYPES = new Set([
     'GoTo',
     'GoToR',
@@ -366,6 +367,14 @@ class Walker {
      */
     fileDecisions = new Map();
     jsReplace = new Map();
+    /** XFA packet streams with their cleaned text, by object number. */
+    xfaReplace = new Map();
+    /** Per XFA entry, by owner and path, the value phase A decided to write, or null when the form goes whole. */
+    xfaDone = new Map();
+    /** Set once an XFA form goes into the output, so the catalog keeps NeedsRendering. */
+    xfaKept = false;
+    /** XFA packet streams, which stay packets whatever their /Type says. Some producers mark them as embedded files. */
+    xfaRole = new Set();
     jsTree;
     efTree;
     keptDocScripts = [];
@@ -440,6 +449,12 @@ class Walker {
         this.push(f);
         return f;
     }
+    /** What a script plugin found in a script, at the script's location unless the plugin gave a finer one. */
+    pushScript(found, location) {
+        for (const f of found ?? []) {
+            this.push({ ...f, action: f.action === 'reject' ? 'strip' : f.action, location: f.location ?? location, data: f.data && { ...f.data } });
+        }
+    }
     /**
      * Adds the findings a plugin reported from inside a contained file, labeled with the file's name and place.
      * A reject inside the file means the file goes, not the upload, so it is recorded here as strip.
@@ -1192,7 +1207,7 @@ class Walker {
                 return undefined;
             // A stream decided as a contained file stays one, whether or not it says /Type /EmbeddedFile, unless it is a page's
             // content: only the reference that made it a contained file goes then.
-            let kind = obj instanceof objects_1.PdfStream && this.fileDecisions.has(num) ? 'efStream' : this.kindOf(obj, num, await this.actionType(d));
+            let kind = obj instanceof objects_1.PdfStream && this.xfaRole.has(num) ? 'generic' : obj instanceof objects_1.PdfStream && this.fileDecisions.has(num) ? 'efStream' : this.kindOf(obj, num, await this.actionType(d));
             if (kind === 'efStream' && this.contentRole.has(num))
                 kind = 'generic';
             // Nothing reads a stream encrypted with a key the password does not give, and pdf.js draws a page without it.
@@ -1370,14 +1385,13 @@ class Walker {
                 continue;
             }
             if (k === 'XFA') {
-                const f = this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.Xfa, 'form');
-                if (f.action === 'strip') {
-                    await this.reach(v);
-                    continue;
-                }
+                const x = await this.handleXfa(v, child, owner, p);
+                if (x !== undefined)
+                    out.set(k, x);
+                continue;
             }
-            // XFA rendering goes with any rewrite. A file passed through unchanged keeps it, so it is no removal.
-            if (k === 'NeedsRendering' && this.phase === 'B')
+            // XFA rendering goes with the XFA form. A file passed through unchanged keeps it, so it is no removal.
+            if (k === 'NeedsRendering' && this.phase === 'B' && !this.xfaKept)
                 continue;
             if (k === 'Metadata') {
                 // XMP, on the catalog, a page, an image or anything else.
@@ -1712,6 +1726,314 @@ class Walker {
         await this.alsoAction(d, ctx, owner, path, out, taken);
         return this.handleGeneric(d, { location: 'document names', shadow: ctx.shadow }, owner, path, taken, out);
     }
+    // ---------- XFA ----------
+    /**
+     * An XFA form: its packets are read, every script goes to the script plugins, and what reaches outside the form
+     * goes. A form that cannot be read exactly goes whole, and so does every form when FORM/XFA is set to strip.
+     */
+    async handleXfa(v, ctx, owner, path) {
+        const key = owner + path;
+        if (this.phase === 'B') {
+            const done = this.xfaDone.get(key);
+            return done ? this.tv(done, ctx, owner, path) : undefined;
+        }
+        if (ctx.shadow) {
+            await this.reach(v);
+            return undefined;
+        }
+        const cached = this.xfaDone.get(key);
+        if (cached !== undefined)
+            return cached === null ? undefined : this.tv(cached, ctx, owner, path);
+        let out = null;
+        if (this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.Xfa, 'form').action !== 'strip') {
+            try {
+                out = await this.cleanXfa(v);
+            }
+            catch (e) {
+                if (e instanceof filters_1.DecompressionLimitError || e instanceof document_1.TimeLimitError || e instanceof document_1.ObjectLimitError)
+                    throw e;
+                this.passOn(e);
+                const reason = e instanceof xfa_1.XfaReadError ? e.message : `it could not be decoded (${String(e?.message ?? e).slice(0, 80)})`;
+                this.emitRemoval(types_1.PdfCategory.Form, types_1.PdfDetail.XfaUnreadable, 'form', { reason });
+            }
+        }
+        this.xfaDone.set(key, out);
+        if (out === null) {
+            await this.reach(v);
+            return undefined;
+        }
+        this.xfaKept = true;
+        return this.tv(out, ctx, owner, path);
+    }
+    /** Returns the XFA entry to write. Cleaned packet text goes into xfaReplace, keyed by the stream that holds it. */
+    async cleanXfa(v) {
+        const streamRef = async (r) => {
+            if (!(r instanceof objects_1.PdfRef))
+                throw new xfa_1.XfaReadError('a packet that is not a stream');
+            let ref = r;
+            let o = await this.doc.getObject(ref);
+            for (let i = 1; i < 32 && o instanceof objects_1.PdfRef; i++) {
+                ref = o;
+                o = await this.doc.getObject(ref);
+            }
+            if (!(o instanceof objects_1.PdfStream))
+                throw new xfa_1.XfaReadError('a packet that is not a stream');
+            if (!this.doc.canDecrypt(o, ref.num))
+                throw new xfa_1.XfaReadError('a packet encrypted with a key the password does not give');
+            return { ref, stream: o };
+        };
+        const value = await this.doc.resolve(v);
+        const packets = [];
+        if (value instanceof objects_1.PdfStream)
+            packets.push(await streamRef(v));
+        else if (Array.isArray(value)) {
+            if (value.length % 2)
+                throw new xfa_1.XfaReadError('a packet array of odd length');
+            for (let i = 0; i < value.length; i += 2) {
+                if (!(value[i] instanceof objects_1.PdfString))
+                    throw new xfa_1.XfaReadError('a packet without a name');
+                packets.push({ name: value[i], ...(await streamRef(value[i + 1])) });
+            }
+        }
+        else
+            throw new xfa_1.XfaReadError('an XFA entry that is neither a stream nor a packet array');
+        if (new Set(packets.map(p => p.ref.num)).size !== packets.length)
+            throw new xfa_1.XfaReadError('a packet stream listed twice');
+        for (const p of packets)
+            this.xfaRole.add(p.ref.num);
+        const bodies = [];
+        for (const p of packets) {
+            const bytes = await this.doc.decode(p.stream, p.ref.num, this.options.limits?.decompressedBytes);
+            bodies.push(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.length).toString('latin1'));
+        }
+        const whole = bodies.join('');
+        try {
+            new TextDecoder('utf-8', { fatal: true }).decode(Buffer.from(whole, 'latin1'));
+        }
+        catch {
+            throw new xfa_1.XfaReadError('bytes that are not UTF-8');
+        }
+        const plan = (0, xfa_1.planXfa)(whole, { stripMetadata: this.options.stripMetadata });
+        const edits = [];
+        const cut = [];
+        const inCut = (a, b) => cut.some(([x, y]) => a >= x && b <= y);
+        const where = (packet, som) => `XFA ${packet}${som ? `, ${som}` : ''}`;
+        for (const r of plan.removals) {
+            if (inCut(r.start, r.end))
+                continue;
+            const loc = where(r.packet, r.som);
+            const what = short(r.what, 120);
+            const f = r.kind === 'packet'
+                ? this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaPacket, loc, { packet: what })
+                : r.kind === 'submit'
+                    ? this.emit(types_1.PdfCategory.Action, types_1.PdfDetail.SubmitForm, loc, { target: what })
+                    : r.kind === 'execute'
+                        ? this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaExecute, loc, { connection: what })
+                        : r.kind === 'connection'
+                            ? this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaConnection, loc, { connection: what })
+                            : r.kind === 'exObject'
+                                ? this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaExternalObject, loc, { object: what })
+                                : this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaExternalReference, loc, { reference: what });
+            if (f.action !== 'strip')
+                continue;
+            edits.push({ start: r.start, end: r.end, insert: '' });
+            cut.push([r.start, r.end]);
+        }
+        for (const sc of plan.scripts) {
+            if (inCut(sc.start, sc.end))
+                continue;
+            const d = await this.decideXfaScript(sc);
+            if (!d.keep)
+                edits.push({ start: sc.start, end: sc.end, insert: '' });
+            else if (d.text !== undefined)
+                edits.push({ start: sc.start, end: sc.end, insert: Buffer.from((0, xfa_1.escapeXmlText)(d.text), 'utf8').toString('latin1') });
+        }
+        for (const l of plan.links) {
+            if (inCut(l.start, l.end))
+                continue;
+            if (!this.decideXfaLink(l.uri, where(l.packet, l.som)))
+                edits.push({ start: l.start, end: l.end, insert: '' });
+        }
+        for (const img of plan.images) {
+            if (inCut(img.start, img.end))
+                continue;
+            const d = await this.decideXfaImage(img, `${where(img.packet, img.som)}, image`);
+            if (!d.keep)
+                edits.push({ start: img.start, end: img.end, insert: '' });
+            else if (d.data !== undefined)
+                edits.push({ start: img.start, end: img.end, insert: d.data });
+        }
+        if (!edits.length)
+            return v;
+        const bounds = [0];
+        for (const b of bodies)
+            bounds.push(bounds[bounds.length - 1] + b.length);
+        const per = (0, xfa_1.splitEdits)(bounds, edits);
+        const kept = [];
+        for (let k = 0; k < packets.length; k++) {
+            const p = packets[k];
+            if (per[k].length) {
+                const body = (0, xfa_1.applyEdits)(bodies[k], per[k]);
+                // A packet emptied whole goes from the array, name and all.
+                if (packets.length > 1 && !body.trim()) {
+                    await this.reach(p.ref);
+                    continue;
+                }
+                this.xfaReplace.set(p.ref.num, Buffer.from(body, 'latin1'));
+            }
+            if (p.name)
+                kept.push(p.name, p.ref);
+        }
+        if (value instanceof objects_1.PdfStream)
+            return v;
+        // The array is written in place, so an array object of its own is no longer referenced.
+        if (v instanceof objects_1.PdfRef && !this.visited.has(v.num))
+            this.reached.add(v.num);
+        return kept;
+    }
+    /** Runs the script plugins over an XFA script. Returns whether it stays, and its new text when a plugin rewrote it. */
+    async decideXfaScript(sc) {
+        const location = `XFA ${sc.packet}${sc.som ? `, ${sc.som}` : ''}, ${sc.activity}`;
+        const trigger = `xfa-${sc.activity}`;
+        const verify = sc.language ? this.cfg.verify?.scripts.get(sc.text) : undefined;
+        if (verify) {
+            this.emit(types_1.PdfCategory.JavaScript, verify.result === 'passed' ? types_1.PdfDetail.PluginPassed : types_1.PdfDetail.PluginScrubbed, location, { plugin: verify.plugin });
+            return { keep: true };
+        }
+        const language = sc.language === 'formcalc' ? 'FormCalc' : sc.language === 'javascript' ? 'JavaScript' : short(sc.contentType || 'an unreadable form', 40);
+        const f = this.cfg.factory.make(types_1.PdfCategory.JavaScript, types_1.PdfDetail.Xfa, location, { trigger, length: sc.text.length, language });
+        let decision = { keep: f.action !== 'strip' && sc.language !== undefined };
+        let answer;
+        let found;
+        if (f.action === 'strip' && sc.language) {
+            for (const plugin of this.options.scriptPlugins ?? []) {
+                const script = {
+                    text: sc.text,
+                    trigger,
+                    location,
+                    fieldName: sc.som || undefined,
+                    keptDocumentScripts: [...this.keptDocScripts],
+                    language: sc.language,
+                    form: 'xfa',
+                };
+                const data = { plugin: plugin.name };
+                try {
+                    if (!(await plugin.accepts(script)))
+                        continue;
+                    const r = await plugin.process(script);
+                    if (Array.isArray(r.findings))
+                        found = r.findings;
+                    if (r.result === 'passed') {
+                        decision = { keep: true };
+                        answer = this.cfg.factory.make(types_1.PdfCategory.JavaScript, types_1.PdfDetail.PluginPassed, location, data);
+                        this.kept.scripts.set(sc.text, { result: 'passed', plugin: plugin.name });
+                    }
+                    else if (r.result === 'scrubbed' && typeof r.text === 'string' && r.text.length) {
+                        decision = { keep: true, text: r.text };
+                        answer = this.cfg.factory.make(types_1.PdfCategory.JavaScript, types_1.PdfDetail.PluginScrubbed, location, data);
+                        // Written with its carriage returns as references, so the output check reads back this exact text.
+                        this.kept.scripts.set(r.text, { result: 'scrubbed', plugin: plugin.name });
+                    }
+                    else
+                        answer = this.cfg.factory.make(types_1.PdfCategory.JavaScript, r.result === 'removed' ? types_1.PdfDetail.PluginRemoved : types_1.PdfDetail.PluginFailed, location, data);
+                }
+                catch (e) {
+                    this.passOn(e);
+                    answer = this.cfg.factory.make(types_1.PdfCategory.JavaScript, types_1.PdfDetail.PluginFailed, location, data);
+                }
+                break;
+            }
+            if (decision.keep)
+                f.action = 'info';
+        }
+        // A script in a language no plugin reads goes, whatever the override says.
+        if (!sc.language && f.action === 'info')
+            f.action = 'strip';
+        this.push(f);
+        if (answer)
+            this.push(answer);
+        this.pushScript(found, location);
+        return decision;
+    }
+    /**
+     * An image an XFA form carries inline goes to the file plugins, as an attached file does: a viewer decodes it with
+     * decoders of its own. Returns whether it stays, and its new base64 when a plugin rewrote it.
+     */
+    async decideXfaImage(img, loc) {
+        const type = short(img.contentType, 40);
+        const b64 = img.data.replace(/\s+/g, '');
+        // A last lone character holds six bits, no whole byte, so every decoder reads the same bytes without it.
+        if (img.transferEncoding !== 'base64' || !/^[A-Za-z0-9+/]*={0,2}$/.test(b64)) {
+            this.emitRemoval(types_1.PdfCategory.Form, types_1.PdfDetail.XfaImage, loc, { type, reason: 'Its data is not base64' });
+            return { keep: false };
+        }
+        const bytes = Buffer.from(b64, 'base64');
+        const hash = (0, node_crypto_1.createHash)('md5').update(bytes).digest('hex');
+        const expected = this.cfg.verify?.files.get(hash);
+        if (expected) {
+            this.emit(types_1.PdfCategory.Form, expected.result === 'passed' ? types_1.PdfDetail.PluginPassed : types_1.PdfDetail.PluginScrubbed, loc, { plugin: expected.plugin });
+            this.pushContained(expected.findings, loc, 'XFA image');
+            return { keep: true };
+        }
+        const sniffed = (0, sniff_1.sniffType)(bytes.subarray(0, 1024));
+        const file = { declaredType: img.contentType || undefined, sniffedType: sniffed, size: bytes.length, location: loc, depth: this.cfg.depth + 1, source: (0, io_1.bufferSource)(bytes) };
+        const context = { depth: file.depth, deadline: this.cfg.deadline, [exports.RUN_OPTIONS]: this.options };
+        for (const plugin of this.options.filePlugins ?? []) {
+            try {
+                if (!(await plugin.accepts(file)))
+                    continue;
+            }
+            catch (e) {
+                this.passOn(e);
+                continue;
+            }
+            const outSink = new io_1.SpillSink(this.cfg.temp, Number.POSITIVE_INFINITY);
+            try {
+                const out = await plugin.process(file, outSink, context);
+                const r = typeof out === 'string' ? { result: out } : (out ?? {});
+                await outSink.close();
+                const data = { plugin: plugin.name };
+                const written = outSink.length > 0 ? Buffer.from(await outSink.source().read(0, outSink.length)) : undefined;
+                this.pushContained(r.findings, loc, 'XFA image');
+                if (r.result === 'passed' || (r.result === 'scrubbed' && written)) {
+                    this.emit(types_1.PdfCategory.Form, r.result === 'passed' ? types_1.PdfDetail.PluginPassed : types_1.PdfDetail.PluginScrubbed, loc, data);
+                    // Bytes the plugin wrote are the ones kept.
+                    this.kept.files.set(written ? outSink.digest() : hash, { result: r.result, plugin: plugin.name, findings: r.outputFindings });
+                    return { keep: true, data: written && !written.equals(bytes) ? written.toString('base64') : undefined };
+                }
+                this.emitRemoval(types_1.PdfCategory.Form, r.result === 'removed' ? types_1.PdfDetail.PluginRemoved : types_1.PdfDetail.PluginFailed, loc, data);
+                return { keep: false };
+            }
+            catch (e) {
+                this.passOn(e);
+                this.emitRemoval(types_1.PdfCategory.Form, types_1.PdfDetail.PluginFailed, loc, { plugin: plugin.name });
+                return { keep: false };
+            }
+            finally {
+                await outSink.dispose();
+            }
+        }
+        const f = this.emit(types_1.PdfCategory.Form, types_1.PdfDetail.XfaImage, loc, { type: type || sniffed || '' });
+        return { keep: f.action !== 'strip' };
+    }
+    /** A link in an XFA form's rich text, checked as a link action's address is. Returns whether it stays. */
+    decideXfaLink(uri, loc) {
+        const verdict = (0, uri_1.checkUri)(uri, this.uriBase);
+        if (verdict.detail === types_1.PdfDetail.Safe) {
+            const f = this.aggregate(types_1.PdfCategory.Link, types_1.PdfDetail.Safe, data => {
+                const hosts = String(data.hosts ?? '')
+                    .split(', ')
+                    .filter(Boolean);
+                if (verdict.host && hosts.length < 20 && !hosts.includes(verdict.host))
+                    hosts.push(verdict.host);
+                data.hosts = hosts.join(', ');
+            });
+            return f.action !== 'strip';
+        }
+        const target = { uri: short(uri, 120), ...(verdict.reason ? { reason: verdict.reason } : {}) };
+        const f = verdict.detail === types_1.PdfDetail.Url ? this.emit(types_1.PdfCategory.JavaScript, types_1.PdfDetail.Url, loc, target) : this.emit(types_1.PdfCategory.Link, verdict.detail, loc, target);
+        return f.action !== 'strip';
+    }
     async handleAcroForm(d, ctx, owner, path) {
         const out = new objects_1.PdfDict();
         const taken = new Set();
@@ -2258,14 +2580,25 @@ class Walker {
         const f = this.cfg.factory.make(types_1.PdfCategory.JavaScript, ctx.jsDetail ?? types_1.PdfDetail.Annotation, ctx.location, { trigger: ctx.trigger ?? 'unknown', length });
         let decision = { keep: f.action !== 'strip' };
         let answer;
+        let found;
         if (f.action === 'strip' && !ctx.shadow && src !== undefined) {
             for (const plugin of this.options.scriptPlugins ?? []) {
-                const script = { text: src, trigger: ctx.trigger ?? 'unknown', location: ctx.location, fieldName: ctx.fieldName, keptDocumentScripts: [...this.keptDocScripts] };
+                const script = {
+                    text: src,
+                    trigger: ctx.trigger ?? 'unknown',
+                    location: ctx.location,
+                    fieldName: ctx.fieldName,
+                    keptDocumentScripts: [...this.keptDocScripts],
+                    language: 'javascript',
+                    form: 'acroform',
+                };
                 const data = { plugin: plugin.name };
                 try {
                     if (!(await plugin.accepts(script)))
                         continue;
                     const r = await plugin.process(script);
+                    if (Array.isArray(r.findings))
+                        found = r.findings;
                     if (r.result === 'passed') {
                         decision = { keep: true };
                         answer = this.cfg.factory.make(types_1.PdfCategory.JavaScript, types_1.PdfDetail.PluginPassed, ctx.location, data);
@@ -2305,6 +2638,7 @@ class Walker {
         this.push(f);
         if (answer)
             this.push(answer);
+        this.pushScript(found, ctx.location);
         if (first) {
             // One object holds one text, so a different rewrite is a refusal too, and only the slot can report it.
             if (first.keep && (!decision.keep || decision.text !== first.text)) {
@@ -2353,13 +2687,16 @@ class Walker {
             // Decided again for another slot: only a script can be decided differently, and the rest was settled before.
         }
         else if (s === 'URI') {
-            // Every reading a reader may take has to pass.
+            // Every reading a reader may take has to pass. A relative reading stays, so it does not end the check.
             const readings = uriReadings(await this.doc.resolve(d.get('URI')));
             let uri = readings[0];
             let verdict = (0, uri_1.checkUri)(uri, this.uriBase);
-            for (let i = 1; i < readings.length && verdict.detail === types_1.PdfDetail.Safe; i++) {
+            for (let i = 1; i < readings.length && (verdict.detail === types_1.PdfDetail.Safe || verdict.detail === types_1.PdfDetail.Relative); i++) {
+                const next = (0, uri_1.checkUri)(readings[i], this.uriBase);
+                if (next.detail === types_1.PdfDetail.Safe && verdict.detail === types_1.PdfDetail.Relative)
+                    continue;
                 uri = readings[i];
-                verdict = (0, uri_1.checkUri)(uri, this.uriBase);
+                verdict = next;
             }
             if (verdict.detail === types_1.PdfDetail.Safe) {
                 // A link being removed for another reason is not "kept", so it is not counted as safe.
@@ -2376,7 +2713,8 @@ class Walker {
                 keep = (f?.action ?? this.cfg.factory.actionFor(types_1.PdfCategory.Link, types_1.PdfDetail.Safe)) !== 'strip';
             }
             else {
-                const f = verdict.detail === types_1.PdfDetail.Url ? this.emit(types_1.PdfCategory.JavaScript, types_1.PdfDetail.Url, loc, { uri: short(uri, 120) }) : this.emit(types_1.PdfCategory.Link, verdict.detail, loc, { uri: short(uri, 120) });
+                const target = { uri: short(uri, 120), ...(verdict.reason ? { reason: verdict.reason } : {}) };
+                const f = verdict.detail === types_1.PdfDetail.Url ? this.emit(types_1.PdfCategory.JavaScript, types_1.PdfDetail.Url, loc, target) : this.emit(types_1.PdfCategory.Link, verdict.detail, loc, target);
                 keep = f.action !== 'strip';
             }
         }
@@ -2831,6 +3169,7 @@ class Walker {
     async writeStream(out, nn, s, num, mapRef) {
         const dict = s.dict.clone();
         const replaceJs = this.jsReplace.get(num);
+        const replaceXfa = this.xfaReplace.get(num);
         const fileDec = this.fileDecisions.get(num);
         let body;
         let compressed;
@@ -2841,6 +3180,14 @@ class Walker {
             dict.set('Length', replaceJs.length);
             body = [replaceJs];
         }
+        else if (replaceXfa) {
+            const z = zlib.deflateSync(replaceXfa);
+            dict.set('Filter', new objects_1.PdfName('FlateDecode'));
+            dict.delete('DecodeParms');
+            dict.delete('DL');
+            dict.set('Length', z.length);
+            body = [z];
+        }
         else if (fileDec?.replacement) {
             const sink = new io_1.SpillSink(this.cfg.temp, this.options.memoryThreshold ?? 8 * 1024 * 1024);
             compressed = sink;
@@ -2916,6 +3263,9 @@ class Walker {
         this.queue = [];
         this.scriptDecisions.clear();
         this.jsReplace.clear();
+        this.xfaReplace.clear();
+        this.xfaDone.clear();
+        this.xfaRole.clear();
         this.annotPage.clear();
         this.altText.clear();
         this.refusedSlots.clear();

package/dist/xfa.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Reads an XFA form's XML, the XDP, and plans what a defused copy keeps. The text is the packets' bytes read as
+ * latin1, so every offset is a byte offset into the concatenated packets. The reader is strict: anything it does not
+ * read exactly as a viewer would, such as a DOCTYPE or an unknown entity, fails the whole form instead of being
+ * guessed at.
+ */
+export interface XAttr {
+    name: string;
+    local: string;
+    /** Decoded. */
+    value: string;
+    /** From the whitespace before the name to the closing quote, so cutting it leaves the tag well formed. */
+    start: number;
+    end: number;
+}
+export interface XElement {
+    name: string;
+    local: string;
+    attrs: XAttr[];
+    start: number;
+    /** Just after the start tag's `>`. */
+    openEnd: number;
+    /** At the end tag's `<`, or openEnd for an empty element. */
+    closeStart: number;
+    end: number;
+    children: XElement[];
+    /** Character data directly inside, as ranges: text with entities, or CDATA without its markers. */
+    texts: Array<{
+        start: number;
+        end: number;
+        cdata: boolean;
+    }>;
+    parent?: XElement;
+}
+export declare class XfaReadError extends Error {
+}
+/** Decodes entity and character references in latin1 text read from UTF-8 bytes, then the UTF-8. */
+export declare function decodeXmlText(raw: string): string;
+/** Escapes text to go back between tags. A carriage return is written as a reference, so a reader keeps it. */
+export declare function escapeXmlText(s: string): string;
+/** Reads the XDP. It has one root element, and nothing but comments, processing instructions and space around it. */
+export declare function readXml(s: string): XElement;
+/** The text directly inside an element, decoded, with line ends as a reader gives them. */
+export declare function textOf(s: string, el: XElement): string;
+export declare const attrOf: (el: XElement, local: string) => XAttr | undefined;
+/** What a script's `<script>` element holds, for the script plugins. */
+export interface XfaScript {
+    /** The content between the tags, which a removal empties. */
+    start: number;
+    end: number;
+    text: string;
+    /** undefined for a content type no plugin reads, or content that is not plain text. */
+    language?: 'javascript' | 'formcalc';
+    contentType: string;
+    /** The SOM path of the node the script belongs to. */
+    som: string;
+    activity: string;
+    packet: string;
+}
+export type XfaRemovalKind = 'packet' | 'submit' | 'execute' | 'connection' | 'exObject' | 'reference';
+export interface XfaRemoval {
+    start: number;
+    end: number;
+    kind: XfaRemovalKind;
+    packet: string;
+    som: string;
+    /** What the removed part names, for the finding. */
+    what: string;
+}
+export interface XfaLink {
+    /** The href attribute, which an unsafe link loses. */
+    start: number;
+    end: number;
+    uri: string;
+    packet: string;
+    som: string;
+}
+/** An image a template, form or data value carries inline, which a viewer decodes. */
+export interface XfaImage {
+    /** The content between the tags. */
+    start: number;
+    end: number;
+    /** The text inside, still encoded. */
+    data: string;
+    contentType: string;
+    transferEncoding: string;
+    packet: string;
+    som: string;
+}
+export interface XfaPlan {
+    root: XElement;
+    scripts: XfaScript[];
+    removals: XfaRemoval[];
+    links: XfaLink[];
+    images: XfaImage[];
+}
+/**
+ * Whether an image or rich text href is a relative name, which stays unless it is written to read as another path.
+ * An address with a scheme, a drive letter or a leading slash or backslash points outside the PDF.
+ */
+export declare function isLocalHref(v: string): boolean;
+export declare function planXfa(s: string, options?: {
+    stripMetadata?: boolean;
+}): XfaPlan;
+export interface XfaEdit {
+    start: number;
+    end: number;
+    insert: string;
+}
+/** Applies edits that do not overlap, after dropping any that falls inside another. */
+export declare function applyEdits(s: string, edits: XfaEdit[]): string;
+/** Splits edits of the concatenation by packet stream. `bounds` holds each stream's start and, last, the end. */
+export declare function splitEdits(bounds: number[], edits: XfaEdit[]): XfaEdit[][];