@mdream/js 0.17.0

package/dist/llms-txt.mjs

@@ -0,0 +1,347 @@
+import { join, relative } from "pathe";
+import { mkdir, open } from "node:fs/promises";
+//#region src/llms-txt.ts
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+const ANCHOR_INVALID_CHARS_RE = /[^a-z0-9]/g;
+const LEADING_SLASH_RE = /^\//;
+const TRAILING_SLASH_RE = /\/$/;
+/**
+* Generate llms.txt content
+*/
+function generateLlmsTxtContent(files, options) {
+	const { siteName = "Site", description, origin = "", sections, notes } = options;
+	let content = `# ${siteName}\n\n`;
+	if (description) content += `> ${description}\n\n`;
+	if (origin) content += `Canonical Origin: ${origin}\n\n`;
+	if (sections) for (const section of sections) content += formatSection(section);
+	if (files.length > 0) {
+		content += `## Pages\n\n`;
+		for (const file of files) {
+			const desc = file.metadata?.description;
+			const descText = desc ? `: ${desc.substring(0, 100)}${desc.length > 100 ? "..." : ""}` : "";
+			if (file.filePath && options.outputDir && file.filePath.endsWith(".md")) {
+				const relativePath = relative(options.outputDir, file.filePath);
+				content += `- [${file.title}](${relativePath})${descText}\n`;
+			} else {
+				const url = file.url.startsWith("http://") || file.url.startsWith("https://") ? file.url : origin ? origin + file.url : file.url;
+				content += `- [${file.title}](${url})${descText}\n`;
+			}
+		}
+	}
+	if (notes) content += `\n${formatNotes(notes)}`;
+	return content;
+}
+/**
+* Parse frontmatter from markdown content
+*/
+function parseFrontmatter(content) {
+	const match = content.match(FRONTMATTER_RE);
+	if (!match) return {
+		frontmatter: null,
+		body: content
+	};
+	const frontmatterContent = match[1];
+	const body = match[2];
+	const frontmatter = {};
+	const lines = frontmatterContent.split("\n");
+	for (const line of lines) {
+		const colonIndex = line.indexOf(":");
+		if (colonIndex > 0) {
+			const key = line.substring(0, colonIndex).trim();
+			frontmatter[key] = line.substring(colonIndex + 1).trim();
+		}
+	}
+	return {
+		frontmatter,
+		body
+	};
+}
+/**
+* Serialize frontmatter object to YAML-like format
+*/
+function serializeFrontmatter(data) {
+	const lines = [];
+	for (const [key, value] of Object.entries(data)) if (value !== void 0 && value !== null) lines.push(`${key}: ${String(value)}`);
+	return lines.join("\n");
+}
+/**
+* Generate llms-full.txt content with complete page content
+*/
+function generateLlmsFullTxtContent(files, options) {
+	const { siteName = "Site", description, origin = "", sections, notes } = options;
+	let content = `# ${siteName}\n\n`;
+	if (description) content += `> ${description}\n\n`;
+	if (origin) content += `Canonical Origin: ${origin}\n\n`;
+	if (sections) for (const section of sections) content += formatSection(section);
+	if (files.length > 0) {
+		content += `## Table of Contents\n\n`;
+		for (const file of files) {
+			const anchor = file.title.toLowerCase().replace(ANCHOR_INVALID_CHARS_RE, "-");
+			content += `- [${file.title}](#${anchor})\n`;
+		}
+		content += `\n---\n\n`;
+		for (const file of files) {
+			const url = file.url.startsWith("http://") || file.url.startsWith("https://") ? file.url : origin ? origin + file.url : file.url;
+			const { frontmatter, body } = parseFrontmatter(file.content);
+			const metadata = {
+				title: file.title,
+				url
+			};
+			if (file.filePath && options.outputDir) metadata.file = relative(options.outputDir, file.filePath);
+			else if (file.filePath) metadata.file = file.filePath;
+			if (file.metadata) {
+				if (file.metadata.description) metadata.description = file.metadata.description;
+				if (file.metadata.keywords) metadata.keywords = file.metadata.keywords;
+				if (file.metadata.author) metadata.author = file.metadata.author;
+			}
+			const frontmatterString = serializeFrontmatter(frontmatter ? {
+				...frontmatter,
+				...metadata
+			} : metadata);
+			let contentBody = frontmatter ? body : file.content;
+			const titleLine = contentBody.trim().split("\n")[0];
+			if (titleLine === file.title || titleLine === `# ${file.title}`) contentBody = contentBody.trim().split("\n").slice(1).join("\n").trimStart();
+			content += `---\n${frontmatterString}\n---\n\n${contentBody}\n\n---\n\n`;
+		}
+	}
+	if (notes) content += `\n${formatNotes(notes)}`;
+	return content;
+}
+/**
+* Generate individual markdown files structure
+*/
+function generateMarkdownFilesContent(files) {
+	const markdownFiles = [];
+	for (const file of files) {
+		const mdPath = `md/${file.url === "/" ? "index" : file.url.replace(LEADING_SLASH_RE, "").replace(TRAILING_SLASH_RE, "")}.md`;
+		markdownFiles.push({
+			path: mdPath,
+			content: file.content
+		});
+	}
+	return markdownFiles;
+}
+/**
+* Main function to generate llms.txt artifacts from pre-processed files
+*/
+async function generateLlmsTxtArtifacts(options) {
+	const files = options.files;
+	const llmsTxt = generateLlmsTxtContent(files, options);
+	let llmsFullTxt;
+	if (options.generateFull) llmsFullTxt = generateLlmsFullTxtContent(files, options);
+	let markdownFiles;
+	if (options.generateMarkdown) markdownFiles = generateMarkdownFilesContent(files);
+	return {
+		llmsTxt,
+		llmsFullTxt,
+		markdownFiles,
+		processedFiles: files
+	};
+}
+/**
+* Format a section with title, description, and links
+*/
+function formatSection(section) {
+	let content = `## ${section.title}\n\n`;
+	if (section.description) {
+		const descriptions = Array.isArray(section.description) ? section.description : [section.description];
+		for (const desc of descriptions) content += `${desc}\n\n`;
+	}
+	if (section.links?.length) {
+		for (const link of section.links) {
+			const desc = link.description ? `: ${link.description}` : "";
+			content += `- [${link.title}](${link.href})${desc}\n`;
+		}
+		content += "\n";
+	}
+	return content;
+}
+/**
+* Format notes section
+*/
+function formatNotes(notes) {
+	const noteLines = Array.isArray(notes) ? notes : [notes];
+	let content = "";
+	for (const note of noteLines) content += `${note}\n\n`;
+	return content;
+}
+/**
+* Get group prefix for a URL (up to 2 segments)
+*/
+function getGroupPrefix(url, depth) {
+	const segments = url.split("/").filter(Boolean);
+	if (segments.length === 0) return "/";
+	if (depth === 1 || segments.length === 1) return `/${segments[0]}`;
+	return `/${segments[0]}/${segments[1]}`;
+}
+/**
+* Sort pages by URL path in hierarchical order (directory tree structure)
+* Groups by up to 2 segments, with root-level pages without nesting grouped together
+*/
+function sortPagesByPath(pages) {
+	const twoSegmentCount = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const prefix = getGroupPrefix(page.url, 2);
+		twoSegmentCount.set(prefix, (twoSegmentCount.get(prefix) || 0) + 1);
+	}
+	const segmentHasNested = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const segments = page.url.split("/").filter(Boolean);
+		const firstSegment = segments.length > 0 ? segments[0] : "";
+		if (!segmentHasNested.has(firstSegment)) segmentHasNested.set(firstSegment, false);
+		if (segments.length > 1) segmentHasNested.set(firstSegment, true);
+	}
+	return pages.sort((a, b) => {
+		const segmentsA = a.url.split("/").filter(Boolean);
+		const segmentsB = b.url.split("/").filter(Boolean);
+		const firstSegmentA = segmentsA.length > 0 ? segmentsA[0] : "";
+		const firstSegmentB = segmentsB.length > 0 ? segmentsB[0] : "";
+		const twoSegPrefixA = getGroupPrefix(a.url, 2);
+		const twoSegPrefixB = getGroupPrefix(b.url, 2);
+		const twoSegCountA = twoSegmentCount.get(twoSegPrefixA) || 0;
+		const twoSegCountB = twoSegmentCount.get(twoSegPrefixB) || 0;
+		let groupKeyA = twoSegCountA > 1 ? twoSegPrefixA : `/${firstSegmentA}`;
+		let groupKeyB = twoSegCountB > 1 ? twoSegPrefixB : `/${firstSegmentB}`;
+		const isRootLevelA = segmentsA.length <= 1;
+		const isRootLevelB = segmentsB.length <= 1;
+		const hasNestedA = segmentHasNested.get(firstSegmentA);
+		const hasNestedB = segmentHasNested.get(firstSegmentB);
+		if (isRootLevelA && !hasNestedA) groupKeyA = "";
+		if (isRootLevelB && !hasNestedB) groupKeyB = "";
+		if (groupKeyA === "" && groupKeyB !== "") return -1;
+		if (groupKeyA !== "" && groupKeyB === "") return 1;
+		if (groupKeyA !== groupKeyB) return groupKeyA.localeCompare(groupKeyB);
+		if (segmentsA.length === 0) return -1;
+		if (segmentsB.length === 0) return 1;
+		const minLen = Math.min(segmentsA.length, segmentsB.length);
+		for (let i = 0; i < minLen; i++) {
+			const cmp = segmentsA[i].localeCompare(segmentsB[i]);
+			if (cmp !== 0) return cmp;
+		}
+		return segmentsA.length - segmentsB.length;
+	});
+}
+/**
+* Create a WritableStream that generates llms.txt artifacts by streaming pages to disk.
+*
+* Writes llms.txt (and optionally llms-full.txt) incrementally as pages are written,
+* never keeping full content in memory. Creates outputDir recursively if needed.
+*/
+function createLlmsTxtStream(options) {
+	const { siteName = "Site", description, origin = "", generateFull, outputDir = process.cwd(), sections, notes } = options;
+	let llmsTxtHandle;
+	let llmsFullTxtHandle;
+	const bufferedPages = [];
+	return new WritableStream({
+		async start() {
+			await mkdir(outputDir, { recursive: true });
+			llmsTxtHandle = await open(join(outputDir, "llms.txt"), "w");
+			let header = `# ${siteName}\n\n`;
+			if (description) header += `> ${description}\n\n`;
+			if (origin) header += `Canonical Origin: ${origin}\n\n`;
+			if (sections) for (const section of sections) header += formatSection(section);
+			await llmsTxtHandle.write(header);
+			if (generateFull) {
+				llmsFullTxtHandle = await open(join(outputDir, "llms-full.txt"), "w");
+				let fullHeader = `# ${siteName}\n\n`;
+				if (description) fullHeader += `> ${description}\n\n`;
+				if (origin) fullHeader += `Canonical Origin: ${origin}\n\n`;
+				if (sections) for (const section of sections) fullHeader += formatSection(section);
+				await llmsFullTxtHandle.write(fullHeader);
+			}
+		},
+		async write(file) {
+			const desc = file.metadata?.description;
+			bufferedPages.push({
+				url: file.url,
+				title: file.title,
+				description: desc,
+				filePath: file.filePath
+			});
+			if (generateFull && llmsFullTxtHandle) {
+				const url = file.url.startsWith("http://") || file.url.startsWith("https://") ? file.url : origin ? origin + file.url : file.url;
+				const { frontmatter, body } = parseFrontmatter(file.content);
+				const metadata = {
+					title: file.title,
+					url
+				};
+				if (file.filePath) metadata.file = relative(outputDir, file.filePath);
+				if (file.metadata) {
+					if (file.metadata.description) metadata.description = file.metadata.description;
+					if (file.metadata.keywords) metadata.keywords = file.metadata.keywords;
+					if (file.metadata.author) metadata.author = file.metadata.author;
+				}
+				const frontmatterString = serializeFrontmatter(frontmatter ? {
+					...frontmatter,
+					...metadata
+				} : metadata);
+				let contentBody = frontmatter ? body : file.content;
+				const titleLine = contentBody.trim().split("\n")[0];
+				if (titleLine === file.title || titleLine === `# ${file.title}`) contentBody = contentBody.trim().split("\n").slice(1).join("\n").trimStart();
+				const fullChunk = `---\n${frontmatterString}\n---\n\n${contentBody}\n\n---\n\n`;
+				await llmsFullTxtHandle.write(fullChunk);
+			}
+		},
+		async close() {
+			const sortedPages = sortPagesByPath(bufferedPages);
+			const twoSegmentCount = /* @__PURE__ */ new Map();
+			for (const page of sortedPages) {
+				const prefix = getGroupPrefix(page.url, 2);
+				twoSegmentCount.set(prefix, (twoSegmentCount.get(prefix) || 0) + 1);
+			}
+			const segmentHasNested = /* @__PURE__ */ new Map();
+			for (const page of sortedPages) {
+				const segments = page.url.split("/").filter(Boolean);
+				const firstSegment = segments.length > 0 ? segments[0] : "";
+				if (!segmentHasNested.has(firstSegment)) segmentHasNested.set(firstSegment, false);
+				if (segments.length > 1) segmentHasNested.set(firstSegment, true);
+			}
+			await llmsTxtHandle?.write(`## Pages\n\n`);
+			let currentGroup = "";
+			let segmentGroupIndex = 0;
+			let urlsInCurrentGroup = 0;
+			for (let i = 0; i < sortedPages.length; i++) {
+				const page = sortedPages[i];
+				const segments = page.url.split("/").filter(Boolean);
+				const firstSegment = segments.length > 0 ? segments[0] : "";
+				const twoSegPrefix = getGroupPrefix(page.url, 2);
+				let groupKey = (twoSegmentCount.get(twoSegPrefix) || 0) > 1 ? twoSegPrefix : `/${firstSegment}`;
+				const isRootLevel = segments.length <= 1;
+				const hasNested = segmentHasNested.get(firstSegment);
+				if (isRootLevel && !hasNested) groupKey = "";
+				if (groupKey !== currentGroup) {
+					if (urlsInCurrentGroup > 0) {
+						if (segmentGroupIndex === 0 || segmentGroupIndex >= 1 && segmentGroupIndex <= 2 && urlsInCurrentGroup > 1) await llmsTxtHandle?.write("\n");
+					}
+					currentGroup = groupKey;
+					segmentGroupIndex++;
+					urlsInCurrentGroup = 0;
+				}
+				urlsInCurrentGroup++;
+				const descText = page.description ? `: ${page.description.substring(0, 160)}${page.description.length > 160 ? "..." : ""}` : "";
+				let chunk = "";
+				if (page.filePath && page.filePath.endsWith(".md")) {
+					const relativePath = relative(outputDir, page.filePath);
+					chunk = `- [${page.title}](${relativePath})${descText}\n`;
+				} else {
+					const url = page.url.startsWith("http://") || page.url.startsWith("https://") ? page.url : origin ? origin + page.url : page.url;
+					chunk = `- [${page.title}](${url})${descText}\n`;
+				}
+				await llmsTxtHandle?.write(chunk);
+			}
+			if (notes) {
+				const notesContent = formatNotes(notes);
+				await llmsTxtHandle?.write(`\n${notesContent}`);
+				if (generateFull && llmsFullTxtHandle) await llmsFullTxtHandle.write(`\n${notesContent}`);
+			}
+			await llmsTxtHandle?.close();
+			await llmsFullTxtHandle?.close();
+		},
+		async abort(_reason) {
+			await llmsTxtHandle?.close();
+			await llmsFullTxtHandle?.close();
+		}
+	});
+}
+//#endregion
+export { createLlmsTxtStream, generateLlmsTxtArtifacts };

