pdf-lite 1.3.3 → 1.5.0

package/dist/acroform/pdf-acro-form.d.ts

@@ -0,0 +1,69 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfBoolean } from '../core/objects/pdf-boolean.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+import { PdfFormField } from './fields/pdf-form-field.js';
+import './fields/pdf-text-form-field.js';
+import './fields/pdf-button-form-field.js';
+import './fields/pdf-choice-form-field.js';
+import './fields/pdf-signature-form-field.js';
+import type { FormContext } from './fields/types.js';
+export type PdfDefaultResourcesDictionary = PdfDictionary<{
+    Font?: PdfDictionary;
+    ProcSet?: PdfArray;
+    ExtGState?: PdfDictionary;
+    ColorSpace?: PdfDictionary;
+    Pattern?: PdfDictionary;
+    Shading?: PdfDictionary;
+    XObject?: PdfDictionary;
+}>;
+export declare class PdfAcroForm<T extends Record<string, string> = Record<string, string>> extends PdfIndirectObject<PdfDictionary<{
+    Fields: PdfArray<PdfObjectReference>;
+    NeedAppearances?: PdfBoolean;
+    SigFlags?: PdfNumber;
+    CO?: PdfArray<PdfObjectReference>;
+    DR?: PdfDefaultResourcesDictionary;
+    DA?: PdfString;
+    Q?: PdfNumber;
+    XFA?: PdfDictionary;
+}>> implements FormContext<PdfFormField> {
+    fields: PdfFormField[];
+    private _fontEncodingCache?;
+    private document?;
+    private _xfa?;
+    constructor(options?: {
+        other?: PdfIndirectObject;
+        fields?: PdfFormField[];
+        document?: PdfDocument;
+    });
+    private get fontEncodingCache();
+    get fontEncodingMaps(): Map<string, Map<number, string>>;
+    get fontRefs(): Map<string, PdfObjectReference>;
+    setXfa(xfa: PdfXfaForm | null): void;
+    isModified(): boolean;
+    get needAppearances(): boolean;
+    set needAppearances(value: boolean);
+    get signatureFlags(): number;
+    set signatureFlags(flags: number);
+    get defaultAppearance(): string | null;
+    set defaultAppearance(da: string);
+    get defaultQuadding(): number;
+    set defaultQuadding(q: number);
+    get defaultResources(): PdfDefaultResourcesDictionary | null;
+    set defaultResources(resources: PdfDefaultResourcesDictionary | null);
+    setValues(values: Partial<T>): void;
+    importData(fields: T): void;
+    exportData(): Partial<T>;
+    getFontEncodingMap(fontName: string): Promise<Map<number, string> | null>;
+    isFontUnicode(fontName: string): boolean;
+    static fromDocument(document: PdfDocument): Promise<PdfAcroForm | null>;
+    private cacheAllFontEncodings;
+    private updatePageAnnotations;
+    getXfa(document?: PdfDocument): Promise<PdfXfaForm | null>;
+    write(document?: PdfDocument): Promise<void>;
+}

package/dist/acroform/pdf-acro-form.js

