formatferry 1.0.12 → 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",
@@ -20376,6 +20379,9 @@ var ConversionEngine = class {
     this.addPdfPageMarkerRules(this.githubService);
     this.addPdfPageMarkerRules(this.commonmarkService);
     this.addPdfPageMarkerRules(this.customService);
+    this.addSlideMarkerRules(this.githubService);
+    this.addSlideMarkerRules(this.commonmarkService);
+    this.addSlideMarkerRules(this.customService);
     this.discordService = this.createDiscordService();
     this.redditService = this.createRedditService();
     this.rmarkdownService = this.createRMarkdownService();
@@ -20386,6 +20392,8 @@ var ConversionEngine = class {
     };
     this.slackService = createSlackService(deps);
     this.confluenceService = createConfluenceService(deps);
+    this.addSlideMarkerRules(this.slackService);
+    this.addSlideMarkerRules(this.confluenceService);
   }
   /**
    * Create Discord-optimized Turndown service
@@ -20405,6 +20413,7 @@ var ConversionEngine = class {
     this.addGoogleDocsRules(service);
     this.addListRules(service);
     this.addPdfPageMarkerRules(service);
+    this.addSlideMarkerRules(service);
     service.addRule("discordUnderline", {
       filter: ["u", "ins"],
       replacement: (content) => content.trim() ? `__${content}__` : content
@@ -20583,6 +20592,7 @@ ${plainText}
     this.addTableRules(service);
     this.addListRules(service);
     this.addPdfPageMarkerRules(service);
+    this.addSlideMarkerRules(service);
     service.addRule("redditSuperscript", {
       filter: (node) => node.nodeName === "SUP",
       replacement: (content) => {
@@ -20641,6 +20651,7 @@ ${plainText}
     this.addTableRules(service);
     this.addListRules(service);
     this.addPdfPageMarkerRules(service);
+    this.addSlideMarkerRules(service);
     service.addRule("rmdSuperscript", {
       filter: (node) => node.nodeName === "SUP",
       replacement: (content) => {
@@ -20924,6 +20935,21 @@ ${plainText}
     });
     return markdown;
   }
+  addSlideMarkerRules(service) {
+    service.addRule("pptxSlideMarker", {
+      filter: (node) => node.nodeName === "DIV" && node.hasAttribute("data-slide-marker"),
+      replacement: (_content, node) => {
+        const slideNumber = node.getAttribute("data-slide-marker");
+        return `
+
+---
+
+**[Slide ${slideNumber}]**
+
+`;
+      }
+    });
+  }
   /**
    * Add PDF page marker rules to convert data-page-marker divs to Markdown comments
    * This preserves page boundaries from PDF documents (Req 3.5)
@@ -21348,7 +21374,11 @@ var _flags = {
   enableXlsx: true,
   enablePdf: true,
   enableHtml: true,
-  enablePdfTableDetection: true
+  enablePdfTableDetection: true,
+  enableData: true,
+  enablePptx: true,
+  enablePdfEnhanced: true,
+  enablePdfMultiColumn: true
 };
 function getFeatureFlags() {
   return { ..._flags };
@@ -21453,17 +21483,21 @@ function clusterIntoRows(items) {
 }
 function detectColumns(rows) {
   if (rows.length === 0) return [];
-  const allItems = rows.flatMap((r) => r.items);
+  const columnRows = selectColumnRows(rows);
+  if (columnRows.length < 2) return [];
+  const allItems = columnRows.flatMap((r) => r.items);
   if (allItems.length === 0) return [];
   const medianCharWidth = median(allItems.map((it) => estimateCharWidth(it)).filter((w) => w > 0)) || 1;
   const gapTol = medianCharWidth * COLUMN_GAP_MERGE_FACTOR;
-  const hardBoundaries = voteColumnBoundaries(rows, medianCharWidth);
+  const separationGap = Math.max(gapTol, medianCharWidth * 1.5);
+  const hardBoundaries = voteColumnBoundaries(columnRows, medianCharWidth);
   const intervals = allItems.map((it) => ({ x0: it.x, x1: it.right })).sort((a, b) => a.x0 - b.x0);
   const merged = [];
   for (const iv of intervals) {
     const last = merged[merged.length - 1];
     const crossesHardBoundary = last !== void 0 && hardBoundaries.some((b) => b >= last.x1 && b <= iv.x0);
-    if (last && iv.x0 - last.x1 <= gapTol && !crossesHardBoundary) {
+    const hasStrongRowSeparation = last !== void 0 && hasConsistentRowSeparation(columnRows, last, iv, separationGap);
+    if (last && iv.x0 - last.x1 <= gapTol && !crossesHardBoundary && !hasStrongRowSeparation) {
       last.x1 = Math.max(last.x1, iv.x1);
     } else {
       merged.push({ ...iv });
@@ -21471,16 +21505,50 @@ function detectColumns(rows) {
   }
   const anchors = [];
   for (const iv of merged) {
-    const rowsWithHit = rows.filter(
+    const rowsWithHit = columnRows.filter(
       (r) => r.items.some((it) => rangeOverlap(it.x, it.right, iv.x0, iv.x1))
     );
-    const support = rowsWithHit.length / rows.length;
+    const support = rowsWithHit.length / columnRows.length;
     if (support < COLUMN_SUPPORT_THRESHOLD) continue;
-    const alignment = chooseAlignment(rows, iv);
+    const alignment = chooseAlignment(columnRows, iv);
     anchors.push({ x0: iv.x0, x1: iv.x1, alignment, support });
   }
   return anchors;
 }
+function selectColumnRows(rows) {
+  if (rows.length === 0) return [];
+  const maxItems = Math.max(...rows.map((r) => r.items.length));
+  if (maxItems < 2) return [];
+  const minItems = Math.max(2, Math.ceil(maxItems * 0.5));
+  const denseRows = rows.filter((r) => r.items.length >= minItems);
+  if (denseRows.length < 2) return [];
+  return denseRows;
+}
+function trimSparseBoundaryRows(rows) {
+  if (rows.length === 0) return { rows: [], start: 0, end: -1 };
+  let start = 0;
+  let end = rows.length - 1;
+  while (start <= end && rows[start].items.length < 2) start++;
+  while (end >= start && rows[end].items.length < 2) end--;
+  if (start > end) return { rows: [], start, end };
+  return { rows: rows.slice(start, end + 1), start, end };
+}
+function hasConsistentRowSeparation(rows, left, right, minGap) {
+  if (rows.length === 0) return false;
+  let supporting = 0;
+  for (const row of rows) {
+    let leftRight = -Infinity;
+    let rightLeft = Infinity;
+    for (const it of row.items) {
+      if (rangeOverlap(it.x, it.right, left.x0, left.x1)) leftRight = Math.max(leftRight, it.right);
+      if (rangeOverlap(it.x, it.right, right.x0, right.x1)) rightLeft = Math.min(rightLeft, it.x);
+    }
+    if (leftRight > -Infinity && rightLeft < Infinity && rightLeft - leftRight > minGap) {
+      supporting++;
+    }
+  }
+  return supporting / rows.length >= COLUMN_SUPPORT_THRESHOLD;
+}
 function coalesceMultiLineCells(rows, columns) {
   if (rows.length < 2 || columns.length < 2) return rows;
   const gaps = rowGaps(rows);
@@ -21557,12 +21625,15 @@ function findTableRegions(items, options = {}) {
     let best = null;
     for (let j = i + 1; j < rows.length; j++) {
       const run = rows.slice(i, j + 1);
-      const columns = detectColumns(run);
+      const trimmed = trimSparseBoundaryRows(run);
+      if (trimmed.rows.length < 2) {
+        continue;
+      }
+      const columns = detectColumns(trimmed.rows);
       if (columns.length < 2) {
-        if (best) break;
         continue;
       }
-      const coalesced = coalesceMultiLineCells(run, columns);
+      const coalesced = coalesceMultiLineCells(trimmed.rows, columns);
       if (coalesced.length < 2) {
         continue;
       }
@@ -21574,20 +21645,33 @@ 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(run);
-      const medianH = median(run.flatMap((r) => r.items.map((it) => it.height))) || 0;
+      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 = {
         rows: coalesced,
         columns,
         confidence,
         bbox,
-        rowRange: { start: i, end: j },
+        rowRange: { start: i + trimmed.start, end: i + trimmed.end },
         mayContinue
       };
     }
@@ -21887,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) {
@@ -21903,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;
@@ -21926,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,
@@ -21935,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) {
@@ -22035,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) => {
@@ -22101,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>`);
+          }
         }
       }
     }
@@ -22226,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);
@@ -22248,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) {
@@ -22279,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,
@@ -22747,6 +23418,621 @@ var SpreadsheetAdapter = class {
 };
 var spreadsheetAdapter = new SpreadsheetAdapter();
 
+// ../../src/shared/html-escape.ts
+function escapeHtml3(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// ../../src/shared/adapters/data-adapter.ts
+var DataParseError = class extends Error {
+  constructor(message, code, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "DataParseError";
+  }
+};
+var XML_MAX_STRUCTURED_DEPTH = 4;
+var TABLE_WIDE_COLUMN_WARNING = 15;
+var JSON_DEPTH_GUARD = 128;
+var XML_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+var XML_ATTRIBUTE_REGEX = /[A-Za-z_][A-Za-z0-9_.:-]*\s*=\s*(?:"[^"]*"|'[^']*')/y;
+function isXmlWhitespace(ch) {
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "	";
+}
+function findTagEnd(xml, start) {
+  let quote = null;
+  for (let i = start; i < xml.length; i++) {
+    const ch = xml[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") return i;
+  }
+  return -1;
+}
+function findDoctypeEnd(xml, start) {
+  let bracketDepth = 0;
+  let quote = null;
+  for (let i = start; i < xml.length; i++) {
+    const ch = xml[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "[") {
+      bracketDepth++;
+      continue;
+    }
+    if (ch === "]") {
+      bracketDepth = Math.max(0, bracketDepth - 1);
+      continue;
+    }
+    if (ch === ">" && bracketDepth === 0) return i;
+  }
+  return -1;
+}
+function hasValidXmlAttributes(attrs) {
+  let index = 0;
+  while (index < attrs.length) {
+    while (index < attrs.length && isXmlWhitespace(attrs[index])) index++;
+    if (index >= attrs.length) return true;
+    XML_ATTRIBUTE_REGEX.lastIndex = index;
+    const match = XML_ATTRIBUTE_REGEX.exec(attrs);
+    if (!match || match.index !== index) return false;
+    index = XML_ATTRIBUTE_REGEX.lastIndex;
+  }
+  return true;
+}
+function isWellFormedXml(text) {
+  const xml = text.replace(/^\uFEFF/, "");
+  const stack = [];
+  let seenRoot = false;
+  let i = 0;
+  while (i < xml.length) {
+    const lt = xml.indexOf("<", i);
+    if (lt === -1) {
+      return seenRoot && stack.length === 0 && xml.slice(i).trim().length === 0;
+    }
+    if (xml.slice(i, lt).trim().length > 0 && stack.length === 0) {
+      return false;
+    }
+    i = lt;
+    if (xml.startsWith("<!--", i)) {
+      const end = xml.indexOf("-->", i + 4);
+      if (end === -1) return false;
+      i = end + 3;
+      continue;
+    }
+    if (xml.startsWith("<![CDATA[", i)) {
+      if (stack.length === 0) return false;
+      const end = xml.indexOf("]]>", i + 9);
+      if (end === -1) return false;
+      i = end + 3;
+      continue;
+    }
+    if (xml.startsWith("<?", i)) {
+      const end = xml.indexOf("?>", i + 2);
+      if (end === -1) return false;
+      i = end + 2;
+      continue;
+    }
+    if (xml.startsWith("<!DOCTYPE", i) || xml.startsWith("<!doctype", i)) {
+      if (seenRoot || stack.length > 0) return false;
+      const end = findDoctypeEnd(xml, i + 9);
+      if (end === -1) return false;
+      i = end + 1;
+      continue;
+    }
+    const gt = findTagEnd(xml, i + 1);
+    if (gt === -1) return false;
+    const raw = xml.slice(i + 1, gt).trim();
+    if (raw.length === 0) return false;
+    if (raw.startsWith("/")) {
+      const name2 = raw.slice(1).trim();
+      if (!XML_NAME_REGEX.test(name2)) return false;
+      const open = stack.pop();
+      if (open !== name2) return false;
+      if (stack.length === 0) seenRoot = true;
+      i = gt + 1;
+      continue;
+    }
+    const selfClosing = raw.endsWith("/");
+    const body = selfClosing ? raw.slice(0, -1).trim() : raw;
+    if (body.length === 0) return false;
+    const spaceIndex = body.search(/\s/);
+    const name = spaceIndex === -1 ? body : body.slice(0, spaceIndex);
+    const attrs = spaceIndex === -1 ? "" : body.slice(spaceIndex + 1).trim();
+    if (!XML_NAME_REGEX.test(name)) return false;
+    if (!hasValidXmlAttributes(attrs)) return false;
+    if (selfClosing) {
+      if (stack.length === 0) {
+        if (seenRoot) return false;
+        seenRoot = true;
+      }
+    } else {
+      if (seenRoot && stack.length === 0) return false;
+      stack.push(name);
+    }
+    i = gt + 1;
+  }
+  return seenRoot && stack.length === 0;
+}
+function jsonDepth(value, current = 0) {
+  if (value === null || typeof value !== "object") return current;
+  if (current >= JSON_DEPTH_GUARD) return JSON_DEPTH_GUARD + 1;
+  const children = Object.values(value);
+  if (children.length === 0) return current;
+  let maxDepth = current;
+  for (const child of children) {
+    const depth = jsonDepth(child, current + 1);
+    if (depth > maxDepth) {
+      maxDepth = depth;
+      if (maxDepth > JSON_DEPTH_GUARD) {
+        return maxDepth;
+      }
+    }
+  }
+  return maxDepth;
+}
+function isTableArray(arr) {
+  if (arr.length === 0) return false;
+  const first = arr[0];
+  if (first === null || typeof first !== "object" || Array.isArray(first)) return false;
+  const keys = Object.keys(first);
+  return arr.every((item) => {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) return false;
+    const itemObj = item;
+    const itemKeys = Object.keys(itemObj);
+    return itemKeys.length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(itemObj, key));
+  });
+}
+function arrayToTable(arr) {
+  const keys = Object.keys(arr[0]);
+  const headerCells = keys.map((k) => `<th>${escapeHtml3(k)}</th>`).join("");
+  const bodyRows = arr.map((row) => {
+    const cells = keys.map((k) => `<td>${escapeHtml3(String(row[k] ?? ""))}</td>`).join("");
+    return `<tr>${cells}</tr>`;
+  }).join("\n");
+  return `<table>
+<thead><tr>${headerCells}</tr></thead>
+<tbody>
+${bodyRows}
+</tbody>
+</table>`;
+}
+function objectToTable(obj) {
+  const rows = Object.entries(obj).map(([k, v]) => `<tr><td>${escapeHtml3(k)}</td><td>${escapeHtml3(String(v ?? ""))}</td></tr>`).join("\n");
+  return `<table>
+<thead><tr><th>Key</th><th>Value</th></tr></thead>
+<tbody>
+${rows}
+</tbody>
+</table>`;
+}
+function safeJsonStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const stack = [];
+  function push(v, indent) {
+    if (v === null) {
+      stack.push("null");
+      return;
+    }
+    const t = typeof v;
+    if (t === "string") {
+      stack.push(JSON.stringify(v));
+      return;
+    }
+    if (t === "number" || t === "boolean") {
+      stack.push(String(v));
+      return;
+    }
+    if (t !== "object") {
+      stack.push("null");
+      return;
+    }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v)) {
+        stack.push("null");
+        return;
+      }
+      seen.add(v);
+    }
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        stack.push("[]");
+        return;
+      }
+      const inner2 = "  ".repeat(indent + 1);
+      const close2 = "  ".repeat(indent);
+      stack.push("[\n");
+      for (let i = 0; i < v.length; i++) {
+        stack.push(inner2);
+        push(v[i], indent + 1);
+        stack.push(i < v.length - 1 ? ",\n" : "\n");
+      }
+      stack.push(close2 + "]");
+      return;
+    }
+    const keys = Object.keys(v);
+    if (keys.length === 0) {
+      stack.push("{}");
+      return;
+    }
+    const inner = "  ".repeat(indent + 1);
+    const close = "  ".repeat(indent);
+    stack.push("{\n");
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      stack.push(inner + JSON.stringify(k) + ": ");
+      push(v[k], indent + 1);
+      stack.push(i < keys.length - 1 ? ",\n" : "\n");
+    }
+    stack.push(close + "}");
+  }
+  push(value, 0);
+  return stack.join("");
+}
+function jsonToCodeBlock(value) {
+  const json = safeJsonStringify(value);
+  return `<pre><code class="language-json">${escapeHtml3(json)}</code></pre>`;
+}
+function jsonValueToHtml(value) {
+  const warnings = [];
+  if (Array.isArray(value) && isTableArray(value)) {
+    const keys = Object.keys(value[0]);
+    if (keys.length > TABLE_WIDE_COLUMN_WARNING) {
+      warnings.push(
+        `Table has ${keys.length} columns which may not render well in narrow Markdown viewers.`
+      );
+    }
+    return { html: arrayToTable(value), warnings };
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && jsonDepth(value) <= 1) {
+    return { html: objectToTable(value), warnings };
+  }
+  return { html: jsonToCodeBlock(value), warnings };
+}
+function serializeXmlElement(el) {
+  const serializerCtor = globalThis.XMLSerializer;
+  if (typeof serializerCtor === "function") {
+    return new serializerCtor().serializeToString(el);
+  }
+  const outer = el.outerHTML;
+  if (typeof outer === "string") {
+    return outer;
+  }
+  return String(el);
+}
+function xmlElementToHtml(el, depth) {
+  const tagName = el.localName || el.nodeName;
+  const directText = Array.from(el.childNodes).filter((n) => n.nodeType === Node.TEXT_NODE).map((n) => (n.textContent || "").trim()).join(" ").trim();
+  const children = Array.from(el.children);
+  if (children.length === 0) {
+    if (!directText) return "";
+    const headingLevel2 = Math.min(depth + 1, 6);
+    return `<h${headingLevel2}>${escapeHtml3(tagName)}</h${headingLevel2}>
+<p>${escapeHtml3(directText)}</p>
+`;
+  }
+  if (depth >= XML_MAX_STRUCTURED_DEPTH) {
+    return `<pre><code class="language-xml">${escapeHtml3(serializeXmlElement(el))}</code></pre>
+`;
+  }
+  const headingLevel = Math.min(depth + 1, 6);
+  let html = `<h${headingLevel}>${escapeHtml3(tagName)}</h${headingLevel}>
+`;
+  if (directText) {
+    html += `<p>${escapeHtml3(directText)}</p>
+`;
+  }
+  for (const child of children) {
+    html += xmlElementToHtml(child, depth + 1);
+  }
+  return html;
+}
+var DataAdapter = class {
+  async parseJsonToHtml(arrayBuffer) {
+    const warnings = [];
+    try {
+      if (arrayBuffer.byteLength === 0) {
+        throw new DataParseError("The JSON file is empty.", "EMPTY_FILE");
+      }
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(arrayBuffer);
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch (err) {
+        throw new DataParseError(
+          "The file does not contain valid JSON.",
+          "INVALID_JSON",
+          err instanceof Error ? err : void 0
+        );
+      }
+      const { html, warnings: convWarnings } = jsonValueToHtml(parsed);
+      warnings.push(...convWarnings);
+      return { html, warnings };
+    } catch (error) {
+      if (error instanceof DataParseError) throw error;
+      throw new DataParseError(
+        `Failed to parse JSON file: ${error instanceof Error ? error.message : String(error)}`,
+        "PARSE_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async parseXmlToHtml(arrayBuffer) {
+    const warnings = [];
+    try {
+      if (arrayBuffer.byteLength === 0) {
+        throw new DataParseError("The XML file is empty.", "EMPTY_FILE");
+      }
+      const text = new TextDecoder("utf-8", { fatal: false }).decode(arrayBuffer);
+      if (!isWellFormedXml(text)) {
+        throw new DataParseError("The file does not contain valid XML.", "INVALID_XML");
+      }
+      const parserCtor = globalThis.DOMParser;
+      if (typeof parserCtor !== "function") {
+        throw new DataParseError("XML parsing is unavailable in this runtime.", "PARSE_ERROR");
+      }
+      const doc = new parserCtor().parseFromString(text, "application/xml");
+      const parseError = doc.querySelector("parsererror");
+      const root = doc.documentElement;
+      if (parseError || !root || /parsererror/i.test(root.nodeName)) {
+        throw new DataParseError("The file does not contain valid XML.", "INVALID_XML");
+      }
+      const html = xmlElementToHtml(root, 0);
+      if (!html.trim()) {
+        warnings.push("The XML file contains no readable text content.");
+        return { html: `<p><em>No text content found in XML file.</em></p>`, warnings };
+      }
+      return { html, warnings };
+    } catch (error) {
+      if (error instanceof DataParseError) throw error;
+      throw new DataParseError(
+        `Failed to parse XML file: ${error instanceof Error ? error.message : String(error)}`,
+        "PARSE_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+var dataAdapter = new DataAdapter();
+
+// ../../src/shared/adapters/pptx-adapter.ts
+import JSZip from "jszip";
+var NS_A = "http://schemas.openxmlformats.org/drawingml/2006/main";
+var NS_P = "http://schemas.openxmlformats.org/presentationml/2006/main";
+var PptxParseError = class extends Error {
+  constructor(message, code, originalError) {
+    super(message);
+    this.code = code;
+    this.originalError = originalError;
+    this.name = "PptxParseError";
+  }
+};
+function getElements(parent, ns, localName) {
+  return Array.from(parent.getElementsByTagNameNS(ns, localName));
+}
+function isTitle(shape) {
+  const phElements = getElements(shape, NS_P, "ph");
+  for (const ph of phElements) {
+    const type = ph.getAttribute("type");
+    if (type === "title" || type === "ctrTitle") return true;
+    const idx = ph.getAttribute("idx");
+    if (!type && (!idx || idx === "0")) return true;
+  }
+  return false;
+}
+function runToHtml(run) {
+  const tElements = getElements(run, NS_A, "t");
+  const text = tElements.map((t) => t.textContent || "").join("");
+  if (!text) return "";
+  const rPr = getElements(run, NS_A, "rPr")[0];
+  if (!rPr) return escapeHtml3(text);
+  let result = escapeHtml3(text);
+  if (rPr.getAttribute("b") === "1") result = `<strong>${result}</strong>`;
+  if (rPr.getAttribute("i") === "1") result = `<em>${result}</em>`;
+  return result;
+}
+function paragraphToHtml(para, shapeTitleFlag) {
+  const runs = getElements(para, NS_A, "r");
+  let content = runs.map(runToHtml).join("");
+  const fields = getElements(para, NS_A, "fld");
+  content += fields.map((fld) => {
+    const t = getElements(fld, NS_A, "t")[0];
+    return t ? escapeHtml3(t.textContent || "") : "";
+  }).join("");
+  if (!content.trim()) return "";
+  if (shapeTitleFlag) {
+    return `<h2>${content}</h2>
+`;
+  }
+  const pPr = getElements(para, NS_A, "pPr")[0];
+  const level = pPr ? parseInt(pPr.getAttribute("lvl") || "0", 10) : 0;
+  if (level > 0) {
+    return `<li>${content}</li>
+`;
+  }
+  return `<p>${content}</p>
+`;
+}
+function tableToHtml(tbl) {
+  const rows = getElements(tbl, NS_A, "tr");
+  if (rows.length === 0) return "";
+  let html = "<table>\n";
+  rows.forEach((row, rowIndex) => {
+    html += "<tr>";
+    const cells = getElements(row, NS_A, "tc");
+    cells.forEach((cell) => {
+      const paragraphs = getElements(cell, NS_A, "p");
+      const text = paragraphs.flatMap((p) => getElements(p, NS_A, "r")).map((r) => getElements(r, NS_A, "t").map((t) => t.textContent || "").join("")).join(" ").trim();
+      const tag = rowIndex === 0 ? "th" : "td";
+      html += `<${tag}>${escapeHtml3(text)}</${tag}>`;
+    });
+    html += "</tr>\n";
+  });
+  html += "</table>\n";
+  return html;
+}
+function parseSlide(xmlString) {
+  const warnings = [];
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xmlString, "application/xml");
+  if (doc.querySelector("parsererror")) {
+    warnings.push("A slide could not be parsed and was skipped.");
+    return { html: "", warnings };
+  }
+  let html = "";
+  const shapes = getElements(doc, NS_P, "sp");
+  for (const shape of shapes) {
+    const txBodies = getElements(shape, NS_P, "txBody");
+    if (txBodies.length === 0) continue;
+    const titleFlag = isTitle(shape);
+    const paragraphs = getElements(txBodies[0], NS_A, "p");
+    let inList = false;
+    for (const para of paragraphs) {
+      const paraHtml = paragraphToHtml(para, titleFlag);
+      if (!paraHtml) continue;
+      if (paraHtml.startsWith("<li>")) {
+        if (!inList) {
+          html += "<ul>\n";
+          inList = true;
+        }
+      } else if (inList) {
+        html += "</ul>\n";
+        inList = false;
+      }
+      html += paraHtml;
+    }
+    if (inList) {
+      html += "</ul>\n";
+    }
+  }
+  const graphicFrames = getElements(doc, NS_P, "graphicFrame");
+  for (const frame of graphicFrames) {
+    const tables = getElements(frame, NS_A, "tbl");
+    for (const tbl of tables) {
+      html += tableToHtml(tbl);
+    }
+  }
+  const pics = getElements(doc, NS_P, "pic");
+  if (pics.length > 0 && !html.trim()) {
+    html += `<p><em>[${pics.length} image${pics.length > 1 ? "s" : ""} on this slide]</em></p>
+`;
+  } else if (pics.length > 0) {
+    html += `<p><em>[+ ${pics.length} image${pics.length > 1 ? "s" : ""}]</em></p>
+`;
+  }
+  return { html, warnings };
+}
+function parseNotes(xmlString) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xmlString, "application/xml");
+  if (doc.querySelector("parsererror")) return "";
+  const shapes = getElements(doc, NS_P, "sp");
+  const lines = [];
+  for (const shape of shapes) {
+    const ph = getElements(shape, NS_P, "ph")[0];
+    if (!ph) continue;
+    const idx = ph.getAttribute("idx");
+    if (idx !== "1") continue;
+    const txBodies = getElements(shape, NS_P, "txBody");
+    if (txBodies.length === 0) continue;
+    const paragraphs = getElements(txBodies[0], NS_A, "p");
+    for (const para of paragraphs) {
+      const runs = getElements(para, NS_A, "r");
+      const text = runs.map((r) => getElements(r, NS_A, "t").map((t) => t.textContent || "").join("")).join("").trim();
+      if (text) lines.push(text);
+    }
+  }
+  if (lines.length === 0) return "";
+  const notesContent = lines.map((l) => `<p>${escapeHtml3(l)}</p>`).join("\n");
+  return `<blockquote>
+<p><strong>Speaker notes:</strong></p>
+${notesContent}
+</blockquote>
+`;
+}
+function sortSlides(paths2) {
+  return paths2.slice().sort((a, b) => {
+    const numA = parseInt(a.match(/(\d+)/)?.[1] ?? "0", 10);
+    const numB = parseInt(b.match(/(\d+)/)?.[1] ?? "0", 10);
+    return numA - numB;
+  });
+}
+var PptxAdapter = class {
+  async parseToHtml(arrayBuffer) {
+    const warnings = [];
+    try {
+      let zip;
+      try {
+        zip = await JSZip.loadAsync(arrayBuffer);
+      } catch (err) {
+        throw new PptxParseError(
+          "This file does not appear to be a valid PPTX document.",
+          "CORRUPTED",
+          err instanceof Error ? err : void 0
+        );
+      }
+      if (!zip.files["ppt/presentation.xml"]) {
+        throw new PptxParseError(
+          "This file does not appear to be a valid PPTX document.",
+          "INVALID_FORMAT"
+        );
+      }
+      const slidePaths = sortSlides(
+        Object.keys(zip.files).filter(
+          (name) => /^ppt\/slides\/slide\d+\.xml$/.test(name)
+        )
+      );
+      if (slidePaths.length === 0) {
+        warnings.push("No slides were found in this presentation.");
+        return { html: "<p><em>No slides found.</em></p>", slideCount: 0, warnings };
+      }
+      let html = "";
+      for (let i = 0; i < slidePaths.length; i++) {
+        const slideNumber = i + 1;
+        const slidePath = slidePaths[i];
+        html += `<div data-slide-marker="${slideNumber}"></div>
+`;
+        const slideXml = await zip.files[slidePath].async("string");
+        const { html: slideHtml, warnings: slideWarnings } = parseSlide(slideXml);
+        warnings.push(...slideWarnings);
+        html += slideHtml || `<p><em>[Empty slide]</em></p>
+`;
+        const notesPath = slidePath.replace("ppt/slides/slide", "ppt/notesSlides/notesSlide");
+        if (zip.files[notesPath]) {
+          const notesXml = await zip.files[notesPath].async("string");
+          const notesHtml = parseNotes(notesXml);
+          if (notesHtml) {
+            html += notesHtml;
+          }
+        }
+      }
+      return { html, slideCount: slidePaths.length, warnings };
+    } catch (error) {
+      if (error instanceof PptxParseError) throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      throw new PptxParseError(
+        `Failed to parse PPTX file: ${message}`,
+        "PARSE_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+var pptxAdapter = new PptxAdapter();
+
 // ../../src/shared/atlassian-detector.ts
 var ATLASSIAN_MARKERS = [
   "ac:structured-macro",
@@ -23372,13 +24658,16 @@ function detectInputType(filePath) {
     ".docx": "docx",
     ".pdf": "pdf",
     ".xlsx": "xlsx",
-    ".csv": "csv"
+    ".csv": "csv",
+    ".json": "json",
+    ".xml": "xml",
+    ".pptx": "pptx"
   };
   const type = map[ext];
   if (!type) {
     process.stderr.write(
       `Unsupported file type: ${ext}
-Supported: .html, .htm, .docx, .pdf, .xlsx, .csv
+Supported: .html, .htm, .docx, .pdf, .xlsx, .csv, .json, .xml, .pptx
 `
     );
     process.exit(1);
@@ -23459,6 +24748,39 @@ async function binaryToMarkdown(buffer, type, format) {
       });
       return converted.markdown;
     }
+    case "json": {
+      const result = await dataAdapter.parseJsonToHtml(arrayBuffer);
+      const sanitized = sanitizeHTML(result.html);
+      const converted = await engine.convert(sanitized, {
+        format,
+        preserveTables: true,
+        preserveLists: true,
+        customRules: []
+      });
+      return converted.markdown;
+    }
+    case "xml": {
+      const result = await dataAdapter.parseXmlToHtml(arrayBuffer);
+      const sanitized = sanitizeHTML(result.html);
+      const converted = await engine.convert(sanitized, {
+        format,
+        preserveTables: true,
+        preserveLists: true,
+        customRules: []
+      });
+      return converted.markdown;
+    }
+    case "pptx": {
+      const result = await pptxAdapter.parseToHtml(arrayBuffer);
+      const sanitized = sanitizeHTML(result.html);
+      const converted = await engine.convert(sanitized, {
+        format,
+        preserveTables: true,
+        preserveLists: true,
+        customRules: []
+      });
+      return converted.markdown;
+    }
   }
 }
 var DEFAULT_PROXY_URL = "https://formatferry.vibingfun.com";
@@ -23630,7 +24952,7 @@ async function convertCommand(options) {
 import fg from "fast-glob";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
 import { extname as extname2, basename, dirname as dirname2, join } from "path";
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".htm", ".docx", ".pdf", ".xlsx", ".csv"]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".htm", ".docx", ".pdf", ".xlsx", ".csv", ".json", ".xml", ".pptx"]);
 function getOutputPath(filePath, outputDir) {
   const ext = extname2(filePath);
   const stem = basename(filePath, ext);
@@ -23653,18 +24975,36 @@ async function convertFile(filePath, format) {
   }
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   if (ext === ".docx") {
-    const r2 = await docxAdapter.parseToHtml(arrayBuffer);
-    const c2 = await engine.convert(sanitizeHTML(r2.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
-    return c2.markdown;
+    const r = await docxAdapter.parseToHtml(arrayBuffer);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
   }
   if (ext === ".pdf") {
-    const r2 = await pdfAdapter.parseToText(arrayBuffer);
-    const c2 = await engine.convert(sanitizeHTML(r2.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
-    return c2.markdown;
+    const r = await pdfAdapter.parseToText(arrayBuffer);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
+  }
+  if (ext === ".xlsx" || ext === ".csv") {
+    const r = await spreadsheetAdapter.parseToHtml(arrayBuffer, ext.slice(1), 0);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
+  }
+  if (ext === ".json") {
+    const r = await dataAdapter.parseJsonToHtml(arrayBuffer);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
+  }
+  if (ext === ".xml") {
+    const r = await dataAdapter.parseXmlToHtml(arrayBuffer);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
+  }
+  if (ext === ".pptx") {
+    const r = await pptxAdapter.parseToHtml(arrayBuffer);
+    const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
+    return c.markdown;
   }
-  const r = await spreadsheetAdapter.parseToHtml(arrayBuffer, ext.slice(1), 0);
-  const c = await engine.convert(sanitizeHTML(r.html), { format, preserveTables: true, preserveLists: true, customRules: [] });
-  return c.markdown;
+  throw new Error(`Unsupported file type: ${ext}`);
 }
 async function batchCommand(options) {
   const parsedTimeout = options.timeout ? parseInt(options.timeout, 10) : void 0;
@@ -23954,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.12") {
-    return "1.0.12";
+  if ("1.0.14") {
+    return "1.0.14";
   }
   try {
     const __dirname = dirname3(fileURLToPath(import.meta.url));
@@ -23968,7 +25308,7 @@ var getVersion = () => {
   }
 };
 var VERSION = getVersion();
-program.name("formatferry").version(VERSION).description("Convert HTML, DOCX, PDF, XLSX, CSV to Markdown").option("-i, --input <path>", "Input file path").option("-o, --output <path>", "Output file path").option("-f, --format <format>", "Markdown format (github, commonmark, slack, discord, reddit, confluence, gdocs, rmarkdown)", "github").option("--url <url>", "Fetch article from URL").option("--batch <glob>", "Batch convert files (Premium)").option("--output-dir <dir>", "Output directory for batch").option("--toonify", "Compress output to TOON format (Premium)").option("--offline", "Skip entitlement check (use cached or free tier)").option("--timeout <ms>", "License server timeout in milliseconds (default: 2000)", "2000").action(async (options) => {
+program.name("formatferry").version(VERSION).description("Convert HTML, DOCX, PDF, XLSX, CSV, JSON, XML, PPTX to Markdown").option("-i, --input <path>", "Input file path").option("-o, --output <path>", "Output file path").option("-f, --format <format>", "Markdown format (github, commonmark, slack, discord, reddit, confluence, gdocs, rmarkdown)", "github").option("--url <url>", "Fetch article from URL").option("--batch <glob>", "Batch convert files (Premium)").option("--output-dir <dir>", "Output directory for batch").option("--toonify", "Compress output to TOON format (Premium)").option("--offline", "Skip entitlement check (use cached or free tier)").option("--timeout <ms>", "License server timeout in milliseconds (default: 2000)", "2000").action(async (options) => {
   if (options.batch) {
     await batchCommand(options);
   } else {