package/dist/negotiate.d.mts

@@ -0,0 +1,26 @@
+//#region src/negotiate.d.ts
+interface AcceptEntry {
+  type: string;
+  q: number;
+  position: number;
+}
+/**
+ * Parse an HTTP Accept header into an ordered list of media types with quality values.
+ * Supports quality weights (q=0.9) and preserves original position for tie-breaking.
+ */
+declare function parseAcceptHeader(accept: string): AcceptEntry[];
+/**
+ * Determine if a client prefers markdown over HTML using proper content negotiation.
+ *
+ * Uses Accept header quality weights and position ordering:
+ * - If text/markdown or text/plain has higher quality than text/html -> markdown
+ * - If same quality, earlier position in Accept header wins
+ * - Bare wildcard does NOT trigger markdown (prevents breaking OG crawlers)
+ * - sec-fetch-dest: document always returns false (browser navigation)
+ *
+ * @param acceptHeader - The HTTP Accept header value
+ * @param secFetchDest - The Sec-Fetch-Dest header value
+ */
+declare function shouldServeMarkdown(acceptHeader?: string, secFetchDest?: string): boolean;
+//#endregion
+export { parseAcceptHeader, shouldServeMarkdown };

package/dist/negotiate.mjs

@@ -0,0 +1,92 @@
+//#region src/negotiate.ts
+/**
+* Parse an HTTP Accept header into an ordered list of media types with quality values.
+* Supports quality weights (q=0.9) and preserves original position for tie-breaking.
+*/
+function parseAcceptHeader(accept) {
+	if (!accept) return [];
+	const entries = [];
+	const parts = accept.split(",");
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (!part) continue;
+		const semicolonIdx = part.indexOf(";");
+		let type;
+		let q = 1;
+		if (semicolonIdx === -1) type = part;
+		else {
+			type = part.slice(0, semicolonIdx).trim();
+			const paramStr = part.slice(semicolonIdx + 1);
+			const qIdx = paramStr.indexOf("q=");
+			if (qIdx !== -1) {
+				const qStart = qIdx + 2;
+				let qEnd = qStart;
+				while (qEnd < paramStr.length && paramStr.charCodeAt(qEnd) !== 59 && paramStr.charCodeAt(qEnd) !== 32) qEnd++;
+				q = +paramStr.slice(qStart, qEnd) || 0;
+			}
+		}
+		entries.push({
+			type,
+			q,
+			position: i
+		});
+	}
+	return entries;
+}
+/**
+* Determine if a client prefers markdown over HTML using proper content negotiation.
+*
+* Uses Accept header quality weights and position ordering:
+* - If text/markdown or text/plain has higher quality than text/html -> markdown
+* - If same quality, earlier position in Accept header wins
+* - Bare wildcard does NOT trigger markdown (prevents breaking OG crawlers)
+* - sec-fetch-dest: document always returns false (browser navigation)
+*
+* @param acceptHeader - The HTTP Accept header value
+* @param secFetchDest - The Sec-Fetch-Dest header value
+*/
+function shouldServeMarkdown(acceptHeader, secFetchDest) {
+	if (secFetchDest === "document") return false;
+	const accept = acceptHeader || "";
+	if (!accept) return false;
+	const parts = accept.split(",");
+	let bestMdQ = -1;
+	let bestMdPos = -1;
+	let htmlQ = -1;
+	let htmlPos = -1;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (!part) continue;
+		const semicolonIdx = part.indexOf(";");
+		let type;
+		let q = 1;
+		if (semicolonIdx === -1) type = part;
+		else {
+			type = part.slice(0, semicolonIdx).trim();
+			const paramStr = part.slice(semicolonIdx + 1);
+			const qIdx = paramStr.indexOf("q=");
+			if (qIdx !== -1) {
+				const qStart = qIdx + 2;
+				let qEnd = qStart;
+				while (qEnd < paramStr.length && paramStr.charCodeAt(qEnd) !== 59 && paramStr.charCodeAt(qEnd) !== 32) qEnd++;
+				q = +paramStr.slice(qStart, qEnd) || 0;
+			}
+		}
+		if (type === "text/markdown" || type === "text/plain") {
+			if (q > bestMdQ || q === bestMdQ && (bestMdPos === -1 || i < bestMdPos)) {
+				bestMdQ = q;
+				bestMdPos = i;
+			}
+		} else if (type === "text/html") {
+			htmlQ = q;
+			htmlPos = i;
+		}
+	}
+	if (bestMdPos === -1) return false;
+	if (htmlPos === -1) return true;
+	if (bestMdQ > htmlQ) return true;
+	if (bestMdQ === htmlQ && bestMdPos < htmlPos) return true;
+	return false;
+}
+//#endregion
+export { parseAcceptHeader, shouldServeMarkdown };

