@adnsistemas/pdf-lib 2.4.5 → 2.6.0

package/dist/pdf-lib.js

@@ -9284,12 +9284,20 @@
 
     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,
@@ -9298,6 +9306,18 @@
             };
         }
         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;
@@ -9313,6 +9333,21 @@
             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) {
@@ -9498,8 +9533,23 @@
             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) {
@@ -9846,6 +9896,7 @@
         constructor() {
             this.pdfSize = 0;
             this.prevStartXRef = 0;
+            this.deletedCount = 0;
         }
         shouldSave(_objectNumber) {
             return true;
@@ -9862,11 +9913,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 +9961,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 +9992,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 +10091,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;
@@ -10007,6 +10131,22 @@
                 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),
@@ -10238,6 +10378,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 +15919,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];
@@ -15819,8 +15974,8 @@ end\
     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 = () => {
@@ -15927,7 +16082,17 @@ end\
                 }
                 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);
@@ -16027,11 +16192,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();
@@ -16050,7 +16220,9 @@ end\
         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?
@@ -16107,7 +16279,7 @@ end\
             }
         }
     }
-    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: {}};
 
@@ -35636,7 +35808,7 @@ end\
          */
         static load(pdf, options = {}) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { ignoreEncryption = false, parseSpeed = exports.ParseSpeeds.Slow, throwOnInvalidObject = false, warnOnInvalidObjects = false, updateMetadata = true, capNumbers = false, password, forIncrementalUpdate = false, } = options;
+                const { ignoreEncryption = false, parseSpeed = exports.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']);
@@ -35644,14 +35816,15 @@ end\
                 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();
@@ -36114,8 +36287,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
@@ -36943,6 +37118,51 @@ end\
             }
             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;