Merge pull request #19051 from Snuffleupagus/Dict-Map

Snuffleupagus · web-flow · commit bc919859417f · 2024-11-17T12:59:02.000+01:00
Convert the `Dict`-implementation to use a `Map` internally
diff --git a/.prettierignore b/.prettierignore
@@ -6,6 +6,7 @@ external/bcmaps/
 external/builder/fixtures/
 external/builder/fixtures_babel/
 external/quickjs/
+test/stats/results/
 test/tmp/
 test/pdfs/
 web/locale/
diff --git a/.stylelintignore b/.stylelintignore
@@ -6,6 +6,7 @@ external/bcmaps/
 external/builder/fixtures/
 external/builder/fixtures_babel/
 external/quickjs/
+test/stats/results/
 test/tmp/
 test/pdfs/
 web/locale/
diff --git a/eslint.config.mjs b/eslint.config.mjs
@@ -35,6 +35,7 @@ export default [
       "external/builder/fixtures_babel/",
       "external/quickjs/",
       "external/openjpeg/",
+      "test/stats/results/",
       "test/tmp/",
       "test/pdfs/",
       "web/locale/",
diff --git a/src/core/catalog.js b/src/core/catalog.js
@@ -720,12 +720,12 @@ class Catalog {
         }
       }
     } else if (obj instanceof Dict) {
-      obj.forEach(function (key, value) {
+      for (const [key, value] of obj) {
         const dest = fetchDest(value);
         if (dest) {
           dests[key] = dest;
         }
-      });
+      }
     }
     return shadow(this, "destinations", dests);
   }
diff --git a/src/core/document.js b/src/core/document.js
@@ -1282,13 +1282,8 @@ class PDFDocument {
       },
     };
 
-    const fonts = new Map();
-    fontRes.forEach((fontName, font) => {
-      fonts.set(fontName, font);
-    });
     const promises = [];