package/dist/parse.d.mts

@@ -0,0 +1,57 @@
+import { _ as TransformPlugin, d as NodeEvent, m as TagHandler, r as ElementNode, u as Node } from "./_chunks/types.mjs";
+
+//#region src/parse.d.ts
+interface ParseOptions {
+  resolvedPlugins?: TransformPlugin[];
+}
+interface ParseState {
+  /** Map of tag names to their current nesting depth - uses TypedArray for performance */
+  depthMap: Uint8Array;
+  /** Current overall nesting depth */
+  depth: number;
+  /** Currently processing element node */
+  currentNode?: ElementNode | null;
+  /** Whether current content contains HTML entities that need decoding */
+  hasEncodedHtmlEntity?: boolean;
+  /** Whether the last processed character was whitespace - for collapsing whitespace */
+  lastCharWasWhitespace?: boolean;
+  /** Whether the last processed buffer has whitespace - optimization flag */
+  textBufferContainsWhitespace?: boolean;
+  /** Whether the last processed buffer contains non-whitespace characters */
+  textBufferContainsNonWhitespace?: boolean;
+  /** Whether a tag was just closed - affects whitespace handling */
+  justClosedTag?: boolean;
+  /** Whether the next text node is the first in its element - for whitespace trimming */
+  isFirstTextInElement?: boolean;
+  /** Reference to the last processed text node - for context tracking */
+  lastTextNode?: Node;
+  /** Quote state tracking for non-nesting tags - avoids backward scanning */
+  inSingleQuote?: boolean;
+  inDoubleQuote?: boolean;
+  inBacktick?: boolean;
+  /** Backslash escaping state tracking - avoids checking previous character */
+  lastCharWasBackslash?: boolean;
+  /** Resolved plugin instances for event processing */
+  resolvedPlugins?: TransformPlugin[];
+  /** Tag override handlers built from declarative tagOverrides config */
+  tagOverrideHandlers?: Map<string, TagHandler>;
+}
+interface ParseResult {
+  events: NodeEvent[];
+  remainingHtml: string;
+}
+/**
+ * Pure HTML parser that emits DOM events
+ * Completely decoupled from markdown generation
+ */
+declare function parseHtml(html: string, options?: ParseOptions): ParseResult;
+/**
+ * Streaming HTML parser - calls onEvent for each DOM event
+ */
+declare function parseHtmlStream(html: string, state: ParseState, onEvent: (event: NodeEvent) => void): string;
+/**
+ * Parse HTML attributes string into key-value object
+ */
+declare function parseAttributes(attrStr: string): Record<string, string>;
+//#endregion
+export { ParseOptions, ParseResult, ParseState, parseAttributes, parseHtml, parseHtmlStream };