@@ -0,0 +1,293 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
+import { PdfBoolean } from '../core/objects/pdf-boolean.js';
+import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfFontEncodingCache } from './pdf-font-encoding-cache.js';
+import { PdfAnnotationWriter } from '../annotations/pdf-annotation-writer.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
+import { PdfFormField } from './fields/pdf-form-field.js';
+// Import subclasses to trigger static registration blocks
+import './fields/pdf-text-form-field.js';
+import './fields/pdf-button-form-field.js';
+import './fields/pdf-choice-form-field.js';
+import './fields/pdf-signature-form-field.js';
+export class PdfAcroForm extends PdfIndirectObject {
+    fields;
+    _fontEncodingCache;
+    document;
+    _xfa; // undefined = not set; null = explicitly no XFA
+    constructor(options) {
+        super(options?.other ??
+            new PdfIndirectObject({
+                content: new PdfDictionary(),
+            }));
+        this.fields = options?.fields ?? [];
+        this.document = options?.document;
+    }
+    get fontEncodingCache() {
+        if (!this._fontEncodingCache) {
+            this._fontEncodingCache = new PdfFontEncodingCache(this.document, this.defaultResources);
+        }
+        return this._fontEncodingCache;
+    }
+    get fontEncodingMaps() {
+        return this.fontEncodingCache.fontEncodingMaps;
+    }
+    get fontRefs() {
+        return this.fontEncodingCache.fontRefs;
+    }
+    setXfa(xfa) {
+        this._xfa = xfa;
+    }
+    isModified() {
+        return this.content.isModified();
+    }
+    get needAppearances() {
+        return (this.content.get('NeedAppearances')?.as(PdfBoolean)?.value ?? false);
+    }
+    set needAppearances(value) {
+        this.content.set('NeedAppearances', new PdfBoolean(value));
+    }
+    get signatureFlags() {
+        return this.content.get('SigFlags')?.as(PdfNumber)?.value ?? 0;
+    }
+    set signatureFlags(flags) {
+        this.content.set('SigFlags', new PdfNumber(flags));
+    }
+    get defaultAppearance() {
+        return this.content.get('DA')?.as(PdfString)?.value ?? null;
+    }
+    set defaultAppearance(da) {
+        this.content.set('DA', new PdfString(da));
+    }
+    get defaultQuadding() {
+        return this.content.get('Q')?.as(PdfNumber)?.value ?? 0;
+    }
+    set defaultQuadding(q) {
+        this.content.set('Q', new PdfNumber(q));
+    }
+    get defaultResources() {
+        return this.content.get('DR')?.as(PdfDictionary) ?? null;
+    }
+    set defaultResources(resources) {
+        if (resources === null) {
+            this.content.delete('DR');
+        }
+        else {
+            this.content.set('DR', resources);
+        }
+    }
+    setValues(values) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name in values && values[name] !== undefined) {
+                field.value = values[name];
+            }
+        }
+    }
+    importData(fields) {
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name && name in fields) {
+                field.value = fields[name];
+            }
+        }
+    }
+    exportData() {
+        const result = {};
+        for (const field of this.fields) {
+            const name = field.name;
+            if (name) {
+                result[name] = field.value;
+            }
+        }
+        return result;
+    }
+    async getFontEncodingMap(fontName) {
+        return this.fontEncodingCache.getFontEncodingMap(fontName);
+    }
+    isFontUnicode(fontName) {
+        return this.fontEncodingCache.isFontUnicode(fontName);
+    }
+    static async fromDocument(document) {
+        const catalog = document.root;
+        if (!catalog)
+            return null;
+        const acroFormRef = catalog.content.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        let acroFormDict;
+        let acroFormContainer;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await document.readObject(acroFormRef);
+            if (!acroFormObject)
+                return null;
+            if (!(acroFormObject.content instanceof PdfDictionary))
+                throw new Error('AcroForm content must be a dictionary');
+            acroFormDict = acroFormObject.content;
+            acroFormContainer = acroFormObject;
+        }
+        else if (acroFormRef instanceof PdfDictionary) {
+            acroFormDict = acroFormRef;
+            acroFormContainer = new PdfIndirectObject({ content: acroFormDict });
+        }
+        else {
+            return null;
+        }
+        const acroForm = new PdfAcroForm({ other: acroFormContainer, document });
+        const fields = new Map();
+        const getFields = async (fieldRefs, parent) => {
+            for (const fieldRef of fieldRefs) {
+                const refKey = fieldRef.toString().trim();
+                if (fields.has(refKey)) {
+                    fields.get(refKey).parent = parent;
+                    continue;
+                }
+                const fieldObject = await document.readObject(fieldRef);
+                if (!fieldObject)
+                    continue;
+                if (!(fieldObject.content instanceof PdfDictionary))
+                    continue;
+                const field = PdfFormField.create({
+                    other: fieldObject,
+                    form: acroForm,
+                    parent,
+                });
+                const kids = field.kids;
+                if (kids.length > 0) {
+                    await getFields(kids, field);
+                }
+                acroForm.fields.push(field);
+                fields.set(refKey, field);
+            }
+        };
+        const fieldsArray = new PdfArray();
+        if (acroForm.content.get('Fields') instanceof PdfArray) {
+            fieldsArray.items.push(...acroForm.content
+                .get('Fields')
+                .as((PdfArray)).items);
+        }
+        else if (acroForm.content.get('Fields') instanceof PdfObjectReference) {
+            const fieldsObj = await document.readObject(acroForm.content.get('Fields').as(PdfObjectReference));
+            if (fieldsObj && fieldsObj.content instanceof PdfArray) {
+                fieldsArray.items.push(...fieldsObj.content.as((PdfArray)).items);
+            }
+        }
+        await getFields(fieldsArray.items);
+        // Pre-cache font encoding maps now that this.fields is populated
+        await acroForm.cacheAllFontEncodings();
+        // Reset field-level modified flag so only explicitly changed fields are detected
+        for (const field of acroForm.fields) {
+            field.setModified(false);
+        }
+        return acroForm;
+    }
+    async cacheAllFontEncodings() {
+        await this.fontEncodingCache.cacheAllFontEncodings(this.fields);
+    }
+    async updatePageAnnotations(document, fieldsByPage) {
+        await PdfAnnotationWriter.updatePageAnnotations(document, fieldsByPage);
+    }
+    async getXfa(document) {
+        if (this._xfa) {
+            return this._xfa;
+        }
+        const doc = document || this.document;
+        if (!doc) {
+            throw new Error('No document available to load XFA form. Provide a document or ensure this AcroForm is associated with a document.');
+        }
+        this._xfa = await PdfXfaForm.fromDocument(doc);
+        return this._xfa;
+    }
+    async write(document) {
+        document ||= this.document;
+        if (!document) {
+            throw new Error('No document associated with this AcroForm');
+        }
+        const catalog = document.root;
+        const isIncremental = document.isIncremental();
+        document.setIncremental(true);
+        const xfaForm = this._xfa !== undefined
+            ? this._xfa
+            : await PdfXfaForm.fromDocument(document);
+        if (xfaForm) {
+            // Only send fields whose value was explicitly changed (field.isModified())
+            const xfaFields = this.fields
+                .filter((f) => f.isModified() && f.fieldType !== 'Signature' && f.name)
+                .map((f) => ({ name: f.name, value: f.value }));
+            if (xfaFields.length > 0) {
+                xfaForm.datasets?.updateFields(xfaFields);
+            }
+        }
+        const fieldsArray = new PdfArray();
+        this.content.set('Fields', fieldsArray);
+        const fieldsByPage = new Map();
+        // Phase 1: add appearance streams standalone (PdfStream — cannot go in ObjStm)
+        // and collect field dicts for ObjStm batching.
+        const compressibleFields = [];
+        for (const field of this.fields) {
+            if (field.content.isModified()) {
+                const appearances = field.getAppearanceStreamsForWriting();
+                if (appearances) {
+                    document.add(appearances.primary);
+                    if (appearances.secondary) {
+                        document.add(appearances.secondary);
+                    }
+                    field.setAppearanceReference(appearances.primary.reference, appearances.secondary?.reference);
+                    if (!field.print) {
+                        field.print = true;
+                    }
+                }
+                compressibleFields.push(field);
+            }
+        }
+        // Phase 2: pack field dicts into ObjStm — pre-assigns their object numbers.
+        document.addObjectsAsStream(compressibleFields);
+        // Phase 3: build fieldsArray now that field object numbers are stable.
+        for (const field of this.fields) {
+            let fieldReference;
+            if (field.content.isModified()) {
+                fieldReference = new PdfObjectReference(field.objectNumber, field.generationNumber);
+                const parentRef = field.parentRef;
+                const isWidget = field.isWidget;
+                if (parentRef && isWidget) {
+                    const pageKey = `${parentRef.objectNumber}_${parentRef.generationNumber}`;
+                    if (!fieldsByPage.has(pageKey)) {
+                        fieldsByPage.set(pageKey, {
+                            pageRef: parentRef,
+                            fieldRefs: [],
+                        });
+                    }
+                    fieldsByPage.get(pageKey).fieldRefs.push(fieldReference);
+                }
+            }
+            else {
+                fieldReference = field.reference;
+            }
+            fieldsArray.push(fieldReference);
+        }
+        await this.updatePageAnnotations(document, fieldsByPage);
+        // Phase 4: pack AcroForm dict into ObjStm AFTER fieldsArray is populated,
+        // so the dict is serialized with the correct Fields array.
+        if (this.isModified()) {
+            document.addObjectsAsStream([this]);
+            if (!catalog.content.has('AcroForm')) {
+                let updatableCatalog = catalog;
+                if (catalog.isImmutable()) {
+                    updatableCatalog = catalog.clone();
+                    document.add(updatableCatalog);
+                }
+                updatableCatalog.content.set('AcroForm', this.reference);
+            }
+        }
+        // XFA datasets stream — PdfXfaData extends PdfIndirectObject<PdfStream>, must stay standalone
+        if (xfaForm?.datasets?.isModified()) {
+            document.add(xfaForm.datasets);
+        }
+        await document.commit();
+        document.setIncremental(isIncremental);
+    }
+}

