markit-ai 0.1.0

package/dist/converters/image.js

@@ -0,0 +1,94 @@
+const EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".tiff", ".tif", ".bmp", ".svg"];
+const MIMETYPES = ["image/"];
+export class ImageConverter {
+    name = "image";
+    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, options) {
+        const sections = [];
+        // Extract EXIF metadata
+        try {
+            const exifr = await import("exifr");
+            const metadata = await exifr.parse(input, {
+                pick: [
+                    "ImageWidth", "ImageHeight", "Make", "Model",
+                    "DateTimeOriginal", "CreateDate", "GPSLatitude", "GPSLongitude",
+                    "Artist", "Copyright", "Description", "Title",
+                    "Keywords", "Software", "ExposureTime", "FNumber",
+                    "ISO", "FocalLength",
+                ],
+            });
+            if (metadata && Object.keys(metadata).length > 0) {
+                sections.push("## Metadata\n");
+                if (metadata.ImageWidth && metadata.ImageHeight) {
+                    sections.push(`ImageSize: ${metadata.ImageWidth}x${metadata.ImageHeight}`);
+                }
+                const fields = {
+                    Title: metadata.Title,
+                    Description: metadata.Description || metadata.ImageDescription,
+                    Keywords: Array.isArray(metadata.Keywords)
+                        ? metadata.Keywords.join(", ")
+                        : metadata.Keywords,
+                    Artist: metadata.Artist,
+                    Copyright: metadata.Copyright,
+                    Camera: [metadata.Make, metadata.Model].filter(Boolean).join(" "),
+                    DateTimeOriginal: metadata.DateTimeOriginal
+                        ? String(metadata.DateTimeOriginal)
+                        : undefined,
+                    CreateDate: metadata.CreateDate
+                        ? String(metadata.CreateDate)
+                        : undefined,
+                    GPS: metadata.GPSLatitude && metadata.GPSLongitude
+                        ? `${metadata.GPSLatitude}, ${metadata.GPSLongitude}`
+                        : undefined,
+                    ExposureTime: metadata.ExposureTime
+                        ? `1/${Math.round(1 / metadata.ExposureTime)}s`
+                        : undefined,
+                    FNumber: metadata.FNumber ? `f/${metadata.FNumber}` : undefined,
+                    ISO: metadata.ISO ? String(metadata.ISO) : undefined,
+                    FocalLength: metadata.FocalLength
+                        ? `${metadata.FocalLength}mm`
+                        : undefined,
+                    Software: metadata.Software,
+                };
+                for (const [key, value] of Object.entries(fields)) {
+                    if (value)
+                        sections.push(`${key}: ${value}`);
+                }
+            }
+        }
+        catch {
+            // EXIF parsing failed — not all images have EXIF
+        }
+        // AI description
+        if (options?.describe) {
+            try {
+                const mimetype = streamInfo.mimetype || guessMimetype(streamInfo.extension);
+                const description = await options.describe(input, mimetype);
+                if (description) {
+                    sections.push(`\n## Description\n\n${description}`);
+                }
+            }
+            catch {
+                // Description failed — continue without it
+            }
+        }
+        if (sections.length === 0) {
+            return { markdown: `*[image: ${streamInfo.filename || "unknown"}]*` };
+        }
+        return { markdown: sections.join("\n").trim() };
+    }
+}
+function guessMimetype(ext) {
+    const map = {
+        ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png",
+        ".gif": "image/gif", ".webp": "image/webp", ".tiff": "image/tiff",
+        ".tif": "image/tiff", ".bmp": "image/bmp", ".svg": "image/svg+xml",
+    };
+    return map[ext || ""] || "image/png";
+}

package/dist/converters/ipynb.d.ts

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

package/dist/converters/ipynb.js

@@ -0,0 +1,72 @@
+const EXTENSIONS = [".ipynb"];
+export class IpynbConverter {
+    name = "ipynb";
+    accepts(streamInfo) {
+        if (streamInfo.extension && EXTENSIONS.includes(streamInfo.extension))
+            return true;
+        return false;
+    }
+    async convert(input, _streamInfo) {
+        const text = new TextDecoder("utf-8").decode(input);
+        const notebook = JSON.parse(text);
+        const sections = [];
+        let title;
+        for (const cell of notebook.cells ?? []) {
+            const source = Array.isArray(cell.source)
+                ? cell.source.join("")
+                : cell.source ?? "";
+            if (cell.cell_type === "markdown") {
+                sections.push(source);
+                // Extract first heading as title
+                if (!title) {
+                    const match = source.match(/^# (.+)$/m);
+                    if (match)
+                        title = match[1].trim();
+                }
+            }
+            else if (cell.cell_type === "code") {
+                // Detect language from kernel
+                const lang = notebook.metadata?.kernelspec?.language ||
+                    notebook.metadata?.language_info?.name ||
+                    "python";
+                sections.push(`\`\`\`${lang}\n${source}\n\`\`\``);
+                // Include text outputs
+                const outputs = [];
+                for (const out of cell.outputs ?? []) {
+                    if (out.output_type === "stream") {
+                        const text = Array.isArray(out.text) ? out.text.join("") : out.text ?? "";
+                        if (text.trim())
+                            outputs.push(text.trim());
+                    }
+                    else if (out.output_type === "execute_result" || out.output_type === "display_data") {
+                        const data = out.data;
+                        if (data?.["text/plain"]) {
+                            const plain = Array.isArray(data["text/plain"])
+                                ? data["text/plain"].join("")
+                                : data["text/plain"];
+                            if (plain.trim())
+                                outputs.push(plain.trim());
+                        }
+                    }
+                    else if (out.output_type === "error") {
+                        const tb = (out.traceback ?? []).join("\n");
+                        if (tb.trim())
+                            outputs.push(`Error: ${out.ename}: ${out.evalue}`);
+                    }
+                }
+                if (outputs.length > 0) {
+                    sections.push(`\`\`\`\n${outputs.join("\n")}\n\`\`\``);
+                }
+            }
+            else if (cell.cell_type === "raw") {
+                sections.push(`\`\`\`\n${source}\n\`\`\``);
+            }
+        }
+        // Check metadata for title
+        title = notebook.metadata?.title ?? title;
+        return {
+            markdown: sections.join("\n\n").trim(),
+            title,
+        };
+    }
+}

package/dist/converters/json.d.ts

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

package/dist/converters/json.js

@@ -0,0 +1,21 @@
+const EXTENSIONS = [".json"];
+const MIMETYPES = ["application/json"];
+export class JsonConverter {
+    name = "json";
+    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("utf-8").decode(input);
+        const parsed = JSON.parse(text);
+        const pretty = JSON.stringify(parsed, null, 2);
+        return { markdown: `\`\`\`json\n${pretty}\n\`\`\`` };
+    }
+}

