Merge pull request #20384 from calixteman/bug1937438

Make MathML elements visible in the struct tree (bug 1937438)

Author: calixteman

src/core/struct_tree.js

@@ -16,6 +16,7 @@
 import { AnnotationPrefix, stringToPDFString, warn } from "../shared/util.js";
 import { Dict, isName, Name, Ref, RefSetCache } from "./primitives.js";
 import { lookupNormalRect, stringToAsciiOrUTF16BE } from "./core_utils.js";
+import { BaseStream } from "./base_stream.js";
 import { NumberTree } from "./name_number_tree.js";
 
 const MAX_DEPTH = 40;
@@ -579,6 +580,50 @@ class StructElementNode {
     return root.roleMap.get(name) ?? name;
   }
 
+  get mathML() {
+    let AFs = this.dict.get("AF") || [];
+    if (!Array.isArray(AFs)) {
+      AFs = [AFs];
+    }
+    for (let af of AFs) {
+      af = this.xref.fetchIfRef(af);
+      if (!(af instanceof Dict)) {
+        continue;
+      }
+      if (!isName(af.get("Type"), "Filespec")) {
+        continue;
+      }
+      if (!isName(af.get("AFRelationship"), "Supplement")) {
+        continue;
+      }
+      const ef = af.get("EF");
+      if (!(ef instanceof Dict)) {
+        continue;
+      }
+      const fileStream = ef.get("UF") || ef.get("F");
+      if (!(fileStream instanceof BaseStream)) {
+        continue;
+      }
+      if (!isName(fileStream.dict.get("Type"), "EmbeddedFile")) {
+        continue;
+      }
+      if (!isName(fileStream.dict.get("Subtype"), "application/mathml+xml")) {
+        continue;
+      }
+      return fileStream.getString();
+    }
+    const A = this.dict.get("A");
+    if (A instanceof Dict) {
+      // This stuff isn't in the spec, but MS Office seems to use it.
+      const O = A.get("O");
+      if (isName(O, "MSFT_Office")) {
+        const mathml = A.get("MSFT_MathML");
+        return mathml ? stringToPDFString(mathml) : null;
+      }
+    }
+    return null;
+  }
+
   parseKids() {
     let pageObjId = null;
     const objRef = this.dict.getRaw("Pg");
@@ -842,6 +887,12 @@ class StructTreePage {
       if (typeof alt === "string") {
         obj.alt = stringToPDFString(alt);
       }
+      if (obj.role === "Formula") {
+        const { mathML } = node;
+        if (mathML) {
+          obj.mathML = mathML;
+        }
+      }
 
       const a = node.dict.get("A");
       if (a instanceof Dict) {

src/shared/util.js

@@ -658,6 +658,15 @@ class FeatureTest {
     );
   }
 
+  static get isSanitizerSupported() {
+    return shadow(
+      this,
+      "isSanitizerSupported",
+      // eslint-disable-next-line no-undef
+      typeof Sanitizer !== "undefined"
+    );
+  }
+
   static get platform() {
     const { platform, userAgent } = navigator;
 

test/integration/accessibility_spec.mjs

@@ -305,4 +305,72 @@ describe("accessibility", () => {
       );
     });
   });
+
+  describe("MathML in AF entry from LaTeX", () => {
+    let pages;
+
+    beforeEach(async () => {
+      pages = await loadAndWait("bug1937438_af_from_latex.pdf", ".textLayer");
+    });
+
+    afterEach(async () => {
+      await closePages(pages);
+    });
+
+    it("must check that the MathML is correctly inserted", async () => {
+      await Promise.all(
+        pages.map(async ([browserName, page]) => {
+          const isSanitizerSupported = await page.evaluate(() => {
+            try {
+              // eslint-disable-next-line no-undef
+              return typeof Sanitizer !== "undefined";
+            } catch {
+              return false;
+            }
+          });
+          if (isSanitizerSupported) {
+            const mathML = await page.$eval(
+              "span.structTree span[aria-owns='p58R_mc13'] > math",
+              el => el?.innerHTML ?? ""
+            );
+            expect(mathML)
+              .withContext(`In ${browserName}`)
+              .toEqual(
+                " <msqrt><msup><mi>x</mi><mn>2</mn></msup></msqrt> <mo>=</mo> <mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow> "
+              );
+          } else {
+            pending(`Sanitizer API (in ${browserName}) is not supported`);
+          }
+        })
+      );
+    });
+  });
+
+  describe("MathML tags in the struct tree", () => {
+    let pages;
+
+    beforeEach(async () => {
+      pages = await loadAndWait("bug1937438_mml_from_latex.pdf", ".textLayer");
+    });
+
+    afterEach(async () => {
+      await closePages(pages);
+    });
+
+    it("must check that the MathML is correctly inserted", async () => {
+      await Promise.all(
+        pages.map(async ([browserName, page]) => {
+          const mathML = await page.$eval(
+            "span.structTree span[role='group'] span[role='group']:last-child > span math",
+            el => el?.innerHTML ?? ""
+          );
+          expect(mathML)
+            .withContext(`In ${browserName}`)
+            .toEqual(
+              `<mi aria-owns="p76R_mc16"></mi><mo aria-owns="p76R_mc17"></mo><msqrt><mrow><msup><mi aria-owns="p76R_mc18"></mi><mn aria-owns="p76R_mc19"></mn></msup><mo aria-owns="p76R_mc20"></mo><msup><mi aria-owns="p76R_mc21"></mi><mn aria-owns="p76R_mc22"></mn></msup></mrow></msqrt>`
+            );
+        })
+      );
+    });
+  });
 });

