@adnsistemas/pdf-lib 2.5.0 → 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;
@@ -9315,6 +9335,19 @@
         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) {
@@ -9500,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) {
@@ -10083,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),
@@ -15910,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 = () => {
@@ -16018,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);
@@ -16146,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?
@@ -16203,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: {}};
 
@@ -35732,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']);
@@ -35740,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();
@@ -37041,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;