@gajae-code/coding-agent 0.17.2 → 0.17.5

package/vendor/markit-ai/dist/converters/pptx.js

@@ -0,0 +1,289 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { XMLParser } from "fast-xml-parser";
+import JSZip from "jszip";
+const EXTENSIONS = [".pptx"];
+const MIMETYPES = [
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+];
+export class PptxConverter {
+    name = "pptx";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const zip = await JSZip.loadAsync(input);
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            processEntities: { maxTotalExpansions: 1_000_000 },
+        });
+        // Get slide order from presentation.xml
+        const presXml = await zip.file("ppt/presentation.xml")?.async("string");
+        if (!presXml)
+            throw new Error("Invalid PPTX: missing presentation.xml");
+        const pres = parser.parse(presXml);
+        const sldIdList = pres["p:presentation"]?.["p:sldIdLst"]?.["p:sldId"];
+        const sldIds = Array.isArray(sldIdList)
+            ? sldIdList
+            : sldIdList
+                ? [sldIdList]
+                : [];
+        // Get relationship mappings
+        const relsXml = await zip
+            .file("ppt/_rels/presentation.xml.rels")
+            ?.async("string");
+        const rels = relsXml ? parser.parse(relsXml) : null;
+        const relList = rels?.Relationships?.Relationship;
+        const relArray = Array.isArray(relList)
+            ? relList
+            : relList
+                ? [relList]
+                : [];
+        const relMap = new Map();
+        for (const r of relArray) {
+            relMap.set(r["@_Id"], r["@_Target"]);
+        }
+        // Map slide IDs to file paths in order
+        const slidePaths = [];
+        for (const sld of sldIds) {
+            const rId = sld["@_r:id"];
+            const target = relMap.get(rId);
+            if (target)
+                slidePaths.push(`ppt/${target}`);
+        }
+        // If we couldn't resolve from rels, fall back to finding slide files
+        if (slidePaths.length === 0) {
+            const slideFiles = Object.keys(zip.files)
+                .filter((f) => /^ppt\/slides\/slide\d+\.xml$/.test(f))
+                .sort((a, b) => {
+                const na = parseInt(a.match(/slide(\d+)/)?.[1] || "0", 10);
+                const nb = parseInt(b.match(/slide(\d+)/)?.[1] || "0", 10);
+                return na - nb;
+            });
+            slidePaths.push(...slideFiles);
+        }
+        const imageDir = streamInfo.imageDir;
+        if (imageDir) {
+            mkdirSync(imageDir, { recursive: true });
+        }
+        const sections = [];
+        let imageCount = 0;
+        for (let i = 0; i < slidePaths.length; i++) {
+            const slideXml = await zip.file(slidePaths[i])?.async("string");
+            if (!slideXml)
+                continue;
+            const slide = parser.parse(slideXml);
+            const spTree = slide["p:sld"]?.["p:cSld"]?.["p:spTree"];
+            if (!spTree)
+                continue;
+            // Parse slide-level rels for image references
+            const slideRelsPath = `${slidePaths[i].replace("slides/slide", "slides/_rels/slide")}.rels`;
+            const slideRelsXml = await zip.file(slideRelsPath)?.async("string");
+            const slideRelMap = new Map();
+            if (slideRelsXml) {
+                const slideRels = parser.parse(slideRelsXml);
+                const relItems = toList(slideRels?.Relationships?.Relationship);
+                for (const r of relItems) {
+                    slideRelMap.set(r["@_Id"], r["@_Target"]);
+                }
+            }
+            const slideLines = [`<!-- Slide ${i + 1} -->`];
+            const shapes = spTree["p:sp"];
+            const shapeList = Array.isArray(shapes) ? shapes : shapes ? [shapes] : [];
+            let isTitle = true;
+            for (const shape of shapeList) {
+                const text = this.extractText(shape);
+                if (!text)
+                    continue;
+                if (isTitle) {
+                    slideLines.push(`# ${text}`);
+                    isTitle = false;
+                }
+                else {
+                    slideLines.push(text);
+                }
+            }
+            // Extract embedded images
+            const pics = toList(spTree["p:pic"]);
+            for (const pic of pics) {
+                const blipFill = pic["p:blipFill"];
+                const rEmbed = blipFill?.["a:blip"]?.["@_r:embed"];
+                if (!rEmbed)
+                    continue;
+                const target = slideRelMap.get(rEmbed);
+                if (!target)
+                    continue;
+                // Resolve relative target against slide directory
+                const imagePath = target.startsWith("/")
+                    ? target.slice(1)
+                    : `ppt/slides/${target}`;
+                // Normalize path (e.g. ppt/slides/../media/image1.png → ppt/media/image1.png)
+                const normalizedPath = imagePath
+                    .split("/")
+                    .reduce((parts, seg) => {
+                    if (seg === "..")
+                        parts.pop();
+                    else
+                        parts.push(seg);
+                    return parts;
+                }, [])
+                    .join("/");
+                const imageFile = zip.file(normalizedPath);
+                if (!imageFile)
+                    continue;
+                imageCount++;
+                const name = pic["p:nvSpPr"]?.["p:cNvPr"]?.["@_name"] ||
+                    pic["p:nvPicPr"]?.["p:cNvPr"]?.["@_name"] ||
+                    `image_${imageCount}`;
+                if (imageDir) {
+                    try {
+                        const ext = normalizedPath.split(".").pop() || "png";
+                        const filename = `slide${i + 1}_${imageCount}.${ext}`;
+                        const filepath = join(imageDir, filename);
+                        const buf = await imageFile.async("nodebuffer");
+                        writeFileSync(filepath, buf);
+                        slideLines.push(`![${name}](${filepath})`);
+                    }
+                    catch {
+                        slideLines.push(`<!-- image: ${name} (slide ${i + 1}) -->`);
+                    }
+                }
+                else {
+                    slideLines.push(`<!-- image: ${name} (slide ${i + 1}) -->`);
+                }
+            }
+            // Tables
+            const graphicFrames = spTree["p:graphicFrame"];
+            const gfList = Array.isArray(graphicFrames)
+                ? graphicFrames
+                : graphicFrames
+                    ? [graphicFrames]
+                    : [];
+            for (const gf of gfList) {
+                const table = this.extractTable(gf);
+                if (table)
+                    slideLines.push(table);
+            }
+            // Slide notes
+            const noteFile = slidePaths[i].replace("slides/slide", "notesSlides/notesSlide");
+            const noteXml = await zip.file(noteFile)?.async("string");
+            if (noteXml) {
+                const note = parser.parse(noteXml);
+                const noteSpTree = note["p:notes"]?.["p:cSld"]?.["p:spTree"];
+                if (noteSpTree) {
+                    const noteShapes = noteSpTree["p:sp"];
+                    const noteList = Array.isArray(noteShapes)
+                        ? noteShapes
+                        : noteShapes
+                            ? [noteShapes]
+                            : [];
+                    const noteTexts = [];
+                    for (const ns of noteList) {
+                        // Skip slide image placeholder
+                        const phType = ns["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"]?.["@_type"];
+                        if (phType === "sldImg")
+                            continue;
+                        const t = this.extractText(ns);
+                        if (t)
+                            noteTexts.push(t);
+                    }
+                    if (noteTexts.length > 0) {
+                        slideLines.push("\n### Notes:");
+                        slideLines.push(noteTexts.join("\n"));
+                    }
+                }
+            }
+            sections.push(slideLines.join("\n"));
+        }
+        return { markdown: sections.join("\n\n").trim() };
+    }
+    extractText(shape) {
+        const txBody = shape["p:txBody"];
+        if (!txBody)
+            return "";
+        const paragraphs = txBody["a:p"];
+        const pList = Array.isArray(paragraphs)
+            ? paragraphs
+            : paragraphs
+                ? [paragraphs]
+                : [];
+        const lines = [];
+        for (const p of pList) {
+            const runs = p["a:r"];
+            const rList = Array.isArray(runs) ? runs : runs ? [runs] : [];
+            const parts = [];
+            for (const r of rList) {
+                const t = r["a:t"];
+                if (t != null)
+                    parts.push(typeof t === "object" ? t["#text"] || "" : String(t));
+            }
+            if (parts.length > 0)
+                lines.push(parts.join(""));
+        }
+        return lines.join("\n").trim();
+    }
+    extractTable(gf) {
+        const tbl = gf?.["a:graphic"]?.["a:graphicData"]?.["a:tbl"];
+        if (!tbl)
+            return null;
+        const rows = tbl["a:tr"];
+        const rowList = Array.isArray(rows) ? rows : rows ? [rows] : [];
+        if (rowList.length === 0)
+            return null;
+        const mdRows = [];
+        for (const row of rowList) {
+            const cells = row["a:tc"];
+            const cellList = Array.isArray(cells) ? cells : cells ? [cells] : [];
+            const cellTexts = [];
+            for (const cell of cellList) {
+                const txBody = cell["a:txBody"];
+                if (!txBody) {
+                    cellTexts.push("");
+                    continue;
+                }
+                const paragraphs = txBody["a:p"];
+                const pList = Array.isArray(paragraphs)
+                    ? paragraphs
+                    : paragraphs
+                        ? [paragraphs]
+                        : [];
+                const parts = [];
+                for (const p of pList) {
+                    const runs = p["a:r"];
+                    const rList = Array.isArray(runs) ? runs : runs ? [runs] : [];
+                    for (const r of rList) {
+                        const t = r["a:t"];
+                        if (t != null)
+                            parts.push(typeof t === "object" ? t["#text"] || "" : String(t));
+                    }
+                }
+                cellTexts.push(parts.join(" "));
+            }
+            mdRows.push(cellTexts);
+        }
+        if (mdRows.length === 0)
+            return null;
+        const [header, ...body] = mdRows;
+        const lines = [];
+        lines.push(`| ${header.join(" | ")} |`);
+        lines.push(`| ${header.map(() => "---").join(" | ")} |`);
+        for (const row of body) {
+            while (row.length < header.length)
+                row.push("");
+            lines.push(`| ${row.join(" | ")} |`);
+        }
+        return lines.join("\n");
+    }
+}
+function toList(val) {
+    if (!val)
+        return [];
+    return Array.isArray(val) ? val : [val];
+}

