@wsqc2026/markitdown-typescript 0.1.0

package/dist/index.js

@@ -0,0 +1,3184 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/converter.ts
+function byMime(...mimes) {
+  return (ctx) => {
+    const mimetype = (ctx.info.mimetype ?? "").toLowerCase();
+    if (!mimetype)
+      return false;
+    return mimes.some((m) => {
+      if (m.endsWith("/*")) {
+        return mimetype.startsWith(m.slice(0, -1));
+      }
+      return mimetype.startsWith(m);
+    });
+  };
+}
+function byExt(...exts) {
+  return (ctx) => {
+    const ext = (ctx.info.extension ?? "").toLowerCase();
+    if (!ext)
+      return false;
+    return exts.some((e) => ext === e.toLowerCase());
+  };
+}
+function byUrl(pattern) {
+  return (ctx) => {
+    const url = ctx.info.url ?? "";
+    if (!url)
+      return false;
+    return pattern.test(url);
+  };
+}
+function anyOf(...matchers) {
+  return (ctx) => matchers.some((m) => m(ctx));
+}
+function allOf(...matchers) {
+  return (ctx) => matchers.every((m) => m(ctx));
+}
+function hasCharset() {
+  return (ctx) => ctx.info.charset != null;
+}
+function converter(name, match, convert) {
+  return { name, match, convert };
+}
+// src/converters/exiftool.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function parseVersion(version) {
+  return version.split(".").map((s) => parseInt(s, 10));
+}
+function compareVersions(a, b) {
+  for (let i = 0;i < Math.max(a.length, b.length); i++) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    if (av !== bv)
+      return av - bv;
+  }
+  return 0;
+}
+async function exiftoolMetadata(buffer, exiftoolPath) {
+  if (!exiftoolPath)
+    return {};
+  try {
+    const { stdout } = await execFileAsync(exiftoolPath, ["-ver"]);
+    const version = parseVersion(stdout.trim());
+    if (compareVersions(version, [12, 24]) < 0) {
+      throw new Error(`ExifTool version ${stdout.trim()} is vulnerable to CVE-2021-22204. Please upgrade to version 12.24 or later.`);
+    }
+  } catch (e) {
+    if (e.message?.includes("CVE"))
+      throw e;
+    throw new Error("Failed to verify ExifTool version.");
+  }
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const proc = spawn(exiftoolPath, ["-json", "-"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const chunks = [];
+      proc.stdout.on("data", (chunk) => chunks.push(chunk));
+      proc.on("close", (_code) => {
+        resolve(Buffer.concat(chunks).toString("utf-8"));
+      });
+      proc.on("error", reject);
+      proc.stdin.write(buffer);
+      proc.stdin.end();
+    });
+    const parsed = JSON.parse(result);
+    return parsed[0] ?? {};
+  } catch {
+    return {};
+  }
+}
+
+// src/converters/audio.ts
+var ACCEPTED_EXTENSIONS = [".wav", ".mp3", ".m4a", ".mp4"];
+var ACCEPTED_MIME_PREFIXES = ["audio/x-wav", "audio/mpeg", "video/mp4"];
+var AUDIO_METADATA_FIELDS = [
+  "Title",
+  "Artist",
+  "Author",
+  "Band",
+  "Album",
+  "Genre",
+  "Track",
+  "DateTimeOriginal",
+  "CreateDate",
+  "NumChannels",
+  "SampleRate",
+  "AvgBytesPerSec",
+  "BitsPerSample"
+];
+var audioConverter = converter("Audio", anyOf(byExt(...ACCEPTED_EXTENSIONS), byMime(...ACCEPTED_MIME_PREFIXES)), async (ctx) => {
+  let md = "";
+  const metadata = await exiftoolMetadata(ctx.buffer, ctx.opts.exiftoolPath);
+  const metaLines = [];
+  for (const field of AUDIO_METADATA_FIELDS) {
+    if (metadata[field]) {
+      metaLines.push(`- **${field}:** ${metadata[field]}`);
+    }
+  }
+  if (metaLines.length) {
+    md += `# Audio Metadata
+
+${metaLines.join(`
+`)}
+`;
+  }
+  return { markdown: md.trim() };
+});
+// src/converters/bing-serp.ts
+import * as cheerio from "cheerio";
+import TurndownService from "turndown";
+
+// src/transforms/decode-text.ts
+import iconv from "iconv-lite";
+function decodeBuffer(buffer, charset) {
+  const encoding = charset ?? "utf-8";
+  try {
+    const decoder = new TextDecoder(encoding, { fatal: true });
+    return decoder.decode(buffer);
+  } catch {}
+  if (iconv.encodingExists(encoding)) {
+    return iconv.decode(buffer, encoding);
+  }
+  return new TextDecoder("utf-8", { fatal: false }).decode(buffer);
+}
+
+// src/converters/bing-serp.ts
+var ACCEPTED_EXTENSIONS2 = [".html", ".htm"];
+var ACCEPTED_MIME_PREFIXES2 = ["text/html", "application/xhtml"];
+function decodeRedirectUrl(href) {
+  try {
+    const url = new URL(href);
+    const u = url.searchParams.get("u");
+    if (!u)
+      return href;
+    const encoded = `${u.slice(2).trim()}==`;
+    const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = Buffer.from(normalized, "base64").toString("utf-8");
+    return decoded;
+  } catch {
+    return href;
+  }
+}
+var bingSerpConverter = converter("BingSerp", allOf(byUrl(/^https:\/\/www\.bing\.com\/search\?q=/), anyOf(byExt(...ACCEPTED_EXTENSIONS2), byMime(...ACCEPTED_MIME_PREFIXES2))), async (ctx) => {
+  const encoding = ctx.info.charset ?? "utf-8";
+  const html = decodeBuffer(ctx.buffer, encoding);
+  const $ = cheerio.load(html);
+  const url = ctx.info.url ?? "";
+  let query = "";
+  try {
+    const parsed = new URL(url);
+    query = parsed.searchParams.get("q") || "";
+  } catch {}
+  $(".tptt").each((_, el) => {
+    const $el = $(el);
+    const text = $el.text();
+    if (text)
+      $el.text(`${text} `);
+  });
+  $(".algoSlug_icon").remove();
+  const td = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced"
+  });
+  td.addRule("links", {
+    filter: "a",
+    replacement(content, node) {
+      const el = node;
+      let href = el.getAttribute("href") || "";
+      const title2 = el.getAttribute("title") || "";
+      if (!content.trim())
+        return "";
+      if (href.includes("bing.com") && href.includes("u=")) {
+        href = decodeRedirectUrl(href);
+      }
+      const titlePart = title2 ? ` "${title2.replace(/"/g, "\\\"")}"` : "";
+      return href ? `[${content}](${href}${titlePart})` : content;
+    }
+  });
+  td.addRule("images", {
+    filter: "img",
+    replacement(_content, node) {
+      const el = node;
+      const src = el.getAttribute("src") || "";
+      if (src.startsWith("data:"))
+        return "";
+      const alt = (el.getAttribute("alt") || "").replace(/\n/g, " ");
+      return `![${alt}](${src})`;
+    }
+  });
+  const results = [];
+  $(".b_algo").each((_, el) => {
+    const resultHtml = $(el).html();
+    if (!resultHtml)
+      return;
+    const mdResult = td.turndown(resultHtml).trim();
+    const lines = mdResult.split(/\n+/).map((l) => l.trim()).filter((l) => l.length > 0);
+    results.push(lines.join(`
+`));
+  });
+  const title = $("title").first().text() || undefined;
+  const markdown = `## A Bing search for '${query}' found the following results:
+
+${results.join(`
+
+`)}`;
+  return { markdown, title };
+});
+// src/converters/csv.ts
+var ACCEPTED_EXTENSIONS3 = [".csv"];
+var ACCEPTED_MIME_PREFIXES3 = ["text/csv", "application/csv"];
+function parseCsvLine(line) {
+  const fields = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < line.length && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ",") {
+        fields.push(current);
+        current = "";
+      } else {
+        current += ch;
+      }
+    }
+  }
+  fields.push(current);
+  return fields;
+}
+function parseCsv(text) {
+  const rows = [];
+  let current = "";
+  let inQuotes = false;
+  const lines = text.split(/\r?\n/);
+  for (const line of lines) {
+    if (inQuotes) {
+      current += `
+${line}`;
+    } else {
+      if (current.trim() !== "" || rows.length > 0) {
+        if (current.trim() !== "")
+          rows.push(parseCsvLine(current));
+      }
+      current = line;
+    }
+    let quotes = 0;
+    for (let i = 0;i < line.length; i++) {
+      if (line[i] === '"') {
+        if (i + 1 < line.length && line[i + 1] === '"') {
+          i++;
+        } else {
+          quotes++;
+        }
+      }
+    }
+    if (quotes % 2 !== 0)
+      inQuotes = !inQuotes;
+  }
+  if (current.trim() !== "")
+    rows.push(parseCsvLine(current));
+  return rows;
+}
+var csvConverter = converter("CSV", anyOf(byExt(...ACCEPTED_EXTENSIONS3), byMime(...ACCEPTED_MIME_PREFIXES3)), async (ctx) => {
+  const text = decodeBuffer(ctx.buffer, ctx.info.charset);
+  const rows = parseCsv(text);
+  if (rows.length === 0) {
+    return { markdown: "" };
+  }
+  const header = rows[0];
+  const numCols = header.length;
+  const mdLines = [];
+  mdLines.push(`| ${header.join(" | ")} |`);
+  mdLines.push(`| ${header.map(() => "---").join(" | ")} |`);
+  for (let i = 1;i < rows.length; i++) {
+    let row = rows[i];
+    while (row.length < numCols)
+      row.push("");
+    row = row.slice(0, numCols);
+    mdLines.push(`| ${row.join(" | ")} |`);
+  }
+  return { markdown: mdLines.join(`
+`) };
+});
+// src/converters/docx.ts
+import mammoth from "mammoth";
+
+// src/converter-utils/docx/pre-process.ts
+import JSZip from "jszip";
+
+// src/converter-utils/docx/latex-dict.ts
+var CHARS = new Set(["{", "}", "_", "^", "#", "&", "$", "%", "~"]);
+var BLANK = "";
+var BACKSLASH = "\\";
+var ALN = "&";
+var BRK = "\\\\";
+var FUNC_PLACE = "{fe}";
+var CHR = {
+  "̀": "\\grave{{{0}}}",
+  "́": "\\acute{{{0}}}",
+  "̂": "\\hat{{{0}}}",
+  "̃": "\\tilde{{{0}}}",
+  "̄": "\\bar{{{0}}}",
+  "̅": "\\overbar{{{0}}}",
+  "̆": "\\breve{{{0}}}",
+  "̇": "\\dot{{{0}}}",
+  "̈": "\\ddot{{{0}}}",
+  "̉": "\\ovhook{{{0}}}",
+  "̊": "\\ocirc{{{0}}}",
+  "̌": "\\check{{{0}}}",
+  "̐": "\\candra{{{0}}}",
+  "̒": "\\oturnedcomma{{{0}}}",
+  "̕": "\\ocommatopright{{{0}}}",
+  "̚": "\\droang{{{0}}}",
+  "̸": "\\not{{{0}}}",
+  "⃐": "\\leftharpoonaccent{{{0}}}",
+  "⃑": "\\rightharpoonaccent{{{0}}}",
+  "⃒": "\\vertoverlay{{{0}}}",
+  "⃖": "\\overleftarrow{{{0}}}",
+  "⃗": "\\vec{{{0}}}",
+  "⃛": "\\dddot{{{0}}}",
+  "⃜": "\\ddddot{{{0}}}",
+  "⃡": "\\overleftrightarrow{{{0}}}",
+  "⃧": "\\annuity{{{0}}}",
+  "⃩": "\\widebridgeabove{{{0}}}",
+  "⃰": "\\asteraccent{{{0}}}",
+  "̰": "\\wideutilde{{{0}}}",
+  "̱": "\\underbar{{{0}}}",
+  "⃨": "\\threeunderdot{{{0}}}",
+  "⃬": "\\underrightharpoondown{{{0}}}",
+  "⃭": "\\underleftharpoondown{{{0}}}",
+  "⃮": "\\underledtarrow{{{0}}}",
+  "⃯": "\\underrightarrow{{{0}}}",
+  "⎴": "\\overbracket{{{0}}}",
+  "⏜": "\\overparen{{{0}}}",
+  "⏞": "\\overbrace{{{0}}}",
+  "⎵": "\\underbracket{{{0}}}",
+  "⏝": "\\underparen{{{0}}}",
+  "⏟": "\\underbrace{{{0}}}"
+};
+var CHR_BO = {
+  "⅀": "\\Bbbsum",
+  "∏": "\\prod",
+  "∐": "\\coprod",
+  "∑": "\\sum",
+  "∫": "\\int",
+  "⋀": "\\bigwedge",
+  "⋁": "\\bigvee",
+  "⋂": "\\bigcap",
+  "⋃": "\\bigcup",
+  "⨀": "\\bigodot",
+  "⨁": "\\bigoplus",
+  "⨂": "\\bigotimes"
+};
+var T = {
+  "→": "\\rightarrow ",
+  "\uD835\uDEFC": "\\alpha ",
+  "\uD835\uDEFD": "\\beta ",
+  "\uD835\uDEFE": "\\gamma ",
+  "\uD835\uDEFF": "\\theta ",
+  "\uD835\uDF00": "\\epsilon ",
+  "\uD835\uDF01": "\\zeta ",
+  "\uD835\uDF02": "\\eta ",
+  "\uD835\uDF03": "\\theta ",
+  "\uD835\uDF04": "\\iota ",
+  "\uD835\uDF05": "\\kappa ",
+  "\uD835\uDF06": "\\lambda ",
+  "\uD835\uDF07": "\\m ",
+  "\uD835\uDF08": "\\n ",
+  "\uD835\uDF09": "\\xi ",
+  "\uD835\uDF0A": "\\omicron ",
+  "\uD835\uDF0B": "\\pi ",
+  "\uD835\uDF0C": "\\rho ",
+  "\uD835\uDF0D": "\\varsigma ",
+  "\uD835\uDF0E": "\\sigma ",
+  "\uD835\uDF0F": "\\ta ",
+  "\uD835\uDF10": "\\upsilon ",
+  "\uD835\uDF11": "\\phi ",
+  "\uD835\uDF12": "\\chi ",
+  "\uD835\uDF13": "\\psi ",
+  "\uD835\uDF14": "\\omega ",
+  "\uD835\uDF15": "\\partial ",
+  "\uD835\uDF16": "\\varepsilon ",
+  "\uD835\uDF17": "\\vartheta ",
+  "\uD835\uDF18": "\\varkappa ",
+  "\uD835\uDF19": "\\varphi ",
+  "\uD835\uDF1A": "\\varrho ",
+  "\uD835\uDF1B": "\\varpi ",
+  "←": "\\leftarrow ",
+  "↑": "\\uparrow ",
+  "↓": "\\downright ",
+  "↔": "\\leftrightarrow ",
+  "↕": "\\updownarrow ",
+  "↖": "\\nwarrow ",
+  "↗": "\\nearrow ",
+  "↘": "\\searrow ",
+  "↙": "\\swarrow ",
+  "⋮": "\\vdots ",
+  "⋯": "\\cdots ",
+  "⋰": "\\adots ",
+  "⋱": "\\ddots ",
+  "≠": "\\ne ",
+  "≤": "\\leq ",
+  "≥": "\\geq ",
+  "≦": "\\leqq ",
+  "≧": "\\geqq ",
+  "≨": "\\lneqq ",
+  "≩": "\\gneqq ",
+  "≪": "\\ll ",
+  "≫": "\\gg ",
+  "∈": "\\in ",
+  "∉": "\\notin ",
+  "∋": "\\ni ",
+  "∌": "\\nni ",
+  "∞": "\\infty ",
+  "±": "\\pm ",
+  "∓": "\\mp ",
+  "\uD835\uDC34": "A",
+  "\uD835\uDC35": "B",
+  "\uD835\uDC36": "C",
+  "\uD835\uDC37": "D",
+  "\uD835\uDC38": "E",
+  "\uD835\uDC39": "F",
+  "\uD835\uDC3A": "G",
+  "\uD835\uDC3B": "H",
+  "\uD835\uDC3C": "I",
+  "\uD835\uDC3D": "J",
+  "\uD835\uDC3E": "K",
+  "\uD835\uDC3F": "L",
+  "\uD835\uDC40": "M",
+  "\uD835\uDC41": "N",
+  "\uD835\uDC42": "O",
+  "\uD835\uDC43": "P",
+  "\uD835\uDC44": "Q",
+  "\uD835\uDC45": "R",
+  "\uD835\uDC46": "S",
+  "\uD835\uDC47": "T",
+  "\uD835\uDC48": "U",
+  "\uD835\uDC49": "V",
+  "\uD835\uDC4A": "W",
+  "\uD835\uDC4B": "X",
+  "\uD835\uDC4C": "Y",
+  "\uD835\uDC4D": "Z",
+  "\uD835\uDC4E": "a",
+  "\uD835\uDC4F": "b",
+  "\uD835\uDC50": "c",
+  "\uD835\uDC51": "d",
+  "\uD835\uDC52": "e",
+  "\uD835\uDC53": "f",
+  "\uD835\uDC54": "g",
+  "\uD835\uDC56": "i",
+  "\uD835\uDC57": "j",
+  "\uD835\uDC58": "k",
+  "\uD835\uDC59": "l",
+  "\uD835\uDC5A": "m",
+  "\uD835\uDC5B": "n",
+  "\uD835\uDC5C": "o",
+  "\uD835\uDC5D": "p",
+  "\uD835\uDC5E": "q",
+  "\uD835\uDC5F": "r",
+  "\uD835\uDC60": "s",
+  "\uD835\uDC61": "t",
+  "\uD835\uDC62": "u",
+  "\uD835\uDC63": "v",
+  "\uD835\uDC64": "w",
+  "\uD835\uDC65": "x",
+  "\uD835\uDC66": "y",
+  "\uD835\uDC67": "z"
+};
+var FUNC = {
+  sin: "\\sin({fe})",
+  cos: "\\cos({fe})",
+  tan: "\\tan({fe})",
+  arcsin: "\\arcsin({fe})",
+  arccos: "\\arccos({fe})",
+  arctan: "\\arctan({fe})",
+  arccot: "\\arccot({fe})",
+  sinh: "\\sinh({fe})",
+  cosh: "\\cosh({fe})",
+  tanh: "\\tanh({fe})",
+  coth: "\\coth({fe})",
+  sec: "\\sec({fe})",
+  csc: "\\csc({fe})"
+};
+var CHR_DEFAULT = {
+  ACC_VAL: "\\hat{{{0}}}"
+};
+var POS = {
+  top: "\\overline{{{0}}}",
+  bot: "\\underline{{{0}}}"
+};
+var POS_DEFAULT = {
+  BAR_VAL: "\\overline{{{0}}}"
+};
+var SUB = "_{{{0}}}";
+var SUP = "^{{{0}}}";
+var F = {
+  bar: "\\frac{{{num}}}{{{den}}}",
+  skw: "^{{{num}}}/_{{{den}}}",
+  noBar: "\\genfrac{{}}{{}}{0pt}{{}}{{{num}}}{{{den}}}",
+  lin: "{{{num}}}/{{{den}}}"
+};
+var F_DEFAULT = "\\frac{{{num}}}{{{den}}}";
+var D = "\\left{left}{text}\\right{right}";
+var D_DEFAULT = {
+  left: "(",
+  right: ")",
+  null: "."
+};
+var RAD = "\\sqrt[{deg}]{{{text}}}";
+var RAD_DEFAULT = "\\sqrt{{{text}}}";
+var ARR = "\\begin{{array}}{{c}}{text}\\end{{array}}";
+var LIM_FUNC = {
+  lim: "\\lim_{{{lim}}}",
+  max: "\\max_{{{lim}}}",
+  min: "\\min_{{{lim}}}"
+};
+var LIM_TO = ["\\rightarrow", "\\to"];
+var LIM_UPP = "\\overset{{{lim}}}{{{text}}}";
+var M = "\\begin{{matrix}}{text}\\end{{matrix}}";
+
+// src/converter-utils/docx/omml.ts
+var OMML_NS = "http://schemas.openxmlformats.org/officeDocument/2006/math";
+var OMML_NS_BRACE = `{${OMML_NS}}`;
+function tpl(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{${key}\\}`, "g"), value);
+  }
+  result = result.replace(/\{\{/g, "{").replace(/\}\}/g, "}");
+  return result;
+}
+function tpl0(template, value) {
+  let result = template.replace(/\{0\}/g, value);
+  result = result.replace(/\{\{/g, "{").replace(/\}\}/g, "}");
+  return result;
+}
+function escapeLatex(strs) {
+  let last = null;
+  const newChr = [];
+  strs = strs.replace(/\\\\/g, "\\");
+  for (const c of strs) {
+    if (CHARS.has(c) && last !== BACKSLASH) {
+      newChr.push(BACKSLASH + c);
+    } else {
+      newChr.push(c);
+    }
+    last = c;
+  }
+  return newChr.join(BLANK);
+}
+function getVal(key, defaultVal, store) {
+  if (key != null) {
+    return !store ? key : store[key] ?? key;
+  }
+  return defaultVal ?? "";
+}
+function parseOmmlXml(xmlStr) {
+  const nsMap = {};
+  const xmlnsRe = /xmlns(?::(\w+))?="([^"]+)"/g;
+  let m;
+  while ((m = xmlnsRe.exec(xmlStr)) !== null) {
+    const prefix = m[1] || "";
+    nsMap[prefix] = m[2];
+  }
+  const { XMLParser } = __require("fast-xml-parser");
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "",
+    preserveOrder: true,
+    processEntities: false,
+    trimValues: false,
+    parseTagValue: false
+  });
+  const parsed = parser.parse(xmlStr);
+  function resolveNs(tagName) {
+    const parts = tagName.split(":");
+    if (parts.length === 2) {
+      const ns = nsMap[parts[0]];
+      if (ns)
+        return `{${ns}}${parts[1]}`;
+    } else if (nsMap[""]) {
+      return `{${nsMap[""]}}${tagName}`;
+    }
+    return tagName;
+  }
+  function convertNode(node) {
+    if (!node || typeof node !== "object")
+      return null;
+    const keys = Object.keys(node).filter((k) => k !== ":@");
+    if (keys.length === 0)
+      return null;
+    const tagName = keys[0];
+    const resolvedTag = resolveNs(tagName);
+    const attrib = {};
+    if (node[":@"]) {
+      for (const [k, v] of Object.entries(node[":@"])) {
+        attrib[resolveNs(k)] = String(v);
+      }
+    }
+    let text = null;
+    const children = [];
+    const content = node[tagName];
+    if (Array.isArray(content)) {
+      for (const child of content) {
+        if (child && typeof child === "object") {
+          const childKeys = Object.keys(child).filter((k) => k !== ":@");
+          if (childKeys.length > 0) {
+            if (childKeys[0] === "#text") {
+              text = String(child["#text"]);
+            } else {
+              const childNode = convertNode(child);
+              if (childNode)
+                children.push(childNode);
+            }
+          }
+        }
+      }
+    } else if (typeof content === "string") {
+      text = content;
+    }
+    return { tag: resolvedTag, attrib, text, children };
+  }
+  if (Array.isArray(parsed) && parsed.length > 0) {
+    const root = convertNode(parsed[0]);
+    if (root)
+      return root;
+  }
+  throw new Error("Failed to parse OMML XML");
+}
+function findAll(node, tag) {
+  const results = [];
+  for (const child of node.children) {
+    if (child.tag === tag)
+      results.push(child);
+  }
+  return results;
+}
+function find(node, tag) {
+  for (const child of node.children) {
+    if (child.tag === tag)
+      return child;
+  }
+  return null;
+}
+function stripNs(tag) {
+  return tag.replace(OMML_NS_BRACE, "");
+}
+var PR_VAL_TAGS = new Set(["chr", "pos", "begChr", "endChr", "type"]);
+function processPr(elm) {
+  const result = { text: "" };
+  const parts = [];
+  for (const child of elm.children) {
+    if (!child.tag.includes(OMML_NS))
+      continue;
+    const stag = stripNs(child.tag);
+    if (stag === "brk") {
+      result.brk = BRK;
+      parts.push(BRK);
+    } else if (PR_VAL_TAGS.has(stag)) {
+      const val = child.attrib[`${OMML_NS_BRACE}val`] ?? null;
+      result[stag] = val;
+    }
+  }
+  result.text = parts.join(BLANK);
+  return result;
+}
+var DIRECT_TAGS = new Set(["box", "sSub", "sSup", "sSubSup", "num", "den", "deg", "e"]);
+function* processChildrenList(elm, include) {
+  for (const child of elm.children) {
+    if (!child.tag.includes(OMML_NS))
+      continue;
+    const stag = stripNs(child.tag);
+    if (include && !include.has(stag))
+      continue;
+    let t = callMethod(child, stag);
+    if (t === null) {
+      t = processUnknown(child, stag);
+      if (t === null)
+        continue;
+    }
+    yield [stag, t, child];
+  }
+}
+function processChildrenDict(elm, include) {
+  const dict = {};
+  for (const [stag, t] of processChildrenList(elm, include)) {
+    dict[stag] = t;
+  }
+  return dict;
+}
+function processChildren(elm, include) {
+  const parts = [];
+  for (const [, t] of processChildrenList(elm, include)) {
+    if (typeof t === "string") {
+      parts.push(t);
+    } else if (t && typeof t === "object" && "text" in t) {
+      parts.push(t.text);
+    } else {
+      parts.push(String(t));
+    }
+  }
+  return parts.join(BLANK);
+}
+function processUnknown(elm, stag) {
+  if (DIRECT_TAGS.has(stag)) {
+    return processChildren(elm);
+  } else if (stag.endsWith("Pr")) {
+    return processPr(elm);
+  }
+  return null;
+}
+function callMethod(elm, stag) {
+  if (!stag)
+    stag = stripNs(elm.tag);
+  const method = TAG2METH[stag];
+  if (method)
+    return method(elm);
+  return null;
+}
+function doAcc(elm) {
+  const cDict = processChildrenDict(elm);
+  const pr = cDict.accPr;
+  const latexS = getVal(pr.chr, CHR_DEFAULT.ACC_VAL, CHR);
+  return tpl0(latexS, cDict.e);
+}
+function doBar(elm) {
+  const cDict = processChildrenDict(elm);
+  const pr = cDict.barPr;
+  const latexS = getVal(pr.pos, POS_DEFAULT.BAR_VAL, POS);
+  return pr.text + tpl0(latexS, cDict.e);
+}
+function doD(elm) {
+  const cDict = processChildrenDict(elm);
+  const pr = cDict.dPr;
+  const nullVal = D_DEFAULT.null;
+  const sVal = getVal(pr.begChr, D_DEFAULT.left, T);
+  const eVal = getVal(pr.endChr, D_DEFAULT.right, T);
+  return pr.text + tpl(D, {
+    left: !sVal ? nullVal : escapeLatex(sVal),
+    text: cDict.e,
+    right: !eVal ? nullVal : escapeLatex(eVal)
+  });
+}
+function doSub(elm) {
+  return tpl0(SUB, processChildren(elm));
+}
+function doSup(elm) {
+  return tpl0(SUP, processChildren(elm));
+}
+function doF(elm) {
+  const cDict = processChildrenDict(elm);
+  const pr = cDict.fPr;
+  const latexS = getVal(pr.type, F_DEFAULT, F);
+  return pr.text + tpl(latexS, { num: cDict.num ?? "", den: cDict.den ?? "" });
+}
+function doFunc(elm) {
+  const cDict = processChildrenDict(elm);
+  const funcName = cDict.fName ?? "";
+  return funcName.replace(FUNC_PLACE, cDict.e ?? "");
+}
+function doFname(elm) {
+  const latexChars = [];
+  for (const [stag, t] of processChildrenList(elm)) {
+    if (stag === "r") {
+      if (FUNC[t]) {
+        latexChars.push(FUNC[t]);
+      } else {
+        throw new Error(`Not supported func ${t}`);
+      }
+    } else {
+      latexChars.push(t);
+    }
+  }
+  const result = latexChars.join(BLANK);
+  return result.includes(FUNC_PLACE) ? result : result + FUNC_PLACE;
+}
+function doGroupchr(elm) {
+  const cDict = processChildrenDict(elm);
+  const pr = cDict.groupChrPr;
+  const latexS = getVal(pr.chr);
+  return pr.text + tpl0(latexS, cDict.e);
+}
+function doRad(elm) {
+  const cDict = processChildrenDict(elm);
+  const text = cDict.e ?? "";
+  const degText = cDict.deg ?? "";
+  if (degText) {
+    return tpl(RAD, { deg: degText, text });
+  }
+  return tpl(RAD_DEFAULT, { text });
+}
+function doEqarr(elm) {
+  const parts = [];
+  for (const [, t] of processChildrenList(elm, new Set(["e"]))) {
+    parts.push(t);
+  }
+  return tpl(ARR, { text: parts.join(BRK) });
+}
+function doLimlow(elm) {
+  const tDict = processChildrenDict(elm, new Set(["e", "lim"]));
+  const latexS = LIM_FUNC[tDict.e];
+  if (!latexS) {
+    throw new Error(`Not supported lim ${tDict.e}`);
+  }
+  return tpl(latexS, { lim: tDict.lim ?? "" });
+}
+function doLimupp(elm) {
+  const tDict = processChildrenDict(elm, new Set(["e", "lim"]));
+  return tpl(LIM_UPP, { lim: tDict.lim ?? "", text: tDict.e ?? "" });
+}
+function doLim(elm) {
+  return processChildren(elm).replace(LIM_TO[0], LIM_TO[1]);
+}
+function doM(elm) {
+  const rows = [];
+  for (const [stag, t] of processChildrenList(elm)) {
+    if (stag === "mPr") {} else if (stag === "mr") {
+      rows.push(t);
+    }
+  }
+  return tpl(M, { text: rows.join(BRK) });
+}
+function doMr(elm) {
+  const parts = [];
+  for (const [, t] of processChildrenList(elm, new Set(["e"]))) {
+    parts.push(t);
+  }
+  return parts.join(ALN);
+}
+function doNary(elm) {
+  const res = [];
+  let bo = "";
+  for (const [stag, t] of processChildrenList(elm)) {
+    if (stag === "naryPr") {
+      const pr = t;
+      bo = getVal(pr.chr, undefined, CHR_BO);
+    } else {
+      res.push(t);
+    }
+  }
+  return bo + res.join(BLANK);
+}
+function doR(elm) {
+  const tTag = find(elm, `${OMML_NS_BRACE}t`);
+  if (!tTag)
+    return "";
+  const text = tTag.text ?? "";
+  const chars = [];
+  for (const s of text) {
+    chars.push(T[s] ?? s);
+  }
+  return escapeLatex(chars.join(BLANK));
+}
+var TAG2METH = {
+  acc: doAcc,
+  r: doR,
+  bar: doBar,
+  sub: doSub,
+  sup: doSup,
+  f: doF,
+  func: doFunc,
+  fName: doFname,
+  groupChr: doGroupchr,
+  d: doD,
+  rad: doRad,
+  eqArr: doEqarr,
+  limLow: doLimlow,
+  limUpp: doLimupp,
+  lim: doLim,
+  m: doM,
+  mr: doMr,
+  nary: doNary
+};
+function oMathToLatex(element) {
+  return processChildren(element);
+}
+
+// src/converter-utils/docx/pre-process.ts
+var OMML_NS_BRACE2 = `{${OMML_NS}}`;
+var MATH_ROOT_TEMPLATE_PARTS = [
+  "<w:document ",
+  'xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" ',
+  'xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" ',
+  'xmlns:o="urn:schemas-microsoft-com:office:office" ',
+  'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" ',
+  'xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" ',
+  'xmlns:v="urn:schemas-microsoft-com:vml" ',
+  'xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing" ',
+  'xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" ',
+  'xmlns:w10="urn:schemas-microsoft-com:office:word" ',
+  'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ',
+  'xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" ',
+  'xmlns:wpg="http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" ',
+  'xmlns:wpi="http://schemas.microsoft.com/office/word/2010/wordprocessingInk" ',
+  'xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml" ',
+  'xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" ',
+  'mc:Ignorable="w14 wp14">'
+];
+function mathRootTemplate(content) {
+  return `${MATH_ROOT_TEMPLATE_PARTS.join("") + content}</w:document>`;
+}
+function convertOmathToLatex(omathXml) {
+  const wrappedXml = mathRootTemplate(omathXml);
+  const root = parseOmmlXml(wrappedXml);
+  const oMathNode = findAll(root, `${OMML_NS_BRACE2}oMath`)[0];
+  if (!oMathNode)
+    return "";
+  return oMathToLatex(oMathNode);
+}
+function preProcessMath(content) {
+  content = content.replace(/<m:oMathPara\b[^>]*>([\s\S]*?)<\/m:oMathPara>/g, (_match, inner) => {
+    const oMathRegex = /<m:oMath\b[^>]*>[\s\S]*?<\/m:oMath>/g;
+    const parts = [];
+    let oMathMatch;
+    while ((oMathMatch = oMathRegex.exec(inner)) !== null) {
+      try {
+        const latex = convertOmathToLatex(oMathMatch[0]);
+        parts.push(`<w:r><w:t>$$${latex}$$</w:t></w:r>`);
+      } catch {
+        return _match;
+      }
+    }
+    if (parts.length === 0)
+      return _match;
+    return `<w:p>${parts.join("")}</w:p>`;
+  });
+  content = content.replace(/<m:oMath\b[^>]*>([\s\S]*?)<\/m:oMath>/g, (match) => {
+    try {
+      const latex = convertOmathToLatex(match);
+      return `<w:r><w:t>$${latex}$</w:t></w:r>`;
+    } catch {
+      return match;
+    }
+  });
+  return content;
+}
+var PRE_PROCESS_FILES = ["word/document.xml", "word/footnotes.xml", "word/endnotes.xml"];
+async function preProcessDocx(inputBuffer) {
+  const zip = await JSZip.loadAsync(inputBuffer);
+  const outputZip = new JSZip;
+  for (const [path, file] of Object.entries(zip.files)) {
+    if (file.dir) {
+      outputZip.folder(path);
+      continue;
+    }
+    if (PRE_PROCESS_FILES.includes(path)) {
+      try {
+        const content = await file.async("string");
+        const processed = preProcessMath(content);
+        outputZip.file(path, processed);
+      } catch {
+        const content = await file.async("uint8array");
+        outputZip.file(path, content);
+      }
+    } else {
+      const content = await file.async("uint8array");
+      outputZip.file(path, content);
+    }
+  }
+  const result = await outputZip.generateAsync({ type: "nodebuffer" });
+  return result;
+}
+
+// src/transforms/html-to-markdown.ts
+import * as cheerio2 from "cheerio";
+import TurndownService2 from "turndown";
+import { tables } from "turndown-plugin-gfm";
+function createTurndownService(opts) {
+  const td = new TurndownService2({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "*",
+    emDelimiter: "*"
+  });
+  td.use(tables);
+  td.addRule("links", {
+    filter: "a",
+    replacement(content, node) {
+      const el = node;
+      const href = el.getAttribute("href") || "";
+      const title = el.getAttribute("title") || "";
+      if (!content.trim())
+        return "";
+      if (href) {
+        try {
+          const url = new URL(href, "http://placeholder.invalid");
+          const scheme = url.protocol.replace(":", "").toLowerCase();
+          if (scheme && !["http", "https", "file"].includes(scheme)) {
+            if (href.includes(":") && !href.startsWith("/") && !href.startsWith("#")) {
+              return content;
+            }
+          }
+        } catch {}
+      }
+      const titlePart = title ? ` "${title.replace(/"/g, "\\\"")}"` : "";
+      return href ? `[${content}](${href}${titlePart})` : content;
+    }
+  });
+  td.addRule("images", {
+    filter: "img",
+    replacement(_content, node) {
+      const el = node;
+      const alt = (el.getAttribute("alt") || "").replace(/\n/g, " ");
+      let src = el.getAttribute("src") || el.getAttribute("data-src") || "";
+      const title = el.getAttribute("title") || "";
+      if (src.startsWith("data:") && !opts?.keepDataUris) {
+        src = `${src.split(",")[0]}...`;
+      }
+      const titlePart = title ? ` "${title.replace(/"/g, "\\\"")}"` : "";
+      return `![${alt}](${src}${titlePart})`;
+    }
+  });
+  td.addRule("listItem", {
+    filter: "li",
+    replacement(content, node, options) {
+      content = content.replace(/^\n+/, "").replace(/\n+$/, `
+`).replace(/\n/gm, `
+  `);
+      const parent = node.parentNode;
+      const isOrdered = parent?.nodeName === "OL";
+      let prefix;
+      if (isOrdered) {
+        const start = parent.getAttribute("start");
+        const index = Array.prototype.indexOf.call(parent.children, node);
+        const num = (start ? parseInt(start, 10) : 1) + index;
+        prefix = `${num}. `;
+      } else {
+        prefix = `${options.bulletListMarker} `;
+      }
+      return prefix + content + (node.nextSibling ? `
+` : "");
+    }
+  });
+  td.addRule("definitionList", {
+    filter: "dl",
+    replacement(content) {
+      return `
+
+${content}
+
+`;
+    }
+  });
+  td.addRule("definitionTerm", {
+    filter: "dt",
+    replacement(content) {
+      return `
+${content}
+`;
+    }
+  });
+  td.addRule("definitionDescription", {
+    filter: "dd",
+    replacement(content) {
+      return `:   ${content.trim()}
+`;
+    }
+  });
+  td.addRule("checkboxes", {
+    filter(node) {
+      return node.nodeName === "INPUT" && node.getAttribute("type") === "checkbox";
+    },
+    replacement(_content, node) {
+      const el = node;
+      return el.hasAttribute("checked") ? "[x] " : "[ ] ";
+    }
+  });
+  return td;
+}
+function htmlToMarkdown(html, opts) {
+  const $ = cheerio2.load(html);
+  $("script, style").remove();
+  const title = $("title").first().text() || undefined;
+  $("td, th").each((_, el) => {
+    const $el = $(el);
+    $el.find("> p").each((_2, p) => {
+      $(p).replaceWith(`${$(p).html()} `);
+    });
+    $el.html(($el.html() || "").trim());
+  });
+  $("table").each((_, table) => {
+    const $table = $(table);
+    if ($table.find("thead").length)
+      return;
+    const $firstRow = $table.find("> tr, > tbody > tr").first();
+    if (!$firstRow.length)
+      return;
+    $firstRow.find("> td").each((_2, td2) => {
+      const $td = $(td2);
+      const $th = $("<th>").html($td.html() || "");
+      const attrs = td2.attribs || {};
+      for (const [name, value] of Object.entries(attrs)) {
+        $th.attr(name, value);
+      }
+      $td.replaceWith($th);
+    });
+    const $thead = $("<thead>").append($firstRow.clone());
+    $firstRow.remove();
+    const $tbody = $table.find("> tbody");
+    if (!$tbody.length) {
+      const remainingRows = $table.find("> tr");
+      if (remainingRows.length) {
+        const $newTbody = $("<tbody>");
+        remainingRows.each((_2, row) => {
+          $newTbody.append($(row));
+        });
+        $table.append($newTbody);
+      }
+    }
+    $table.prepend($thead);
+  });
+  const body = $("body");
+  const processedHtml = body.length > 0 ? body.html() || "" : $.html() || "";
+  const td = createTurndownService(opts);
+  let markdown = td.turndown(processedHtml);
+  markdown = markdown.trim();
+  return { markdown, title };
+}
+
+// src/converters/docx.ts
+var ACCEPTED_EXTENSIONS4 = [".docx"];
+var ACCEPTED_MIME_PREFIXES4 = ["application/vnd.openxmlformats-officedocument.wordprocessingml.document"];
+var docxConverter = converter("DOCX", anyOf(byExt(...ACCEPTED_EXTENSIONS4), byMime(...ACCEPTED_MIME_PREFIXES4)), async (ctx) => {
+  let buffer;
+  try {
+    buffer = await preProcessDocx(ctx.buffer);
+  } catch {
+    buffer = ctx.buffer;
+  }
+  const result = await mammoth.convertToHtml({ buffer }, { styleMap: ctx.opts.styleMap ? [ctx.opts.styleMap] : undefined });
+  let { markdown, title } = htmlToMarkdown(result.value, ctx.opts);
+  markdown = markdown.replace(/(\${1,2})((?:(?!\1).)+)\1/g, (_match, delim, body) => delim + body.replace(/\\\\/g, "\\") + delim);
+  return { markdown, title };
+});
+// src/converters/epub.ts
+var ACCEPTED_EXTENSIONS5 = [".epub"];
+var ACCEPTED_MIME_PREFIXES5 = ["application/epub", "application/epub+zip", "application/x-epub+zip"];
+var epubConverter = converter("EPUB", anyOf(byExt(...ACCEPTED_EXTENSIONS5), byMime(...ACCEPTED_MIME_PREFIXES5)), async (ctx) => {
+  const JSZip2 = (await import("jszip")).default;
+  const { XMLParser } = await import("fast-xml-parser");
+  const zip = await JSZip2.loadAsync(ctx.buffer);
+  const containerXml = await zip.file("META-INF/container.xml")?.async("text");
+  if (!containerXml)
+    throw new Error("Invalid EPUB: missing META-INF/container.xml");
+  const containerParser = new XMLParser({ ignoreAttributes: false });
+  const container = containerParser.parse(containerXml);
+  const rootfiles = container?.container?.rootfiles?.rootfile;
+  const rootfile = Array.isArray(rootfiles) ? rootfiles[0] : rootfiles;
+  const opfPath = rootfile?.["@_full-path"];
+  if (!opfPath)
+    throw new Error("Invalid EPUB: cannot find content.opf path");
+  const opfXml = await zip.file(opfPath)?.async("text");
+  if (!opfXml)
+    throw new Error(`Invalid EPUB: missing ${opfPath}`);
+  const opfParser = new XMLParser({ ignoreAttributes: false });
+  const opf = opfParser.parse(opfXml);
+  const pkg = opf?.package ?? opf?.package;
+  const meta = pkg?.metadata ?? {};
+  const metadata = {
+    title: extractText(meta, "dc:title"),
+    authors: extractAllTexts(meta, "dc:creator").join(", ") || null,
+    language: extractText(meta, "dc:language"),
+    publisher: extractText(meta, "dc:publisher"),
+    date: extractText(meta, "dc:date"),
+    description: extractText(meta, "dc:description"),
+    identifier: extractText(meta, "dc:identifier")
+  };
+  const manifestItems = asArray(pkg?.manifest?.item);
+  const manifest = new Map;
+  for (const item of manifestItems) {
+    const id = item["@_id"];
+    const href = item["@_href"];
+    if (id && href)
+      manifest.set(id, href);
+  }
+  const spineItems = asArray(pkg?.spine?.itemref);
+  const spineOrder = spineItems.map((item) => item["@_idref"]).filter(Boolean);
+  const basePath = opfPath.includes("/") ? opfPath.split("/").slice(0, -1).join("/") : "";
+  const spineFiles = spineOrder.map((id) => {
+    const href = manifest.get(id);
+    if (!href)
+      return null;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(href);
+    } catch {
+      decoded = href;
+    }
+    return basePath ? `${basePath}/${decoded}` : decoded;
+  }).filter(Boolean);
+  const markdownParts = [];
+  for (const file of spineFiles) {
+    const zipFile = zip.file(file);
+    if (!zipFile)
+      continue;
+    const htmlBuffer = Buffer.from(await zipFile.async("nodebuffer"));
+    const htmlText = decodeBuffer(htmlBuffer, "utf-8");
+    const { markdown } = htmlToMarkdown(htmlText, ctx.opts);
+    const trimmed = markdown.trim();
+    if (trimmed)
+      markdownParts.push(trimmed);
+  }
+  const metadataLines = [];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value) {
+      metadataLines.push(`**${key.charAt(0).toUpperCase() + key.slice(1)}:** ${value}`);
+    }
+  }
+  if (metadataLines.length > 0) {
+    markdownParts.unshift(metadataLines.join(`
+`));
+  }
+  return {
+    markdown: markdownParts.join(`
+
+`),
+    title: metadata.title ?? undefined
+  };
+});
+function extractText(meta, tag) {
+  const val = meta?.[tag];
+  if (!val)
+    return null;
+  if (typeof val === "string")
+    return val;
+  if (typeof val === "object" && "#text" in val)
+    return val["#text"];
+  if (Array.isArray(val)) {
+    const first = val[0];
+    if (typeof first === "string")
+      return first;
+    if (typeof first === "object" && "#text" in first)
+      return first["#text"];
+  }
+  return null;
+}
+function extractAllTexts(meta, tag) {
+  const val = meta?.[tag];
+  if (!val)
+    return [];
+  const arr = Array.isArray(val) ? val : [val];
+  return arr.map((v) => {
+    if (typeof v === "string")
+      return v;
+    if (typeof v === "object" && "#text" in v)
+      return v["#text"];
+    return null;
+  }).filter(Boolean);
+}
+function asArray(val) {
+  if (!val)
+    return [];
+  return Array.isArray(val) ? val : [val];
+}
+// src/converters/html.ts
+var ACCEPTED_EXTENSIONS6 = [".html", ".htm"];
+var ACCEPTED_MIME_PREFIXES6 = ["text/html", "application/xhtml"];
+var htmlConverter = converter("HTML", anyOf(byExt(...ACCEPTED_EXTENSIONS6), byMime(...ACCEPTED_MIME_PREFIXES6)), async (ctx) => {
+  const encoding = ctx.info.charset ?? "utf-8";
+  const html = decodeBuffer(ctx.buffer, encoding);
+  const { markdown, title } = htmlToMarkdown(html, ctx.opts);
+  return { markdown, title };
+});
+// src/converters/image.ts
+var ACCEPTED_EXTENSIONS7 = [".jpg", ".jpeg", ".png"];
+var ACCEPTED_MIME_PREFIXES7 = ["image/jpeg", "image/png"];
+var IMAGE_METADATA_FIELDS = [
+  "ImageSize",
+  "Title",
+  "Caption",
+  "Description",
+  "Keywords",
+  "Artist",
+  "Author",
+  "DateTimeOriginal",
+  "CreateDate",
+  "GPSPosition"
+];
+var imageConverter = converter("Image", anyOf(byExt(...ACCEPTED_EXTENSIONS7), byMime(...ACCEPTED_MIME_PREFIXES7)), async (ctx) => {
+  let md = "";
+  const metadata = await exiftoolMetadata(ctx.buffer, ctx.opts.exiftoolPath);
+  const metaLines = [];
+  for (const field of IMAGE_METADATA_FIELDS) {
+    if (metadata[field]) {
+      metaLines.push(`- **${field}:** ${metadata[field]}`);
+    }
+  }
+  if (metaLines.length) {
+    md += `# Image Metadata
+
+${metaLines.join(`
+`)}
+`;
+  }
+  if (ctx.opts.llmClient && ctx.opts.llmModel) {
+    const extMimeMap = {
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".png": "image/png"
+    };
+    const contentType = ctx.info.mimetype || (ctx.info.extension ? extMimeMap[ctx.info.extension] : undefined) || "application/octet-stream";
+    const base64Image = ctx.buffer.toString("base64");
+    const dataUri = `data:${contentType};base64,${base64Image}`;
+    const prompt = ctx.opts.llmPrompt?.trim() || "Write a detailed caption for this image.";
+    try {
+      const response = await ctx.opts.llmClient.chat.completions.create({
+        model: ctx.opts.llmModel,
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image_url", image_url: { url: dataUri } }
+            ]
+          }
+        ]
+      });
+      const description = response.choices?.[0]?.message?.content;
+      if (description) {
+        md += `
+# Description:
+${description.trim()}
+`;
+      }
+    } catch {}
+  }
+  return { markdown: md };
+});
+// src/exceptions.ts
+class MarkItDownError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MarkItDownError";
+  }
+}
+
+class MissingDependencyError extends MarkItDownError {
+  constructor(message) {
+    super(message);
+    this.name = "MissingDependencyError";
+  }
+}
+
+class UnsupportedFormatError extends MarkItDownError {
+  constructor(message) {
+    super(message);
+    this.name = "UnsupportedFormatError";
+  }
+}
+var SUPPORTED_FORMATS_LIST = "pdf, docx, pptx, xlsx, xls, html, csv, epub, zip, msg, json, ipynb, jpg, png, mp3, wav";
+function getSuggestion(error) {
+  if (error instanceof UnsupportedFormatError) {
+    return `Supported formats: ${SUPPORTED_FORMATS_LIST}. Use --describe for full details.`;
+  }
+  if (error instanceof FileConversionError) {
+    return "The file was recognized but conversion failed. Ensure the file is not corrupted.";
+  }
+  if (error instanceof MissingDependencyError) {
+    return "A required dependency is missing. Check the installation.";
+  }
+  if (error && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    if (code === "ENOENT")
+      return "Check the file path and try again.";
+    if (code === "EACCES" || code === "EPERM")
+      return "Check file permissions and try again.";
+  }
+  return;
+}
+
+class FileConversionError extends MarkItDownError {
+  attempts;
+  constructor(message, attempts) {
+    if (!message && attempts) {
+      message = `File conversion failed after ${attempts.length} attempts:
+`;
+      for (const attempt of attempts) {
+        if (attempt.error) {
+          message += ` - ${attempt.converterName} threw ${attempt.error.name}: ${attempt.error.message}
+`;
+        } else {
+          message += ` - ${attempt.converterName} provided no error info.
+`;
+        }
+      }
+    }
+    super(message ?? "File conversion failed.");
+    this.name = "FileConversionError";
+    this.attempts = attempts;
+  }
+}
+
+// src/converters/ipynb.ts
+var ACCEPTED_EXTENSIONS8 = [".ipynb"];
+function looksLikeNotebook(buffer, charset) {
+  try {
+    const text = decodeBuffer(buffer, charset ?? "utf-8");
+    return text.includes("nbformat") && text.includes("nbformat_minor");
+  } catch {
+    return false;
+  }
+}
+var ipynbConverter = converter("Ipynb", anyOf(byExt(...ACCEPTED_EXTENSIONS8), (ctx) => {
+  const mime = (ctx.info.mimetype ?? "").toLowerCase();
+  if (!mime.startsWith("application/json"))
+    return false;
+  return looksLikeNotebook(ctx.buffer, ctx.info.charset);
+}), async (ctx) => {
+  try {
+    const text = decodeBuffer(ctx.buffer, ctx.info.charset ?? "utf-8");
+    const notebook = JSON.parse(text);
+    const mdOutput = [];
+    let title;
+    for (const cell of notebook.cells ?? []) {
+      const cellType = cell.cell_type ?? "";
+      const sourceLines = cell.source ?? [];
+      const source = sourceLines.join("");
+      if (cellType === "markdown") {
+        mdOutput.push(source);
+        if (title === undefined) {
+          for (const line of sourceLines) {
+            if (line.startsWith("# ")) {
+              title = line.replace(/^#+\s*/, "").trim();
+              break;
+            }
+          }
+        }
+      } else if (cellType === "code") {
+        mdOutput.push(`\`\`\`python
+${source}
+\`\`\``);
+      } else if (cellType === "raw") {
+        mdOutput.push(`\`\`\`
+${source}
+\`\`\``);
+      }
+    }
+    const mdText = mdOutput.join(`
+
+`);
+    const metadataTitle = notebook.metadata?.title;
+    if (metadataTitle) {
+      title = metadataTitle;
+    }
+    return { markdown: mdText, title };
+  } catch (e) {
+    throw new FileConversionError(`Error converting .ipynb file: ${e instanceof Error ? e.message : String(e)}`);
+  }
+});
+// src/converters/outlook-msg.ts
+var ACCEPTED_EXTENSIONS9 = [".msg"];
+var ACCEPTED_MIME_PREFIXES8 = ["application/vnd.ms-outlook"];
+var STREAM_FROM = "__substg1.0_0C1F001F";
+var STREAM_TO = "__substg1.0_0E04001F";
+var STREAM_SUBJECT = "__substg1.0_0037001F";
+var STREAM_BODY = "__substg1.0_1000001F";
+var outlookMsgConverter = converter("OutlookMSG", anyOf(byExt(...ACCEPTED_EXTENSIONS9), byMime(...ACCEPTED_MIME_PREFIXES8)), async (ctx) => {
+  const CFB = await import("cfb");
+  const cfb = CFB.read(ctx.buffer, { type: "buffer" });
+  function getStream(streamPath) {
+    const paths = [`/${streamPath}`, streamPath, `/Root Entry/${streamPath}`];
+    for (const p of paths) {
+      const entry = CFB.find(cfb, p);
+      if (entry?.content) {
+        const data = entry.content;
+        try {
+          const text = new TextDecoder("utf-16le").decode(data).trim();
+          if (text)
+            return text;
+        } catch {}
+        try {
+          return new TextDecoder("utf-8").decode(data).trim();
+        } catch {
+          return new TextDecoder("utf-8", { fatal: false }).decode(data).trim();
+        }
+      }
+    }
+    return null;
+  }
+  const from = getStream(STREAM_FROM);
+  const to = getStream(STREAM_TO);
+  const subject = getStream(STREAM_SUBJECT);
+  const body = getStream(STREAM_BODY);
+  let md = `# Email Message
+
+`;
+  if (from)
+    md += `**From:** ${from}
+`;
+  if (to)
+    md += `**To:** ${to}
+`;
+  if (subject)
+    md += `**Subject:** ${subject}
+`;
+  md += `
+## Content
+
+`;
+  if (body)
+    md += body;
+  return {
+    markdown: md.trim(),
+    title: subject ?? undefined
+  };
+});
+// src/converters/pdf.ts
+import fs from "node:fs";
+import path from "node:path";
+var ACCEPTED_EXTENSIONS10 = [".pdf"];
+var ACCEPTED_MIME_PREFIXES9 = ["application/pdf", "application/x-pdf"];
+var PARTIAL_NUMBERING_PATTERN = /^\.\d+$/;
+function normalizeWord(w) {
+  if (w.bbox) {
+    return {
+      text: w.text,
+      x0: w.bbox.x0,
+      top: w.bbox.top,
+      x1: w.bbox.x1,
+      bottom: w.bbox.bottom
+    };
+  }
+  return { text: w.text, x0: w.x0, top: w.top, x1: w.x1, bottom: w.bottom };
+}
+function mergePartialNumberingLines(text) {
+  const lines = text.split(`
+`);
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const stripped = lines[i].trim();
+    if (PARTIAL_NUMBERING_PATTERN.test(stripped)) {
+      let j = i + 1;
+      while (j < lines.length && !lines[j].trim())
+        j++;
+      if (j < lines.length) {
+        result.push(`${stripped} ${lines[j].trim()}`);
+        i = j + 1;
+      } else {
+        result.push(lines[i]);
+        i++;
+      }
+    } else {
+      result.push(lines[i]);
+      i++;
+    }
+  }
+  return result.join(`
+`);
+}
+function extractFormContentFromWords(words, pageWidth) {
+  if (!words.length)
+    return null;
+  const yTolerance = 5;
+  const rowsByY = new Map;
+  for (const word of words) {
+    const yKey = Math.round(word.top / yTolerance) * yTolerance;
+    let arr = rowsByY.get(yKey);
+    if (!arr) {
+      arr = [];
+      rowsByY.set(yKey, arr);
+    }
+    arr.push(word);
+  }
+  const sortedYKeys = [...rowsByY.keys()].sort((a, b) => a - b);
+  const rowInfo = [];
+  for (const yKey of sortedYKeys) {
+    const rowWords = rowsByY.get(yKey).sort((a, b) => a.x0 - b.x0);
+    if (!rowWords.length)
+      continue;
+    const firstX0 = rowWords[0].x0;
+    const lastX1 = rowWords[rowWords.length - 1].x1;
+    const lineWidth = lastX1 - firstX0;
+    const combinedText = rowWords.map((w) => w.text).join(" ");
+    const xPositions = rowWords.map((w) => w.x0);
+    const xGroups = [];
+    for (const x of [...xPositions].sort((a, b) => a - b)) {
+      if (!xGroups.length || x - xGroups[xGroups.length - 1] > 50) {
+        xGroups.push(x);
+      }
+    }
+    const isParagraph = lineWidth > pageWidth * 0.55 && combinedText.length > 60;
+    let hasPartialNumbering = false;
+    if (rowWords.length) {
+      const firstWord = rowWords[0].text.trim();
+      if (PARTIAL_NUMBERING_PATTERN.test(firstWord))
+        hasPartialNumbering = true;
+    }
+    rowInfo.push({
+      yKey,
+      words: rowWords,
+      text: combinedText,
+      xGroups,
+      isParagraph,
+      numColumns: xGroups.length,
+      hasPartialNumbering
+    });
+  }
+  const allTableXPositions = [];
+  for (const info of rowInfo) {
+    if (info.numColumns >= 3 && !info.isParagraph) {
+      allTableXPositions.push(...info.xGroups);
+    }
+  }
+  if (!allTableXPositions.length)
+    return null;
+  allTableXPositions.sort((a, b) => a - b);
+  const gaps = [];
+  for (let i2 = 0;i2 < allTableXPositions.length - 1; i2++) {
+    const gap = allTableXPositions[i2 + 1] - allTableXPositions[i2];
+    if (gap > 5)
+      gaps.push(gap);
+  }
+  let adaptiveTolerance;
+  if (gaps.length >= 3) {
+    const sortedGaps = [...gaps].sort((a, b) => a - b);
+    const idx2 = Math.floor(sortedGaps.length * 0.7);
+    adaptiveTolerance = Math.max(25, Math.min(50, sortedGaps[idx2]));
+  } else {
+    adaptiveTolerance = 35;
+  }
+  const globalColumns = [];
+  for (const x of allTableXPositions) {
+    if (!globalColumns.length || x - globalColumns[globalColumns.length - 1] > adaptiveTolerance) {
+      globalColumns.push(x);
+    }
+  }
+  if (globalColumns.length > 1) {
+    const contentWidth = globalColumns[globalColumns.length - 1] - globalColumns[0];
+    const avgColWidth = contentWidth / globalColumns.length;
+    if (avgColWidth < 30)
+      return null;
+    const columnsPerInch = globalColumns.length / (contentWidth / 72);
+    if (columnsPerInch > 10)
+      return null;
+    const adaptiveMaxColumns = Math.max(15, Math.floor(20 * (pageWidth / 612)));
+    if (globalColumns.length > adaptiveMaxColumns)
+      return null;
+  } else {
+    return null;
+  }
+  const numCols = globalColumns.length;
+  for (const info of rowInfo) {
+    if (info.isParagraph || info.hasPartialNumbering) {
+      info.isTableRow = false;
+      continue;
+    }
+    const alignedColumns = new Set;
+    for (const word of info.words) {
+      for (let colIdx = 0;colIdx < globalColumns.length; colIdx++) {
+        if (Math.abs(word.x0 - globalColumns[colIdx]) < 40) {
+          alignedColumns.add(colIdx);
+          break;
+        }
+      }
+    }
+    info.isTableRow = alignedColumns.size >= 2;
+  }
+  const tableRegions = [];
+  let i = 0;
+  while (i < rowInfo.length) {
+    if (rowInfo[i].isTableRow) {
+      const start = i;
+      while (i < rowInfo.length && rowInfo[i].isTableRow)
+        i++;
+      tableRegions.push([start, i]);
+    } else {
+      i++;
+    }
+  }
+  const totalTableRows = tableRegions.reduce((sum, [s, e]) => sum + (e - s), 0);
+  if (rowInfo.length > 0 && totalTableRows / rowInfo.length < 0.2)
+    return null;
+  function extractCells(info) {
+    const cells = Array(numCols).fill("");
+    for (const word of info.words) {
+      let assignedCol = numCols - 1;
+      for (let colIdx = 0;colIdx < numCols - 1; colIdx++) {
+        if (word.x0 < globalColumns[colIdx + 1] - 20) {
+          assignedCol = colIdx;
+          break;
+        }
+      }
+      cells[assignedCol] = cells[assignedCol] ? `${cells[assignedCol]} ${word.text}` : word.text;
+    }
+    return cells;
+  }
+  const resultLines = [];
+  let idx = 0;
+  while (idx < rowInfo.length) {
+    const region = tableRegions.find(([start]) => start === idx);
+    if (region) {
+      const [start, end] = region;
+      const tableData = [];
+      for (let ti = start;ti < end; ti++) {
+        tableData.push(extractCells(rowInfo[ti]));
+      }
+      if (tableData.length) {
+        const colWidths = Array.from({ length: numCols }, (_, col) => Math.max(3, ...tableData.map((row) => (row[col] || "").length)));
+        const header = tableData[0];
+        resultLines.push(`| ${header.map((cell, ci) => cell.padEnd(colWidths[ci])).join(" | ")} |`);
+        resultLines.push(`| ${colWidths.map((w) => "-".repeat(w)).join(" | ")} |`);
+        for (const row of tableData.slice(1)) {
+          resultLines.push(`| ${row.map((cell, ci) => cell.padEnd(colWidths[ci])).join(" | ")} |`);
+        }
+      }
+      idx = end;
+    } else {
+      const inTable = tableRegions.some(([s, e]) => s < idx && idx < e);
+      if (!inTable)
+        resultLines.push(rowInfo[idx].text);
+      idx++;
+    }
+  }
+  return resultLines.join(`
+`);
+}
+var _initPromise = null;
+async function initPdfplumber() {
+  if (!_initPromise) {
+    _initPromise = (async () => {
+      const bgModule = await import("pdfplumber-wasm/pdfplumber_wasm_bg.js");
+      const imports = {
+        "./pdfplumber_wasm_bg.js": {}
+      };
+      for (const [key, value] of Object.entries(bgModule)) {
+        if ((key.startsWith("__wbg_") || key.startsWith("__wbindgen_")) && typeof value === "function") {
+          imports["./pdfplumber_wasm_bg.js"][key] = value;
+        }
+      }
+      const wasmPath = path.join(path.dirname(__require.resolve("pdfplumber-wasm/package.json")), "pdfplumber_wasm_bg.wasm");
+      const wasmBytes = fs.readFileSync(wasmPath);
+      const wasmModule = new WebAssembly.Module(wasmBytes);
+      const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+      bgModule.__wbg_set_wasm(wasmInstance.exports);
+      if (typeof wasmInstance.exports.__wbindgen_start === "function") {
+        wasmInstance.exports.__wbindgen_start();
+      }
+      return bgModule.WasmPdf;
+    })();
+  }
+  return _initPromise;
+}
+var pdfConverter = converter("PDF", anyOf(byExt(...ACCEPTED_EXTENSIONS10), byMime(...ACCEPTED_MIME_PREFIXES9)), async (ctx) => {
+  const markdownChunks = [];
+  let formPages = 0;
+  let plainPages = 0;
+  try {
+    const WasmPdf = await initPdfplumber();
+    const pdf = WasmPdf.open(new Uint8Array(ctx.buffer));
+    try {
+      for (let i = 0;i < pdf.pageCount; i++) {
+        const page = pdf.page(i);
+        try {
+          const rawWords = page.extractWords(3, 3);
+          const words = rawWords.map(normalizeWord);
+          const pageWidth = page.width || 612;
+          const pageContent = extractFormContentFromWords(words, pageWidth);
+          if (pageContent === null) {
+            plainPages++;
+            const text = page.extractText();
+            if (text?.trim())
+              markdownChunks.push(text.trim());
+          } else {
+            formPages++;
+            if (pageContent.trim())
+              markdownChunks.push(pageContent);
+          }
+        } finally {
+          page.free();
+        }
+      }
+      let markdown;
+      if (plainPages > formPages && plainPages > 0) {
+        markdown = await fallbackPdfParse(ctx.buffer);
+      } else {
+        markdown = markdownChunks.join(`
+
+`).trim();
+      }
+      if (!markdown.trim()) {
+        markdown = await fallbackPdfParse(ctx.buffer);
+      }
+      return { markdown: mergePartialNumberingLines(markdown) };
+    } catch {
+      const markdown = await fallbackPdfParse(ctx.buffer);
+      return { markdown: mergePartialNumberingLines(markdown) };
+    } finally {
+      pdf.free();
+    }
+  } catch {
+    const markdown = await fallbackPdfParse(ctx.buffer);
+    return { markdown: mergePartialNumberingLines(markdown) };
+  }
+});
+async function fallbackPdfParse(buffer) {
+  const { PDFParse } = await import("pdf-parse");
+  const parser = new PDFParse(new Uint8Array(buffer));
+  await parser.load();
+  const result = await parser.getText();
+  return result.text;
+}
+// src/converters/plain-text.ts
+var ACCEPTED_EXTENSIONS11 = [".txt", ".text", ".md", ".markdown", ".json", ".jsonl"];
+var ACCEPTED_MIME_PREFIXES10 = ["text/", "application/json", "application/markdown"];
+var plainTextConverter = converter("PlainText", anyOf(hasCharset(), byExt(...ACCEPTED_EXTENSIONS11), byMime(...ACCEPTED_MIME_PREFIXES10)), async (ctx) => {
+  const text = decodeBuffer(ctx.buffer, ctx.info.charset);
+  return { markdown: text };
+});
+// src/converters/pptx.ts
+import { XMLParser } from "fast-xml-parser";
+import JSZip2 from "jszip";
+var ACCEPTED_EXTENSIONS12 = [".pptx"];
+var ACCEPTED_MIME_PREFIXES11 = ["application/vnd.openxmlformats-officedocument.presentationml"];
+function escapeMarkdown(text) {
+  return text.replace(/[\r\n[\]]/g, " ").replace(/\s+/g, " ").trim();
+}
+function collectText(node) {
+  if (typeof node === "string")
+    return node;
+  if (typeof node === "number")
+    return String(node);
+  if (!node || typeof node !== "object")
+    return "";
+  const results = [];
+  if (node["#text"] !== undefined) {
+    results.push(String(node["#text"]));
+  }
+  if (node["a:t"] !== undefined) {
+    const t = node["a:t"];
+    if (typeof t === "string" || typeof t === "number") {
+      results.push(String(t));
+    } else if (Array.isArray(t)) {
+      for (const item of t) {
+        results.push(collectText(item));
+      }
+    } else if (typeof t === "object" && t["#text"] !== undefined) {
+      results.push(String(t["#text"]));
+    }
+  }
+  for (const [key, val] of Object.entries(node)) {
+    if (key === "#text" || key === "a:t")
+      continue;
+    if (key.startsWith("@_"))
+      continue;
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        results.push(collectText(item));
+      }
+    } else if (typeof val === "object" && val !== null) {
+      results.push(collectText(val));
+    }
+  }
+  return results.join("");
+}
+function collectTextNsStripped(node) {
+  if (typeof node === "string")
+    return node;
+  if (typeof node === "number")
+    return String(node);
+  if (!node || typeof node !== "object")
+    return "";
+  const results = [];
+  if (node["#text"] !== undefined)
+    results.push(String(node["#text"]));
+  if (node.t !== undefined) {
+    const t = node.t;
+    if (typeof t === "string" || typeof t === "number") {
+      results.push(String(t));
+    } else if (Array.isArray(t)) {
+      for (const item of t)
+        results.push(collectTextNsStripped(item));
+    } else if (typeof t === "object" && t["#text"] !== undefined) {
+      results.push(String(t["#text"]));
+    }
+  }
+  for (const [key, val] of Object.entries(node)) {
+    if (key === "#text" || key === "t")
+      continue;
+    if (key.startsWith("@_"))
+      continue;
+    if (Array.isArray(val)) {
+      for (const item of val)
+        results.push(collectTextNsStripped(item));
+    } else if (typeof val === "object" && val !== null) {
+      results.push(collectTextNsStripped(val));
+    }
+  }
+  return results.join("");
+}
+function extractTextFromShape(sp) {
+  const txBody = sp["p:txBody"];
+  if (!txBody)
+    return "";
+  let paragraphs = txBody["a:p"];
+  if (!paragraphs)
+    return "";
+  if (!Array.isArray(paragraphs))
+    paragraphs = [paragraphs];
+  const lines = [];
+  for (const p of paragraphs) {
+    const text = collectText(p);
+    if (text)
+      lines.push(text);
+  }
+  return lines.join(`
+`);
+}
+function isTitle(sp) {
+  const nvSpPr = sp["p:nvSpPr"];
+  if (!nvSpPr)
+    return false;
+  const nvPr = nvSpPr["p:nvPr"];
+  if (!nvPr)
+    return false;
+  const ph = nvPr["p:ph"];
+  if (!ph)
+    return false;
+  const type = ph["@_type"];
+  return type === "title" || type === "ctrTitle";
+}
+function extractTable(graphicFrame) {
+  const graphic = graphicFrame["a:graphic"];
+  if (!graphic)
+    return "";
+  const graphicData = graphic["a:graphicData"];
+  if (!graphicData)
+    return "";
+  const tbl = graphicData["a:tbl"];
+  if (!tbl)
+    return "";
+  let rows = tbl["a:tr"];
+  if (!rows)
+    return "";
+  if (!Array.isArray(rows))
+    rows = [rows];
+  const htmlRows = [];
+  let isFirst = true;
+  for (const row of rows) {
+    let cells = row["a:tc"];
+    if (!cells)
+      continue;
+    if (!Array.isArray(cells))
+      cells = [cells];
+    const tag = isFirst ? "th" : "td";
+    const cellsHtml = cells.map((cell) => {
+      const text = collectText(cell);
+      const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      return `<${tag}>${escaped}</${tag}>`;
+    }).join("");
+    htmlRows.push(`<tr>${cellsHtml}</tr>`);
+    isFirst = false;
+  }
+  const html = `<html><body><table>${htmlRows.join("")}</table></body></html>`;
+  return `${htmlToMarkdown(html).markdown.trim()}
+`;
+}
+function extractChartData(chartXml) {
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    removeNSPrefix: true
+  });
+  const chart = parser.parse(chartXml);
+  try {
+    const chartSpace = chart.chartSpace || chart["c:chartSpace"];
+    if (!chartSpace)
+      return `
+
+[chart]
+
+`;
+    const chartEl = chartSpace.chart || chartSpace["c:chart"];
+    if (!chartEl)
+      return `
+
+[chart]
+
+`;
+    let title = "";
+    const titleEl = chartEl.title || chartEl["c:title"];
+    if (titleEl) {
+      title = collectTextNsStripped(titleEl);
+    }
+    const plotArea = chartEl.plotArea || chartEl["c:plotArea"];
+    if (!plotArea)
+      return `
+
+### Chart${title ? `: ${title}` : ""}
+
+[chart data unavailable]
+`;
+    const chartTypes = ["barChart", "lineChart", "pieChart", "areaChart", "scatterChart"];
+    let plotData = null;
+    for (const type of chartTypes) {
+      plotData = plotArea[type] || plotArea[`c:${type}`];
+      if (plotData)
+        break;
+    }
+    if (!plotData)
+      return `
+
+### Chart${title ? `: ${title}` : ""}
+
+[unsupported chart]
+`;
+    let seriesList = plotData.ser || plotData["c:ser"];
+    if (!seriesList)
+      return `
+
+### Chart${title ? `: ${title}` : ""}
+
+`;
+    if (!Array.isArray(seriesList))
+      seriesList = [seriesList];
+    const categories = [];
+    const firstSer = seriesList[0];
+    const cat = firstSer.cat || firstSer["c:cat"];
+    if (cat) {
+      const strRef = cat.strRef || cat["c:strRef"];
+      const numRef = cat.numRef || cat["c:numRef"];
+      const ref = strRef || numRef;
+      if (ref) {
+        const cache = ref.strCache || ref["c:strCache"] || ref.numCache || ref["c:numCache"];
+        if (cache) {
+          let pts = cache.pt || cache["c:pt"];
+          if (pts) {
+            if (!Array.isArray(pts))
+              pts = [pts];
+            for (const pt of pts) {
+              categories.push(String(pt.v || pt["c:v"] || ""));
+            }
+          }
+        }
+      }
+    }
+    const seriesNames = [];
+    const seriesValues = [];
+    for (const ser of seriesList) {
+      const tx = ser.tx || ser["c:tx"];
+      let name = "";
+      if (tx) {
+        const sr = tx.strRef || tx["c:strRef"];
+        if (sr) {
+          const sc = sr.strCache || sr["c:strCache"];
+          if (sc) {
+            let pts = sc.pt || sc["c:pt"];
+            if (pts) {
+              if (!Array.isArray(pts))
+                pts = [pts];
+              name = String(pts[0]?.v || pts[0]?.["c:v"] || "");
+            }
+          }
+        }
+        if (!name) {
+          name = collectTextNsStripped(tx);
+        }
+      }
+      seriesNames.push(name);
+      const val = ser.val || ser["c:val"];
+      const values = [];
+      if (val) {
+        const nr = val.numRef || val["c:numRef"];
+        if (nr) {
+          const nc = nr.numCache || nr["c:numCache"];
+          if (nc) {
+            let pts = nc.pt || nc["c:pt"];
+            if (pts) {
+              if (!Array.isArray(pts))
+                pts = [pts];
+              for (const pt of pts) {
+                values.push(Number(pt.v || pt["c:v"] || 0));
+              }
+            }
+          }
+        }
+      }
+      seriesValues.push(values);
+    }
+    let md = `
+
+### Chart${title ? `: ${title}` : ""}
+
+`;
+    const header = ["Category", ...seriesNames];
+    md += `| ${header.join(" | ")} |
+`;
+    md += `|${header.map(() => "---").join("|")}|
+`;
+    for (let i = 0;i < categories.length; i++) {
+      const row = [categories[i], ...seriesValues.map((v) => String(v[i] ?? ""))];
+      md += `| ${row.join(" | ")} |
+`;
+    }
+    return md;
+  } catch {
+    return `
+
+[unsupported chart]
+
+`;
+  }
+}
+var pptxConverter = converter("PPTX", anyOf(byExt(...ACCEPTED_EXTENSIONS12), byMime(...ACCEPTED_MIME_PREFIXES11)), async (ctx) => {
+  const zip = await JSZip2.loadAsync(ctx.buffer);
+  const parser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    preserveOrder: false,
+    trimValues: false
+  });
+  const contentTypesXml = await zip.file("[Content_Types].xml")?.async("string");
+  if (!contentTypesXml)
+    throw new Error("Invalid PPTX: missing [Content_Types].xml");
+  const slideFiles = [];
+  for (const [filename] of Object.entries(zip.files)) {
+    if (/^ppt\/slides\/slide\d+\.xml$/.test(filename)) {
+      slideFiles.push(filename);
+    }
+  }
+  slideFiles.sort((a, b) => {
+    const numA = parseInt(a.match(/slide(\d+)/)?.[1] ?? "0", 10);
+    const numB = parseInt(b.match(/slide(\d+)/)?.[1] ?? "0", 10);
+    return numA - numB;
+  });
+  let mdContent = "";
+  let slideNum = 0;
+  for (const slideFile of slideFiles) {
+    slideNum++;
+    mdContent += `
+
+<!-- Slide number: ${slideNum} -->
+`;
+    const slideXml = await zip.file(slideFile)?.async("string");
+    if (!slideXml)
+      continue;
+    const slideDoc = parser.parse(slideXml);
+    const sld = slideDoc["p:sld"];
+    if (!sld)
+      continue;
+    const cSld = sld["p:cSld"];
+    if (!cSld)
+      continue;
+    const spTree = cSld["p:spTree"];
+    if (!spTree)
+      continue;
+    const shapes = [];
+    if (spTree["p:sp"]) {
+      const sps = Array.isArray(spTree["p:sp"]) ? spTree["p:sp"] : [spTree["p:sp"]];
+      shapes.push(...sps);
+    }
+    if (spTree["p:graphicFrame"]) {
+      const gfs = Array.isArray(spTree["p:graphicFrame"]) ? spTree["p:graphicFrame"] : [spTree["p:graphicFrame"]];
+      shapes.push(...gfs);
+    }
+    if (spTree["p:pic"]) {
+      const pics = Array.isArray(spTree["p:pic"]) ? spTree["p:pic"] : [spTree["p:pic"]];
+      shapes.push(...pics);
+    }
+    if (spTree["p:grpSp"]) {
+      const grps = Array.isArray(spTree["p:grpSp"]) ? spTree["p:grpSp"] : [spTree["p:grpSp"]];
+      shapes.push(...grps);
+    }
+    for (const shape of shapes) {
+      if (shape["p:txBody"]) {
+        const text = extractTextFromShape(shape);
+        if (text.trim()) {
+          if (isTitle(shape)) {
+            mdContent += `# ${text.trim()}
+`;
+          } else {
+            mdContent += `${text}
+`;
+          }
+        }
+      }
+      const graphic = shape["a:graphic"];
+      if (graphic) {
+        const graphicData = graphic["a:graphicData"];
+        if (graphicData) {
+          if (graphicData["a:tbl"]) {
+            mdContent += extractTable(shape);
+          }
+          const chartRef = graphicData["@_uri"] === "http://schemas.openxmlformats.org/drawingml/2006/chart";
+          if (chartRef || graphicData["c:chart"]) {
+            const slideRelsFile = `${slideFile.replace("slides/", "slides/_rels/")}.rels`;
+            const relsXml = await zip.file(slideRelsFile)?.async("string");
+            if (relsXml) {
+              const relsParsed = parser.parse(relsXml);
+              const rels = relsParsed.Relationships;
+              if (rels) {
+                let relList = rels.Relationship;
+                if (relList && !Array.isArray(relList))
+                  relList = [relList];
+                if (relList) {
+                  for (const rel of relList) {
+                    if (rel["@_Type"]?.includes("/chart") && rel["@_Target"]) {
+                      const chartPath = `ppt/${rel["@_Target"].replace("../", "")}`;
+                      const chartXml = await zip.file(chartPath)?.async("string");
+                      if (chartXml) {
+                        mdContent += extractChartData(chartXml);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      if (shape["p:blipFill"]) {
+        const blipFill = shape["p:blipFill"];
+        const blip = blipFill["a:blip"];
+        if (blip) {
+          let altText = "";
+          const nvPicPr = shape["p:nvPicPr"];
+          if (nvPicPr) {
+            const cNvPr = nvPicPr["p:cNvPr"];
+            if (cNvPr) {
+              altText = cNvPr["@_descr"] || cNvPr["@_name"] || "";
+            }
+          }
+          altText = escapeMarkdown(altText || "image");
+          if (ctx.opts.keepDataUris) {
+            const rId = blip["@_r:embed"];
+            if (rId) {
+              const slideRelsFile = `${slideFile.replace("slides/", "slides/_rels/")}.rels`;
+              const relsXml = await zip.file(slideRelsFile)?.async("string");
+              if (relsXml) {
+                const relsParsed = parser.parse(relsXml);
+                const rels = relsParsed.Relationships;
+                if (rels) {
+                  let relList = rels.Relationship;
+                  if (relList && !Array.isArray(relList))
+                    relList = [relList];
+                  if (relList) {
+                    for (const rel of relList) {
+                      if (rel["@_Id"] === rId && rel["@_Target"]) {
+                        const imgPath = `ppt/${rel["@_Target"].replace("../", "")}`;
+                        const imgData = await zip.file(imgPath)?.async("base64");
+                        if (imgData) {
+                          const ext = imgPath.split(".").pop()?.toLowerCase();
+                          const contentType = ext === "png" ? "image/png" : ext === "gif" ? "image/gif" : ext === "svg" ? "image/svg+xml" : "image/jpeg";
+                          mdContent += `
+![${altText}](data:${contentType};base64,${imgData})
+`;
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          } else {
+            const nvPicPr2 = shape["p:nvPicPr"];
+            let filename = "image.jpg";
+            if (nvPicPr2?.["p:cNvPr"]?.["@_name"]) {
+              filename = `${nvPicPr2["p:cNvPr"]["@_name"].replace(/\W/g, "")}.jpg`;
+            }
+            mdContent += `
+![${altText}](${filename})
+`;
+          }
+        }
+      }
+    }
+    const notesFile = slideFile.replace("slides/slide", "notesSlides/notesSlide");
+    const notesXml = await zip.file(notesFile)?.async("string");
+    if (notesXml) {
+      const notesDoc = parser.parse(notesXml);
+      const notes = notesDoc["p:notes"];
+      if (notes) {
+        const cSld2 = notes["p:cSld"];
+        if (cSld2) {
+          const spTree2 = cSld2["p:spTree"];
+          if (spTree2) {
+            let sps = spTree2["p:sp"];
+            if (sps && !Array.isArray(sps))
+              sps = [sps];
+            if (sps) {
+              for (const sp of sps) {
+                const nvSpPr = sp["p:nvSpPr"];
+                if (nvSpPr?.["p:nvPr"]?.["p:ph"]?.["@_type"] === "body") {
+                  const text = extractTextFromShape(sp);
+                  if (text.trim()) {
+                    mdContent += `
+
+### Notes:
+${text.trim()}`;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return { markdown: mdContent.trim() };
+});
+// src/converters/rss.ts
+import { XMLParser as XMLParser2 } from "fast-xml-parser";
+var PRECISE_MIME_PREFIXES = ["application/rss", "application/rss+xml", "application/atom", "application/atom+xml"];
+var PRECISE_EXTENSIONS = [".rss", ".atom"];
+var CANDIDATE_MIME_PREFIXES = ["text/xml", "application/xml"];
+var CANDIDATE_EXTENSIONS = [".xml"];
+function getFirstTextChild(parent, tagName) {
+  if (!parent)
+    return null;
+  const val = parent[tagName];
+  if (val === undefined || val === null)
+    return null;
+  if (typeof val === "string")
+    return val;
+  if (typeof val === "number")
+    return String(val);
+  if (typeof val === "object" && val["#text"] !== undefined)
+    return String(val["#text"]);
+  return null;
+}
+function parseContent(content) {
+  try {
+    const { markdown } = htmlToMarkdown(content);
+    return markdown;
+  } catch {
+    return content;
+  }
+}
+function detectFeedType(parsed) {
+  if (parsed.rss)
+    return "rss";
+  if (parsed.feed) {
+    const feed = parsed.feed;
+    if (feed.entry || Array.isArray(feed) && feed.some((f) => f.entry)) {
+      return "atom";
+    }
+  }
+  return null;
+}
+function looksLikeFeed(buffer, charset) {
+  try {
+    const text = decodeBuffer(buffer, charset ?? "utf-8");
+    const parser = new XMLParser2({ ignoreAttributes: true });
+    const parsed = parser.parse(text);
+    return detectFeedType(parsed) !== null;
+  } catch {
+    return false;
+  }
+}
+var rssConverter = converter("RSS", anyOf(byExt(...PRECISE_EXTENSIONS), byMime(...PRECISE_MIME_PREFIXES), (ctx) => {
+  const mime = (ctx.info.mimetype ?? "").toLowerCase();
+  const ext = (ctx.info.extension ?? "").toLowerCase();
+  const isCandidate = CANDIDATE_EXTENSIONS.includes(ext) || CANDIDATE_MIME_PREFIXES.some((p) => mime.startsWith(p));
+  if (!isCandidate)
+    return false;
+  return looksLikeFeed(ctx.buffer, ctx.info.charset);
+}), async (ctx) => {
+  const text = decodeBuffer(ctx.buffer, ctx.info.charset ?? "utf-8");
+  const parser = new XMLParser2({
+    ignoreAttributes: true,
+    textNodeName: "#text",
+    cdataPropName: "__cdata"
+  });
+  const parsed = parser.parse(text);
+  const feedType = detectFeedType(parsed);
+  if (feedType === "rss") {
+    return parseRss(parsed);
+  } else if (feedType === "atom") {
+    return parseAtom(parsed);
+  }
+  throw new Error("Unknown feed type");
+});
+function parseRss(parsed) {
+  const rss = parsed.rss;
+  const channel = rss.channel;
+  if (!channel)
+    throw new Error("No channel found in RSS feed");
+  const channelTitle = getFirstTextChild(channel, "title");
+  const channelDescription = getFirstTextChild(channel, "description");
+  let md = "";
+  if (channelTitle)
+    md += `# ${channelTitle}
+`;
+  if (channelDescription)
+    md += `${channelDescription}
+`;
+  let items = channel.item;
+  if (items && !Array.isArray(items))
+    items = [items];
+  if (items) {
+    for (const item of items) {
+      const title = getFirstTextChild(item, "title");
+      const description = getFirstTextChild(item, "description") || (item.description?.__cdata ? String(item.description.__cdata) : null);
+      const pubDate = getFirstTextChild(item, "pubDate");
+      const content = getFirstTextChild(item, "content:encoded") || (item["content:encoded"]?.__cdata ? String(item["content:encoded"].__cdata) : null);
+      if (title)
+        md += `
+## ${title}
+`;
+      if (pubDate)
+        md += `Published on: ${pubDate}
+`;
+      if (description)
+        md += parseContent(description);
+      if (content)
+        md += parseContent(content);
+    }
+  }
+  return { markdown: md, title: channelTitle ?? undefined };
+}
+function parseAtom(parsed) {
+  const feed = parsed.feed;
+  const title = getFirstTextChild(feed, "title");
+  const subtitle = getFirstTextChild(feed, "subtitle");
+  let md = "";
+  if (title)
+    md += `# ${title}
+`;
+  if (subtitle)
+    md += `${subtitle}
+`;
+  let entries = feed.entry;
+  if (entries && !Array.isArray(entries))
+    entries = [entries];
+  if (entries) {
+    for (const entry of entries) {
+      const entryTitle = getFirstTextChild(entry, "title");
+      const entrySummary = getFirstTextChild(entry, "summary");
+      const entryUpdated = getFirstTextChild(entry, "updated");
+      const entryContent = getFirstTextChild(entry, "content");
+      if (entryTitle)
+        md += `
+## ${entryTitle}
+`;
+      if (entryUpdated)
+        md += `Updated on: ${entryUpdated}
+`;
+      if (entrySummary)
+        md += parseContent(entrySummary);
+      if (entryContent)
+        md += parseContent(entryContent);
+    }
+  }
+  return { markdown: md, title: title ?? undefined };
+}
+// src/converters/wikipedia.ts
+import * as cheerio3 from "cheerio";
+import TurndownService3 from "turndown";
+import { tables as tables2 } from "turndown-plugin-gfm";
+var ACCEPTED_EXTENSIONS13 = [".html", ".htm"];
+var ACCEPTED_MIME_PREFIXES12 = ["text/html", "application/xhtml"];
+var wikipediaConverter = converter("Wikipedia", allOf(byUrl(/^https?:\/\/[a-zA-Z]{2,3}\.wikipedia\.org\//), anyOf(byExt(...ACCEPTED_EXTENSIONS13), byMime(...ACCEPTED_MIME_PREFIXES12))), async (ctx) => {
+  const encoding = ctx.info.charset ?? "utf-8";
+  const html = decodeBuffer(ctx.buffer, encoding);
+  const $ = cheerio3.load(html);
+  $("script, style").remove();
+  let mainTitle = $("title").first().text() || undefined;
+  const titleElm = $("span.mw-page-title-main").first();
+  if (titleElm.length) {
+    mainTitle = titleElm.text();
+  }
+  const bodyElm = $("#mw-content-text");
+  let contentHtml;
+  if (bodyElm.length) {
+    contentHtml = bodyElm.html() || "";
+  } else {
+    contentHtml = $("body").html() || $.html() || "";
+  }
+  const td = new TurndownService3({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "*",
+    emDelimiter: "*"
+  });
+  td.use(tables2);
+  td.addRule("links", {
+    filter: "a",
+    replacement(content, node) {
+      const el = node;
+      const href = el.getAttribute("href") || "";
+      const title = el.getAttribute("title") || "";
+      if (!content.trim())
+        return "";
+      if (href) {
+        try {
+          const url = new URL(href, "http://placeholder.invalid");
+          const scheme = url.protocol.replace(":", "").toLowerCase();
+          if (scheme && !["http", "https", "file"].includes(scheme)) {
+            if (href.includes(":") && !href.startsWith("/") && !href.startsWith("#")) {
+              return content;
+            }
+          }
+        } catch {}
+      }
+      const titlePart = title ? ` "${title.replace(/"/g, "\\\"")}"` : "";
+      return href ? `[${content}](${href}${titlePart})` : content;
+    }
+  });
+  let markdown = td.turndown(contentHtml).trim();
+  if (mainTitle) {
+    markdown = `# ${mainTitle}
+
+${markdown}`;
+  }
+  return { markdown, title: mainTitle };
+});
+// src/converters/xlsx.ts
+import * as XLSX from "xlsx";
+var ACCEPTED_XLSX_EXTENSIONS = [".xlsx"];
+var ACCEPTED_XLSX_MIME_PREFIXES = ["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"];
+var ACCEPTED_XLS_EXTENSIONS = [".xls"];
+var ACCEPTED_XLS_MIME_PREFIXES = ["application/vnd.ms-excel", "application/excel"];
+function sheetsToMarkdown(workbook) {
+  const parts = [];
+  for (const sheetName of workbook.SheetNames) {
+    const sheet = workbook.Sheets[sheetName];
+    if (!sheet)
+      continue;
+    parts.push(`## ${sheetName}`);
+    const html = XLSX.utils.sheet_to_html(sheet);
+    const { markdown } = htmlToMarkdown(html);
+    parts.push(markdown.trim());
+    parts.push("");
+  }
+  return parts.join(`
+`).trim();
+}
+var xlsxConverter = converter("XLSX", anyOf(byExt(...ACCEPTED_XLSX_EXTENSIONS), byMime(...ACCEPTED_XLSX_MIME_PREFIXES)), async (ctx) => {
+  const workbook = XLSX.read(ctx.buffer, { type: "buffer" });
+  return { markdown: sheetsToMarkdown(workbook) };
+});
+var xlsConverter = converter("XLS", anyOf(byExt(...ACCEPTED_XLS_EXTENSIONS), byMime(...ACCEPTED_XLS_MIME_PREFIXES)), async (ctx) => {
+  const workbook = XLSX.read(ctx.buffer, { type: "buffer" });
+  return { markdown: sheetsToMarkdown(workbook) };
+});
+// src/converters/youtube.ts
+import * as cheerio4 from "cheerio";
+var ACCEPTED_EXTENSIONS14 = [".html", ".htm"];
+var ACCEPTED_MIME_PREFIXES13 = ["text/html", "application/xhtml"];
+function findKey(obj, key) {
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const result = findKey(item, key);
+      if (result !== undefined)
+        return result;
+    }
+  } else if (obj && typeof obj === "object") {
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === key)
+        return v;
+      const result = findKey(v, key);
+      if (result !== undefined)
+        return result;
+    }
+  }
+  return;
+}
+function extractVideoId(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.searchParams.get("v");
+  } catch {
+    return null;
+  }
+}
+async function fetchTranscript(videoId, languages) {
+  try {
+    const { YoutubeTranscript } = await import("youtube-transcript");
+    const langAttempts = languages && languages.length > 0 ? [...languages, undefined] : [undefined];
+    for (const lang of langAttempts) {
+      for (let attempt = 0;attempt < 3; attempt++) {
+        try {
+          const config = lang ? { lang } : undefined;
+          const parts = await YoutubeTranscript.fetchTranscript(videoId, config);
+          if (parts && parts.length > 0) {
+            return parts.map((p) => p.text).join(" ");
+          }
+          break;
+        } catch (e) {
+          if (attempt < 2) {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+          } else if (lang !== undefined) {
+            break;
+          } else {
+            throw e;
+          }
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var youtubeConverter = converter("YouTube", allOf(byUrl(/^https:\/\/www\.youtube\.com\/watch\?/), anyOf(byExt(...ACCEPTED_EXTENSIONS14), byMime(...ACCEPTED_MIME_PREFIXES13))), async (ctx) => {
+  const encoding = ctx.info.charset ?? "utf-8";
+  const html = decodeBuffer(ctx.buffer, encoding);
+  const $ = cheerio4.load(html);
+  const metadata = {};
+  const titleText = $("title").first().text();
+  if (titleText)
+    metadata.title = titleText;
+  $("meta").each((_, el) => {
+    const $el = $(el);
+    for (const attr of ["itemprop", "property", "name"]) {
+      const key = $el.attr(attr);
+      const content = $el.attr("content");
+      if (key && content) {
+        metadata[key] = content;
+        break;
+      }
+    }
+  });
+  $("script").each((_, el) => {
+    const content = $(el).html();
+    if (!content?.includes("ytInitialData"))
+      return;
+    const match = content.match(/var ytInitialData = ({.*?});/);
+    if (match) {
+      try {
+        const data = JSON.parse(match[1]);
+        const attrDesc = findKey(data, "attributedDescriptionBodyText");
+        if (attrDesc && typeof attrDesc === "object" && attrDesc.content) {
+          metadata.description = String(attrDesc.content);
+        }
+      } catch {}
+    }
+  });
+  let md = `# YouTube
+`;
+  const title = metadata.title || metadata["og:title"] || metadata.name || "";
+  if (title)
+    md += `
+## ${title}
+`;
+  let stats = "";
+  if (metadata.interactionCount)
+    stats += `- **Views:** ${metadata.interactionCount}
+`;
+  if (metadata.keywords)
+    stats += `- **Keywords:** ${metadata.keywords}
+`;
+  if (metadata.duration)
+    stats += `- **Runtime:** ${metadata.duration}
+`;
+  if (stats)
+    md += `
+### Video Metadata
+${stats}
+`;
+  const description = metadata.description || metadata["og:description"];
+  if (description)
+    md += `
+### Description
+${description}
+`;
+  const videoId = ctx.info.url ? extractVideoId(ctx.info.url) : null;
+  if (videoId) {
+    const transcript = await fetchTranscript(videoId, ctx.opts.youtubeTranscriptLanguages);
+    if (transcript) {
+      md += `
+### Transcript
+${transcript}
+`;
+    }
+  }
+  return { markdown: md, title: title || undefined };
+});
+// src/converters/zip.ts
+import path2 from "node:path";
+var ACCEPTED_EXTENSIONS15 = [".zip"];
+var ACCEPTED_MIME_PREFIXES14 = ["application/zip"];
+var matcher = anyOf(byExt(...ACCEPTED_EXTENSIONS15), byMime(...ACCEPTED_MIME_PREFIXES14));
+var MAX_ZIP_DEPTH = 10;
+function createZipConverter(convertFn) {
+  return {
+    name: "ZIP",
+    match: (ctx) => matcher(ctx),
+    async convert(ctx) {
+      const currentDepth = ctx.opts._zipDepth ?? 0;
+      if (currentDepth >= MAX_ZIP_DEPTH) {
+        return { markdown: "[Max ZIP nesting depth exceeded]" };
+      }
+      const JSZip3 = (await import("jszip")).default;
+      const zip = await JSZip3.loadAsync(ctx.buffer);
+      const filePath = ctx.info.url || ctx.info.localPath || ctx.info.filename || "archive.zip";
+      let md = `Content from the zip file \`${filePath}\`:
+
+`;
+      for (const name of Object.keys(zip.files)) {
+        const entry = zip.files[name];
+        if (entry.dir)
+          continue;
+        try {
+          const data = await entry.async("nodebuffer");
+          const ext = path2.extname(name);
+          const filename = path2.basename(name);
+          const result = await convertFn(Buffer.from(data), {
+            streamInfo: {
+              extension: ext || undefined,
+              filename
+            },
+            _zipDepth: currentDepth + 1
+          });
+          md += `## File: ${name}
+
+`;
+          md += `${result.markdown}
+
+`;
+        } catch (e) {
+          if (e instanceof UnsupportedFormatError || e instanceof FileConversionError) {
+            continue;
+          }
+          throw e;
+        }
+      }
+      return { markdown: md.trim() };
+    }
+  };
+}
+// src/markitdown.ts
+import fs2 from "node:fs";
+import path4 from "node:path";
+
+// src/stream-info.ts
+function mergeStreamInfo(base, ...overrides) {
+  const result = { ...base };
+  for (const override of overrides) {
+    if (!override)
+      continue;
+    for (const [key, value] of Object.entries(override)) {
+      if (value !== undefined) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function guessMimeFromExtension(ext) {
+  const map = {
+    ".txt": "text/plain",
+    ".text": "text/plain",
+    ".md": "text/markdown",
+    ".markdown": "text/markdown",
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".json": "application/json",
+    ".jsonl": "application/jsonl",
+    ".csv": "text/csv",
+    ".xml": "text/xml",
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xls": "application/vnd.ms-excel",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".epub": "application/epub+zip",
+    ".zip": "application/zip",
+    ".ipynb": "application/x-ipynb+json",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".msg": "application/vnd.ms-outlook",
+    ".rss": "application/rss+xml",
+    ".atom": "application/atom+xml"
+  };
+  return map[ext.toLowerCase()];
+}
+function guessExtensionFromMime(mime) {
+  const map = {
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "text/html": ".html",
+    "application/json": ".json",
+    "text/csv": ".csv",
+    "text/xml": ".xml",
+    "application/pdf": ".pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "application/epub+zip": ".epub",
+    "application/zip": ".zip",
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "audio/mpeg": ".mp3",
+    "application/vnd.ms-outlook": ".msg"
+  };
+  return map[mime.toLowerCase()];
+}
+
+// src/uri-utils.ts
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+function fileUriToPath(fileUri) {
+  if (!fileUri.startsWith("file:")) {
+    throw new Error(`Not a file URL: ${fileUri}`);
+  }
+  let netloc = null;
+  const afterScheme = fileUri.slice(5);
+  if (afterScheme.startsWith("//")) {
+    const rest = afterScheme.slice(2);
+    const slashIdx = rest.indexOf("/");
+    if (slashIdx > 0) {
+      const host = rest.slice(0, slashIdx);
+      if (host && host !== "") {
+        netloc = host;
+      }
+    }
+  }
+  const localPath = path3.resolve(fileURLToPath(fileUri));
+  return { netloc, path: localPath };
+}
+function parseDataUri(uri) {
+  if (!uri.startsWith("data:")) {
+    throw new Error("Not a data URI");
+  }
+  const commaIndex = uri.indexOf(",");
+  if (commaIndex === -1) {
+    throw new Error("Malformed data URI, missing ',' separator");
+  }
+  const meta = uri.slice(5, commaIndex);
+  const rawData = uri.slice(commaIndex + 1);
+  const parts = meta.split(";");
+  let isBase64 = false;
+  if (parts[parts.length - 1] === "base64") {
+    parts.pop();
+    isBase64 = true;
+  }
+  let mimeType = null;
+  if (parts.length > 0 && parts[0].length > 0) {
+    mimeType = parts.shift();
+  }
+  const attributes = {};
+  for (const part of parts) {
+    if (part.includes("=")) {
+      const [key, ...rest] = part.split("=");
+      attributes[key] = rest.join("=");
+    } else if (part.length > 0) {
+      attributes[part] = "";
+    }
+  }
+  const data = isBase64 ? Buffer.from(rawData, "base64") : Buffer.from(decodeURIComponent(rawData));
+  return { mimeType, attributes, data };
+}
+
+// src/markitdown.ts
+var PRIORITY_SPECIFIC = 0;
+var PRIORITY_GENERIC = 10;
+function createMarkItDown(options) {
+  const opts = options ?? {};
+  const registrations = [];
+  function register(conv, priority = PRIORITY_SPECIFIC) {
+    registrations.unshift({ converter: conv, priority });
+  }
+  register(plainTextConverter, PRIORITY_GENERIC);
+  register(htmlConverter, PRIORITY_GENERIC);
+  register(csvConverter);
+  register(ipynbConverter);
+  register(docxConverter);
+  register(xlsxConverter);
+  register(xlsConverter);
+  register(pdfConverter);
+  register(pptxConverter);
+  register(rssConverter);
+  register(wikipediaConverter);
+  register(youtubeConverter);
+  register(bingSerpConverter);
+  register(epubConverter);
+  register(imageConverter);
+  register(audioConverter);
+  register(outlookMsgConverter);
+  register(createZipConverter(convert));
+  function getSorted() {
+    return [...registrations].sort((a, b) => a.priority - b.priority);
+  }
+  async function detectStreamInfo(buffer, base) {
+    const guesses = [];
+    let enhanced = { ...base };
+    if (!enhanced.mimetype && enhanced.extension) {
+      const guessedMime = guessMimeFromExtension(enhanced.extension);
+      if (guessedMime)
+        enhanced = { ...enhanced, mimetype: guessedMime };
+    }
+    if (enhanced.mimetype && !enhanced.extension) {
+      const guessedExt = guessExtensionFromMime(enhanced.mimetype);
+      if (guessedExt)
+        enhanced = { ...enhanced, extension: guessedExt };
+    }
+    try {
+      const { fileTypeFromBuffer } = await import("file-type");
+      const detected = await fileTypeFromBuffer(buffer);
+      if (detected) {
+        const detectedExt = `.${detected.ext}`;
+        const isCompatible = (!base.mimetype || base.mimetype === detected.mime) && (!base.extension || base.extension === detectedExt);
+        if (isCompatible) {
+          guesses.push({
+            ...enhanced,
+            mimetype: enhanced.mimetype ?? detected.mime,
+            extension: enhanced.extension ?? detectedExt
+          });
+        } else {
+          guesses.push(enhanced);
+          guesses.push({
+            ...base,
+            mimetype: detected.mime,
+            extension: detectedExt
+          });
+        }
+      } else {
+        guesses.push(enhanced);
+      }
+    } catch {
+      guesses.push(enhanced);
+    }
+    return guesses;
+  }
+  function normalizeResult(result) {
+    let md = result.markdown;
+    md = md.split(/\r?\n/).map((line) => line.trimEnd()).join(`
+`);
+    md = md.replace(/\n{3,}/g, `
+
+`);
+    return { ...result, markdown: md };
+  }
+  async function runConversion(buffer, streamInfoGuesses) {
+    const sorted = getSorted();
+    const failedAttempts = [];
+    const allGuesses = [...streamInfoGuesses, {}];
+    for (const info of allGuesses) {
+      for (const reg of sorted) {
+        const ctx = { buffer, info, opts };
+        let accepts = false;
+        try {
+          accepts = reg.converter.match(ctx);
+        } catch {}
+        if (accepts) {
+          try {
+            const result = await reg.converter.convert(ctx);
+            return normalizeResult(result);
+          } catch (e) {
+            failedAttempts.push({
+              converterName: reg.converter.name,
+              error: e instanceof Error ? e : new Error(String(e))
+            });
+          }
+        }
+      }
+    }
+    if (failedAttempts.length > 0) {
+      throw new FileConversionError(undefined, failedAttempts);
+    }
+    throw new UnsupportedFormatError("Could not convert to Markdown. No converter attempted a conversion, suggesting the format is not supported.");
+  }
+  async function convert(source, input) {
+    const prevDepth = opts._zipDepth;
+    if (input?._zipDepth !== undefined) {
+      opts._zipDepth = input._zipDepth;
+    }
+    try {
+      if (typeof source === "string") {
+        if (source.startsWith("http:") || source.startsWith("https:") || source.startsWith("file:") || source.startsWith("data:")) {
+          return await convertUri(source, input?.streamInfo);
+        }
+        return await convertLocal(source, input?.streamInfo);
+      }
+      const info = input?.streamInfo ?? {};
+      const guesses = await detectStreamInfo(source, info);
+      return await runConversion(source, guesses);
+    } finally {
+      opts._zipDepth = prevDepth;
+    }
+  }
+  async function convertLocal(filePath, streamInfo) {
+    const ext = path4.extname(filePath);
+    const filename = path4.basename(filePath);
+    const base = {
+      localPath: filePath,
+      extension: ext || undefined,
+      filename
+    };
+    const merged = streamInfo ? mergeStreamInfo(base, streamInfo) : base;
+    const buffer = await fs2.promises.readFile(filePath);
+    const guesses = await detectStreamInfo(buffer, merged);
+    return runConversion(buffer, guesses);
+  }
+  async function convertUri(uri, streamInfo) {
+    uri = uri.trim();
+    if (uri.startsWith("file:")) {
+      const { netloc, path: localPath } = fileUriToPath(uri);
+      if (netloc && netloc !== "localhost") {
+        throw new Error(`Unsupported file URI: ${uri}. Netloc must be empty or localhost.`);
+      }
+      return convertLocal(localPath, streamInfo);
+    }
+    if (uri.startsWith("data:")) {
+      const { mimeType, attributes, data } = parseDataUri(uri);
+      const base = {
+        mimetype: mimeType ?? undefined,
+        charset: attributes.charset
+      };
+      const merged = streamInfo ? mergeStreamInfo(base, streamInfo) : base;
+      const guesses = await detectStreamInfo(data, merged);
+      return runConversion(data, guesses);
+    }
+    if (uri.startsWith("http:") || uri.startsWith("https:")) {
+      return convertUrl(uri, streamInfo);
+    }
+    throw new Error(`Unsupported URI scheme: ${uri.split(":")[0]}. Supported: file, data, http, https`);
+  }
+  async function convertUrl(url, streamInfo) {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "text/markdown, text/html;q=0.9, text/plain;q=0.8, */*;q=0.1"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    let mimetype;
+    let charset;
+    const contentType = response.headers.get("content-type");
+    if (contentType) {
+      const parts = contentType.split(";");
+      mimetype = parts.shift()?.trim();
+      for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed.startsWith("charset=")) {
+          const val = trimmed.slice(8).trim();
+          if (val)
+            charset = val;
+        }
+      }
+    }
+    let filename;
+    let extension;
+    const disposition = response.headers.get("content-disposition");
+    if (disposition) {
+      const match = disposition.match(/filename=([^;]+)/);
+      if (match) {
+        filename = match[1].replace(/["']/g, "");
+        const ext = path4.extname(filename);
+        if (ext)
+          extension = ext;
+      }
+    }
+    if (!filename) {
+      try {
+        const parsed = new URL(url);
+        const ext = path4.extname(parsed.pathname);
+        if (ext) {
+          filename = path4.basename(parsed.pathname);
+          extension = ext;
+        }
+      } catch {}
+    }
+    const base = {
+      mimetype,
+      charset,
+      filename,
+      extension,
+      url
+    };
+    const merged = streamInfo ? mergeStreamInfo(base, streamInfo) : base;
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const guesses = await detectStreamInfo(buffer, merged);
+    return runConversion(buffer, guesses);
+  }
+  return {
+    convert,
+    convertLocal,
+    convertUri,
+    convertUrl,
+    registerConverter: (conv, priority = PRIORITY_SPECIFIC) => {
+      register(conv, priority);
+    }
+  };
+}
+// src/types.ts
+import { z } from "zod/v4";
+var StreamInfoSchema = z.object({
+  mimetype: z.string().optional(),
+  extension: z.string().optional(),
+  charset: z.string().optional(),
+  filename: z.string().optional(),
+  localPath: z.string().optional(),
+  url: z.string().optional()
+});
+var ConvertResultSchema = z.object({
+  markdown: z.string(),
+  title: z.string().optional()
+});
+var ConvertOptionsSchema = z.object({
+  llmClient: z.any().optional(),
+  llmModel: z.string().optional(),
+  llmPrompt: z.string().optional(),
+  exiftoolPath: z.string().optional(),
+  styleMap: z.string().optional(),
+  keepDataUris: z.boolean().optional(),
+  youtubeTranscriptLanguages: z.array(z.string()).optional(),
+  _zipDepth: z.number().optional()
+});
+export {
+  youtubeConverter,
+  xlsxConverter,
+  xlsConverter,
+  wikipediaConverter,
+  rssConverter,
+  pptxConverter,
+  plainTextConverter,
+  pdfConverter,
+  outlookMsgConverter,
+  mergeStreamInfo,
+  ipynbConverter,
+  imageConverter,
+  htmlToMarkdown,
+  htmlConverter,
+  hasCharset,
+  epubConverter,
+  docxConverter,
+  decodeBuffer,
+  csvConverter,
+  createZipConverter,
+  createMarkItDown,
+  converter,
+  byUrl,
+  byMime,
+  byExt,
+  bingSerpConverter,
+  audioConverter,
+  anyOf,
+  allOf,
+  UnsupportedFormatError,
+  StreamInfoSchema,
+  MissingDependencyError,
+  MarkItDownError,
+  FileConversionError,
+  ConvertResultSchema,
+  ConvertOptionsSchema
+};