@adnsistemas/pdf-lib 2.7.1 → 2.7.2

package/dist/pdf-lib.js

@@ -10331,6 +10331,12 @@
     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;
             this.shouldWaitForTick = (n) => {
                 this.parsedObjects += n;
                 return this.parsedObjects % this.objectsPerTick === 0;
@@ -10339,6 +10345,27 @@
             this.objectsPerTick = objectsPerTick;
             this.snapshot = snapshot;
         }
+        /**
+         * For incremental saves, defers the decision to the snapshot.
+         * For full saves, checks that the object is not an XRef stream object.
+         * @param {boolean} incremental If making an incremental save, or a full save of the PDF
+         * @param {number} objNum Object number
+         * @param {PDFObject} object PDFObject used to check if it is an XRef stream, when not 'incremental' saving
+         * @returns {boolean} whether the object should be saved or not
+         */
+        shouldSave(incremental, objNum, object) {
+            let should = true;
+            if (incremental) {
+                should = this.snapshot.shouldSave(objNum);
+            }
+            else {
+                should = !(object instanceof PDFRawStream &&
+                    object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef'));
+            }
+            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);
@@ -10352,7 +10379,7 @@
                 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, object)) {
                         continue;
                     }
                     const objectNumber = String(ref.objectNumber);
@@ -10398,8 +10425,16 @@
             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,
@@ -10409,6 +10444,7 @@
         }
         computeBufferSize(incremental) {
             return __awaiter(this, void 0, void 0, function* () {
+                this._largestSkippedObjectNum = 0;
                 const header = PDFHeader.forVersion(1, 7);
                 let size = this.snapshot.pdfSize;
                 if (!incremental) {
@@ -10421,7 +10457,7 @@
                 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, object))
                         continue;
                     if (security)
                         this.encrypt(ref, object, security);