nuxt-ai-ready 2.5.0 → 2.5.2

package/node_modules/@mdream/js/dist/index.mjs

@@ -0,0 +1,58 @@
+import { ELEMENT_NODE, NodeEventEnter, NodeEventExit, TAG_H1, TAG_H2, TAG_H3, TAG_H4, TAG_H5, TAG_H6, TEXT_NODE } from "./_chunks/const.mjs";
+import { buildTagOverrideHandlers } from "./_chunks/parse.mjs";
+import { applyClean, createMarkdownProcessor, resolveClean } from "./_chunks/markdown-processor.mjs";
+import { createPlugin } from "./_chunks/plugins.mjs";
+import { resolvePlugins } from "./_chunks/resolve-plugins.mjs";
+import { streamHtmlToMarkdown as streamHtmlToMarkdown$1 } from "./_chunks/stream.mjs";
+import { withMinimalPreset } from "./preset/minimal.mjs";
+const TOP_LEVEL_PLUGIN_KEYS = [
+	"frontmatter",
+	"isolateMain",
+	"tailwind",
+	"filter",
+	"extraction",
+	"tagOverrides"
+];
+function assertEngineOptions(options) {
+	if ("minimal" in options) throw new TypeError("@mdream/js has no `minimal` option. Use withMinimalPreset() from '@mdream/js/preset/minimal': htmlToMarkdown(html, withMinimalPreset({ origin })).");
+	for (const key of TOP_LEVEL_PLUGIN_KEYS) if (key in options) throw new TypeError(`@mdream/js reads \`${key}\` from \`plugins\`. Pass { plugins: { ${key} } } instead of { ${key} }.`);
+}
+function resolveHooks(options) {
+	return options.hooks?.length ? options.hooks : void 0;
+}
+function convert(html, options, hooks) {
+	const { plugins, callExtractionHandlers, getFrontmatter, frontmatterCallback } = resolvePlugins(options, hooks);
+	const tagOverrideHandlers = options.plugins?.tagOverrides ? buildTagOverrideHandlers(options.plugins.tagOverrides) : void 0;
+	const processor = createMarkdownProcessor(options, plugins, tagOverrideHandlers);
+	processor.processHtml(html);
+	if (getFrontmatter && frontmatterCallback) {
+		const fm = getFrontmatter();
+		if (fm) frontmatterCallback(fm);
+	}
+	callExtractionHandlers?.();
+	return processor.getMarkdown();
+}
+function htmlToMarkdown(html, options = {}) {
+	assertEngineOptions(options);
+	const markdown = convert(html, options, resolveHooks(options));
+	if (options.clean && (options.format === void 0 || options.format === "markdown")) return applyClean(markdown, resolveClean(options.clean));
+	return markdown;
+}
+function streamHtmlToMarkdown(htmlStream, options = {}) {
+	assertEngineOptions(options);
+	const hooks = resolveHooks(options);
+	const { plugins, callExtractionHandlers, getFrontmatter, frontmatterCallback } = resolvePlugins(options, hooks);
+	const tagOverrideHandlers = options.plugins?.tagOverrides ? buildTagOverrideHandlers(options.plugins.tagOverrides) : void 0;
+	const stream = streamHtmlToMarkdown$1(htmlStream, options, plugins, tagOverrideHandlers);
+	if (!callExtractionHandlers && !frontmatterCallback) return stream;
+	return withCallbacks(stream, () => {
+		const fm = getFrontmatter?.();
+		if (fm && frontmatterCallback) frontmatterCallback(fm);
+		callExtractionHandlers?.();
+	});
+}
+async function* withCallbacks(stream, onEnd) {
+	yield* stream;
+	onEnd();
+}
+export { ELEMENT_NODE, NodeEventEnter, NodeEventExit, TAG_H1, TAG_H2, TAG_H3, TAG_H4, TAG_H5, TAG_H6, TEXT_NODE, createPlugin, htmlToMarkdown, streamHtmlToMarkdown, withMinimalPreset };

package/node_modules/@mdream/js/dist/llms-txt.d.mts