package/dist/acroform/pdf-font-encoding-cache.d.ts

@@ -0,0 +1,27 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import type { PdfDefaultResourcesDictionary } from './acroform.js';
+/**
+ * Resolves and caches font encoding maps from the form's default resources.
+ */
+export declare class PdfFontEncodingCache {
+    readonly fontEncodingMaps: Map<string, Map<number, string>>;
+    readonly fontTypes: Map<string, string>;
+    /** Object references for all resolved fonts, keyed by resource name. */
+    readonly fontRefs: Map<string, PdfObjectReference>;
+    private document?;
+    private defaultResources;
+    constructor(document: PdfDocument | undefined, defaultResources: PdfDefaultResourcesDictionary | null);
+    getFontEncodingMap(fontName: string): Promise<Map<number, string> | null>;
+    cacheAllFontEncodings(fields: Array<{
+        content: PdfDictionary;
+    }>): Promise<void>;
+    /**
+     * Walks the page-tree (page → parent → … → Pages root), looking for the
+     * font in each node's /Resources/Font dict. Stops as soon as it finds the
+     * font. PDF resource inheritance means any ancestor can supply the font.
+     */
+    private resolveFontFromPage;
+    isFontUnicode(fontName: string): boolean;
+}

package/dist/acroform/pdf-font-encoding-cache.js