package/dist/converters/pdf.d.ts

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

package/dist/converters/pdf.js

@@ -0,0 +1,29 @@
+const EXTENSIONS = [".pdf"];
+const MIMETYPES = ["application/pdf", "application/x-pdf"];
+export class PdfConverter {
+    name = "pdf";
+    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) {
+        let extractText;
+        try {
+            ({ extractText } = await import("unpdf"));
+        }
+        catch {
+            throw new Error("PDF support requires 'unpdf'. Install it: npm install unpdf");
+        }
+        const result = await extractText(new Uint8Array(input));
+        const text = Array.isArray(result.text)
+            ? result.text.join("\n\n")
+            : String(result.text);
+        return { markdown: text.trim() };
+    }
+}

package/dist/converters/plain-text.d.ts

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

package/dist/converters/plain-text.js

@@ -0,0 +1,41 @@
+const TEXT_EXTENSIONS = [
+    ".txt", ".md", ".markdown", ".rst", ".log", ".cfg", ".ini", ".yaml", ".yml",
+    ".toml", ".xml", ".svg", ".env", ".sh", ".bash", ".zsh", ".fish",
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".go", ".rs", ".rb", ".java",
+    ".c", ".cpp", ".h", ".hpp", ".cs", ".swift", ".kt", ".scala",
+    ".sql", ".r", ".m", ".lua", ".pl", ".php", ".ex", ".exs",
+    ".zig", ".nim", ".v", ".d", ".hs", ".ml", ".clj",
+    ".makefile", ".dockerfile",
+];
+const TEXT_MIMETYPES = ["text/"];
+export class PlainTextConverter {
+    name = "plain-text";
+    accepts(streamInfo) {
+        if (streamInfo.extension && TEXT_EXTENSIONS.includes(streamInfo.extension)) {
+            return true;
+        }
+        if (streamInfo.mimetype &&
+            TEXT_MIMETYPES.some((m) => streamInfo.mimetype.startsWith(m))) {
+            return true;
+        }
+        // If nothing else matched and there's no extension, try to decode as text
+        if (!streamInfo.extension && !streamInfo.mimetype) {
+            return true;
+        }
+        return false;
+    }
+    async convert(input, streamInfo) {
+        const charset = streamInfo.charset || "utf-8";
+        const text = new TextDecoder(charset).decode(input);
+        // If it's already markdown, return as-is
+        if (streamInfo.extension === ".md" || streamInfo.extension === ".markdown") {
+            return { markdown: text };
+        }
+        // For code files, wrap in a fenced code block
+        const ext = streamInfo.extension?.slice(1);
+        if (ext && !["txt", "log", "rst"].includes(ext)) {
+            return { markdown: `\`\`\`${ext}\n${text}\n\`\`\`` };
+        }
+        return { markdown: text };
+    }
+}

package/dist/converters/pptx.d.ts

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

package/dist/converters/pptx.js

@@ -0,0 +1,189 @@
+import JSZip from "jszip";
+import { XMLParser } from "fast-xml-parser";
+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",
+        });
+        // 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");
+                const nb = parseInt(b.match(/slide(\d+)/)?.[1] || "0");
+                return na - nb;
+            });
+            slidePaths.push(...slideFiles);
+        }
+        const sections = [];
+        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;
+            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);
+                }
+            }
+            // 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");
+    }
+}

package/dist/converters/rss.d.ts

@@ -0,0 +1,11 @@
+import type { Converter, ConversionResult, 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/dist/converters/rss.js

@@ -0,0 +1,134 @@
+import TurndownService from "turndown";
+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 = new TurndownService({ headingStyle: "atx" });
+        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 = new TurndownService({ headingStyle: "atx" });
+        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;
+        while ((match = re.exec(xml)) !== null) {
+            results.push(match[0]);
+        }
+        return results;
+    }
+}

package/dist/converters/wikipedia.d.ts

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