package/vendor/markit-ai/dist/converters/rss.d.ts

@@ -0,0 +1,11 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class RssConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
+    private parseRss;
+    private parseAtom;
+    private htmlToMd;
+    private extract;
+    private extractAll;
+}

package/vendor/markit-ai/dist/converters/rss.js

@@ -0,0 +1,138 @@
+import { createTurndown } from "../utils/turndown.js";
+const _EXTENSIONS = [".rss", ".atom", ".xml"];
+const MIMETYPES = [
+    "application/rss+xml",
+    "application/rss",
+    "application/atom+xml",
+    "application/atom",
+    "text/xml",
+    "application/xml",
+];
+export class RssConverter {
+    name = "rss";
+    accepts(streamInfo) {
+        // Only accept known RSS/Atom extensions directly
+        if (streamInfo.extension &&
+            [".rss", ".atom"].includes(streamInfo.extension))
+            return true;
+        // For .xml, we'll try and fail gracefully
+        if (streamInfo.extension === ".xml")
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, _streamInfo) {
+        const text = new TextDecoder("utf-8").decode(input);
+        // Detect feed type
+        if (text.includes("<rss")) {
+            return this.parseRss(text);
+        }
+        else if (text.includes("<feed")) {
+            return this.parseAtom(text);
+        }
+        // Not a feed — fall through for XML as generic text
+        throw new Error("Not an RSS or Atom feed");
+    }
+    parseRss(xml) {
+        const turndown = createTurndown();
+        const sections = [];
+        // Extract from the <channel> block specifically
+        const channelMatch = xml.match(/<channel>([\s\S]*?)<\/channel>/i);
+        const channelXml = channelMatch ? channelMatch[1] : xml;
+        const channelTitle = this.extract(channelXml, "title");
+        const channelDesc = this.extract(channelXml, "description");
+        if (channelTitle)
+            sections.push(`# ${channelTitle}`);
+        if (channelDesc)
+            sections.push(this.htmlToMd(channelDesc, turndown));
+        // Extract items
+        const items = this.extractAll(xml, "item");
+        for (const item of items) {
+            const title = this.extract(item, "title");
+            const pubDate = this.extract(item, "pubDate");
+            const description = this.extract(item, "description");
+            const content = this.extract(item, "content:encoded");
+            const link = this.extract(item, "link");
+            const parts = [];
+            if (title)
+                parts.push(`## ${title}`);
+            if (pubDate)
+                parts.push(`Published: ${pubDate}`);
+            if (link)
+                parts.push(`[Link](${link})`);
+            if (content) {
+                parts.push(this.htmlToMd(content, turndown));
+            }
+            else if (description) {
+                parts.push(this.htmlToMd(description, turndown));
+            }
+            if (parts.length > 0)
+                sections.push(parts.join("\n"));
+        }
+        return { markdown: sections.join("\n\n").trim(), title: channelTitle };
+    }
+    parseAtom(xml) {
+        const turndown = createTurndown();
+        const sections = [];
+        const feedTitle = this.extract(xml, "title");
+        const subtitle = this.extract(xml, "subtitle");
+        if (feedTitle)
+            sections.push(`# ${feedTitle}`);
+        if (subtitle)
+            sections.push(subtitle);
+        const entries = this.extractAll(xml, "entry");
+        for (const entry of entries) {
+            const title = this.extract(entry, "title");
+            const updated = this.extract(entry, "updated");
+            const summary = this.extract(entry, "summary");
+            const content = this.extract(entry, "content");
+            const parts = [];
+            if (title)
+                parts.push(`## ${title}`);
+            if (updated)
+                parts.push(`Updated: ${updated}`);
+            if (content) {
+                parts.push(this.htmlToMd(content, turndown));
+            }
+            else if (summary) {
+                parts.push(this.htmlToMd(summary, turndown));
+            }
+            if (parts.length > 0)
+                sections.push(parts.join("\n"));
+        }
+        return { markdown: sections.join("\n\n").trim(), title: feedTitle };
+    }
+    htmlToMd(html, turndown) {
+        // Unescape CDATA and HTML entities that might be in RSS
+        const unescaped = html
+            .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&amp;/g, "&");
+        // If it looks like HTML, convert it
+        if (unescaped.includes("<")) {
+            return turndown.turndown(unescaped).trim();
+        }
+        return unescaped.trim();
+    }
+    extract(xml, tag) {
+        // Handle both <tag>content</tag> and <tag><![CDATA[content]]></tag>
+        const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i");
+        const match = xml.match(re);
+        if (!match)
+            return undefined;
+        return (match[1].replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1").trim() || undefined);
+    }
+    extractAll(xml, tag) {
+        const results = [];
+        const re = new RegExp(`<${tag}[^>]*>[\\s\\S]*?</${tag}>`, "gi");
+        let match = re.exec(xml);
+        while (match !== null) {
+            results.push(match[0]);
+            match = re.exec(xml);
+        }
+        return results;
+    }
+}

