pdf-lite 1.5.0 → 1.6.1

package/dist/pdf/pdf-document.js

@@ -5,8 +5,9 @@ import { PdfIndirectObject } from '../core/objects/pdf-indirect-object.js';
 import { PdfComment } from '../core/objects/pdf-comment.js';
 import { PdfWhitespaceToken } from '../core/tokens/whitespace-token.js';
 import { PdfObjStream, PdfStream, PdfXRefStreamCompressedEntry, } from '../core/objects/pdf-stream.js';
+import { PdfArray } from '../core/objects/pdf-array.js';
 import { PdfDictionary } from '../core/objects/pdf-dictionary.js';
-import { PdfObjectReference } from '../core/objects/pdf-object-reference.js';
+import { PdfObjectReference, } from '../core/objects/pdf-object-reference.js';
 import { PdfTokenSerializer } from '../core/serializer.js';
 import { PdfRevision } from './pdf-revision.js';
 import { PdfV5SecurityHandler } from '../security/handlers/v5.js';
@@ -17,9 +18,9 @@ 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 { PdfAcroFormManager } from '../acroform/manager.js';
-import { PdfFontManager } from '../fonts/manager.js';
 import { concatUint8Arrays } from '../utils/concatUint8Arrays.js';
+import { PdfAcroForm } from '../acroform/pdf-acro-form.js';
+import { PdfPages } from './pdf-pages.js';
 /**
  * Represents a PDF document with support for reading, writing, and modifying PDF files.
  * Handles document structure, revisions, encryption, and digital signatures.
@@ -44,11 +45,16 @@ export class PdfDocument extends PdfObject {
     signer;
     /** Security handler for encryption/decryption operations */
     securityHandler;
-    /**  */
-    acroForm;
-    fonts;
+    /** Whether the document is currently in incremental mode (appending changes as a new revision) */
+    incremental = false;
+    originalSecurityHandler;
     hasEncryptionDictionary = false;
-    toBeCommitted = [];
+    _resolvedCache = new Map();
+    _objStreamCache = new Map();
+    _committing = false;
+    _updating = false;
+    _finalized = false;
+    _signed = false;
     /**
      * Creates a new PDF document instance.
      *
@@ -75,13 +81,48 @@ export class PdfDocument extends PdfObject {
         if (options?.ownerPassword) {
             this.setOwnerPassword(options.ownerPassword);
         }
-        this.signer = options?.signer ?? new PdfSigner();
+        this.signer = options?.signer ?? new PdfSigner({ document: this });
         this.linkRevisions();
+        this.wireResolvers(...this.objects.filter((x) => x instanceof PdfIndirectObject), ...this.revisions.map((rev) => rev.xref.trailerDict));
         this.calculateOffsets();
-        this.securityHandler =
-            options?.securityHandler ?? this.getSecurityHandler();
-        this.acroForm = new PdfAcroFormManager(this);
-        this.fonts = new PdfFontManager(this);
+        this.originalSecurityHandler = options?.securityHandler;
+        this.resetSecurityHandler();
+    }
+    resolve(objectNumber, generationNumber) {
+        const cacheKey = `${objectNumber} ${generationNumber}`;
+        const cached = this._resolvedCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const found = this.readObject({ objectNumber, generationNumber });
+        if (!found) {
+            throw new Error(`Object ${objectNumber} ${generationNumber} not found`);
+        }
+        this.wireResolvers(found);
+        this._resolvedCache.set(cacheKey, found);
+        return found;
+    }
+    get acroform() {
+        const root = this.root;
+        const acroFormEntry = root.content.get('AcroForm');
+        if (!acroFormEntry)
+            return null;
+        const acroFormRef = acroFormEntry.as(PdfObjectReference)?.resolve();
+        if (!acroFormRef)
+            return null;
+        return acroFormRef.becomes(PdfAcroForm);
+    }
+    get pages() {
+        const root = this.root;
+        const pagesEntry = root.content.get('Pages');
+        if (pagesEntry) {
+            const pagesRef = pagesEntry.as(PdfObjectReference)?.resolve();
+            if (pagesRef)
+                return pagesRef.becomes(PdfPages);
+        }
+        const pages = new PdfPages();
+        this.add(pages);
+        root.content.set('Pages', pages.reference);
+        return pages;
     }
     get header() {
         return this.revisions[0].header;
@@ -132,6 +173,9 @@ export class PdfDocument extends PdfObject {
         }
         return this;
     }
+    hasObjectInLatestRevision(obj) {
+        return this.latestRevision.objects.includes(obj);
+    }
     /**
      * Adds objects to the document's latest revision.
      * Automatically starts a new revision if the current one is locked.
@@ -143,12 +187,21 @@ export class PdfDocument extends PdfObject {
             this.startNewRevision();
         }
         for (const obj of objects) {
-            if (obj.isImmutable()) {
-                throw new Error('Risky adding a immutable obj');
+            this.wireResolvers(obj);
+            if (this.hasObjectInLatestRevision(obj)) {
+                continue;
             }
-            this.toBeCommitted.push(obj);
             this.latestRevision.addObject(obj);
         }
+        // Auto-add any referenced-but-missing objects
+        const missing = this.collectMissingReferences(...objects);
+        if (missing.length > 0) {
+            this.add(...missing);
+        }
+        this.update();
+        for (const obj of objects) {
+            obj.setModified(false);
+        }
     }
     /**
      * Packs non-stream indirect objects into compressed ObjStm containers.
@@ -290,6 +343,10 @@ export class PdfDocument extends PdfObject {
         }
         return metadataRef;
     }
+    resetSecurityHandler() {
+        this.securityHandler =
+            this.originalSecurityHandler ?? this.getSecurityHandler();
+    }
     getSecurityHandler() {
         const encryptionDictionaryRef = this.trailerDict
             .get('Encrypt')
@@ -383,11 +440,47 @@ export class PdfDocument extends PdfObject {
         }
         return true;
     }
+    commitIncrementalUpdates() {
+        if (!this.incremental || this._committing) {
+            return;
+        }
+        this._committing = true;
+        try {
+            for (const revision of this.revisions) {
+                if (!revision.locked)
+                    continue;
+                for (const obj of revision.objects) {
+                    if (!(obj instanceof PdfIndirectObject)) {
+                        continue;
+                    }
+                    if (obj.isModified()) {
+                        // Pre-register any new objects referenced by obj before
+                        // cloning so the clone gets correct object numbers.
+                        // Without this, proxy references (objectNumber = -1) get
+                        // frozen into the clone as "-1 0 R" — a dangling reference.
+                        const missing = this.collectMissingReferences(obj);
+                        if (missing.length > 0) {
+                            this.add(...missing);
+                        }
+                        const adding = obj.clone();
+                        this.add(adding);
+                        adding.setModified(false);
+                        obj.setModified(false);
+                    }
+                }
+            }
+        }
+        finally {
+            this._committing = false;
+        }
+    }
     /**
-     * Decrypts all encrypted objects in the document.
-     * Removes the security handler and encryption dictionary after decryption.
+     * Decrypts all encrypted object data in-place without removing
+     * the encryption infrastructure. Useful in incremental mode where
+     * the original (encrypted) bytes are preserved via cached tokens
+     * but the live object data needs to be readable.
      */