test/pdfs/.gitignore

@@ -749,3 +749,6 @@
 !issue20319_1.pdf
 !issue20319_2.pdf
 !bug1992868.pdf
+!bug1937438_af_from_latex.pdf
+!bug1937438_from_word.pdf
+!bug1937438_mml_from_latex.pdf

test/pdfs/bug1937438_af_from_latex.pdf

@@ -21,6 +21,7 @@ function equalTrees(rootA, rootB) {
     expect(a.role).toEqual(b.role);
     expect(a.lang).toEqual(b.lang);
     expect(a.type).toEqual(b.type);
+    expect(a.mathML).toEqual(b.mathML);
     expect("children" in a).toEqual("children" in b);
     if (!a.children) {
       return;
@@ -151,4 +152,154 @@ describe("struct tree", function () {
     );
     await loadingTask.destroy();
   });
+
+  it("parses structure with some MathML in AF dictionary", async function () {
+    const filename = "bug1937438_af_from_latex.pdf";
+    const params = buildGetDocumentParams(filename);
+    const loadingTask = getDocument(params);
+    const doc = await loadingTask.promise;
+    const page = await doc.getPage(1);
+    const struct = await page.getStructTree();
+    equalTrees(
+      {
+        children: [
+          {
+            role: "Document",
+            children: [
+              {
+                role: "Part",
+                children: [
+                  {
+                    role: "P",
+                    children: [
+                      {
+                        role: "P",
+                        children: [{ type: "content", id: "p58R_mc0" }],
+                      },
+                    ],
+                  },
+                  {
+                    role: "P",
+                    children: [{ type: "content", id: "p58R_mc1" }],
+                  },
+                  {
+                    role: "P",
+                    children: [{ type: "content", id: "p58R_mc2" }],
+                  },
+                ],
+              },
+              {
+                role: "Sect",
+                children: [
+                  {
+                    role: "H1",
+                    children: [
+                      {
+                        role: "Lbl",
+                        children: [{ type: "content", id: "p58R_mc3" }],
+                      },
+                      { type: "content", id: "p58R_mc4" },
+                    ],
+                  },
+                  {
+                    role: "Part",
+                    children: [
+                      {
+                        role: "P",
+                        children: [
+                          { type: "content", id: "p58R_mc5" },
+                          {
+                            role: "Formula",
+                            children: [{ type: "content", id: "p58R_mc6" }],
+                            mathML: "<math> <mi>x</mi> </math>",
+                          },
+                          { type: "content", id: "p58R_mc7" },
+                          {
+                            role: "Formula",
+                            children: [{ type: "content", id: "p58R_mc8" }],
+                            mathML: "<math> <mi>y</mi> </math>",
+                          },
+                          { type: "content", id: "p58R_mc9" },
+                          {
+                            role: "Formula",
+                            children: [{ type: "content", id: "p58R_mc10" }],
+                            mathML:
+                              "<math> <mi>x</mi> <mo>&gt;</mo> <mi>y</mi> </math>",
+                          },
+                          { type: "content", id: "p58R_mc11" },
+                        ],
+                      },
+                    ],
+                  },
+                  {
+                    role: "Part",
+                    children: [
+                      {
+                        role: "P",
+                        children: [{ type: "content", id: "p58R_mc12" }],
+                      },
+                      {
+                        role: "Formula",
+                        children: [{ type: "content", id: "p58R_mc13" }],
+                        mathML:
+                          '<math> <msqrt><msup><mi>x</mi><mn>2</mn></msup></msqrt> <mo>=</mo> <mrow intent="absolute-value($x)"><mo>|</mo><mi arg="x">x</mi><mo>|</mo></mrow> </math>',
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        role: "Root",
+      },
+      struct
+    );
+    await loadingTask.destroy();
+  });
+
+  it("parses structure with some MathML in MS Office specific entry", async function () {
+    const filename = "bug1937438_from_word.pdf";
+    const params = buildGetDocumentParams(filename);
+    const loadingTask = getDocument(params);
+    const doc = await loadingTask.promise;
+    const page = await doc.getPage(1);
+    const struct = await page.getStructTree();
+    equalTrees(
+      {
+        children: [
+          {
+            role: "Document",
+            children: [
+              {
+                role: "P",
+                children: [
+                  { type: "content", id: "p3R_mc0" },
+                  {
+                    role: "Formula",
+                    children: [{ type: "content", id: "p3R_mc1" }],
+                    alt: "pi",
+                    mathML: '<math display="block"><mi>&#x1D70B;</mi></math>',
+                  },
+                  { type: "content", id: "p3R_mc2" },
+                ],
+              },
+              {
+                role: "Formula",
+                children: [{ type: "content", id: "p3R_mc3" }],
+                alt: "6 sum from n equals 1 to infinity of 1 over n squared , equals pi squared",
+                mathML:
+                  '<math display="block"><mn>6</mn><mrow><munderover><mo stretchy="false">&#x2211;</mo><mrow><mi>n</mi><mo>=</mo><mn>1</mn></mrow><mo>&#x221E;</mo></munderover><mfrac><mn>1</mn><msup><mrow><mi>n</mi></mrow><mn>2</mn></msup></mfrac></mrow><mo>=</mo><msup><mrow><mi>&#x1D70B;</mi></mrow><mn>2</mn></msup></math>',
+              },
+              { role: "P", children: [{ type: "content", id: "p3R_mc4" }] },
+              { role: "P", children: [{ type: "content", id: "p3R_mc5" }] },
+            ],
+          },
+        ],
+        role: "Root",
+      },
+      struct
+    );
+    await loadingTask.destroy();
+  });
 });