@adnsistemas/pdf-lib 2.4.5 → 2.6.0

package/src/api/snapshot/DefaultDocumentSnapshot.ts

@@ -4,6 +4,7 @@ import type { DocumentSnapshot } from './DocumentSnapshot';
 export class DefaultDocumentSnapshot implements DocumentSnapshot {
   pdfSize = 0;
   prevStartXRef = 0;
+  deletedCount = 0;
 
   shouldSave(_objectNumber: number): boolean {
     return true;
@@ -24,6 +25,18 @@ export class DefaultDocumentSnapshot implements DocumentSnapshot {
   markObjsForSave(_objs: PDFObject[]): void {
     throw new Error('This method should not be called.');
   }
+
+  markDeletedObj(_obj: PDFObject): void {
+    throw new Error('This method should not be called.');
+  }
+
+  markDeletedRef(_ref: PDFRef): void {
+    throw new Error('This method should not be called.');
+  }
+
+  deletedRef(_index: number): PDFRef | null {
+    throw new Error('This method should not be called.');
+  }
 }
 
 export const defaultDocumentSnapshot = new DefaultDocumentSnapshot();

package/src/api/snapshot/DocumentSnapshot.ts

@@ -3,6 +3,7 @@ import type { PDFObject, PDFRef } from '../../core';
 export interface DocumentSnapshot {
   pdfSize: number;
   prevStartXRef: number;
+  deletedCount: number;
 
   shouldSave: (objectNumber: number) => boolean;
 
@@ -11,4 +12,9 @@ export interface DocumentSnapshot {
 
   markObjForSave: (obj: PDFObject) => void;
   markObjsForSave: (objs: PDFObject[]) => void;
+
+  markDeletedRef: (ref: PDFRef) => void;
+  markDeletedObj: (obj: PDFObject) => void;
+
+  deletedRef: (index: number) => PDFRef | null;
 }

package/src/api/snapshot/IncrementalDocumentSnapshot.ts

@@ -4,7 +4,9 @@ import type { DocumentSnapshot } from './DocumentSnapshot';
 export class IncrementalDocumentSnapshot implements DocumentSnapshot {
   pdfSize: number;
   prevStartXRef: number;
+  deletedCount: number = 0;
 
+  private deleted: PDFRef[] = [];
   private lastObjectNumber: number;
   private changedObjects: number[];
 
@@ -56,4 +58,22 @@ export class IncrementalDocumentSnapshot implements DocumentSnapshot {
         .filter((ref) => ref !== undefined) as PDFRef[],
     );
   }
+
+  markDeletedRef(ref: PDFRef): void {
+    if (
+      this.deleted.findIndex((dref) => dref.objectNumber === ref.objectNumber) <
+      0
+    )
+      this.deletedCount = this.deleted.push(ref);
+  }
+
+  markDeletedObj(obj: PDFObject): void {
+    const oref = this.context.getRef(obj);
+    if (oref) this.markDeletedRef(oref);
+  }
+
+  deletedRef(index: number): PDFRef | null {
+    if (index < 0 || index >= this.deleted.length) return null;
+    return this.deleted[index];
+  }
 }

package/src/core/PDFContext.ts

@@ -21,6 +21,8 @@ import PDFContentStream from './structures/PDFContentStream';
 import PDFSecurity from './security/PDFSecurity';
 import { typedArrayFor } from '../utils';
 import { SimpleRNG } from '../utils/rng';
+import PDFCrossRefSection from './document/PDFCrossRefSection';
+import type { Entry } from './document/PDFCrossRefSection';
 
 type LookupKey = PDFRef | PDFObject | undefined;
 
@@ -55,11 +57,13 @@ const byAscendingObjectNumber = (
 
 class PDFContext {
   isDecrypted = true;
-  static create = () => new PDFContext();
+  static create = (withObjectVersions: boolean = false) =>
+    new PDFContext(withObjectVersions);
 
   largestObjectNumber: number;
   header: PDFHeader;
   trailerInfo: {
+    Size?: PDFNumber;
     Root?: PDFObject;
     Encrypt?: PDFObject;
     Info?: PDFObject;
@@ -73,20 +77,30 @@ class PDFContext {
     originalBytes?: Uint8Array;
   };
   snapshot?: DocumentSnapshot;
+  xrefs: PDFCrossRefSection[] = [];
+  private _preserveObjectsVersions: boolean;
+  public get preserveObjectsVersions(): boolean {
+    return this._preserveObjectsVersions;
+  }
 
   security?: PDFSecurity;
 
   private readonly indirectObjects: Map<PDFRef, PDFObject>;
+  private readonly objectsPreviousVersions: Map<PDFRef, PDFObject[]>;
 
   private pushGraphicsStateContentStreamRef?: PDFRef;
   private popGraphicsStateContentStreamRef?: PDFRef;
 
-  private constructor() {
+  private constructor(preserveObjectsVersions?: boolean) {
+    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,
@@ -96,6 +110,17 @@ class PDFContext {
   }
 
   assign(ref: PDFRef, object: PDFObject): void {
+    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;
@@ -114,6 +139,19 @@ class PDFContext {
   }
 
   delete(ref: PDFRef): boolean {
+    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);
   }
 
@@ -391,6 +429,19 @@ class PDFContext {
   registerObjectChange(obj: PDFObject) {
     if (this.snapshot) this.snapshot.markObjForSave(obj);
   }
+
+  getObjectVersions(ref: PDFRef): PDFObject[] {
+    if (!this.preserveObjectsVersions) return [];
+    const list = this.objectsPreviousVersions.get(ref);
+    if (list) return list;
+    return [];
+  }
+
+  listXrefEntries(xrefIndex: number = -1): Entry[] {
+    if (xrefIndex < 0) xrefIndex = this.xrefs.length - 1;
+    if (xrefIndex < 0 || xrefIndex >= this.xrefs.length) return [];
+    return this.xrefs[xrefIndex].listRefs();
+  }
 }
 
 export default PDFContext;

package/src/core/document/PDFCrossRefSection.ts

@@ -10,7 +10,7 @@ export interface Entry {
 
 /**
  * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
- * methods **in order of ascending object number**.
+ * methods.
  */
 class PDFCrossRefSection {
   static create = () =>
@@ -37,6 +37,22 @@ class PDFCrossRefSection {
   }
 
   addDeletedEntry(ref: PDFRef, nextFreeObjectNumber: number): void {
+    // 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 });
   }
 
@@ -159,7 +175,35 @@ class PDFCrossRefSection {
     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;
@@ -168,6 +212,30 @@ class PDFCrossRefSection {
       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(): Entry[] {
+    const refList: Entry[] = [];
+    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;
+  }
 }
 
 export default PDFCrossRefSection;

package/src/core/parser/PDFParser.ts

@@ -24,6 +24,7 @@ import { Keywords } from '../syntax/Keywords';
 import { IsDigit } from '../syntax/Numeric';
 import { waitForTick } from '../../utils';
 import { CipherTransformFactory } from '../crypto';
+import PDFNumber from '../objects/PDFNumber';
 
 class PDFParser extends PDFObjectParser {
   static forBytesWithOptions = (
@@ -34,6 +35,7 @@ class PDFParser extends PDFObjectParser {
     capNumbers?: boolean,
     cryptoFactory?: CipherTransformFactory,
     forIncrementalUpdate?: boolean,
+    preserveObjectsVersions?: boolean,
   ) =>
     new PDFParser(
       pdfBytes,
@@ -43,6 +45,7 @@ class PDFParser extends PDFObjectParser {
       capNumbers,
       cryptoFactory,
       forIncrementalUpdate,
+      preserveObjectsVersions,
     );
 
   private readonly objectsPerTick: number;
@@ -59,10 +62,11 @@ class PDFParser extends PDFObjectParser {
     capNumbers = false,
     cryptoFactory?: CipherTransformFactory,
     forIncrementalUpdate = false,
+    preserveObjectsVersions = false,
   ) {
     super(
       ByteStream.of(pdfBytes),
-      PDFContext.create(),
+      PDFContext.create(preserveObjectsVersions),
       capNumbers,
       cryptoFactory,
     );
@@ -195,7 +199,15 @@ class PDFParser extends PDFObjectParser {
       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);
@@ -307,11 +319,17 @@ class PDFParser extends PDFObjectParser {
 
     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;
   }
 
   private maybeParseTrailer(): PDFTrailer | void {
@@ -333,7 +351,8 @@ class PDFParser extends PDFObjectParser {
 
   private async parseDocumentSection(): Promise<void> {
     await this.parseIndirectObjects();
-    this.maybeParseCrossRefSection();
+    const xref = this.maybeParseCrossRefSection();
+    if (xref) this.context.xrefs.push(xref);
     this.maybeParseTrailerDict();
     this.maybeParseTrailer();
 

package/src/core/parser/PDFXRefStreamParser.ts

@@ -66,11 +66,19 @@ class PDFXRefStreamParser {
     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();
 

package/src/core/writers/PDFWriter.ts

@@ -166,6 +166,17 @@ class PDFWriter {
       size += this.computeIndirectObjectSize(indirectObject);
       if (this.shouldWaitForTick(1)) await 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'

package/ts3.4/cjs/api/PDFDocument.d.ts

@@ -6,6 +6,7 @@ import PDFForm from './form/PDFForm';
 import { StandardFonts } from './StandardFonts';
 import { PageBoundingBox, PDFCatalog, PDFContext } from '../core';
 import { AttachmentOptions, SaveOptions, Base64SaveOptions, LoadOptions, CreateOptions, EmbedFontOptions, SetTitleOptions, IncrementalSaveOptions } from './PDFDocumentOptions';
+import PDFObject from '../core/objects/PDFObject';
 import PDFRef from '../core/objects/PDFRef';
 import { Fontkit } from '../types/fontkit';
 import { TransformationMatrix } from '../types/matrix';
@@ -22,6 +23,11 @@ export type PDFAttachment = {
     creationDate: Date | undefined;
     modificationDate: Date | undefined;
 };
+export type PDFObjectVersions = {
+    ref: PDFRef;
+    actual: PDFObject | undefined;
+    previous: PDFObject[];
+};
 /**
  * Represents a PDF document.
  */
@@ -828,6 +834,14 @@ export default class PDFDocument {
     saveAsBase64(options?: Base64SaveOptions): Promise<string>;
     findPageForAnnotationRef(ref: PDFRef): PDFPage | undefined;
     takeSnapshot(): DocumentSnapshot;
+    /**
+     * 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?: number): PDFObjectVersions[];
     private prepareForSave;
     private embedAll;
     private updateInfoDict;

package/ts3.4/cjs/api/PDFDocumentOptions.d.ts

@@ -30,6 +30,7 @@ export interface LoadOptions {
     capNumbers?: boolean;
     password?: string;
     forIncrementalUpdate?: boolean;
+    preserveObjectsVersions?: boolean;
 }
 export interface CreateOptions {
     updateMetadata?: boolean;

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

@@ -3,11 +3,15 @@ import { DocumentSnapshot } from './DocumentSnapshot';
 export declare class DefaultDocumentSnapshot implements DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
+    deletedCount: number;
     shouldSave(_objectNumber: number): boolean;
     markRefForSave(_ref: PDFRef): void;
     markRefsForSave(_refs: PDFRef[]): void;
     markObjForSave(_obj: PDFObject): void;
     markObjsForSave(_objs: PDFObject[]): void;
+    markDeletedObj(_obj: PDFObject): void;
+    markDeletedRef(_ref: PDFRef): void;
+    deletedRef(_index: number): PDFRef | null;
 }
 export declare const defaultDocumentSnapshot: DefaultDocumentSnapshot;
 //# sourceMappingURL=DefaultDocumentSnapshot.d.ts.map

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

@@ -2,10 +2,14 @@ import { PDFObject, PDFRef } from '../../core';
 export interface DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
+    deletedCount: number;
     shouldSave: (objectNumber: number) => boolean;
     markRefForSave: (ref: PDFRef) => void;
     markRefsForSave: (refs: PDFRef[]) => void;
     markObjForSave: (obj: PDFObject) => void;
     markObjsForSave: (objs: PDFObject[]) => void;
+    markDeletedRef: (ref: PDFRef) => void;
+    markDeletedObj: (obj: PDFObject) => void;
+    deletedRef: (index: number) => PDFRef | null;
 }
 //# sourceMappingURL=DocumentSnapshot.d.ts.map

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

@@ -3,6 +3,8 @@ import { DocumentSnapshot } from './DocumentSnapshot';
 export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
+    deletedCount: number;
+    private deleted;
     private lastObjectNumber;
     private changedObjects;
     context: PDFContext;
@@ -12,5 +14,8 @@ export declare class IncrementalDocumentSnapshot implements DocumentSnapshot {
     markRefsForSave(refs: PDFRef[]): void;
     markObjForSave(obj: PDFObject): void;
     markObjsForSave(objs: PDFObject[]): void;
+    markDeletedRef(ref: PDFRef): void;
+    markDeletedObj(obj: PDFObject): void;
+    deletedRef(index: number): PDFRef | null;
 }
 //# sourceMappingURL=IncrementalDocumentSnapshot.d.ts.map

package/ts3.4/cjs/core/PDFContext.d.ts

@@ -16,6 +16,8 @@ import PDFOperator from './operators/PDFOperator';
 import PDFContentStream from './structures/PDFContentStream';
 import PDFSecurity from './security/PDFSecurity';
 import { SimpleRNG } from '../utils/rng';
+import PDFCrossRefSection from './document/PDFCrossRefSection';
+import { Entry } from './document/PDFCrossRefSection';
 type LookupKey = PDFRef | PDFObject | undefined;
 interface LiteralObject {
     [name: string]: Literal | PDFObject;
@@ -32,10 +34,11 @@ interface LiteralConfig {
 }
 declare class PDFContext {
     isDecrypted: boolean;
-    static create: () => PDFContext;
+    static create: (withObjectVersions?: boolean) => PDFContext;
     largestObjectNumber: number;
     header: PDFHeader;
     trailerInfo: {
+        Size?: PDFNumber;
         Root?: PDFObject;
         Encrypt?: PDFObject;
         Info?: PDFObject;
@@ -49,8 +52,12 @@ declare class PDFContext {
         originalBytes?: Uint8Array;
     };
     snapshot?: DocumentSnapshot;
+    xrefs: PDFCrossRefSection[];
+    private _preserveObjectsVersions;
+    readonly preserveObjectsVersions: boolean;
     security?: PDFSecurity;
     private readonly indirectObjects;
+    private readonly objectsPreviousVersions;
     private pushGraphicsStateContentStreamRef?;
     private popGraphicsStateContentStreamRef?;
     private constructor();
@@ -112,6 +119,8 @@ declare class PDFContext {
     getPopGraphicsStateContentStream(): PDFRef;
     addRandomSuffix(prefix: string, suffixLength?: number): string;
     registerObjectChange(obj: PDFObject): void;
+    getObjectVersions(ref: PDFRef): PDFObject[];
+    listXrefEntries(xrefIndex?: number): Entry[];
 }
 export default PDFContext;
 //# sourceMappingURL=PDFContext.d.ts.map

package/ts3.4/cjs/core/document/PDFCrossRefSection.d.ts

@@ -6,7 +6,7 @@ export interface Entry {
 }
 /**
  * Entries should be added using the [[addEntry]] and [[addDeletedEntry]]
- * methods **in order of ascending object number**.
+ * methods.
  */
 declare class PDFCrossRefSection {
     static create: () => PDFCrossRefSection;
@@ -23,6 +23,11 @@ declare class PDFCrossRefSection {
     private copySubsectionsIntoBuffer;
     private copyEntriesIntoBuffer;
     private append;
+    /**
+     * Returns all the entries in the XREF section, except the first one (object == 0)
+     * @returns {Entry[]} All the entries in the XREF section
+     */
+    listRefs(): Entry[];
 }
 export default PDFCrossRefSection;
 //# sourceMappingURL=PDFCrossRefSection.d.ts.map

package/ts3.4/cjs/core/parser/PDFParser.d.ts

@@ -2,13 +2,13 @@ import PDFObjectParser from './PDFObjectParser';
 import PDFContext from '../PDFContext';
 import { CipherTransformFactory } from '../crypto';
 declare class PDFParser extends PDFObjectParser {
-    static forBytesWithOptions: (pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean) => PDFParser;
+    static forBytesWithOptions: (pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean, preserveObjectsVersions?: boolean) => PDFParser;
     private readonly objectsPerTick;
     private readonly throwOnInvalidObject;
     private readonly warnOnInvalidObjects;
     private alreadyParsed;
     private parsedObjects;
-    constructor(pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean);
+    constructor(pdfBytes: Uint8Array, objectsPerTick?: number, throwOnInvalidObject?: boolean, warnOnInvalidObjects?: boolean, capNumbers?: boolean, cryptoFactory?: CipherTransformFactory, forIncrementalUpdate?: boolean, preserveObjectsVersions?: boolean);
     parseDocument(): Promise<PDFContext>;
     private maybeRecoverRoot;
     private parseHeader;

package/ts3.4/es/api/PDFDocument.d.ts

@@ -6,6 +6,7 @@ import PDFForm from './form/PDFForm';
 import { StandardFonts } from './StandardFonts';
 import { PageBoundingBox, PDFCatalog, PDFContext } from '../core';
 import { AttachmentOptions, SaveOptions, Base64SaveOptions, LoadOptions, CreateOptions, EmbedFontOptions, SetTitleOptions, IncrementalSaveOptions } from './PDFDocumentOptions';
+import PDFObject from '../core/objects/PDFObject';
 import PDFRef from '../core/objects/PDFRef';
 import { Fontkit } from '../types/fontkit';
 import { TransformationMatrix } from '../types/matrix';
@@ -22,6 +23,11 @@ export type PDFAttachment = {
     creationDate: Date | undefined;
     modificationDate: Date | undefined;
 };
+export type PDFObjectVersions = {
+    ref: PDFRef;
+    actual: PDFObject | undefined;
+    previous: PDFObject[];
+};
 /**
  * Represents a PDF document.
  */
@@ -828,6 +834,14 @@ export default class PDFDocument {
     saveAsBase64(options?: Base64SaveOptions): Promise<string>;
     findPageForAnnotationRef(ref: PDFRef): PDFPage | undefined;
     takeSnapshot(): DocumentSnapshot;
+    /**
+     * 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?: number): PDFObjectVersions[];
     private prepareForSave;
     private embedAll;
     private updateInfoDict;

package/ts3.4/es/api/PDFDocumentOptions.d.ts

@@ -30,6 +30,7 @@ export interface LoadOptions {
     capNumbers?: boolean;
     password?: string;
     forIncrementalUpdate?: boolean;
+    preserveObjectsVersions?: boolean;
 }
 export interface CreateOptions {
     updateMetadata?: boolean;

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

@@ -3,11 +3,15 @@ import { DocumentSnapshot } from './DocumentSnapshot';
 export declare class DefaultDocumentSnapshot implements DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
+    deletedCount: number;
     shouldSave(_objectNumber: number): boolean;
     markRefForSave(_ref: PDFRef): void;
     markRefsForSave(_refs: PDFRef[]): void;
     markObjForSave(_obj: PDFObject): void;
     markObjsForSave(_objs: PDFObject[]): void;
+    markDeletedObj(_obj: PDFObject): void;
+    markDeletedRef(_ref: PDFRef): void;
+    deletedRef(_index: number): PDFRef | null;
 }
 export declare const defaultDocumentSnapshot: DefaultDocumentSnapshot;
 //# sourceMappingURL=DefaultDocumentSnapshot.d.ts.map

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

@@ -2,10 +2,14 @@ import { PDFObject, PDFRef } from '../../core';
 export interface DocumentSnapshot {
     pdfSize: number;
     prevStartXRef: number;
+    deletedCount: number;
     shouldSave: (objectNumber: number) => boolean;
     markRefForSave: (ref: PDFRef) => void;
     markRefsForSave: (refs: PDFRef[]) => void;
     markObjForSave: (obj: PDFObject) => void;
     markObjsForSave: (objs: PDFObject[]) => void;
+    markDeletedRef: (ref: PDFRef) => void;
+    markDeletedObj: (obj: PDFObject) => void;
+    deletedRef: (index: number) => PDFRef | null;
 }
 //# sourceMappingURL=DocumentSnapshot.d.ts.map