-    async decrypt() {
+    async decryptObjects() {
         if (!this.securityHandler) {
             return;
         }
@@ -400,19 +493,55 @@ export class PdfDocument extends PdfObject {
             }
             await this.securityHandler.decryptObject(object);
         }
-        this.securityHandler = undefined;
+    }
+    /**
+     * Re-encrypts all objects and updates the document structure.
+     * No-op if the document has no security handler (unencrypted document).
+     */
+    async finalize() {
+        if (this._finalized) {
+            throw new Error('Document has already been finalized');
+        }
+        this._finalized = true;
+        this.update();
+        if (this.securityHandler) {
+            await this.encrypt();
+        }
+        this.update();
+        await this.sign();
+    }
+    /**
+     * Decrypts all encrypted objects in the document.
+     * Removes the security handler and encryption dictionary after decryption.
+     */
+    async decrypt() {
+        if (!this.securityHandler) {
+            return;
+        }
+        await this.decryptObjects();
         this.hasEncryptionDictionary = false;
+        this.securityHandler = undefined;
         const encryptionDict = this.encryptionDictionary;
+        this.trailerDict.delete('Encrypt');
         if (encryptionDict) {
-            await this.deleteObject(encryptionDict);
+            this.deleteObject(encryptionDict);
         }
-        await this.update();
+        this.update();
     }
     /**
-     * Encrypts all objects in the document using the security handler.
-     * Creates and adds an encryption dictionary to all revisions.
+     * Encrypts all encryptable objects using the security handler.
+     * Re-uses the existing encryption dictionary or creates one if needed,
+     * propagating it to all revisions.
      */
     async encrypt() {
+        if (!this.securityHandler) {
+            return;
+        }
+        const addingEncryption = !this.hasEncryptionDictionary;
+        const wasIncremental = this.incremental;
+        if (addingEncryption) {
+            this.setIncremental(false);
+        }
         this.initSecurityHandler({});
         await this.securityHandler.write();
         for (const object of this.objects) {
@@ -423,20 +552,24 @@ export class PdfDocument extends PdfObject {
                 continue;
             }
             await this.securityHandler.encryptObject(object);
+            object.setModified(false);
         }
-        const encryptionDictObject = new PdfIndirectObject({
-            content: this.securityHandler.dict,
-            encryptable: false,
-        });
-        for (const revision of this.revisions) {
-            revision.xref.trailerDict.set('Encrypt', encryptionDictObject.reference);
-            if (!revision.xref.trailerDict.get('ID')) {
-                revision.xref.trailerDict.set('ID', this.securityHandler.getDocumentId());
+        if (addingEncryption) {
+            const encryptionDictObject = new PdfIndirectObject({
+                content: this.securityHandler.dict,
+                encryptable: false,
+            });
+            this.add(encryptionDictObject);
+            this.hasEncryptionDictionary = true;
+            for (const revision of this.revisions) {
+                revision.xref.trailerDict.set('Encrypt', encryptionDictObject.reference);
+                if (!revision.xref.trailerDict.get('ID')) {
+                    revision.xref.trailerDict.set('ID', this.securityHandler.getDocumentId());
+                }
             }
+            this.setIncremental(wasIncremental);
         }
-        await this.commit(encryptionDictObject);
-        this.hasEncryptionDictionary = true;
-        await this.update();
+        this.update();
     }
     /**
      * Finds a compressed object by its object number within an object stream.
@@ -445,28 +578,26 @@ export class PdfDocument extends PdfObject {
      * @returns The found indirect object or undefined if not found
      * @throws Error if the object cannot be found in the expected object stream
      */
-    async findCompressedObject(options) {
+    findCompressedObject(options) {
         const xrefEntry = this.xrefLookup.getObject(options.objectNumber);
         if (!(xrefEntry instanceof PdfXRefStreamCompressedEntry)) {
             throw new Error('Cannot find object inside object stream via PdfDocument.findObject');
         }
-        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}`);
-        }
-        if (this.securityHandler &&
-            this.isObjectEncryptable(objectStreamIndirect)) {
-            await this.securityHandler.decryptObject(objectStreamIndirect);
-        }
-        const objectStream = objectStreamIndirect.content
-            .as(PdfStream)
-            .parseAs(PdfObjStream);
-        const decompressedObject = objectStream.getObject({
-            objectNumber: options.objectNumber,
-        });
-        return decompressedObject;
+        const streamNumber = xrefEntry.objectStreamNumber.value;
+        let objectStream = this._objStreamCache.get(streamNumber);
+        if (!objectStream) {
+            const objectStreamIndirect = this.findUncompressedObject({
+                objectNumber: streamNumber,
+            });
+            if (!objectStreamIndirect) {
+                throw new Error(`Cannot find object stream ${streamNumber} for object ${options.objectNumber}`);
+            }
+            objectStream = objectStreamIndirect.content
+                .as(PdfStream)
+                .parseAs(PdfObjStream);
+            this._objStreamCache.set(streamNumber, objectStream);
+        }
+        return objectStream.getObject({ objectNumber: options.objectNumber });
     }
     /**
      * Finds an uncompressed indirect object by its object number.
@@ -502,14 +633,14 @@ export class PdfDocument extends PdfObject {
      * @param options.allowUnindexed - If true, searches unindexed objects as fallback
      * @returns A cloned and decrypted copy of the object, or undefined if not found
      */
-    async readObject(options) {
+    readObject(options) {
         let foundObject;
         try {
             foundObject = this.findUncompressedObject(options);
         }
         catch (e) {
             if (e instanceof FoundCompressedObjectError) {
-                foundObject = await this.findCompressedObject(options);
+                foundObject = this.findCompressedObject(options);
             }
             else {
                 throw e;
@@ -524,24 +655,32 @@ export class PdfDocument extends PdfObject {
         if (!foundObject) {
             return undefined;
         }
-        if (this.securityHandler && this.isObjectEncryptable(foundObject)) {
+        if (options.cloned) {
             foundObject = foundObject.clone();
-            await this.securityHandler.decryptObject(foundObject);
         }
         return foundObject;
     }
+    /**
+     * Finds the revision that contains a given PDF object.
+     * Useful for determining the origin of an object across multiple revisions.
+     * @param obj - The PDF object to find the revision for
+     * @returns The PdfRevision that contains the object, or undefined if not found in any revision
+     */
+    findRevisionForObject(obj) {
+        return this.revisions.find((rev) => rev.objects.includes(obj));
+    }
     /**
      * Deletes an object from all revisions in the document.
      *
      * @param obj - The PDF object to delete
      */
-    async deleteObject(obj) {
+    deleteObject(obj) {
         if (!obj)
             return;
         for (const revision of this.revisions) {
             revision.deleteObject(obj);
         }
-        await this.update();
+        this.update();
     }
     /**
      * Sets the PDF version for the document.
@@ -565,10 +704,10 @@ export class PdfDocument extends PdfObject {
         if (value === this.isIncremental()) {
             return;
         }
+        this.incremental = value;
         for (const revision of this.revisions) {
             revision.locked = value;
         }
-        this.startNewRevision();
     }
     /**
      * Checks if the document is in incremental mode.
@@ -576,57 +715,7 @@ export class PdfDocument extends PdfObject {
      * @returns True if all revisions are locked for incremental updates
      */
     isIncremental() {
-        return this.latestRevision.locked;
-    }
-    /**
-     * Commits pending objects to the document.
-     * Adds objects, applies encryption if configured, and updates the document structure.
-     *
-     * @param newObjects - Additional objects to add before committing
-     */
-    async commit(...newObjects) {
-        this.add(...newObjects);
-        const queue = this.toBeCommitted.slice();
-        this.toBeCommitted = [];
-        for (const newObject of queue) {
-            if (this.securityHandler &&
-                newObject instanceof PdfIndirectObject &&
-                this.isObjectEncryptable(newObject)) {
-                await this.securityHandler.write();
-                this.ensureEncryptionDictionary();
-                await this.securityHandler.encryptObject(newObject);
-            }
-        }
-        await this.update();
-    }
-    ensureEncryptionDictionary() {
-        if (this.hasEncryptionDictionary) {
-            return;
-        }
-        const encryptionDictObject = new PdfIndirectObject({
-            content: this.securityHandler.dict,
-            encryptable: false,
-        });
-        this.latestRevision.addObject(encryptionDictObject);
-        this.trailerDict.set('Encrypt', encryptionDictObject.reference);
-        this.hasEncryptionDictionary = true;
-    }
-    /**
-     * Sets the Document Security Store (DSS) for the document.
-     * Used for long-term validation of digital signatures.
-     *
-     * @param dss - The Document Security Store object to set
-     * @throws Error if the document has no root dictionary
-     */
-    async setDocumentSecurityStore(dss) {
-        let rootDictionary = this.root?.content;
-        if (!rootDictionary) {
-            throw new Error('Cannot set DSS - document has no root dictionary');
-        }
-        rootDictionary.set('DSS', dss.reference);
-        if (!this.hasObject(dss)) {
-            await this.commit(dss);
-        }
+        return this.incremental;
     }
     /**
      * Returns tokens paired with their source objects.
@@ -648,12 +737,93 @@ export class PdfDocument extends PdfObject {
     tokenize() {
         return this.tokensWithObjects().map(({ token }) => token);
     }
+    wireResolvers(...objects) {
+        const seen = new Set();
+        const walk = (obj) => {
+            if (seen.has(obj))
+                return;
+            seen.add(obj);
+            if (obj instanceof PdfObjectReference &&
+                !(obj instanceof PdfIndirectObject)) {
+                obj.resolver = this;
+            }
+            else if (obj instanceof PdfStream) {
+                walk(obj.header);
+            }
+            else if (obj instanceof PdfDictionary) {
+                for (const [, value] of obj.entries()) {
+                    if (value)
+                        walk(value);
+                }
+            }
+            else if (obj instanceof PdfArray) {
+                for (const item of obj.items) {
+                    walk(item);
+                }
+            }
+            else if (obj instanceof PdfIndirectObject) {
+                walk(obj.content);
+            }
+        };
+        for (const obj of objects) {
+            walk(obj);
+        }
+    }
+    collectMissingReferences(...objects) {
+        const seen = new Set();
+        const missing = [];
+        const queue = [...objects];
+        while (queue.length > 0) {
+            const obj = queue.pop();
+            if (seen.has(obj))
+                continue;
+            seen.add(obj);
+            if (obj instanceof PdfObjectReference &&
+                !(obj instanceof PdfIndirectObject)) {
+                if (obj.resolver) {
+                    try {
+                        const resolved = obj.resolve();
+                        if (resolved instanceof PdfIndirectObject &&
+                            !resolved.inPdf()) {
+                            missing.push(resolved);
+                            queue.push(resolved);
+                        }
+                    }
+                    catch {
+                        // Skip unresolvable references
+                    }
+                }
+            }
+            else if (obj instanceof PdfStream) {
+                queue.push(obj.header);
+            }
+            else if (obj instanceof PdfDictionary) {
+                for (const [, value] of obj.entries()) {
+                    if (value)
+                        queue.push(value);
+                }
+            }
+            else if (obj instanceof PdfArray) {
+                for (const item of obj.items)
+                    queue.push(item);
+            }
+            else if (obj instanceof PdfIndirectObject) {
+                queue.push(obj.content);
+            }
+        }
+        return missing;
+    }
     linkRevisions() {
         const xrefLookups = this.revisions.map((rev) => rev.xref);
         const indirectObjects = this.objects.filter((x) => x instanceof PdfIndirectObject);
         for (const revision of this.revisions) {
             revision.xref.linkPrev(xrefLookups);
-            revision.xref.linkIndirectObjects(indirectObjects);
+            // Walk the entire prev chain to link all xref entries
+            let xref = revision.xref;
+            while (xref) {
+                xref.linkIndirectObjects(indirectObjects);
+                xref = xref.prev;
+            }
         }
     }
     linkOffsets() {
@@ -700,7 +870,7 @@ export class PdfDocument extends PdfObject {
     }
     updateRevisions() {
         let modified = false;
-        this.revisions.forEach((rev, i) => {
+        this.revisions.forEach((rev) => {
             if (rev.isModified()) {
                 modified = true;
             }
@@ -708,11 +878,72 @@ export class PdfDocument extends PdfObject {
                 rev.update();
             }
         });
+        // Always rebuild xref binary data to reflect recalculated offsets
+        // This walks the entire prev chain for each revision
+        for (const rev of this.revisions) {
+            let xref = rev.xref;
+            while (xref) {
+                xref.update();
+                xref = xref.prev;
+            }
+        }
     }
-    async update() {
-        this.calculateOffsets();
-        this.updateRevisions();
-        await this.signer?.sign(this);
+    /**
+     * Performs a full update cycle to ensure all revisions are consistent and offsets are correct.
+     */
+    update() {
+        if (this._updating)
+            return;
+        this._updating = true;
+        try {
+            this.commitIncrementalUpdates();
+            this.flushResolvedCache();
+            this.registerNewReferences();
+            this.calculateOffsets();
+            this.updateRevisions();
+            // Second pass: xref binary may have changed size (e.g. FlateDecode removed
+            // from xref stream), shifting objects that follow it. Recalculate so entry
+            // byteOffset refs hold the new positions, then rebuild the xref binary once
+            // more so the baked bytes match those positions.
+            this.calculateOffsets();
+            this.updateRevisions();
+            // Third pass: confirm positions are stable (xref binary size should not
+            // change again because W widths and entry count are the same).
+            this.calculateOffsets();
+        }
+        finally {
+            this._updating = false;
+        }
+    }
+    /**
+     * Walks all objects in the document and registers any newly created
+     * PdfIndirectObjects that are referenced but not yet part of the document
+     * (e.g. appearance streams created by generateAppearance).
+     */
+    registerNewReferences() {
+        const missing = this.collectMissingReferences(...this.latestRevision.objects);
+        if (missing.length > 0) {
+            this.add(...missing);
+        }
+    }
+    flushResolvedCache() {
+        const existing = new Set(this.objects);
+        for (const [, obj] of this._resolvedCache) {
+            if (obj.isModified() && !existing.has(obj)) {
+                this.add(obj);
+                existing.add(obj);
+            }
+        }
+    }
+    async sign() {
+        if (this._signed) {
+            throw new Error('Document has already been signed');
+        }
+        if (!this.signer) {
+            return;
+        }
+        await this.signer.sign();
+        this._signed = true;
     }
     /**
      * Serializes the document to a byte array.
@@ -720,24 +951,9 @@ export class PdfDocument extends PdfObject {
      * @returns The PDF document as a Uint8Array
      */
     toBytes() {
-        this.calculateOffsets();
-        this.updateRevisions();
+        this.update();
         return concatUint8Arrays(...this.revisions.map((x) => x.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.
      *
@@ -757,8 +973,8 @@ export class PdfDocument extends PdfObject {
      * @param input - Async or sync iterable of byte arrays
      * @returns A promise that resolves to the parsed PdfDocument
      */
-    static fromBytes(input) {
-        return PdfReader.fromBytes(input);
+    static fromBytes(input, options) {
+        return PdfReader.fromBytes(input, options);
     }
     isModified() {
         return (super.isModified() || this.revisions.some((rev) => rev.isModified()));
@@ -769,6 +985,6 @@ export class PdfDocument extends PdfObject {
      * @returns A promise that resolves to the verification result
      */
     async verifySignatures() {
-        return await this.signer.verify(this);
+        return await this.signer.verify();
     }
 }