@adnsistemas/pdf-lib 2.7.1 → 2.7.3

package/src/core/writers/PDFWriter.ts

@@ -17,6 +17,8 @@ import { copyStringIntoBuffer, waitForTick } from '../../utils';
 import PDFNumber from '../objects/PDFNumber';
 import PDFSecurity from '../security/PDFSecurity';
 import PDFStream from '../objects/PDFStream';
+import PDFName from '../objects/PDFName';
+import PDFRawStream from '../objects/PDFRawStream';
 
 export interface SerializationInfo {
   size: number;
@@ -53,6 +55,61 @@ class PDFWriter {
     this.snapshot = snapshot;
   }
 
+  /**
+   * 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.
+   */
+  protected _largestSkippedObjectNum: number = 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.
+   */
+  protected _lastXRefObjectNumber: number = 0;
+  /**
+   * 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
+   */
+  protected shouldSave(
+    incremental: boolean,
+    objNum: number,
+    objects: [PDFRef, PDFObject][],
+  ): boolean {
+    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;
+  }
+
   async serializeToBuffer(): Promise<Uint8Array> {
     const incremental = !(this.snapshot instanceof DefaultDocumentSnapshot);
     const { size, header, indirectObjects, xref, trailerDict, trailer } =
@@ -70,7 +127,7 @@ class PDFWriter {
     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;
       }
 
@@ -130,8 +187,17 @@ class PDFWriter {
   }
 
   protected createTrailerDict(prevStartXRef?: number): PDFDict {
+    /**
+     * 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,
@@ -143,6 +209,8 @@ class PDFWriter {
   protected async computeBufferSize(
     incremental: boolean,
   ): Promise<SerializationInfo> {
+    this._largestSkippedObjectNum = 0;
+    this._lastXRefObjectNumber = 0;
     const header = PDFHeader.forVersion(1, 7);
 
     let size = this.snapshot.pdfSize;
@@ -160,7 +228,8 @@ 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)) continue;
+      if (!this.shouldSave(incremental, ref.objectNumber, indirectObjects))
+        continue;
       if (security) this.encrypt(ref, object, security);
       xref.addEntry(ref, size);
       size += this.computeIndirectObjectSize(indirectObject);

package/ts3.4/cjs/api/snapshot/IncrementalDocumentSnapshot.d.ts

@@ -8,7 +8,7 @@ export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     private lastObjectNumber;
     private changedObjects;
     context: PDFContext;
-    constructor(lastObjectNumber: number, indirectObjects: number[], pdfSize: number, prevStartXRef: number, context: PDFContext);
+    constructor(lastObjectNumber: number, indirectObjects: Set<number>, pdfSize: number, prevStartXRef: number, context: PDFContext);
     shouldSave(objectNumber: number): boolean;
     markRefForSave(ref: PDFRef): void;
     markRefsForSave(refs: PDFRef[]): void;

package/ts3.4/cjs/core/writers/PDFWriter.d.ts

@@ -27,6 +27,29 @@ declare class PDFWriter {
     protected readonly snapshot: DocumentSnapshot;
     private parsedObjects;
     protected constructor(context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot);
+    /**
+     * 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.
+     */
+    protected _largestSkippedObjectNum: number;
+    /**
+     * 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.
+     */
+    protected _lastXRefObjectNumber: number;
+    /**
+     * 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
+     */
+    protected shouldSave(incremental: boolean, objNum: number, objects: [
+        PDFRef,
+        PDFObject
+    ][]): boolean;
     serializeToBuffer(): Promise<Uint8Array>;
     protected computeIndirectObjectSize([ref, object]: [
         PDFRef,

package/ts3.4/es/api/snapshot/IncrementalDocumentSnapshot.d.ts

@@ -8,7 +8,7 @@ export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     private lastObjectNumber;
     private changedObjects;
     context: PDFContext;
-    constructor(lastObjectNumber: number, indirectObjects: number[], pdfSize: number, prevStartXRef: number, context: PDFContext);
+    constructor(lastObjectNumber: number, indirectObjects: Set<number>, pdfSize: number, prevStartXRef: number, context: PDFContext);
     shouldSave(objectNumber: number): boolean;
     markRefForSave(ref: PDFRef): void;
     markRefsForSave(refs: PDFRef[]): void;

package/ts3.4/es/core/writers/PDFWriter.d.ts

@@ -27,6 +27,29 @@ declare class PDFWriter {
     protected readonly snapshot: DocumentSnapshot;
     private parsedObjects;
     protected constructor(context: PDFContext, objectsPerTick: number, snapshot: DocumentSnapshot);
+    /**
+     * 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.
+     */
+    protected _largestSkippedObjectNum: number;
+    /**
+     * 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.
+     */
+    protected _lastXRefObjectNumber: number;
+    /**
+     * 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
+     */
+    protected shouldSave(incremental: boolean, objNum: number, objects: [
+        PDFRef,
+        PDFObject
+    ][]): boolean;
     serializeToBuffer(): Promise<Uint8Array>;
     protected computeIndirectObjectSize([ref, object]: [
         PDFRef,