@@ -0,0 +1,188 @@
+import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
+import { PdfName } from '../core/objects/pdf-name.js';
+import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { buildEncodingMap } from '../utils/decodeWithFontEncoding.js';
+/**
+ * Resolves and caches font encoding maps from the form's default resources.
+ */
+export class PdfFontEncodingCache {
+    fontEncodingMaps = new Map();
+    fontTypes = new Map();
+    /** Object references for all resolved fonts, keyed by resource name. */
+    fontRefs = new Map();
+    document;
+    defaultResources;
+    constructor(document, defaultResources) {
+        this.document = document;
+        this.defaultResources = defaultResources;
+    }
+    async getFontEncodingMap(fontName) {
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
+        }
+        const dr = this.defaultResources;
+        if (!dr)
+            return null;
+        const fontDictEntry = dr.get('Font');
+        const fonts = fontDictEntry instanceof PdfDictionary ? fontDictEntry : null;
+        if (!fonts)
+            return null;
+        const fontEntry = fonts.get(fontName);
+        const fontRef = fontEntry instanceof PdfObjectReference ? fontEntry : null;
+        if (!fontRef)
+            return null;
+        this.fontRefs.set(fontName, fontRef);
+        const fontObj = await this.document?.readObject(fontRef);
+        if (!fontObj)
+            return null;
+        const fontDict = fontObj.content instanceof PdfDictionary ? fontObj.content : null;
+        if (!fontDict)
+            return null;
+        // Cache font subtype (Type0, TrueType, Type1, etc.)
+        const subtypeEntry = fontDict.get('Subtype');
+        const subtype = subtypeEntry instanceof PdfName ? subtypeEntry.value : undefined;
+        if (subtype) {
+            this.fontTypes.set(fontName, subtype);
+        }
+        const encoding = fontDict.get('Encoding');
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document?.readObject(encoding);
+            encodingDict =
+                encodingObj?.content instanceof PdfDictionary
+                    ? encodingObj.content
+                    : null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict)
+            return null;
+        const differences = encodingDict.get('Differences')?.as(PdfArray);
+        if (!differences)
+            return null;
+        const encodingMap = buildEncodingMap(differences);
+        if (!encodingMap)
+            return null;
+        this.fontEncodingMaps.set(fontName, encodingMap);
+        return encodingMap;
+    }
+    async cacheAllFontEncodings(fields) {
+        // Collect font names with an associated page ref for the first field
+        // that uses them (needed to fall back to page resources).
+        const fontPageRefs = new Map();
+        for (const field of fields) {
+            const daEntry = field.content.get('DA');
+            const da = daEntry instanceof PdfString ? daEntry.value : undefined;
+            if (da) {
+                const fontMatch = da.match(/\/(\w+)\s+[\d.]+\s+Tf/);
+                if (fontMatch) {
+                    const fontName = fontMatch[1];
+                    if (!fontPageRefs.has(fontName)) {
+                        const pageEntry = field.content.get('P');
+                        const pageRef = pageEntry instanceof PdfObjectReference
+                            ? pageEntry
+                            : null;
+                        fontPageRefs.set(fontName, pageRef);
+                    }
+                }
+            }
+        }
+        for (const [fontName, pageRef] of fontPageRefs) {
+            await this.getFontEncodingMap(fontName);
+            // If the font was not in the AcroForm DR, try the field's page resources
+            if (!this.fontRefs.has(fontName) && pageRef) {
+                await this.resolveFontFromPage(fontName, pageRef);
+            }
+        }
+    }
+    /**
+     * Walks the page-tree (page → parent → … → Pages root), looking for the
+     * font in each node's /Resources/Font dict. Stops as soon as it finds the
+     * font. PDF resource inheritance means any ancestor can supply the font.
+     */
+    async resolveFontFromPage(fontName, pageRef) {
+        if (!this.document)
+            return;
+        // Walk up the parent chain (max 16 levels to avoid infinite loops)
+        let currentRef = pageRef;
+        for (let depth = 0; depth < 16 && currentRef; depth++) {
+            const nodeObj = await this.document.readObject({
+                objectNumber: currentRef.objectNumber,
+                generationNumber: currentRef.generationNumber,
+            });
+            const nodeDict = nodeObj?.content instanceof PdfDictionary
+                ? nodeObj.content
+                : null;
+            if (!nodeDict)
+                break;
+            // Try Resources.Font in this node
+            const resourcesEntry = nodeDict.get('Resources');
+            const resources = resourcesEntry instanceof PdfDictionary ? resourcesEntry : null;
+            if (resources) {
+                const fontsEntry = resources.get('Font');
+                const fonts = fontsEntry instanceof PdfDictionary ? fontsEntry : null;
+                if (fonts) {
+                    const fontEntry = fonts.get(fontName);
+                    const fontRef = fontEntry instanceof PdfObjectReference
+                        ? fontEntry
+                        : null;
+                    if (fontRef) {
+                        // Found — cache and finish
+                        currentRef = fontRef;
+                        break;
+                    }
+                }
+            }
+            // Walk to parent
+            const parentEntry = nodeDict.get('Parent');
+            currentRef =
+                parentEntry instanceof PdfObjectReference ? parentEntry : null;
+        }
+        const fontRef = currentRef;
+        if (!fontRef)
+            return;
+        this.fontRefs.set(fontName, fontRef);
+        const fontObj = await this.document.readObject({
+            objectNumber: fontRef.objectNumber,
+            generationNumber: fontRef.generationNumber,
+        });
+        const fontDict = fontObj?.content instanceof PdfDictionary ? fontObj.content : null;
+        if (!fontDict)
+            return;
+        const subtypeEntry = fontDict.get('Subtype');
+        const subtype = subtypeEntry instanceof PdfName ? subtypeEntry.value : undefined;
+        if (subtype)
+            this.fontTypes.set(fontName, subtype);
+        // Also resolve encoding map if present
+        const encoding = fontDict.get('Encoding');
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document.readObject({
+                objectNumber: encoding.objectNumber,
+                generationNumber: encoding.generationNumber,
+            });
+            encodingDict =
+                encodingObj?.content instanceof PdfDictionary
+                    ? encodingObj.content
+                    : null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict)
+            return;
+        const differencesEntry = encodingDict.get('Differences');
+        if (!(differencesEntry instanceof PdfArray))
+            return;
+        const encodingMap = buildEncodingMap(differencesEntry);
+        if (encodingMap) {
+            this.fontEncodingMaps.set(fontName, encodingMap);
+        }
+    }
+    isFontUnicode(fontName) {
+        return this.fontTypes.get(fontName) === 'Type0';
+    }
+}

