@adnsistemas/pdf-lib 2.9.0 → 2.9.1

package/dist/pdf-lib.js

@@ -8680,34 +8680,39 @@
         constructor(map, context) {
             super();
             this.suppressEncryption = false;
-            this.dict = map;
+            this.dict = new Map(Array.from(map.entries()).map((entry) => [entry[0].toString(), entry]));
             this.context = context;
         }
         keys() {
-            return Array.from(this.dict.keys());
+            return Array.from(this.dict.values()).map((value) => value[0]);
         }
         values() {
-            return Array.from(this.dict.values());
+            return Array.from(this.dict.values()).map((value) => value[1]);
         }
         entries() {
-            return Array.from(this.dict.entries());
+            return Array.from(this.dict.values());
         }
         set(key, value) {
             this.registerChange();
-            this.dict.set(key, value);
+            this.dict.set(key.asString(), [key, value]);
         }
         get(key, 
         // TODO: `preservePDFNull` is for backwards compatibility. Should be
         // removed in next breaking API change.
         preservePDFNull = false) {
-            const value = this.dict.get(key);
-            if (value === PDFNull$1 && !preservePDFNull)
+            if (!key.asString)
                 return undefined;
-            return value;
+            const value = this.dict.get(key.asString());
+            if (!value ||
+                (isPDFInstance(value[1], exports.PDFClasses.PDFNull) && !preservePDFNull))
+                return undefined;
+            return value[1];
         }
         has(key) {
-            const value = this.dict.get(key);
-            return value !== undefined && value !== PDFNull$1;
+            if (!key.asString)
+                return false;
+            const value = this.dict.get(key.asString());
+            return value !== undefined && !isPDFInstance(value[1], exports.PDFClasses.PDFNull);
         }
         lookupMaybe(key, ...types) {
             // TODO: `preservePDFNull` is for backwards compatibility. Should be
@@ -8716,7 +8721,7 @@
             const value = this.context.lookupMaybe(this.get(key, preservePDFNull), 
             // @ts-ignore
             ...types);
-            if (value === PDFNull$1 && !preservePDFNull)
+            if (isPDFInstance(value, exports.PDFClasses.PDFNull) && !preservePDFNull)
                 return undefined;
             return value;
         }
@@ -8727,16 +8732,16 @@
             const value = this.context.lookup(this.get(key, preservePDFNull), 
             // @ts-ignore
             ...types);
-            if (value === PDFNull$1 && !preservePDFNull)
+            if (isPDFInstance(value, exports.PDFClasses.PDFNull) && !preservePDFNull)
                 return undefined;
             return value;
         }
         delete(key) {
             this.registerChange();
-            return this.dict.delete(key);
+            return this.dict.delete(key.asString());
         }
         asMap() {
-            return new Map(this.dict);
+            return new Map(this.dict.values());
         }
         /** Generate a random key that doesn't exist in current key set */
         uniqueKey(tag = '') {
@@ -9263,18 +9268,18 @@
         }
         assign(ref, object) {
             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;
             }
@@ -9295,27 +9300,32 @@
             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, ...types) {
             // TODO: `preservePDFNull` is for backwards compatibility. Should be
             // removed in next breaking API change.
             const preservePDFNull = types.includes(PDFNull$1);
-            const result = isPDFInstance(ref, exports.PDFClasses.PDFRef)
-                ? this.indirectObjects.get(ref)
-                : ref;
+            let result;
+            if (isPDFInstance(ref, exports.PDFClasses.PDFRef)) {
+                const iobj = this.indirectObjects.get(ref.toString());
+                result = iobj ? iobj[1] : undefined;
+            }
+            else {
+                result = ref;
+            }
             if (!result ||
                 (isPDFInstance(result, exports.PDFClasses.PDFNull) && !preservePDFNull))
                 return undefined;
@@ -9330,9 +9340,14 @@
             throw new UnexpectedObjectTypeError(types, result);
         }
         lookup(ref, ...types) {
-            const result = isPDFInstance(ref, exports.PDFClasses.PDFRef)
-                ? this.indirectObjects.get(ref)
-                : ref;
+            let result;
+            if (isPDFInstance(ref, exports.PDFClasses.PDFRef)) {
+                const iobj = this.indirectObjects.get(ref.toString());
+                result = iobj ? iobj[1] : undefined;
+            }
+            else {
+                result = ref;
+            }
             if (types.length === 0)
                 return result;
             for (let idx = 0, len = types.length; idx < len; idx++) {
@@ -9351,7 +9366,7 @@
             return this.getObjectRef(pdfObject);
         }
         getObjectRef(pdfObject) {
-            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) {
@@ -9361,7 +9376,7 @@
             return undefined;
         }
         enumerateIndirectObjects() {
-            return Array.from(this.indirectObjects.entries()).sort(byAscendingObjectNumber);
+            return Array.from(this.indirectObjects.values()).sort(byAscendingObjectNumber);
         }
         obj(literal) {
             if (isPDFInstance(literal, exports.PDFClasses.PDFObject)) {
@@ -9502,7 +9517,7 @@
             }
         }
         findContainingIndirectObject(target) {
-            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)) {
@@ -9536,7 +9551,7 @@
         getObjectVersions(ref) {
             if (!this.preserveObjectsVersions)
                 return [];
-            const list = this.objectsPreviousVersions.get(ref);
+            const list = this.objectsPreviousVersions.get(ref.toString());
             if (list)
                 return list;
             return [];
@@ -37738,7 +37753,7 @@ end\
             const changed = new Map();
             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),
@@ -37746,13 +37761,13 @@ end\
             }
             // 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]);
+                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);
@@ -37760,9 +37775,7 @@ end\
                 }
             }
             // 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);
         }
         /**
          * Saves the current changes to the document as an incremental update, returns the full document,