@adnsistemas/pdf-lib 2.4.5 → 2.5.0

package/dist/pdf-lib.js

@@ -9313,6 +9313,8 @@
             return ref;
         }
         delete(ref) {
+            if (this.snapshot)
+                this.snapshot.markDeletedRef(ref);
             return this.indirectObjects.delete(ref);
         }
         lookupMaybe(ref, ...types) {
@@ -9846,6 +9848,7 @@
         constructor() {
             this.pdfSize = 0;
             this.prevStartXRef = 0;
+            this.deletedCount = 0;
         }
         shouldSave(_objectNumber) {
             return true;
@@ -9862,11 +9865,22 @@
         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;
@@ -9899,11 +9913,26 @@
                 .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) {
@@ -9915,6 +9944,23 @@
             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() {
@@ -9997,7 +10043,37 @@
             }
             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;
@@ -10238,6 +10314,15 @@
                     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));
@@ -15770,11 +15855,17 @@ end\
             }
             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];
@@ -16027,11 +16118,16 @@ end\
             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();
@@ -36114,8 +36210,10 @@ end\
             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