@@ -0,0 +1,86 @@
+/**
+ * Link in llms.txt section
+ */
+export interface LlmsTxtLink {
+  /** The title of the link */
+  title: string;
+  /** The description of the link */
+  description?: string;
+  /** The href of the link */
+  href: string;
+}
+/**
+ * Section in llms.txt
+ */
+export interface LlmsTxtSection {
+  /** The title of the section */
+  title: string;
+  /** The description of the section (can be array for multiple paragraphs) */
+  description?: string | string[];
+  /** The links of the section */
+  links?: LlmsTxtLink[];
+}
+export interface LlmsTxtArtifactsOptions {
+  files: ProcessedFile[];
+  siteName?: string;
+  description?: string;
+  origin?: string;
+  generateFull?: boolean;
+  generateMarkdown?: boolean;
+  outputDir?: string;
+  /** The sections to write before pages */
+  sections?: LlmsTxtSection[];
+  /** Notes to write at the end */
+  notes?: string | string[];
+}
+export interface ProcessedFile {
+  filePath?: string;
+  title: string;
+  content: string;
+  url: string;
+  metadata?: {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    author?: string;
+  };
+}
+export interface LlmsTxtArtifactsResult {
+  llmsTxt: string;
+  llmsFullTxt?: string;
+  markdownFiles?: {
+    path: string;
+    content: string;
+  }[];
+  processedFiles: ProcessedFile[];
+}
+/**
+ * Main function to generate llms.txt artifacts from pre-processed files
+ */
+export declare function generateLlmsTxtArtifacts(options: LlmsTxtArtifactsOptions): Promise<LlmsTxtArtifactsResult>;
+/**
+ * Options for creating an llms.txt stream
+ */
+export interface CreateLlmsTxtStreamOptions extends Omit<LlmsTxtArtifactsOptions, 'files' | 'generateMarkdown'> {
+  /** Directory to write files to (defaults to process.cwd()) */
+  outputDir?: string;
+  /** Site name for the header (defaults to 'Site') */
+  siteName?: string;
+  /** Site description for the header */
+  description?: string;
+  /** Origin URL to prepend to relative URLs */
+  origin?: string;
+  /** Generate llms-full.txt with complete page content (defaults to false) */
+  generateFull?: boolean;
+  /** The sections to write before pages */
+  sections?: LlmsTxtSection[];
+  /** Notes to write at the end */
+  notes?: string | string[];
+}
+/**
+ * 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.
+ */
+export declare function createLlmsTxtStream(options: CreateLlmsTxtStreamOptions): WritableStream<ProcessedFile>;

package/node_modules/@mdream/js/dist/llms-txt.mjs

@@ -0,0 +1,308 @@
+import { join, relative } from "pathe";
+import { mkdir, open } from "node:fs/promises";
+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 = /\/$/;
+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;
+}
+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
+	};
+}
+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");
+}
+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;
+}
+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;
+}
+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
+	};
+}
+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;
+}
+function formatNotes(notes) {
+	const noteLines = Array.isArray(notes) ? notes : [notes];
+	let content = "";
+	for (const note of noteLines) content += `${note}\n\n`;
+	return content;
+}
+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]}`;
+}
+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;
+	});
+}
+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();
+		}
+	});
+}
+export { createLlmsTxtStream, generateLlmsTxtArtifacts };

package/node_modules/@mdream/js/dist/negotiate.d.mts

@@ -0,0 +1,35 @@
+export type ContentNegotiationResult = 'markdown' | 'html' | 'not-acceptable';
+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.
+ */
+export declare function parseAcceptHeader(accept: string): AcceptEntry[];
+/**
+ * Perform RFC 7231 content negotiation for HTML vs Markdown.
+ *
+ * Resolution rules:
+ * - `Sec-Fetch-Dest: document` always returns `'html'` (browser navigation).
+ * - Missing or empty Accept header returns `'html'` (server picks default).
+ * - q=0 entries are treated as explicit rejections and ignored for matching
+ *   (but still count towards "something was listed").
+ * - `text/markdown` and `text/plain` are the markdown-capable types.
+ * - `text/html` and `application/xhtml+xml` are the html-capable types.
+ * - `*_/_*` and `text/*` are wildcards; they satisfy 406 but never on their
+ *   own tip negotiation towards markdown (preserves OG crawler behavior).
+ * - If nothing in the Accept header can be served (no explicit match, no
+ *   wildcard), returns `'not-acceptable'` so the caller can send 406.
+ * - Otherwise, compares best markdown entry vs best html-or-wildcard entry
+ *   by q, then by position.
+ */
+export declare function negotiateContent(acceptHeader?: string, secFetchDest?: string): ContentNegotiationResult;
+/**
+ * Determine if a client prefers markdown over HTML. Convenience wrapper over
+ * {@link negotiateContent}; treats `'not-acceptable'` the same as `'html'`
+ * (callers that want 406 semantics should use `negotiateContent` directly).
+ */
+export declare function shouldServeMarkdown(acceptHeader?: string, secFetchDest?: string): boolean;

