formatferry 1.0.11 → 1.0.13

package/dist/index.js

@@ -20376,6 +20376,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 +20389,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 +20410,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 +20589,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 +20648,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 +20932,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 +21371,9 @@ var _flags = {
   enableXlsx: true,
   enablePdf: true,
   enableHtml: true,
-  enablePdfTableDetection: true
+  enablePdfTableDetection: true,
+  enableData: true,
+  enablePptx: true
 };
 function getFeatureFlags() {
   return { ..._flags };
@@ -21361,16 +21386,45 @@ var DATE_LIKE_REGEX = /^\d{1,4}[-/.]\d{1,2}([-/.]\d{1,4})?$/;
 var SUPERSCRIPT_MERGE_GAP_FACTOR = 0.3;
 var VERTICAL_OVERLAP_THRESHOLD = 0.5;
 var COLUMN_SUPPORT_THRESHOLD = 0.6;
-var COLUMN_GAP_MERGE_FACTOR = 0.5;
+var COLUMN_GAP_MERGE_FACTOR = 0.35;
+var COLUMN_BOUNDARY_VOTE_TOLERANCE_FACTOR = 0.5;
+var MIN_CELL_OVERLAP_SCORE = 0.35;
+var WIDE_WHITESPACE_MIN_RUN = 2;
 var SHORT_CELL_THRESHOLD_LATIN = 40;
 var SHORT_CELL_THRESHOLD_CJK = 20;
 var MIN_CONFIDENCE_EMIT = 0.55;
 var MIN_CONFIDENCE_HIGH = 0.7;
 var PROSE_FLOW_MAX_FRACTION = 0.3;
+function splitWideWhitespaceItems(items) {
+  const out = [];
+  for (const it of items) {
+    const tokens = splitAtWideRuns(it.str, WIDE_WHITESPACE_MIN_RUN);
+    if (tokens.length < 2 || it.str.length < 4 || it.width <= 0) {
+      out.push(it);
+      continue;
+    }
+    const perChar = it.width / it.str.length;
+    for (const t of tokens) {
+      const subX = it.x + t.start * perChar;
+      const subRight = it.x + t.end * perChar;
+      const subWidth = Math.max(subRight - subX, perChar);
+      out.push({
+        ...it,
+        str: t.str,
+        x: subX,
+        width: subWidth,
+        right: subX + subWidth
+      });
+    }
+  }
+  return out;
+}
 function preFilterAndMerge(items) {
-  const alive = items.filter(
+  const filtered = items.filter(
     (it) => it.str.trim().length > 0 && it.width > 0 && it.height > 0
   );
+  if (filtered.length === 0) return [];
+  const alive = splitWideWhitespaceItems(filtered);
   if (alive.length === 0) return [];
   const widths = alive.map((it) => estimateCharWidth(it)).filter((w) => w > 0);
   const medianCharWidth = median(widths) || 1;
@@ -21424,15 +21478,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 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];
-    if (last && iv.x0 - last.x1 <= gapTol) {
+    const crossesHardBoundary = last !== void 0 && hardBoundaries.some((b) => b >= last.x1 && b <= iv.x0);
+    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 });
@@ -21440,16 +21500,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);
@@ -21526,12 +21620,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;
       }
@@ -21548,15 +21645,15 @@ function findTableRegions(items, options = {}) {
         if (best) break;
         continue;
       }
-      const bbox = computeBbox(run);
-      const medianH = median(run.flatMap((r) => r.items.map((it) => it.height))) || 0;
+      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 = {
         rows: coalesced,
         columns,
         confidence,
         bbox,
-        rowRange: { start: i, end: j },
+        rowRange: { start: i + trimmed.start, end: i + trimmed.end },
         mayContinue
       };
     }
@@ -21611,6 +21708,67 @@ function estimateCharWidth(item) {
   const chars = item.str.length;
   return chars > 0 ? item.width / chars : 0;
 }
+function splitAtWideRuns(str, minRun) {
+  const tokens = [];
+  const isWs = (ch) => ch === " " || ch === "	" || ch === "\xA0";
+  let i = 0;
+  while (i < str.length) {
+    while (i < str.length && isWs(str[i])) i++;
+    if (i >= str.length) break;
+    const start = i;
+    let end = i;
+    while (i < str.length) {
+      if (isWs(str[i])) {
+        let j = i;
+        while (j < str.length && isWs(str[j])) j++;
+        if (j - i >= minRun) break;
+        i = j;
+      } else {
+        i++;
+        end = i;
+      }
+    }
+    if (end > start) tokens.push({ str: str.slice(start, end), start, end });
+  }
+  return tokens;
+}
+function voteColumnBoundaries(rows, medianCharWidth) {
+  if (rows.length < 2 || medianCharWidth <= 0) return [];
+  const candidates = [];
+  rows.forEach((row, rIdx) => {
+    const sorted = [...row.items].sort((a, b) => a.x - b.x);
+    for (let i = 1; i < sorted.length; i++) {
+      const gap = sorted[i].x - sorted[i - 1].right;
+      if (gap > 0) {
+        candidates.push({
+          mid: (sorted[i - 1].right + sorted[i].x) / 2,
+          rowIdx: rIdx
+        });
+      }
+    }
+  });
+  if (candidates.length === 0) return [];
+  candidates.sort((a, b) => a.mid - b.mid);
+  const tolerance = medianCharWidth * COLUMN_BOUNDARY_VOTE_TOLERANCE_FACTOR;
+  const clusters = [];
+  for (const c of candidates) {
+    const last = clusters[clusters.length - 1];
+    if (last && c.mid - last.mids[last.mids.length - 1] <= tolerance) {
+      last.mids.push(c.mid);
+      last.rowSet.add(c.rowIdx);
+    } else {
+      clusters.push({ mids: [c.mid], rowSet: /* @__PURE__ */ new Set([c.rowIdx]) });
+    }
+  }
+  const hard = [];
+  for (const cl of clusters) {
+    if (cl.rowSet.size / rows.length >= COLUMN_SUPPORT_THRESHOLD) {
+      hard.push(median(cl.mids));
+    }
+  }
+  hard.sort((a, b) => a - b);
+  return hard;
+}
 function median(xs) {
   if (xs.length === 0) return 0;
   const sorted = [...xs].sort((a, b) => a - b);
@@ -21702,7 +21860,7 @@ function assignRowToColumns(row, columns) {
         best = c;
       }
     }
-    if (best >= 0 && bestScore > 0.2) buckets[best].push(item);
+    if (best >= 0 && bestScore > MIN_CELL_OVERLAP_SCORE) buckets[best].push(item);
   }
   for (let c = 0; c < columns.length; c++) {
     const bucket = buckets[c].sort((a, b) => a.x - b.x);
@@ -22655,6 +22813,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",
@@ -23280,13 +24053,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);
@@ -23367,6 +24143,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";
@@ -23538,7 +24347,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);
@@ -23561,18 +24370,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;
@@ -23862,8 +24689,8 @@ import { readFileSync as readFileSync4 } from "fs";
 import { resolve, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var getVersion = () => {
-  if ("1.0.11") {
-    return "1.0.11";
+  if ("1.0.13") {
+    return "1.0.13";
   }
   try {
     const __dirname = dirname3(fileURLToPath(import.meta.url));
@@ -23876,7 +24703,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 {

package/package.json

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