pdf-lite 1.0.5 → 1.0.6

package/EXAMPLES.md

@@ -915,6 +915,18 @@ function createTextField(
     // Default appearance string (font and size)
     fieldDict.set('DA', new PdfString('/Helv 12 Tf 0 g'))
 
+    // Border style (solid, 1pt width)
+    const borderDict = new PdfDictionary()
+    borderDict.set('W', new PdfNumber(1))
+    borderDict.set('S', new PdfName('S'))
+    fieldDict.set('BS', borderDict)
+
+    // Appearance characteristics
+    const mkDict = new PdfDictionary()
+    mkDict.set('BC', new PdfArray([new PdfNumber(0)])) // Border color (black)
+    mkDict.set('BG', new PdfArray([new PdfNumber(1)])) // Background color (white)
+    fieldDict.set('MK', mkDict)
+
     return new PdfIndirectObject({ content: fieldDict })
 }
 
@@ -951,6 +963,18 @@ function createCheckboxField(
     fieldDict.set('V', new PdfName(checked ? 'Yes' : 'Off'))
     fieldDict.set('AS', new PdfName(checked ? 'Yes' : 'Off'))
 
+    // Border style
+    const borderDict = new PdfDictionary()
+    borderDict.set('W', new PdfNumber(1))
+    borderDict.set('S', new PdfName('S'))
+    fieldDict.set('BS', borderDict)
+
+    // Appearance characteristics
+    const mkDict = new PdfDictionary()
+    mkDict.set('BC', new PdfArray([new PdfNumber(0)])) // Border color (black)
+    mkDict.set('BG', new PdfArray([new PdfNumber(1)])) // Background color (white)
+    fieldDict.set('MK', mkDict)
+
     return new PdfIndirectObject({ content: fieldDict })
 }
 
@@ -978,7 +1002,7 @@ const contentStream = new PdfIndirectObject({
 0 -30 Td (Email:) Tj
 0 -30 Td (Phone:) Tj
 0 -30 Td (Subscribe to newsletter:) Tj
-ET`,
+ET `,
     }),
 })
 document.add(contentStream)
@@ -1041,7 +1065,8 @@ acroForm.set(
         subscribeField.reference,
     ]),
 )
-// NeedAppearances flag tells PDF readers to generate appearance streams
+// With appearance streams provided, we don't need NeedAppearances
+// This prevents Acrobat from modifying the PDF on open
 acroForm.set('NeedAppearances', new PdfBoolean(true))
 
 // Default resources for the form (font)
@@ -1051,9 +1076,12 @@ const helveticaFont = new PdfDictionary()
 helveticaFont.set('Type', new PdfName('Font'))
 helveticaFont.set('Subtype', new PdfName('Type1'))
 helveticaFont.set('BaseFont', new PdfName('Helvetica'))
-formFontDict.set('Helv', helveticaFont)
+const helveticaFontObj = new PdfIndirectObject({ content: helveticaFont })
+document.add(helveticaFontObj)
+formFontDict.set('Helv', helveticaFontObj.reference)
 formResources.set('Font', formFontDict)
 acroForm.set('DR', formResources)
+acroForm.set('DA', new PdfString('/Helv 12 Tf 0 g'))
 
 const acroFormObj = new PdfIndirectObject({ content: acroForm })
 document.add(acroFormObj)
@@ -1081,90 +1109,12 @@ console.log('Created form-empty.pdf with empty form fields')
 const emptyFormBytes = await fs.readFile(`${tmpFolder}/form-empty.pdf`)
 const filledDocument = await PdfDocument.fromBytes([emptyFormBytes])
 
