markit-ai 0.4.0 → 0.5.1

package/dist/commands/formats.js

@@ -23,6 +23,21 @@ const BUILTIN_FORMATS = [
         extensions: [".mp3", ".wav", ".m4a", ".flac"],
         builtin: true,
     },
+    {
+        name: "Pages",
+        extensions: [".pages"],
+        builtin: true,
+    },
+    {
+        name: "Keynote",
+        extensions: [".key"],
+        builtin: true,
+    },
+    {
+        name: "Numbers",
+        extensions: [".numbers"],
+        builtin: true,
+    },
     {
         name: "GitHub",
         extensions: ["github.com/*", "gist.github.com/*"],

package/dist/converters/iwork.d.ts

@@ -0,0 +1,20 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+/**
+ * Converts Apple iWork files (Pages, Keynote, Numbers) to markdown.
+ *
+ * All three formats are ZIP archives containing an XML file:
+ *   - Pages:   index.xml   (sf:p paragraphs with named styles)
+ *   - Keynote: index.apxl  (key:slide elements with sf:p text)
+ *   - Numbers: index.xml   (sf:t text cells + sf:n number cells)
+ */
+export declare class IWorkConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    private convertPages;
+    private convertKeynote;
+    private convertNumbers;
+    private extractGrid;
+    private convertNumbersFallback;
+    private readIndex;
+}

package/dist/converters/iwork.js