package/dist/parse.mjs

@@ -0,0 +1,3 @@
+import "./_chunks/const.mjs";
+import { n as parseHtml, r as parseHtmlStream, t as parseAttributes } from "./_chunks/parse.mjs";
+export { parseAttributes, parseHtml, parseHtmlStream };

package/dist/plugins.d.mts

@@ -0,0 +1,93 @@
+import { _ as TransformPlugin, a as ExtractedElement$1, l as MdreamRuntimeState, r as ElementNode } from "./_chunks/types.mjs";
+import { r as createPlugin } from "./_chunks/index.mjs";
+//#region src/plugins/extraction.d.ts
+interface ExtractedElement extends ElementNode {
+  textContent: string;
+}
+/**
+ * @deprecated Use `plugins.extraction` config for declarative extraction that works with both JS and Rust engines.
+ */
+declare function extractionPlugin(selectors: Record<string, (element: ExtractedElement, state: MdreamRuntimeState) => void>): TransformPlugin;
+/**
+ * Extraction collector for `plugins.extraction` config.
+ * Collects results during processing; callbacks are called post-conversion
+ * to match Rust engine behavior.
+ */
+declare function extractionCollectorPlugin(config: Record<string, (element: ExtractedElement$1) => void>): {
+  plugin: TransformPlugin;
+  getResults: () => ExtractedElement$1[];
+  callHandlers: () => void;
+};
+//#endregion
+//#region src/plugins/filter.d.ts
+/**
+ * Plugin that filters nodes based on CSS selectors.
+ * Allows including or excluding nodes based on selectors.
+ *
+ * @example
+ * // Include only heading elements and their children
+ * withQuerySelectorPlugin({ include: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] })
+ *
+ * @example
+ * // Exclude navigation, sidebar, and footer
+ * withQuerySelectorPlugin({ exclude: ['nav', '#sidebar', '.footer'] })
+ */
+declare function filterPlugin(options?: {
+  /** CSS selectors, tag names, or TAG_* constants for elements to include (all others will be excluded) */include?: (string | number)[]; /** CSS selectors, tag names, or TAG_* constants for elements to exclude */
+  exclude?: (string | number)[]; /** Whether to also process the children of matching elements */
+  processChildren?: boolean;
+  keepAbsolute?: boolean;
+}): TransformPlugin;
+//#endregion
+//#region src/plugins/frontmatter.d.ts
+interface FrontmatterPluginOptions {
+  /** Additional frontmatter fields to include */
+  additionalFields?: Record<string, string>;
+  /** Meta tag names to extract (beyond the standard ones) */
+  metaFields?: string[];
+}
+/**
+ * A plugin that manages frontmatter generation from HTML head elements
+ * Extracts metadata from meta tags and title and generates YAML frontmatter
+ */
+declare function frontmatterPlugin(options?: FrontmatterPluginOptions): TransformPlugin;
+//#endregion
+//#region src/plugins/isolate-main.d.ts
+/**
+ * Plugin that isolates main content using the following priority order:
+ * 1. If an explicit <main> element exists (within 5 depth levels), use its content exclusively
+ * 2. Otherwise, find content between the first header tag (h1-h6) and first footer
+ * 3. If footer is within 5 levels of nesting from the header, use it as the end boundary
+ * 4. Exclude all content before the start marker and after the end marker
+ *
+ * @example
+ * ```html
+ * <body>
+ *   <nav>Navigation (excluded)</nav>
+ *   <main>
+ *     <h1>Main Title (included)</h1>
+ *     <p>Main content (included)</p>
+ *   </main>
+ *   <footer>Footer (excluded)</footer>
+ * </body>
+ * ```
+ *
+ * @example
+ * ```html
+ * <body>
+ *   <nav>Navigation (excluded)</nav>
+ *   <h1>Main Title (included)</h1>
+ *   <p>Main content (included)</p>
+ *   <footer>Footer (excluded)</footer>
+ * </body>
+ * ```
+ */
+declare function isolateMainPlugin(): TransformPlugin;
+//#endregion
+//#region src/plugins/tailwind.d.ts
+/**
+ * Creates a plugin that adds Tailwind class processing
+ */
+declare function tailwindPlugin(): TransformPlugin;
+//#endregion
+export { type ExtractedElement, createPlugin, extractionCollectorPlugin, extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, tailwindPlugin };

