pretext-pdfjs 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pretext-pdfjs",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Pretext-native text layer for PDF.js — zero DOM reflows, per-block reflow with image preservation, pinch-to-zoom text",
   "type": "module",
   "main": "./src/index.js",

package/src/pinch.js

@@ -392,6 +392,37 @@ export function createPDFPinchReader(container, options = {}) {
     }
   }
 
+  /**
+   * Find adaptive paragraph threshold by analyzing gap distribution.
+   */
+  function findParagraphThreshold(gaps, fontSize) {
+    if (gaps.length < 3) return 1.8;
+
+    // Filter out extreme outliers (>5x font size - likely headers, titles, etc.)
+    const filtered = gaps.filter(g => g / fontSize < 5);
+    if (filtered.length < 3) return 1.8;
+
+    const ratios = filtered.map(g => g / fontSize).sort((a, b) => a - b);
+
+    let maxGap = 0;
+    let threshold = 1.8;
+
+    for (let i = 0; i < ratios.length - 1; i++) {
+      const gap = ratios[i + 1] - ratios[i];
+      if (gap > maxGap && gap > 0.25 && ratios[i] > 0.8) {
+        maxGap = gap;
+        threshold = (ratios[i] + ratios[i + 1]) / 2;
+      }
+    }
+
+    if (maxGap < 0.2) {
+      const idx = Math.floor(ratios.length * 0.75);
+      threshold = ratios[Math.min(idx, ratios.length - 1)];
+    }
+
+    return Math.max(1.25, Math.min(threshold, 2.2));
+  }
+
   /**
    * Extract plain text from a PDF page.
    * Joins text items with spaces, preserves paragraph breaks.
@@ -400,11 +431,32 @@ export function createPDFPinchReader(container, options = {}) {
     const page = await pdfDoc.getPage(pageNum);
     const content = await page.getTextContent();
 
-    // Build text with paragraph detection
-    let result = "";
+    // First pass: collect all gaps to compute adaptive threshold
+    const gaps = [];
     let lastY = null;
     let lastFontSize = 12;
 
+    for (const item of content.items) {
+      if (!item.str || !item.transform) continue;
+
+      const currentY = item.transform[5];
+      const fontHeight = Math.hypot(item.transform[2], item.transform[3]);
+      if (fontHeight > 0) lastFontSize = fontHeight;
+
+      if (lastY !== null) {
+        gaps.push(Math.abs(currentY - lastY));
+      }
+      lastY = currentY;
+    }
+
+    // Compute adaptive threshold
+    const paraThreshold = findParagraphThreshold(gaps, lastFontSize);
+    const lineThreshold = lastFontSize * 0.3;
+
+    // Second pass: build text with adaptive threshold
+    let result = "";
+    lastY = null;
+
     for (const item of content.items) {
       if (!item.str) continue;
 
@@ -415,10 +467,10 @@ export function createPDFPinchReader(container, options = {}) {
 
         if (lastY !== null) {
           const gap = Math.abs(currentY - lastY);
-          if (gap > lastFontSize * 1.8) {
+          if (gap > lastFontSize * paraThreshold) {
             // Paragraph break
             result += "\n\n";
-          } else if (gap > lastFontSize * 0.3) {
+          } else if (gap > lineThreshold) {
             // Line break within paragraph — add space
             if (!result.endsWith(" ") && !result.endsWith("\n")) {
               result += " ";

package/src/reflow.js

@@ -64,7 +64,7 @@ function drawColoredLine(ctx, text, charOffset, spans, defaultColor, x, y) {
     }
 
     const spanText = text.slice(overlapStart, overlapEnd);
-    ctx.fillStyle = span.color;
+    ctx.fillStyle = span.color === "transparent" ? defaultColor : span.color;
     ctx.fillText(spanText, xPos, y);
     xPos += ctx.measureText(spanText).width;
     pos = overlapEnd;
@@ -156,111 +156,195 @@ async function extractFontMetadata(page, opList, OPS) {
 // ─── Text color extraction ───────────────────────────────────────────────
 
 /**
- * Extract fill colors per beginText/endText block pair.
- * Returns an array of color strings, one per text block.
- *
- * The previous approach pushed one color per text-drawing operator (showText,
- * showSpacedText, etc.) and tried to index into text items 1:1. That mapping
- * is broken because a single showSpacedText operator can produce multiple text
- * items via buildTextContentItem(). Instead, we track color at text-block
- * boundaries — all text items within the same beginText/endText pair share
- * the same color context.
+ * Extract text with colors from the operator list.
+ * Returns an array of {text, color} objects that can be matched to getTextContent() items.
  */
