@ryangarber/markitdown-ts 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vaibhav Raj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# markitdown-ts
+
+`markitdown-ts` converts web-native document data to Markdown without filesystem, process, stream, or other runtime-specific dependencies. It is designed for browsers, workers, edge functions, and all other modern JavaScript environments.
+
+## Supported formats
+
+- Plain text, Markdown, CSV, and JSON
+- HTML
+- XML, RSS, and Atom feeds
+- Jupyter notebooks (`.ipynb`)
+- Word documents (`.docx`)
+- Excel workbooks (`.xlsx`)
+- Wikipedia, YouTube metadata, and Bing result pages supplied as HTML
+
+PDF, archive, audio, image metadata, local-path, and YouTube transcript features from the original project are intentionally not included because their implementations depended on runtime-specific modules, binaries, streams, or filesystem access.
+
+## Installation
+
+```sh
+npm install @ryangarber/markitdown-ts
+```
+
+## Usage
+
+### `Uint8Array` (preferred)
+
+```ts
+import { MarkItDown } from "markitdown-ts";
+
+const bytes = new TextEncoder().encode("Hello from the web");
+const result = await new MarkItDown().convert(bytes, {
+  file_extension: ".txt"
+});
+
+console.log(result?.markdown);
+```
+
+Any `Uint8Array` subclass is accepted as well. This keeps byte data from other modern JavaScript runtimes interoperable without requiring runtime-specific types.
+
+### Other in-memory sources
+
+The same `convert` method accepts:
+
+- `ArrayBuffer` and `SharedArrayBuffer`
+- Any typed array or `DataView`
+- `Blob` and `File`
+- `Response`
+
+A `file_extension` is required when the source does not carry a recognized MIME type or filename.
+
+```ts
+const file = new File([docxBytes], "document.docx");
+const result = await new MarkItDown().convert(file);
+```
+
+### URLs
+
+HTTP and HTTPS URLs are fetched with the global `fetch`. Pass a custom implementation when needed.
+
+```ts
+const result = await new MarkItDown().convert("https://example.com/article.html");
+```
+
+Browser requests remain subject to the remote server's CORS policy.
+
+### Responses
+
+```ts
+const response = await fetch("https://example.com/feed.xml");
+const result = await new MarkItDown().convert(response);
+```
+
+## API
+
+```ts
+type ByteSource = Uint8Array | ArrayBufferLike | ArrayBufferView | Blob;
+type ConversionSource = ByteSource | Response | URL | string;
+
+class MarkItDown {
+  convert(source: ConversionSource, options?: ConverterOptions): Promise<ConverterResult>;
+
+  /** @deprecated Pass the source directly to convert(). */
+  convertBuffer(
+    source: ByteSource,
+    options: ConverterOptions & { file_extension: string }
+  ): Promise<ConverterResult>;
+}
+```
+
+`convertBuffer` remains as a compatibility alias, but `convert(bytes, options)` is preferred.
+
+## Development
+
+```sh
+pnpm install
+pnpm check
+pnpm test --run
+pnpm build
+```
+
+Biome handles both formatting and linting. `tsup` produces ESM, CommonJS, source maps, and declarations in `dist`.
+
+## License
+
+MIT License © 2024 Vaibhav Raj

package/dist/index.cjs