@@ -0,0 +1,391 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import JSZip from "jszip";
+const EXTENSIONS = [".pages", ".key", ".numbers"];
+const SF = "http://developer.apple.com/namespaces/sf";
+const SFA = "http://developer.apple.com/namespaces/sfa";
+const KEY = "http://developer.apple.com/namespaces/keynote2";
+/**
+ * Converts Apple iWork files (Pages, Keynote, Numbers) to markdown.
+ *
+ * All three formats are ZIP archives containing an XML file:
+ *   - Pages:   index.xml   (sf:p paragraphs with named styles)
+ *   - Keynote: index.apxl  (key:slide elements with sf:p text)
+ *   - Numbers: index.xml   (sf:t text cells + sf:n number cells)
+ */
+export class IWorkConverter {
+    name = "iwork";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension)) {
+            return true;
+        }
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const zip = await JSZip.loadAsync(input);
+        const ext = streamInfo.extension;
+        if (ext === ".pages")
+            return this.convertPages(zip, streamInfo);
+        if (ext === ".key")
+            return this.convertKeynote(zip, streamInfo);
+        if (ext === ".numbers")
+            return this.convertNumbers(zip);
+        throw new Error(`Unsupported iWork format: ${ext}`);
+    }
+    // ---------------------------------------------------------------------------
+    // Pages
+    // ---------------------------------------------------------------------------
+    async convertPages(zip, streamInfo) {
+        const xml = await this.readIndex(zip, "index.xml");
+        const root = parseXml(xml);
+        const imageDir = streamInfo.imageDir;
+        if (imageDir)
+            mkdirSync(imageDir, { recursive: true });
+        let imageCount = 0;
+        const lines = [];
+        let title;
+        for (const p of iterAll(root, SF, "p")) {
+            const text = collectText(p).trim();
+            if (!text)
+                continue;
+            const style = p.getAttribute("sf:style") || "";
+            const prefix = paragraphPrefix(style);
+            if (!title && text.length > 0)
+                title = text;
+            lines.push(`${prefix}${text}`);
+        }
+        // Extract images
+        for (const name of Object.keys(zip.files)) {
+            if (!name.match(/\.(png|jpg|jpeg|gif|webp|tiff|bmp)$/i))
+                continue;
+            if (name.startsWith("QuickLook/"))
+                continue;
+            imageCount++;
+            const imgName = name.split("/").pop() || `image_${imageCount}`;
+            if (imageDir) {
+                const file = zip.file(name);
+                if (file) {
+                    const buf = await file.async("nodebuffer");
+                    const filepath = join(imageDir, imgName);
+                    writeFileSync(filepath, buf);
+                    lines.push(`![${imgName}](${filepath})`);
+                }
+            }
+            else {
+                lines.push(`<!-- image: ${imgName} -->`);
+            }
+        }
+        return { markdown: lines.join("\n\n"), title };
+    }
+    // ---------------------------------------------------------------------------
+    // Keynote
+    // ---------------------------------------------------------------------------
+    async convertKeynote(zip, streamInfo) {
+        const xml = await this.readIndex(zip, "index.apxl");
+        const root = parseXml(xml);
+        const imageDir = streamInfo.imageDir;
+        if (imageDir)
+            mkdirSync(imageDir, { recursive: true });
+        const sections = [];
+        let title;
+        const slides = [...iterAll(root, KEY, "slide")];
+        for (let i = 0; i < slides.length; i++) {
+            const slide = slides[i];
+            const slideLines = [`<!-- Slide ${i + 1} -->`];
+            const paragraphs = [...iterAll(slide, SF, "p")];
+            let isTitle = true;
+            for (const p of paragraphs) {
+                const text = collectText(p).trim();
+                if (!text)
+                    continue;
+                if (isTitle) {
+                    slideLines.push(`# ${text}`);
+                    if (!title)
+                        title = text;
+                    isTitle = false;
+                }
+                else {
+                    slideLines.push(text);
+                }
+            }
+            sections.push(slideLines.join("\n"));
+        }
+        // Extract media images
+        let imageCount = 0;
+        for (const name of Object.keys(zip.files)) {
+            if (!name.match(/\.(png|jpg|jpeg|gif|webp|tiff|bmp)$/i))
+                continue;
+            if (name.startsWith("QuickLook/"))
+                continue;
+            imageCount++;
+            const imgName = name.split("/").pop() || `image_${imageCount}`;
+            if (imageDir) {
+                const file = zip.file(name);
+                if (file) {
+                    const buf = await file.async("nodebuffer");
+                    const filepath = join(imageDir, imgName);
+                    writeFileSync(filepath, buf);
+                    sections.push(`![${imgName}](${filepath})`);
+                }
+            }
+            else {
+                sections.push(`<!-- image: ${imgName} -->`);
+            }
+        }
+        return { markdown: sections.join("\n\n"), title };
+    }
+    // ---------------------------------------------------------------------------
+    // Numbers
+    // ---------------------------------------------------------------------------
+    async convertNumbers(zip) {
+        const xml = await this.readIndex(zip, "index.xml");
+        const root = parseXml(xml);
+        // Find grid elements (tables)
+        const grids = [...iterAll(root, SF, "grid")];
+        if (grids.length === 0) {
+            // Fallback: extract all text and number cells
+            return this.convertNumbersFallback(root);
+        }
+        const sections = [];
+        for (const grid of grids) {
+            const rows = this.extractGrid(grid);
+            if (rows.length === 0)
+                continue;
+            const maxCols = Math.max(...rows.map((r) => r.length));
+            for (const row of rows) {
+                while (row.length < maxCols)
+                    row.push("");
+            }
+            const [header, ...body] = rows;
+            const lines = [];
+            lines.push(`| ${header.join(" | ")} |`);
+            lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+            for (const row of body) {
+                lines.push(`| ${row.join(" | ")} |`);
+            }
+            sections.push(lines.join("\n"));
+        }
+        return { markdown: sections.join("\n\n") };
+    }
+    extractGrid(grid) {
+        const datasource = findFirst(grid, SF, "datasource");
+        if (!datasource)
+            return [];
+        const rows = [];
+        let currentRow = [];
+        let colCount = 0;
+        let totalCells = 0;
+        const allValues = [];
+        // Get column count from grid attributes (raw attribute names)
+        const numCols = Number.parseInt(grid.getAttribute("sf:numcols") || "0", 10);
+        for (const child of datasource.children) {
+            const tag = child.tagName;
+            let value = "";
+            if (tag === `${SF}:t`) {
+                // Text cell
+                const ct = findFirst(child, SF, "ct");
+                value = ct?.getAttribute("sfa:s") || collectText(child).trim();
+            }
+            else if (tag === `${SF}:n`) {
+                // Number cell
+                value = child.getAttribute("sf:v") || "";
+            }
+            else if (tag === `${SF}:b`) {
+                // Boolean cell
+                value = child.getAttribute("sf:v") === "1" ? "TRUE" : "FALSE";
+            }
+            else if (tag === `${SF}:d`) {
+                // Date cell
+                value = child.getAttribute("sf:v") || "";
+            }
+            else if (tag === `${SF}:du`) {
+                // Duration cell
+                value = child.getAttribute("sf:v") || "";
+            }
+            else if (tag === `${SF}:e`) {
+                // Empty cell
+                value = "";
+            }
+            else {
+                continue;
+            }
+            currentRow.push(value);
+            allValues.push(value);
+            colCount++;
+            totalCells++;
+            if (numCols > 0 && colCount >= numCols) {
+                rows.push(currentRow);
+                currentRow = [];
+                colCount = 0;
+            }
+        }
+        if (currentRow.length > 0)
+            rows.push(currentRow);
+        // If the grid used default dimensions and produced only one row,
+        // the data probably doesn't fill the full grid width. Fall back to
+        // treating the cells as a 2-column key/value list or single column.
+        if (rows.length <= 1 && totalCells > 0 && totalCells < numCols) {
+            // Re-layout: try 2 columns if even, otherwise single column
+            const cols = totalCells % 2 === 0 ? 2 : 1;
+            const relaid = [];
+            for (let i = 0; i < allValues.length; i += cols) {
+                relaid.push(allValues.slice(i, i + cols));
+            }
+            return relaid;
+        }
+        return rows;
+    }
+    convertNumbersFallback(root) {
+        const values = [];
+        for (const t of iterAll(root, SF, "t")) {
+            const ct = findFirst(t, SF, "ct");
+            const val = ct?.getAttribute("sfa:s") || "";
+            if (val)
+                values.push(val);
+        }
+        for (const n of iterAll(root, SF, "n")) {
+            const val = n.getAttribute("sf:v") || "";
+            if (val)
+                values.push(val);
+        }
+        return { markdown: values.join("\n") };
+    }
+    // ---------------------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------------------
+    async readIndex(zip, filename) {
+        const file = zip.file(filename);
+        if (!file) {
+            throw new Error(`Invalid iWork file: missing ${filename}`);
+        }
+        return file.async("string");
+    }
+}
+/**
+ * Minimal XML parser that preserves namespace prefixes in tag names
+ * and extracts text content and attributes.
+ */
+function parseXml(xml) {
+    // Use a simple recursive descent approach
+    const root = createElement("root");
+    const stack = [root];
+    // Match tags and text
+    const tagRe = /<(\/?)([a-zA-Z0-9_:.-]+)((?:\s+[a-zA-Z0-9_:.-]+\s*=\s*"[^"]*")*)\s*(\/?)>/g;
+    let lastIndex = 0;
+    let match = tagRe.exec(xml);
+    while (match !== null) {
+        const [fullMatch, isClose, tagName, attrs, isSelfClose] = match;
+        const textBefore = xml.slice(lastIndex, match.index);
+        lastIndex = match.index + fullMatch.length;
+        // Add text to current element
+        if (textBefore.trim()) {
+            const current = stack[stack.length - 1];
+            if (current.children.length > 0) {
+                current.children[current.children.length - 1].tail += textBefore.trim();
+            }
+            else {
+                current.text += textBefore.trim();
+            }
+        }
+        if (isClose) {
+            // Closing tag
+            stack.pop();
+        }
+        else {
+            // Opening tag
+            const el = createElement(expandTag(tagName, xml));
+            parseAttributes(attrs, el);
+            stack[stack.length - 1].children.push(el);
+            if (!isSelfClose) {
+                stack.push(el);
+            }
+        }
+        match = tagRe.exec(xml);
+    }
+    return root;
+}
+function createElement(tagName) {
+    return {
+        tagName,
+        children: [],
+        text: "",
+        tail: "",
+        attributes: {},
+        getAttribute(name) {
+            return this.attributes[name] ?? null;
+        },
+    };
+}
+function parseAttributes(attrStr, el) {
+    const attrRe = /([a-zA-Z0-9_:.-]+)\s*=\s*"([^"]*)"/g;
+    let m = attrRe.exec(attrStr);
+    while (m !== null) {
+        el.attributes[m[1]] = m[2];
+        m = attrRe.exec(attrStr);
+    }
+}
+/**
+ * Expand namespace prefix in tag name to full URI.
+ * e.g. "sf:p" with xmlns:sf="..." → "{uri}p"
+ * For simplicity, we use the known Apple namespaces.
+ */
+function expandTag(tag, _xml) {
+    const nsMap = {
+        sf: SF,
+        sfa: SFA,
+        sl: "http://developer.apple.com/namespaces/sl",
+        key: KEY,
+    };
+    const colon = tag.indexOf(":");
+    if (colon === -1)
+        return tag;
+    const prefix = tag.slice(0, colon);
+    const local = tag.slice(colon + 1);
+    const uri = nsMap[prefix];
+    return uri ? `${uri}:${local}` : tag;
+}
+function collectText(el) {
+    let result = el.text;
+    for (const child of el.children) {
+        result += collectText(child);
+        result += child.tail;
+    }
+    return result;
+}
+function* iterAll(el, ns, localName) {
+    const fullTag = `${ns}:${localName}`;
+    if (el.tagName === fullTag)
+        yield el;
+    for (const child of el.children) {
+        yield* iterAll(child, ns, localName);
+    }
+}
+function findFirst(el, ns, localName) {
+    for (const found of iterAll(el, ns, localName)) {
+        return found;
+    }
+    return null;
+}
+/**
+ * Map iWork paragraph style names to markdown heading prefixes.
+ */
+function paragraphPrefix(style) {
+    if (!style)
+        return "";
+    const lower = style.toLowerCase();
+    if (lower.includes("title"))
+        return "# ";
+    if (lower.includes("subtitle"))
+        return "## ";
+    if (lower.includes("heading-1") || lower.includes("heading 1"))
+        return "## ";
+    if (lower.includes("heading-2") || lower.includes("heading 2"))
+        return "### ";
+    if (lower.includes("heading-3") || lower.includes("heading 3"))
+        return "#### ";
+    if (lower.includes("heading-4") || lower.includes("heading 4"))
+        return "##### ";
+    if (lower.includes("caption"))
+        return "*";
+    return "";
+}