package/dist/acroform/xfa/index.d.ts

@@ -0,0 +1,3 @@
+export { PdfXfaForm } from './pdf-xfa-form.js';
+export { PdfXfaData } from './pdf-xfa-data.js';
+export type { XfaFieldData } from './pdf-xfa-data.js';

package/dist/acroform/xfa/index.js

@@ -0,0 +1,2 @@
+export { PdfXfaForm } from './pdf-xfa-form.js';
+export { PdfXfaData } from './pdf-xfa-data.js';

package/dist/acroform/xfa/pdf-xfa-data.d.ts

@@ -0,0 +1,20 @@
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+export interface XfaFieldData {
+    name: string;
+    value: string;
+}
+/**
+ * Wraps an XFA datasets stream as a typed PDF indirect object.
+ * Provides methods to read/write XML and update individual field values.
+ */
+export declare class PdfXfaData extends PdfIndirectObject<PdfStream> {
+    constructor(stream: PdfIndirectObject<PdfStream>);
+    readXml(): string;
+    writeXml(xml: string): void;
+    updateField(name: string, value: string): void;
+    updateFields(fields: XfaFieldData[]): void;
+    getFieldValue(name: string): string | null;
+    private static updateFieldValue;
+    private static escapeRegex;
+}

package/dist/acroform/xfa/pdf-xfa-data.js

