+
+ Content after HTML.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("Content after HTML"));
+ assert.ok(!result.includes("
"));
+ assert.ok(!result.includes("
Text
"));
+ });
+
+ test("removes HTML with empty elements", (t) => {
+ let input = dedent`
+
+
+
Content
+
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(!result.includes("
+ }
+
+ More content here.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("Breakpoint"));
+ assert.ok(result.includes("Width"));
+ assert.ok(result.includes("More content here"));
+ assert.ok(!result.includes("{"));
+ assert.ok(!result.includes("}"));
+ });
+
+ test("handles JSX expressions with code blocks inside", (t) => {
+ let input = dedent`
+ {
+
+ \`\`\`html
+
Code example
+ \`\`\`
+
+ }
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("```html") || result.includes("Code example"));
+ });
+ });
+
+ describe("real-world examples", () => {
+ test("handles responsive-design.mdx with JSX table expression", (t) => {
+ let input = dedent`
+ export const title = "Responsive design";
+ export const description = "Using responsive utility variants.";
+
+ ## Overview
+
+ There are five breakpoints:
+
+ {
+
+
+
+
Breakpoint prefix
+
Minimum width
+
+
+
+
+
sm
+
40rem (640px)
+
+
+
+ }
+
+ ### Customizing your theme
+
+ More content here.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("Responsive design"));
+ assert.ok(result.includes("Using responsive utility variants"));
+ assert.ok(result.includes("## Overview"));
+ assert.ok(result.includes("Breakpoint prefix"));
+ assert.ok(result.includes("Minimum width"));
+ assert.ok(result.includes("### Customizing your theme"));
+ assert.ok(result.includes("More content here"));
+ assert.ok(!result.includes("export const"));
+ assert.ok(!result.includes("{"));
+ assert.ok(!result.includes("}"));
+ });
+
+ test("handles display.mdx structure", (t) => {
+ let input = dedent`
+ import dedent from "dedent";
+ import { ApiTable } from "@/components/api-table.tsx";
+ import { Example } from "@/components/example.tsx";
+ import { Figure } from "@/components/figure.tsx";
+
+ export const title = "display";
+ export const description = "Utilities for controlling the display box type of an element.";
+
+
+
+ ## Examples
+
+ ### Block and Inline
+
+ Use the \`inline\`, \`inline-block\`, and \`block\` utilities:
+
+
+
+ {
Example content
}
+
+
+ \`\`\`html
+
+
Content
+ \`\`\`
+
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("display"));
+ assert.ok(result.includes("Utilities for controlling the display box type"));
+ assert.ok(result.includes("## Examples"));
+ assert.ok(result.includes("### Block and Inline"));
+ assert.ok(result.includes("Use the"));
+ assert.ok(result.includes("```html"));
+ assert.ok(result.includes('
Content
'));
+ assert.ok(!result.includes("import"));
+ assert.ok(!result.includes(""));
+ assert.ok(!result.includes("[!code"));
+ });
+ });
+
+ describe("handling media elements", () => {
+ test("removes img tags completely", (t) => {
+ let input = dedent`
+ ## Editor setup
+
+ Some content before.
+
+
+
+ More content here.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Editor setup"));
+ assert.ok(result.includes("Some content before"));
+ assert.ok(result.includes("More content here"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Icons
+
+ Here's an icon:
+
+
+
+ More content here.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Icons"));
+ assert.ok(result.includes("More content here"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Demo
+
+
+
+ Watch the demo above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Demo"));
+ assert.ok(result.includes("Watch the demo above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Embedded content
+
+
+
+ See the embedded content above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Embedded content"));
+ assert.ok(result.includes("See the embedded content above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Responsive images
+
+
+
+
+
+
+ Image shown above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Responsive images"));
+ assert.ok(result.includes("Image shown above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Gallery
+
+
+
+
+
+ Three photos above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Gallery"));
+ assert.ok(result.includes("Three photos above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ Before image after image.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("Before image"));
+ assert.ok(result.includes("after image"));
+ assert.ok(!result.includes(" {
+ test("removes img tags and preserves surrounding content", (t) => {
+ let input = dedent`
+ ## Editor Setup
+
+ Check out our editor:
+
+
+
+ It's great for development.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Editor Setup"));
+ assert.ok(result.includes("Check out our editor"));
+ assert.ok(result.includes("It's great for development"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Icons
+
+ Here's an icon:
+
+
+
+ Use it wisely.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Icons"));
+ assert.ok(result.includes("Here's an icon"));
+ assert.ok(result.includes("Use it wisely"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Demo
+
+
+
+ Watch the demo above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Demo"));
+ assert.ok(result.includes("Watch the demo above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Embedded Content
+
+
+
+ Check out the embed.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Embedded Content"));
+ assert.ok(result.includes("Check out the embed"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## Responsive Images
+
+
+
+
+
+
+ Beautiful image above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Responsive Images"));
+ assert.ok(result.includes("Beautiful image above"));
+ assert.ok(!result.includes(" {
+ let input = dedent`
+ ## HTML Example
+
+ \`\`\`html
+
+ \`\`\`
+
+ The code above shows an image tag.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## HTML Example"));
+ assert.ok(result.includes("```html"));
+ assert.ok(result.includes(''));
+ assert.ok(result.includes("The code above shows an image tag"));
+ });
+
+ test("removes multiple media elements in sequence", (t) => {
+ let input = dedent`
+ ## Gallery
+
+
+
+
+
+
+ All media above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Gallery"));
+ assert.ok(result.includes("All media above"));
+ assert.ok(!result.includes(" removeCodeDirectives(block));
+
+ // Remove JSX component tags and extract their content
+ processedContent = removeJSXComponents(processedContent);
+
+ // Remove code example directives from non-code content
+ processedContent = removeCodeDirectives(processedContent);
+
+ // Restore code blocks
+ processedContent = restoreCodeBlocks(processedContent, codeBlocks);
+
+ // Clean up extra whitespace
+ processedContent = cleanWhitespace(processedContent);
+
+ // Build result with title and description if available
+ let result = "";
+ if (title) {
+ result += `# ${title}\n\n`;
+ }
+ if (description) {
+ result += `${description}\n\n`;
+ }
+ if (title || description) {
+ result += "---\n\n";
+ }
+
+ result += processedContent;
+
+ return result.trim();
+}
+
+function extractExport(name: string, content: string): string | null {
+ // Match: export const title = "value"; or export const title = 'value';
+ let match = content.match(new RegExp(`export\\s+const\\s+${name}\\s*=\\s*["']([^"']+)["']`, "s"));
+ if (match) {
+ return match[1];
+ }
+
+ // Match: export const title = `value`;
+ match = content.match(new RegExp(`export\\s+const\\s+${name}\\s*=\\s*\`([^\`]+)\``, "s"));
+ if (match) {
+ return match[1];
+ }
+
+ return null;
+}
+
+function removeImports(content: string): string {
+ // Remove all import statements (single and multi-line)
+ content = content.replace(/^import\s+.*?from\s+["'][^"']+["'];?\s*$/gm, "");
+ // Remove export statements (but keep the content after them)
+ // Handle both single and double quotes, and template literals
+ content = content.replace(/^export\s+const\s+(title|description)\s*=\s*["']([^"']+)["'];?\s*$/gm, "");
+ content = content.replace(/^export\s+const\s+(title|description)\s*=\s*`([^`]+)`;?\s*$/gm, "");
+ // Also handle exports that might be on the same line as other content
+ content = content.replace(/export\s+const\s+(title|description)\s*=\s*["']([^"']+)["'];?/g, "");
+ content = content.replace(/export\s+const\s+(title|description)\s*=\s*`([^`]+)`;?/g, "");
+ return content;
+}
+
+function preserveCodeBlocks(content: string): { content: string; codeBlocks: string[] } {
+ // Extract code blocks temporarily to protect them from JSX removal
+ let codeBlocks: string[] = [];
+ let blockIndex = 0;
+
+ // Match code blocks with optional language
+ let processedContent = content.replace(/```(\w+)?\n([\s\S]*?)```/g, (match, lang, code) => {
+ let placeholder = `__CODE_BLOCK_${blockIndex}__`;
+ codeBlocks[blockIndex] = `\`\`\`${lang || ""}\n${code}\`\`\``;
+ blockIndex++;
+ return placeholder;
+ });
+
+ return { content: processedContent, codeBlocks };
+}
+
+function restoreCodeBlocks(content: string, codeBlocks: string[]): string {
+ for (let i = 0; i < codeBlocks.length; i++) {
+ content = content.replace(`__CODE_BLOCK_${i}__`, codeBlocks[i]);
+ }
+
+ return content;
+}
+
+function extractApiTableData(match: string): string {
+ let rowsMatch = match.match(/rows\s*=\s*\{\s*\[([\s\S]*?)\]\s*\}/);
+ if (rowsMatch) {
+ let rowsContent = rowsMatch[1];
+ let extracted = rowsContent
+ .replace(/\[([^\]]+)\]/g, "$1")
+ .replace(/["']([^"']+)["']/g, "$1")
+ .replace(/dedent\s*`([^`]+)`/g, "$1")
+ .replace(/dedent\\`([^`]+)\\`/g, "$1")
+ .replace(/,/g, " | ")
+ .replace(/\s+/g, " ")
+ .trim();
+ return extracted ? `\n${extracted}\n` : "";
+ }
+ return "";
+}
+
+function removeJSXComponents(content: string): string {
+ // Handle ApiTable components - extract table data
+ content = content.replace(//g, extractApiTableData);
+ content = content.replace(//g, extractApiTableData);
+
+ // Handle content components that have meaningful text - extract their props to generate text
+ // ResponsiveDesign, CustomizingYourTheme, TargetingSpecificStates, etc.
+ content = content.replace(/]*\/>/g, (match) => {
+ // Extract property and featuredClass to generate descriptive text
+ let propertyMatch = match.match(/property=["']([^"']+)["']/);
+ let featuredClassMatch = match.match(/featuredClass=["']([^"']+)["']/);
+ let breakpointMatch = match.match(/breakpoint=["']([^"']+)["']/);
+ let breakpoint = breakpointMatch ? breakpointMatch[1] : "md";
+ let property = propertyMatch ? propertyMatch[1] : "utility";
+ let featuredClass = featuredClassMatch ? featuredClassMatch[1] : "";
+
+ if (property && featuredClass) {
+ return `\n\nPrefix a ${property} utility with a breakpoint variant like ${breakpoint}: to only apply the utility at ${breakpoint} screen sizes and above. Use ${breakpoint}:${featuredClass} to apply ${featuredClass} at the ${breakpoint} breakpoint and above.\n\n`;
+ }
+ return "\n\nUse responsive variants to apply utilities at specific breakpoints.\n\n";
+ });
+
+ content = content.replace(/]*\/>/g, (match) => {
+ let utilityMatch = match.match(/utility=["']([^"']+)["']/);
+ let utility = utilityMatch ? utilityMatch[1] : "utility";
+ return `\n\nUse the --${utility}-* theme variables to customize the ${utility} utilities in your project.\n\n`;
+ });
+
+ content = content.replace(/]*\/>/g, (match) => {
+ let propertyMatch = match.match(/property=["']([^"']+)["']/);
+ let variantMatch = match.match(/variant=["']([^"']+)["']/);
+ let property = propertyMatch ? propertyMatch[1] : "utility";
+ let variant = variantMatch ? variantMatch[1] : "hover";
+ return `\n\nPrefix a ${property} utility with a variant like ${variant}: to only apply the utility in that state.\n\n`;
+ });
+
+ // Remove other component tags (Figure, Example, etc.) but extract text content first
+ // Extract text from component children before removing the component tags
+ // Match each component type separately to ensure opening/closing tags match
+ for (let componentName of ["Figure", "Example", "CodeExampleWrapper", "CodeExampleStack"]) {
+ let regex = new RegExp(`<${componentName}[^>]*>([\\s\\S]*?)<\\/${componentName}>`, "g");
+ content = content.replace(regex, (match, innerContent) => {
+ // Extract text from the inner content, removing HTML tags
+ let text = innerContent
+ .replace(/<[^>]+>/g, "") // Remove all HTML tags
+ .replace(/\s+/g, " ") // Normalize whitespace
+ .trim();
+ return text ? `\n${text}\n` : "";
+ });
+ }
+
+ // Remove any remaining self-closing component tags
+ content = content.replace(/<(Figure|Example|CodeExampleWrapper|CodeExampleStack)[^>]*\/>/g, "");
+
+ // Extract text from JSX expressions like {
...
} before removing them
+ // Handle multi-line JSX expressions with nested content
+ // We need to match braces properly, handling nested braces
+ let braceDepth = 0;
+ let startIndex = -1;
+ let result = "";
+ let i = 0;
+
+ while (i < content.length) {
+ if (content[i] === "{" && (i === 0 || content[i - 1] !== "\\")) {
+ if (braceDepth === 0) {
+ startIndex = i;
+ }
+ braceDepth++;
+ } else if (content[i] === "}" && (i === 0 || content[i - 1] !== "\\")) {
+ braceDepth--;
+ if (braceDepth === 0 && startIndex !== -1) {
+ let innerContent = content.slice(startIndex + 1, i);
+ // If it contains HTML tags, extract the text content only (not HTML structure)
+ if (innerContent.includes("<")) {
+ // Extract text from HTML - remove all tags and get just the text
+ let text = innerContent
+ .replace(/<[A-Z][a-zA-Z0-9]*[^>]*>/g, "") // Remove React component tags
+ .replace(/<\/[A-Z][a-zA-Z0-9]*>/g, "")
+ .replace(/<[^>]+>/g, "") // Remove all remaining HTML tags
+ .replace(/\s+/g, " ") // Normalize whitespace
+ .trim();
+ // Only add if there's actual text content
+ if (text) {
+ result += text;
+ }
+ }
+ // Skip the braces and continue
+ startIndex = -1;
+ i++;
+ continue;
+ }
+ }
+
+ if (braceDepth === 0) {
+ result += content[i];
+ }
+ i++;
+ }
+
+ // If we ended with unclosed braces, add the rest
+ if (braceDepth > 0) {
+ result += content.slice(startIndex);
+ }
+
+ content = result;
+
+ // Remove remaining JSX component tags and their props (but keep HTML tags like
,
, etc.)
+ // Only remove tags that start with uppercase (React components), not lowercase HTML tags
+ content = content.replace(/<[A-Z][a-zA-Z0-9]*[^>]*\/>/g, "");
+ content = content.replace(/<[A-Z][a-zA-Z0-9]*[^>]*>/g, "");
+ content = content.replace(/<\/[A-Z][a-zA-Z0-9]*>/g, "");
+
+ // Remove JSX attributes from remaining tags
+ content = content.replace(/<([a-z][a-z0-9]*)\s+[^>]*>/g, "<$1>");
+
+ // Remove standalone HTML blocks (not in code blocks)
+ // These are leftover HTML structures that aren't useful for LLM consumption
+ content = removeStandaloneHTML(content);
+
+ return content;
+}
+
+function removeStandaloneHTML(content: string): string {
+ // First, protect code blocks by replacing them with placeholders
+ let codeBlockPlaceholders: string[] = [];
+ let placeholderIndex = 0;
+
+ content = content.replace(/```[\s\S]*?```/g, (match) => {
+ let placeholder = `__CODE_BLOCK_PLACEHOLDER_${placeholderIndex}__`;
+ codeBlockPlaceholders[placeholderIndex] = match;
+ placeholderIndex++;
+ return placeholder;
+ });
+
+ // Remove nested HTML structures that span multiple lines
+ // These are leftover HTML blocks that aren't in code blocks
+ let lines = content.split("\n");
+ let result: string[] = [];
+ let inHTMLBlock = false;
+ let htmlBlockDepth = 0;
+
+ for (let i = 0; i < lines.length; i++) {
+ let line = lines[i];
+ let trimmed = line.trim();
+
+ let startsWithOpeningTag = /^\s*<[a-z][a-z0-9]*[^>]*>\s*$/.test(trimmed);
+ let startsWithClosingTag = /^\s*<\/[a-z][a-z0-9]*>\s*$/.test(trimmed);
+ let isSelfClosingTag = /^\s*<[a-z][a-z0-9]*[^>]*\/>\s*$/.test(trimmed);
+ let hasOpeningTag = /<[a-z][a-z0-9]*[^>]*>/.test(trimmed);
+ let hasClosingTag = /<\/[a-z][a-z0-9]*>/.test(trimmed);
+ let isCompleteHTMLElement = /^\s*<[a-z][a-z0-9]*[^>]*>.*<\/[a-z][a-z0-9]*>\s*$/.test(trimmed) || isSelfClosingTag;
+
+ if (isSelfClosingTag && !inHTMLBlock) {
+ continue;
+ } else if (isCompleteHTMLElement && !inHTMLBlock) {
+ continue;
+ } else if (startsWithOpeningTag && !inHTMLBlock) {
+ inHTMLBlock = true;
+ htmlBlockDepth = 1;
+ } else if (hasOpeningTag && inHTMLBlock && !hasClosingTag) {
+ htmlBlockDepth++;
+ } else if (startsWithClosingTag && inHTMLBlock) {
+ htmlBlockDepth--;
+ if (htmlBlockDepth === 0) {
+ inHTMLBlock = false;
+ continue;
+ }
+ } else if (inHTMLBlock) {
+ continue;
+ } else {
+ result.push(line);
+ }
+ }
+
+ content = result.join("\n");
+
+ // Restore code blocks
+ for (let i = 0; i < codeBlockPlaceholders.length; i++) {
+ content = content.replace(`__CODE_BLOCK_PLACEHOLDER_${i}__`, codeBlockPlaceholders[i]);
+ }
+
+ return content;
+}
+
+function removeCodeDirectives(content: string): string {
+ // Remove [!code ...] directives
+ // These can appear as comments in various formats
+ content = content.replace(//g, "");
+ content = content.replace(/\/\*\s*\[!code[^\]]+\]\s*\*\//g, "");
+ content = content.replace(/#\s*\[!code[^\]]+\]/g, "");
+ content = content.replace(/\/\/\s*\[!code[^\]]+\]/g, "");
+
+ // Remove prettier-ignore comments
+ content = content.replace(//g, "");
+ content = content.replace(/\/\*\s*prettier-ignore\s*\*\//g, "");
+ content = content.replace(/#\s*prettier-ignore/g, "");
+ content = content.replace(/\/\/\s*prettier-ignore/g, "");
+
+ return content;
+}
+
+function cleanWhitespace(content: string): string {
+ // Remove excessive blank lines (more than 2 consecutive)
+ content = content.replace(/\n{3,}/g, "\n\n");
+
+ // Trim each line
+ content = content
+ .split("\n")
+ .map((line) => line.trimEnd())
+ .join("\n");
+
+ // Remove leading/trailing whitespace
+ return content.trim();
+}
diff --git a/src/app/llms.txt/route.ts b/src/app/llms.txt/route.ts
new file mode 100644
index 0000000000..44364ae466
--- /dev/null
+++ b/src/app/llms.txt/route.ts
@@ -0,0 +1,136 @@
+import { NextResponse } from "next/server";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getDocPageSlugs } from "../(docs)/docs/api";
+import { extractTextFromMDX } from "../api/llms-txt/ast-extract";
+import index from "../(docs)/docs/index";
+
+export const dynamic = "force-static";
+export const revalidate = false;
+
+export async function GET() {
+ let output = "# Tailwind CSS Documentation\n\n";
+ output +=
+ "This file contains a concatenated, text-only version of all Tailwind CSS documentation pages, optimized for Large Language Model consumption.\n\n";
+ output += "---\n\n";
+
+ let slugs = await getDocPageSlugs();
+
+ // Build a map of slugs to their section and title from the index
+ let slugToSection = new Map();
+ for (let [section, entries] of Object.entries(index)) {
+ for (let entry of entries) {
+ let [title, docPath] = entry;
+ let slug = docPath.replace("/docs/", "");
+ slugToSection.set(slug, { section, title });
+
+ // Handle nested children
+ if (entry.length > 2 && Array.isArray(entry[2])) {
+ for (let [childTitle, childPath] of entry[2]) {
+ let childSlug = childPath.replace("/docs/", "");
+ slugToSection.set(childSlug, { section, title: childTitle });
+ }
+ }
+ }
+ }
+
+ // Process each slug in the order defined by the index
+ let processedSlugs = new Set();
+ let currentSection = "";
+
+ for (let [section, entries] of Object.entries(index)) {
+ if (section !== currentSection) {
+ if (currentSection !== "") {
+ output += "\n";
+ }
+ output += `## ${section}\n\n`;
+ currentSection = section;
+ }
+
+ for (let entry of entries) {
+ let [title, docPath] = entry;
+ let slug = docPath.replace("/docs/", "");
+
+ if (processedSlugs.has(slug)) continue;
+ processedSlugs.add(slug);
+
+ output += await processSlug(slug, title);
+
+ // Handle nested children
+ if (entry.length > 2 && Array.isArray(entry[2])) {
+ for (let [childTitle, childPath] of entry[2]) {
+ let childSlug = childPath.replace("/docs/", "");
+ if (processedSlugs.has(childSlug)) continue;
+ processedSlugs.add(childSlug);
+ output += await processSlug(childSlug, childTitle);
+ }
+ }
+ }
+ }
+
+ // Process any remaining slugs that weren't in the index
+ for (let slug of slugs) {
+ if (!processedSlugs.has(slug)) {
+ let sectionInfo = slugToSection.get(slug);
+ let title = sectionInfo?.title || slug;
+ output += await processSlug(slug, title);
+ }
+ }
+
+ return new NextResponse(output, {
+ headers: {
+ "Content-Type": "text/plain; charset=utf-8",
+ "Cache-Control": process.env.NODE_ENV === "development" ? "no-cache" : "public, max-age=3600",
+ },
+ });
+}
+
+async function processSlug(slug: string, title: string): Promise {
+ try {
+ let filePath = path.join(process.cwd(), "./src/docs", `${slug}.mdx`);
+ let content = await fs.readFile(filePath, "utf8");
+
+ // Extract title and description from exports
+ let titleMatch = content.match(/export\s+const\s+title\s*=\s*["']([^"']+)["']/);
+ let descriptionMatch = content.match(/export\s+const\s+description\s*=\s*["']([^"']+)["']/);
+
+ let pageTitle = titleMatch ? titleMatch[1] : title;
+ let description = descriptionMatch ? descriptionMatch[1] : "";
+
+ // Extract text from MDX
+ let extractedText = extractTextFromMDX(content);
+
+ // Remove the title/description header that extractTextFromMDX adds (we'll format it ourselves)
+ if (extractedText.startsWith("# ")) {
+ let lines = extractedText.split("\n");
+ // Skip the title line, description line(s), and separator
+ let startIndex = 0;
+ for (let i = 0; i < lines.length; i++) {
+ if (lines[i].startsWith("---")) {
+ startIndex = i + 1;
+ break;
+ }
+ }
+ extractedText = lines.slice(startIndex).join("\n").trim();
+ }
+
+ // Format the page
+ let pageOutput = `### ${pageTitle}\n\n`;
+ if (description) {
+ pageOutput += `${description}\n\n`;
+ }
+ pageOutput += `URL: /docs/${slug}\n\n`;
+ pageOutput += `${extractedText}\n\n`;
+ pageOutput += "---\n\n";
+
+ return pageOutput;
+ } catch (error) {
+ // Silently skip "installation" - it's a Next.js route without an MDX file
+ if (slug === "installation") {
+ return "";
+ }
+ // Log errors for other files
+ console.error(`Error processing ${slug}:`, error);
+ return "";
+ }
+}
+
+ More content here.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Editor setup"));
+ assert.ok(result.includes("Some content before"));
+ assert.ok(result.includes("More content here"));
+ assert.ok(!result.includes("![Built-in support for Tailwind CSS in Zed]({require("./img/zed-intellisense.png").default.src})
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(!result.includes("
+ 
+ 
+ 
+
+ Three photos above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Gallery"));
+ assert.ok(result.includes("Three photos above"));
+ assert.ok(!result.includes("
after image.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("Before image"));
+ assert.ok(result.includes("after image"));
+ assert.ok(!result.includes("
+
+ It's great for development.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Editor Setup"));
+ assert.ok(result.includes("Check out our editor"));
+ assert.ok(result.includes("It's great for development"));
+ assert.ok(!result.includes("
+ \`\`\`
+
+ The code above shows an image tag.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## HTML Example"));
+ assert.ok(result.includes("```html"));
+ assert.ok(result.includes('
+ 
+
+
+
+ All media above.
+ `;
+
+ let result = extractTextFromMDX(input);
+ assert.ok(result.includes("## Gallery"));
+ assert.ok(result.includes("All media above"));
+ assert.ok(!result.includes("
+