package/dist/converters/pdf/grid.js

@@ -258,6 +258,122 @@ function expandSubRowsByYClusters(originalRows, cols, cells, cellBoxes) {
     return originalRows + addedRows;
 }
 // ---------------------------------------------------------------------------
+// Cross-column text box splitting
+// ---------------------------------------------------------------------------
+/**
+ * Find which column a horizontal position falls into.
+ * Returns -1 if outside the grid.
+ */
+function findCol(x, xLines) {
+    for (let i = 0; i < xLines.length - 1; i++) {
+        if (x >= xLines[i] && x <= xLines[i + 1])
+            return i;
+    }
+    return -1;
+}
+/**
+ * When a text box spans across one or more vertical column boundaries,
+ * split it into multiple virtual text boxes — one per column — with the
+ * text divided proportionally by width.
+ *
+ * We split at word boundaries closest to the proportional split point
+ * so we don't chop words in half.
+ */
+function splitCrossColumnBoxes(textBoxes, xLines) {
+    const result = [];
+    const MARGIN = 5; // allow small overlap before considering it cross-column
+    for (const tb of textBoxes) {
+        const leftCol = findCol(tb.bounds.left + MARGIN, xLines);
+        const rightCol = findCol(tb.bounds.right - MARGIN, xLines);
+        // Not spanning columns, or outside grid — keep as-is
+        if (leftCol < 0 || rightCol < 0 || leftCol === rightCol) {
+            result.push(tb);
+            continue;
+        }
+        // Text box spans from leftCol to rightCol — split it
+        const totalWidth = tb.bounds.right - tb.bounds.left;
+        if (totalWidth <= 0) {
+            result.push(tb);
+            continue;
+        }
+        const words = tb.text.split(/\s+/);
+        if (words.length <= 1) {
+            // Single word spanning columns — just assign to whichever col has more overlap
+            result.push(tb);
+            continue;
+        }
+        // For each column boundary crossing, find the best word-boundary split
+        let remainingWords = [...words];
+        let currentLeft = tb.bounds.left;
+        for (let col = leftCol; col <= rightCol && remainingWords.length > 0; col++) {
+            const colRight = col < xLines.length - 1 ? xLines[col + 1] : tb.bounds.right;
+            const segmentRight = Math.min(colRight, tb.bounds.right);
+            if (col === rightCol) {
+                // Last column — take all remaining words
+                result.push({
+                    ...tb,
+                    id: `${tb.id}-split${col}`,
+                    text: remainingWords.join(" "),
+                    bounds: {
+                        ...tb.bounds,
+                        left: currentLeft,
+                        right: tb.bounds.right,
+                    },
+                });
+                remainingWords = [];
+            }
+            else {
+                // Find how many words fit in this column segment proportionally
+                const segmentWidth = segmentRight - currentLeft;
+                const fractionOfTotal = segmentWidth / totalWidth;
+                const approxChars = Math.round(fractionOfTotal * tb.text.length);
+                // Walk words to find the split closest to the proportional point
+                let charCount = 0;
+                let splitIdx = 0;
+                for (let w = 0; w < remainingWords.length; w++) {
+                    const nextCount = charCount + remainingWords[w].length + (w > 0 ? 1 : 0);
+                    if (nextCount > approxChars && splitIdx > 0)
+                        break;
+                    charCount = nextCount;
+                    splitIdx = w + 1;
+                }
+                if (splitIdx === 0)
+                    splitIdx = 1; // take at least one word
+                if (splitIdx >= remainingWords.length) {
+                    // All remaining words fit here
+                    result.push({
+                        ...tb,
+                        id: `${tb.id}-split${col}`,
+                        text: remainingWords.join(" "),
+                        bounds: {
+                            ...tb.bounds,
+                            left: currentLeft,
+                            right: segmentRight,
+                        },
+                    });
+                    remainingWords = [];
+                }
+                else {
+                    const partWords = remainingWords.slice(0, splitIdx);
+                    result.push({
+                        ...tb,
+                        id: `${tb.id}-split${col}`,
+                        text: partWords.join(" "),
+                        bounds: {
+                            ...tb.bounds,
+                            left: currentLeft,
+                            right: segmentRight,
+                        },
+                    });
+                    remainingWords = remainingWords.slice(splitIdx);
+                    currentLeft = segmentRight;
+                }
+            }
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
 // Full grid table (H + V lines)
 // ---------------------------------------------------------------------------
 function buildCells(rows, cols) {
@@ -278,11 +394,26 @@ function buildTableGrid(pageNumber, yLines, xLines, filteredSegments, textBoxes)
     const yMax = yLines[0];
     const xMin = xLines[0];
     const xMax = xLines[xLines.length - 1];
-    // Look for header text boxes just above the grid
+    // Split text boxes that span multiple columns before placement
+    const splitBoxes = splitCrossColumnBoxes(textBoxes, xLines);
+    // Track which split piece IDs get placed in cells, so we can consume
+    // the original (unsplit) text box IDs too.
+    const placedSplitIds = new Set();
+    // Look for header text boxes just above the grid.
+    // Use the ORIGINAL (unsplit) text boxes for header detection so that
+    // wide paragraph text isn't falsely split into column-sized header chunks.
+    // Reject boxes wider than 1.5 columns — those are paragraph text, not headers.
+    const avgColWidth = (xMax - xMin) / cols;
+    const maxHeaderBoxWidth = avgColWidth * 1.5;
     const headerBoxes = textBoxes.filter((tb) => {
         const cy = (tb.bounds.top + tb.bounds.bottom) / 2;
         const cx = (tb.bounds.left + tb.bounds.right) / 2;
-        return cy > yMax && cy <= yMax + 20 && cx >= xMin && cx <= xMax;
+        const boxWidth = tb.bounds.right - tb.bounds.left;
+        return (cy > yMax &&
+            cy <= yMax + 20 &&
+            cx >= xMin &&
+            cx <= xMax &&
+            boxWidth <= maxHeaderBoxWidth);
     });
     if (headerBoxes.length > 0) {
         rows += 1;
@@ -308,7 +439,7 @@ function buildTableGrid(pageNumber, yLines, xLines, filteredSegments, textBoxes)
         }
     }
     const cellBoxes = new Map();
-    for (const tb of textBoxes) {
+    for (const tb of splitBoxes) {
         const cx = (tb.bounds.left + tb.bounds.right) / 2;
         const cy = (tb.bounds.top + tb.bounds.bottom) / 2;
         if (cy < yMin || cy > yMax || cx < xMin || cx > xMax)
@@ -338,6 +469,8 @@ function buildTableGrid(pageNumber, yLines, xLines, filteredSegments, textBoxes)
             cellBoxes.set(cell, []);
         cellBoxes.get(cell)?.push(tb);
         consumedIds.push(tb.id);
+        if (tb.id.includes("-split"))
+            placedSplitIds.add(tb.id);
     }
     rows = expandSubRowsByYClusters(rows, cols, cells, cellBoxes);
     // Merge text boxes within each cell into cell text
@@ -369,6 +502,14 @@ function buildTableGrid(pageNumber, yLines, xLines, filteredSegments, textBoxes)
         topY: yLines[0],
         isBorderless: false,
     });
+    // Also consume the original (unsplit) text box IDs when any of their
+    // split pieces were placed in a cell.
+    for (const splitId of placedSplitIds) {
+        const origId = splitId.replace(/-split\d+$/, "");
+        if (!consumedIds.includes(origId)) {
+            consumedIds.push(origId);
+        }
+    }
     return { grid, consumedIds };
 }
 // ---------------------------------------------------------------------------

package/dist/converters/pdf/index.js

@@ -80,8 +80,28 @@ export class PdfConverter {
                     });
                 }
             }
