markitdown-ts 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1160 @@
+'use strict';
+
+const mime = require('mime-types');
+const path = require('path');
+const fs = require('fs');
+const jsdom = require('jsdom');
+const TurndownService = require('turndown');
+const turndownPluginGfm = require('@joplin/turndown-plugin-gfm');
+const xmldom = require('@xmldom/xmldom');
+const url = require('url');
+const pdfTs = require('pdf-ts');
+const Mammoth = require('mammoth');
+const XLSX = require('xlsx');
+const childProcess = require('child_process');
+const util = require('util');
+const fs$1 = require('fs/promises');
+const os = require('os');
+const ai = require('ai');
+const unzipper = require('unzipper');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const mime__namespace = /*#__PURE__*/_interopNamespaceCompat(mime);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const path__default = /*#__PURE__*/_interopDefaultCompat(path);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+const TurndownService__default = /*#__PURE__*/_interopDefaultCompat(TurndownService);
+const turndownPluginGfm__default = /*#__PURE__*/_interopDefaultCompat(turndownPluginGfm);
+const Mammoth__default = /*#__PURE__*/_interopDefaultCompat(Mammoth);
+const XLSX__default = /*#__PURE__*/_interopDefaultCompat(XLSX);
+const childProcess__namespace = /*#__PURE__*/_interopNamespaceCompat(childProcess);
+const util__namespace = /*#__PURE__*/_interopNamespaceCompat(util);
+const fs__namespace$1 = /*#__PURE__*/_interopNamespaceCompat(fs$1);
+const os__namespace = /*#__PURE__*/_interopNamespaceCompat(os);
+const unzipper__namespace = /*#__PURE__*/_interopNamespaceCompat(unzipper);
+
+class PlainTextConverter {
+  async convert(local_path, options = {}) {
+    const fileExtension = options.file_extension || "";
+    const contentType = mime__namespace.lookup(fileExtension);
+    if (!contentType) {
+      return null;
+    } else if (!contentType.toLowerCase().includes("text/")) {
+      return null;
+    }
+    const content = fs__default.readFileSync(local_path, { encoding: "utf-8" });
+    return {
+      title: null,
+      text_content: content
+    };
+  }
+}
+
+class CustomTurnDown {
+  convert_soup(doc) {
+    let turnDownService = new TurndownService__default({
+      headingStyle: "atx"
+    });
+    turnDownService.use(turndownPluginGfm__default.gfm);
+    turnDownService.addRule("anchor tags", {
+      filter: ["a"],
+      replacement: function(content, node) {
+        if (content === "") {
+          return "";
+        }
+        let prefix = "";
+        let suffix = "";
+        if (content && content[0] === " ") {
+          prefix = " ";
+        }
+        if (content && content[content.length - 1] === " ") {
+          suffix = " ";
+        }
+        let text = content.trim().replace(/\n\n.*/g, "");
+        if (text === "") {
+          return "";
+        }
+        let href = node.getAttribute("href");
+        let title = node.title;
+        if (href) {
+          try {
+            let parsed_url = new URL(href);
+            if (!["https:", "http:", "file:"].includes(parsed_url.protocol)) {
+              return `${prefix}${text}${suffix}`;
+            }
+          } catch (e) {
+            if (!/^https?:|^file:/.test(href)) {
+              return `${prefix}[${text}](${href} "${title}")${suffix}`;
+            }
+            return `${prefix}${text}${suffix}`;
+          }
+        }
+        if (text.replace(/\\_/g, "_") === href && !title) {
+          return `<${href}>`;
+        }
+        if (!title && href) {
+          title = href;
+        }
+        let title_part = title ? ` "${title}"` : "";
+        return `${prefix}[${text}](${href}${title_part})${suffix}`;
+      }
+    });
+    turnDownService.addRule("img tags", {
+      filter: ["img"],
+      replacement: function(_, node) {
+        if (!node || node.nodeName !== "IMG") {
+          return "";
+        }
+        let alt = node.getAttribute("alt") || "";
+        let src = node.getAttribute("src") || "";
+        let title = node.getAttribute("title") || "";
+        let titlePart = title ? ` "${title}"` : "";
+        if (src.startsWith("data:")) {
+          src = src.split(",")[0] + "...";
+        }
+        return `![${alt}](${src}${titlePart})`;
+      }
+    });
+    let markdown = turnDownService.turndown(doc);
+    return markdown;
+  }
+}
+
+class HtmlConverter {
+  async convert(local_path, options) {
+    const extension = options.file_extension || "";
+    if (![".html", ".htm"].includes(extension.toLowerCase())) {
+      return null;
+    }
+    try {
+      let exists = fs__namespace.existsSync(local_path);
+      if (!exists) {
+        throw new Error("File does'nt exists");
+      }
+      let content = fs__namespace.readFileSync(local_path, { encoding: "utf-8" });
+      return await this._convert(content);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+  async _convert(htmlContent) {
+    const soup = new jsdom.JSDOM(htmlContent);
+    const doc = soup.window.document;
+    doc.querySelectorAll("script, style").forEach((script) => {
+      script.remove();
+    });
+    const bodyElm = doc.querySelector("body");
+    let webpageText = "";
+    if (bodyElm) {
+      webpageText = new CustomTurnDown().convert_soup(bodyElm);
+    } else {
+      webpageText = new CustomTurnDown().convert_soup(doc);
+    }
+    return {
+      title: doc.title,
+      text_content: webpageText
+    };
+  }
+}
+
+class RSSConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".xml", ".rss", ".atom"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    try {
+      const xmlString = fs__namespace.readFileSync(localPath, { encoding: "utf-8" });
+      const doc = new xmldom.DOMParser().parseFromString(xmlString, "text/xml");
+      let result;
+      if (doc.getElementsByTagName("rss").length > 0) {
+        result = this._parseRssType(doc);
+      } else if (doc.getElementsByTagName("feed").length > 0) {
+        const root = doc.getElementsByTagName("feed")[0];
+        if (root.getElementsByTagName("entry").length > 0) {
+          result = this._parseAtomType(doc);
+        }
+      }
+      return result;
+    } catch (error) {
+      console.error("RSS Parsing Error:", error);
+      return null;
+    }
+  }
+  _parseAtomType(doc) {
+    try {
+      const root = doc.getElementsByTagName("feed")[0];
+      const title = this._getDataByTagName(root, "title");
+      const subtitle = this._getDataByTagName(root, "subtitle");
+      const entries = root.getElementsByTagName("entry");
+      let mdText = `# ${title}
+`;
+      if (subtitle) {
+        mdText += `${subtitle}
+`;
+      }
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        const entryTitle = this._getDataByTagName(entry, "title");
+        const entrySummary = this._getDataByTagName(entry, "summary");
+        const entryUpdated = this._getDataByTagName(entry, "updated");
+        const entryContent = this._getDataByTagName(entry, "content");
+        if (entryTitle) {
+          mdText += `
+## ${entryTitle}
+`;
+        }
+        if (entryUpdated) {
+          mdText += `Updated on: ${entryUpdated}
+`;
+        }
+        if (entrySummary) {
+          mdText += this._parseContent(entrySummary);
+        }
+        if (entryContent) {
+          mdText += this._parseContent(entryContent);
+        }
+      }
+      return {
+        title,
+        text_content: mdText
+      };
+    } catch (error) {
+      console.error("Atom Parsing Error:", error);
+      return null;
+    }
+  }
+  _parseRssType(doc) {
+    try {
+      const root = doc.getElementsByTagName("rss")[0];
+      const channel = root.getElementsByTagName("channel");
+      if (!channel || channel.length === 0) {
+        return null;
+      }
+      const channelElement = channel[0];
+      const channelTitle = this._getDataByTagName(channelElement, "title");
+      const channelDescription = this._getDataByTagName(channelElement, "description");
+      const items = channelElement.getElementsByTagName("item");
+      let mdText = "";
+      if (channelTitle) {
+        mdText = `# ${channelTitle}
+`;
+      }
+      if (channelDescription) {
+        mdText += `${channelDescription}
+`;
+      }
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const title = this._getDataByTagName(item, "title");
+        const description = this._getDataByTagName(item, "description");
+        const pubDate = this._getDataByTagName(item, "pubDate");
+        const content = this._getDataByTagName(item, "content:encoded");
+        if (title) {
+          mdText += `
+## ${title}
+`;
+        }
+        if (pubDate) {
+          mdText += `Published on: ${pubDate}
+`;
+        }
+        if (description) {
+          mdText += this._parseContent(description);
+        }
+        if (content) {
+          mdText += this._parseContent(content);
+        }
+      }
+      return {
+        title: channelTitle,
+        text_content: mdText
+      };
+    } catch (error) {
+      console.error("RSS Parsing Error:", error);
+      return null;
+    }
+  }
+  _parseContent(content) {
+    try {
+      const dom = new jsdom.JSDOM(content);
+      const document = dom.window.document;
+      return new CustomTurnDown().convert_soup(document);
+    } catch (error) {
+      console.warn("Parsing content error", error);
+      return content;
+    }
+  }
+  _getDataByTagName(element, tagName) {
+    const nodes = element.getElementsByTagName(tagName);
+    if (!nodes || nodes.length === 0) {
+      return null;
+    }
+    const fc = nodes[0].firstChild;
+    if (fc && fc.nodeValue) {
+      return fc.nodeValue;
+    }
+    return null;
+  }
+}
+
+class WikipediaConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".html", ".htm"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    const url = options.url || "";
+    if (!/^https?:\/\/[a-zA-Z]{2,3}\.wikipedia\.org\//.test(url)) {
+      return null;
+    }
+    try {
+      const htmlContent = fs__namespace.readFileSync(localPath, { encoding: "utf-8" });
+      return this._convert(htmlContent);
+    } catch (error) {
+      console.error("Wikipedia Parsing Error:", error);
+      return null;
+    }
+  }
+  _convert(htmlContent) {
+    const dom = new jsdom.JSDOM(htmlContent);
+    const doc = dom.window.document;
+    doc.querySelectorAll("script, style").forEach((script) => {
+      script.remove();
+    });
+    const bodyElm = doc.querySelector("div#mw-content-text");
+    const titleElm = doc.querySelector("span.mw-page-title-main");
+    let webpageText = "";
+    let mainTitle = doc.title;
+    if (bodyElm) {
+      if (titleElm && titleElm.textContent) {
+        mainTitle = titleElm.textContent;
+      }
+      webpageText = `# ${mainTitle}
+
+` + new CustomTurnDown().convert_soup(bodyElm);
+    } else {
+      webpageText = new CustomTurnDown().convert_soup(doc);
+    }
+    return {
+      title: mainTitle,
+      text_content: webpageText
+    };
+  }
+}
+
+class YouTubeConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".html", ".htm"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    const url = options.url || "";
+    if (!url.startsWith("https://www.youtube.com/watch?")) {
+      return null;
+    }
+    try {
+      const htmlContent = fs__namespace.readFileSync(localPath, { encoding: "utf-8" });
+      return this._convert(htmlContent, url, options);
+    } catch (error) {
+      console.error("YouTube Parsing Error:", error);
+      return null;
+    }
+  }
+  async _convert(htmlContent, url$1, options) {
+    const dom = new jsdom.JSDOM(htmlContent);
+    const doc = dom.window.document;
+    const metadata = {
+      title: doc.title
+    };
+    doc.querySelectorAll("meta").forEach((meta) => {
+      for (const a of meta.attributes) {
+        const attributeContent = meta.getAttribute("content");
+        if (["itemprop", "property", "name"].includes(a.name) && attributeContent) {
+          metadata[a.value] = attributeContent;
+          break;
+        }
+      }
+    });
+    try {
+      for (const script of doc.querySelectorAll("script")) {
+        const content = script.textContent || "";
+        if (content.includes("ytInitialData")) {
+          const lines = content.split(/\r?\n/);
+          const objStart = lines[0].indexOf("{");
+          const objEnd = lines[0].lastIndexOf("}");
+          if (objStart >= 0 && objEnd >= 0) {
+            const data = JSON.parse(lines[0].substring(objStart, objEnd + 1));
+            const attrdesc = this._findKey(data, "attributedDescriptionBodyText");
+            if (attrdesc) {
+              metadata["description"] = attrdesc["content"];
+            }
+          }
+          break;
+        }
+      }
+    } catch (e) {
+      console.warn("Error while parsing Youtube description");
+    }
+    let webpageText = "# YouTube\n";
+    const title = this._get(metadata, ["title", "og:title", "name"]);
+    if (title) {
+      webpageText += `
+## ${title}
+`;
+    }
+    let stats = "";
+    const views = this._get(metadata, ["interactionCount"]);
+    if (views) {
+      stats += `- **Views:** ${views}
+`;
+    }
+    const keywords = this._get(metadata, ["keywords"]);
+    if (keywords) {
+      stats += `- **Keywords:** ${keywords}
+`;
+    }
+    const runtime = this._get(metadata, ["duration"]);
+    if (runtime) {
+      stats += `- **Runtime:** ${runtime}
+`;
+    }
+    if (stats.length > 0) {
+      webpageText += `
+### Video Metadata
+${stats}
+`;
+    }
+    const description = this._get(metadata, ["description", "og:description"]);
+    if (description) {
+      webpageText += `
+### Description
+${description}
+`;
+    }
+    if (options.enableYoutubeTranscript) {
+      let transcriptText = "";
+      const parsedUrl = new url.URL(url$1);
+      const params = parsedUrl.searchParams;
+      const videoId = params.get("v");
+      let ytTranscript;
+      try {
+        ytTranscript = await import('youtube-transcript').then((mod) => mod.YoutubeTranscript);
+      } catch (error) {
+        console.warn(
+          "Optional dependency 'youtube-transcript' is not installed. Run `npm install youtube-transcript` to enable this feature."
+        );
+        return null;
+      }
+      if (videoId) {
+        try {
+          const youtubeTranscriptLanguage = options.youtubeTranscriptLanguage || "en";
+          const transcript = await ytTranscript.fetchTranscript(videoId, {
+            lang: youtubeTranscriptLanguage
+          });
+          transcriptText = transcript.map((part) => part.text).join(" ");
+        } catch (error) {
+          console.warn("Error while extracting the Youtube Transcript", error);
+        }
+      }
+      if (transcriptText) {
+        webpageText += `
+### Transcript
+${transcriptText}
+`;
+      }
+    }
+    const finalTitle = title ? title : doc.title;
+    return {
+      title: finalTitle,
+      text_content: webpageText
+    };
+  }
+  _get(metadata, keys, default_value) {
+    for (const k of keys) {
+      if (metadata[k]) {
+        return metadata[k];
+      }
+    }
+    return default_value || null;
+  }
+  _findKey(json, key) {
+    if (Array.isArray(json)) {
+      for (const elm of json) {
+        const ret = this._findKey(elm, key);
+        if (ret) {
+          return ret;
+        }
+      }
+    } else if (typeof json === "object" && json !== null) {
+      for (const k in json) {
+        if (k === key) {
+          return json[k];
+        } else {
+          const ret = this._findKey(json[k], key);
+          if (ret) {
+            return ret;
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
+
+class IpynbConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (fileExtension.toLowerCase() !== ".ipynb") {
+      return null;
+    }
+    try {
+      const notebookContent = JSON.parse(fs__namespace.readFileSync(localPath, { encoding: "utf-8" }));
+      return this._convert(notebookContent);
+    } catch (error) {
+      console.error("Error converting .ipynb file:", error);
+      return null;
+    }
+  }
+  _convert(notebookContent) {
+    try {
+      const mdOutput = [];
+      let title = null;
+      for (const cell of notebookContent.cells || []) {
+        const cellType = cell.cell_type || "";
+        const sourceLines = cell.source || [];
+        if (cellType === "markdown") {
+          mdOutput.push(sourceLines.join(""));
+          if (!title) {
+            for (const line of sourceLines) {
+              if (line.startsWith("# ")) {
+                title = line.substring(line.indexOf("# ") + 2).trim();
+                break;
+              }
+            }
+          }
+        } else if (cellType === "code") {
+          mdOutput.push(`\`\`\`python
+${sourceLines.join("")}
+\`\`\``);
+        } else if (cellType === "raw") {
+          mdOutput.push(`\`\`\`
+${sourceLines.join("")}
+\`\`\``);
+        }
+      }
+      const mdText = mdOutput.join("\n\n");
+      title = notebookContent.metadata?.title || title;
+      return {
+        title,
+        text_content: mdText
+      };
+    } catch (e) {
+      console.error("Error converting .ipynb file:", e);
+      throw new Error(`Error converting .ipynb file: ${e}`);
+    }
+  }
+}
+
+class BingSerpConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".html", ".htm"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    const url = options.url || "";
+    if (!/^https:\/\/www\.bing\.com\/search\?q=/.test(url)) {
+      return null;
+    }
+    try {
+      const htmlContent = fs__namespace.readFileSync(localPath, { encoding: "utf-8" });
+      return this._convert(htmlContent, url);
+    } catch (error) {
+      console.error("Bing SERP Parsing Error:", error);
+      return null;
+    }
+  }
+  _convert(htmlContent, url$1) {
+    const dom = new jsdom.JSDOM(htmlContent);
+    const doc = dom.window.document;
+    const parsedParams = new url.URL(url$1).searchParams;
+    const query = parsedParams.get("q") || "";
+    doc.querySelectorAll(".tptt").forEach((tptt) => {
+      if (tptt.textContent) {
+        tptt.textContent += " ";
+      }
+    });
+    doc.querySelectorAll(".algoSlug_icon").forEach((slug) => {
+      slug.remove();
+    });
+    const markdownify = new CustomTurnDown();
+    const results = [];
+    doc.querySelectorAll(".b_algo").forEach((result) => {
+      result.querySelectorAll("a[href]").forEach((a) => {
+        try {
+          const parsedHref = new url.URL(a.getAttribute("href"));
+          const params = parsedHref.searchParams;
+          const u = params.get("u");
+          if (u) {
+            const decoded = this._decodeBase64Url(u);
+            a.setAttribute("href", decoded);
+          }
+        } catch (e) {
+        }
+      });
+      const mdResult = markdownify.convert_soup(result).trim();
+      const lines = mdResult.split(/\n+/).map((line) => line.trim()).filter((line) => line.length > 0);
+      results.push(lines.join("\n"));
+    });
+    const webpageText = `## A Bing search for '${query}' found the following results:
+
+${results.join("\n\n")}`;
+    return {
+      title: doc.title,
+      text_content: webpageText
+    };
+  }
+  _decodeBase64Url(encodedUrl) {
+    let u = encodedUrl.slice(2).trim() + "==";
+    try {
+      const decoded = Buffer.from(u, "base64").toString("utf-8");
+      return decoded;
+    } catch (error) {
+      console.error("Error decoding Base64URL:", error);
+      return encodedUrl;
+    }
+  }
+}
+
+class PdfConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".pdf"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    try {
+      const pdfContent = fs__default.readFileSync(localPath);
+      return this._convert(pdfContent);
+    } catch (error) {
+      console.error("PDF Parsing Error:", error);
+      return null;
+    }
+  }
+  async _convert(pdfContent) {
+    try {
+      const textContent = await pdfTs.pdfToText(pdfContent);
+      return {
+        title: null,
+        text_content: textContent
+      };
+    } catch (error) {
+      console.error("PDF Parsing Error:", error);
+      return null;
+    }
+  }
+}
+
+class DocxConverter extends HtmlConverter {
+  async convert(local_path, options) {
+    const fileExtension = options.file_extension || "";
+    if (![".docx"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    try {
+      let exists = fs__namespace.existsSync(local_path);
+      if (!exists) {
+        throw new Error("File does'nt exists");
+      }
+      let htmlContent = await Mammoth__default.convertToHtml(
+        {
+          path: local_path
+        },
+        {
+          ...options
+        }
+      );
+      return await this._convert(htmlContent.value);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+}
+
+class XlsxConverter extends HtmlConverter {
+  async convert(local_path, options) {
+    const extension = options.file_extension || "";
+    if (![".xlsx"].includes(extension.toLowerCase())) {
+      return null;
+    }
+    try {
+      let exists = fs__namespace.existsSync(local_path);
+      if (!exists) {
+        throw new Error("File does'nt exists");
+      }
+      let workbook = XLSX__default.readFile(local_path);
+      let mdContent = "";
+      for (const sheetName of workbook.SheetNames) {
+        mdContent += `## ${sheetName}
+`;
+        let htmlContent = XLSX__default.utils.sheet_to_html(workbook.Sheets[sheetName]);
+        mdContent += (await this._convert(htmlContent))?.text_content.trim() + "\n\n";
+      }
+      return {
+        title: workbook?.Props?.Title || "Untitled",
+        text_content: mdContent
+      };
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+}
+
+const exec = util__namespace.promisify(childProcess__namespace.exec);
+class MediaConverter {
+  async _getMetadata(localPath) {
+    const exiftool = await this._which("exiftool");
+    if (!exiftool) {
+      console.error("exiftool is not found on this system so metadata cannot be extracted");
+      return null;
+    }
+    try {
+      const result = await exec(`"${exiftool}" -json "${localPath}"`);
+      return JSON.parse(result.stdout)[0];
+    } catch (error) {
+      console.error("Exiftool error:", error);
+      return null;
+    }
+  }
+  async _which(command) {
+    try {
+      const result = await exec(`which ${command}`);
+      return result.stdout.trim();
+    } catch (error) {
+      console.warn("Which command error:", error);
+      return null;
+    }
+  }
+}
+
+class WavConverter extends MediaConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (fileExtension.toLowerCase() !== ".wav") {
+      return null;
+    }
+    try {
+      return this._convert(localPath, options);
+    } catch (error) {
+      console.error("WAV Conversion Error:", error);
+      return null;
+    }
+  }
+  async _convert(localPath, _) {
+    let mdContent = "";
+    const metadata = await this._getMetadata(localPath);
+    if (metadata) {
+      for (const f of [
+        "Title",
+        "Artist",
+        "Author",
+        "Band",
+        "Album",
+        "Genre",
+        "Track",
+        "DateTimeOriginal",
+        "CreateDate",
+        "Duration"
+      ]) {
+        if (metadata[f]) {
+          mdContent += `${f}: ${metadata[f]}
+`;
+        }
+      }
+    }
+    try {
+      const transcript = await this._transcribeAudio(localPath);
+      mdContent += `
+
+### Audio Transcript:
+${transcript === "" ? "[No speech detected]" : transcript}`;
+    } catch (error) {
+      console.error("Error loading speech recognition module:", error);
+      mdContent += "\n\n### Audio Transcript:\nError. Could not transcribe this audio.";
+    }
+    return {
+      title: null,
+      text_content: mdContent.trim()
+    };
+  }
+  // TODO: Add speech to text
+  async _transcribeAudio(_) {
+    throw new Error("TODO: Audio transcription not implemented yet");
+  }
+}
+
+class Mp3Converter extends WavConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (fileExtension.toLowerCase() !== ".mp3") {
+      return null;
+    }
+    try {
+      return await this._convert$(localPath, options);
+    } catch (error) {
+      console.error("MP3 Conversion Error:", error);
+      return null;
+    }
+  }
+  async _convert$(localPath, options) {
+    let mdContent = "";
+    const metadata = await this._getMetadata(localPath);
+    if (metadata) {
+      for (const f of [
+        "Title",
+        "Artist",
+        "Author",
+        "Band",
+        "Album",
+        "Genre",
+        "Track",
+        "DateTimeOriginal",
+        "CreateDate",
+        "Duration"
+      ]) {
+        if (metadata[f]) {
+          mdContent += `${f}: ${metadata[f]}
+`;
+        }
+      }
+    }
+    const tempPath = await fs__namespace$1.mkdtemp(path__namespace.join(os__namespace.tmpdir(), "temp_"));
+    const wavPath = path__namespace.join(tempPath, "audio.wav");
+    try {
+      const transcript = await super._transcribeAudio(wavPath);
+      mdContent += `
+
+### Audio Transcript:
+${transcript == "" ? "[No speech detected]" : transcript}`;
+    } catch (e) {
+      mdContent += "\n\n### Audio Transcript:\nError. Could not transcribe this audio.";
+    } finally {
+      await fs__namespace$1.unlink(wavPath);
+      await fs__namespace$1.rmdir(tempPath);
+    }
+    return {
+      title: null,
+      text_content: mdContent.trim()
+    };
+  }
+}
+
+class ImageConverter extends MediaConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (![".jpg", ".jpeg", ".png"].includes(fileExtension.toLowerCase())) {
+      return null;
+    }
+    try {
+      return this._convert(localPath, options);
+    } catch (error) {
+      console.error("Image Conversion Error:", error);
+      return null;
+    }
+  }
+  async _convert(localPath, options) {
+    let mdContent = "";
+    const metadata = await this._getMetadata(localPath);
+    if (metadata) {
+      for (const f of [
+        "ImageSize",
+        "Title",
+        "Caption",
+        "Description",
+        "Keywords",
+        "Artist",
+        "Author",
+        "DateTimeOriginal",
+        "CreateDate",
+        "GPSPosition"
+      ]) {
+        if (metadata[f]) {
+          mdContent += `${f}: ${metadata[f]}
+`;
+        }
+      }
+    }
+    if (options.llmModel) {
+      mdContent += `
+# Description:
+${(await this._getLLMDescription(localPath, options)).trim()}
+`;
+    }
+    return {
+      title: null,
+      text_content: mdContent.trim()
+    };
+  }
+  async _getLLMDescription(localPath, options) {
+    if (!options.llmPrompt || options.llmPrompt.trim() === "") {
+      options.llmPrompt = "Write a detailed caption for this image.";
+    }
+    const imageFile = fs__namespace.readFileSync(localPath).toString("base64");
+    const result = await ai.generateText({
+      model: options.llmModel,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: options.llmPrompt },
+            {
+              type: "image",
+              image: imageFile
+            }
+          ]
+        }
+      ]
+    });
+    return result.text.trim();
+  }
+}
+
+class ZipConverter {
+  async convert(localPath, options = {}) {
+    const fileExtension = options.file_extension || "";
+    if (fileExtension.toLowerCase() !== ".zip") {
+      return null;
+    }
+    const parentConverters = options._parent_converters || [];
+    if (!parentConverters) {
+      return {
+        title: null,
+        text_content: `[ERROR] No converters available to process zip contents from: ${localPath}`
+      };
+    }
+    const extractedZipFolderName = `extracted_${path__namespace.basename(localPath).replace(".zip", "_zip")}`;
+    const newFolder = path__namespace.normalize(path__namespace.join(path__namespace.dirname(localPath), extractedZipFolderName));
+    let mdContent = `Content from the zip file \`${path__namespace.basename(localPath)}\`:
+
+`;
+    if (!newFolder.startsWith(path__namespace.dirname(localPath))) {
+      return {
+        title: null,
+        text_content: `[ERROR] Invalid zip file path: ${localPath}`
+      };
+    }
+    try {
+      await fs__namespace$1.mkdir(newFolder, { recursive: true });
+      const zip = await unzipper__namespace.Open.file(localPath);
+      await zip.extract({ path: newFolder });
+      const files = await this._walk(newFolder);
+      for (const { root, name } of files) {
+        const filePath = path__namespace.join(root, name);
+        const relativePath = path__namespace.relative(newFolder, filePath);
+        const fileExtension2 = path__namespace.extname(name);
+        const fileOptions = {
+          ...options,
+          file_extension: fileExtension2,
+          _parent_converters: parentConverters
+        };
+        for (const converter of parentConverters) {
+          if (converter instanceof ZipConverter) {
+            continue;
+          }
+          const result = await converter.convert(filePath, fileOptions);
+          if (result) {
+            mdContent += `
+## File: ${relativePath}
+
+`;
+            mdContent += result.text_content + "\n\n";
+            break;
+          }
+        }
+      }
+      if (options.cleanupExtracted !== false) {
+        await fs__namespace$1.rm(newFolder, { recursive: true, force: true });
+      }
+      return {
+        title: null,
+        text_content: mdContent.trim()
+      };
+    } catch (error) {
+      if (error.message.includes("invalid signature")) {
+        return {
+          title: null,
+          text_content: `[ERROR] Invalid or corrupted zip file: ${localPath}`
+        };
+      }
+      return {
+        title: null,
+        text_content: `[ERROR] Failed to process zip file ${localPath}: ${String(error)}`
+      };
+    }
+  }
+  async _walk(dir) {
+    let results = [];
+    const files = await fs__namespace$1.readdir(dir, { withFileTypes: true });
+    for (const file of files) {
+      if (file.isDirectory()) {
+        results = results.concat(await this._walk(path__namespace.join(dir, file.name)));
+      } else {
+        results.push({ root: dir, name: file.name });
+      }
+    }
+    return results;
+  }
+}
+
+class MarkItDown {
+  converters = [];
+  constructor() {
+    this.register_converter(new PlainTextConverter());
+    this.register_converter(new HtmlConverter());
+    this.register_converter(new RSSConverter());
+    this.register_converter(new WikipediaConverter());
+    this.register_converter(new YouTubeConverter());
+    this.register_converter(new BingSerpConverter());
+    this.register_converter(new DocxConverter());
+    this.register_converter(new XlsxConverter());
+    this.register_converter(new WavConverter());
+    this.register_converter(new Mp3Converter());
+    this.register_converter(new ImageConverter());
+    this.register_converter(new IpynbConverter());
+    this.register_converter(new PdfConverter());
+    this.register_converter(new ZipConverter());
+  }
+  async convert(source, options = {}) {
+    if (source instanceof Response) {
+      return await this.convert_response(source, options);
+    } else {
+      if (source.startsWith("http://") || source.startsWith("https://") || source.startsWith("file://")) {
+        return await this.convert_url(source, options);
+      } else {
+        return this.convert_local(source, options);
+      }
+    }
+  }
+  async convert_url(source, { fetch = globalThis.fetch, ...options }) {
+    let response = await fetch(source);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch URL: ${source}, status: ${response.status}`);
+    }
+    return await this.convert_response(response, options);
+  }
+  async convert_response(response, options) {
+    const ext = options.file_extension;
+    const extensions = ext ? /* @__PURE__ */ new Set([ext]) : /* @__PURE__ */ new Set();
+    const contentType = response.headers?.get("content-type")?.split(";")[0];
+    if (!contentType) {
+      throw new Error("Response Content-Type header is missing");
+    }
+    const mimeExtension = mime__namespace.extension(contentType);
+    if (mimeExtension) {
+      extensions.add(`.${mimeExtension}`);
+    }
+    const content_disposition = response.headers?.get("content-disposition") || "";
+    const fname = content_disposition.match(/filename="([^;]+)"/);
+    if (fname) {
+      extensions.add(path__default.extname(fname[1]));
+    }
+    const url_ext = path__default.extname(new URL(response.url).pathname);
+    extensions.add(url_ext);
+    const file = fname ? `/tmp/${fname?.[1]}` : "/tmp/temp";
+    const temp_writeable = fs__namespace.createWriteStream(file);
+    try {
+      if (response.body == null) {
+        throw new Error("Response body is empty");
+      }
+      const reader = response.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        temp_writeable.write(value);
+      }
+      temp_writeable.end();
+      return await this._convert(file, extensions, {
+        ...options,
+        url: response.url
+      });
+    } catch (e) {
+      throw new Error(`Could not write to file: ${e}`);
+    } finally {
+      try {
+        temp_writeable.close();
+      } catch (e) {
+        throw new Error(`Could not close file: ${e}`);
+      }
+    }
+  }
+  async convert_local(source, options) {
+    const ext = options.file_extension;
+    const extensions = ext ? new Set(ext) : /* @__PURE__ */ new Set();
+    if (!fs__namespace.existsSync(source)) {
+      throw new Error(`File not found: ${source}`);
+    }
+    const extname = path__default.extname(source);
+    if (extname === "") {
+      throw new Error(`File extension not found: ${source}`);
+    }
+    if (!extensions.has(extname)) {
+      extensions.add(extname);
+    }
+    return await this._convert(source, extensions, options);
+  }
+  async _convert(source, extensions, options = {}) {
+    let error;
+    for (const ext of extensions) {
+      for (const converter of this.converters) {
+        let res;
+        try {
+          const op = {
+            ...options,
+            file_extension: ext,
+            _parent_converters: this.converters
+          };
+          res = await converter.convert(source, op);
+        } catch (e) {
+          error = e;
+        }
+        if (res != null) {
+          res.text_content = res.text_content.replace(/(?:\r\n|\r|\n)/g, "\n").trim();
+          res.text_content = res.text_content.replace(/\n{3,}/g, "\n\n");
+          return res;
+        }
+      }
+    }
+    if (error) {
+      throw new Error(
+        `Could not convert ${source} to markdown. While converting the following error occurred: ${error}`
+      );
+    }
+    throw new Error(
+      `Could not convert ${source} to markdown format. The ${Array.from(extensions).join(
+        ", "
+      )} are not supported.`
+    );
+  }
+  // NOTE: Inserts the converter at the beginning of the list
+  register_converter(converter) {
+    this.converters.unshift(converter);
+  }
+}
+
+exports.MarkItDown = MarkItDown;