@@ -0,0 +1,543 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _joplin_turndown_plugin_gfm = require("@joplin/turndown-plugin-gfm");
+_joplin_turndown_plugin_gfm = __toESM(_joplin_turndown_plugin_gfm, 1);
+let turndown = require("turndown");
+turndown = __toESM(turndown, 1);
+let linkedom = require("linkedom");
+let mammoth = require("mammoth");
+mammoth = __toESM(mammoth, 1);
+let xlsx = require("xlsx");
+xlsx = __toESM(xlsx, 1);
+let _xmldom_xmldom = require("@xmldom/xmldom");
+//#region src/bytes.ts
+async function toUint8Array(source) {
+	if (source instanceof Uint8Array) return source;
+	if (isBlob(source)) return new Uint8Array(await source.arrayBuffer());
+	if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+	return new Uint8Array(source);
+}
+function toArrayBuffer(source) {
+	return source.slice().buffer;
+}
+function decodeText(source) {
+	return new TextDecoder().decode(source);
+}
+function isBlob(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+//#endregion
+//#region src/custom-turndown.ts
+var CustomTurnDown = class {
+	convertSoup(document) {
+		const service = new turndown.default({ headingStyle: "atx" });
+		service.use(_joplin_turndown_plugin_gfm.default.gfm);
+		service.addRule("anchor tags", {
+			filter: ["a"],
+			replacement(content, node) {
+				if (!content) return "";
+				const prefix = content.startsWith(" ") ? " " : "";
+				const suffix = content.endsWith(" ") ? " " : "";
+				const text = content.trim().replace(/\n\n.*/g, "");
+				if (!text) return "";
+				const element = node;
+				const href = element.getAttribute("href");
+				let title = element.getAttribute("title") ?? "";
+				if (!href) return `${prefix}${text}${suffix}`;
+				try {
+					const url = new URL(href);
+					if (url.protocol !== "https:" && url.protocol !== "http:") return `${prefix}${text}${suffix}`;
+				} catch {
+					if (!href.startsWith("/") && !href.startsWith("#") && !href.startsWith("./") && !href.startsWith("../")) return `${prefix}${text}${suffix}`;
+				}
+				if (text.replace(/\\_/g, "_") === href && !title) return `<${href}>`;
+				if (!title) title = href;
+				return `${prefix}[${text}](${href}${title ? ` "${title}"` : ""})${suffix}`;
+			}
+		});
+		service.addRule("img tags", {
+			filter: ["img"],
+			replacement(_content, node) {
+				const element = node;
+				const alt = element.getAttribute("alt") ?? "";
+				let source = element.getAttribute("src") ?? "";
+				const title = element.getAttribute("title");
+				if (source.startsWith("data:")) source = `${source.split(",", 1)[0]}...`;
+				return `![${alt}](${source}${title ? ` "${title}"` : ""})`;
+			}
+		});
+		return service.turndown(document);
+	}
+};
+//#endregion
+//#region src/html-document.ts
+function parseHtmlDocument(html) {
+	return (0, linkedom.parseHTML)(html).document;
+}
+//#endregion
+//#region src/converters/bingserp.ts
+const BING_SEARCH_URL = /^https:\/\/www\.bing\.com\/search\?q=/i;
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BingSerpConverter = class {
+	async convert(source, options = {}) {
+		const extension = options.file_extension?.toLowerCase() ?? "";
+		const url = options.url ?? "";
+		if (extension !== ".html" && extension !== ".htm" || !BING_SEARCH_URL.test(url)) return null;
+		const document = parseHtmlDocument(decodeText(source));
+		const query = new URL(url).searchParams.get("q") ?? "";
+		document.querySelectorAll(".tptt").forEach((element) => {
+			if (element.textContent) element.textContent += " ";
+		});
+		document.querySelectorAll(".algoSlug_icon").forEach((element) => {
+			element.remove();
+		});
+		const turndown = new CustomTurnDown();
+		const markdown = `## A Bing search for '${query}' found the following results:\n\n${[...document.querySelectorAll(".b_algo")].map((result) => {
+			result.querySelectorAll("a[href]").forEach((anchor) => {
+				const href = anchor.getAttribute("href");
+				if (!href) return;
+				try {
+					const encoded = new URL(href, url).searchParams.get("u");
+					if (encoded) anchor.setAttribute("href", decodeBingUrl(encoded));
+				} catch {}
+			});
+			return turndown.convertSoup(result).split(/\n+/).map((line) => line.trim()).filter(Boolean).join("\n");
+		}).join("\n\n")}`;
+		return {
+			title: document.title || null,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+function decodeBingUrl(encoded) {
+	const input = encoded.slice(2).replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+	const bytes = [];
+	let bits = 0;
+	let bitCount = 0;
+	for (const character of input) {
+		const value = BASE64_ALPHABET.indexOf(character);
+		if (value < 0) return encoded;
+		bits = bits << 6 | value;
+		bitCount += 6;
+		if (bitCount >= 8) {
+			bitCount -= 8;
+			bytes.push(bits >> bitCount & 255);
+		}
+	}
+	return new TextDecoder().decode(new Uint8Array(bytes));
+}
+//#endregion
+//#region src/converters/html.ts
+var HtmlConverter = class {
+	async convert(source, options) {
+		const extension = options.file_extension?.toLowerCase() ?? "";
+		if (extension !== ".html" && extension !== ".htm") return null;
+		return this.convertHtml(decodeText(source));
+	}
+	async convertHtml(html) {
+		const document = parseHtmlDocument(html);
+		document.querySelectorAll("script, style").forEach((element) => {
+			element.remove();
+		});
+		const markdown = new CustomTurnDown().convertSoup(document.body ?? document);
+		return {
+			title: document.title || null,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+//#endregion
+//#region src/converters/docx.ts
+var DocxConverter = class extends HtmlConverter {
+	async convert(source, options) {
+		if (options.file_extension?.toLowerCase() !== ".docx") return null;
+		const html = await mammoth.default.convertToHtml({ arrayBuffer: toArrayBuffer(source) }, {
+			styleMap: options.styleMap,
+			includeEmbeddedStyleMap: options.includeEmbeddedStyleMap,
+			includeDefaultStyleMap: options.includeDefaultStyleMap,
+			ignoreEmptyParagraphs: options.ignoreEmptyParagraphs,
+			idPrefix: options.idPrefix,
+			transformDocument: options.transformDocument
+		});
+		return this.convertHtml(html.value);
+	}
+};
+//#endregion
+//#region src/converters/ipynb.ts
+var IpynbConverter = class {
+	async convert(source, options = {}) {
+		if (options.file_extension?.toLowerCase() !== ".ipynb") return null;
+		const notebook = JSON.parse(decodeText(source));
+		const output = [];
+		let title = notebook.metadata?.title ?? null;
+		for (const cell of notebook.cells ?? []) {
+			const lines = cell.source ?? [];
+			if (cell.cell_type === "markdown") {
+				output.push(lines.join(""));
+				title ?? (title = lines.find((line) => line.startsWith("# "))?.slice(2).trim() ?? null);
+			} else if (cell.cell_type === "code") output.push(`\`\`\`python\n${lines.join("")}\n\`\`\``);
+			else if (cell.cell_type === "raw") output.push(`\`\`\`\n${lines.join("")}\n\`\`\``);
+		}
+		const markdown = output.join("\n\n");
+		return {
+			title,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+//#endregion
+//#region src/mime.ts
+const MIME_EXTENSIONS = {
+	"application/atom+xml": ".atom",
+	"application/json": ".json",
+	"application/rss+xml": ".rss",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+	"application/xml": ".xml",
+	"text/csv": ".csv",
+	"text/html": ".html",
+	"text/markdown": ".md",
+	"text/plain": ".txt",
+	"text/xml": ".xml"
+};
+const TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".csv",
+	".json",
+	".log",
+	".markdown",
+	".md",
+	".text",
+	".txt"
+]);
+function extensionFromMime(contentType) {
+	if (!contentType) return null;
+	const mime = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+	return MIME_EXTENSIONS[mime] ?? (mime.startsWith("text/") ? ".txt" : null);
+}
+function isTextExtension(extension) {
+	return TEXT_EXTENSIONS.has(extension.toLowerCase());
+}
+function extensionFromPathname(pathname) {
+	const filename = pathname.split("/").pop() ?? "";
+	const dot = filename.lastIndexOf(".");
+	return dot > 0 ? filename.slice(dot).toLowerCase() : null;
+}
+//#endregion
+//#region src/converters/plain-text.ts
+var PlainTextConverter = class {
+	async convert(source, options = {}) {
+		if (!isTextExtension(options.file_extension ?? "")) return null;
+		const content = decodeText(source);
+		return {
+			title: null,
+			markdown: content,
+			text_content: content
+		};
+	}
+};
+//#endregion
+//#region src/converters/wikipedia.ts
+const WIKIPEDIA_URL = /^https?:\/\/[a-z]{2,3}\.wikipedia\.org\//i;
+var WikipediaConverter = class {
+	async convert(source, options = {}) {
+		const extension = options.file_extension?.toLowerCase() ?? "";
+		if (extension !== ".html" && extension !== ".htm" || !WIKIPEDIA_URL.test(options.url ?? "")) return null;
+		const document = parseHtmlDocument(decodeText(source));
+		document.querySelectorAll("script, style").forEach((element) => {
+			element.remove();
+		});
+		const body = document.querySelector("div#mw-content-text");
+		const title = document.querySelector("span.mw-page-title-main")?.textContent?.trim() || document.title || null;
+		const markdown = body ? `# ${title ?? "Wikipedia"}\n\n${new CustomTurnDown().convertSoup(body)}` : new CustomTurnDown().convertSoup(document);
+		return {
+			title,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+//#endregion
+//#region src/converters/xlsx.ts
+var XlsxConverter = class extends HtmlConverter {
+	async convert(source, options) {
+		if (options.file_extension?.toLowerCase() !== ".xlsx") return null;
+		const workbook = xlsx.read(source, { type: "array" });
+		const sections = [];
+		for (const sheetName of workbook.SheetNames) {
+			const sheet = workbook.Sheets[sheetName];
+			if (sheet?.["!ref"]) {
+				const result = await this.convertHtml(xlsx.utils.sheet_to_html(sheet));
+				sections.push(`## ${sheetName}\n${result?.markdown.trim() ?? ""}`);
+			}
+		}
+		const markdown = sections.join("\n\n");
+		return {
+			title: workbook.Props?.Title || "Untitled",
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+//#endregion
+//#region src/converters/xml-rss-atom.ts
+var RSSConverter = class {
+	async convert(source, options = {}) {
+		const extension = options.file_extension?.toLowerCase() ?? "";
+		if (![
+			".xml",
+			".rss",
+			".atom"
+		].includes(extension)) return null;
+		const document = new _xmldom_xmldom.DOMParser().parseFromString(decodeText(source), "text/xml");
+		if (document.getElementsByTagName("rss").length > 0) return this.parseRss(document);
+		if (document.getElementsByTagName("feed")[0]?.getElementsByTagName("entry").length) return this.parseAtom(document);
+		return null;
+	}
+	parseAtom(document) {
+		const root = document.getElementsByTagName("feed")[0];
+		if (!root) return null;
+		const title = getText(root, "title");
+		const subtitle = getText(root, "subtitle");
+		const sections = [`# ${title ?? "Feed"}`];
+		if (subtitle) sections.push(subtitle);
+		for (const entry of [...root.getElementsByTagName("entry")]) {
+			const entryTitle = getText(entry, "title");
+			const updated = getText(entry, "updated");
+			const summary = getText(entry, "summary");
+			const content = getText(entry, "content");
+			const lines = [];
+			if (entryTitle) lines.push(`## ${entryTitle}`);
+			if (updated) lines.push(`Updated on: ${updated}`);
+			if (summary) lines.push(parseContent(summary));
+			if (content) lines.push(parseContent(content));
+			sections.push(lines.join("\n"));
+		}
+		const markdown = sections.join("\n\n");
+		return {
+			title,
+			markdown,
+			text_content: markdown
+		};
+	}
+	parseRss(document) {
+		const channel = document.getElementsByTagName("rss")[0]?.getElementsByTagName("channel")[0];
+		if (!channel) return null;
+		const title = getText(channel, "title");
+		const description = getText(channel, "description");
+		const sections = title ? [`# ${title}`] : [];
+		if (description) sections.push(description);
+		for (const item of [...channel.getElementsByTagName("item")]) {
+			const itemTitle = getText(item, "title");
+			const published = getText(item, "pubDate");
+			const itemDescription = getText(item, "description");
+			const content = getText(item, "content:encoded");
+			const lines = [];
+			if (itemTitle) lines.push(`## ${itemTitle}`);
+			if (published) lines.push(`Published on: ${published}`);
+			if (itemDescription) lines.push(parseContent(itemDescription));
+			if (content) lines.push(parseContent(content));
+			sections.push(lines.join("\n"));
+		}
+		const markdown = sections.join("\n\n");
+		return {
+			title,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+function parseContent(content) {
+	return new CustomTurnDown().convertSoup(parseHtmlDocument(content).documentElement);
+}
+function getText(element, tagName) {
+	return element.getElementsByTagName(tagName)[0]?.textContent?.trim() || null;
+}
+//#endregion
+//#region src/converters/youtube.ts
+var YouTubeConverter = class {
+	async convert(source, options = {}) {
+		const extension = options.file_extension?.toLowerCase() ?? "";
+		if (extension !== ".html" && extension !== ".htm" || !options.url?.startsWith("https://www.youtube.com/watch?")) return null;
+		const document = parseHtmlDocument(decodeText(source));
+		const metadata = { title: document.title };
+		document.querySelectorAll("meta").forEach((meta) => {
+			const content = meta.getAttribute("content");
+			const key = meta.getAttribute("itemprop") ?? meta.getAttribute("property") ?? meta.getAttribute("name");
+			if (key && content) metadata[key] = content;
+		});
+		try {
+			for (const script of document.querySelectorAll("script")) {
+				const content = script.textContent ?? "";
+				if (!content.includes("ytInitialData")) continue;
+				const start = content.indexOf("{");
+				const end = content.lastIndexOf("}");
+				if (start >= 0 && end > start) {
+					const description = findKey(JSON.parse(content.slice(start, end + 1)), "attributedDescriptionBodyText");
+					if (isRecord(description) && typeof description.content === "string") metadata.description = description.content;
+				}
+				break;
+			}
+		} catch {}
+		const title = first(metadata, [
+			"title",
+			"og:title",
+			"name"
+		]) || document.title || null;
+		const lines = ["# YouTube"];
+		if (title) lines.push(`## ${title}`);
+		const stats = [];
+		const views = first(metadata, ["interactionCount"]);
+		const keywords = first(metadata, ["keywords"]);
+		const runtime = first(metadata, ["duration"]);
+		if (views) stats.push(`- **Views:** ${views}`);
+		if (keywords) stats.push(`- **Keywords:** ${keywords}`);
+		if (runtime) stats.push(`- **Runtime:** ${runtime}`);
+		if (stats.length > 0) lines.push(`### Video Metadata\n${stats.join("\n")}`);
+		const description = first(metadata, ["description", "og:description"]);
+		if (description) lines.push(`### Description\n${description}`);
+		const markdown = lines.join("\n\n");
+		return {
+			title,
+			markdown,
+			text_content: markdown
+		};
+	}
+};
+function first(metadata, keys) {
+	for (const key of keys) if (metadata[key]) return metadata[key];
+	return null;
+}
+function findKey(value, key) {
+	if (Array.isArray(value)) for (const item of value) {
+		const match = findKey(item, key);
+		if (match !== void 0) return match;
+	}
+	else if (isRecord(value)) {
+		if (key in value) return value[key];
+		for (const item of Object.values(value)) {
+			const match = findKey(item, key);
+			if (match !== void 0) return match;
+		}
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/markitdown.ts
+var MarkItDown = class {
+	constructor() {
+		this.converters = [];
+		this.registerConverter(new PlainTextConverter());
+		this.registerConverter(new HtmlConverter());
+		this.registerConverter(new RSSConverter());
+		this.registerConverter(new WikipediaConverter());
+		this.registerConverter(new YouTubeConverter());
+		this.registerConverter(new BingSerpConverter());
+		this.registerConverter(new DocxConverter());
+		this.registerConverter(new XlsxConverter());
+		this.registerConverter(new IpynbConverter());
+	}
+	/** Convert a URL, response, blob, array buffer, data view, or typed array. */
+	async convert(source, options = {}) {
+		if (typeof source === "string" || source instanceof URL) return this.convertUrl(source.toString(), options);
+		if (isResponse(source)) return this.convertResponse(source, options);
+		const extensions = /* @__PURE__ */ new Set();
+		this.addExtension(extensions, options.file_extension);
+		if (isBlob(source)) {
+			this.addExtension(extensions, extensionFromMime(source.type));
+			if ("name" in source && typeof source.name === "string") this.addExtension(extensions, extensionFromPathname(source.name));
+		}
+		if (extensions.size === 0) throw new Error("Could not determine the file type. Provide `file_extension` when converting bytes.");
+		return this.convertBytes(await toUint8Array(source), extensions, options);
+	}
+	/**
+	* @deprecated Pass the byte source directly to `convert`.
+	*/
+	async convertBuffer(source, options) {
+		return this.convert(source, options);
+	}
+	async convertUrl(source, { fetch: fetchImplementation = globalThis.fetch, ...options }) {
+		const url = new URL(source);
+		if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`Unsupported URL protocol: ${url.protocol}`);
+		if (!fetchImplementation) throw new Error("No fetch implementation is available.");
+		const response = await fetchImplementation(url);
+		if (!response.ok) throw new Error(`Failed to fetch URL: ${url}, status: ${response.status}`);
+		return this.convertResponse(response, {
+			...options,
+			url: url.toString()
+		});
+	}
+	async convertResponse(response, options) {
+		const extensions = /* @__PURE__ */ new Set();
+		this.addExtension(extensions, options.file_extension);
+		this.addExtension(extensions, extensionFromMime(response.headers.get("content-type")));
+		const filename = (response.headers.get("content-disposition") ?? "").match(/filename\*?=(?:UTF-8''|["']?)([^;"']+)/i)?.[1];
+		if (filename) this.addExtension(extensions, extensionFromPathname(decodeURIComponent(filename.trim())));
+		const responseUrl = options.url || response.url;
+		if (responseUrl) this.addExtension(extensions, extensionFromPathname(new URL(responseUrl).pathname));
+		if (extensions.size === 0) throw new Error("Could not determine the file type. Provide `file_extension` or a Content-Type header.");
+		return this.convertBytes(new Uint8Array(await response.arrayBuffer()), extensions, {
+			...options,
+			url: responseUrl
+		});
+	}
+	async convertBytes(source, extensions, options) {
+		let lastError;
+		for (const extension of extensions) for (const converter of this.converters) try {
+			const result = await converter.convert(source, {
+				...options,
+				file_extension: extension,
+				_parent_converters: this.converters
+			});
+			if (result) {
+				result.markdown = result.markdown.replace(/\r\n|\r|\n/g, "\n").trim().replace(/\n{3,}/g, "\n\n");
+				result.text_content = result.markdown;
+				return result;
+			}
+		} catch (error) {
+			lastError = error;
+		}
+		const formats = [...extensions].join(", ");
+		if (lastError) throw new Error(`Could not convert ${formats} to Markdown: ${String(lastError)}`);
+		throw new Error(`Unsupported file type: ${formats}.`);
+	}
+	addExtension(extensions, extension) {
+		if (!extension) return;
+		extensions.add(extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`);
+	}
+	registerConverter(converter) {
+		this.converters.unshift(converter);
+	}
+};
+function isResponse(value) {
+	return typeof Response !== "undefined" && value instanceof Response;
+}
+//#endregion
+exports.MarkItDown = MarkItDown;
+
+//# sourceMappingURL=index.cjs.map