pdf-lite 1.2.1 → 1.3.1

package/dist/acroform/acroform.js

@@ -6,6 +6,8 @@ import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
 import { PdfName } from '../core/objects/pdf-name.js';
 import { PdfBoolean } from '../core/objects/pdf-boolean.js';
 import { PdfNumber } from '../core/objects/pdf-number.js';
+import { PdfStream } from '../core/objects/pdf-stream.js';
+import { buildEncodingMap, decodeWithFontEncoding, } from '../utils/decodeWithFontEncoding.js';
 /**
  * Field types for AcroForm fields
  */
@@ -15,85 +17,118 @@ export const PdfFieldType = {
     Choice: 'Ch',
     Signature: 'Sig',
 };
-export class PdfAcroFormField extends PdfDictionary {
+export class PdfAcroFormField extends PdfIndirectObject {
     parent;
-    container;
+    defaultGenerateAppearance = true;
+    _appearanceStream;
+    _appearanceStreamYes; // For button fields: checked state
+    form;
     constructor(options) {
-        super();
-        this.container = options?.container;
+        super(options?.other ??
+            new PdfIndirectObject({ content: new PdfDictionary() }));
+        this.form = options?.form;
+    }
+    get encodingMap() {
+        const fontName = this.fontName;
+        if (!fontName)
+            return undefined;
+        return this.form?.fontEncodingMaps?.get(fontName);
+    }
+    /**
+     * Convenience method to check if field dictionary is modified
+     */
+    isModified() {
+        return this.content.isModified();
     }
     /**
      * Gets the field type
      */
     get fieldType() {
-        return this.get('FT')?.as(PdfName)?.value ?? null;
+        const ft = this.content.get('FT')?.value;
+        switch (ft) {
+            case 'Tx':
+                return 'Text';
+            case 'Btn':
+                return 'Button';
+            case 'Ch':
+                return 'Choice';
+            case 'Sig':
+                return 'Signature';
+            default:
+                return null;
+        }
     }
     set fieldType(type) {
         if (type === null) {
-            this.delete('FT');
+            this.content.delete('FT');
         }
         else {
-            this.set('FT', new PdfName(type));
+            this.content.set('FT', new PdfName(PdfFieldType[type]));
         }
     }
     get rect() {
-        const rectArray = this.get('Rect')?.as((PdfArray));
+        const rectArray = this.content.get('Rect')?.as((PdfArray));
         if (!rectArray)
             return null;
         return rectArray.items.map((num) => num.value);
     }
     set rect(rect) {
         if (rect === null) {
-            this.delete('Rect');
+            this.content.delete('Rect');
             return;
         }
         const rectArray = new PdfArray(rect.map((num) => new PdfNumber(num)));
-        this.set('Rect', rectArray);
+        this.content.set('Rect', rectArray);
     }
     get parentRef() {
-        const ref = this.get('P')?.as(PdfObjectReference);
+        const ref = this.content.get('P')?.as(PdfObjectReference);
         return ref ?? null;
     }
     set parentRef(ref) {
         if (ref === null) {
-            this.delete('P');
+            this.content.delete('P');
         }
         else {
-            this.set('P', ref);
+            this.content.set('P', ref);
         }
     }
     get isWidget() {
-        const type = this.get('Type')?.as(PdfName)?.value;
-        const subtype = this.get('Subtype')?.as(PdfName)?.value;
+        const type = this.content.get('Type')?.as(PdfName)?.value;
+        const subtype = this.content.get('Subtype')?.as(PdfName)?.value;
         return type === 'Annot' && subtype === 'Widget';
     }
     set isWidget(isWidget) {
         if (isWidget) {
-            this.set('Type', new PdfName('Annot'));
-            this.set('Subtype', new PdfName('Widget'));
+            this.content.set('Type', new PdfName('Annot'));
+            this.content.set('Subtype', new PdfName('Widget'));
         }
         else {
-            this.delete('Type');
-            this.delete('Subtype');
+            this.content.delete('Type');
+            this.content.delete('Subtype');
         }
     }
     /**
      * Gets the field name
      */
     get name() {
-        return this.get('T')?.as(PdfString)?.value ?? '';
+        const parentName = this.parent?.name ?? '';
+        const ownName = this.content.get('T')?.as(PdfString)?.value ?? '';
+        if (parentName && ownName) {
+            return `${parentName}.${ownName}`;
+        }
+        return parentName || ownName;
     }
     /**
      * Sets the field name
      */
     set name(name) {
-        this.set('T', new PdfString(name));
+        this.content.set('T', new PdfString(name));
     }
     /**
      * Gets the default value
      */
     get defaultValue() {
-        const dv = this.get('DV');
+        const dv = this.content.get('DV');
         if (dv instanceof PdfString) {
             return dv.value;
         }
@@ -107,16 +142,23 @@ export class PdfAcroFormField extends PdfDictionary {
      */
     set defaultValue(val) {
         const fieldType = this.fieldType;
-        if (fieldType === PdfFieldType.Button) {
-            this.set('DV', new PdfName(val));
+        if (fieldType === 'Button') {
+            this.content.set('DV', new PdfName(val));
         }
         else {
-            this.set('DV', new PdfString(val));
+            this.content.set('DV', new PdfString(val));
         }
     }
     get value() {
-        const v = this.get('V');
+        const v = this.content.get('V');
         if (v instanceof PdfString) {
+            // UTF-16BE strings should always use UTF-16BE decoding regardless of font encoding
+            if (v.isUTF16BE) {
+                return v.value; // Use PdfString's built-in UTF-16BE decoder
+            }
+            if (this.encodingMap) {
+                return decodeWithFontEncoding(v.raw, this.encodingMap);
+            }
             return v.value;
         }
         else if (v instanceof PdfName) {
@@ -125,43 +167,48 @@ export class PdfAcroFormField extends PdfDictionary {
         return '';
     }
     set value(val) {
-        const fieldType = this.get('FT')?.as(PdfName)?.value;
-        if (fieldType === PdfFieldType.Button) {
+        if (this.value === val) {
+            return;
+        }
+        const fieldType = this.fieldType;
+        if (fieldType === 'Button') {
+            val = val instanceof PdfString ? val.value : val;
             if (val.trim() === '') {
-                this.delete('V');
-                this.delete('AS');
+                this.content.delete('V');
+                this.content.delete('AS');
                 return;
             }
-            this.set('V', new PdfName(val));
-            this.set('AS', new PdfName(val));
+            this.content.set('V', new PdfName(val));
+            this.content.set('AS', new PdfName(val));
         }
         else {
-            this.set('V', new PdfString(val));
+            this.content.set('V', val instanceof PdfString ? val : new PdfString(val));
+        }
+        if (this.defaultGenerateAppearance) {
+            this.generateAppearance();
         }
     }
     get checked() {
-        const fieldType = this.get('FT')?.as(PdfName)?.value;
-        if (fieldType === PdfFieldType.Button) {
-            const v = this.get('V');
+        if (this.fieldType === 'Button') {
+            const v = this.content.get('V');
             return v instanceof PdfName && v.value === 'Yes';
         }
         return false;
     }
     set checked(isChecked) {
-        const fieldType = this.get('FT')?.as(PdfName)?.value;
-        if (fieldType === PdfFieldType.Button) {
+        if (this.fieldType === 'Button') {
             if (isChecked) {
-                this.set('V', new PdfName('Yes'));
-                this.set('AS', new PdfName('Yes'));
+                this.content.set('V', new PdfName('Yes'));
+                this.content.set('AS', new PdfName('Yes'));
             }
             else {
-                this.set('V', new PdfName('Off'));
-                this.set('AS', new PdfName('Off'));
+                this.content.set('V', new PdfName('Off'));
+                this.content.set('AS', new PdfName('Off'));
             }
         }
     }
     get fontSize() {
-        const da = this.get('DA')?.as(PdfString)?.value || '';
+        const da = this.content.get('DA')?.as(PdfString)?.value || '';
         const match = da.match(/\/[A-Za-z0-9_-]+\s+([\d.]+)\s+Tf/);
         if (match) {
             return parseFloat(match[1]);
@@ -169,16 +216,16 @@ export class PdfAcroFormField extends PdfDictionary {
         return null;
     }
     set fontSize(size) {
-        const da = this.get('DA')?.as(PdfString)?.value || '';
+        const da = this.content.get('DA')?.as(PdfString)?.value || '';
         if (!da) {
-            this.set('DA', new PdfString(`/F1 ${size} Tf 0 g`));
+            this.content.set('DA', new PdfString(`/F1 ${size} Tf 0 g`));
             return;
         }
         const updatedDa = da.replace(/(\/[A-Za-z0-9_-]+)\s+[\d.]+\s+Tf/g, `$1 ${size} Tf`);
-        this.set('DA', new PdfString(updatedDa));
+        this.content.set('DA', new PdfString(updatedDa));
     }
     get fontName() {
-        const da = this.get('DA')?.as(PdfString)?.value || '';
+        const da = this.content.get('DA')?.as(PdfString)?.value || '';
         const match = da.match(/\/([A-Za-z0-9_-]+)\s+[\d.]+\s+Tf/);
         if (match) {
             return match[1];
@@ -186,13 +233,13 @@ export class PdfAcroFormField extends PdfDictionary {
         return null;
     }
     set fontName(fontName) {
-        const da = this.get('DA')?.as(PdfString)?.value || '';
+        const da = this.content.get('DA')?.as(PdfString)?.value || '';
         if (!da) {
-            this.set('DA', new PdfString(`/${fontName} 12 Tf 0 g`));
+            this.content.set('DA', new PdfString(`/${fontName} 12 Tf 0 g`));
             return;
         }
         const updatedDa = da.replace(/\/[A-Za-z0-9_-]+(\s+[\d.]+\s+Tf)/g, `/${fontName}$1`);
-        this.set('DA', new PdfString(updatedDa));
+        this.content.set('DA', new PdfString(updatedDa));
     }
     /**
      * Sets the font using a PdfFont object.
@@ -201,39 +248,51 @@ export class PdfAcroFormField extends PdfDictionary {
     set font(font) {
         if (font === null) {
             // Clear font - set to empty or default
-            this.set('DA', new PdfString(''));
+            this.content.set('DA', new PdfString(''));
             return;
         }
         const resourceName = font.resourceName;
         const currentSize = this.fontSize ?? 12;
-        const da = this.get('DA')?.as(PdfString)?.value || '';
+        const da = this.content.get('DA')?.as(PdfString)?.value || '';
         if (!da) {
-            this.set('DA', new PdfString(`/${resourceName} ${currentSize} Tf 0 g`));
+            this.content.set('DA', new PdfString(`/${resourceName} ${currentSize} Tf 0 g`));
             return;
         }
         const updatedDa = da.replace(/\/[A-Za-z0-9_-]+(\s+[\d.]+\s+Tf)/g, `/${resourceName}$1`);
-        this.set('DA', new PdfString(updatedDa));
+        this.content.set('DA', new PdfString(updatedDa));
     }
     /**
      * Gets field flags (bitwise combination of field attributes)
      */
     get flags() {
-        return this.get('Ff')?.as(PdfNumber)?.value ?? 0;
+        return this.content.get('Ff')?.as(PdfNumber)?.value ?? 0;
     }
     /**
      * Sets field flags
      */
     set flags(flags) {
-        this.set('Ff', new PdfNumber(flags));
+        this.content.set('Ff', new PdfNumber(flags));
+    }
+    /**
+     * Gets annotation flags (for visual appearance and behavior)
+     */
+    get annotationFlags() {
+        return this.content.get('F')?.as(PdfNumber)?.value ?? 0;
+    }
+    /**
+     * Sets annotation flags
+     */
+    set annotationFlags(flags) {
+        this.content.set('F', new PdfNumber(flags));
     }
     /**
-     * Checks if the field is read-only
+     * Checks if the field is read-only (Ff bit 1)
      */
     get readOnly() {
         return (this.flags & 1) !== 0;
     }
     /**
-     * Sets the field as read-only or editable
+     * Sets the field as read-only or editable (Ff bit 1)
      */
     set readOnly(isReadOnly) {
         if (isReadOnly) {
@@ -294,64 +353,865 @@ export class PdfAcroFormField extends PdfDictionary {
             this.flags = this.flags & ~8192;
         }
     }
+    /**
+     * Checks if the field is a comb field (characters distributed evenly across cells)
+     */
+    get comb() {
+        return (this.flags & 16777216) !== 0;
+    }
+    /**
+     * Gets the quadding (text alignment) for this field.
+     * 0 = left-justified, 1 = centered, 2 = right-justified
+     */
+    get quadding() {
+        return this.content.get('Q')?.as(PdfNumber)?.value ?? 0;
+    }
+    /**
+     * Sets the quadding (text alignment) for this field.
+     * 0 = left-justified, 1 = centered, 2 = right-justified
+     */
+    set quadding(q) {
+        this.content.set('Q', new PdfNumber(q));
+    }
+    /**
+     * Gets the options for choice fields (dropdowns, list boxes).
+     * Returns an array of option strings.
+     */
+    get options() {
+        const opt = this.content.get('Opt')?.as((PdfArray));
+        if (!opt)
+            return [];
+        return opt.items.map((item) => item.value);
+    }
+    /**
+     * Sets the options for choice fields (dropdowns, list boxes).
+     * Pass an array of strings.
+     */
+    set options(options) {
+        if (options.length === 0) {
+            this.content.delete('Opt');
+            return;
+        }
+        const optArray = new PdfArray(options.map((opt) => new PdfString(opt)));
+        this.content.set('Opt', optArray);
+    }
+    get defaultAppearance() {
+        return this.content.get('DA')?.as(PdfString)?.value ?? null;
+    }
+    set defaultAppearance(da) {
+        this.content.set('DA', new PdfString(da));
+    }
+    set combo(isCombo) {
+        if (isCombo) {
+            this.flags = this.flags | 131072;
+        }
+        else {
+            this.flags = this.flags & ~131072;
+        }
+    }
+    get combo() {
+        return (this.flags & 131072) !== 0;
+    }
+    get radio() {
+        return (this.flags & 32768) !== 0;
+    }
+    set radio(isRadio) {
+        if (isRadio) {
+            this.flags = this.flags | 32768;
+        }
+        else {
+            this.flags = this.flags & ~32768;
+        }
+    }
+    get noToggleToOff() {
+        return (this.flags & 16384) !== 0;
+    }
+    set noToggleToOff(noToggle) {
+        if (noToggle) {
+            this.flags = this.flags | 16384;
+        }
+        else {
+            this.flags = this.flags & ~16384;
+        }
+    }
+    get combField() {
+        return (this.flags & 16777216) !== 0;
+    }
+    set combField(isComb) {
+        if (isComb) {
+            this.flags = this.flags | 16777216;
+        }
+        else {
+            this.flags = this.flags & ~16777216;
+        }
+    }
+    get maxLen() {
+        return this.content.get('MaxLen')?.as(PdfNumber)?.value ?? null;
+    }
+    set maxLen(maxLen) {
+        if (maxLen === null) {
+            this.content.delete('MaxLen');
+        }
+        else {
+            this.content.set('MaxLen', new PdfNumber(maxLen));
+        }
+    }
+    // ============================================
+    // Annotation Flags (F field)
+    // ============================================
+    /**
+     * If true, the annotation is invisible (F bit 1)
+     */
+    get invisible() {
+        return (this.annotationFlags & 1) !== 0;
+    }
+    set invisible(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 1;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~1;
+        }
+    }
+    /**
+     * If true, the annotation is hidden (F bit 2)
+     */
+    get hidden() {
+        return (this.annotationFlags & 2) !== 0;
+    }
+    set hidden(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 2;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~2;
+        }
+    }
+    /**
+     * If true, print the annotation when printing (F bit 3)
+     */
+    get print() {
+        return (this.annotationFlags & 4) !== 0;
+    }
+    set print(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 4;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~4;
+        }
+    }
+    /**
+     * If true, do not zoom annotation when zooming (F bit 4)
+     */
+    get noZoom() {
+        return (this.annotationFlags & 8) !== 0;
+    }
+    set noZoom(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 8;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~8;
+        }
+    }
+    /**
+     * If true, do not rotate annotation when rotating (F bit 5)
+     */
+    get noRotate() {
+        return (this.annotationFlags & 16) !== 0;
+    }
+    set noRotate(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 16;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~16;
+        }
+    }
+    /**
+     * If true, do not display annotation on screen (F bit 6)
+     */
+    get noView() {
+        return (this.annotationFlags & 32) !== 0;
+    }
+    set noView(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 32;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~32;
+        }
+    }
+    /**
+     * If true, annotation is locked (F bit 8)
+     */
+    get locked() {
+        return (this.annotationFlags & 128) !== 0;
+    }
+    set locked(value) {
+        if (value) {
+            this.annotationFlags = this.annotationFlags | 128;
+        }
+        else {
+            this.annotationFlags = this.annotationFlags & ~128;
+        }
+    }
+    // ============================================
+    // Field Flags (Ff field) - Additional
+    // ============================================
+    /**
+     * If true, field value should not be exported (Ff bit 3)
+     */
+    get noExport() {
+        return (this.flags & 4) !== 0;
+    }
+    set noExport(value) {
+        if (value) {
+            this.flags = this.flags | 4;
+        }
+        else {
+            this.flags = this.flags & ~4;
+        }
+    }
+    /**
+     * If true, field is a pushbutton (Ff bit 17)
+     */
+    get pushButton() {
+        return (this.flags & 65536) !== 0;
+    }
+    set pushButton(value) {
+        if (value) {
+            this.flags = this.flags | 65536;
+        }
+        else {
+            this.flags = this.flags & ~65536;
+        }
+    }
+    /**
+     * If true, text field allows editing (Ff bit 19)
+     */
+    get edit() {
+        return (this.flags & 262144) !== 0;
+    }
+    set edit(value) {
+        if (value) {
+            this.flags = this.flags | 262144;
+        }
+        else {
+            this.flags = this.flags & ~262144;
+        }
+    }
+    /**
+     * If true, choice options should be sorted alphabetically (Ff bit 20)
+     */
+    get sort() {
+        return (this.flags & 524288) !== 0;
+    }
+    set sort(value) {
+        if (value) {
+            this.flags = this.flags | 524288;
+        }
+        else {
+            this.flags = this.flags & ~524288;
+        }
+    }
+    /**
+     * If true, allows multiple selections in choice field (Ff bit 22)
+     */
+    get multiSelect() {
+        return (this.flags & 2097152) !== 0;
+    }
+    set multiSelect(value) {
+        if (value) {
+            this.flags = this.flags | 2097152;
+        }
+        else {
+            this.flags = this.flags & ~2097152;
+        }
+    }
+    /**
+     * If true, do not spell check this field (Ff bit 23)
+     */
+    get doNotSpellCheck() {
+        return (this.flags & 4194304) !== 0;
+    }
+    set doNotSpellCheck(value) {
+        if (value) {
+            this.flags = this.flags | 4194304;
+        }
+        else {
+            this.flags = this.flags & ~4194304;
+        }
+    }
+    /**
+     * If true, do not scroll text field (Ff bit 24)
+     */
+    get doNotScroll() {
+        return (this.flags & 8388608) !== 0;
+    }
+    set doNotScroll(value) {
+        if (value) {
+            this.flags = this.flags | 8388608;
+        }
+        else {
+            this.flags = this.flags & ~8388608;
+        }
+    }
+    /**
+     * If true, commit field value immediately on selection change (Ff bit 27)
+     */
+    get commitOnSelChange() {
+        return (this.flags & 67108864) !== 0;
+    }
+    set commitOnSelChange(value) {
+        if (value) {
+            this.flags = this.flags | 67108864;
+        }
+        else {
+            this.flags = this.flags & ~67108864;
+        }
+    }
+    get kids() {
+        const kidsArray = this.content
+            .get('Kids')
+            ?.as((PdfArray));
+        if (!kidsArray)
+            return [];
+        return kidsArray.items;
+    }
+    set kids(kids) {
+        if (kids.length === 0) {
+            this.content.delete('Kids');
+            return;
+        }
+        const kidsArray = new PdfArray(kids);
+        this.content.set('Kids', kidsArray);
+    }
+    get appearanceStreamDict() {
+        const apDict = this.content.get('AP')?.as(PdfDictionary);
+        if (!apDict)
+            return null;
+        return apDict;
+    }
+    set appearanceStreamDict(dict) {
+        if (dict === null) {
+            this.content.delete('AP');
+            return;
+        }
+        this.content.set('AP', dict);
+    }
+    /**
+     * Generates an appearance stream for a text field using iText's approach.
+     *
+     * This generates an appearance with text using the same positioning formula as iText:
+     * - textY = (height - fontSize) / 2 + fontSize * 0.2
+     * - Wrapped in marked content blocks (/Tx BMC ... EMC)
+     * - Field remains editable unless makeReadOnly is set
+     *
+     * For editable fields (default, no options):
+     * - Text visible immediately
+     * - Field remains fully editable
+     * - No save dialog (needAppearances = false)
+     * - Text positioning matches iText
+     *
+     * For read-only fields (makeReadOnly: true):
+     * - Same appearance generation
+     * - Field is set as read-only
+     *
+     * @param options.makeReadOnly - If true, sets field as read-only
+     * @returns true if appearance was generated successfully
+     */
+    generateAppearance(options) {
+        const fieldType = this.fieldType;
+        // Route to appropriate generation method based on field type
+        if (fieldType === 'Text') {
+            return this.generateTextAppearance(options);
+        }
+        else if (fieldType === 'Button') {
+            return this.generateButtonAppearance(options);
+        }
+        else if (fieldType === 'Choice') {
+            return this.generateChoiceAppearance(options);
+        }
+        return false;
+    }
+    /**
+     * Generates appearance for text fields
+     * @internal
+     */
+    generateTextAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const [x1, y1, x2, y2] = rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        // Get the default appearance string
+        const da = this.content.get('DA')?.as(PdfString)?.value;
+        if (!da)
+            return false;
+        // Get the field value
+        const value = this.value;
+        // Parse font name and size from DA
+        const fontMatch = da.match(/\/(\w+)\s+([\d.]+)\s+Tf/);
+        if (!fontMatch)
+            return false;
+        const fontName = fontMatch[1];
+        let fontSize = parseFloat(fontMatch[2]);
+        // If font size is 0 or invalid, use a default size
+        if (!fontSize || fontSize <= 0) {
+            fontSize = 12; // Default to 12pt
+        }
+        // Parse color from DA (format: "r g b rg" or "g g")
+        let colorOp = '0 g'; // default to black
+        const rgMatch = da.match(/([\d.]+\s+[\d.]+\s+[\d.]+)\s+rg/);
+        const gMatch = da.match(/([\d.]+)\s+g/);
+        if (rgMatch) {
+            colorOp = `${rgMatch[1]} rg`;
+        }
+        else if (gMatch) {
+            colorOp = `${gMatch[1]} g`;
+        }
+        // Reconstruct the DA string with the correct font size
+        const reconstructedDA = `/${fontName} ${fontSize} Tf ${colorOp}`;
+        // Calculate text position using Adobe Acrobat's positioning formula
+        // After testing, this formula matches Acrobat's rendering most closely
+        const padding = 2;
+        // Vertical positioning: Position baseline to match viewer behavior
+        // This accounts for the font's typical metrics (cap height, descenders, etc.)
+        const textY = (height - fontSize) / 2 + fontSize * 0.2;
+        // Escape special characters in the text value
+        const escapedValue = value
+            .replace(/\\/g, '\\\\')
+            .replace(/\(/g, '\\(')
+            .replace(/\)/g, '\\)')
+            .replace(/\r/g, '\\r')
+            .replace(/\n/g, '\\n');
+        // Generate text positioning based on field type
+        let textContent;
+        if (this.multiline) {
+            // Multiline text field: handle line breaks
+            const lines = value.split('\n');
+            const lineHeight = fontSize * 1.2;
+            const startY = height - padding - fontSize;
+            textContent = 'BT\n';
+            textContent += `${reconstructedDA}\n`;
+            textContent += `${padding} ${startY} Td\n`;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i]
+                    .replace(/\\/g, '\\\\')
+                    .replace(/\(/g, '\\(')
+                    .replace(/\)/g, '\\)')
+                    .replace(/\r/g, '');
+                if (i > 0) {
+                    textContent += `0 ${-lineHeight} Td\n`;
+                }
+                textContent += `(${line}) Tj\n`;
+            }
+            textContent += 'ET\n';
+        }
+        else if (this.comb && this.maxLen) {
+            // Comb field: position each character in its own cell
+            const cellWidth = width / this.maxLen;
+            const chars = value.split('');
+            textContent = 'BT\n';
+            textContent += `${reconstructedDA}\n`;
+            for (let i = 0; i < chars.length && i < this.maxLen; i++) {
+                // Center each character in its cell
+                const cellX = cellWidth * i + cellWidth / 2 - fontSize * 0.3;
+                const escapedChar = chars[i]
+                    .replace(/\\/g, '\\\\')
+                    .replace(/\(/g, '\\(')
+                    .replace(/\)/g, '\\)');
+                textContent += `${cellX} ${textY} Td\n`;
+                textContent += `(${escapedChar}) Tj\n`;
+                textContent += `${-cellX} ${-textY} Td\n`; // Reset position
+            }
+            textContent += 'ET\n';
+        }
+        else {
+            // Regular text field
+            const textX = padding;
+            textContent = `BT
+${reconstructedDA}
+${textX} ${textY} Td
+(${escapedValue}) Tj
+ET
+`;
+        }
+        // Generate appearance with text (iText approach)
+        // Use marked content to properly tag the text field content
+        const contentStream = `/Tx BMC
+q
+${textContent}Q
+EMC
+`;
+        // Create the appearance stream
+        const appearanceDict = new PdfDictionary();
+        appearanceDict.set('Type', new PdfName('XObject'));
+        appearanceDict.set('Subtype', new PdfName('Form'));
+        appearanceDict.set('FormType', new PdfNumber(1));
+        appearanceDict.set('BBox', new PdfArray([
+            new PdfNumber(0),
+            new PdfNumber(0),
+            new PdfNumber(width),
+            new PdfNumber(height),
+        ]));
+        const stream = new PdfStream({
+            header: appearanceDict,
+            original: contentStream,
+        });
+        // Store the appearance stream for later writing
+        this._appearanceStream = stream;
+        // Configure field flags based on options
+        if (options?.makeReadOnly) {
+            // Set the read-only flag (Ff bit 0)
+            this.readOnly = true;
+            // Ensure the annotation is visible and printable
+            this.print = true;
+            this.noZoom = true;
+        }
+        else {
+            // For editable fields, just ensure print flag is set
+            this.print = true;
+        }
+        return true;
+    }
+    /**
+     * Generates appearance for button fields (checkboxes, radio buttons)
+     * @internal
+     */
+    generateButtonAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const [x1, y1, x2, y2] = rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        const size = Math.min(width, height);
+        // Check if this is a radio button by looking at parent/siblings
+        // Radio buttons typically have Ff bit 15 (Radio) set
+        const isRadio = (this.flags & 32768) !== 0;
+        // Helper to create appearance stream dictionary
+        const createAppearanceStream = (content) => {
+            const appearanceDict = new PdfDictionary();
+            appearanceDict.set('Type', new PdfName('XObject'));
+            appearanceDict.set('Subtype', new PdfName('Form'));
+            appearanceDict.set('FormType', new PdfNumber(1));
+            appearanceDict.set('BBox', new PdfArray([
+                new PdfNumber(0),
+                new PdfNumber(0),
+                new PdfNumber(width),
+                new PdfNumber(height),
+            ]));
+            // Add ZapfDingbats font for checkmarks
+            const resources = new PdfDictionary();
+            const fonts = new PdfDictionary();
+            const zapfFont = new PdfDictionary();
+            zapfFont.set('Type', new PdfName('Font'));
+            zapfFont.set('Subtype', new PdfName('Type1'));
+            zapfFont.set('BaseFont', new PdfName('ZapfDingbats'));
+            fonts.set('ZaDb', zapfFont);
+            resources.set('Font', fonts);
+            appearanceDict.set('Resources', resources);
+            return new PdfStream({
+                header: appearanceDict,
+                original: content,
+            });
+        };
+        // Generate "Off" state appearance (unchecked/empty)
+        const offStream = createAppearanceStream('');
+        // Generate "Yes" state appearance (checked)
+        let yesContent;
+        if (isRadio) {
+            // Radio button: filled circle using 4 Bezier curves to approximate a circle
+            const center = size / 2;
+            const radius = size * 0.35;
+            const k = 0.5522847498; // Magic number for circular Bezier curves (4/3 * tan(π/8))
+            const kRadius = k * radius;
+            // Draw a filled circle using 4 cubic Bezier curves
+            yesContent = `q
+0 0 0 rg
+${center} ${center + radius} m
+${center + kRadius} ${center + radius} ${center + radius} ${center + kRadius} ${center + radius} ${center} c
+${center + radius} ${center - kRadius} ${center + kRadius} ${center - radius} ${center} ${center - radius} c
+${center - kRadius} ${center - radius} ${center - radius} ${center - kRadius} ${center - radius} ${center} c
+${center - radius} ${center + kRadius} ${center - kRadius} ${center + radius} ${center} ${center + radius} c
+f
+Q
+`;
+        }
+        else {
+            // Checkbox: checkmark (using ZapfDingbats character)
+            const checkSize = size * 0.8;
+            const offset = (size - checkSize) / 2;
+            yesContent = `q
+BT
+/ZaDb ${checkSize} Tf
+${offset} ${offset} Td
+(4) Tj
+ET
+Q
+`;
+        }
+        const yesStream = createAppearanceStream(yesContent);
+        // Store both appearance streams in a state dictionary
+        // We'll use a special structure to hold both states
+        this._appearanceStream = offStream; // Store Off as default
+        this._appearanceStreamYes = yesStream; // Store Yes state separately
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+    /**
+     * Generates appearance for choice fields (dropdowns, list boxes)
+     * @internal
+     */
+    generateChoiceAppearance(options) {
+        const rect = this.rect;
+        if (!rect || rect.length !== 4)
+            return false;
+        const [x1, y1, x2, y2] = rect;
+        const width = x2 - x1;
+        const height = y2 - y1;
+        // Get the default appearance string
+        const da = this.content.get('DA')?.as(PdfString)?.value;
+        if (!da)
+            return false;
+        const value = this.value;
+        if (!value)
+            return false;
+        // Parse font and size from DA
+        const fontMatch = da.match(/\/(\w+)\s+([\d.]+)\s+Tf/);
+        if (!fontMatch)
+            return false;
+        const fontName = fontMatch[1];
+        let fontSize = parseFloat(fontMatch[2]);
+        if (!fontSize || fontSize <= 0) {
+            fontSize = 12;
+        }
+        const colorOp = '0 g';
+        const reconstructedDA = `/${fontName} ${fontSize} Tf ${colorOp}`;
+        const padding = 2;
+        const textY = (height - fontSize) / 2 + fontSize * 0.2;
+        const textX = padding;
+        const escapedValue = value
+            .replace(/\\/g, '\\\\')
+            .replace(/\(/g, '\\(')
+            .replace(/\)/g, '\\)');
+        // Check if this is a combo box (dropdown) - Ff bit 17 (131072)
+        const isCombo = (this.flags & 131072) !== 0;
+        // Draw dropdown arrow for combo boxes
+        let arrowGraphics = '';
+        if (isCombo) {
+            // Reserve space for the arrow on the right
+            const arrowWidth = height * 0.8; // Arrow area width
+            const arrowX = width - arrowWidth - 2; // X position for arrow
+            const arrowY = height / 2; // Y center
+            const arrowSize = height * 0.3; // Triangle size
+            // Draw a small downward-pointing triangle
+            arrowGraphics = `
+q
+0.5 0.5 0.5 rg
+${arrowX + arrowWidth / 2} ${arrowY - arrowSize / 3} m
+${arrowX + arrowWidth / 2 - arrowSize / 2} ${arrowY + arrowSize / 3} l
+${arrowX + arrowWidth / 2 + arrowSize / 2} ${arrowY + arrowSize / 3} l
+f
+Q
+`;
+        }
+        // Generate appearance with text and optional dropdown arrow
+        const contentStream = `/Tx BMC
+q
+BT
+${reconstructedDA}
+${textX} ${textY} Td
+(${escapedValue}) Tj
+ET
+${arrowGraphics}Q
+EMC
+`;
+        const appearanceDict = new PdfDictionary();
+        appearanceDict.set('Type', new PdfName('XObject'));
+        appearanceDict.set('Subtype', new PdfName('Form'));
+        appearanceDict.set('FormType', new PdfNumber(1));
+        appearanceDict.set('BBox', new PdfArray([
+            new PdfNumber(0),
+            new PdfNumber(0),
+            new PdfNumber(width),
+            new PdfNumber(height),
+        ]));
+        const stream = new PdfStream({
+            header: appearanceDict,
+            original: contentStream,
+        });
+        this._appearanceStream = stream;
+        if (options?.makeReadOnly) {
+            this.readOnly = true;
+            this.print = true;
+            this.noZoom = true;
+        }
+        return true;
+    }
+    /**
+     * Gets the stored appearance stream if one has been generated.
+     * For button fields, returns the appropriate stream based on the current state.
+     * @internal
+     */
+    getAppearanceStream() {
+        // For button fields, return the appropriate stream based on state
+        if (this.fieldType === 'Button') {
+            if (this.checked && this._appearanceStreamYes) {
+                return this._appearanceStreamYes;
+            }
+            return this._appearanceStream; // Return "Off" state
+        }
+        return this._appearanceStream;
+    }
+    /**
+     * Gets all appearance streams for writing to PDF.
+     * For button fields, returns both Off and Yes states.
+     * For other fields, returns just the primary appearance.
+     * @internal
+     */
+    getAppearanceStreamsForWriting() {
+        if (!this._appearanceStream)
+            return undefined;
+        return {
+            primary: this._appearanceStream,
+            secondary: this.fieldType === 'Button'
+                ? this._appearanceStreamYes
+                : undefined,
+        };
+    }
+    /**
+     * Sets the appearance dictionary reference for this field.
+     * @internal - This is called automatically by PdfAcroForm.write()
+     */
+    setAppearanceReference(appearanceStreamRef, appearanceStreamYesRef) {
+        let apDict = this.appearanceStreamDict;
+        if (!apDict) {
+            apDict = new PdfDictionary();
+            this.appearanceStreamDict = apDict;
+        }
+        // For button fields with multiple states, create a state dictionary
+        if (appearanceStreamYesRef && this.fieldType === 'Button') {
+            const stateDict = new PdfDictionary();
+            stateDict.set('Off', appearanceStreamRef);
+            stateDict.set('Yes', appearanceStreamYesRef);
+            apDict.set('N', stateDict);
+        }
+        else {
+            // For other fields, set the appearance stream directly
+            apDict.set('N', appearanceStreamRef);
+        }
+    }
 }
-export class PdfAcroForm extends PdfDictionary {
+export class PdfAcroForm extends PdfIndirectObject {
     fields;
-    container;
+    fontEncodingMaps = new Map();
+    document;
     constructor(options) {
-        super();
-        this.copyFrom(options.dict);
-        this.fields = options.fields ?? [];
-        this.container = options.container;
+        super(options?.other ??
+            new PdfIndirectObject({
+                content: new PdfDictionary(),
+            }));
+        this.fields = options?.fields ?? [];
+        this.document = options?.document;
+    }
+    /**
+     * Convenience method to get a value from the form dictionary
+     */
+    get(key) {
+        return this.content.get(key);
+    }
+    /**
+     * Convenience method to set a value in the form dictionary
+     */
+    set(key, value) {
+        this.content.set(key, value);
+    }
+    /**
+     * Convenience method to delete a key from the form dictionary
+     */
+    delete(key) {
+        this.content.delete(key);
+    }
+    /**
+     * Convenience method to check if form dictionary is modified
+     */
+    isModified() {
+        return this.content.isModified();
     }
     /**
      * Gets the NeedAppearances flag
      */
     get needAppearances() {
-        return this.get('NeedAppearances')?.as(PdfBoolean)?.value ?? false;
+        return (this.content.get('NeedAppearances')?.as(PdfBoolean)?.value ?? false);
     }
     /**
      * Sets the NeedAppearances flag to indicate that appearance streams need to be regenerated
      */
     set needAppearances(value) {
-        this.set('NeedAppearances', new PdfBoolean(value));
+        this.content.set('NeedAppearances', new PdfBoolean(value));
     }
     /**
      * Gets the signature flags
      */
     get signatureFlags() {
-        return this.get('SigFlags')?.as(PdfNumber)?.value ?? 0;
+        return this.content.get('SigFlags')?.as(PdfNumber)?.value ?? 0;
     }
     /**
      * Sets the signature flags
      */
     set signatureFlags(flags) {
-        this.set('SigFlags', new PdfNumber(flags));
+        this.content.set('SigFlags', new PdfNumber(flags));
     }
     /**
      * Gets the default appearance string for the form
      */
     get defaultAppearance() {
-        return this.get('DA')?.as(PdfString)?.value ?? null;
+        return this.content.get('DA')?.as(PdfString)?.value ?? null;
     }
     /**
      * Sets the default appearance string for the form
      */
     set defaultAppearance(da) {
-        this.set('DA', new PdfString(da));
+        this.content.set('DA', new PdfString(da));
     }
     /**
      * Gets the default quadding (alignment) for the form
      * 0 = left, 1 = center, 2 = right
      */
     get defaultQuadding() {
-        return this.get('Q')?.as(PdfNumber)?.value ?? 0;
+        return this.content.get('Q')?.as(PdfNumber)?.value ?? 0;
     }
     /**
      * Sets the default quadding (alignment) for the form
      */
     set defaultQuadding(q) {
-        this.set('Q', new PdfNumber(q));
+        this.content.set('Q', new PdfNumber(q));
+    }
+    /**
+     * Gets the default resources dictionary for the form
+     */
+    get defaultResources() {
+        return this.content.get('DR')?.as(PdfDictionary) ?? null;
+    }
+    /**
+     * Sets the default resources dictionary for the form
+     */
+    set defaultResources(resources) {
+        if (resources === null) {
+            this.content.delete('DR');
+        }
+        else {
+            this.content.set('DR', resources);
+        }
     }
     /**
      * Sets multiple field values by field name.
@@ -383,11 +1243,71 @@ export class PdfAcroForm extends PdfDictionary {
         }
         return result;
     }
+    /**
+     * Gets the encoding map for a specific font in the form's resources.
+     * Returns null if no custom encoding is found.
+     * Results are cached for performance.
+     */
+    async getFontEncodingMap(fontName) {
+        // Check cache first
+        if (this.fontEncodingMaps.has(fontName)) {
+            return this.fontEncodingMaps.get(fontName);
+        }
+        // Get the font from default resources
+        const dr = this.defaultResources;
+        if (!dr) {
+            return null;
+        }
+        const fonts = dr.get('Font')?.as(PdfDictionary);
+        if (!fonts) {
+            return null;
+        }
+        const fontRef = fonts.get(fontName)?.as(PdfObjectReference);
+        if (!fontRef || !this.document) {
+            return null;
+        }
+        // Read the font object
+        const fontObj = await this.document.readObject({
+            objectNumber: fontRef.objectNumber,
+            generationNumber: fontRef.generationNumber,
+        });
+        if (!fontObj) {
+            return null;
+        }
+        const fontDict = fontObj.content.as(PdfDictionary);
+        const encoding = fontDict.get('Encoding');
+        // Handle encoding reference
+        let encodingDict = null;
+        if (encoding instanceof PdfObjectReference) {
+            const encodingObj = await this.document.readObject({
+                objectNumber: encoding.objectNumber,
+                generationNumber: encoding.generationNumber,
+            });
+            encodingDict = encodingObj?.content.as(PdfDictionary) ?? null;
+        }
+        else if (encoding instanceof PdfDictionary) {
+            encodingDict = encoding;
+        }
+        if (!encodingDict) {
+            return null;
+        }
+        // Parse the Differences array
+        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;
+    }
     static async fromDocument(document) {
-        const catalog = document.rootDictionary;
+        const catalog = document.root;
         if (!catalog)
             return null;
-        const acroFormRef = catalog.get('AcroForm');
+        const acroFormRef = catalog.content.get('AcroForm');
         if (!acroFormRef)
             return null;
         let acroFormDict;
@@ -406,21 +1326,22 @@ export class PdfAcroForm extends PdfDictionary {
         }
         else if (acroFormRef instanceof PdfDictionary) {
             acroFormDict = acroFormRef;
+            acroFormContainer = new PdfIndirectObject({ content: acroFormDict });
         }
         else {
             return null;
         }
-        const acroForm = new PdfAcroForm({
-            dict: acroFormDict,
-            container: acroFormContainer,
-        });
-        const getFields = async (fields, seen = new Set(), parent) => {
-            for (const fieldRef of fields.items) {
-                const refKey = fieldRef.toString();
-                if (seen.has(refKey)) {
+        const acroForm = new PdfAcroForm({ other: acroFormContainer, document });
+        // Pre-cache font encoding maps for all fonts used in fields
+        await acroForm.cacheAllFontEncodings();
+        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;
                 }
-                seen.add(refKey);
                 const fieldObject = await document.readObject({
                     objectNumber: fieldRef.objectNumber,
                     generationNumber: fieldRef.generationNumber,
@@ -430,37 +1351,62 @@ export class PdfAcroForm extends PdfDictionary {
                 if (!(fieldObject.content instanceof PdfDictionary))
                     continue;
                 const field = new PdfAcroFormField({
-                    container: fieldObject,
+                    other: fieldObject,
+                    form: acroForm,
                 });
                 field.parent = parent;
-                field.copyFrom(fieldObject.content);
                 // Process child fields (Kids) before adding the parent
-                const kids = field.get('Kids')?.as((PdfArray));
-                if (kids) {
-                    await getFields(kids, seen, field);
+                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.get('Fields') instanceof PdfArray) {
-            fieldsArray.items.push(...acroForm.get('Fields').as((PdfArray))
-                .items);
+        if (acroForm.content.get('Fields') instanceof PdfArray) {
+            fieldsArray.items.push(...acroForm.content
+                .get('Fields')
+                .as((PdfArray)).items);
         }
-        else if (acroForm.get('Fields') instanceof PdfObjectReference) {
+        else if (acroForm.content.get('Fields') instanceof PdfObjectReference) {
             const fieldsObj = await document.readObject({
-                objectNumber: acroForm.get('Fields').as(PdfObjectReference)
-                    .objectNumber,
-                generationNumber: acroForm.get('Fields').as(PdfObjectReference)
-                    .generationNumber,
+                objectNumber: acroForm.content
+                    .get('Fields')
+                    .as(PdfObjectReference).objectNumber,
+                generationNumber: acroForm.content
+                    .get('Fields')
+                    .as(PdfObjectReference).generationNumber,
             });
             if (fieldsObj && fieldsObj.content instanceof PdfArray) {
                 fieldsArray.items.push(...fieldsObj.content.as((PdfArray)).items);
             }
         }
-        await getFields(fieldsArray);
+        await getFields(fieldsArray.items);
         return acroForm;
     }
+    /**
+     * Pre-caches encoding maps for all fonts used in the form fields.
+     * This makes subsequent field value access faster and synchronous.
+     */
+    async cacheAllFontEncodings() {
+        const fontNames = new Set();
+        // Collect all font names from field DA strings
+        for (const field of this.fields) {
+            const da = field.content.get('DA')?.as(PdfString)?.value;
+            if (da) {
+                const fontMatch = da.match(/\/(\w+)\s+[\d.]+\s+Tf/);
+                if (fontMatch) {
+                    fontNames.add(fontMatch[1]);
+                }
+            }
+        }
+        // Pre-cache encoding for each font
+        for (const fontName of fontNames) {
+            await this.getFontEncodingMap(fontName);
+        }
+    }
     /**
      * Gets or creates the Annots array for a page.
      * Returns the array and metadata about whether it's an indirect object.
@@ -518,7 +1464,7 @@ export class PdfAcroForm extends PdfDictionary {
             });
             if (!pageObj)
                 continue;
-            const pageDict = pageObj.content.as(PdfDictionary);
+            const pageDict = pageObj.content.as(PdfDictionary).clone();
             const annotsInfo = await this.getPageAnnotsArray(document, pageDict);
             this.addFieldsToAnnots(annotsInfo.annotsArray, fieldRefs);
             // Write the Annots array if it's an indirect object
@@ -541,33 +1487,45 @@ export class PdfAcroForm extends PdfDictionary {
         }
     }
     async write(document) {
-        const catalog = document.rootDictionary?.clone();
-        if (!catalog) {
-            throw new Error('Document has no root catalog');
-        }
+        const catalog = document.root;
         const isIncremental = document.isIncremental();
         document.setIncremental(true);
         const fieldsArray = new PdfArray();
-        this.set('Fields', fieldsArray);
+        this.content.set('Fields', fieldsArray);
         // Track fields that need to be added to page annotations
         const fieldsByPage = new Map();
         for (const field of this.fields) {
-            if (!field.isModified())
-                continue;
-            const acroFormFieldIndirect = new PdfIndirectObject({
-                ...field.container,
-                content: field,
-            });
             let fieldReference;
             if (field.isModified()) {
-                // Write modified field as an indirect object
-                const acroFormFieldIndirect = new PdfIndirectObject({
-                    ...field.container,
-                    content: field,
-                });
-                document.add(acroFormFieldIndirect);
+                // If the field has generated appearance streams, create them as indirect objects
+                const appearances = field.getAppearanceStreamsForWriting();
+                if (appearances) {
+                    // Create the primary appearance stream
+                    const primaryAppearanceObj = new PdfIndirectObject({
+                        content: appearances.primary,
+                    });
+                    document.add(primaryAppearanceObj);
+                    // Create the secondary appearance stream if present (for button fields)
+                    let secondaryAppearanceRef;
+                    if (appearances.secondary) {
+                        const secondaryAppearanceObj = new PdfIndirectObject({
+                            content: appearances.secondary,
+                        });
+                        document.add(secondaryAppearanceObj);
+                        secondaryAppearanceRef =
+                            secondaryAppearanceObj.reference;
+                    }
+                    // Set the appearance references on the field
+                    field.setAppearanceReference(primaryAppearanceObj.reference, secondaryAppearanceRef);
+                    // Ensure field has the Print flag set
+                    // This ensures the appearance is used for display and printing
+                    if (!field.print) {
+                        field.print = true;
+                    }
+                }
+                document.add(field);
                 // Create a proper PdfObjectReference (not the proxy from .reference)
-                fieldReference = new PdfObjectReference(acroFormFieldIndirect.objectNumber, acroFormFieldIndirect.generationNumber);
+                fieldReference = new PdfObjectReference(field.objectNumber, field.generationNumber);
                 // Track if this field needs to be added to a page's Annots
                 const parentRef = field.parentRef;
                 const isWidget = field.isWidget;
@@ -583,39 +1541,21 @@ export class PdfAcroForm extends PdfDictionary {
                 }
             }
             else {
-                // Unmodified field: reuse existing indirect reference information
-                const container = field.container;
-                if (container &&
-                    typeof container.objectNumber === 'number' &&
-                    typeof container.generationNumber === 'number') {
-                    fieldReference = new PdfObjectReference(container.objectNumber, container.generationNumber);
-                }
-            }
-            if (fieldReference) {
-                fieldsArray.push(fieldReference);
+                fieldReference = field.reference;
             }
+            fieldsArray.push(fieldReference);
         }
         // Add field references to page annotations
         await this.updatePageAnnotations(document, fieldsByPage);
         if (this.isModified()) {
-            // Create or update the AcroForm entry in the catalog
-            const acroFormIndirect = new PdfIndirectObject({
-                ...this.container,
-                content: this,
-            });
-            document.add(acroFormIndirect);
-            catalog.set('AcroForm', acroFormIndirect.reference);
-            // In incremental mode, ensure the updated catalog is written
-            const rootRef = document.trailerDict
-                .get('Root')
-                ?.as(PdfObjectReference);
-            if (rootRef) {
-                const rootIndirect = new PdfIndirectObject({
-                    objectNumber: rootRef.objectNumber,
-                    generationNumber: rootRef.generationNumber,
-                    content: catalog,
-                });
-                document.add(rootIndirect);
+            document.add(this);
+            if (!catalog.content.has('AcroForm')) {
+                let updatableCatalog = catalog;
+                if (catalog.isImmutable()) {
+                    updatableCatalog = catalog.clone();
+                    document.add(updatableCatalog);
+                }
+                updatableCatalog.content.set('AcroForm', this.reference);
             }
         }
         await document.commit();