formatferry 1.0.13 → 1.0.14

package/dist/index.js

@@ -19705,9 +19705,12 @@ var InputSanitizer = class {
         "table",
         "thead",
         "tbody",
+        "tfoot",
         "tr",
         "td",
         "th",
+        "figure",
+        "figcaption",
         "a",
         "img",
         "sup",
@@ -21373,7 +21376,9 @@ var _flags = {
   enableHtml: true,
   enablePdfTableDetection: true,
   enableData: true,
-  enablePptx: true
+  enablePptx: true,
+  enablePdfEnhanced: true,
+  enablePdfMultiColumn: true
 };
 function getFeatureFlags() {
   return { ..._flags };
@@ -21640,12 +21645,25 @@ function findTableRegions(items, options = {}) {
         if (best) break;
         else continue;
       }
-      const confidence = scoreCandidate(coalesced, columns);
+      const rawConfidence = scoreCandidate(coalesced, columns);
+      const bbox = computeBbox(coalesced);
+      const ruleBonus = (() => {
+        const hRules = options.ruleSeparators?.filter((r) => r.orientation === "h") ?? [];
+        if (hRules.length === 0) return 0;
+        const tol = 10;
+        const hasTop = hRules.some(
+          (r) => Math.abs(r.position - bbox.y1) <= tol && r.span[0] <= bbox.x0 + tol && r.span[1] >= bbox.x1 - tol
+        );
+        const hasBottom = hRules.some(
+          (r) => Math.abs(r.position - bbox.y0) <= tol && r.span[0] <= bbox.x0 + tol && r.span[1] >= bbox.x1 - tol
+        );
+        return (hasTop ? 0.075 : 0) + (hasBottom ? 0.075 : 0);
+      })();
+      const confidence = Math.min(1, rawConfidence + ruleBonus);
       if (confidence < MIN_CONFIDENCE_EMIT) {
         if (best) break;
         continue;
       }
-      const bbox = computeBbox(coalesced);
       const medianH = median(coalesced.flatMap((r) => r.items.map((it) => it.height))) || 0;
       const mayContinue = options.pageBottomY !== void 0 && medianH > 0 && bbox.y0 - options.pageBottomY < medianH * 2;
       best = {
@@ -21953,6 +21971,142 @@ function looksLikeHeader(row) {
   return boldish / n >= 0.5 || allCaps / n >= 0.5 || trailingColon / n >= 0.5;
 }
 
+// ../../src/shared/adapters/pdf-struct-tree-adapter.ts
+function buildMcidMap(items) {
+  const map = /* @__PURE__ */ new Map();
+  let currentId = null;
+  for (const item of items) {
+    const itemType = "type" in item ? item.type : void 0;
+    if (itemType === "beginMarkedContentProps") {
+      const mc = item;
+      if (mc.id != null) {
+        currentId = mc.id;
+        if (!map.has(currentId)) map.set(currentId, "");
+      }
+    } else if (itemType === "endMarkedContent") {
+      currentId = null;
+    } else if ("str" in item && currentId !== null) {
+      const existing = map.get(currentId) ?? "";
+      map.set(currentId, existing + item.str);
+    }
+  }
+  return map;
+}
+function countNodes(node, limit) {
+  let n = 1;
+  if ("children" in node && node.children) {
+    for (const child of node.children) {
+      n += countNodes(child, limit);
+      if (n >= limit) return n;
+    }
+  }
+  return n;
+}
+function esc(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function isContent(node) {
+  return "id" in node && !("role" in node);
+}
+function walkChildren(children, mcidMap, depth) {
+  return children.map((c) => walkNode(c, mcidMap, depth)).join("");
+}
+function walkNode(node, mcidMap, depth = 0) {
+  if (depth > 50) return "";
+  if (isContent(node)) {
+    const text = mcidMap.get(node.id) ?? "";
+    return esc(text);
+  }
+  const children = node.children ?? [];
+  const inner = walkChildren(children, mcidMap, depth + 1);
+  switch (node.role) {
+    case "H":
+      return `<h1>${inner}</h1>`;
+    case "H1":
+      return `<h1>${inner}</h1>`;
+    case "H2":
+      return `<h2>${inner}</h2>`;
+    case "H3":
+      return `<h3>${inner}</h3>`;
+    case "H4":
+      return `<h4>${inner}</h4>`;
+    case "H5":
+      return `<h5>${inner}</h5>`;
+    case "H6":
+      return `<h6>${inner}</h6>`;
+    case "P":
+      return inner ? `<p>${inner}</p>` : "";
+    case "L":
+      return inner ? `<ul>${inner}</ul>` : "";
+    case "LI":
+      return inner ? `<li>${inner}</li>` : "";
+    case "Lbl":
+      return inner ? `<span>${inner}</span> ` : "";
+    case "LBody":
+      return inner;
+    case "Table":
+      return inner ? `<table>${inner}</table>` : "";
+    case "THead":
+      return inner ? `<thead>${inner}</thead>` : "";
+    case "TBody":
+      return inner ? `<tbody>${inner}</tbody>` : "";
+    case "TFoot":
+      return inner ? `<tfoot>${inner}</tfoot>` : "";
+    case "TR":
+      return inner ? `<tr>${inner}</tr>` : "";
+    case "TH":
+      return `<th>${inner}</th>`;
+    case "TD":
+      return `<td>${inner}</td>`;
+    case "Figure": {
+      const alt = node.alt ?? "";
+      const caption = alt ? `<figcaption>${esc(alt)}</figcaption>` : "";
+      return `<figure>${caption}${inner}</figure>`;
+    }
+    case "BlockQuote":
+      return inner ? `<blockquote>${inner}</blockquote>` : "";
+    case "Code":
+      return inner ? `<code>${inner}</code>` : "";
+    // Inline / passthrough roles
+    case "Span":
+    case "Link":
+    case "Reference":
+    case "Note":
+    case "Annot":
+    case "Strong":
+    case "Em":
+    case "Sub":
+    case "Sup":
+      return inner;
+    // Grouping roles — just pass through children
+    default:
+      return inner;
+  }
+}
+async function structTreeToHtml(page) {
+  let structTree;
+  try {
+    structTree = await page.getStructTree();
+  } catch {
+    return null;
+  }
+  if (!structTree || !structTree.children || structTree.children.length === 0) {
+    return null;
+  }
+  if (countNodes(structTree, 5) < 5) return null;
+  let textContent;
+  try {
+    textContent = await page.getTextContent({ includeMarkedContent: true });
+  } catch {
+    return null;
+  }
+  const mcidMap = buildMcidMap(textContent.items);
+  const html = walkNode(structTree, mcidMap);
+  const textOnly = html.replace(/<[^>]+>/g, "").trim();
+  if (!textOnly) return null;
+  return html;
+}
+
 // ../../src/shared/adapters/pdf-adapter.ts
 var PdfParseError = class extends Error {
   constructor(message, code, originalError) {
@@ -21969,6 +22123,52 @@ var FORM_LABEL_GAP_FACTOR = 3;
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
+function computeFontSize(transform) {
+  return Math.sqrt(transform[2] ** 2 + transform[3] ** 2);
+}
+function normalizeLigatures(text) {
+  return text.normalize("NFC").replace(/ff/g, "ff").replace(/fi/g, "fi").replace(/fl/g, "fl").replace(/ffi/g, "ffi").replace(/ffl/g, "ffl");
+}
+function hasStructTree(page) {
+  return typeof page.getStructTree === "function";
+}
+function isSafeUrl(url) {
+  return /^(?:https?|mailto|ftp):/i.test(url);
+}
+function detectFontStyle(fontName) {
+  if (!fontName) return null;
+  const bold = /(Bold|Black|Heavy|Semibold|Demi)/i.test(fontName) && !/Blackletter/i.test(fontName);
+  const italic = /(Italic|Oblique|Slanted)/i.test(fontName);
+  if (bold && italic) return "bold-italic";
+  if (bold) return "bold";
+  if (italic) return "italic";
+  return null;
+}
+function buildOutlineSet(outline) {
+  const set = /* @__PURE__ */ new Set();
+  if (!outline) return set;
+  function walk(items) {
+    for (const item of items) {
+      if (item.title) {
+        set.add(normalizeLigatures(item.title).replace(/\s+/g, " ").trim().toLowerCase());
+      }
+      if (item.items) walk(item.items);
+    }
+  }
+  walk(outline);
+  return set;
+}
+function fuzzyMatchOutline(text, outlineTitles) {
+  if (outlineTitles.size === 0) return false;
+  for (const title of outlineTitles) {
+    if (title.length < 3) continue;
+    if (text.includes(title) || title.includes(text)) {
+      const ratio = Math.min(text.length, title.length) / Math.max(text.length, title.length);
+      if (ratio >= 0.8) return true;
+    }
+  }
+  return false;
+}
 function detectRotation(transform) {
   const EPS = 1e-3;
   const [sx, shy, shx, sy] = transform;
@@ -21992,6 +22192,7 @@ function textItemToPositioned(item) {
   const descent = height * DESCENDER_BUDGET_FACTOR;
   const y = ty - descent;
   const paddedHeight = height + descent;
+  const fs = computeFontSize(item.transform);
   return {
     str: item.str,
     x: tx,
@@ -22001,7 +22202,8 @@ function textItemToPositioned(item) {
     right: tx + width,
     rotation,
     fontName: item.fontName,
-    source: "text"
+    source: "text",
+    fontSize: fs > 0 ? fs : rawHeight > 0 ? rawHeight : void 0
   };
 }
 function widgetToPositionedItems(ann) {
@@ -22101,9 +22303,309 @@ function itemsToLinearText(items) {
   }
   return lines.join("\n").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
 }
-function renderPage(items, pageNum, nextPageNum, enableTableDetection, translate, pageBottomY) {
+function renderTextBlockEnhanced(items, medianPageFontSize, outlineTitles) {
+  if (items.length === 0) return { htmlBlocks: [], textContent: "" };
+  const sorted = [...items].sort(
+    (a, b) => b.y + b.height - (a.y + a.height) || a.x - b.x
+  );
+  const rows = [];
+  for (const it of sorted) {
+    const last = rows[rows.length - 1];
+    if (last && last.some(
+      (li) => Math.max(
+        0,
+        Math.min(li.y + li.height, it.y + it.height) - Math.max(li.y, it.y)
+      ) / Math.max(Math.min(li.height, it.height), 1e-6) >= 0.5
+    )) {
+      last.push(it);
+    } else {
+      rows.push([it]);
+    }
+  }
+  const htmlBlocks = [];
+  const textLines = [];
+  const col3Rows = getFeatureFlags().enablePdfMultiColumn ? detectAndReorderColumns(rows) : rows;
+  const finalRows = repairRowHyphenation(col3Rows);
+  let pendingListKind = null;
+  const pendingListHtml = [];
+  const flushPendingList = () => {
+    if (pendingListHtml.length === 0) return;
+    const tag = pendingListKind === "ol" ? "ol" : "ul";
+    htmlBlocks.push(`<${tag}>${pendingListHtml.join("")}</${tag}>`);
+    pendingListKind = null;
+    pendingListHtml.length = 0;
+  };
+  for (const row of finalRows) {
+    row.sort((a, b) => a.x - b.x);
+    const fsSamples = row.map((it) => it.fontSize ?? 0).filter((f) => f > 0);
+    const rowFs = fsSamples.length > 0 ? [...fsSamples].sort((a, b) => a - b)[Math.floor(fsSamples.length / 2)] : medianPageFontSize;
+    const rowWidths = row.map((it) => it.str.length > 0 ? it.width / it.str.length : 0).filter((w) => w > 0);
+    const rowMedianCharWidth = rowWidths.length ? [...rowWidths].sort((a, b) => a - b)[Math.floor(rowWidths.length / 2)] || 1 : 1;
+    const rowLabelGap = rowMedianCharWidth * FORM_LABEL_GAP_FACTOR;
+    let plainText = "";
+    let inlineHtml = "";
+    let hasAnyStyle = false;
+    for (let i = 0; i < row.length; i++) {
+      const it = row[i];
+      let sep = "";
+      if (i > 0) {
+        const prev = row[i - 1];
+        const gap = it.x - prev.right;
+        const prevStr = prev.str.trimEnd();
+        sep = /:$/.test(prevStr) && gap > rowLabelGap ? "\xA0\xA0" : " ";
+      }
+      plainText += sep + it.str;
+      const escaped = escapeHtml(normalizeLigatures(it.str));
+      const style = detectFontStyle(it.fontName);
+      if (style) hasAnyStyle = true;
+      let styledPart = style === "bold-italic" ? `<strong><em>${escaped}</em></strong>` : style === "bold" ? `<strong>${escaped}</strong>` : style === "italic" ? `<em>${escaped}</em>` : escaped;
+      if (it.linkUrl && isSafeUrl(it.linkUrl)) {
+        styledPart = `<a href="${escapeHtml(it.linkUrl)}">${styledPart}</a>`;
+      }
+      inlineHtml += (i > 0 ? escapeHtml(sep) : "") + styledPart;
+    }
+    plainText = plainText.replace(/[ \t]+/g, " ").trim();
+    if (!plainText) continue;
+    const normalizedPlain = normalizeLigatures(plainText);
+    const normalized = normalizedPlain.replace(/\s+/g, " ").trim().toLowerCase();
+    if (getFeatureFlags().enablePdfEnhanced) {
+      const listMatch = detectListMarker(normalizedPlain);
+      if (listMatch) {
+        if (pendingListKind !== null && pendingListKind !== listMatch.kind) {
+          flushPendingList();
+        }
+        pendingListKind = listMatch.kind;
+        const escapedBody = escapeHtml(normalizeLigatures(listMatch.bodyText));
+        pendingListHtml.push(`<li>${escapedBody}</li>`);
+        textLines.push(normalizedPlain);
+        continue;
+      }
+    }
+    flushPendingList();
+    const ratio = medianPageFontSize > 0 ? rowFs / medianPageFontSize : 1;
+    let headingLevel = 0;
+    if (ratio >= 1.5) headingLevel = 1;
+    else if (ratio >= 1.25) headingLevel = 2;
+    else if (ratio >= 1.1) headingLevel = 3;
+    if (headingLevel === 0 && outlineTitles.size > 0) {
+      if (outlineTitles.has(normalized) || fuzzyMatchOutline(normalized, outlineTitles)) {
+        headingLevel = 2;
+      }
+    }
+    textLines.push(normalizedPlain);
+    if (headingLevel > 0) {
+      htmlBlocks.push(`<h${headingLevel}>${inlineHtml}</h${headingLevel}>`);
+    } else {
+      const hasWideGap = /( {3,}|\u00A0\u00A0|\t)/.test(normalizedPlain);
+      const isShort = normalizedPlain.length < 100 && !/[.,:;!?]$/.test(normalizedPlain) && !/\n/.test(normalizedPlain) && !hasWideGap;
+      if (isShort && !hasAnyStyle) {
+        htmlBlocks.push(`<p><strong>${inlineHtml}</strong></p>`);
+      } else {
+        htmlBlocks.push(`<p>${inlineHtml}</p>`);
+      }
+    }
+  }
+  flushPendingList();
+  return {
+    htmlBlocks,
+    textContent: textLines.join("\n").replace(/[ \t]+/g, " ").replace(/\n{3,}/g, "\n\n").trim()
+  };
+}
+function repairRowHyphenation(rows) {
+  if (rows.length < 2) return rows;
+  const result = [];
+  let i = 0;
+  while (i < rows.length) {
+    if (i + 1 < rows.length) {
+      const row = rows[i];
+      const nextRow = rows[i + 1];
+      const lastItem = [...row].sort((a, b) => b.right - a.right)[0];
+      const firstNext = [...nextRow].sort((a, b) => a.x - b.x)[0];
+      if (lastItem && firstNext && /-$/.test(lastItem.str) && new RegExp("^\\p{Ll}", "u").test(firstNext.str)) {
+        const fixed = { ...lastItem, str: lastItem.str.slice(0, -1) };
+        result.push([...row.map((it) => it === lastItem ? fixed : it), ...nextRow]);
+        i += 2;
+        continue;
+      }
+    }
+    result.push(rows[i]);
+    i++;
+  }
+  return result;
+}
+function detectListMarker(plainText) {
+  const bulletMatch = /^[•◦◆▪▸–\-*·]\s+(.+)/u.exec(plainText);
+  if (bulletMatch) return { kind: "ul", bodyText: bulletMatch[1] };
+  const numberedMatch = /^\d+[.)]\s+(.+)/.exec(plainText);
+  if (numberedMatch) return { kind: "ol", bodyText: numberedMatch[1] };
+  const letteredMatch = /^[a-z][.)]\s+(.+)/.exec(plainText);
+  if (letteredMatch) return { kind: "ol", bodyText: letteredMatch[1] };
+  return null;
+}
+function detectAndReorderColumns(rows) {
+  if (rows.length < 4) return rows;
+  const allItems = rows.flat();
+  const itemWidths = allItems.filter((it) => it.width > 0 && it.str.trim().length > 0).map((it) => it.width);
+  if (itemWidths.length === 0) return rows;
+  const sortedWidths = [...itemWidths].sort((a, b) => a - b);
+  const medianWidth = sortedWidths[Math.floor(sortedWidths.length / 2)];
+  const gutterThreshold = medianWidth * 3;
+  const xMin = allItems.reduce((m, it) => Math.min(m, it.x), Infinity);
+  const xMax = allItems.reduce((m, it) => Math.max(m, it.right), -Infinity);
+  const midLeft = xMin + (xMax - xMin) * 0.25;
+  const midRight = xMin + (xMax - xMin) * 0.75;
+  const gutterMidpoints = [];
+  for (const row of rows) {
+    if (row.length < 2) continue;
+    const rowSorted = [...row].sort((a, b) => a.x - b.x);
+    for (let i = 1; i < rowSorted.length; i++) {
+      const prev = rowSorted[i - 1];
+      const curr = rowSorted[i];
+      const gap = curr.x - prev.right;
+      if (gap < gutterThreshold) continue;
+      const midX = (prev.right + curr.x) / 2;
+      if (midX >= midLeft && midX <= midRight) {
+        gutterMidpoints.push(midX);
+        break;
+      }
+    }
+  }
+  const multiItemRowCount = rows.filter((r) => r.length >= 2).length;
+  const minVotes = Math.max(2, Math.ceil(multiItemRowCount * 0.35));
+  if (gutterMidpoints.length < minVotes) return rows;
+  const sortedGutters = [...gutterMidpoints].sort((a, b) => a - b);
+  const gutterX = sortedGutters[Math.floor(sortedGutters.length / 2)];
+  const leftRows = [];
+  const rightRows = [];
+  for (const row of rows) {
+    const leftItems = row.filter((it) => it.x + it.width / 2 <= gutterX);
+    const rightItems = row.filter((it) => it.x + it.width / 2 > gutterX);
+    if (leftItems.length > 0) leftRows.push(leftItems);
+    if (rightItems.length > 0) rightRows.push(rightItems);
+  }
+  if (leftRows.length < 2 || rightRows.length < 2) return rows;
+  const sortTopDown = (arr) => [...arr].sort((a, b) => {
+    const aTop = a.reduce((m, it) => Math.max(m, it.y + it.height), -Infinity);
+    const bTop = b.reduce((m, it) => Math.max(m, it.y + it.height), -Infinity);
+    return bTop - aTop;
+  });
+  return [...sortTopDown(leftRows), ...sortTopDown(rightRows)];
+}
+function buildHeaderFooterSuppressSet(pageDataArray) {
+  const totalPages = pageDataArray.length;
+  if (totalPages < 3) return /* @__PURE__ */ new Set();
+  const HEADER_THRESHOLD = 0.92;
+  const FOOTER_THRESHOLD = 0.08;
+  const Y_TOLERANCE = 5;
+  const MIN_PAGE_FRACTION = 0.4;
+  const occurrences = /* @__PURE__ */ new Map();
+  for (const { pageNum, items, viewportHeight } of pageDataArray) {
+    for (const it of items) {
+      const itemTop = it.y + it.height;
+      const inHeader = itemTop > viewportHeight * HEADER_THRESHOLD;
+      const inFooter = it.y < viewportHeight * FOOTER_THRESHOLD;
+      if (!inHeader && !inFooter) continue;
+      const normalized = it.str.replace(/\s+/g, " ").trim().toLowerCase();
+      if (normalized.length === 0) continue;
+      const yBucket = Math.round(it.y / Y_TOLERANCE) * Y_TOLERANCE;
+      const key = `${normalized}@${yBucket}`;
+      if (!occurrences.has(key)) occurrences.set(key, /* @__PURE__ */ new Set());
+      occurrences.get(key).add(pageNum);
+    }
+  }
+  const suppressSet = /* @__PURE__ */ new Set();
+  for (const [key, pageSet] of occurrences) {
+    if (pageSet.size / totalPages >= MIN_PAGE_FRACTION) {
+      suppressSet.add(key);
+    }
+  }
+  return suppressSet;
+}
+function isHeaderFooterItem(it, suppressSet, Y_TOLERANCE = 5) {
+  if (suppressSet.size === 0) return false;
+  const normalized = it.str.replace(/\s+/g, " ").trim().toLowerCase();
+  if (normalized.length === 0) return false;
+  const yBucket = Math.round(it.y / Y_TOLERANCE) * Y_TOLERANCE;
+  return suppressSet.has(`${normalized}@${yBucket}`);
+}
+var PDF_OP = { moveTo: 13, lineTo: 14, closePath: 18, rectangle: 92 };
+function extractVectorLines(fnArray, argsArray, pageWidth, pageHeight) {
+  const MIN_H_SPAN = pageWidth * 0.3;
+  const MIN_V_SPAN = pageHeight * 0.3;
+  const lines = [];
+  let curX = 0;
+  let curY = 0;
+  let pathStartX = 0;
+  let pathStartY = 0;
+  const pushIfSignificant = (x0, y0, x1, y1) => {
+    const dx = Math.abs(x1 - x0);
+    const dy = Math.abs(y1 - y0);
+    if (dy < 2 && dx >= MIN_H_SPAN) {
+      lines.push({
+        orientation: "h",
+        position: (y0 + y1) / 2,
+        span: [Math.min(x0, x1), Math.max(x0, x1)]
+      });
+    } else if (dx < 2 && dy >= MIN_V_SPAN) {
+      lines.push({
+        orientation: "v",
+        position: (x0 + x1) / 2,
+        span: [Math.min(y0, y1), Math.max(y0, y1)]
+      });
+    }
+  };
+  for (let i = 0; i < fnArray.length; i++) {
+    const op = fnArray[i];
+    const args = argsArray[i] ?? [];
+    if (op === PDF_OP.moveTo) {
+      curX = args[0] ?? 0;
+      curY = args[1] ?? 0;
+      pathStartX = curX;
+      pathStartY = curY;
+    } else if (op === PDF_OP.lineTo) {
+      const nx = args[0] ?? 0;
+      const ny = args[1] ?? 0;
+      pushIfSignificant(curX, curY, nx, ny);
+      curX = nx;
+      curY = ny;
+    } else if (op === PDF_OP.rectangle) {
+      const rx = args[0] ?? 0;
+      const ry = args[1] ?? 0;
+      const rw = args[2] ?? 0;
+      const rh = args[3] ?? 0;
+      pushIfSignificant(rx, ry, rx + rw, ry);
+      pushIfSignificant(rx, ry + rh, rx + rw, ry + rh);
+      pushIfSignificant(rx, ry, rx, ry + rh);
+      pushIfSignificant(rx + rw, ry, rx + rw, ry + rh);
+    } else if (op === PDF_OP.closePath) {
+      pushIfSignificant(curX, curY, pathStartX, pathStartY);
+      curX = pathStartX;
+      curY = pathStartY;
+    }
+  }
+  return lines;
+}
+function applyLinkAnnotations(items, annotations) {
+  const linkAnns = annotations.filter(
+    (a) => a.subtype === "Link" && a.url && a.rect && a.rect.length === 4
+  );
+  if (linkAnns.length === 0) return;
+  for (const it of items) {
+    const itArea = Math.max(it.width * it.height, 1e-6);
+    for (const ann of linkAnns) {
+      const [llx, lly, urx, ury] = ann.rect;
+      const ox = Math.max(0, Math.min(it.right, urx) - Math.max(it.x, llx));
+      const oy = Math.max(0, Math.min(it.y + it.height, ury) - Math.max(it.y, lly));
+      if (ox * oy / itArea >= 0.2) {
+        it.linkUrl = ann.url;
+        break;
+      }
+    }
+  }
+}
+function renderPage(items, pageNum, nextPageNum, enableTableDetection, translate, pageBottomY, enhancedOpts, ruleSeparators) {
   const warnings = [];
-  const candidates = enableTableDetection ? findTableRegions(items, { pageBottomY }) : [];
+  const candidates = enableTableDetection ? findTableRegions(items, { pageBottomY, ruleSeparators }) : [];
   const htmlBlocks = [];
   const candsByY = [...candidates].sort((a, b) => b.bbox.y1 - a.bbox.y1);
   const itemOverlapsCandidate = (it, c) => {
@@ -22167,36 +22669,46 @@ function renderPage(items, pageNum, nextPageNum, enableTableDetection, translate
       }
       linearTextParts.push(tableToText(block.cand));
     } else {
-      const text = itemsToLinearText(block.items);
-      if (!text) continue;
-      linearTextParts.push(text);
-      const medH = (() => {
-        const hs = block.items.map((i) => i.height).filter((h) => h > 0);
-        if (hs.length === 0) return 10;
-        return hs.sort((a, b) => a - b)[Math.floor(hs.length / 2)] || 10;
-      })();
-      const topY = block.items.reduce(
-        (m, it) => Math.max(m, it.y + it.height),
-        -Infinity
-      );
-      const topRowItems = block.items.filter(
-        (it) => topY - (it.y + it.height) <= medH * 0.5
-      );
-      const topRowLooksTabular = topRowItems.length >= 4 && topRowItems.some((a) => topRowItems.some((b) => b.x - a.right > medH * 2));
-      const paragraphs = text.split(/\n{2,}/);
-      let paraIdx = 0;
-      for (const para of paragraphs) {
-        const trimmed = para.trim();
-        paraIdx++;
-        if (!trimmed) continue;
-        const hasWideGap = /( {3,}|\u00A0\u00A0|\t)/.test(trimmed);
-        const isFirstPara = paraIdx === 1;
-        const looksTabular = hasWideGap || isFirstPara && topRowLooksTabular;
-        const short = trimmed.length < 100 && !/[.,:;!?]$/.test(trimmed) && !/\n/.test(trimmed) && !looksTabular;
-        if (short) {
-          htmlBlocks.push(`<p><strong>${escapeHtml(trimmed)}</strong></p>`);
-        } else {
-          htmlBlocks.push(`<p>${escapeHtml(trimmed)}</p>`);
+      if (enhancedOpts) {
+        const { htmlBlocks: eBlocks, textContent: eText } = renderTextBlockEnhanced(
+          block.items,
+          enhancedOpts.medianFontSize,
+          enhancedOpts.outlineTitles
+        );
+        if (eText) linearTextParts.push(eText);
+        for (const b of eBlocks) htmlBlocks.push(b);
+      } else {
+        const text = itemsToLinearText(block.items);
+        if (!text) continue;
+        linearTextParts.push(text);
+        const medH = (() => {
+          const hs = block.items.map((i) => i.height).filter((h) => h > 0);
+          if (hs.length === 0) return 10;
+          return hs.sort((a, b) => a - b)[Math.floor(hs.length / 2)] || 10;
+        })();
+        const topY = block.items.reduce(
+          (m, it) => Math.max(m, it.y + it.height),
+          -Infinity
+        );
+        const topRowItems = block.items.filter(
+          (it) => topY - (it.y + it.height) <= medH * 0.5
+        );
+        const topRowLooksTabular = topRowItems.length >= 4 && topRowItems.some((a) => topRowItems.some((b) => b.x - a.right > medH * 2));
+        const paragraphs = text.split(/\n{2,}/);
+        let paraIdx = 0;
+        for (const para of paragraphs) {
+          const trimmed = para.trim();
+          paraIdx++;
+          if (!trimmed) continue;
+          const hasWideGap = /( {3,}|\u00A0\u00A0|\t)/.test(trimmed);
+          const isFirstPara = paraIdx === 1;
+          const looksTabular = hasWideGap || isFirstPara && topRowLooksTabular;
+          const short = trimmed.length < 100 && !/[.,:;!?]$/.test(trimmed) && !/\n/.test(trimmed) && !looksTabular;
+          if (short) {
+            htmlBlocks.push(`<p><strong>${escapeHtml(trimmed)}</strong></p>`);
+          } else {
+            htmlBlocks.push(`<p>${escapeHtml(trimmed)}</p>`);
+          }
         }
       }
     }
@@ -22292,6 +22804,43 @@ var PdfAdapter = class {
         }
       } catch {
       }
+      let isTaggedPdf = false;
+      let outlineTitles = /* @__PURE__ */ new Set();
+      if (getFeatureFlags().enablePdfEnhanced) {
+        try {
+          const markInfo = await pdf.getMarkInfo();
+          isTaggedPdf = markInfo?.Marked === true;
+        } catch {
+        }
+        try {
+          const outline = await pdf.getOutline();
+          outlineTitles = buildOutlineSet(outline);
+        } catch {
+        }
+      }
+      let hfSuppressSet = /* @__PURE__ */ new Set();
+      if (getFeatureFlags().enablePdfEnhanced && numPages >= 3 && numPages <= 200) {
+        const hfCandidates = [];
+        for (let pn = 1; pn <= numPages; pn++) {
+          try {
+            const hfPage = await pdf.getPage(pn);
+            const hfViewport = hfPage.getViewport({ scale: 1 });
+            const hfText = await hfPage.getTextContent();
+            const hfAnns = await hfPage.getAnnotations().catch(() => []);
+            const hfPositioned = [];
+            for (const item of hfText.items) {
+              if (!("str" in item) || typeof item.str !== "string") continue;
+              const p = textItemToPositioned(item);
+              if (p) hfPositioned.push(p);
+            }
+            const hfWidgets = hfAnns.flatMap(widgetToPositionedItems);
+            const hfItems = hfWidgets.length > 0 ? [...dedupAgainstWidgets(hfPositioned, hfWidgets), ...hfWidgets] : hfPositioned;
+            hfCandidates.push({ pageNum: pn, items: hfItems, viewportHeight: hfViewport.height });
+          } catch {
+          }
+        }
+        hfSuppressSet = buildHeaderFooterSuppressSet(hfCandidates);
+      }
       for (let pageNum = 1; pageNum <= numPages; pageNum++) {
         onProgress?.(pageNum / numPages);
         const page = await pdf.getPage(pageNum);
@@ -22314,14 +22863,75 @@ var PdfAdapter = class {
         }
         const widgetItems = annotations.flatMap(widgetToPositionedItems);
         const items = widgetItems.length > 0 ? [...dedupAgainstWidgets(positionedText, widgetItems), ...widgetItems] : positionedText;
+        if (getFeatureFlags().enablePdfEnhanced) {
+          applyLinkAnnotations(items, annotations);
+        }
+        const renderItems = getFeatureFlags().enablePdfEnhanced && hfSuppressSet.size > 0 ? items.filter((it) => !isHeaderFooterItem(it, hfSuppressSet)) : items;
+        if (getFeatureFlags().enablePdfEnhanced && isTaggedPdf) {
+          let structHtml = null;
+          try {
+            if (hasStructTree(page)) {
+              structHtml = await structTreeToHtml(page);
+            }
+          } catch {
+          }
+          if (structHtml !== null) {
+            const structTextLen = structHtml.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim().length;
+            const geoTextLen = renderItems.map((it) => it.str).join(" ").length;
+            if (geoTextLen > 0 && structTextLen / geoTextLen < 0.7) {
+              structHtml = null;
+            }
+          }
+          if (structHtml !== null) {
+            const plainText = structHtml.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+            totalTextLength += plainText.length;
+            let hasImages2 = false;
+            try {
+              const opList = await page.getOperatorList();
+              hasImages2 = opList.fnArray.some((op) => op === 85 || op === 86);
+            } catch {
+            }
+            pages.push({
+              pageNumber: pageNum,
+              textContent: plainText,
+              hasImages: hasImages2,
+              viewportWidth: viewport.width,
+              htmlBlocks: [structHtml],
+              tablesDetected: 0
+            });
+            continue;
+          }
+        }
+        let enhancedOpts;
+        if (getFeatureFlags().enablePdfEnhanced) {
+          const fsSamples = positionedText.map((it) => it.fontSize ?? 0).filter((f) => f > 0);
+          const medianFontSize = fsSamples.length > 0 ? [...fsSamples].sort((a, b) => a - b)[Math.floor(fsSamples.length / 2)] : 12;
+          enhancedOpts = { medianFontSize, outlineTitles };
+        }
         const pageBottomY = Array.isArray(page.view) && page.view.length >= 2 ? page.view[1] : 0;
+        let pageOpList;
+        let ruleSeparators;
+        try {
+          pageOpList = await page.getOperatorList();
+          if (getFeatureFlags().enablePdfEnhanced && tableDetectionEnabled) {
+            ruleSeparators = extractVectorLines(
+              pageOpList.fnArray,
+              pageOpList.argsArray ?? [],
+              viewport.width,
+              viewport.height
+            );
+          }
+        } catch {
+        }
         const rendered = renderPage(
-          items,
+          renderItems,
           pageNum,
           pageNum < numPages ? pageNum + 1 : void 0,
           tableDetectionEnabled,
           translate,
-          pageBottomY
+          pageBottomY,
+          enhancedOpts,
+          ruleSeparators
         );
         for (const w of rendered.warnings) warnings.push(w);
         if (!hasMultiColumnWarning && !rendered.anyTableDetected && xPositions.length > 10) {
@@ -22345,12 +22955,7 @@ var PdfAdapter = class {
           }
         }
         totalTextLength += rendered.textContent.length;
-        let hasImages = false;
-        try {
-          const operatorList = await page.getOperatorList();
-          hasImages = operatorList.fnArray.some((op) => op === 85 || op === 86);
-        } catch {
-        }
+        const hasImages = pageOpList?.fnArray.some((op) => op === 85 || op === 86) ?? false;
         pages.push({
           pageNumber: pageNum,
           textContent: rendered.textContent,
@@ -24689,8 +25294,8 @@ import { readFileSync as readFileSync4 } from "fs";
 import { resolve, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var getVersion = () => {
-  if ("1.0.13") {
-    return "1.0.13";
+  if ("1.0.14") {
+    return "1.0.14";
   }
   try {
     const __dirname = dirname3(fileURLToPath(import.meta.url));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formatferry",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "FormatFerry CLI — Convert HTML, DOCX, PDF, XLSX, CSV, JSON, XML, PPTX to Markdown",
   "keywords": [
     "markdown",