-
-    for (const [fontName, font] of fonts) {
+    for (const [fontName, font] of fontRes) {
       const descriptor = font.get("FontDescriptor");
       if (!(descriptor instanceof Dict)) {
         continue;
diff --git a/src/core/primitives.js b/src/core/primitives.js
@@ -69,7 +69,7 @@ const nonSerializable = function nonSerializableClosure() {
 class Dict {
   constructor(xref = null) {
     // Map should only be used internally, use functions below to access.
-    this._map = Object.create(null);
+    this._map = new Map();
     this.xref = xref;
     this.objId = null;
     this.suppressEncryption = false;
@@ -81,28 +81,28 @@ class Dict {
   }
 
   get size() {
-    return Object.keys(this._map).length;
+    return this._map.size;
   }
 
   // Automatically dereferences Ref objects.
   get(key1, key2, key3) {
-    let value = this._map[key1];
+    let value = this._map.get(key1);
     if (value === undefined && key2 !== undefined) {
       if (
         (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
         key2.length < key1.length
       ) {
         unreachable("Dict.get: Expected keys to be ordered by length.");
       }
-      value = this._map[key2];
+      value = this._map.get(key2);
       if (value === undefined && key3 !== undefined) {
         if (
           (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
           key3.length < key2.length
         ) {
           unreachable("Dict.get: Expected keys to be ordered by length.");
         }
-        value = this._map[key3];
+        value = this._map.get(key3);
       }
     }
     if (value instanceof Ref && this.xref) {
@@ -113,23 +113,23 @@ class Dict {
 
   // Same as get(), but returns a promise and uses fetchIfRefAsync().
   async getAsync(key1, key2, key3) {
-    let value = this._map[key1];
+    let value = this._map.get(key1);
     if (value === undefined && key2 !== undefined) {
       if (
         (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
         key2.length < key1.length
       ) {
         unreachable("Dict.getAsync: Expected keys to be ordered by length.");
       }
-      value = this._map[key2];
+      value = this._map.get(key2);
       if (value === undefined && key3 !== undefined) {
         if (
           (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
           key3.length < key2.length
         ) {
           unreachable("Dict.getAsync: Expected keys to be ordered by length.");
         }
-        value = this._map[key3];
+        value = this._map.get(key3);
       }
     }
     if (value instanceof Ref && this.xref) {
@@ -140,23 +140,23 @@ class Dict {
 
   // Same as get(), but dereferences all elements if the result is an Array.
   getArray(key1, key2, key3) {
-    let value = this._map[key1];
+    let value = this._map.get(key1);
     if (value === undefined && key2 !== undefined) {
       if (
         (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
         key2.length < key1.length
       ) {
         unreachable("Dict.getArray: Expected keys to be ordered by length.");
       }
-      value = this._map[key2];
+      value = this._map.get(key2);
       if (value === undefined && key3 !== undefined) {
         if (
           (typeof PDFJSDev === "undefined" || PDFJSDev.test("TESTING")) &&
           key3.length < key2.length
         ) {
           unreachable("Dict.getArray: Expected keys to be ordered by length.");
         }
-        value = this._map[key3];
+        value = this._map.get(key3);
       }
     }
     if (value instanceof Ref && this.xref) {
@@ -176,16 +176,16 @@ class Dict {
 
   // No dereferencing.
   getRaw(key) {
-    return this._map[key];
+    return this._map.get(key);
   }
 
   getKeys() {
-    return Object.keys(this._map);
+    return [...this._map.keys()];
   }
 
   // No dereferencing.
   getRawValues() {
-    return Object.values(this._map);
+    return [...this._map.values()];
   }
 
   set(key, value) {
@@ -196,16 +196,21 @@ class Dict {
         unreachable('Dict.set: The "value" cannot be undefined.');
       }
     }
-    this._map[key] = value;
+    this._map.set(key, value);
   }
 
   has(key) {
-    return this._map[key] !== undefined;
+    return this._map.has(key);
   }
 
-  forEach(callback) {
-    for (const key in this._map) {
-      callback(key, this.get(key));
+  *[Symbol.iterator]() {
+    for (const [key, value] of this._map) {
+      yield [
+        key,
+        value instanceof Ref && this.xref
+          ? this.xref.fetch(value, this.suppressEncryption)
+          : value,
+      ];
     }
   }
 
@@ -226,7 +231,7 @@ class Dict {
       if (!(dict instanceof Dict)) {
         continue;
       }
-      for (const [key, value] of Object.entries(dict._map)) {
+      for (const [key, value] of dict._map) {
         let property = properties.get(key);
         if (property === undefined) {
           property = [];
@@ -242,20 +247,20 @@ class Dict {
     }
     for (const [name, values] of properties) {
       if (values.length === 1 || !(values[0] instanceof Dict)) {
-        mergedDict._map[name] = values[0];
+        mergedDict._map.set(name, values[0]);
         continue;
       }
       const subDict = new Dict(xref);
 
       for (const dict of values) {
-        for (const [key, value] of Object.entries(dict._map)) {
-          if (subDict._map[key] === undefined) {
-            subDict._map[key] = value;
+        for (const [key, value] of dict._map) {
+          if (!subDict._map.has(key)) {
+            subDict._map.set(key, value);
           }
         }
       }
       if (subDict.size > 0) {
-        mergedDict._map[name] = subDict;
+        mergedDict._map.set(name, subDict);
       }
     }
     properties.clear();
diff --git a/src/core/struct_tree.js b/src/core/struct_tree.js
@@ -62,12 +62,11 @@ class StructTreeRoot {
     if (!(roleMapDict instanceof Dict)) {
       return;
     }
-    roleMapDict.forEach((key, value) => {
-      if (!(value instanceof Name)) {
-        return;
+    for (const [key, value] of roleMapDict) {
+      if (value instanceof Name) {
+        this.roleMap.set(key, value.name);
       }
-      this.roleMap.set(key, value.name);
-    });
+    }
   }
 
   static async canCreateStructureTree({
diff --git a/src/core/worker.js b/src/core/worker.js
@@ -688,11 +688,11 @@ class WorkerMessageHandler {
           const infoObj = Object.create(null);
           const xrefInfo = xref.trailer.get("Info") || null;
           if (xrefInfo instanceof Dict) {
-            xrefInfo.forEach((key, value) => {
+            for (const [key, value] of xrefInfo) {
               if (typeof value === "string") {
                 infoObj[key] = stringToPDFString(value);
               }
-            });
+            }
           }
 
           newXrefInfo = {
diff --git a/src/pdf.js b/src/pdf.js
@@ -80,7 +80,7 @@ const pdfjsVersion =
 const pdfjsBuild =
   typeof PDFJSDev !== "undefined" ? PDFJSDev.eval("BUNDLE_BUILD") : void 0;
 
-if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("TESTING")) {
+if (typeof PDFJSDev !== "undefined" && PDFJSDev.test("TESTING || GENERIC")) {
   globalThis.pdfjsTestingUtils = {
     HighlightOutliner,
   };
diff --git a/test/unit/primitives_spec.js b/test/unit/primitives_spec.js
@@ -221,17 +221,12 @@ describe("primitives", function () {
       expect(values[2]).toEqual(testFontFile);
     });
 
-    it("should callback for each stored key", function () {
-      const callbackSpy = jasmine.createSpy("spy on callback in dictionary");
-
-      dictWithManyKeys.forEach(callbackSpy);
-
-      expect(callbackSpy).toHaveBeenCalled();
-      const callbackSpyCalls = callbackSpy.calls;
-      expect(callbackSpyCalls.argsFor(0)).toEqual(["FontFile", testFontFile]);
-      expect(callbackSpyCalls.argsFor(1)).toEqual(["FontFile2", testFontFile2]);
-      expect(callbackSpyCalls.argsFor(2)).toEqual(["FontFile3", testFontFile3]);
-      expect(callbackSpyCalls.count()).toEqual(3);
+    it("should iterate through each stored key", function () {
+      expect([...dictWithManyKeys]).toEqual([
+        ["FontFile", testFontFile],
+        ["FontFile2", testFontFile2],
+        ["FontFile3", testFontFile3],
+      ]);
     });
 
     it("should handle keys pointing to indirect objects, both sync and async", async function () {

Original file line number	Diff line number	Diff line change
`@@ -720,12 +720,12 @@ class Catalog {`
`720`	`720`	`}`
`721`	`721`	`}`
`722`	`722`	`} else if (obj instanceof Dict) {`
`723`		`- obj.forEach(function (key, value) {`
	`723`	`+ for (const [key, value] of obj) {`
`724`	`724`	`const dest = fetchDest(value);`
`725`	`725`	`if (dest) {`
`726`	`726`	`dests[key] = dest;`
`727`	`727`	`}`
`728`		`- });`
	`728`	`+ }`
`729`	`729`	`}`
`730`	`730`	`return shadow(this, "destinations", dests);`
`731`	`731`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ const nonSerializable = function nonSerializableClosure() {`
`69`	`69`	`class Dict {`
`70`	`70`	`constructor(xref = null) {`
`71`	`71`	`// Map should only be used internally, use functions below to access.`
`72`		`- this._map = Object.create(null);`
	`72`	`+ this._map = new Map();`
`73`	`73`	`this.xref = xref;`
`74`	`74`	`this.objId = null;`
`75`	`75`	`this.suppressEncryption = false;`
`@@ -81,28 +81,28 @@ class Dict {`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`get size() {`
`84`		`- return Object.keys(this._map).length;`
	`84`	`+ return this._map.size;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`// Automatically dereferences Ref objects.`
`88`	`88`	`get(key1, key2, key3) {`
`89`		`- let value = this._map[key1];`
	`89`	`+ let value = this._map.get(key1);`
`90`	`90`	`if (value === undefined && key2 !== undefined) {`
`91`	`91`	`if (`
`92`	`92`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`93`	`93`	`key2.length < key1.length`
`94`	`94`	`) {`
`95`	`95`	`unreachable("Dict.get: Expected keys to be ordered by length.");`
`96`	`96`	`}`
`97`		`- value = this._map[key2];`
	`97`	`+ value = this._map.get(key2);`
`98`	`98`	`if (value === undefined && key3 !== undefined) {`
`99`	`99`	`if (`
`100`	`100`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`101`	`101`	`key3.length < key2.length`
`102`	`102`	`) {`
`103`	`103`	`unreachable("Dict.get: Expected keys to be ordered by length.");`
`104`	`104`	`}`
`105`		`- value = this._map[key3];`
	`105`	`+ value = this._map.get(key3);`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`if (value instanceof Ref && this.xref) {`
`@@ -113,23 +113,23 @@ class Dict {`
`113`	`113`
`114`	`114`	`// Same as get(), but returns a promise and uses fetchIfRefAsync().`
`115`	`115`	`async getAsync(key1, key2, key3) {`
`116`		`- let value = this._map[key1];`
	`116`	`+ let value = this._map.get(key1);`
`117`	`117`	`if (value === undefined && key2 !== undefined) {`
`118`	`118`	`if (`
`119`	`119`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`120`	`120`	`key2.length < key1.length`
`121`	`121`	`) {`
`122`	`122`	`unreachable("Dict.getAsync: Expected keys to be ordered by length.");`
`123`	`123`	`}`
`124`		`- value = this._map[key2];`
	`124`	`+ value = this._map.get(key2);`
`125`	`125`	`if (value === undefined && key3 !== undefined) {`
`126`	`126`	`if (`
`127`	`127`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`128`	`128`	`key3.length < key2.length`
`129`	`129`	`) {`
`130`	`130`	`unreachable("Dict.getAsync: Expected keys to be ordered by length.");`
`131`	`131`	`}`
`132`		`- value = this._map[key3];`
	`132`	`+ value = this._map.get(key3);`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`if (value instanceof Ref && this.xref) {`
`@@ -140,23 +140,23 @@ class Dict {`
`140`	`140`
`141`	`141`	`// Same as get(), but dereferences all elements if the result is an Array.`
`142`	`142`	`getArray(key1, key2, key3) {`
`143`		`- let value = this._map[key1];`
	`143`	`+ let value = this._map.get(key1);`
`144`	`144`	`if (value === undefined && key2 !== undefined) {`
`145`	`145`	`if (`
`146`	`146`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`147`	`147`	`key2.length < key1.length`
`148`	`148`	`) {`
`149`	`149`	`unreachable("Dict.getArray: Expected keys to be ordered by length.");`
`150`	`150`	`}`
`151`		`- value = this._map[key2];`
	`151`	`+ value = this._map.get(key2);`
`152`	`152`	`if (value === undefined && key3 !== undefined) {`
`153`	`153`	`if (`
`154`	`154`	`(typeof PDFJSDev === "undefined" \|\| PDFJSDev.test("TESTING")) &&`
`155`	`155`	`key3.length < key2.length`
`156`	`156`	`) {`
`157`	`157`	`unreachable("Dict.getArray: Expected keys to be ordered by length.");`
`158`	`158`	`}`
`159`		`- value = this._map[key3];`
	`159`	`+ value = this._map.get(key3);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`	`if (value instanceof Ref && this.xref) {`
`@@ -176,16 +176,16 @@ class Dict {`
`176`	`176`
`177`	`177`	`// No dereferencing.`
`178`	`178`	`getRaw(key) {`
`179`		`- return this._map[key];`
	`179`	`+ return this._map.get(key);`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`getKeys() {`
`183`		`- return Object.keys(this._map);`
	`183`	`+ return [...this._map.keys()];`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`// No dereferencing.`
`187`	`187`	`getRawValues() {`
`188`		`- return Object.values(this._map);`
	`188`	`+ return [...this._map.values()];`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`set(key, value) {`
`@@ -196,16 +196,21 @@ class Dict {`
`196`	`196`	`unreachable('Dict.set: The "value" cannot be undefined.');`
`197`	`197`	`}`
`198`	`198`	`}`
`199`		`- this._map[key] = value;`
	`199`	`+ this._map.set(key, value);`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`has(key) {`
`203`		`- return this._map[key] !== undefined;`
	`203`	`+ return this._map.has(key);`
`204`	`204`	`}`
`205`	`205`
`206`		`- forEach(callback) {`
`207`		`- for (const key in this._map) {`
`208`		`- callback(key, this.get(key));`
	`206`	`+ *[Symbol.iterator]() {`
	`207`	`+ for (const [key, value] of this._map) {`
	`208`	`+ yield [`
	`209`	`+ key,`
	`210`	`+ value instanceof Ref && this.xref`
	`211`	`+ ? this.xref.fetch(value, this.suppressEncryption)`
	`212`	`+ : value,`
	`213`	`+ ];`
`209`	`214`	`}`
`210`	`215`	`}`
`211`	`216`
`@@ -226,7 +231,7 @@ class Dict {`
`226`	`231`	`if (!(dict instanceof Dict)) {`
`227`	`232`	`continue;`
`228`	`233`	`}`
`229`		`- for (const [key, value] of Object.entries(dict._map)) {`
	`234`	`+ for (const [key, value] of dict._map) {`
`230`	`235`	`let property = properties.get(key);`
`231`	`236`	`if (property === undefined) {`
`232`	`237`	`property = [];`
`@@ -242,20 +247,20 @@ class Dict {`
`242`	`247`	`}`
`243`	`248`	`for (const [name, values] of properties) {`
`244`	`249`	`if (values.length === 1 \|\| !(values[0] instanceof Dict)) {`
`245`		`- mergedDict._map[name] = values[0];`
	`250`	`+ mergedDict._map.set(name, values[0]);`
`246`	`251`	`continue;`
`247`	`252`	`}`
`248`	`253`	`const subDict = new Dict(xref);`
`249`	`254`
`250`	`255`	`for (const dict of values) {`
`251`		`- for (const [key, value] of Object.entries(dict._map)) {`
`252`		`- if (subDict._map[key] === undefined) {`
`253`		`- subDict._map[key] = value;`
	`256`	`+ for (const [key, value] of dict._map) {`
	`257`	`+ if (!subDict._map.has(key)) {`
	`258`	`+ subDict._map.set(key, value);`
`254`	`259`	`}`
`255`	`260`	`}`
`256`	`261`	`}`
`257`	`262`	`if (subDict.size > 0) {`
`258`		`- mergedDict._map[name] = subDict;`
	`263`	`+ mergedDict._map.set(name, subDict);`
`259`	`264`	`}`
`260`	`265`	`}`
`261`	`266`	`properties.clear();`
Original file line number	Diff line number	Diff line change
`@@ -62,12 +62,11 @@ class StructTreeRoot {`
`62`	`62`	`if (!(roleMapDict instanceof Dict)) {`
`63`	`63`	`return;`
`64`	`64`	`}`
`65`		`- roleMapDict.forEach((key, value) => {`
`66`		`- if (!(value instanceof Name)) {`
`67`		`- return;`
	`65`	`+ for (const [key, value] of roleMapDict) {`
	`66`	`+ if (value instanceof Name) {`
	`67`	`+ this.roleMap.set(key, value.name);`
`68`	`68`	`}`
`69`		`- this.roleMap.set(key, value.name);`
`70`		`- });`
	`69`	`+ }`
`71`	`70`	`}`
`72`	`71`
`73`	`72`	`static async canCreateStructureTree({`
Original file line number	Diff line number	Diff line change
`@@ -688,11 +688,11 @@ class WorkerMessageHandler {`
`688`	`688`	`const infoObj = Object.create(null);`
`689`	`689`	`const xrefInfo = xref.trailer.get("Info") \|\| null;`
`690`	`690`	`if (xrefInfo instanceof Dict) {`
`691`		`- xrefInfo.forEach((key, value) => {`
	`691`	`+ for (const [key, value] of xrefInfo) {`
`692`	`692`	`if (typeof value === "string") {`
`693`	`693`	`infoObj[key] = stringToPDFString(value);`
`694`	`694`	`}`
`695`		`- });`
	`695`	`+ }`
`696`	`696`	`}`
`697`	`697`
`698`	`698`	`newXrefInfo = {`