pdf-lite 1.5.0 → 1.6.1

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

@@ -5,45 +5,20 @@ 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';
+import { buildEncodingMap } from '../utils/decodeWithFontEncoding.js';
+import { PdfXfaForm } from './xfa/pdf-xfa-form.js';
 export class PdfAcroForm extends PdfIndirectObject {
-    fields;
-    _fontEncodingCache;
-    document;
-    _xfa; // undefined = not set; null = explicitly no XFA
     constructor(options) {
-        super(options?.other ??
+        super(options ??
             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);
@@ -80,6 +55,69 @@ export class PdfAcroForm extends PdfIndirectObject {
             this.content.set('DR', resources);
         }
     }
+    get fields() {
+        const result = [];
+        const seen = new Set();
+        const collect = (refs) => {
+            for (const ref of refs) {
+                const key = ref.key;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const resolved = ref.resolve();
+                if (!(resolved?.content instanceof PdfDictionary))
+                    continue;
+                const dict = resolved.content;
+                const tEntry = dict.get('T');
+                const tValue = tEntry instanceof PdfString ? tEntry.value : null;
+                const hasFt = dict.has('FT');
+                if (tValue) {
+                    const field = PdfFormField.create(resolved);
+                    field.form = this;
+                    result.push(field);
+                }
+                // Only recurse into Kids for non-terminal (group) fields — those
+                // without FT. Terminal fields may have Kids that are pure widget
+                // annotations (no T) which would produce duplicate names.
+                if (!hasFt) {
+                    const kids = dict.get('Kids');
+                    if (kids instanceof PdfArray && kids.items.length > 0) {
+                        collect(kids.items);
+                    }
+                }
+            }
+        };
+        const fieldsRaw = this.content.get('Fields');
+        const resolvedFields = fieldsRaw instanceof PdfObjectReference
+            ? fieldsRaw.resolve()?.content
+            : fieldsRaw;
+        collect(resolvedFields instanceof PdfArray
+            ? resolvedFields.items
+            : []);
+        return result;
+    }
+    addField(...fields) {
+        const content = this.content;
+        const fieldsRaw = content.get('Fields');
+        let fieldsArray = fieldsRaw instanceof PdfObjectReference
+            ? fieldsRaw.resolve()?.content
+            : fieldsRaw;
+        if (!fieldsArray) {
+            fieldsArray = new PdfArray();
+            content.set('Fields', fieldsArray);
+        }
+        for (const field of fields) {
+            fieldsArray.items.push(field.reference);
+            // Auto-add to the page's Annots array
+            const page = field.page;
+            if (page) {
+                page.annotations.items.push(field.reference);
+            }
+        }
+    }
+    set fields(newFields) {
+        this.content.set('Fields', PdfArray.refs(newFields));
+    }
     setValues(values) {
         for (const field of this.fields) {
             const name = field.name;
@@ -106,188 +144,60 @@ export class PdfAcroForm extends PdfIndirectObject {
         }
         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 });
+    fontEncodingMaps = new Map();
+    getFontEncodingMap(fontName) {
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
         }
-        else {
-            return null;
+        const dr = this.defaultResources;
+        const fontRaw = dr?.get('Font');
+        let fontDict;
+        if (fontRaw instanceof PdfObjectReference) {
+            const resolved = fontRaw.resolve()?.content;
+            if (resolved instanceof PdfDictionary)
+                fontDict = resolved;
         }
-        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 (fontRaw instanceof PdfDictionary) {
+            fontDict = fontRaw;
         }
-        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);
+        if (!fontDict)
+            return null;
+        const fontEntry = fontDict.get(fontName);
+        if (!fontEntry)
+            return null;
+        let fontObj;
+        if (fontEntry instanceof PdfObjectReference) {
+            const resolved = fontEntry.resolve();
+            if (resolved?.content instanceof PdfDictionary) {
+                fontObj = resolved.content;
             }
         }
-        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);
+        else if (fontEntry instanceof PdfDictionary) {
+            fontObj = fontEntry;
         }
-        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;
+        if (!fontObj)
+            return null;
+        let encObj = fontObj.get('Encoding');
+        if (encObj instanceof PdfObjectReference) {
+            encObj = encObj.resolve()?.content;
         }
-        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.');
+        const encDict = encObj instanceof PdfDictionary ? encObj : undefined;
+        const diffs = encDict?.get('Differences')?.as(PdfArray);
+        if (!diffs)
+            return null;
+        const map = buildEncodingMap(diffs);
+        if (map) {
+            this.fontEncodingMaps.set(fontName, map);
         }
-        this._xfa = await PdfXfaForm.fromDocument(doc);
-        return this._xfa;
+        return map;
     }
