@adnsistemas/pdf-lib 2.4.5 → 2.6.0

package/dist/pdf-lib.esm.js

@@ -9278,12 +9278,20 @@ SimpleRNG.withSeed = (seed) => new SimpleRNG(seed);
 
 const byAscendingObjectNumber = ([a], [b]) => a.objectNumber - b.objectNumber;
 class PDFContext {
-    constructor() {
+    get preserveObjectsVersions() {
+        return this._preserveObjectsVersions;
+    }
+    constructor(preserveObjectsVersions) {
         this.isDecrypted = true;
+        this.xrefs = [];
+        this._preserveObjectsVersions = preserveObjectsVersions
+            ? preserveObjectsVersions
+            : false;
         this.largestObjectNumber = 0;
         this.header = PDFHeader.forVersion(1, 7);
         this.trailerInfo = {};
         this.indirectObjects = new Map();
+        this.objectsPreviousVersions = new Map();
         this.rng = SimpleRNG.withSeed(1);
         this.pdfFileDetails = {
             pdfSize: 0,
@@ -9292,6 +9300,18 @@ class PDFContext {
         };
     }
     assign(ref, object) {
+        if (this.preserveObjectsVersions) {
+            const prevOV = this.indirectObjects.get(ref);
+            if (prevOV) {
+                const prevList = this.objectsPreviousVersions.get(ref);
+                if (!prevList) {
+                    this.objectsPreviousVersions.set(ref, [prevOV]);
+                }
+                else {
+                    prevList.unshift(prevOV);
+                }
+            }
+        }
         this.indirectObjects.set(ref, object);
         if (ref.objectNumber > this.largestObjectNumber) {
             this.largestObjectNumber = ref.objectNumber;
@@ -9307,6 +9327,21 @@ class PDFContext {
         return ref;
     }
     delete(ref) {
+        if (this.snapshot)
+            this.snapshot.markDeletedRef(ref);
+        if (this.preserveObjectsVersions) {
+            const object = this.indirectObjects.get(ref);
+            if (object) {
+                // check is not already deleted
+                const verlist = this.objectsPreviousVersions.get(ref);
+                if (verlist) {
+                    verlist.unshift(object);
+                }
+                else {
+                    this.objectsPreviousVersions.set(ref, [object]);
+                }
+            }
+        }
         return this.indirectObjects.delete(ref);
     }
     lookupMaybe(ref, ...types) {
@@ -9492,8 +9527,23 @@ class PDFContext {
         if (this.snapshot)
             this.snapshot.markObjForSave(obj);
     }
+    getObjectVersions(ref) {
+        if (!this.preserveObjectsVersions)
+            return [];
+        const list = this.objectsPreviousVersions.get(ref);
+        if (list)
+            return list;
+        return [];
+    }
+    listXrefEntries(xrefIndex = -1) {
+        if (xrefIndex < 0)
+            xrefIndex = this.xrefs.length - 1;
+        if (xrefIndex < 0 || xrefIndex >= this.xrefs.length)
+            return [];
+        return this.xrefs[xrefIndex].listRefs();
+    }
 }
-PDFContext.create = () => new PDFContext();
+PDFContext.create = (withObjectVersions = false) => new PDFContext(withObjectVersions);
 
 class PDFPageLeaf extends PDFDict {
     constructor(map, context, autoNormalizeCTM = true) {
@@ -9840,6 +9890,7 @@ class DefaultDocumentSnapshot {
     constructor() {
         this.pdfSize = 0;
         this.prevStartXRef = 0;
+        this.deletedCount = 0;
     }
     shouldSave(_objectNumber) {
         return true;
@@ -9856,11 +9907,22 @@ class DefaultDocumentSnapshot {
     markObjsForSave(_objs) {
         throw new Error('This method should not be called.');
     }
+    markDeletedObj(_obj) {
+        throw new Error('This method should not be called.');
+    }
+    markDeletedRef(_ref) {
+        throw new Error('This method should not be called.');
+    }
+    deletedRef(_index) {
+        throw new Error('This method should not be called.');
+    }
 }
 const defaultDocumentSnapshot = new DefaultDocumentSnapshot();
 
 class IncrementalDocumentSnapshot {
     constructor(lastObjectNumber, indirectObjects, pdfSize, prevStartXRef, context) {
+        this.deletedCount = 0;
+        this.deleted = [];
         this.lastObjectNumber = lastObjectNumber;
         this.changedObjects = indirectObjects;
         this.pdfSize = pdfSize;
@@ -9893,11 +9955,26 @@ class IncrementalDocumentSnapshot {
             .map((obj) => this.context.getRef(obj))
             .filter((ref) => ref !== undefined));
     }
+    markDeletedRef(ref) {
+        if (this.deleted.findIndex((dref) => dref.objectNumber === ref.objectNumber) <
+            0)
+            this.deletedCount = this.deleted.push(ref);
+    }
+    markDeletedObj(obj) {
+        const oref = this.context.getRef(obj);
+        if (oref)
+            this.markDeletedRef(oref);
+    }
+    deletedRef(index) {
+        if (index < 0 || index >= this.deleted.length)
+            return null;
+        return this.deleted[index];
+    }
 }
 
 /**
  * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
- * methods **in order of ascending object number**.
+ * methods.
  */
 class PDFCrossRefSection {
     constructor(firstEntry) {
@@ -9909,6 +9986,23 @@ class PDFCrossRefSection {
         this.append({ ref, offset, deleted: false });
     }
     addDeletedEntry(ref, nextFreeObjectNumber) {
+        // fix the first entry if required
+        if (!this.subsections.length) {
+            this.subsections = [
+                [
+                    {
+                        ref: PDFRef.of(0, 65535),
+                        offset: ref.objectNumber,
+                        deleted: true,
+                    },
+                ],
+            ];
+            this.chunkIdx = 0;
+            this.chunkLength = 1;
+        }
+        else if (!this.subsections[0][0].offset) {
+            this.subsections[0][0].offset = ref.objectNumber;
+        }
         this.append({ ref, offset: nextFreeObjectNumber, deleted: true });
     }
     toString() {
@@ -9991,7 +10085,37 @@ class PDFCrossRefSection {
         }
         const chunk = this.subsections[this.chunkIdx];
         const prevEntry = chunk[this.chunkLength - 1];
-        if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) {
+        if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber !== 1) {
+            // the current chunk is not the right chunk, find the right one, or create a new one
+            for (let c = 0; c < this.subsections.length; c++) {
+                const first = this.subsections[c][0];
+                const last = this.subsections[c][this.subsections[c].length - 1];
+                if (first.ref.objectNumber > currEntry.ref.objectNumber) {
+                    // goes before this subsection, or at the start of it
+                    if (first.ref.objectNumber - currEntry.ref.objectNumber === 1) {
+                        // first element of subsection
+                        this.subsections[c].unshift(currEntry);
+                        if (c === this.chunkIdx)
+                            this.chunkLength += 1;
+                        return;
+                    }
+                    else {
+                        // create subsection
+                        this.subsections.splice(c, 0, [currEntry]);
+                        this.chunkIdx++;
+                        return;
+                    }
+                }
+                else if (last.ref.objectNumber > currEntry.ref.objectNumber) {
+                    // goes in this subsection, find its place..
+                    const cep = this.subsections[c].findIndex((ee) => ee.ref.objectNumber > currEntry.ref.objectNumber);
+                    this.subsections[c].splice(cep, 0, currEntry);
+                    if (c === this.chunkIdx)
+                        this.chunkLength += 1;
+                }
+                // bigger, keep looking
+            }
+            // if got to here, then a new subsection is required
             this.subsections.push([currEntry]);
             this.chunkIdx += 1;
             this.chunkLength = 1;
@@ -10001,6 +10125,22 @@ class PDFCrossRefSection {
             this.chunkLength += 1;
         }
     }
+    /**
+     * Returns all the entries in the XREF section, except the first one (object == 0)
+     * @returns {Entry[]} All the entries in the XREF section
+     */
+    listRefs() {
+        const refList = [];
+        for (let rangeIdx = 0, rangeLen = this.subsections.length; rangeIdx < rangeLen; rangeIdx++) {
+            const range = this.subsections[rangeIdx];
+            for (let entryIdx = 0, entryLen = range.length; entryIdx < entryLen; entryIdx++) {
+                const entry = range[entryIdx];
+                if (entry.ref.objectNumber)
+                    refList.push(entry);
+            }
+        }
+        return refList;
+    }
 }
 PDFCrossRefSection.create = () => new PDFCrossRefSection({
     ref: PDFRef.of(0, 65535),
@@ -10232,6 +10372,15 @@ class PDFWriter {
                 if (this.shouldWaitForTick(1))
                     yield waitForTick();
             }
+            // deleted objects
+            for (let idx = 0; idx < this.snapshot.deletedCount; idx++) {
+                const dref = this.snapshot.deletedRef(idx);
+                if (!dref)
+                    break;
+                const nextdref = this.snapshot.deletedRef(idx + 1);
+                // add 1 to generation number for deleted ref
+                xref.addDeletedEntry(PDFRef.of(dref.objectNumber, dref.generationNumber + 1), nextdref ? nextdref.objectNumber : 0);
+            }
             const xrefOffset = size;
             size += xref.sizeInBytes() + 1; // '\n'
             const trailerDict = PDFTrailerDict.of(this.createTrailerDict(this.snapshot.prevStartXRef));
@@ -15764,11 +15913,17 @@ class PDFXRefStreamParser {
         }
         this.alreadyParsed = true;
         this.context.trailerInfo = {
+            Size: this.dict.lookup(PDFName.of('Size'), PDFNumber),
             Root: this.dict.get(PDFName.of('Root')),
             Encrypt: this.dict.get(PDFName.of('Encrypt')),
             Info: this.dict.get(PDFName.of('Info')),
             ID: this.dict.get(PDFName.of('ID')),
         };
+        // if open for incremental update, make sure next object number doesn't overlap a deleted one
+        if (this.context.trailerInfo.Size &&
+            this.context.pdfFileDetails.originalBytes)
+            this.context.largestObjectNumber =
+                this.context.trailerInfo.Size.asNumber() - 1;
         const entries = this.parseEntries();
         // for (let idx = 0, len = entries.length; idx < len; idx++) {
         // const entry = entries[idx];
@@ -15813,8 +15968,8 @@ class PDFXRefStreamParser {
 PDFXRefStreamParser.forStream = (rawStream) => new PDFXRefStreamParser(rawStream);
 
 class PDFParser extends PDFObjectParser {
-    constructor(pdfBytes, objectsPerTick = Infinity, throwOnInvalidObject = false, warnOnInvalidObjects = false, capNumbers = false, cryptoFactory, forIncrementalUpdate = false) {
-        super(ByteStream.of(pdfBytes), PDFContext.create(), capNumbers, cryptoFactory);
+    constructor(pdfBytes, objectsPerTick = Infinity, throwOnInvalidObject = false, warnOnInvalidObjects = false, capNumbers = false, cryptoFactory, forIncrementalUpdate = false, preserveObjectsVersions = false) {
+        super(ByteStream.of(pdfBytes), PDFContext.create(preserveObjectsVersions), capNumbers, cryptoFactory);
         this.alreadyParsed = false;
         this.parsedObjects = 0;
         this.shouldWaitForTick = () => {
@@ -15921,7 +16076,17 @@ class PDFParser extends PDFObjectParser {
             }
             else if (object instanceof PDFRawStream &&
                 object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')) {
-                PDFXRefStreamParser.forStream(object).parseIntoContext();
+                const entries = PDFXRefStreamParser.forStream(object).parseIntoContext();
+                if (entries.length) {
+                    const xref = PDFCrossRefSection.createEmpty();
+                    for (const entry of entries) {
+                        if (entry.deleted)
+                            xref.addDeletedEntry(entry.ref, entry.offset);
+                        else
+                            xref.addEntry(entry.ref, entry.offset);
+                    }
+                    this.context.xrefs.push(xref);
+                }
             }
             // always register the object and the ref, to properly handle object numeration
             this.context.assign(ref, object);
@@ -16021,11 +16186,16 @@ class PDFParser extends PDFObjectParser {
         const dict = this.parseDict();
         const { context } = this;
         context.trailerInfo = {
+            Size: dict.lookupMaybe(PDFName.of('Size'), PDFNumber) ||
+                context.trailerInfo.Size,
             Root: dict.get(PDFName.of('Root')) || context.trailerInfo.Root,
             Encrypt: dict.get(PDFName.of('Encrypt')) || context.trailerInfo.Encrypt,
             Info: dict.get(PDFName.of('Info')) || context.trailerInfo.Info,
             ID: dict.get(PDFName.of('ID')) || context.trailerInfo.ID,
         };
+        // if open for incremental update, then deleted objects need to be preserved, and largestObjectNumber has to be Size-1
+        if (context.trailerInfo.Size && context.pdfFileDetails.originalBytes)
+            context.largestObjectNumber = context.trailerInfo.Size.asNumber() - 1;
     }
     maybeParseTrailer() {
         this.skipWhitespaceAndComments();
@@ -16044,7 +16214,9 @@ class PDFParser extends PDFObjectParser {
     parseDocumentSection() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.parseIndirectObjects();
-            this.maybeParseCrossRefSection();
+            const xref = this.maybeParseCrossRefSection();
+            if (xref)
+                this.context.xrefs.push(xref);
             this.maybeParseTrailerDict();
             this.maybeParseTrailer();
             // TODO: Can this be done only when needed, to avoid harming performance?
@@ -16101,7 +16273,7 @@ class PDFParser extends PDFObjectParser {
         }
     }
 }
-PDFParser.forBytesWithOptions = (pdfBytes, objectsPerTick, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, cryptoFactory, forIncrementalUpdate) => new PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, cryptoFactory, forIncrementalUpdate);
+PDFParser.forBytesWithOptions = (pdfBytes, objectsPerTick, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, cryptoFactory, forIncrementalUpdate, preserveObjectsVersions) => new PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, cryptoFactory, forIncrementalUpdate, preserveObjectsVersions);
 
 var cryptoJs = {exports: {}};
 
@@ -35630,7 +35802,7 @@ class PDFDocument {
      */
     static load(pdf, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { ignoreEncryption = false, parseSpeed = ParseSpeeds.Slow, throwOnInvalidObject = false, warnOnInvalidObjects = false, updateMetadata = true, capNumbers = false, password, forIncrementalUpdate = false, } = options;
+            const { ignoreEncryption = false, parseSpeed = ParseSpeeds.Slow, throwOnInvalidObject = false, warnOnInvalidObjects = false, updateMetadata = true, capNumbers = false, password, forIncrementalUpdate = false, preserveObjectsVersions = false, } = options;
             assertIs(pdf, 'pdf', ['string', Uint8Array, ArrayBuffer]);
             assertIs(ignoreEncryption, 'ignoreEncryption', ['boolean']);
             assertIs(parseSpeed, 'parseSpeed', ['number']);
@@ -35638,14 +35810,15 @@ class PDFDocument {
             assertIs(warnOnInvalidObjects, 'warnOnInvalidObjects', ['boolean']);
             assertIs(password, 'password', ['string', 'undefined']);
             assertIs(forIncrementalUpdate, 'forIncrementalUpdate', ['boolean']);
+            assertIs(preserveObjectsVersions, 'preserveObjectsVersions', ['boolean']);
             const bytes = toUint8Array(pdf);
-            const context = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, undefined, capNumbers, undefined, forIncrementalUpdate).parseDocument();
+            const context = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, undefined, capNumbers, undefined, forIncrementalUpdate, preserveObjectsVersions).parseDocument();
             if (!!context.lookup(context.trailerInfo.Encrypt) &&
                 password !== undefined) {
                 // Decrypt
                 const fileIds = context.lookup(context.trailerInfo.ID, PDFArray);
                 const encryptDict = context.lookup(context.trailerInfo.Encrypt, PDFDict);
-                const decryptedContext = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, new CipherTransformFactory(encryptDict, fileIds.get(0).asBytes(), password), forIncrementalUpdate).parseDocument();
+                const decryptedContext = yield PDFParser.forBytesWithOptions(bytes, parseSpeed, throwOnInvalidObject, warnOnInvalidObjects, capNumbers, new CipherTransformFactory(encryptDict, fileIds.get(0).asBytes(), password), forIncrementalUpdate, preserveObjectsVersions).parseDocument();
                 const pdfDoc = new PDFDocument(decryptedContext, true, updateMetadata);
                 if (forIncrementalUpdate)
                     pdfDoc.takeSnapshot();
@@ -36108,8 +36281,10 @@ class PDFDocument {
         if (this.pageCount === 0)
             throw new RemovePageFromEmptyDocumentError();
         assertRange(index, 'index', 0, pageCount - 1);
+        const page = this.getPage(index);
         this.catalog.removeLeafNode(index);
         this.pageCount = pageCount - 1;
+        this.context.delete(page.ref);
     }
     /**
      * Add a page to the end of this document. This method accepts three
@@ -36937,6 +37112,51 @@ class PDFDocument {
         }
         return snapshot;
     }
+    /**
+     * Returns the update version of the object as 'actual', and all the previous versions, of the objects
+     * that has changed in the indicated update (or the last one).
+     * If document wasn't load to preserve objects versions, an empty array is returned.
+     * @param {number} lastUpdateMinusX If not the last update, how many updates before the last.
+     * @returns  {PDFObjectVersions[]} Objects modified in the update, and previous versions
+     */
+    getChangedObjects(lastUpdateMinusX = 0) {
+        if (!this.context.preserveObjectsVersions)
+            return [];
+        if (lastUpdateMinusX < 0)
+            lastUpdateMinusX = 0;
+        const upind = this.context.xrefs.length - lastUpdateMinusX - 1;
+        const entries = this.context.listXrefEntries(upind);
+        if (!entries.length)
+            return [];
+        const changed = new Map();
+        for (const entry of entries) {
+            const ref = entry.ref;
+            changed.set(ref, {
+                ref,
+                actual: entry.deleted ? undefined : this.context.lookup(ref),
+                previous: this.context.getObjectVersions(ref),
+            });
+        }
+        // if not the las update, then check objects later modified and adjust PDFObjectVersions accordingly
+        if (!lastUpdateMinusX)
+            return Array.from(changed.entries()).map((value) => value[1]);
+        while (lastUpdateMinusX) {
+            lastUpdateMinusX -= 1;
+            const upind = this.context.xrefs.length - lastUpdateMinusX - 1;
+            const nentries = this.context.listXrefEntries(upind);
+            for (const nentry of nentries) {
+                const oce = changed.get(nentry.ref);
+                if (oce && oce.actual) {
+                    oce.actual = oce.previous[0];
+                    oce.previous = oce.previous.slice(1);
+                }
+            }
+        }
+        // if PDF has errors, it may happen to end with objects that has no current, nor previous versions
+        return Array.from(changed.entries())
+            .map((value) => value[1])
+            .filter((ov) => ov.actual || ov.previous.length);
+    }
     prepareForSave(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { addDefaultPage = true, updateFieldAppearances = true } = options;