@chialab/pdfjs-lib 1.0.0-alpha.28 → 1.0.0-alpha.29

package/dist/browser/index.js

@@ -5885,25 +5885,11 @@ _serializable = new WeakMap();
 // src/lib/Canvas.ts
 var Path2DConstructor = Path2D;
 async function createCanvas(width, height) {
-  await loadDefaultFonts();
   const canvas = document.createElement("canvas");
   canvas.width = width;
   canvas.height = height;
   return canvas;
 }
-var loadingFontPromise = null;
-async function loadDefaultFonts() {
-  if (loadingFontPromise === null) {
-    loadingFontPromise = import("./LiberationSans-Regular-3SH5NGZO.js").then((module) => new Blob([module.default], { type: "font/ttf" })).then(async (sansBlob) => {
-      const fontSans = new FontFace(
-        "Liberation Sans",
-        `url(${URL.createObjectURL(sansBlob)})`
-      );
-      document.fonts.add(await fontSans.load());
-    });
-  }
-  return loadingFontPromise;
-}
 
 // src/lib/Path2D.ts
 function toFixed(value, digits = 6) {
@@ -27871,79 +27857,6 @@ PDFPageProxy.prototype.getAnnotations = async function(params) {
   return makeSerializable(annotations);
 };
 
-// src/lib/WasmFactory.ts
-var WasmFactory = class {
-  async fetch({
-    filename
-  }) {
-    switch (filename) {
-      case "openjpeg.wasm":
-        return import("./openjpeg-QLA762TL.js").then(
-          (module) => module.default
-        );
-      case "qcms_bg":
-        return import("./qcms_bg-BCJEADMU.js").then(
-          (module) => module.default
-        );
-    }
-    return Uint8Array.from([]);
-  }
-};
-
-// src/lib/StandardFontDataFactory.ts
-var StandardFontDataFactory = class extends BaseStandardFontDataFactory {
-  constructor() {
-    super({
-      baseUrl: null
-    });
-  }
-  /**
-   * Fetch the corresponding standard font data.
-   * We need to use specific dynamic imports for each font file for the bundler to include them.
-   */
-  async fetch({
-    filename
-  }) {
-    switch (filename) {
-      case "FoxitDingbats.pfb":
-        return import("./FoxitDingbats-XZTZYAP6.js").then((module) => module.default);
-      case "FoxitFixed.pfb":
-        return import("./FoxitFixed-DRWD6QNM.js").then(
-          (module) => module.default
-        );
-      case "FoxitFixedBold.pfb":
-        return import("./FoxitFixedBold-A3IBPIFC.js").then((module) => module.default);
-      case "FoxitFixedBoldItalic.pfb":
-        return import("./FoxitFixedBoldItalic-V4ORMFGL.js").then((module) => module.default);
-      case "FoxitFixedItalic.pfb":
-        return import("./FoxitFixedItalic-Z7BSNTJA.js").then((module) => module.default);
-      case "FoxitSerif.pfb":
-        return import("./FoxitSerif-Y34FHWHO.js").then(
-          (module) => module.default
-        );
-      case "FoxitSerifBold.pfb":
-        return import("./FoxitSerifBold-NCWBT4GX.js").then((module) => module.default);
-      case "FoxitSerifBoldItalic.pfb":
-        return import("./FoxitSerifBoldItalic-YTEOG5ZU.js").then((module) => module.default);
-      case "FoxitSerifItalic.pfb":
-        return import("./FoxitSerifItalic-3H547RIJ.js").then((module) => module.default);
-      case "FoxitSymbol.pfb":
-        return import("./FoxitSymbol-EMTQEYPB.js").then(
-          (module) => module.default
-        );
-      case "LiberationSans-Bold.ttf":
-        return import("./LiberationSans-Bold-MGX34QV4.js").then((module) => module.default);
-      case "LiberationSans-BoldItalic.ttf":
-        return import("./LiberationSans-BoldItalic-WSEQ5LH5.js").then((module) => module.default);
-      case "LiberationSans-Italic.ttf":
-        return import("./LiberationSans-Italic-E4SLDR4M.js").then((module) => module.default);
-      case "LiberationSans-Regular.ttf":
-        return import("./LiberationSans-Regular-3SH5NGZO.js").then((module) => module.default);
-    }
-    return Uint8Array.from([]);
-  }
-};
-
 // src/lib/AnnotationData.ts
 function isTextAnnotation(annotation) {
   return annotation.subtype === "Text";
@@ -28033,59 +27946,6 @@ function isRedactAnnotation(annotation) {
   return annotation.subtype === "Redact";
 }
 
-// src/lib/CanvasGraphics.ts
-var {
-  beginDrawing,
-  beginText,
-  endText,
-  beginMarkedContent,
-  beginMarkedContentProps,
-  endMarkedContent
-} = CanvasGraphics.prototype;
-CanvasGraphics.prototype.beginDrawing = function(options) {
-  if (this.ctx instanceof SvgCanvasContext) {
-    options.transparency = false;
-  }
-  return beginDrawing.call(this, options);
-};
-CanvasGraphics.prototype.beginText = function(opIdx) {
-  beginText.call(this, opIdx);
-  if (this.ctx instanceof SvgCanvasContext) {
-    this.ctx.beginText();
-  }
-};
-CanvasGraphics.prototype.endText = function(opIdx) {
-  endText.call(this, opIdx);
-  if (this.ctx instanceof SvgCanvasContext) {
-    this.ctx.endText();
-  }
-};
-CanvasGraphics.prototype.beginMarkedContent = function(opIdx, type) {
-  beginMarkedContent.call(this, opIdx, this.ctx);
-  if (this.ctx instanceof SvgCanvasContext) {
-    this.ctx.beginMarkedContent(type);
-  }
-};
-CanvasGraphics.prototype.beginMarkedContentProps = function(opIdx, type, props) {
-  beginMarkedContentProps.call(this, opIdx, type, props);
-  if (this.ctx instanceof SvgCanvasContext) {
-    this.ctx.beginMarkedContent(type, props);
-  }
-};
-CanvasGraphics.prototype.endMarkedContent = function(opIdx) {
-  if (this.ctx instanceof SvgCanvasContext) {
-    this.ctx.endMarkedContent();
-  }
-  endMarkedContent.call(this, opIdx);
-};
-Object.assign(CanvasGraphics.prototype, {
-  [OPS.beginText]: CanvasGraphics.prototype.beginText,
-  [OPS.endText]: CanvasGraphics.prototype.endText,
-  [OPS.beginMarkedContent]: CanvasGraphics.prototype.beginMarkedContent,
-  [OPS.beginMarkedContentProps]: CanvasGraphics.prototype.beginMarkedContentProps,
-  [OPS.endMarkedContent]: CanvasGraphics.prototype.endMarkedContent
-});
-
 // src/lib/TextLayer.ts
 function isTextNode(node) {
   return node.role === "text";
@@ -28144,6 +28004,7 @@ async function loadTextLayerFonts(document2) {
   });
   return loadedFontsPromise;
 }
+var loadDefaultFonts = loadTextLayerFonts;
 var normalizeMarkedContentId = (idRef) => {
   if (idRef == null) {
     return null;
@@ -28156,10 +28017,321 @@ var normalizeMarkedContentId = (idRef) => {
   }
   return `${idRef}`;
 };
+var getNodeContents = (node) => {
+  if (isTextNode(node)) {
+    return typeof node.text === "string" ? node.text : node.text.map((t) => t.text).join("");
+  }
+  if (isElementNode(node)) {
+    return node.children.map((n) => {
+      if (typeof n === "string") {
+        return n;
+      }
+      return getNodeContents(n);
+    }).join("");
+  }
+  return "";
+};
+var findNode = (root, callback) => {
+  for (let i = root.children.length - 1; i >= 0; i--) {
+    const child = root.children[i];
+    if (typeof child === "string") {
+      continue;
+    }
+    if (callback(child, root)) {
+      return child;
+    }
+    if (isElementNode(child)) {
+      const found = findNode(child, callback);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return null;
+};
+var findNodes = (node, callback) => {
+  return node.children.reduce((nodes, child) => {
+    if (typeof child === "string") {
+      return nodes;
+    }
+    if (callback(child, node)) {
+      nodes.push(child);
+    }
+    if (isElementNode(child)) {
+      nodes.push(...findNodes(child, callback));
+    }
+    return nodes;
+  }, []);
+};
+var flattenNodes = (node) => {
+  if (typeof node === "string") {
+    return [];
+  }
+  if (isElementNode(node)) {
+    return [node, ...node.children.flatMap(flattenNodes)];
+  }
+  return [node];
+};
 var MAX_TEXT_DIVS_TO_RENDER2 = 1e5;
 var DEFAULT_FONT_SIZE3 = 30;
 var DEFAULT_FONT_ASCENT = 0.8;
 var HYPHEN_REGEX = /-\n+$/;
+var decorateStructTree = (node, rootContainer, graphics, annotations, parents = []) => {
+  let parent = parents.at(-1) || rootContainer;
+  if ("role" in node) {
+    const role = node.role.toLowerCase();
+    switch (role) {
+      case "root":
+      case "document":
+      case "art":
+        parent.attrs ?? (parent.attrs = {});
+        Object.assign(parent.attrs, node.attrs);
+        for (const child of [...node.children]) {
+          decorateStructTree(
+            child,
+            rootContainer,
+            graphics,
+            annotations,
+            parents
+          );
+        }
+        break;
+      case "part":
+      case "sect": {
+        const section = {
+          role: "section",
+          children: [],
+          attrs: node.attrs
+        };
+        while (parents.find(
+          (p) => ["h1", "h2", "h3", "h4", "h5", "h6"].includes(p.role)
+        )) {
+          parents.pop();
+          parent = parents.at(-1) || rootContainer;
+        }
+        parent.children.push(section);
+        for (const child of [...node.children]) {
+          decorateStructTree(child, rootContainer, graphics, annotations, [
+            ...parents,
+            section
+          ]);
+        }
+        break;
+      }
+      case "lbl":
+      case "lbody":
+      case "span": {
+        for (const child of [...node.children]) {
+          decorateStructTree(
+            child,
+            rootContainer,
+            graphics,
+            annotations,
+            parents
+          );
+        }
+        break;
+      }
+      case "link": {
+        const [ref, ...children] = node.children;
+        if (ref.type !== "object") {
+          console.warn(
+            `Unsupported link type: ${ref.type}`
+          );
+          for (const child of children) {
+            decorateStructTree(
+              child,
+              rootContainer,
+              graphics,
+              annotations,
+              parents
+            );
+          }
+          return;
+        }
+        const annotation = annotations?.find(
+          (note) => note.id === ref.id
+        );
+        if (!annotation) {
+          console.warn("Link not found", ref);
+          for (const child of children) {
+            decorateStructTree(
+              child,
+              rootContainer,
+              graphics,
+              annotations,
+              parents
+            );
+          }
+          return;
+        }
+        if (isLinkAnnotation(annotation)) {
+          const anchor = {
+            role: "a",
+            href: annotation.url,
+            children: []
+          };
+          parent.children.push(anchor);
+          for (const child of children) {
+            decorateStructTree(child, rootContainer, graphics, annotations, [
+              ...parents,
+              anchor
+            ]);
+          }
+        } else {
+          console.warn(`Unsupported annotation subtype: ${annotation.subtype}`);
+          for (const child of children) {
+            decorateStructTree(
+              child,
+              rootContainer,
+              graphics,
+              annotations,
+              parents
+            );
+          }
+        }
+        break;
+      }
+      case "p": {
+        if (node.children.length === 0) {
+          break;
+        }
+        if (node.children.length === 1 && node.children[0].role === "Table") {
+          decorateStructTree(
+            node.children[0],
+            rootContainer,
+            graphics,
+            annotations,
+            parents
+          );
+          break;
+        }
+        const paragraph = {
+          role: "p",
+          children: [],
+          attrs: node.attrs
+        };
+        parent.children.push(paragraph);
+        for (const child of [...node.children]) {
+          decorateStructTree(child, rootContainer, graphics, annotations, [
+            ...parents,
+            paragraph
+          ]);
+        }
+        break;
+      }
+      case "l": {
+        const list = {
+          role: "ul",
+          children: [],
+          attrs: node.attrs
+        };
+        parent.children.push(list);
+        for (const child of [...node.children]) {
+          decorateStructTree(child, rootContainer, graphics, annotations, [
+            ...parents,
+            list
+          ]);
+        }
+        break;
+      }
+      case "table":
+      case "thead":
+      case "tbody":
+      case "tfoot":
+      case "tr":
+      case "h1":
+      case "h2":
+      case "h3":
+      case "h4":
+      case "h5":
+      case "h6":
+      case "li":
+      case "td":
+      case "th": {
+        const block = {
+          role,
+          children: [],
+          attrs: node.attrs
+        };
+        parent.children.push(block);
+        for (const child of [...node.children]) {
+          decorateStructTree(child, rootContainer, graphics, annotations, [
+            ...parents,
+            block
+          ]);
+        }
+        break;
+      }
+      case "figure": {
+        if (graphics) {
+          for (const child of [...node.children]) {
+            if (!("id" in child)) {
+              continue;
+            }
+            const contentId = normalizeMarkedContentId(child.id);
+            const useId = `#${id("marked_content" /* MarkedContent */, contentId, graphics.attrs.id)}`;
+            const graphic = findSvgNode(
+              graphics,
+              (node2) => isSvgMarkedContent(node2) && node2.attrs.href === useId
+            );
+            if (!graphic) {
+              continue;
+            }
+            parent.children.push({
+              role: "figure",
+              href: graphic.attrs.href,
+              x: graphic.attrs.x || 0,
+              y: graphic.attrs.y || 0,
+              width: graphic.attrs.width || 0,
+              height: graphic.attrs.height || 0,
+              alt: node.alt
+            });
+          }
+        }
+        break;
+      }
+      default: {
+        const block = {
+          role: "div",
+          children: [],
+          attrs: node.attrs
+        };
+        parent.children.push(block);
+        for (const child of [...node.children]) {
+          decorateStructTree(child, rootContainer, graphics, annotations, [
+            ...parents,
+            block
+          ]);
+        }
+        break;
+      }
+    }
+  } else {
+    const contentId = normalizeMarkedContentId(node.id);
+    findNode(rootContainer, (child, previousParent) => {
+      if (child.id !== contentId) {
+        return;
+      }
+      previousParent.children = previousParent.children.filter(
+        (c) => c !== child
+      );
+      if (isElementNode(child)) {
+        const children = child.children;
+        const lastTextItem = parent.children.at(-1);
+        if (lastTextItem && typeof lastTextItem !== "string" && isTextNode(lastTextItem) && getNodeContents(lastTextItem).trim() === "") {
+          while (children[0] && typeof children[0] !== "string" && isTextNode(children[0]) && getNodeContents(children[0]).trim() === "") {
+            children.shift();
+          }
+        }
+        parent.children.push(...children);
+      } else {
+        parent.children.push(child);
+      }
+      return true;
+    });
+  }
+};
 async function createTextLayer(page, {
   canvasFactory,
   viewport = page.getViewport({ scale: 1 }),
@@ -28171,7 +28343,6 @@ async function createTextLayer(page, {
   const ascentCache = /* @__PURE__ */ new Map();
   const canvasCache = /* @__PURE__ */ new Map();
   const textDivs = [];
-  const markedContent = /* @__PURE__ */ new Map();
   const [tree, contentSource] = await Promise.all([
     page.getStructTree(),
     page.getTextContent({ includeMarkedContent: true })
@@ -28217,10 +28388,6 @@ async function createTextLayer(page, {
           const id2 = normalizeMarkedContentId(item);
           if (id2 != null) {
             container.id = id2;
-            markedContent.set(id2, {
-              node: container,
-              parent
-            });
           }
         } else if (item.type === "endMarkedContent") {
           container = parents.pop();
@@ -28383,215 +28550,6 @@ async function createTextLayer(page, {
     ascentCache.set(fontFamily, ratio);
     return ratio;
   };
-  const renderStructTreeNode = (node, parents) => {
-    let parent = parents[parents.length - 1] || rootContainer;
-    if ("role" in node) {
-      const role = node.role.toLowerCase();
-      switch (role) {
-        case "root":
-        case "document":
-        case "art":
-          parent.attrs ?? (parent.attrs = {});
-          Object.assign(parent.attrs, node.attrs);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, parents);
-          }
-          break;
-        case "sect": {
-          const section = {
-            role: "section",
-            children: [],
-            attrs: node.attrs
-          };
-          while (parents.find(
-            (p) => ["h1", "h2", "h3", "h4", "h5", "h6"].includes(p.role)
-          )) {
-            parents.pop();
-            parent = parents.at(-1) || rootContainer;
-          }
-          parent.children.push(section);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, section]);
-          }
-          break;
-        }
-        case "lbl":
-        case "lbody":
-        case "span": {
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, parents);
-          }
-          break;
-        }
-        case "link": {
-          const [ref, ...children] = node.children;
-          if (ref.type !== "object") {
-            console.warn(
-              `Unsupported link type: ${ref.type}`
-            );
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-            return;
-          }
-          const annotation = annotations?.find(
-            (note) => note.id === ref.id
-          );
-          if (!annotation) {
-            console.warn("Link not found", ref);
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-            return;
-          }
-          if (isLinkAnnotation(annotation)) {
-            const anchor = {
-              role: "a",
-              href: annotation.url,
-              children: []
-            };
-            parent.children.push(anchor);
-            for (const child of children) {
-              renderStructTreeNode(child, [...parents, anchor]);
-            }
-          } else {
-            console.warn(
-              `Unsupported annotation subtype: ${annotation.subtype}`
-            );
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-          }
-          break;
-        }
-        case "p": {
-          if (node.children.length === 0) {
-            break;
-          }
-          if (node.children.length === 1 && node.children[0].role === "Table") {
-            renderStructTreeNode(node.children[0], parents);
-            break;
-          }
-          const paragraph = {
-            role: "p",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(paragraph);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, paragraph]);
-          }
-          break;
-        }
-        case "l": {
-          const list = {
-            role: "ul",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(list);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, list]);
-          }
-          break;
-        }
-        case "table":
-        case "thead":
-        case "tbody":
-        case "tfoot":
-        case "tr":
-        case "h1":
-        case "h2":
-        case "h3":
-        case "h4":
-        case "h5":
-        case "h6":
-        case "li":
-        case "td":
-        case "th": {
-          const block = {
-            role,
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(block);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, block]);
-          }
-          break;
-        }
-        case "figure": {
-          const ids = [...node.children].map((child) => {
-            const id2 = normalizeMarkedContentId(child);
-            if (!id2) {
-              return null;
-            }
-            const span = markedContent.get(id2);
-            if (!span) {
-              return id2;
-            }
-            if (span.parent) {
-              span.parent.children = span.parent.children.filter(
-                (child2) => child2 !== span.node
-              );
-            }
-            return id2;
-          }).filter((id2) => id2 !== null);
-          if (graphics) {
-            for (const markedId of ids) {
-              const figureId = normalizeMarkedContentId(markedId);
-              if (!figureId) {
-                continue;
-              }
-              const useId = `#${id("marked_content" /* MarkedContent */, figureId, graphics.attrs.id)}`;
-              const graphic = findSvgNode(
-                graphics,
-                (node2) => isSvgMarkedContent(node2) && node2.attrs.href === useId
-              );
-              if (!graphic) {
-                continue;
-              }
-              const figure = {
-                role: "figure",
-                href: graphic.attrs.href,
-                x: graphic.attrs.x || 0,
-                y: graphic.attrs.y || 0,
-                width: graphic.attrs.width || 0,
-                height: graphic.attrs.height || 0,
-                alt: node.alt
-              };
-              parent.children.push(figure);
-            }
-          }
-          break;
-        }
-        default: {
-          const block = {
-            role: "div",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(block);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, block]);
-          }
-          break;
-        }
-      }
-    } else {
-      const span = markedContent.get(`${node.id}`);
-      if (!span) {
-        return;
-      }
-      if (span.parent) {
-        span.parent.children = span.parent.children.filter(
-          (child) => child !== span.node
-        );
-      }
-      parent.children.push(span.node);
-    }
-  };
-  await loadDefaultFonts();
   const reader = textContentSource.getReader();
   while (true) {
     const { value, done } = await reader.read();
@@ -28604,7 +28562,7 @@ async function createTextLayer(page, {
   const root = tree?.children[0]?.children[0];
   if (root?.children) {
     for (const child of root.children) {
-      renderStructTreeNode(child, [rootContainer]);
+      decorateStructTree(child, rootContainer, graphics, annotations);
     }
   }
   ascentCache.clear();
@@ -28615,6 +28573,132 @@ async function createTextLayer(page, {
   return rootContainer;
 }
 
+// src/lib/WasmFactory.ts
+var WasmFactory = class {
+  async fetch({
+    filename
+  }) {
+    switch (filename) {
+      case "openjpeg.wasm":
+        return import("./openjpeg-QLA762TL.js").then(
+          (module) => module.default
+        );
+      case "qcms_bg":
+        return import("./qcms_bg-BCJEADMU.js").then(
+          (module) => module.default
+        );
+    }
+    return Uint8Array.from([]);
+  }
+};
+
+// src/lib/StandardFontDataFactory.ts
+var StandardFontDataFactory = class extends BaseStandardFontDataFactory {
+  constructor() {
+    super({
+      baseUrl: null
+    });
+  }
+  /**
+   * Fetch the corresponding standard font data.
+   * We need to use specific dynamic imports for each font file for the bundler to include them.
+   */
+  async fetch({
+    filename
+  }) {
+    switch (filename) {
+      case "FoxitDingbats.pfb":
+        return import("./FoxitDingbats-XZTZYAP6.js").then((module) => module.default);
+      case "FoxitFixed.pfb":
+        return import("./FoxitFixed-DRWD6QNM.js").then(
+          (module) => module.default
+        );
+      case "FoxitFixedBold.pfb":
+        return import("./FoxitFixedBold-A3IBPIFC.js").then((module) => module.default);
+      case "FoxitFixedBoldItalic.pfb":
+        return import("./FoxitFixedBoldItalic-V4ORMFGL.js").then((module) => module.default);
+      case "FoxitFixedItalic.pfb":
+        return import("./FoxitFixedItalic-Z7BSNTJA.js").then((module) => module.default);
+      case "FoxitSerif.pfb":
+        return import("./FoxitSerif-Y34FHWHO.js").then(
+          (module) => module.default
+        );
+      case "FoxitSerifBold.pfb":
+        return import("./FoxitSerifBold-NCWBT4GX.js").then((module) => module.default);
+      case "FoxitSerifBoldItalic.pfb":
+        return import("./FoxitSerifBoldItalic-YTEOG5ZU.js").then((module) => module.default);
+      case "FoxitSerifItalic.pfb":
+        return import("./FoxitSerifItalic-3H547RIJ.js").then((module) => module.default);
+      case "FoxitSymbol.pfb":
+        return import("./FoxitSymbol-EMTQEYPB.js").then(
+          (module) => module.default
+        );
+      case "LiberationSans-Bold.ttf":
+        return import("./LiberationSans-Bold-MGX34QV4.js").then((module) => module.default);
+      case "LiberationSans-BoldItalic.ttf":
+        return import("./LiberationSans-BoldItalic-WSEQ5LH5.js").then((module) => module.default);
+      case "LiberationSans-Italic.ttf":
+        return import("./LiberationSans-Italic-E4SLDR4M.js").then((module) => module.default);
+      case "LiberationSans-Regular.ttf":
+        return import("./LiberationSans-Regular-3SH5NGZO.js").then((module) => module.default);
+    }
+    return Uint8Array.from([]);
+  }
+};
+
+// src/lib/CanvasGraphics.ts
+var {
+  beginDrawing,
+  beginText,
+  endText,
+  beginMarkedContent,
+  beginMarkedContentProps,
+  endMarkedContent
+} = CanvasGraphics.prototype;
+CanvasGraphics.prototype.beginDrawing = function(options) {
+  if (this.ctx instanceof SvgCanvasContext) {
+    options.transparency = false;
+  }
+  return beginDrawing.call(this, options);
+};
+CanvasGraphics.prototype.beginText = function(opIdx) {
+  beginText.call(this, opIdx);
+  if (this.ctx instanceof SvgCanvasContext) {
+    this.ctx.beginText();
+  }
+};
+CanvasGraphics.prototype.endText = function(opIdx) {
+  endText.call(this, opIdx);
+  if (this.ctx instanceof SvgCanvasContext) {
+    this.ctx.endText();
+  }
+};
+CanvasGraphics.prototype.beginMarkedContent = function(opIdx, type) {
+  beginMarkedContent.call(this, opIdx, this.ctx);
+  if (this.ctx instanceof SvgCanvasContext) {
+    this.ctx.beginMarkedContent(type);
+  }
+};
+CanvasGraphics.prototype.beginMarkedContentProps = function(opIdx, type, props) {
+  beginMarkedContentProps.call(this, opIdx, type, props);
+  if (this.ctx instanceof SvgCanvasContext) {
+    this.ctx.beginMarkedContent(type, props);
+  }
+};
+CanvasGraphics.prototype.endMarkedContent = function(opIdx) {
+  if (this.ctx instanceof SvgCanvasContext) {
+    this.ctx.endMarkedContent();
+  }
+  endMarkedContent.call(this, opIdx);
+};
+Object.assign(CanvasGraphics.prototype, {
+  [OPS.beginText]: CanvasGraphics.prototype.beginText,
+  [OPS.endText]: CanvasGraphics.prototype.endText,
+  [OPS.beginMarkedContent]: CanvasGraphics.prototype.beginMarkedContent,
+  [OPS.beginMarkedContentProps]: CanvasGraphics.prototype.beginMarkedContentProps,
+  [OPS.endMarkedContent]: CanvasGraphics.prototype.endMarkedContent
+});
+
 // node_modules/opentype.js/dist/opentype.module.js
 if (!String.prototype.codePointAt) {
   (function() {
@@ -40863,20 +40947,6 @@ var opentype = /* @__PURE__ */ Object.freeze({
 var opentype_module_default = opentype;
 
 // src/lib/TextLayer_v2.ts
-var findNode = (node, callback) => {
-  for (let i = node.children.length - 1; i >= 0; i--) {
-    const child = node.children[i];
-    if (typeof child === "string") {
-      continue;
-    }
-    if (callback(child, node)) {
-      return;
-    }
-    if (isElementNode(child)) {
-      findNode(child, callback);
-    }
-  }
-};
 var loadTextLayerFontsMap = /* @__PURE__ */ (() => {
   let promise = null;
   return () => {
@@ -40892,12 +40962,6 @@ var loadTextLayerFontsMap = /* @__PURE__ */ (() => {
     return promise;
   };
 })();
-var computeText = (node) => {
-  if (typeof node.text === "string") {
-    return node.text;
-  }
-  return node.text.map((t) => t.text).join("");
-};
 async function createTextLayerV2(page, {
   graphics,
   annotations: _annotations
@@ -41003,210 +41067,6 @@ async function createTextLayerV2(page, {
     });
     resetTextItem();
   };
-  const renderStructTreeNode = (node, parents) => {
-    let parent = parents.at(-1) || rootContainer;
-    if ("role" in node) {
-      const role = node.role.toLowerCase();
-      switch (role) {
-        case "root":
-        case "document":
-        case "art":
-          parent.attrs ?? (parent.attrs = {});
-          Object.assign(parent.attrs, node.attrs);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, parents);
-          }
-          break;
-        case "part":
-        case "sect": {
-          const section = {
-            role: "section",
-            children: [],
-            attrs: node.attrs
-          };
-          while (parents.find(
-            (p) => ["h1", "h2", "h3", "h4", "h5", "h6"].includes(p.role)
-          )) {
-            parents.pop();
-            parent = parents.at(-1) || rootContainer;
-          }
-          parent.children.push(section);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, section]);
-          }
-          break;
-        }
-        case "lbl":
-        case "lbody":
-        case "span": {
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, parents);
-          }
-          break;
-        }
-        case "link": {
-          const [ref, ...children] = node.children;
-          if (ref.type !== "object") {
-            console.warn(
-              `Unsupported link type: ${ref.type}`
-            );
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-            return;
-          }
-          const annotation = annotations?.find(
-            (note) => note.id === ref.id
-          );
-          if (!annotation) {
-            console.warn("Link not found", ref);
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-            return;
-          }
-          if (isLinkAnnotation(annotation)) {
-            const anchor = {
-              role: "a",
-              href: annotation.url,
-              children: []
-            };
-            parent.children.push(anchor);
-            for (const child of children) {
-              renderStructTreeNode(child, [...parents, anchor]);
-            }
-          } else {
-            console.warn(
-              `Unsupported annotation subtype: ${annotation.subtype}`
-            );
-            for (const child of children) {
-              renderStructTreeNode(child, parents);
-            }
-          }
-          break;
-        }
-        case "p": {
-          if (node.children.length === 0) {
-            break;
-          }
-          if (node.children.length === 1 && node.children[0].role === "Table") {
-            renderStructTreeNode(node.children[0], parents);
-            break;
-          }
-          const paragraph = {
-            role: "p",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(paragraph);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, paragraph]);
-          }
-          break;
-        }
-        case "l": {
-          const list = {
-            role: "ul",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(list);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, list]);
-          }
-          break;
-        }
-        case "table":
-        case "thead":
-        case "tbody":
-        case "tfoot":
-        case "tr":
-        case "h1":
-        case "h2":
-        case "h3":
-        case "h4":
-        case "h5":
-        case "h6":
-        case "li":
-        case "td":
-        case "th": {
-          const block = {
-            role,
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(block);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, block]);
-          }
-          break;
-        }
-        case "figure": {
-          if (graphics) {
-            for (const child of [...node.children]) {
-              if (!("id" in child)) {
-                continue;
-              }
-              const contentId = normalizeMarkedContentId(child.id);
-              const useId = `#${id("marked_content" /* MarkedContent */, contentId, graphics.attrs.id)}`;
-              const graphic = findSvgNode(
-                graphics,
-                (node2) => isSvgMarkedContent(node2) && node2.attrs.href === useId
-              );
-              if (!graphic) {
-                continue;
-              }
-              parent.children.push({
-                role: "figure",
-                href: graphic.attrs.href,
-                x: graphic.attrs.x || 0,
-                y: graphic.attrs.y || 0,
-                width: graphic.attrs.width || 0,
-                height: graphic.attrs.height || 0,
-                alt: node.alt
-              });
-            }
-          }
-          break;
-        }
-        default: {
-          const block = {
-            role: "div",
-            children: [],
-            attrs: node.attrs
-          };
-          parent.children.push(block);
-          for (const child of [...node.children]) {
-            renderStructTreeNode(child, [...parents, block]);
-          }
-          break;
-        }
-      }
-    } else {
-      const contentId = normalizeMarkedContentId(node.id);
-      findNode(rootContainer, (child, previousParent) => {
-        if (child.id !== contentId) {
-          return;
-        }
-        previousParent.children = previousParent.children.filter(
-          (c) => c !== child
-        );
-        if (isElementNode(child)) {
-          const children = child.children;
-          const lastTextItem = parent.children.at(-1);
-          if (lastTextItem && typeof lastTextItem !== "string" && isTextNode(lastTextItem) && computeText(lastTextItem).trim() === "") {
-            while (children[0] && typeof children[0] !== "string" && isTextNode(children[0]) && computeText(children[0]).trim() === "") {
-              children.shift();
-            }
-          }
-          parent.children.push(...children);
-        } else {
-          parent.children.push(child);
-        }
-        return true;
-      });
-    }
-  };
   for (let i = 0; i < operatorsList.fnArray.length; i++) {
     const fnId = operatorsList.fnArray[i];
     const args = operatorsList.argsArray[i];
@@ -41404,9 +41264,22 @@ async function createTextLayerV2(page, {
     }
   }
   closeTextItem();
-  renderStructTreeNode(structTree, [rootContainer]);
+  decorateStructTree(
+    structTree,
+    rootContainer,
+    graphics,
+    annotations
+  );
   return rootContainer;
 }
+
+// src/index.ts
+var textLayerUtils = {
+  findNode,
+  findNodes,
+  getNodeContents,
+  flattenNodes
+};
 export {
   AbortException,
   AnnotationEditorLayer,
@@ -41456,7 +41329,6 @@ export {
   createValidAbsoluteUrl,
   destroySvgContext,
   fetchData,
-  fontLoader,
   getDocument,
   getFilenameFromUrl,
   getPdfFilenameFromUrl,
@@ -41508,7 +41380,6 @@ export {
   loadTextLayerFonts,
   makeSerializable,
   noContextMenu,
-  normalizeMarkedContentId,
   normalizeUnicode,
   parseRgbaColor,
   renderSvgNode,
@@ -41516,6 +41387,7 @@ export {
   setLayerDimensions,
   shadow,
   stopEvent,
+  textLayerUtils,
   toDataUrl,
   toSvgNode,
   toSvgString,