package/vendor/markit-ai/dist/converters/wikipedia.d.ts

@@ -0,0 +1,6 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class WikipediaConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/vendor/markit-ai/dist/converters/wikipedia.js

@@ -0,0 +1,33 @@
+import { createTurndown } from "../utils/turndown.js";
+const WIKIPEDIA_RE = /^https?:\/\/[a-zA-Z]{2,3}\.wikipedia\.org\//;
+export class WikipediaConverter {
+    name = "wikipedia";
+    accepts(streamInfo) {
+        if (!streamInfo.url)
+            return false;
+        return WIKIPEDIA_RE.test(streamInfo.url);
+    }
+    async convert(input, streamInfo) {
+        const html = new TextDecoder(streamInfo.charset || "utf-8").decode(input);
+        // Extract the main content div
+        const contentMatch = html.match(/<div[^>]*id="mw-content-text"[^>]*>([\s\S]*?)<\/div>\s*(?:<\/div>|$)/i);
+        // Extract title
+        const titleMatch = html.match(/<span[^>]*class="mw-page-title-main"[^>]*>([\s\S]*?)<\/span>/i) || html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+        const title = titleMatch
+            ? titleMatch[1].replace(/ - Wikipedia$/, "").trim()
+            : undefined;
+        const turndown = createTurndown();
+        // Clean up Wikipedia-specific elements
+        let content = contentMatch ? contentMatch[1] : html;
+        content = content
+            .replace(/<script[\s\S]*?<\/script>/gi, "")
+            .replace(/<style[\s\S]*?<\/style>/gi, "")
+            .replace(/<div[^>]*class="[^"]*mw-editsection[^"]*"[\s\S]*?<\/div>/gi, "") // edit links
+            .replace(/<sup[^>]*class="[^"]*reference[^"]*"[\s\S]*?<\/sup>/gi, "") // reference numbers
+            .replace(/<div[^>]*class="[^"]*navbox[\s\S]*?<\/div>/gi, "") // navboxes
+            .replace(/<table[^>]*class="[^"]*sidebar[\s\S]*?<\/table>/gi, ""); // sidebars
+        const markdown = turndown.turndown(content).trim();
+        const result = title ? `# ${title}\n\n${markdown}` : markdown;
+        return { markdown: result, title };
+    }
+}