package/node_modules/@mdream/js/dist/negotiate.mjs

@@ -0,0 +1,121 @@
+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;
+}
+function negotiateContent(acceptHeader, secFetchDest) {
+	if (secFetchDest === "document") return "html";
+	const accept = acceptHeader || "";
+	if (!accept) return "html";
+	let bestMdQ = -1;
+	let bestMdPos = -1;
+	let bestHtmlQ = -1;
+	let bestHtmlPos = -1;
+	let bestWildcardQ = -1;
+	let bestWildcardPos = -1;
+	let sawAnyEntry = false;
+	let sawAcceptable = false;
+	let rejectedMd = false;
+	let rejectedHtml = false;
+	const parts = accept.split(",");
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i].trim();
+		if (!part) continue;
+		sawAnyEntry = true;
+		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);
+			let qIdx = -1;
+			for (let j = 0; j < paramStr.length - 1; j++) {
+				const c = paramStr.charCodeAt(j);
+				if ((c === 113 || c === 81) && paramStr.charCodeAt(j + 1) === 61) {
+					qIdx = j;
+					break;
+				}
+			}
+			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;
+			}
+		}
+		const normalized = type.toLowerCase();
+		if (normalized === "text/markdown" || normalized === "text/plain") {
+			if (q === 0) {
+				rejectedMd = true;
+				continue;
+			}
+			sawAcceptable = true;
+			if (q > bestMdQ || q === bestMdQ && bestMdPos === -1) {
+				bestMdQ = q;
+				bestMdPos = i;
+			}
+		} else if (normalized === "text/html" || normalized === "application/xhtml+xml") {
+			if (q === 0) {
+				rejectedHtml = true;
+				continue;
+			}
+			sawAcceptable = true;
+			if (q > bestHtmlQ || q === bestHtmlQ && bestHtmlPos === -1) {
+				bestHtmlQ = q;
+				bestHtmlPos = i;
+			}
+		} else if (normalized === "*/*" || normalized === "text/*") {
+			if (q === 0) continue;
+			sawAcceptable = true;
+			if (q > bestWildcardQ || q === bestWildcardQ && bestWildcardPos === -1) {
+				bestWildcardQ = q;
+				bestWildcardPos = i;
+			}
+		}
+	}
+	if (sawAnyEntry && !sawAcceptable) return "not-acceptable";
+	if (bestMdPos === -1 && !rejectedMd && bestWildcardPos !== -1) {
+		bestMdQ = bestWildcardQ;
+		bestMdPos = bestWildcardPos;
+	}
+	if (bestHtmlPos === -1 && !rejectedHtml && bestWildcardPos !== -1) {
+		bestHtmlQ = bestWildcardQ;
+		bestHtmlPos = bestWildcardPos;
+	}
+	if (bestMdPos === -1 && bestHtmlPos === -1) return "not-acceptable";
+	if (bestMdPos === -1) return "html";
+	if (bestHtmlPos === -1) return "markdown";
+	if (bestMdQ > bestHtmlQ) return "markdown";
+	if (bestMdQ === bestHtmlQ && bestMdPos < bestHtmlPos) return "markdown";
+	return "html";
+}
+function shouldServeMarkdown(acceptHeader, secFetchDest) {
+	return negotiateContent(acceptHeader, secFetchDest) === "markdown";
+}
+export { negotiateContent, parseAcceptHeader, shouldServeMarkdown };