pretext-pdfjs 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pretext-pdfjs",
-  "version": "0.3.4",
+  "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/reflow.js

@@ -439,7 +439,7 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, textRuns) {
   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;
@@ -456,6 +456,15 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, textRuns) {
       // 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) :
@@ -479,6 +488,83 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, textRuns) {
     }
   }
 
+  // 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 = [];
@@ -551,8 +637,7 @@ function groupTextBlocks(textItems, pageHeight, styles, fontMap, textRuns) {
 
 /**
  * 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 = [];
@@ -609,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) },
+        });
+      }
     }
   }
 
@@ -744,7 +846,110 @@ function findParagraphThreshold(gaps, fontSize) {
 /**
  * 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) {
+  // 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;
@@ -772,28 +977,39 @@ function blockToText(block, pageHeight) {
   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);
-      const isShortItem = (item.str || "").trim().length <= 2;
 
       // Use adaptive threshold for paragraph detection
       if (vGap > lastFontSize * paraThreshold && !isShortItem) {
         result += "\n\n";
       } 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 += " ";
           }
@@ -803,6 +1019,7 @@ function blockToText(block, pageHeight) {
     lastY = currentY;
     lastX = currentX;
     lastW = item.width || 0;
+    lastItemLen = currentItemLen;
     result += item.str;
   }
   return result.trim();
@@ -1212,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);
@@ -1469,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) {