package/vendor/markit-ai/dist/converters/xlsx.d.ts

@@ -0,0 +1,8 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class XlsxConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
+    private getCellValue;
+    private getSharedString;
+}

package/vendor/markit-ai/dist/converters/xlsx.js

@@ -0,0 +1,147 @@
+import { XMLParser } from "fast-xml-parser";
+import JSZip from "jszip";
+const EXTENSIONS = [".xlsx"];
+const MIMETYPES = [
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+];
+export class XlsxConverter {
+    name = "xlsx";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, _streamInfo) {
+        const zip = await JSZip.loadAsync(input);
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            textNodeName: "#text",
+            processEntities: { maxTotalExpansions: 1_000_000 },
+        });
+        // Parse shared strings
+        const ssXml = await zip.file("xl/sharedStrings.xml")?.async("string");
+        const ss = ssXml ? parser.parse(ssXml) : null;
+        const siList = ss?.sst?.si;
+        const shared = toArray(siList);
+        // Parse workbook for sheet names
+        const wbXml = await zip.file("xl/workbook.xml")?.async("string");
+        if (!wbXml)
+            throw new Error("Invalid XLSX: missing workbook.xml");
+        const wb = parser.parse(wbXml);
+        const sheets = toArray(wb.workbook?.sheets?.sheet);
+        // Parse workbook rels to map rIds to sheet files
+        const relsXml = await zip
+            .file("xl/_rels/workbook.xml.rels")
+            ?.async("string");
+        const rels = relsXml ? parser.parse(relsXml) : null;
+        const relList = toArray(rels?.Relationships?.Relationship);
+        const relMap = new Map();
+        for (const r of relList) {
+            relMap.set(r["@_Id"], r["@_Target"]);
+        }
+        const sections = [];
+        for (const sheet of sheets) {
+            const sheetName = sheet["@_name"];
+            const rId = sheet["@_r:id"];
+            const target = relMap.get(rId);
+            if (!target)
+                continue;
+            const sheetPath = target.startsWith("/")
+                ? target.slice(1)
+                : `xl/${target}`;
+            const sheetXml = await zip.file(sheetPath)?.async("string");
+            if (!sheetXml)
+                continue;
+            const parsed = parser.parse(sheetXml);
+            const rows = toArray(parsed.worksheet?.sheetData?.row);
+            if (rows.length === 0)
+                continue;
+            // Extract all rows as string arrays
+            const tableRows = [];
+            for (const row of rows) {
+                const cells = toArray(row.c);
+                const values = [];
+                for (const cell of cells) {
+                    values.push(this.getCellValue(cell, shared));
+                }
+                tableRows.push(values);
+            }
+            if (tableRows.length === 0)
+                continue;
+            // Normalize column count
+            const maxCols = Math.max(...tableRows.map((r) => r.length));
+            for (const row of tableRows) {
+                while (row.length < maxCols)
+                    row.push("");
+            }
+            sections.push(`## ${sheetName}`);
+            const [header, ...body] = tableRows;
+            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") };
+    }
+    getCellValue(cell, shared) {
+        // Shared string
+        if (cell["@_t"] === "s") {
+            return this.getSharedString(shared, Number(cell.v));
+        }
+        // Inline string
+        if (cell["@_t"] === "inlineStr") {
+            const is = cell.is;
+            if (!is)
+                return "";
+            if (is.t != null)
+                return textValue(is.t);
+            if (is.r)
+                return toArray(is.r)
+                    .map((r) => textValue(r.t))
+                    .join("");
+            return "";
+        }
+        // Boolean
+        if (cell["@_t"] === "b") {
+            return cell.v === 1 || cell.v === "1" ? "TRUE" : "FALSE";
+        }
+        // Number or formula result
+        if (cell.v != null)
+            return String(cell.v);
+        return "";
+    }
+    getSharedString(shared, idx) {
+        const si = shared[idx];
+        if (!si)
+            return "";
+        // Simple text
+        if (si.t != null)
+            return textValue(si.t);
+        // Rich text runs
+        if (si.r) {
+            return toArray(si.r)
+                .map((r) => textValue(r.t))
+                .join("");
+        }
+        return "";
+    }
+}
+function textValue(t) {
+    if (t == null)
+        return "";
+    if (typeof t === "object")
+        return t["#text"] || "";
+    return String(t);
+}
+function toArray(val) {
+    if (!val)
+        return [];
+    return Array.isArray(val) ? val : [val];
+}

package/vendor/markit-ai/dist/converters/xml.d.ts

@@ -0,0 +1,6 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class XmlConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}

package/vendor/markit-ai/dist/converters/xml.js

@@ -0,0 +1,18 @@
+const EXTENSIONS = [".xml", ".svg"];
+const MIMETYPES = ["text/xml", "application/xml"];
+export class XmlConverter {
+    name = "xml";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        if (streamInfo.mimetype &&
+            MIMETYPES.some((m) => streamInfo.mimetype?.startsWith(m)))
+            return true;
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const text = new TextDecoder(streamInfo.charset || "utf-8").decode(input);
+        const ext = streamInfo.extension?.slice(1) || "xml";
+        return { markdown: `\`\`\`${ext}\n${text}\n\`\`\`` };
+    }
+}

package/vendor/markit-ai/dist/converters/yaml.d.ts

@@ -0,0 +1,6 @@
+import type { ConversionResult, Converter, StreamInfo } from "../types.js";
+export declare class YamlConverter implements Converter {
+    name: string;
+    accepts(streamInfo: StreamInfo): boolean;
+    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+}