@adnsistemas/pdf-lib 2.7.1 → 2.7.3

package/dist/pdf-lib.esm.js

@@ -9002,7 +9002,7 @@ class PDFString extends PDFObject {
                     pushByte(CharCodes$1.LeftParen);
                 else if (byte === CharCodes$1.RightParen)
                     pushByte(CharCodes$1.RightParen);
-                else if (byte === CharCodes$1.Backspace)
+                else if (byte === CharCodes$1.BackSlash)
                     pushByte(CharCodes$1.BackSlash);
                 else if (byte >= CharCodes$1.Zero && byte <= CharCodes$1.Seven) {
                     octal += char;
@@ -9982,13 +9982,9 @@ class IncrementalDocumentSnapshot {
         this.context = context;
     }
     shouldSave(objectNumber) {
-        if (objectNumber > this.lastObjectNumber) {
+        if (objectNumber > this.lastObjectNumber)
             return true;
-        }
-        if (this.changedObjects.includes(objectNumber)) {
-            return true;
-        }
-        return false;
+        return this.changedObjects.has(objectNumber);
     }
     markRefForSave(ref) {
         this.markRefsForSave([ref]);
@@ -9996,7 +9992,7 @@ class IncrementalDocumentSnapshot {
     markRefsForSave(refs) {
         refs.forEach((ref) => {
             if (ref)
-                this.changedObjects.push(ref.objectNumber);
+                this.changedObjects.add(ref.objectNumber);
         });
     }
     markObjForSave(obj) {
@@ -10325,6 +10321,17 @@ PDFObjectStream.withContextAndObjects = (context, objects, encode = true) => new
 class PDFWriter {
     constructor(context, objectsPerTick, snapshot) {
         this.parsedObjects = 0;
+        /**
+         * If PDF has an XRef Stream, then the last object will be probably be skipped on saving.
+         * If that's the case, this property will have that object number, and the PDF /Size can
+         * be corrected, to be accurate.
+         */
+        this._largestSkippedObjectNum = 0;
+        /**
+         * Used to check wheter an object should be saved or not, preserves the object number of the
+         * last XRef Stream object, if there is one.
+         */
+        this._lastXRefObjectNumber = 0;
         this.shouldWaitForTick = (n) => {
             this.parsedObjects += n;
             return this.parsedObjects % this.objectsPerTick === 0;
@@ -10333,6 +10340,44 @@ class PDFWriter {
         this.objectsPerTick = objectsPerTick;
         this.snapshot = snapshot;
     }
+    /**
+     * For incremental saves, defers the decision to the snapshot.
+     * For full saves, checks that the object is not the last XRef stream object.
+     * @param {boolean} incremental If making an incremental save, or a full save of the PDF
+     * @param {number} objNum Object number
+     * @param {[PDFRef, PDFObject][]} objects List of objects that form the PDF
+     * @returns {boolean} whether the object should be saved or not
+     */
+    shouldSave(incremental, objNum, objects) {
+        let should = true;
+        if (incremental) {
+            should = this.snapshot.shouldSave(objNum);
+        }
+        else {
+            // only the last XRef Stream will be regenerated on save
+            if (!this._lastXRefObjectNumber) {
+                // if no XRef Stream, then nothing should be skipped
+                this._lastXRefObjectNumber = this.context.largestObjectNumber + 1;
+                const checkWatermark = this._lastXRefObjectNumber - 10; // max number of objects in the final part of the PDF to check
+                // search the last XRef Stream, if there is one, objects are expected to be in object number order
+                for (let idx = objects.length - 1; idx > 0; idx--) {
+                    // if not in last 'rangeToCheck' objects, there is none that should be skipped, most probably a linearized PDF, or without XRef Streams
+                    if (objects[idx][0].objectNumber < checkWatermark)
+                        break;
+                    const object = objects[idx][1];
+                    if (object instanceof PDFRawStream &&
+                        object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')) {
+                        this._lastXRefObjectNumber = objects[idx][0].objectNumber;
+                        break;
+                    }
+                }
+            }
+            should = objNum !== this._lastXRefObjectNumber;
+        }
+        if (!should && this._largestSkippedObjectNum < objNum)
+            this._largestSkippedObjectNum = objNum;
+        return should;
+    }
     serializeToBuffer() {
         return __awaiter(this, void 0, void 0, function* () {
             const incremental = !(this.snapshot instanceof DefaultDocumentSnapshot);
@@ -10346,7 +10391,7 @@ class PDFWriter {
             buffer[offset++] = CharCodes$1.Newline;
             for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
                 const [ref, object] = indirectObjects[idx];
-                if (!this.snapshot.shouldSave(ref.objectNumber)) {
+                if (!this.shouldSave(incremental, ref.objectNumber, indirectObjects)) {
                     continue;
                 }
                 const objectNumber = String(ref.objectNumber);
@@ -10392,8 +10437,16 @@ class PDFWriter {
         return refSize + objectSize;
     }
     createTrailerDict(prevStartXRef) {
+        /**
+         * if last object (XRef Stream) is not in the output, then size is one less.
+         * An XRef Stream object should always be the largest object number in PDF
+         */
+        const size = this.context.largestObjectNumber +
+            (this._largestSkippedObjectNum === this.context.largestObjectNumber
+                ? 0
+                : 1);
         return this.context.obj({
-            Size: this.context.largestObjectNumber + 1,
+            Size: size,
             Root: this.context.trailerInfo.Root,
             Encrypt: this.context.trailerInfo.Encrypt,
             Info: this.context.trailerInfo.Info,
@@ -10403,6 +10456,8 @@ class PDFWriter {
     }
     computeBufferSize(incremental) {
         return __awaiter(this, void 0, void 0, function* () {
+            this._largestSkippedObjectNum = 0;
+            this._lastXRefObjectNumber = 0;
             const header = PDFHeader.forVersion(1, 7);
             let size = this.snapshot.pdfSize;
             if (!incremental) {
@@ -10415,7 +10470,7 @@ class PDFWriter {
             for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
                 const indirectObject = indirectObjects[idx];
                 const [ref, object] = indirectObject;
-                if (!this.snapshot.shouldSave(ref.objectNumber))
+                if (!this.shouldSave(incremental, ref.objectNumber, indirectObjects))
                     continue;
                 if (security)
                     this.encrypt(ref, object, security);
@@ -15877,7 +15932,8 @@ class PDFObjectParser extends BaseParser {
                 let actualValue = value.substring(1, value.length - 1);
                 if (this.cryptoFactory && ref) {
                     const transformer = this.cryptoFactory.createCipherTransform(ref.objectNumber, ref.generationNumber);
-                    actualValue = transformer.decryptString(actualValue);
+                    const decrypted = transformer.decryptBytes(PDFString.of(actualValue).asBytes());
+                    actualValue = arrayAsString(decrypted);
                 }
                 // Remove the outer parens so they aren't part of the contents
                 return PDFString.of(actualValue);
@@ -37269,7 +37325,7 @@ class PDFDocument {
         return undefined;
     }
     takeSnapshot() {
-        const indirectObjects = [];
+        const indirectObjects = new Set();
         const snapshot = new IncrementalDocumentSnapshot(this.context.largestObjectNumber, indirectObjects, this.context.pdfFileDetails.pdfSize, this.context.pdfFileDetails.prevStartXRef, this.context);
         if (!this.context.snapshot && this.context.pdfFileDetails.originalBytes) {
             this.context.snapshot = snapshot;