-    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);
+    get xfa() {
+        const xfaEntry = this.content.get('XFA');
+        if (!xfaEntry)
+            return null;
+        if (!(xfaEntry instanceof PdfArray)) {
+            return null;
         }
-        await document.commit();
-        document.setIncremental(isIncremental);
+        return new PdfXfaForm(xfaEntry);
     }
 }

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

@@ -9,12 +9,13 @@ export interface XfaFieldData {
  * 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;
+    constructor(stream: PdfIndirectObject);
+    get xml(): string;
+    set xml(xml: string);
     updateField(name: string, value: string): void;
     updateFields(fields: XfaFieldData[]): void;
     getFieldValue(name: string): string | null;
+    importData(fields: Record<string, string | undefined>): void;
     private static updateFieldValue;
     private static escapeRegex;
 }

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

@@ -1,5 +1,4 @@
 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.
@@ -8,29 +7,26 @@ export class PdfXfaData extends PdfIndirectObject {
     constructor(stream) {
         super(stream);
     }
-    readXml() {
-        const decompressed = this.content.decode();
-        return new TextDecoder().decode(decompressed);
+    get xml() {
+        return this.content.dataAsString;
     }
-    writeXml(xml) {
-        this.content = PdfStream.fromString(xml);
+    set xml(xml) {
+        this.content.dataAsString = xml;
     }
     updateField(name, value) {
-        let xml = this.readXml();
-        xml = PdfXfaData.updateFieldValue(xml, name, value);
-        this.writeXml(xml);
+        this.xml = PdfXfaData.updateFieldValue(this.xml, name, value);
     }
     updateFields(fields) {
         if (fields.length === 0)
             return;
-        let xml = this.readXml();
+        let xml = this.xml;
         for (const { name, value } of fields) {
             xml = PdfXfaData.updateFieldValue(xml, name, value);
         }
-        this.writeXml(xml);
+        this.xml = xml;
     }
     getFieldValue(name) {
-        const xml = this.readXml();
+        const xml = this.xml;
         const segments = name.split('.');
         const leafSegment = segments[segments.length - 1];
         const leafName = leafSegment.replace(/\[\d+\]$/, '');
@@ -40,6 +36,14 @@ export class PdfXfaData extends PdfIndirectObject {
         const match = xml.match(contentRegex);
         return match ? match[1] : null;
     }
+    importData(fields) {
+        for (const field in fields) {
+            const value = fields[field];
+            if (value === undefined)
+                continue;
+            this.updateField(field, value);
+        }
+    }
     static updateFieldValue(xml, fieldName, value) {
         const segments = fieldName.split('.');
         const leafSegment = segments[segments.length - 1];

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

@@ -1,11 +1,16 @@
-import { PdfDocument } from '../../pdf/pdf-document.js';
 import { PdfArray } from '../../core/objects/pdf-array.js';
+import { PdfObjectReference } from '../../core/objects/pdf-object-reference.js';
+import { PdfIndirectObject } from '../../core/objects/pdf-indirect-object.js';
 import { PdfXfaData } from './pdf-xfa-data.js';
 /**
  * Typed wrapper around the XFA name/stream-ref array.
  * Holds eagerly-loaded references to component streams like datasets.
  */
-export declare class PdfXfaForm extends PdfArray {
-    datasets: PdfXfaData | null;
-    static fromDocument(document: PdfDocument): Promise<PdfXfaForm | null>;
+export declare class PdfXfaForm {
+    private xfaEntry?;
+    constructor(xfaEntry?: PdfArray<PdfObjectReference>);
+    get components(): {
+        [type: string]: PdfIndirectObject;
+    };
+    get datasets(): PdfXfaData | null;
 }

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

@@ -1,5 +1,3 @@
-import { PdfArray } from '../../core/objects/pdf-array.js';
-import { PdfDictionary } from '../../core/objects/pdf-dictionary.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';
@@ -8,49 +6,29 @@ import { PdfXfaData } from './pdf-xfa-data.js';
  * Typed wrapper around the XFA name/stream-ref array.
  * Holds eagerly-loaded references to component streams like datasets.
  */
-export class PdfXfaForm extends PdfArray {
-    datasets = null;
-    static async fromDocument(document) {
-        const catalog = document.root;
-        const acroFormRef = catalog.content.get('AcroForm');
-        if (!acroFormRef)
-            return null;
-        let acroFormDict;
-        if (acroFormRef instanceof PdfObjectReference) {
-            const acroFormObject = await document.readObject(acroFormRef);
-            if (!acroFormObject)
-                return null;
-            acroFormDict = acroFormObject.content.as(PdfDictionary);
-        }
-        else if (acroFormRef instanceof PdfDictionary) {
-            acroFormDict = acroFormRef;
-        }
-        else {
-            return null;
-        }
-        const xfaArray = acroFormDict.get('XFA');
-        if (!(xfaArray instanceof PdfArray))
-            return null;
-        const form = new PdfXfaForm(xfaArray.items.slice());
-        // Find the datasets reference in the name/ref pairs
-        const items = xfaArray.items;
+export class PdfXfaForm {
+    xfaEntry;
+    constructor(xfaEntry) {
+        this.xfaEntry = xfaEntry;
+    }
+    get components() {
+        const result = {};
+        const items = this.xfaEntry?.items ?? [];
         for (let i = 0; i < items.length - 1; i += 2) {
             const name = items[i];
             const ref = items[i + 1];
             if (name instanceof PdfString &&
-                name.value === 'datasets' &&
                 ref instanceof PdfObjectReference) {
-                const datasetObject = (await document.readObject({
-                    objectNumber: ref.objectNumber,
-                    generationNumber: ref.generationNumber,
-                    allowUnindexed: true,
-                }))?.as((PdfIndirectObject));
-                if (datasetObject) {
-                    form.datasets = new PdfXfaData(datasetObject);
-                }
-                break;
+                result[name.value] = ref.resolve().as(PdfIndirectObject);
             }
         }
-        return form;
+        return result;
+    }
+    get datasets() {
+        const datasetsRef = this.components['datasets'];
+        if (!datasetsRef) {
+            return null;
+        }
+        return datasetsRef.becomes(PdfXfaData);
     }
 }

package/dist/annotations/index.d.ts

@@ -1,4 +1,3 @@
 export { PdfAnnotation, type PdfAppearanceStreamDictionary, } from './pdf-annotation.js';
 export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
 export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';
-export { PdfAnnotationWriter } from './pdf-annotation-writer.js';

package/dist/annotations/index.js

@@ -1,4 +1,3 @@
 export { PdfAnnotation, } from './pdf-annotation.js';
 export { PdfAnnotationFlags } from './pdf-annotation-flags.js';
 export { PdfWidgetAnnotation } from './pdf-widget-annotation.js';
-export { PdfAnnotationWriter } from './pdf-annotation-writer.js';

package/dist/annotations/pdf-annotation.d.ts

@@ -5,6 +5,7 @@ import { PdfArray } from '../core/objects/pdf-array.js';
 import { PdfNumber } from '../core/objects/pdf-number.js';
 import { PdfName } from '../core/objects/pdf-name.js';
 import { PdfString } from '../core/objects/pdf-string.js';
+import { PdfPage } from '../pdf/pdf-page.js';
 export type PdfAppearanceStreamDictionary = PdfDictionary<{
     N: PdfObjectReference | PdfDictionary;
     R?: PdfObjectReference | PdfDictionary;
@@ -23,7 +24,8 @@ export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
     DV: PdfString | PdfName;
     V: PdfString | PdfName;
     DA: PdfString;
-    Opt: PdfArray<PdfString | PdfArray<PdfString>>;
+    DR: PdfDictionary | PdfObjectReference;
+    Opt: PdfArray<PdfString | PdfArray<PdfString>> | PdfObjectReference;
     MaxLen: PdfNumber;
     Q: PdfNumber;
     Kids: PdfArray<PdfObjectReference>;
@@ -31,8 +33,10 @@ export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
     F: PdfNumber;
     AP?: PdfAppearanceStreamDictionary;
     P?: PdfObjectReference;
+    Parent?: PdfObjectReference<PdfPage>;
 }>> {
-    private _annotationFlags;
+    private _annotationFlags?;
+    private get flags_();
     constructor(options?: {
         other?: PdfIndirectObject;
     });
@@ -58,4 +62,5 @@ export declare class PdfAnnotation extends PdfIndirectObject<PdfDictionary<{
     set appearanceStreamDict(dict: PdfAppearanceStreamDictionary | null);
     get parentRef(): PdfObjectReference | null;
     set parentRef(ref: PdfObjectReference | null);
+    get page(): PdfPage | null;
 }