@adnsistemas/pdf-lib 2.9.0 → 2.9.1

package/src/api/PDFDocument.ts

@@ -1737,24 +1737,23 @@ export default class PDFDocument {
     const upind = this.context.xrefs.length - lastUpdateMinusX - 1;
     const entries = this.context.listXrefEntries(upind);
     if (!entries.length) return [];
-    const changed = new Map<PDFRef, PDFObjectVersions>();
+    const changed = new Map<string, PDFObjectVersions>();
     for (const entry of entries) {
       const ref = entry.ref;
-      changed.set(ref, {
+      changed.set(ref.toString(), {
         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]);
+    if (!lastUpdateMinusX) return Array.from(changed.values());
     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);
+        const oce = changed.get(nentry.ref.toString());
         if (oce && oce.actual) {
           oce.actual = oce.previous[0];
           oce.previous = oce.previous.slice(1);
@@ -1762,9 +1761,9 @@ export default class PDFDocument {
       }
     }
     // 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);
+    return Array.from(changed.values()).filter(
+      (ov) => ov.actual || ov.previous.length,
+    );
   }
 
   /**

package/src/core/PDFContext.ts

@@ -86,8 +86,8 @@ class PDFContext {
 
   security?: PDFSecurity;
 
-  private readonly indirectObjects: Map<PDFRef, PDFObject>;
-  private readonly objectsPreviousVersions: Map<PDFRef, PDFObject[]>;
+  private readonly indirectObjects: Map<string, [PDFRef, PDFObject]>;
+  private readonly objectsPreviousVersions: Map<string, PDFObject[]>;
 
   private pushGraphicsStateContentStreamRef?: PDFRef;
   private popGraphicsStateContentStreamRef?: PDFRef;
@@ -112,17 +112,17 @@ class PDFContext {
 
   assign(ref: PDFRef, object: PDFObject): void {
     if (this.preserveObjectsVersions) {
-      const prevOV = this.indirectObjects.get(ref);
+      const prevOV = this.indirectObjects.get(ref.toString());
       if (prevOV) {
-        const prevList = this.objectsPreviousVersions.get(ref);
+        const prevList = this.objectsPreviousVersions.get(ref.toString());
         if (!prevList) {
-          this.objectsPreviousVersions.set(ref, [prevOV]);
+          this.objectsPreviousVersions.set(ref.toString(), [prevOV[1]]);
         } else {
-          prevList.unshift(prevOV);
+          prevList.unshift(prevOV[1]);
         }
       }
     }
-    this.indirectObjects.set(ref, object);
+    this.indirectObjects.set(ref.toString(), [ref, object]);
     if (ref.objectNumber > this.largestObjectNumber) {
       this.largestObjectNumber = ref.objectNumber;
     }
@@ -144,18 +144,18 @@ class PDFContext {
   delete(ref: PDFRef): boolean {
     if (this.snapshot) this.snapshot.markDeletedRef(ref);
     if (this.preserveObjectsVersions) {
-      const object = this.indirectObjects.get(ref);
+      const object = this.indirectObjects.get(ref.toString());
       if (object) {
         // check is not already deleted
-        const verlist = this.objectsPreviousVersions.get(ref);
+        const verlist = this.objectsPreviousVersions.get(ref.toString());
         if (verlist) {
-          verlist.unshift(object);
+          verlist.unshift(object[1]);
         } else {
-          this.objectsPreviousVersions.set(ref, [object]);
+          this.objectsPreviousVersions.set(ref.toString(), [object[1]]);
         }
       }
     }
-    return this.indirectObjects.delete(ref);
+    return this.indirectObjects.delete(ref.toString());
   }
 
   lookupMaybe(ref: LookupKey, type: typeof PDFArray): PDFArray | undefined;
@@ -182,10 +182,13 @@ class PDFContext {
     // removed in next breaking API change.
     const preservePDFNull = types.includes(PDFNull);
 
-    const result = isPDFInstance(ref, PDFClasses.PDFRef)
-      ? this.indirectObjects.get(ref as PDFRef)
-      : ref;
-
+    let result;
+    if (isPDFInstance(ref, PDFClasses.PDFRef)) {
+      const iobj = this.indirectObjects.get((ref as PDFRef).toString());
+      result = iobj ? iobj[1] : undefined;
+    } else {
+      result = ref;
+    }
     if (
       !result ||
       (isPDFInstance(result, PDFClasses.PDFNull) && !preservePDFNull)
@@ -222,9 +225,13 @@ class PDFContext {
   ): PDFString | PDFHexString;
 
   lookup(ref: LookupKey, ...types: any[]) {
-    const result = isPDFInstance(ref, PDFClasses.PDFRef)
-      ? this.indirectObjects.get(ref as PDFRef)
-      : ref;
+    let result;
+    if (isPDFInstance(ref, PDFClasses.PDFRef)) {
+      const iobj = this.indirectObjects.get((ref as PDFRef).toString());
+      result = iobj ? iobj[1] : undefined;
+    } else {
+      result = ref;
+    }
 
     if (types.length === 0) return result;
 
@@ -247,7 +254,7 @@ class PDFContext {
   }
 
   getObjectRef(pdfObject: PDFObject): PDFRef | undefined {
-    const entries = Array.from(this.indirectObjects.entries());
+    const entries = Array.from(this.indirectObjects.values());
     for (let idx = 0, len = entries.length; idx < len; idx++) {
       const [ref, object] = entries[idx];
       if (object === pdfObject) {
@@ -259,7 +266,7 @@ class PDFContext {
   }
 
   enumerateIndirectObjects(): [PDFRef, PDFObject][] {
-    return Array.from(this.indirectObjects.entries()).sort(
+    return Array.from(this.indirectObjects.values()).sort(
       byAscendingObjectNumber,
     );
   }
@@ -456,7 +463,7 @@ class PDFContext {
   }
 
   private findContainingIndirectObject(target: PDFObject): PDFRef | undefined {
-    const entries = Array.from(this.indirectObjects.entries());
+    const entries = Array.from(this.indirectObjects.values());
     for (let idx = 0, len = entries.length; idx < len; idx++) {
       const [ref, object] = entries[idx];
       if (this.objectContains(object, target)) {
@@ -489,7 +496,7 @@ class PDFContext {
 
   getObjectVersions(ref: PDFRef): PDFObject[] {
     if (!this.preserveObjectsVersions) return [];
-    const list = this.objectsPreviousVersions.get(ref);
+    const list = this.objectsPreviousVersions.get(ref.toString());
     if (list) return list;
     return [];
   }

package/src/core/objects/PDFDict.ts

@@ -10,9 +10,11 @@ import PDFStream from './PDFStream';
 import PDFString from './PDFString';
 import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
-import { PDFClasses } from '../../api/objects';
+import { isPDFInstance, PDFClasses } from '../../api/objects';
 
 export type DictMap = Map<PDFName, PDFObject>;
+// dictionary keys must be unique, using PDFName does not guarantee that
+type InternalDictMap = Map<string, [PDFName, PDFObject]>;
 
 class PDFDict extends PDFObject {
   static className = () => PDFClasses.PDFDict;
@@ -26,31 +28,33 @@ class PDFDict extends PDFObject {
 
   readonly context: PDFContext;
 
-  private readonly dict: DictMap;
+  private readonly dict: InternalDictMap;
 
   suppressEncryption: boolean = false;
 
   protected constructor(map: DictMap, context: PDFContext) {
     super();
-    this.dict = map;
+    this.dict = new Map(
+      Array.from(map.entries()).map((entry) => [entry[0].toString(), entry]),
+    );
     this.context = context;
   }
 
   keys(): PDFName[] {
-    return Array.from(this.dict.keys());
+    return Array.from(this.dict.values()).map((value) => value[0]);
   }
 
   values(): PDFObject[] {
-    return Array.from(this.dict.values());
+    return Array.from(this.dict.values()).map((value) => value[1]);
   }
 
   entries(): [PDFName, PDFObject][] {
-    return Array.from(this.dict.entries());
+    return Array.from(this.dict.values());
   }
 
   set(key: PDFName, value: PDFObject): void {
     this.registerChange();
-    this.dict.set(key, value);
+    this.dict.set(key.asString(), [key, value]);
   }
 
   get(
@@ -59,14 +63,20 @@ class PDFDict extends PDFObject {
     // removed in next breaking API change.
     preservePDFNull = false,
   ): PDFObject | undefined {
-    const value = this.dict.get(key);
-    if (value === PDFNull && !preservePDFNull) return undefined;
-    return value;
+    if (!key.asString) return undefined;
+    const value = this.dict.get(key.asString());
+    if (
+      !value ||
+      (isPDFInstance(value[1], PDFClasses.PDFNull) && !preservePDFNull)
+    )
+      return undefined;
+    return value[1];
   }
 
   has(key: PDFName): boolean {
-    const value = this.dict.get(key);
-    return value !== undefined && value !== PDFNull;
+    if (!key.asString) return false;
+    const value = this.dict.get(key.asString());
+    return value !== undefined && !isPDFInstance(value[1], PDFClasses.PDFNull);
   }
 
   lookupMaybe(key: PDFName, type: typeof PDFArray): PDFArray | undefined;
@@ -110,7 +120,8 @@ class PDFDict extends PDFObject {
       ...types,
     ) as any;
 
-    if (value === PDFNull && !preservePDFNull) return undefined;
+    if (isPDFInstance(value, PDFClasses.PDFNull) && !preservePDFNull)
+      return undefined;
 
     return value;
   }
@@ -154,18 +165,19 @@ class PDFDict extends PDFObject {
       ...types,
     ) as any;
 
-    if (value === PDFNull && !preservePDFNull) return undefined;
+    if (isPDFInstance(value, PDFClasses.PDFNull) && !preservePDFNull)
+      return undefined;
 
     return value;
   }
 
   delete(key: PDFName): boolean {
     this.registerChange();
-    return this.dict.delete(key);
+    return this.dict.delete(key.asString());
   }
 
   asMap(): Map<PDFName, PDFObject> {
-    return new Map(this.dict);
+    return new Map(this.dict.values());
   }
 
   /** Generate a random key that doesn't exist in current key set */