-// Get the catalog reference from trailer
-const catalogRef = filledDocument.trailerDict.get('Root')
-if (!catalogRef || !(catalogRef instanceof PdfObjectReference)) {
-    throw new Error('No catalog found in PDF')
-}
-
-// Read the catalog object
-const catalogObj = await filledDocument.readObject({
-    objectNumber: catalogRef.objectNumber,
-})
-if (!catalogObj || !(catalogObj.content instanceof PdfDictionary)) {
-    throw new Error('Catalog object not found')
-}
-
-// Get the AcroForm reference
-const acroFormRef = catalogObj.content.get('AcroForm')
-if (!acroFormRef || !(acroFormRef instanceof PdfObjectReference)) {
-    throw new Error('No AcroForm found in PDF')
-}
-
-// Read the AcroForm object
-const filledAcroFormObj = await filledDocument.readObject({
-    objectNumber: acroFormRef.objectNumber,
+await filledDocument.acroForm.setFieldValues({
+    name: 'John Doe',
+    email: 'john.doe@example.com',
+    phone: '+1 (555) 123-4567',
+    subscribe: 'Off', // For checkbox, use the "Yes/Off" value
 })
-if (
-    !filledAcroFormObj ||
-    !(filledAcroFormObj.content instanceof PdfDictionary)
-) {
-    throw new Error('AcroForm object not found')
-}
-
-// Get the fields array
-const fieldsArray = filledAcroFormObj.content.get('Fields')
-if (!fieldsArray || !(fieldsArray instanceof PdfArray)) {
-    throw new Error('No fields found in AcroForm')
-}
-
-// Helper function to find a field by name
-async function findField(
-    fieldName: string,
-): Promise<PdfIndirectObject<PdfDictionary> | null> {
-    for (const fieldRef of fieldsArray.items) {
-        if (!(fieldRef instanceof PdfObjectReference)) continue
-        const fieldObj = await filledDocument.readObject({
-            objectNumber: fieldRef.objectNumber,
-        })
-        if (!fieldObj || !(fieldObj.content instanceof PdfDictionary)) continue
-
-        const name = fieldObj.content.get('T')
-        if (name instanceof PdfString) {
-            // Convert bytes to string for comparison
-            const nameStr = name.value
-            if (nameStr === fieldName) {
-                return fieldObj as PdfIndirectObject<PdfDictionary>
-            }
-        }
-    }
-    return null
-}
-
-// Update the name field value
-const nameFieldObj = await findField('name')
-if (nameFieldObj) {
-    nameFieldObj.content.set('V', new PdfString('John Doe'))
-}
-
-// Update the email field value
-const emailFieldObj = await findField('email')
-if (emailFieldObj) {
-    emailFieldObj.content.set('V', new PdfString('john.doe@example.com'))
-}
-
-// Update the phone field value
-const phoneFieldObj = await findField('phone')
-if (phoneFieldObj) {
-    phoneFieldObj.content.set('V', new PdfString('+1 (555) 123-4567'))
-}
-
-// Check the subscribe checkbox
-const subscribeFieldObj = await findField('subscribe')
-if (subscribeFieldObj) {
-    subscribeFieldObj.content.set('V', new PdfName('Yes'))
-    subscribeFieldObj.content.set('AS', new PdfName('Yes'))
-}
 
 // Save the filled form
 await fs.writeFile(`${tmpFolder}/form-filled.pdf`, filledDocument.toBytes())
@@ -1174,7 +1124,7 @@ console.log('\nForm field values:')
 console.log('- Name: John Doe')
 console.log('- Email: john.doe@example.com')
 console.log('- Phone: +1 (555) 123-4567')
-console.log('- Subscribe: Yes')
+console.log('- Subscribe: Off')
 ```
 
 ## Tokeniser usage example

package/README.md

@@ -18,6 +18,93 @@ PRs and issues are welcome!
 - **Browser and Node.js support**: Works seamlessly in both environments, allowing for versatile usage.
 - **Low-level API**: Provides a low-level API for advanced users who want to manipulate PDF files directly, as well as a higher-level API for easier usage.
 
+## Installation
+
+```bash
+npm install pdf-lite
+yarn add pdf-lite
+pnpm add pdf-lite
+```
+
+## Usage
+
+The library provides both low-level and high-level APIs for working with PDF documents. See [PDF Support](#pdf-support) for a list of supported features.
+
+### Reading a PDF
+
+```typescript
+import { PdfReader } from 'pdf-lite/pdf/pdf-reader'
+import { readFile } from 'fs/promises'
+
+const pdfBytes = await readFile('document.pdf')
+const doc = await PdfReader.fromBytes([pdfBytes])
+```
+
+### Creating a PDF from Scratch
+
+```typescript
+import { PdfDocument } from 'pdf-lite/pdf/pdf-document'
+import { PdfDictionary } from 'pdf-lite/core/objects/pdf-dictionary'
+import { PdfIndirectObject } from 'pdf-lite/core/objects/pdf-indirect-object'
+import { PdfStream } from 'pdf-lite/core/objects/pdf-stream'
+import { PdfName } from 'pdf-lite/core/objects/pdf-name'
+import { PdfArray } from 'pdf-lite/core/objects/pdf-array'
+import { PdfNumber } from 'pdf-lite/core/objects/pdf-number'
+
+// Create the document
+const document = new PdfDocument()
+
+// Create content stream
+const contentStream = new PdfIndirectObject({
+    content: new PdfStream({
+        header: new PdfDictionary(),
+        original: 'BT /F1 24 Tf 100 700 Td (Hello, PDF-Lite!) Tj ET',
+    }),
+})
+
+// Create and commit objects
+document.commit(contentStream)
+// ... create pages, catalog, etc.
+
+// Output the PDF
+console.log(document.toString())
+```
+
+### Working with Encryption
+
+```typescript
+import { PdfDocument } from 'pdf-lite/pdf/pdf-document'
+import { PdfV2SecurityHandler } from 'pdf-lite/security/handlers/v2'
+
+const document = new PdfDocument()
+// ... build your PDF structure
+
+// Set up encryption
+document.securityHandler = new PdfV2SecurityHandler({
+    password: 'user-password',
+    documentId: 'unique-doc-id',
+    encryptMetadata: true,
+})
+
+// Encrypt the document
+await document.encrypt()
+
+console.log(document.toString())
+```
+
+### Signing PDFs
+
+```typescript
+import {
+    PdfAdbePkcs7DetachedSignatureObject,
+    PdfEtsiCadesDetachedSignatureObject,
+} from 'pdf-lite'
+
+// See examples directory for complete signing implementations
+```
+
+For more detailed examples, see the [EXAMPLES.md](EXAMPLES.md) file and the [examples/](examples/) directory.
+
 ## PDF Support
 
 ### Low-level PDF constructs
@@ -100,6 +187,22 @@ Long-Term Validation (LTV) support ensures that digital signatures remain valid
 - [x] Timestamping
 - [x] Verification of existing signatures
 
+### AcroForm filling
+
+Supports filling out AcroForm forms within PDF documents, allowing for dynamic content generation and user interaction.
+
+[x] Text fields
+[x] Checkboxes
+[x] Radio buttons
+[x] Dropdowns
+
+### XFA Forms
+
+You can read/write XFA XML data from PDFs, but rendering and filling XFA forms is not supported.
+
+[x] Read XFA XML
+[x] Write XFA XML
+
 ## Future Plans
 
 - **Writing Linearized PDF**: Writing linearized PDFs for faster web viewing, improving user experience when accessing documents online.
@@ -133,156 +236,13 @@ pnpm test:unit
 pnpm test:acceptance
 ```
 
-### Package Structure
-
-The main package (`packages/pdf-lite`) contains:
-
-- **src/core/** - Low-level PDF constructs (objects, parser, tokenizer)
-- **src/pdf/** - High-level PDF document handling
-- **src/signing/** - Digital signature support
-- **src/security/** - Encryption and security handlers
-- **src/filters/** - Compression/decompression filters
-
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
 
-## Installation
-
-```bash
-npm install pdf-lite
-```
-
-or
-
-```bash
-yarn add pdf-lite
-```
-
-or
-
-```bash
-pnpm add pdf-lite
-```
-
-## Usage
-
-The library provides both low-level and high-level APIs for working with PDF documents.
-
-### Reading a PDF
-
-```typescript
-import { PdfReader } from 'pdf-lite/pdf/pdf-reader'
-import { readFile } from 'fs/promises'
-
-const pdfBytes = await readFile('document.pdf')
-const doc = await PdfReader.fromBytes([pdfBytes])
-```
-
-### Creating a PDF from Scratch
-
-```typescript
-import { PdfDocument } from 'pdf-lite/pdf/pdf-document'
-import { PdfDictionary } from 'pdf-lite/core/objects/pdf-dictionary'
-import { PdfIndirectObject } from 'pdf-lite/core/objects/pdf-indirect-object'
-import { PdfStream } from 'pdf-lite/core/objects/pdf-stream'
-import { PdfName } from 'pdf-lite/core/objects/pdf-name'
-import { PdfArray } from 'pdf-lite/core/objects/pdf-array'
-import { PdfNumber } from 'pdf-lite/core/objects/pdf-number'
-
-// Create the document
-const document = new PdfDocument()
-
-// Create content stream
-const contentStream = new PdfIndirectObject({
-    content: new PdfStream({
-        header: new PdfDictionary(),
-        original: 'BT /F1 24 Tf 100 700 Td (Hello, PDF-Lite!) Tj ET',
-    }),
-})
-
-// Create and commit objects
-document.commit(contentStream)
-// ... create pages, catalog, etc.
-
-// Output the PDF
-console.log(document.toString())
-```
-
-### Working with Encryption
-
-```typescript
-import { PdfDocument } from 'pdf-lite/pdf/pdf-document'
-import { PdfV2SecurityHandler } from 'pdf-lite/security/handlers/v2'
-
-const document = new PdfDocument()
-// ... build your PDF structure
-
-// Set up encryption
-document.securityHandler = new PdfV2SecurityHandler({
-    password: 'user-password',
-    documentId: 'unique-doc-id',
-    encryptMetadata: true,
-})
-
-// Encrypt the document
-await document.encrypt()
-
-console.log(document.toString())
-```
-
-### Signing PDFs
-
-```typescript
-import {
-    PdfAdbePkcs7DetachedSignatureObject,
-    PdfEtsiCadesDetachedSignatureObject,
-} from 'pdf-lite'
-
-// See examples directory for complete signing implementations
-```
-
-For more detailed examples, see the [EXAMPLES.md](EXAMPLES.md) file and the [examples/](examples/) directory.
-
-## Project Structure
-
-This project is organized as a monorepo:
-
-- **packages/pdf-lite** - Main library package
-- **examples/** - Example scripts demonstrating library usage
-- **scripts/** - Build and development scripts
-
 ## API Reference
 
-The library uses TypeScript subpath exports for modular imports:
-
-```typescript
-// PDF Document
-import { PdfDocument } from 'pdf-lite/pdf/pdf-document'
-import { PdfReader } from 'pdf-lite/pdf/pdf-reader'
-
-// Core PDF objects
-import { PdfArray } from 'pdf-lite/core/objects/pdf-array'
-import { PdfDictionary } from 'pdf-lite/core/objects/pdf-dictionary'
-import { PdfStream } from 'pdf-lite/core/objects/pdf-stream'
-import { PdfString } from 'pdf-lite/core/objects/pdf-string'
-import { PdfName } from 'pdf-lite/core/objects/pdf-name'
-import { PdfNumber } from 'pdf-lite/core/objects/pdf-number'
-import { PdfIndirectObject } from 'pdf-lite/core/objects/pdf-indirect-object'
-import { PdfObjectReference } from 'pdf-lite/core/objects/pdf-object-reference'
-
-// Security
-import { PdfV2SecurityHandler } from 'pdf-lite/security/handlers/v2'
-
-// Signing
-import {
-    PdfAdbePkcs7DetachedSignatureObject,
-    PdfAdbePkcs7Sha1SignatureObject,
-    PdfAdbePkcsX509RsaSha1SignatureObject,
-    PdfEtsiCadesDetachedSignatureObject,
-    PdfEtsiRfc3161SignatureObject,
-} from 'pdf-lite'
-```
+See the [documentation folder](./docs/README.md) or the document site for a complete API reference.
 
 ## License
 

package/dist/acroform/acroform-manager.d.ts

@@ -0,0 +1,49 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+/**
+ * Manages AcroForm fields in PDF documents.
+ * Provides methods to read and write form field values.
+ */
+export declare class PdfAcroFormManager<T extends Record<string, string> = Record<string, string>> {
+    private document;
+    private _acroForm?;
+    constructor(document: PdfDocument);
+    /**
+     * Checks if the document contains AcroForm fields.
+     * @returns True if the document has AcroForm fields, false otherwise
+     */
+    hasAcroForm(): Promise<boolean>;
+    /**
+     * Gets all form field values as a key-value map.
+     * @returns Object with field names as keys and values as strings
+     */
+    getFieldValues(): Promise<T | null>;
+    /**
+     * Sets a form field value by field name.
+     * @param fieldName The name of the field to set
+     * @param value The value to set
+     * @throws Error if the field is not found
+     */
+    setFieldValues(newFields: Partial<T>): Promise<void>;
+    /**
+     * Gets the AcroForm indirect object from the document catalog.
+     * @returns The AcroForm indirect object or null if not found
+     */
+    private getAcroFormObject;
+    /**
+     * Gets the AcroForm dictionary from the document catalog.
+     * @returns The AcroForm dictionary or null if not found
+     */
+    private getAcroForm;
+    /**
+     * Recursively collects field values from the field tree.
+     */
+    private collectFieldValues;
+    /**
+     * Finds a field by its fully qualified name.
+     */
+    private findFieldByName;
+    /**
+     * Gets the fully qualified field name.
+     */
+    private getFieldName;
+}

package/dist/acroform/acroform-manager.js

@@ -0,0 +1,215 @@
+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 { PdfName } from '../core/objects/pdf-name.js';
+import { PdfBoolean } from '../core/objects/pdf-boolean.js';
+/**
+ * Manages AcroForm fields in PDF documents.
+ * Provides methods to read and write form field values.
+ */
+export class PdfAcroFormManager {
+    document;
+    _acroForm;
+    constructor(document) {
+        this.document = document;
+    }
+    /**
+     * Checks if the document contains AcroForm fields.
+     * @returns True if the document has AcroForm fields, false otherwise
+     */
+    async hasAcroForm() {
+        try {
+            const acroForm = await this.getAcroForm();
+            return acroForm !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Gets all form field values as a key-value map.
+     * @returns Object with field names as keys and values as strings
+     */
+    async getFieldValues() {
+        const acroForm = await this.getAcroForm();
+        if (!acroForm)
+            return null;
+        const fields = acroForm.get('Fields')?.as(PdfArray);
+        if (!fields)
+            return null;
+        const values = {};
+        await this.collectFieldValues(fields, values);
+        return values;
+    }
+    /**
+     * Sets a form field value by field name.
+     * @param fieldName The name of the field to set
+     * @param value The value to set
+     * @throws Error if the field is not found
+     */
+    async setFieldValues(newFields) {
+        const acroFormObject = await this.getAcroFormObject();
+        if (!acroFormObject) {
+            throw new Error('Document does not contain AcroForm');
+        }
+        const acroForm = acroFormObject.content.as(PdfDictionary);
+        const fields = acroForm.get('Fields')?.as(PdfArray);
+        if (!fields) {
+            throw new Error('AcroForm has no fields');
+        }
+        const isIncremental = this.document.isIncremental();
+        this.document.setIncremental(true);
+        // Update the AcroForm dictionary with NeedAppearances flag
+        const updatedAcroForm = new PdfIndirectObject({
+            ...acroFormObject,
+            content: acroFormObject.content.clone(),
+        });
+        const updatedAcroFormDict = updatedAcroForm.content.as(PdfDictionary);
+        // Let the PDF viewer know that appearances need to be regenerated
+        updatedAcroFormDict.set('NeedAppearances', new PdfBoolean(true));
+        await this.document.commit(updatedAcroForm);
+        for (const [fieldName, value] of Object.entries(newFields)) {
+            const fieldObject = await this.findFieldByName(fields, fieldName);
+            if (!fieldObject) {
+                throw new Error(`Field '${fieldName}' not found`);
+            }
+            const updatedField = new PdfIndirectObject({
+                ...fieldObject,
+                content: fieldObject.content.clone(),
+            });
+            const fieldDict = updatedField.content.as(PdfDictionary);
+            // Set appearance state (AS) for button fields (checkboxes, radio buttons)
+            // Button fields use PdfName for both V and AS, text fields use PdfString
+            const fieldType = fieldDict.get('FT')?.as(PdfName)?.value;
+            if (fieldType === 'Btn') {
+                fieldDict.set('V', new PdfName(value));
+                fieldDict.set('AS', new PdfName(value));
+            }
+            else {
+                fieldDict.set('V', new PdfString(value));
+            }
+            await this.document.commit(updatedField);
+        }
+        this.document.setIncremental(isIncremental);
+    }
+    /**
+     * Gets the AcroForm indirect object from the document catalog.
+     * @returns The AcroForm indirect object or null if not found
+     */
+    async getAcroFormObject() {
+        const catalog = this.document.rootDictionary;
+        if (!catalog)
+            return null;
+        const acroFormRef = catalog.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await this.document.readObject({
+                objectNumber: acroFormRef.objectNumber,
+                generationNumber: acroFormRef.generationNumber,
+            });
+            if (!acroFormObject)
+                return null;
+            return acroFormObject;
+        }
+        return null;
+    }
+    /**
+     * Gets the AcroForm dictionary from the document catalog.
+     * @returns The AcroForm dictionary or null if not found
+     */
+    async getAcroForm() {
+        if (this._acroForm) {
+            return this._acroForm;
+        }
+        const acroFormObject = await this.getAcroFormObject();
+        if (acroFormObject) {
+            this._acroForm = acroFormObject.content.as(PdfDictionary);
+            return this._acroForm;
+        }
+        const catalog = this.document.rootDictionary;
+        if (!catalog)
+            return null;
+        const acroFormRef = catalog.get('AcroForm');
+        if (acroFormRef instanceof PdfDictionary) {
+            this._acroForm = acroFormRef;
+            return this._acroForm;
+        }
+        return null;
+    }
+    /**
+     * Recursively collects field values from the field tree.
+     */
+    async collectFieldValues(fields, values, parentName = '') {
+        for (const fieldRef of fields.items) {
+            if (!(fieldRef instanceof PdfObjectReference))
+                continue;
+            // Check if we have a modified version cached
+            const fieldObject = await this.document.readObject({
+                objectNumber: fieldRef.objectNumber,
+                generationNumber: fieldRef.generationNumber,
+            });
+            if (!fieldObject)
+                continue;
+            const fieldDict = fieldObject.content.as(PdfDictionary);
+            const fieldName = this.getFieldName(fieldDict, parentName);
+            // Get field value (return empty string if no value set)
+            const value = fieldDict.get('V');
+            if (value instanceof PdfString) {
+                values[fieldName] = value.value;
+            }
+            else if (value instanceof PdfName) {
+                values[fieldName] = value.value;
+            }
+            else if (fieldName) {
+                // Include empty fields
+                values[fieldName] = '';
+            }
+            // Process child fields (Kids)
+            const kids = fieldDict.get('Kids')?.as(PdfArray);
+            if (kids) {
+                await this.collectFieldValues(kids, values, fieldName);
+            }
+        }
+    }
+    /**
+     * Finds a field by its fully qualified name.
+     */
+    async findFieldByName(fields, targetName, parentName = '') {
+        for (const fieldRef of fields.items) {
+            if (!(fieldRef instanceof PdfObjectReference))
+                continue;
+            // Check if we have a modified version cached
+            const fieldObject = await this.document.readObject({
+                objectNumber: fieldRef.objectNumber,
+                generationNumber: fieldRef.generationNumber,
+            });
+            if (!fieldObject)
+                continue;
+            const fieldDict = fieldObject.content.as(PdfDictionary);
+            const fieldName = this.getFieldName(fieldDict, parentName);
+            if (fieldName === targetName) {
+                return fieldObject;
+            }
+            // Search in child fields (Kids)
+            const kids = fieldDict.get('Kids')?.as(PdfArray);
+            if (kids) {
+                const found = await this.findFieldByName(kids, targetName, fieldName);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    /**
+     * Gets the fully qualified field name.
+     */
+    getFieldName(fieldDict, parentName) {
+        const partialName = fieldDict.get('T')?.as(PdfString)?.value ?? '';
+        if (!parentName)
+            return partialName;
+        return `${parentName}.${partialName}`;
+    }
+}

package/dist/acroform/index.d.ts

@@ -0,0 +1 @@
+export { PdfAcroFormManager } from './acroform-manager.js';

package/dist/acroform/index.js

@@ -0,0 +1 @@
+export { PdfAcroFormManager } from './acroform-manager.js';

package/dist/core/objects/pdf-stream.d.ts

@@ -54,6 +54,7 @@ export declare class PdfStream<T extends PdfDictionary = PdfDictionary> extends
     };
     static applyFilters(data: ByteArray, filters: PdfStreamFilterType[]): ByteArray;
     clone(): this;
+    static fromString(data: string): PdfStream;
 }
 export declare class PdfObjStream extends PdfStream {
     constructor(options: {

package/dist/core/objects/pdf-stream.js

@@ -220,6 +220,12 @@ export class PdfStream extends PdfObject {
             original: new Uint8Array(this.original),
         });
     }
+    static fromString(data) {
+        return new PdfStream({
+            original: stringToBytes(data),
+            header: new PdfDictionary(),
+        });
+    }
 }
 export class PdfObjStream extends PdfStream {
     constructor(options) {
@@ -253,11 +259,20 @@ export class PdfObjStream extends PdfStream {
         const reader = bytesToPdfObjects([decodedData]);
         const numbers = [];
         let i = 0;
+        const n = this.header.get('N');
+        const totalObjects = n ? n.value : 0;
         while (true) {
             const { value: obj, done } = reader.next();
             if (done)
                 break;
-            if (obj instanceof PdfDictionary) {
+            if (obj instanceof PdfNumber) {
+                // Collect object numbers and byte offsets
+                numbers.push(obj);
+            }
+            else {
+                // This is an actual PDF object (can be Dictionary, Array, String, Name, etc.)
+                // The first N*2 numbers are: obj_num1 offset1 obj_num2 offset2 ...
+                // After that come the actual objects
                 const objectNumber = numbers[i * 2].value;
                 const generationNumber = 0;
                 yield new PdfIndirectObject({
@@ -266,12 +281,10 @@ export class PdfObjStream extends PdfStream {
                     content: obj,
                 });
                 i++;
-            }
-            else if (obj instanceof PdfNumber) {
-                numbers.push(obj);
-            }
-            else {
-                throw new Error('Invalid object in PDF Object Stream');
+                // Stop after we've read N objects
+                if (totalObjects > 0 && i >= totalObjects) {
+                    break;
+                }
             }
         }
     }

package/dist/pdf/pdf-document.d.ts

@@ -12,6 +12,8 @@ import { PdfTrailerEntries } from '../core/objects/pdf-trailer.js';
 import { PdfDocumentSecurityStoreObject } from '../signing/document-security-store.js';
 import { ByteArray } from '../types.js';
 import { PdfDocumentVerificationResult, PdfSigner } from '../signing/signer.js';
+import { PdfXfaManager } from '../xfa/xfa-manager.js';
+import { PdfAcroFormManager } from '../acroform/acroform-manager.js';
 /**
  * Represents a PDF document with support for reading, writing, and modifying PDF files.
  * Handles document structure, revisions, encryption, and digital signatures.
@@ -38,8 +40,14 @@ export declare class PdfDocument extends PdfObject {
     signer: PdfSigner;
     /** Security handler for encryption/decryption operations */
     securityHandler?: PdfSecurityHandler;
+    private _xfa?;
+    private _acroForm?;
     private hasEncryptionDictionary?;
     private toBeCommitted;
+    /** XFA manager for handling XFA forms */
+    get xfa(): PdfXfaManager;
+    /** AcroForm manager for handling form fields */
+    get acroForm(): PdfAcroFormManager;
     /**
      * Creates a new PDF document instance.
      *
@@ -260,6 +268,12 @@ export declare class PdfDocument extends PdfObject {
      * @returns The PDF document as a Uint8Array
      */
     toBytes(): ByteArray;
+    /**
+     * Serializes the document to a Base64-encoded string.
+     *
+     * @returns A promise that resolves to the PDF document as a Base64 string
+     */
+    toBase64(): string;
     /**
      * Creates a deep copy of the document.
      *

package/dist/pdf/pdf-document.js

@@ -17,6 +17,8 @@ import { PdfStartXRef } from '../core/objects/pdf-start-xref.js';
 import { FoundCompressedObjectError } from './errors.js';
 import { PdfReader } from './pdf-reader.js';
 import { PdfSigner } from '../signing/signer.js';
+import { PdfXfaManager } from '../xfa/xfa-manager.js';
+import { PdfAcroFormManager } from '../acroform/acroform-manager.js';
 /**
  * Represents a PDF document with support for reading, writing, and modifying PDF files.
  * Handles document structure, revisions, encryption, and digital signatures.
@@ -43,8 +45,24 @@ export class PdfDocument extends PdfObject {
     signer;
     /** Security handler for encryption/decryption operations */
     securityHandler;
+    _xfa;
+    _acroForm;
     hasEncryptionDictionary = false;
     toBeCommitted = [];
+    /** XFA manager for handling XFA forms */
+    get xfa() {
+        if (!this._xfa) {
+            this._xfa = new PdfXfaManager(this);
+        }
+        return this._xfa;
+    }
+    /** AcroForm manager for handling form fields */
+    get acroForm() {
+        if (!this._acroForm) {
+            this._acroForm = new PdfAcroFormManager(this);
+        }
+        return this._acroForm;
+    }
     /**
      * Creates a new PDF document instance.
      *
@@ -212,6 +230,9 @@ export class PdfDocument extends PdfObject {
             return undefined;
         }
         const rootObject = this.findUncompressedObject(rootRef);
+        if (!rootObject) {
+            throw new Error('Root object not found');
+        }
         if (!(rootObject?.content instanceof PdfDictionary)) {
             throw new Error(`Root object ${rootRef.objectNumber} ${rootRef.generationNumber} is not a dictionary, it is a ${rootObject?.content.objectType}`);
         }
@@ -392,7 +413,7 @@ export class PdfDocument extends PdfObject {
         }
         const objectStreamIndirect = this.findUncompressedObject({
             objectNumber: xrefEntry.objectStreamNumber.value,
-        });
+        })?.clone();
         if (!objectStreamIndirect) {
             throw new Error(`Cannot find object stream ${xrefEntry.objectStreamNumber.value} for object ${options.objectNumber}`);
         }
@@ -418,7 +439,7 @@ export class PdfDocument extends PdfObject {
     findUncompressedObject(options) {
         const xrefEntry = this.xrefLookup.getObject(options.objectNumber);
         if (xrefEntry instanceof PdfXRefStreamCompressedEntry) {
-            throw new FoundCompressedObjectError(`TODO: Cannot find object ${options.objectNumber} inside object stream via PdfDocument.findObject`);
+            throw new FoundCompressedObjectError(`Cannot find object ${options.objectNumber} inside object stream via PdfDocument.findObject`);
         }
         if (!xrefEntry ||
             (options.generationNumber !== undefined &&
@@ -504,9 +525,13 @@ export class PdfDocument extends PdfObject {
      * @param value - True to enable incremental mode, false to disable. Defaults to true.
      */
     setIncremental(value = true) {
+        if (value === this.isIncremental()) {
+            return;
+        }
         for (const revision of this.revisions) {
             revision.locked = value;
         }
+        this.startNewRevision();
     }
     /**
      * Checks if the document is in incremental mode.
@@ -664,6 +689,20 @@ export class PdfDocument extends PdfObject {
         serializer.feed(...this.toTokens());
         return serializer.toBytes();
     }
+    /**
+     * Serializes the document to a Base64-encoded string.
+     *
+     * @returns A promise that resolves to the PDF document as a Base64 string
+     */
+    toBase64() {
+        const bytes = this.toBytes();
+        let binary = '';
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
     /**
      * Creates a deep copy of the document.
      *

package/dist/pdf/pdf-xref-lookup.js

@@ -204,7 +204,8 @@ export class PdfXrefLookup {
             this.trailerDict.set('Size', new PdfNumber(prevSize));
         }
         const size = Math.max(trailerSize, prevSize);
-        this.trailerDict.set('Size', new PdfNumber(size));
+        if (size !== trailerSize)
+            this.trailerDict.set('Size', new PdfNumber(size));
         return size;
     }
     /**

package/dist/xfa/index.d.ts

@@ -0,0 +1 @@
+export { PdfXfaManager } from './xfa-manager.js';

package/dist/xfa/index.js

@@ -0,0 +1 @@
+export { PdfXfaManager } from './xfa-manager.js';

package/dist/xfa/xfa-manager.d.ts

@@ -0,0 +1,44 @@
+import { PdfDocument } from '../pdf/pdf-document.js';
+/**
+ * Manages XFA (XML Forms Architecture) forms in PDF documents.
+ * Provides methods to read and write XFA form data as XML.
+ */
+export declare class PdfXfaManager {
+    private document;
+    private _datasetsStream?;
+    constructor(document: PdfDocument);
+    /**
+     * Checks if the document contains XFA forms.
+     * @returns True if the document has XFA forms, false otherwise
+     */
+    hasXfaForms(): Promise<boolean>;
+    /**
+     * Reads the XFA form data as XML string.
+     * @returns The XFA datasets XML content, or null if no XFA form exists
+     */
+    readXml(): Promise<string | null>;
+    /**
+     * Writes XML content to the XFA datasets stream.
+     * @param xml The XML content to write
+     * @throws Error if the document doesn't have XFA forms
+     */
+    writeXml(xml: string): Promise<void>;
+    /**
+     * Gets the AcroForm dictionary from the document catalog.
+     * @returns The AcroForm dictionary or null if not found
+     */
+    private getAcroForm;
+    /**
+     * Gets the XFA datasets stream.
+     * Caches the stream for subsequent calls to preserve modifications.
+     * @returns The datasets stream or null if not found
+     */
+    private getDatasetsStream;
+    /**
+     * Finds the XFA dataset object reference from the XFA array.
+     * XFA array structure: [(name1) ref1 (name2) ref2 ...]
+     * @param xfaArray The XFA array from the AcroForm
+     * @returns The object reference to the datasets stream, or null if not found
+     */
+    private findXfaDatasetReference;
+}

package/dist/xfa/xfa-manager.js

@@ -0,0 +1,138 @@
+import { PdfStream } from '../core/objects/pdf-stream.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/index.js';
+/**
+ * Manages XFA (XML Forms Architecture) forms in PDF documents.
+ * Provides methods to read and write XFA form data as XML.
+ */
+export class PdfXfaManager {
+    document;
+    _datasetsStream;
+    constructor(document) {
+        this.document = document;
+    }
+    /**
+     * Checks if the document contains XFA forms.
+     * @returns True if the document has XFA forms, false otherwise
+     */
+    async hasXfaForms() {
+        try {
+            const stream = await this.getDatasetsStream();
+            return stream !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Reads the XFA form data as XML string.
+     * @returns The XFA datasets XML content, or null if no XFA form exists
+     */
+    async readXml() {
+        const stream = await this.getDatasetsStream();
+        if (!stream)
+            return null;
+        // Get decompressed data without modifying the original stream
+        const decompressed = stream.content.decode();
+        // Return the raw XML content as string
+        const decoder = new TextDecoder();
+        return decoder.decode(decompressed);
+    }
+    /**
+     * Writes XML content to the XFA datasets stream.
+     * @param xml The XML content to write
+     * @throws Error if the document doesn't have XFA forms
+     */
+    async writeXml(xml) {
+        const stream = await this.getDatasetsStream();
+        if (!stream) {
+            throw new Error('Document does not contain XFA forms');
+        }
+        // Update the cached stream directly with the new XML content
+        const datasetsIndirect = new PdfIndirectObject({
+            ...stream,
+            content: PdfStream.fromString(xml),
+        });
+        const isIncremental = this.document.isIncremental();
+        this.document.setIncremental(true);
+        await this.document.commit(datasetsIndirect);
+        this.document.setIncremental(isIncremental);
+        // Reset cached stream to force re-fetch if needed
+        this._datasetsStream = undefined;
+    }
+    /**
+     * Gets the AcroForm dictionary from the document catalog.
+     * @returns The AcroForm dictionary or null if not found
+     */
+    async getAcroForm() {
+        const catalog = this.document.rootDictionary;
+        if (!catalog)
+            return null;
+        const acroFormRef = catalog.get('AcroForm');
+        if (!acroFormRef)
+            return null;
+        if (acroFormRef instanceof PdfObjectReference) {
+            const acroFormObject = await this.document.readObject({
+                objectNumber: acroFormRef.objectNumber,
+                generationNumber: acroFormRef.generationNumber,
+            });
+            if (!acroFormObject)
+                return null;
+            return acroFormObject.content.as(PdfDictionary);
+        }
+        else if (acroFormRef instanceof PdfDictionary) {
+            return acroFormRef;
+        }
+        return null;
+    }
+    /**
+     * Gets the XFA datasets stream.
+     * Caches the stream for subsequent calls to preserve modifications.
+     * @returns The datasets stream or null if not found
+     */
+    async getDatasetsStream() {
+        if (this._datasetsStream) {
+            return this._datasetsStream;
+        }
+        const acroForm = await this.getAcroForm();
+        if (!acroForm)
+            return null;
+        const xfaArray = acroForm.get('XFA');
+        if (!(xfaArray instanceof PdfArray))
+            return null;
+        const datasetsRef = this.findXfaDatasetReference(xfaArray);
+        if (!datasetsRef)
+            return null;
+        const datasetObject = await this.document.readObject({
+            objectNumber: datasetsRef.objectNumber,
+            generationNumber: datasetsRef.generationNumber,
+            allowUnindexed: true,
+        });
+        if (!datasetObject)
+            return null;
+        return datasetObject;
+    }
+    /**
+     * Finds the XFA dataset object reference from the XFA array.
+     * XFA array structure: [(name1) ref1 (name2) ref2 ...]
+     * @param xfaArray The XFA array from the AcroForm
+     * @returns The object reference to the datasets stream, or null if not found
+     */
+    findXfaDatasetReference(xfaArray) {
+        const items = xfaArray.items;
+        // XFA array alternates between name strings and object references
+        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') {
+                if (ref instanceof PdfObjectReference) {
+                    return ref;
+                }
+            }
+        }
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-lite",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "dist/index.js",
   "type": "module",
   "exports": {