package/dist/plugins.mjs

@@ -0,0 +1,3 @@
+import "./_chunks/const.mjs";
+import { a as extractionCollectorPlugin, i as filterPlugin, n as isolateMainPlugin, o as extractionPlugin, r as frontmatterPlugin, s as createPlugin, t as tailwindPlugin } from "./_chunks/plugins.mjs";
+export { createPlugin, extractionCollectorPlugin, extractionPlugin, filterPlugin, frontmatterPlugin, isolateMainPlugin, tailwindPlugin };

package/dist/preset/minimal.d.mts

@@ -0,0 +1,2 @@
+import { t as withMinimalPreset } from "../_chunks/minimal.mjs";
+export { withMinimalPreset };

package/dist/preset/minimal.mjs

@@ -0,0 +1,34 @@
+import "../_chunks/const.mjs";
+//#region src/preset/minimal.ts
+/**
+* Creates a configurable minimal preset with advanced options.
+* Returns declarative plugin config that works with both JS and Rust engines.
+*/
+function withMinimalPreset(options = {}) {
+	return {
+		clean: options.clean !== void 0 ? options.clean : true,
+		...options,
+		plugins: {
+			frontmatter: true,
+			isolateMain: true,
+			tailwind: true,
+			filter: { exclude: [
+				40,
+				68,
+				103,
+				58,
+				47,
+				88,
+				73,
+				59,
+				66,
+				65,
+				43,
+				41
+			] },
+			...options.plugins
+		}
+	};
+}
+//#endregion
+export { withMinimalPreset };

package/dist/splitter.d.mts

@@ -0,0 +1,21 @@
+import { p as SplitterOptions, s as MarkdownChunk } from "./_chunks/types.mjs";
+
+//#region src/splitter.d.ts
+/**
+ * Convert HTML to Markdown and split into chunks in single pass.
+ * Yields chunks during HTML event processing for better memory efficiency.
+ *
+ * **JavaScript engine only** — uses the JS engine's internal processing pipeline.
+ * Not compatible with the Rust engine.
+ */
+declare function htmlToMarkdownSplitChunksStream(html: string, options?: SplitterOptions): Generator<MarkdownChunk, void, undefined>;
+/**
+ * Convert HTML to Markdown and split into chunks in single pass.
+ * Chunks are created during HTML event processing.
+ *
+ * **JavaScript engine only** — uses the JS engine's internal processing pipeline.
+ * Not compatible with the Rust engine.
+ */
+declare function htmlToMarkdownSplitChunks(html: string, options?: SplitterOptions): MarkdownChunk[];
+//#endregion
+export { type MarkdownChunk, type SplitterOptions, htmlToMarkdownSplitChunks, htmlToMarkdownSplitChunksStream };