@@ -0,0 +1,68 @@
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
+import { PdfStream } from '../../core/objects/pdf-stream.js';
+/**
+ * Wraps an XFA datasets stream as a typed PDF indirect object.
+ * Provides methods to read/write XML and update individual field values.
+ */
+export class PdfXfaData extends PdfIndirectObject {
+    constructor(stream) {
+        super(stream);
+    }
+    readXml() {
+        const decompressed = this.content.decode();
+        return new TextDecoder().decode(decompressed);
+    }
+    writeXml(xml) {
+        this.content = PdfStream.fromString(xml);
+    }
+    updateField(name, value) {
+        let xml = this.readXml();
+        xml = PdfXfaData.updateFieldValue(xml, name, value);
+        this.writeXml(xml);
+    }
+    updateFields(fields) {
+        if (fields.length === 0)
+            return;
+        let xml = this.readXml();
+        for (const { name, value } of fields) {
+            xml = PdfXfaData.updateFieldValue(xml, name, value);
+        }
+        this.writeXml(xml);
+    }
+    getFieldValue(name) {
+        const xml = this.readXml();
+        const segments = name.split('.');
+        const leafSegment = segments[segments.length - 1];
+        const leafName = leafSegment.replace(/\[\d+\]$/, '');
+        if (leafName.startsWith('#'))
+            return null;
+        const contentRegex = new RegExp(`<${PdfXfaData.escapeRegex(leafName)}(?:\\s[^>]*)?>([\\s\\S]*?)</${PdfXfaData.escapeRegex(leafName)}\\s*>`);
+        const match = xml.match(contentRegex);
+        return match ? match[1] : null;
+    }
+    static updateFieldValue(xml, fieldName, value) {
+        const segments = fieldName.split('.');
+        const leafSegment = segments[segments.length - 1];
+        const leafName = leafSegment.replace(/\[\d+\]$/, '');
+        if (leafName.startsWith('#'))
+            return xml;
+        const escapedValue = value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+        const selfClosingRegex = new RegExp(`<${PdfXfaData.escapeRegex(leafName)}\\s*/>`);
+        if (selfClosingRegex.test(xml)) {
+            return xml.replace(selfClosingRegex, `<${leafName}>${escapedValue}</${leafName}>`);
+        }
+        const contentRegex = new RegExp(`(<${PdfXfaData.escapeRegex(leafName)}(?:\\s[^>]*)?>)[\\s\\S]*?(</${PdfXfaData.escapeRegex(leafName)}\\s*>)`);
+        if (contentRegex.test(xml)) {
+            return xml.replace(contentRegex, `$1${escapedValue}$2`);
+        }
+        return xml;
+    }
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}