-            // Detect column layout
+            // Detect column layout.
+            // If the page has vertical segments (tables), suppress column detection
+            // when one detected column is very narrow — that's a table's first column,
+            // not a page layout column.
             const layout = detectColumns(page.textBoxes);
+            if (layout.columnCount > 1 &&
+                page.segments.some((s) => Math.abs(s.x1 - s.x2) <= 0.8)) {
+                const pageXMin = Math.min(...page.textBoxes.map((tb) => tb.bounds.left));
+                const pageXMax = Math.max(...page.textBoxes.map((tb) => tb.bounds.right));
+                const pageWidth = pageXMax - pageXMin;
+                const minColFraction = 0.3;
+                const tooNarrow = layout.columns.some((col) => {
+                    const colXMin = Math.min(...col.map((tb) => tb.bounds.left));
+                    const colXMax = Math.max(...col.map((tb) => tb.bounds.right));
+                    return (colXMax - colXMin) / pageWidth < minColFraction;
+                });
+                if (tooNarrow) {
+                    layout.columnCount = 1;
+                    layout.columns = [page.textBoxes];
+                    layout.boundaries = [];
+                }
+            }
             if (layout.columnCount === 1) {
                 // Single column — process normally
                 const md = processColumn(page.pageNumber, page.textBoxes, page.segments, imageBlocks);

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { GitHubConverter } from "./converters/github.js";
 export { HtmlConverter } from "./converters/html.js";
 export { ImageConverter } from "./converters/image.js";
 export { IpynbConverter } from "./converters/ipynb.js";
+export { IWorkConverter } from "./converters/iwork.js";
 export { JsonConverter } from "./converters/json.js";
 export { PdfConverter } from "./converters/pdf/index.js";
 export { PlainTextConverter } from "./converters/plain-text.js";

package/dist/index.js

@@ -6,6 +6,7 @@ export { GitHubConverter } from "./converters/github.js";
 export { HtmlConverter } from "./converters/html.js";
 export { ImageConverter } from "./converters/image.js";
 export { IpynbConverter } from "./converters/ipynb.js";
+export { IWorkConverter } from "./converters/iwork.js";
 export { JsonConverter } from "./converters/json.js";
 export { PdfConverter } from "./converters/pdf/index.js";
 export { PlainTextConverter } from "./converters/plain-text.js";

package/dist/markit.js

@@ -8,6 +8,7 @@ import { GitHubConverter } from "./converters/github.js";
 import { HtmlConverter } from "./converters/html.js";
 import { ImageConverter } from "./converters/image.js";
 import { IpynbConverter } from "./converters/ipynb.js";
+import { IWorkConverter } from "./converters/iwork.js";
 import { JsonConverter } from "./converters/json.js";
 import { PdfConverter } from "./converters/pdf/index.js";
 import { PlainTextConverter } from "./converters/plain-text.js";
@@ -33,6 +34,7 @@ export class Markit {
             new XlsxConverter(),
             new EpubConverter(),
             new IpynbConverter(),
+            new IWorkConverter(),
             new GitHubConverter(),
             new WikipediaConverter(),
             new RssConverter(),

package/dist/utils/turndown.js

@@ -51,8 +51,14 @@ export function createTurndown() {
  * - Strip <p> tags inside <td>/<th> cells
  */
 export function normalizeTablesHtml(html) {
-    // Strip <p> tags inside table cells
-    let result = html.replace(/<(td|th)([^>]*)>\s*<p>([\s\S]*?)<\/p>\s*<\/(td|th)>/gi, "<$1$2>$3</$4>");
+    // Strip <p> tags inside table cells, joining multiple paragraphs with <br>
+    let result = html.replace(/<(td|th)([^>]*)>([\s\S]*?)<\/(td|th)>/gi, (_match, tag, attrs, inner, closeTag) => {
+        const stripped = inner
+            .replace(/^\s*<p>/i, "")
+            .replace(/<\/p>\s*$/i, "")
+            .replace(/<\/p>\s*<p>/gi, " ");
+        return `<${tag}${attrs}>${stripped}</${closeTag}>`;
+    });
     // Add thead to tables that lack it
     result = result.replace(/<table([^>]*)>\s*(?:<tbody>\s*)?(<tr[\s\S]*?<\/tr>)([\s\S]*?)<\/(?:tbody>\s*<\/)?table>/gi, (_match, attrs, firstRow, rest) => {
         const theadRow = firstRow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markit-ai",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Convert anything to markdown. PDF, DOCX, PPTX, XLSX, HTML, EPUB, Jupyter, RSS, images, audio, URLs, and more. Pluggable converters, built-in LLM providers for image description and audio transcription. Works as a CLI and as a library.",
   "type": "module",
   "main": "dist/index.js",