-function extractTextBlockColors(opList, OPS) {
-  const blockColors = []; // one entry per beginText/endText pair
-  let currentColor = "#000000";
-  let blockColor = "#000000";
-  let inTextBlock = false;
+function extractTextWithColors(opList, OPS) {
+  const textRuns = []; // {text, color}
+  let fillColor = "#000000";
+  let strokeColor = "#000000";
+  let textRenderingMode = 0;
+
+  // Helper to extract text from glyph array
+  function glyphsToText(glyphs) {
+    if (!Array.isArray(glyphs)) return "";
+    return glyphs
+      .filter(g => g && typeof g === "object" && g.unicode)
+      .map(g => g.unicode)
+      .join("");
+  }
 
   for (let i = 0; i < opList.fnArray.length; i++) {
     const fn = opList.fnArray[i];
+    const args = opList.argsArray[i];
 
-    // Track color changes
     if (fn === OPS.setFillRGBColor) {
-      currentColor = opList.argsArray[i][0];
-    } else if (fn === OPS.setFillTransparent) {
-      currentColor = "transparent";
-    } else if (
-      fn === OPS.setFillGray ||
-      fn === OPS.setFillColor ||
-      fn === OPS.setFillCMYKColor ||
-      fn === OPS.setFillColorN
-    ) {
-      const args = opList.argsArray[i];
-      if (args?.[0] && typeof args[0] === "string" && args[0].startsWith("#")) {
-        currentColor = args[0];
+      fillColor = argsToHex(args);
+    } else if (fn === OPS.setStrokeRGBColor) {
+      strokeColor = argsToHex(args);
+    } else if (fn === OPS.setTextRenderingMode) {
+      textRenderingMode = args[0];
+    } else if (fn === OPS.showText || fn === OPS.nextLineShowText || fn === OPS.nextLineSetSpacingShowText) {
+      const text = glyphsToText(args[0]);
+      if (text) {
+        textRuns.push({ text, color: visibleColor(fillColor, strokeColor, textRenderingMode) });
+      }
+    } else if (fn === OPS.showSpacedText) {
+      // showSpacedText has an array of [glyphs, spacing, glyphs, spacing, ...]
+      const arr = args[0];
+      if (Array.isArray(arr)) {
+        let combinedText = "";
+        for (let j = 0; j < arr.length; j += 2) {
+          const glyphs = arr[j];
+          if (glyphs) {
+            combinedText += glyphsToText(glyphs);
+          }
+        }
+        if (combinedText) {
+          textRuns.push({ text: combinedText, color: visibleColor(fillColor, strokeColor, textRenderingMode) });
+        }
       }
     }
+  }
 
-    if (fn === OPS.beginText) {
-      inTextBlock = true;
-      blockColor = currentColor; // color at start of block
+  return textRuns;
+}
+
+/**
+ * Match text items to colors by content.
+ * Returns an array of colors aligned with textItems.
+ */
+function matchColorsToTextItems(textItems, textRuns) {
+  const colors = [];
+  let runIdx = 0;
+
+  for (const item of textItems) {
+    if (item.str === undefined || !item.str.trim()) {
+      colors.push(null); // Skip non-text items
+      continue;
     }
 
-    // If color changes within a text block, update (last color wins)
-    if (inTextBlock && (
-      fn === OPS.setFillRGBColor ||
-      fn === OPS.setFillTransparent ||
-      fn === OPS.setFillGray ||
-      fn === OPS.setFillColor ||
-      fn === OPS.setFillCMYKColor ||
-      fn === OPS.setFillColorN
-    )) {
-      blockColor = currentColor;
+    const itemText = item.str.trim();
+    let matchedColor = "#000000"; // default
+
+    // Find a text run that matches this item
+    // Reset runIdx if we've gone too far (item may be earlier in the list)
+    if (runIdx >= textRuns.length) {
+      runIdx = 0;
     }
 
-    if (fn === OPS.endText) {
-      blockColors.push(blockColor);
-      inTextBlock = false;
+    // Search for matching run starting from current position
+    for (let i = runIdx; i < textRuns.length; i++) {
+      const run = textRuns[i];
+      const runText = run.text.trim();
+
+      // Skip empty runs
+      if (!runText) continue;
+
+      // Check for exact match or substring match
+      if (runText === itemText || 
+          itemText.startsWith(runText) || 
+          runText.startsWith(itemText)) {
+        matchedColor = run.color;
+        runIdx = i + 1; // Start from next run for next item
+        break;
+      }
     }
+
+    colors.push(matchedColor);
   }
 
-  return blockColors;
+  return colors;
+}
+
+/**
+ * Extract one visible color per text-drawing operator in the operator list.
+ * Returns an array that maps ~1:1 to the text items from getTextContent().
+ * DEPRECATED: Use extractTextWithColors + matchColorsToTextItems instead.
+ */
+function extractTextItemColors(opList, OPS) {
+  const itemColors = []; // one entry per text-drawing operator
+  let fillColor = "#000000";
+  let strokeColor = "#000000";
+  let textRenderingMode = 0;
+
+  for (let i = 0; i < opList.fnArray.length; i++) {
+    const fn = opList.fnArray[i];
+
+    if (fn === OPS.setFillRGBColor) {
+      fillColor = argsToHex(opList.argsArray[i]);
+    } else if (fn === OPS.setStrokeRGBColor) {
+      strokeColor = argsToHex(opList.argsArray[i]);
+    } else if (fn === OPS.setTextRenderingMode) {
+      textRenderingMode = opList.argsArray[i][0];
+    } else if (
+      fn === OPS.showText ||
+      fn === OPS.nextLineShowText ||
+      fn === OPS.nextLineSetSpacingShowText
+    ) {
+      itemColors.push(visibleColor(fillColor, strokeColor, textRenderingMode));
+    } else if (fn === OPS.showSpacedText) {
+      itemColors.push(visibleColor(fillColor, strokeColor, textRenderingMode));
+    }
+  }
+
+  return itemColors;
+}
+
+/** Convert color operator args to a hex string. Args may be a hex string or RGB byte array. */
+function argsToHex(args) {
+  if (typeof args[0] === "string" && args[0].startsWith("#")) return args[0];
+  const r = args[0] | 0, g = args[1] | 0, b = args[2] | 0;
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+
+/** Pick the color that will actually be visible based on text rendering mode. */
+function visibleColor(fill, stroke, mode) {
+  const m = mode & 3; // lower 2 bits: 0=fill, 1=stroke, 2=fill+stroke, 3=invisible
+  if (m === 1) return stroke;
+  if (m === 0 || m === 2) return fill;
+  return "#000000"; // mode 3 (invisible) — show as black in reflow
 }
 
 // ─── Page analysis ────────────────────────────────────────────────────────
 
+/**
+ * Find adaptive threshold for grouping items into blocks.
+ * Similar to paragraph detection but tuned for block-level grouping.
+ */
+function findBlockThreshold(gaps, fontSize) {
+  if (gaps.length < 3) return 2.0;  // Default block threshold
+
+  // Filter extreme outliers
+  const filtered = gaps.filter(g => g / fontSize < 5);
+  if (filtered.length < 3) return 2.0;
+
+  const ratios = filtered.map(g => g / fontSize).sort((a, b) => a - b);
+
+  // For block grouping, we want to be more conservative than paragraph detection
+  // Use the 60th percentile as the threshold - this separates:
+  // - Line spacing (~1.0-1.3x) from paragraph gaps (~1.5x+)
+  const idx = Math.floor(ratios.length * 0.6);
+  const threshold = ratios[Math.min(idx, ratios.length - 1)];
+
+  // Clamp: block threshold should be between 1.5x and 2.2x
+  // Lower than paragraph threshold to ensure paragraphs split into separate blocks
+  return Math.max(1.5, Math.min(threshold, 2.2));
+}
+
 /**
  * Group adjacent text items into text blocks by proximity.
  * Also extracts font metadata: average size, italic, bold.
  */
-function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
-  // Map text items to beginText/endText blocks by detecting position
-  // discontinuities. Items within the same text block are contiguous and
-  // share the same color. When there's a large Y-position jump or font
-  // change, we advance to the next block's color.
-  if (blockColors && blockColors.length > 0) {
-    let blockIdx = 0;
-    let prevY = null;
-    let prevFontName = null;
-    let itemsInCurrentBlock = 0;
-
-    for (const item of textItems) {
-      if (item.str === undefined) continue; // skip marked content
-
-      const y = item.transform ? item.transform[5] : null;
-      const fontHeight = item.transform
-        ? Math.hypot(item.transform[2], item.transform[3])
-        : 12;
-
-      // Detect text block boundary by position discontinuity
-      if (prevY !== null && y !== null && itemsInCurrentBlock > 0) {
-        const yDiff = Math.abs(y - prevY);
-        const fontChanged = item.fontName !== prevFontName;
-
-        if (
-          (yDiff > fontHeight * 3) ||
-          (fontChanged && yDiff > fontHeight * 0.5)
-        ) {
-          blockIdx = Math.min(blockIdx + 1, blockColors.length - 1);
-          itemsInCurrentBlock = 0;
-        }
-      }
-
-      item._color = blockColors[blockIdx] || "#000000";
-      itemsInCurrentBlock++;
-      prevY = y;
-      prevFontName = item.fontName;
+function groupTextBlocks(textItems, pageHeight, styles, fontMap, textRuns) {
+  // Assign colors to text items by matching content from textRuns.
+  // textRuns is an array of {text, color} extracted from the operator list.
+  if (textRuns && textRuns.length > 0) {
+    const colors = matchColorsToTextItems(textItems, textRuns);
+    for (let i = 0; i < textItems.length; i++) {
+      const item = textItems[i];
+      if (item.str === undefined || !item.str.trim()) continue;
+      item._color = colors[i] || "#000000";
     }
   }
 
@@ -271,6 +355,23 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
     return a.transform[4] - b.transform[4];
   });
 
+  // First pass: collect all vertical gaps to compute adaptive block threshold
+  const gaps = [];
+  let lastY = null;
+  let lastFontSize = 12;
+  for (const item of sorted) {
+    const y = pageHeight - item.transform[5];
+    const fontHeight = Math.hypot(item.transform[2], item.transform[3]);
+    if (fontHeight > 0) lastFontSize = fontHeight;
+    if (lastY !== null) {
+      gaps.push(Math.abs(y - lastY));
+    }
+    lastY = y;
+  }
+
+  // Compute adaptive block grouping threshold
+  const blockThreshold = findBlockThreshold(gaps, lastFontSize);
+
   const blocks = [];
   let current = null;
 
@@ -315,9 +416,10 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
       continue;
     }
 
+    // Use adaptive block threshold instead of fixed 2.5x
     if (
       sizeOk &&
-      verticalGap < lastFH * 2.5 &&
+      verticalGap < lastFH * blockThreshold &&
       x < current.bbox.x + current.bbox.w + lastFH * 1.5
     ) {
       current.items.push(item);
@@ -337,7 +439,7 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
   if (current) blocks.push(current);
 
   // Post-process: merge orphan tiny blocks (superscripts, markers like *, +, #)
-  // into the nearest larger block if vertically close
+  // into the nearest larger block if vertically close AND horizontally aligned
   for (let i = blocks.length - 1; i >= 0; i--) {
     const block = blocks[i];
     if (block.items.length > 2) continue;
@@ -354,6 +456,15 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
       // Check vertical proximity: orphan center within 30pt of target block
       const bcy = block.bbox.y + block.bbox.h / 2;
       if (bcy < o.bbox.y - 30 || bcy > o.bbox.y + o.bbox.h + 30) continue;
+      // Horizontal center alignment check - must be roughly in same column
+      const bcx = block.bbox.x + block.bbox.w / 2;
+      const ocx = o.bbox.x + o.bbox.w / 2;
+      const hCenterDist = Math.abs(bcx - ocx);
+      // Must have significant horizontal overlap or be in same column
+      const xOverlap = Math.max(0, Math.min(block.bbox.x + block.bbox.w, o.bbox.x + o.bbox.w) -
+        Math.max(block.bbox.x, o.bbox.x));
+      const inSameColumn = hCenterDist < Math.max(block.bbox.w, o.bbox.w) * 0.8 || xOverlap > 0;
+      if (!inSameColumn) continue;
       // Horizontal edge-to-edge distance (0 if overlapping)
       const hDist = Math.max(0,
         block.bbox.x > o.bbox.x + o.bbox.w ? block.bbox.x - (o.bbox.x + o.bbox.w) :
@@ -377,6 +488,83 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
     }
   }
 
+  // Post-process: detect multi-column grids (like author sections)
+  // Group blocks that form aligned columns into a single composite block
+  const multiColumnBlocks = [];
+  const processed = new Set();
+  
+  for (let i = 0; i < blocks.length; i++) {
+    if (processed.has(i)) continue;
+    const block = blocks[i];
+    const blockText = block.items.map(it => (it.str || "").trim()).join(" ");
+    const blockCenterX = block.bbox.x + block.bbox.w / 2;
+    
+    // Find all blocks in same horizontal band (similar Y position)
+    const sameRowBlocks = [block];
+    const rowY = block.bbox.y;
+    const rowH = block.bbox.h;
+    
+    for (let j = i + 1; j < blocks.length; j++) {
+      if (processed.has(j)) continue;
+      const other = blocks[j];
+      // Check if in same row (vertical overlap)
+      const yOverlap = Math.max(0, Math.min(rowY + rowH, other.bbox.y + other.bbox.h) - Math.max(rowY, other.bbox.y));
+      const minH = Math.min(rowH, other.bbox.h);
+      if (yOverlap > minH * 0.5) {
+        sameRowBlocks.push(other);
+      }
+    }
+    
+    // If we have multiple blocks in same row, this might be a multi-column layout
+    if (sameRowBlocks.length >= 2) {
+      // Sort by X position
+      sameRowBlocks.sort((a, b) => a.bbox.x - b.bbox.x);
+      // Check if they're roughly aligned (similar height, spaced evenly)
+      const avgH = sameRowBlocks.reduce((s, b) => s + b.bbox.h, 0) / sameRowBlocks.length;
+      const heightsOk = sameRowBlocks.every(b => Math.abs(b.bbox.h - avgH) < avgH * 0.5);
+      
+      if (heightsOk) {
+        // Merge into a single composite block that preserves multi-column info
+        const allItems = [];
+        for (const b of sameRowBlocks) {
+          allItems.push(...b.items);
+          processed.add(blocks.indexOf(b));
+        }
+        // Sort items by Y then X to maintain reading order within the grid
+        allItems.sort((a, b) => {
+          const ay = pageHeight - a.transform[5];
+          const by = pageHeight - b.transform[5];
+          if (Math.abs(ay - by) > 2) return ay - by;
+          return a.transform[4] - b.transform[4];
+        });
+        
+        const bbox = {
+          x: Math.min(...sameRowBlocks.map(b => b.bbox.x)),
+          y: Math.min(...sameRowBlocks.map(b => b.bbox.y)),
+          w: Math.max(...sameRowBlocks.map(b => b.bbox.x + b.bbox.w)) - Math.min(...sameRowBlocks.map(b => b.bbox.x)),
+          h: Math.max(...sameRowBlocks.map(b => b.bbox.y + b.bbox.h)) - Math.min(...sameRowBlocks.map(b => b.bbox.y))
+        };
+        
+        multiColumnBlocks.push({
+          items: allItems,
+          bbox,
+          isMultiColumn: true,
+          columnCount: sameRowBlocks.length
+        });
+        continue;
+      }
+    }
+    
+    if (!processed.has(i)) {
+      multiColumnBlocks.push(block);
+      processed.add(i);
+    }
+  }
+  
+  // Replace blocks with multi-column merged version
+  blocks.length = 0;
+  blocks.push(...multiColumnBlocks);
+
   // Compute font metadata per block using real font objects from commonObjs
   for (const block of blocks) {
     const sizes = [];
@@ -408,9 +596,7 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
     const colorFreq = {};
     for (const item of block.items) {
       const c = item._color || "#000000";
-      if (c !== "transparent") {
-        colorFreq[c] = (colorFreq[c] || 0) + 1;
-      }
+      colorFreq[c] = (colorFreq[c] || 0) + 1;
     }
     let dominantColor = "#000000";
     let maxColorFreq = 0;
@@ -451,8 +637,7 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, blockColors) {
 
 /**
  * Extract graphic regions from the page operator list.
- * Only captures image operators (paintImageXObject etc).
- * Skips path/fill/stroke to avoid false positives from text decorations.
+ * Captures images and horizontal divider lines (thin rectangles).
  */
 function extractGraphicRegions(opList, OPS) {
   const regions = [];
@@ -509,6 +694,23 @@ function extractGraphicRegions(opList, OPS) {
           bbox: { x: minX, y: minY, w: maxX - minX, h: maxY - minY },
         });
       }
+    } else if (fn === OPS.rectangle) {
+      // Check for thin horizontal lines (dividers)
+      const [x, y, w, h] = args;
+      if (w > 100 && h > 0.5 && h < 5) {
+        const corners = [
+          transformPoint(x, y),
+          transformPoint(x + w, y),
+          transformPoint(x, y + h),
+          transformPoint(x + w, y + h),
+        ];
+        const xs = corners.map(c => c[0]);
+        const ys = corners.map(c => c[1]);
+        regions.push({
+          type: "divider",
+          bbox: { x: Math.min(...xs), y: Math.min(...ys), w: Math.max(...xs) - Math.min(...xs), h: Math.max(...ys) - Math.min(...ys) },
+        });
+      }
     }
   }
 
@@ -601,37 +803,213 @@ function detectGraphicRegionsFromRender(offCanvas, textBlocks, renderScale) {
   return regions;
 }
 
+/**
+ * Find adaptive paragraph threshold by analyzing gap distribution.
+ * Uses histogram approach to find natural breakpoint between line gaps and paragraph gaps.
+ */
+function findParagraphThreshold(gaps, fontSize) {
+  if (gaps.length < 3) return 1.8;  // Fallback for small blocks
+
+  // Filter out extreme outliers (>5x font size - likely headers, titles, etc.)
+  const filtered = gaps.filter(g => g / fontSize < 5);
+  if (filtered.length < 3) return 1.8;
+
+  // Convert to font size ratios and sort
+  const ratios = filtered.map(g => g / fontSize).sort((a, b) => a - b);
+
+  // Find the largest gap between consecutive ratios (the "elbow")
+  // Look for a significant jump (>0.3) between line spacing and paragraph spacing
+  let maxGap = 0;
+  let threshold = 1.8;  // Default fallback
+
+  for (let i = 0; i < ratios.length - 1; i++) {
+    const gap = ratios[i + 1] - ratios[i];
+    // Look for significant gaps above typical line spacing (0.8x+)
+    if (gap > maxGap && gap > 0.25 && ratios[i] > 0.8) {
+      maxGap = gap;
+      threshold = (ratios[i] + ratios[i + 1]) / 2;
+    }
+  }
+
+  // If no clear cluster boundary found, use percentile-based approach
+  // 75th percentile usually separates lines from paragraphs
+  if (maxGap < 0.2) {
+    const idx = Math.floor(ratios.length * 0.75);
+    threshold = ratios[Math.min(idx, ratios.length - 1)];
+  }
+
+  // Clamp to reasonable range for paragraph detection
+  // Line spacing is typically 1.0-1.3x, paragraphs 1.3-1.8x+
+  return Math.max(1.25, Math.min(threshold, 2.2));
+}
+
 /**
  * Build text content for a block, preserving paragraph breaks.
  */
+function blockToTextMultiColumn(block, pageHeight) {
+  const rows = new Map();
+  const fontHeight = block.avgFontSize || 12;
+  
+  // Group items by row (finer granularity)
+  for (const item of block.items) {
+    if (!item.str) continue;
+    const y = pageHeight - item.transform[5];
+    const rowKey = Math.round(y / 2) * 2; // 2px granularity
+    if (!rows.has(rowKey)) rows.set(rowKey, []);
+    rows.get(rowKey).push(item);
+  }
+  
+  const sortedRows = Array.from(rows.keys()).sort((a, b) => a - b);
+  
+  // Merge rows: if a row has only short items (markers), merge with next row
+  const mergedRows = [];
+  let pendingRow = null;
+  
+  for (const rowKey of sortedRows) {
+    const rowItems = rows.get(rowKey).sort((a, b) => a.transform[4] - b.transform[4]);
+    const allShort = rowItems.every(it => (it.str || "").trim().length <= 3);
+    
+    if (allShort && rowItems.length >= 2) {
+      // This is a marker row - merge with next row
+      pendingRow = { key: rowKey, items: rowItems };
+    } else {
+      if (pendingRow) {
+        // Merge pending marker row with this row
+        // For each item in this row, find and attach the closest marker
+        const mergedItems = [];
+        for (const item of rowItems) {
+          const itemCenterX = item.transform[4] + (item.width || 0) / 2;
+          // Find closest marker
+          let closestMarker = null;
+          let minDist = Infinity;
+          for (const marker of pendingRow.items) {
+            const markerCenterX = marker.transform[4] + (marker.width || 0) / 2;
+            const dist = Math.abs(markerCenterX - itemCenterX);
+            if (dist < minDist) {
+              minDist = dist;
+              closestMarker = marker;
+            }
+          }
+          // Attach marker to item
+          if (closestMarker && minDist < 50) { // Within 50px
+            mergedItems.push({...item, str: item.str + closestMarker.str});
+          } else {
+            mergedItems.push(item);
+          }
+        }
+        mergedItems.sort((a, b) => a.transform[4] - b.transform[4]);
+        mergedRows.push({ items: mergedItems, hasMarkers: true });
+        pendingRow = null;
+      } else {
+        mergedRows.push({ items: rowItems, hasMarkers: false });
+      }
+    }
+  }
+  
+  // Don't forget last pending row
+  if (pendingRow) {
+    mergedRows.push({ items: pendingRow.items, hasMarkers: true });
+  }
+  
+  // Build output lines
+  const lines = [];
+  for (const row of mergedRows) {
+    let lineText = "";
+    let lastX = null;
+    let lastW = 0;
+    let lastItemLen = 0;
+    
+    for (const item of row.items) {
+      const currentX = item.transform[4];
+      const currentItemLen = (item.str || "").trim().length;
+      const isShortItem = currentItemLen <= 3;
+      
+      if (lastX !== null) {
+        const hGap = currentX - (lastX + lastW);
+        const prevWasLong = lastItemLen > 2;
+        // Add column separator, but not before footnote markers
+        if (hGap > fontHeight * 0.3 && (!prevWasLong || !isShortItem)) {
+          lineText += "    ";
+        }
+      }
+      
+      lineText += item.str;
+      lastX = currentX;
+      lastW = item.width || fontHeight * 0.5;
+      lastItemLen = currentItemLen;
+    }
+    lines.push(lineText.trim());
+  }
+  
+  return lines.join("\n");
+}
+
 function blockToText(block, pageHeight) {
-  let result = "";
+  // Special handling for multi-column blocks (like author grids)
+  if (block.isMultiColumn && block.columnCount >= 2) {
+    return blockToTextMultiColumn(block, pageHeight);
+  }
+
+  // First pass: collect all gaps and font sizes to compute adaptive threshold
+  const gaps = [];
   let lastY = null;
-  let lastX = null;
-  let lastW = 0;
   let lastFontSize = 12;
 
   for (const item of block.items) {
     if (!item.str) continue;
-    const currentX = item.transform[4];
     const currentY = pageHeight - item.transform[5];
     const fontHeight = Math.hypot(item.transform[2], item.transform[3]);
     if (fontHeight > 0) lastFontSize = fontHeight;
 
     if (lastY !== null) {
       const vGap = Math.abs(currentY - lastY);
-      const isShortItem = (item.str || "").trim().length <= 2;
-      if (vGap > lastFontSize * 1.8 && !isShortItem) {
+      gaps.push(vGap);
+    }
+    lastY = currentY;
+  }
+
+  // Compute adaptive paragraph threshold
+  const paraThreshold = findParagraphThreshold(gaps, lastFontSize);
+  const lineThreshold = lastFontSize * 0.3;  // Keep fixed line threshold
+
+  // Second pass: build text with adaptive threshold
+  let result = "";
+  lastY = null;
+  let lastX = null;
+  let lastW = 0;
+  let lastItemLen = 0; // Track length of previous item for marker detection
+
+  for (const item of block.items) {
+    if (!item.str) continue;
+    const currentX = item.transform[4];
+    const currentY = pageHeight - item.transform[5];
+    const currentItemLen = (item.str || "").trim().length;
+    // Short items are typically footnote markers (*, †, ‡, #, etc.)
+    // Allow up to 3 chars to handle combined markers like "* †"
+    const isShortItem = currentItemLen <= 3;
+
+    if (lastY !== null) {
+      const vGap = Math.abs(currentY - lastY);
+
+      // Use adaptive threshold for paragraph detection
+      if (vGap > lastFontSize * paraThreshold && !isShortItem) {
         result += "\n\n";
-      } else if (vGap > lastFontSize * 0.3) {
+      } else if (vGap > lineThreshold) {
         // Different line — insert space
-        if (!result.endsWith(" ") && !result.endsWith("\n")) {
-          result += " ";
+        // But skip space if previous item was long and current is short (footnote marker)
+        // This handles superscript markers like *, +, #, †, ‡
+        const prevWasLong = lastItemLen > 2;
+        if (!prevWasLong || !isShortItem) {
+          if (!result.endsWith(" ") && !result.endsWith("\n")) {
+            result += " ";
+          }
         }
       } else if (lastX !== null) {
         // Same line — check horizontal gap between items
         const hGap = currentX - (lastX + lastW);
-        if (hGap > lastFontSize * 0.15) {
+        // Skip adding space before short items (superscript markers like *, +, #, $)
+        // These are usually footnote markers that should attach directly to preceding text
+        if (hGap > lastFontSize * 0.15 && !isShortItem) {
           if (!result.endsWith(" ") && !result.endsWith("\n")) {
             result += " ";
           }
@@ -641,6 +1019,7 @@ function blockToText(block, pageHeight) {
     lastY = currentY;
     lastX = currentX;
     lastW = item.width || 0;
+    lastItemLen = currentItemLen;
     result += item.str;
   }
   return result.trim();
@@ -916,11 +1295,11 @@ async function analyzePage(page, OPS) {
   // Extract real font metadata from commonObjs (bold, italic, weight, loadedName)
   const fontMap = await extractFontMetadata(page, opList, OPS);
 
-  // Extract text colors per beginText/endText block (not per operator)
-  const blockColors = extractTextBlockColors(opList, OPS);
+  // Extract text with colors from operator list
+  const textRuns = extractTextWithColors(opList, OPS);
 
-  // Now group text blocks with real font data and block colors
-  const textBlocks = groupTextBlocks(textContent.items, pageHeight, textContent.styles, fontMap, blockColors);
+  // Now group text blocks with real font data and matched colors
+  const textBlocks = groupTextBlocks(textContent.items, pageHeight, textContent.styles, fontMap, textRuns);
 
   // Compute body font size (most common size = body text)
   const allSizes = textBlocks.map(b => Math.round(b.avgFontSize * 10) / 10);
@@ -1050,6 +1429,13 @@ function reflowAndComposite(analysis, opts) {
         colorSpans: block.colorSpans || [],
         region,
       });
+    } else if (region.type === "divider") {
+      // Horizontal divider line
+      reflowedRegions.push({
+        type: "divider",
+        height: 4, // Small height for the divider line area
+        region,
+      });
     } else {
       // Graphic
       const bitmap = bitmaps.get(region);
@@ -1307,6 +1693,23 @@ export function createReflowRenderer(container, options = {}) {
           lineCharOffset += line.text.length;
           cursorY += lh;
         }
+      } else if (r.type === "divider") {
+        // Draw horizontal divider line
+        const screenY = cursorY - scrollY + 1; // Slight offset to center in area
+        if (screenY > -10 && screenY < H + 10) {
+          const lineWidth = Math.min(400, W - padding * 2); // Max 400px or fit with padding
+          const startX = (W - lineWidth) / 2; // Center the line
+          ctx.save();
+          ctx.strokeStyle = textColor;
+          ctx.globalAlpha = 0.3;
+          ctx.lineWidth = 1 * d;
+          ctx.beginPath();
+          ctx.moveTo(startX * d, screenY * d);
+          ctx.lineTo((startX + lineWidth) * d, screenY * d);
+          ctx.stroke();
+          ctx.restore();
+        }
+        cursorY += r.height;
       } else if (r.type === "graphic" && r.bitmap) {
         const screenY = cursorY - scrollY;
         if (screenY > -r.drawH && screenY < H + r.drawH) {