ardo 3.1.0 → 3.2.1

package/dist/vite/index.js

@@ -1,1335 +1,2984 @@
-import {
-  defaultMarkdownConfig,
-  resolveConfig
-} from "../chunk-NBRHGTR2.js";
-import {
-  generateApiDocs
-} from "../chunk-PGHUPTGL.js";
-
-// src/vite/plugin.ts
-import { reactRouter } from "@react-router/dev/vite";
-import mdx from "@mdx-js/rollup";
+import { defaultMarkdownConfig, resolveConfig } from "../config/index.js";
+import { n as generateApiDocs } from "../generator-DPtRXxM_.js";
+import path from "node:path";
+import matter from "gray-matter";
+import rehypeStringify from "rehype-stringify";
 import remarkFrontmatter from "remark-frontmatter";
-import remarkMdxFrontmatter from "remark-mdx-frontmatter";
 import remarkGfm from "remark-gfm";
-import rehypeShiki from "@shikijs/rehype";
-
-// src/markdown/shiki.ts
-import {
-  createHighlighter
-} from "shiki";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { unified } from "unified";
 import { visit } from "unist-util-visit";
-var DEFAULT_THEMES = {
-  light: "github-light-default",
-  dark: "github-dark-default"
+import { createHighlighter } from "shiki";
+import fs from "node:fs/promises";
+import { vanillaExtractPlugin } from "@vanilla-extract/vite-plugin";
+import fsSync from "node:fs";
+import { execSync } from "node:child_process";
+import mdx from "@mdx-js/rollup";
+import { reactRouter } from "@react-router/dev/vite";
+import rehypeShiki from "@shikijs/rehype";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+//#region src/markdown/links.ts
+/**
+* Rehype plugin that rewrites internal links to include the basePath.
+* This is needed for static sites deployed to subpaths (e.g., GitHub Pages).
+*/
+function rehypeLinks(options) {
+	const { basePath } = options;
+	const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/$/, "");
+	return (tree) => {
+		if (!normalizedBase) return;
+		visit(tree, "element", (node) => {
+			if (node.tagName !== "a") return;
+			const href = node.properties.href;
+			if (typeof href === "string" && href.startsWith("/") && !href.startsWith("//") && !href.startsWith(normalizedBase)) node.properties.href = normalizedBase + href;
+		});
+	};
+}
+//#endregion
+//#region src/markdown/shiki-theme.ts
+/** Default Ardo themes used when no config is provided */
+const DEFAULT_THEMES = {
+	light: "github-light-default",
+	dark: "github-dark-default"
 };
-var cachedHighlighter;
-async function highlightCode(code, language, options) {
-  const themeConfig = options?.theme ?? DEFAULT_THEMES;
-  if (!cachedHighlighter) {
-    cachedHighlighter = await createShikiHighlighter({
-      theme: themeConfig,
-      lineNumbers: false,
-      anchor: false,
-      toc: { level: [2, 3] }
-    });
-  }
-  if (typeof themeConfig === "string") {
-    return cachedHighlighter.codeToHtml(code, { lang: language, theme: themeConfig });
-  }
-  return cachedHighlighter.codeToHtml(code, {
-    lang: language,
-    themes: { light: themeConfig.light, dark: themeConfig.dark },
-    defaultColor: false
-  });
+function resolveThemeConfig(theme) {
+	return theme ?? DEFAULT_THEMES;
 }
-async function createShikiHighlighter(config) {
-  const themeConfig = config.theme;
-  const themes = typeof themeConfig === "string" ? [themeConfig] : [themeConfig.light, themeConfig.dark];
-  const highlighter = await createHighlighter({
-    themes,
-    langs: [
-      // Web fundamentals
-      "javascript",
-      "typescript",
-      "jsx",
-      "tsx",
-      "html",
-      "css",
-      "scss",
-      // Data & config formats
-      "json",
-      "jsonc",
-      "yaml",
-      "toml",
-      "xml",
-      "graphql",
-      // Markdown & docs
-      "markdown",
-      "mdx",
-      // Shell & DevOps
-      "bash",
-      "shell",
-      "dockerfile",
-      // General purpose
-      "python",
-      "rust",
-      "go",
-      "sql",
-      "diff"
-    ]
-  });
-  return highlighter;
+function getBundledThemes(themeConfig) {
+	if (themeConfig == null) return [DEFAULT_THEMES.light, DEFAULT_THEMES.dark];
+	return typeof themeConfig === "string" ? [themeConfig] : [themeConfig.light, themeConfig.dark];
 }
-function rehypeShikiFromHighlighter(options) {
-  const { highlighter, config } = options;
-  const themeConfig = config.theme;
-  return function(tree) {
-    visit(tree, "element", (node, index, parent) => {
-      if (node.tagName !== "pre" || !node.children[0] || node.children[0].tagName !== "code") {
-        return;
-      }
-      const codeNode = node.children[0];
-      const className = codeNode.properties?.className || [];
-      const langClass = className.find((c) => c.startsWith("language-"));
-      const lang = langClass ? langClass.replace("language-", "") : "text";
-      const codeContent = getTextContent(codeNode);
-      if (!codeContent.trim()) {
-        return;
-      }
-      try {
-        let html;
-        if (typeof themeConfig === "string") {
-          html = highlighter.codeToHtml(codeContent, {
-            lang,
-            theme: themeConfig
-          });
-        } else {
-          html = highlighter.codeToHtml(codeContent, {
-            lang,
-            themes: {
-              light: themeConfig.light,
-              dark: themeConfig.dark
-            },
-            defaultColor: false
-          });
-        }
-        const metaString = codeNode.properties?.metastring || "";
-        const lineNumbers = config.lineNumbers || metaString.includes("showLineNumbers");
-        const highlightLines = parseHighlightLines(metaString);
-        const title = parseTitle(metaString);
-        const wrapperHtml = buildCodeBlockHtml(html, {
-          lang,
-          lineNumbers,
-          highlightLines,
-          title
-        });
-        if (parent && typeof index === "number") {
-          const newNode = {
-            type: "element",
-            tagName: "div",
-            properties: {
-              className: ["ardo-code-block"],
-              "data-lang": lang
-            },
-            children: [
-              {
-                type: "raw",
-                value: wrapperHtml
-              }
-            ]
-          };
-          parent.children[index] = newNode;
-        }
-      } catch {
-      }
-    });
-  };
+function highlightWithTheme(params) {
+	const { code, highlighter, language, themeConfig } = params;
+	const resolved = themeConfig ?? DEFAULT_THEMES;
+	if (typeof resolved === "string") return highlighter.codeToHtml(code, {
+		lang: language,
+		theme: resolved
+	});
+	return highlighter.codeToHtml(code, {
+		defaultColor: false,
+		lang: language,
+		themes: {
+			dark: resolved.dark,
+			light: resolved.light
+		}
+	});
 }
-function getTextContent(node) {
-  if (node.type === "text") {
-    return node.value;
-  }
-  if ("children" in node) {
-    return node.children.map((child) => getTextContent(child)).join("");
-  }
-  return "";
+//#endregion
+//#region src/ui/components/code-block-classes.ts
+const shikiContainerClassName = "ardo-shiki";
+//#endregion
+//#region src/markdown/shiki-html.ts
+function buildCodeBlockHtml(shikiHtml, options) {
+	const titleHtml = renderTitle(options.title);
+	const codeHtml = renderCodeLines({
+		highlightLines: options.highlightLines,
+		lineNumbers: options.lineNumbers,
+		shikiHtml
+	});
+	const copyButton = renderCopyButton(shikiHtml);
+	return `${titleHtml}<div data-lang="${options.lang}">${codeHtml}${copyButton}</div>`;
 }
-function parseHighlightLines(meta) {
-  const match = meta.match(/\{([\d,-]+)\}/);
-  if (!match) return [];
-  const ranges = match[1].split(",");
-  const lines = [];
-  for (const range of ranges) {
-    if (range.includes("-")) {
-      const [start, end] = range.split("-").map(Number);
-      for (let i = start; i <= end; i++) {
-        lines.push(i);
-      }
-    } else {
-      lines.push(Number(range));
-    }
-  }
-  return lines;
+function renderTitle(title) {
+	if (title == null || title.length === 0) return "";
+	return `<div data-title>${escapeHtml(title)}</div>`;
 }
-function parseTitle(meta) {
-  const match = meta.match(/title="([^"]+)"/);
-  return match ? match[1] : void 0;
+function renderCodeLines(params) {
+	const { highlightLines, lineNumbers, shikiHtml } = params;
+	if (!lineNumbers && highlightLines.length === 0) return shikiHtml;
+	return shikiHtml.split("\n").map((lineHtml, index) => renderSingleCodeLine({
+		highlightLines,
+		lineHtml,
+		lineNumber: index + 1,
+		lineNumbers
+	})).join("\n");
 }
-function buildCodeBlockHtml(shikiHtml, options) {
-  const { lang, lineNumbers, highlightLines, title } = options;
-  let html = "";
-  if (title) {
-    html += `<div class="ardo-code-title">${escapeHtml(title)}</div>`;
-  }
-  html += `<div class="ardo-code-wrapper" data-lang="${lang}">`;
-  if (lineNumbers || highlightLines.length > 0) {
-    const lines = shikiHtml.split("\n");
-    const processedHtml = lines.map((line, i) => {
-      const lineNum = i + 1;
-      const isHighlighted = highlightLines.includes(lineNum);
-      const classes = ["ardo-code-line"];
-      if (isHighlighted) classes.push("highlighted");
-      let prefix = "";
-      if (lineNumbers) {
-        prefix = `<span class="ardo-line-number">${lineNum}</span>`;
-      }
-      return `<span class="${classes.join(" ")}">${prefix}${line}</span>`;
-    }).join("\n");
-    html += processedHtml;
-  } else {
-    html += shikiHtml;
-  }
-  html += `<button class="ardo-copy-button" data-code="${encodeURIComponent(extractCodeFromHtml(shikiHtml))}">
-    <span class="ardo-copy-icon">Copy</span>
-    <span class="ardo-copied-icon" style="display:none">Copied!</span>
+function renderSingleCodeLine(params) {
+	const { highlightLines, lineHtml, lineNumber, lineNumbers } = params;
+	return `<span class="${highlightLines.includes(lineNumber) ? "line highlighted" : "line"}"${lineNumbers ? ` data-ln="${lineNumber}"` : ""}>${lineHtml}</span>`;
+}
+function renderCopyButton(shikiHtml) {
+	return `<button data-code="${encodeURIComponent(extractCodeFromHtml(shikiHtml))}">
+    <span>Copy</span>
+    <span style="display:none">Copied!</span>
   </button>`;
-  html += "</div>";
-  return html;
 }
 function extractCodeFromHtml(html) {
-  return html.replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+	return decodeCommonEntities(stripTags(html));
+}
+function stripTags(html) {
+	let result = "";
+	let inTag = false;
+	for (const char of html) {
+		if (char === "<") {
+			inTag = true;
+			continue;
+		}
+		if (inTag && char === ">") {
+			inTag = false;
+			continue;
+		}
+		if (!inTag) result += char;
+	}
+	return result;
+}
+function decodeCommonEntities(text) {
+	return text.replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&").replaceAll("&quot;", "\"").replaceAll("&#39;", "'");
 }
 function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+//#endregion
+//#region src/markdown/shiki-meta.ts
+function parseHighlightLines(meta) {
+	const match = /\{([\d,-]+)\}/u.exec(meta);
+	if (match?.[1] == null) return [];
+	const lines = [];
+	for (const range of match[1].split(",")) appendRangeLines(lines, range);
+	return lines;
+}
+function appendRangeLines(lines, range) {
+	if (range.includes("-")) {
+		appendRangeSet(lines, range);
+		return;
+	}
+	const lineNumber = Number(range);
+	if (Number.isFinite(lineNumber)) lines.push(lineNumber);
+}
+function appendRangeSet(lines, range) {
+	const [start, end] = range.split("-").map(Number);
+	if (!Number.isFinite(start) || !Number.isFinite(end)) return;
+	for (let line = start; line <= end; line++) lines.push(line);
+}
+function parseTitle(meta) {
+	return /title="([^"]+)"/u.exec(meta)?.[1];
+}
+function parseLabel(meta) {
+	const start = meta.indexOf("[");
+	if (start === -1) return;
+	const end = meta.indexOf("]", start + 1);
+	if (end === -1) return;
+	const label = meta.slice(start + 1, end).trim();
+	return label.length > 0 ? label : void 0;
+}
+//#endregion
+//#region src/markdown/shiki-rehype.ts
+function rehypeShikiFromHighlighter(options) {
+	const themeConfig = resolveThemeConfig(options.config.theme);
+	return function(tree) {
+		visit(tree, "element", (node, index, parent) => {
+			transformCodeNode({
+				config: options.config,
+				highlighter: options.highlighter,
+				index,
+				node,
+				parent,
+				themeConfig
+			});
+		});
+	};
+}
+function transformCodeNode(context) {
+	const codeNode = getCodeNode(context.node);
+	if (codeNode == null) return;
+	const codeContent = getTextContent(codeNode);
+	if (codeContent.trim().length === 0) return;
+	const metaString = getMetaString(codeNode);
+	const innerHtml = tryRenderHighlightedHtml({
+		codeContent,
+		context,
+		language: getLanguage(codeNode),
+		metaString
+	});
+	if (innerHtml == null) return;
+	replaceNodeWithShikiContainer(context.parent, context.index, innerHtml);
+}
+function tryRenderHighlightedHtml(params) {
+	const { codeContent, context, language, metaString } = params;
+	try {
+		return buildCodeBlockHtml(highlightWithTheme({
+			code: codeContent,
+			highlighter: context.highlighter,
+			language,
+			themeConfig: context.themeConfig
+		}), {
+			highlightLines: parseHighlightLines(metaString),
+			lang: language,
+			lineNumbers: (context.config.lineNumbers ?? false) || metaString.includes("showLineNumbers"),
+			title: parseTitle(metaString)
+		});
+	} catch {
+		return null;
+	}
+}
+function getCodeNode(node) {
+	if (node.tagName !== "pre") return null;
+	const firstChild = node.children.at(0);
+	if (!isElementNode(firstChild) || firstChild.tagName !== "code") return null;
+	return firstChild;
+}
+function isElementNode(node) {
+	return isRecord$5(node) && node.type === "element";
+}
+function getMetaString(codeNode) {
+	const properties = toRecord(codeNode.properties);
+	return typeof properties.metastring === "string" ? properties.metastring : "";
+}
+function getLanguage(codeNode) {
+	const languageClass = toClassNameList(toRecord(codeNode.properties).className).find((className) => className.startsWith("language-"));
+	return languageClass == null ? "text" : languageClass.replace("language-", "");
+}
+function toClassNameList(className) {
+	if (Array.isArray(className)) return className.filter((entry) => typeof entry === "string");
+	if (typeof className === "string") return [className];
+	return [];
+}
+function getTextContent(node) {
+	if (node.type === "text") return node.value;
+	const parts = [];
+	for (const child of node.children) if (child.type === "text" || child.type === "element") parts.push(getTextContent(child));
+	return parts.join("");
+}
+function replaceNodeWithShikiContainer(parent, index, innerHtml) {
+	if (index == null || !hasChildrenArray(parent)) return;
+	parent.children[index] = {
+		type: "element",
+		tagName: "div",
+		properties: { className: [shikiContainerClassName] },
+		children: [{
+			type: "raw",
+			value: innerHtml
+		}]
+	};
+}
+function hasChildrenArray(value) {
+	return isRecord$5(value) && Array.isArray(value.children);
+}
+function toRecord(value) {
+	return isRecord$5(value) ? value : {};
+}
+function isRecord$5(value) {
+	return value != null && typeof value === "object";
 }
+//#endregion
+//#region src/markdown/shiki-transformer.ts
+/**
+* Remark plugin that extracts code fence meta info and stores it as HAST
+* data attributes before MDX compilation can corrupt it.
+*/
 function remarkCodeMeta() {
-  return function(tree) {
-    visit(tree, "code", (node) => {
-      if (!node.meta) return;
-      const meta = node.meta;
-      const data = node.data || (node.data = {});
-      const hProperties = data.hProperties || {};
-      hProperties.metastring = meta;
-      data.hProperties = hProperties;
-      node.meta = null;
-    });
-  };
+	return function(tree) {
+		visit(tree, "code", (node) => {
+			const meta = node.meta;
+			if (meta == null || meta.length === 0) return;
+			const data = ensureNodeData(node);
+			const hProperties = ensureRecord(data.hProperties);
+			hProperties.metastring = meta;
+			data.hProperties = hProperties;
+			node.meta = null;
+		});
+	};
 }
+function ensureNodeData(node) {
+	node.data ??= {};
+	return node.data;
+}
+function ensureRecord(value) {
+	return isRecord$4(value) ? value : {};
+}
+function isRecord$4(value) {
+	return value != null && typeof value === "object";
+}
+/**
+* Shiki transformer that adds line highlighting, line numbers, and title
+* attributes to code blocks in the MDX pipeline.
+*/
 function ardoLineTransformer(options = {}) {
-  let highlightLines = [];
-  let showLineNumbers = false;
-  let metaRaw = "";
-  return {
-    name: "ardo:lines",
-    // preprocess runs BEFORE line() hooks, so state is ready for line()
-    preprocess(_code, shikiOptions) {
-      metaRaw = shikiOptions.meta?.__raw || "";
-      highlightLines = parseHighlightLines(metaRaw);
-      showLineNumbers = options.globalLineNumbers || metaRaw.includes("showLineNumbers");
-    },
-    // pre runs AFTER line() — used only for node property modifications
-    pre(node) {
-      node.properties = node.properties || {};
-      const title = parseTitle(metaRaw);
-      if (title) {
-        node.properties["data-title"] = title;
-      }
-      const labelMatch = metaRaw.match(/\[([^\]]+)\]/);
-      if (labelMatch) {
-        node.properties["data-label"] = labelMatch[1];
-      }
-    },
-    line(node, line) {
-      const currentClass = node.properties?.class || "";
-      const classes = currentClass ? currentClass.split(" ") : [];
-      classes.push("ardo-code-line");
-      if (highlightLines.includes(line)) {
-        classes.push("highlighted");
-      }
-      node.properties = node.properties || {};
-      node.properties.class = classes.join(" ");
-      if (showLineNumbers) {
-        node.children.unshift({
-          type: "element",
-          tagName: "span",
-          properties: { class: "ardo-line-number" },
-          children: [{ type: "text", value: String(line) }]
-        });
-      }
-    }
-  };
+	const state = {
+		highlightLines: [],
+		metaRaw: "",
+		showLineNumbers: false
+	};
+	return {
+		name: "ardo:lines",
+		preprocess(_code, shikiOptions) {
+			const metaRaw = getMetaRaw(shikiOptions.meta);
+			state.metaRaw = metaRaw;
+			state.highlightLines = parseHighlightLines(metaRaw);
+			state.showLineNumbers = (options.globalLineNumbers ?? false) || metaRaw.includes("showLineNumbers");
+		},
+		pre(node) {
+			const properties = ensureNodeProperties(node);
+			applyTitleProperty(properties, state.metaRaw);
+			applyLabelProperty(properties, state.metaRaw);
+		},
+		line(node, line) {
+			const properties = ensureNodeProperties(node);
+			applyHighlightedLineClass(properties, state.highlightLines, line);
+			if (state.showLineNumbers) properties["data-ln"] = String(line);
+		}
+	};
 }
-
-// src/vite/plugin.ts
-import fs2 from "fs/promises";
-import fsSync2 from "fs";
-import path2 from "path";
-import { execSync } from "child_process";
-import matter from "gray-matter";
-
-// src/vite/routes-plugin.ts
-import fs from "fs/promises";
-import fsSync from "fs";
-import path from "path";
-function ardoRoutesPlugin(options = {}) {
-  let routesDir;
-  let appDir;
-  let routesFilePath;
-  function scanRoutesSync(dir, rootDir) {
-    const routes = [];
-    try {
-      const entries = fsSync.readdirSync(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          const children = scanRoutesSync(fullPath, rootDir);
-          routes.push(...children);
-        } else if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md") || entry.name.endsWith(".tsx")) {
-          if (entry.name === "root.tsx" || entry.name.startsWith("_")) {
-            continue;
-          }
-          const relativePath = path.relative(rootDir, fullPath);
-          const ext = entry.name.endsWith(".mdx") ? ".mdx" : entry.name.endsWith(".md") ? ".md" : ".tsx";
-          const baseName = entry.name.replace(ext, "");
-          let urlPath;
-          if (baseName === "index" || baseName === "home") {
-            const parentDir = path.dirname(relativePath);
-            urlPath = parentDir === "." ? "/" : "/" + parentDir.replace(/\\/g, "/");
-          } else {
-            urlPath = "/" + relativePath.replace(ext, "").replace(/\\/g, "/");
-          }
-          urlPath = urlPath.replace(/\$(\w+)/g, ":$1");
-          routes.push({
-            path: urlPath,
-            file: "routes/" + relativePath.replace(/\\/g, "/"),
-            isIndex: baseName === "index" || baseName === "home"
-          });
-        }
-      }
-    } catch {
-    }
-    return routes;
-  }
-  function generateRoutesFile(routes) {
-    const sortedRoutes = [...routes].sort((a, b) => {
-      if (a.path === "/" && b.path !== "/") return -1;
-      if (b.path === "/" && a.path !== "/") return 1;
-      if (a.isIndex && !b.isIndex) return -1;
-      if (b.isIndex && !a.isIndex) return 1;
-      return a.path.localeCompare(b.path);
-    });
-    const entries = sortedRoutes.map((r) => {
-      if (r.path === "/") {
-        return `  index("${r.file}"),`;
-      }
-      const routePath = r.path.substring(1);
-      return `  route("${routePath}", "${r.file}"),`;
-    });
-    return `// AUTO-GENERATED by Ardo - Do not edit manually
-
-import { type RouteConfig, route, index } from "@react-router/dev/routes"
-
-export default [
-${entries.join("\n")}
-] satisfies RouteConfig
-`;
-  }
-  function writeRoutesFileSync() {
-    const routes = scanRoutesSync(routesDir, routesDir);
-    if (routes.length === 0) {
-      return;
-    }
-    const content = generateRoutesFile(routes);
-    try {
-      const existing = fsSync.readFileSync(routesFilePath, "utf-8");
-      if (existing === content) {
-        return;
-      }
-    } catch {
-    }
-    fsSync.mkdirSync(appDir, { recursive: true });
-    fsSync.writeFileSync(routesFilePath, content, "utf-8");
-    console.log(`[ardo] Generated routes.ts with ${routes.length} routes`);
-  }
-  async function writeRoutesFile() {
-    const routes = scanRoutesSync(routesDir, routesDir);
-    if (routes.length === 0) {
-      return;
-    }
-    const content = generateRoutesFile(routes);
-    try {
-      const existing = await fs.readFile(routesFilePath, "utf-8");
-      if (existing === content) {
-        return;
-      }
-    } catch {
-    }
-    await fs.mkdir(appDir, { recursive: true });
-    await fs.writeFile(routesFilePath, content, "utf-8");
-  }
-  return {
-    name: "ardo:routes",
-    enforce: "pre",
-    config(userConfig) {
-      const root = userConfig.root || process.cwd();
-      appDir = path.join(root, "app");
-      routesDir = options.routesDir || path.join(appDir, "routes");
-      routesFilePath = path.join(appDir, "routes.ts");
-      try {
-        writeRoutesFileSync();
-      } catch (err) {
-        console.warn("[ardo] Could not generate routes.ts in config phase:", err);
-      }
-    },
-    configResolved(config) {
-      if (!appDir) {
-        appDir = path.join(config.root, "app");
-        routesDir = options.routesDir || path.join(appDir, "routes");
-        routesFilePath = path.join(appDir, "routes.ts");
-      }
-    },
-    async buildStart() {
-      await writeRoutesFile();
-    },
-    configureServer(server) {
-      server.watcher.add(routesDir);
-      const handleChange = async (changedPath) => {
-        if (changedPath.startsWith(routesDir) && (changedPath.endsWith(".mdx") || changedPath.endsWith(".md") || changedPath.endsWith(".tsx"))) {
-          await writeRoutesFile();
-        }
-      };
-      server.watcher.on("add", handleChange);
-      server.watcher.on("unlink", handleChange);
-    }
-  };
+function getMetaRaw(meta) {
+	if (!isRecord$4(meta)) return "";
+	const raw = meta.__raw;
+	return typeof raw === "string" ? raw : "";
 }
-
-// src/vite/plugin.ts
-import { vanillaExtractPlugin } from "@vanilla-extract/vite-plugin";
-
-// src/vite/codeblock-plugin.ts
+function ensureNodeProperties(node) {
+	node.properties ??= {};
+	return node.properties;
+}
+function applyTitleProperty(properties, metaRaw) {
+	const title = parseTitle(metaRaw);
+	if (title != null && title.length > 0) properties["data-title"] = title;
+}
+function applyLabelProperty(properties, metaRaw) {
+	const label = parseLabel(metaRaw);
+	if (label != null && label.length > 0) properties["data-label"] = label;
+}
+function applyHighlightedLineClass(properties, highlightLines, line) {
+	if (!highlightLines.includes(line)) return;
+	const currentClass = typeof properties.class === "string" ? properties.class : "";
+	properties.class = currentClass.length > 0 ? `${currentClass} highlighted` : "highlighted";
+}
+//#endregion
+//#region src/markdown/shiki.ts
+let cachedHighlighterPromise;
+/**
+* Highlights code using Shiki with Ardo's default themes.
+* Creates and caches a highlighter instance for reuse.
+*/
+async function highlightCode(code, language, options) {
+	const themeConfig = resolveThemeConfig(options?.theme);
+	return highlightWithTheme({
+		code,
+		highlighter: await getCachedHighlighter(themeConfig),
+		language,
+		themeConfig
+	});
+}
+async function getCachedHighlighter(themeConfig) {
+	cachedHighlighterPromise ??= createShikiHighlighter({
+		anchor: false,
+		lineNumbers: false,
+		theme: themeConfig,
+		toc: { level: [2, 3] }
+	});
+	return cachedHighlighterPromise;
+}
+async function createShikiHighlighter(config) {
+	return createHighlighter({
+		themes: getBundledThemes(resolveThemeConfig(config.theme)),
+		langs: [
+			"javascript",
+			"typescript",
+			"jsx",
+			"tsx",
+			"html",
+			"css",
+			"scss",
+			"json",
+			"jsonc",
+			"yaml",
+			"toml",
+			"xml",
+			"graphql",
+			"markdown",
+			"mdx",
+			"bash",
+			"shell",
+			"dockerfile",
+			"python",
+			"rust",
+			"go",
+			"sql",
+			"diff"
+		]
+	});
+}
+//#endregion
+//#region src/markdown/toc.ts
+function remarkExtractToc(options) {
+	const { tocExtraction, levels } = options;
+	const [minLevel, maxLevel] = levels;
+	return function(tree) {
+		const headings = [];
+		let headingIndex = 0;
+		visit(tree, "heading", (node) => {
+			if (node.depth < minLevel || node.depth > maxLevel) return;
+			const text = getHeadingText$1(node);
+			const slug = slugify$1(text);
+			const id = slug === "" ? `heading-${headingIndex}` : slug;
+			headingIndex++;
+			headings.push({
+				text,
+				level: node.depth,
+				id
+			});
+			const hProperties = ensureHProperties$1(node);
+			hProperties.id = id;
+		});
+		tocExtraction.toc = buildTocTree(headings);
+	};
+}
+function getHeadingText$1(node) {
+	const textParts = [];
+	function extractText(child) {
+		if (!isRecord$3(child)) return;
+		if (child.type === "text") textParts.push(typeof child.value === "string" ? child.value : "");
+		else if (child.type === "inlineCode") textParts.push(typeof child.value === "string" ? child.value : "");
+		else if (Array.isArray(child.children)) child.children.forEach((nestedChild) => {
+			extractText(nestedChild);
+		});
+	}
+	node.children.forEach((child) => {
+		extractText(child);
+	});
+	return textParts.join("");
+}
+function slugify$1(text) {
+	let slug = text.toLowerCase().trim().replaceAll(/[^\s\w-]/g, "").replaceAll(/[\s_]/g, "-");
+	while (slug.includes("--")) slug = slug.replaceAll("--", "-");
+	if (slug.startsWith("-")) slug = slug.slice(1);
+	if (slug.endsWith("-")) slug = slug.slice(0, -1);
+	return slug;
+}
+function popStackUntilParent(stack, level) {
+	while (stack.length > 0) {
+		const last = stack.at(-1);
+		if (last === void 0 || last.level < level) break;
+		stack.pop();
+	}
+}
+function insertIntoTree(result, stack, item) {
+	const parent = stack.at(-1)?.item;
+	if (parent === void 0) result.push(item);
+	else {
+		parent.children ??= [];
+		parent.children.push(item);
+	}
+}
+function buildTocTree(headings) {
+	const result = [];
+	const stack = [];
+	for (const heading of headings) {
+		const item = {
+			id: heading.id,
+			text: heading.text,
+			level: heading.level
+		};
+		popStackUntilParent(stack, heading.level);
+		insertIntoTree(result, stack, item);
+		stack.push({
+			item,
+			level: heading.level
+		});
+	}
+	return result;
+}
+function ensureHProperties$1(node) {
+	const data = node.data ?? {};
+	node.data = data;
+	if (!isRecord$3(data.hProperties)) data.hProperties = {};
+	return data.hProperties;
+}
+function isRecord$3(value) {
+	return value != null && typeof value === "object";
+}
+//#endregion
+//#region src/markdown/pipeline.ts
+async function transformMarkdown(content, config, options = {}) {
+	const { data, content: markdownContent } = matter(content);
+	const frontmatterData = data;
+	const { basePath = "/", highlighter: providedHighlighter } = options;
+	const tocExtraction = { toc: [] };
+	const highlighter = providedHighlighter ?? await createShikiHighlighter(config);
+	const processor = unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(remarkGfm).use(remarkExtractToc, {
+		tocExtraction,
+		levels: config.toc?.level ?? [2, 3]
+	}).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeShikiFromHighlighter, {
+		highlighter,
+		config
+	}).use(rehypeLinks, { basePath }).use(rehypeStringify, { allowDangerousHtml: true });
+	if (config.remarkPlugins) processor.use(config.remarkPlugins);
+	if (config.rehypePlugins) processor.use(config.rehypePlugins);
+	const result = await processor.process(markdownContent);
+	return {
+		html: String(result),
+		frontmatter: readPageFrontmatter(frontmatterData),
+		toc: tocExtraction.toc
+	};
+}
+async function transformMarkdownToReact(content, config) {
+	return transformMarkdown(content, config);
+}
+function readPageFrontmatter(data) {
+	return isRecord$2(data) ? data : {};
+}
+function isRecord$2(value) {
+	return value != null && typeof value === "object";
+}
+//#endregion
+//#region src/runtime/loader.ts
+async function findFile(contentDir, slug) {
+	const possiblePaths = [path.join(contentDir, `${slug}.md`), path.join(contentDir, slug, "index.md")];
+	for (const tryPath of possiblePaths) try {
+		return {
+			filePath: tryPath,
+			fileContent: await fs.readFile(tryPath, "utf8")
+		};
+	} catch {
+		continue;
+	}
+	return null;
+}
+async function getLastUpdated(filePath) {
+	try {
+		return (await fs.stat(filePath)).mtimeMs;
+	} catch {
+		return;
+	}
+}
+async function loadDoc(options) {
+	const { slug, contentDir, config } = options;
+	const found = await findFile(contentDir, slug);
+	if (found === null) return null;
+	const result = await transformMarkdown(found.fileContent, config.markdown);
+	return {
+		content: result.html,
+		frontmatter: result.frontmatter,
+		toc: result.toc,
+		filePath: found.filePath,
+		relativePath: path.relative(contentDir, found.filePath),
+		lastUpdated: await getLastUpdated(found.filePath)
+	};
+}
+async function loadAllDocs(contentDir, config) {
+	const docs = [];
+	async function scanDir(dir) {
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) await scanDir(fullPath);
+			else if (entry.name.endsWith(".md")) {
+				const result = await transformMarkdown(await fs.readFile(fullPath, "utf8"), config.markdown);
+				const relativePath = path.relative(contentDir, fullPath);
+				let lastUpdated;
+				try {
+					lastUpdated = (await fs.stat(fullPath)).mtimeMs;
+				} catch {}
+				docs.push({
+					title: result.frontmatter.title ?? formatTitle$3(entry.name.replace(/\.md$/, "")),
+					description: result.frontmatter.description,
+					frontmatter: result.frontmatter,
+					content: result.html,
+					toc: result.toc,
+					filePath: fullPath,
+					relativePath,
+					lastUpdated
+				});
+			}
+		}
+	}
+	await scanDir(contentDir);
+	return docs;
+}
+function formatTitle$3(name) {
+	return name.replaceAll(/[_-]/g, " ").replaceAll(/\b\w/g, (c) => c.toUpperCase());
+}
+function getSlugFromPath(relativePath) {
+	return relativePath.replace(/\.md$/, "").replace(/\/index$/, "").replaceAll("\\", "/");
+}
+function getPageDataForRoute(docs, slug) {
+	return docs.find((doc) => {
+		const docSlug = getSlugFromPath(doc.relativePath);
+		return docSlug === slug || docSlug === `${slug}/index`;
+	});
+}
+//#endregion
+//#region src/runtime/sidebar.ts
+async function generateSidebar(options) {
+	const { contentDir } = options;
+	return scanDirectoryForSidebar(contentDir, contentDir);
+}
+async function scanDirectoryForSidebar(dir, rootDir) {
+	const entries = await readDirectoryEntries$1(dir);
+	const items = [];
+	for (const entry of entries) {
+		const sidebarItem = await createSidebarItemFromEntry({
+			dir,
+			entry,
+			rootDir
+		});
+		if (sidebarItem != null) items.push(sidebarItem);
+	}
+	sortSidebarItems(items);
+	return items.map(({ order: _order, ...item }) => item);
+}
+async function readDirectoryEntries$1(dir) {
+	try {
+		return await fs.readdir(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+async function createSidebarItemFromEntry(params) {
+	const { dir, entry, rootDir } = params;
+	if (isIgnoredEntry(entry.name)) return null;
+	const fullPath = path.join(dir, entry.name);
+	const relativePath = path.relative(rootDir, fullPath);
+	if (entry.isDirectory()) return createDirectorySidebarItem(fullPath, relativePath, rootDir);
+	if (isMarkdownPage(entry.name)) return createMarkdownSidebarItem(fullPath, relativePath, entry.name);
+	return null;
+}
+function isIgnoredEntry(entryName) {
+	return entryName.startsWith(".") || entryName.startsWith("_");
+}
+function isMarkdownPage(entryName) {
+	return entryName.endsWith(".md") && entryName !== "index.md";
+}
+async function createDirectorySidebarItem(fullPath, relativePath, rootDir) {
+	const children = await scanDirectoryForSidebar(fullPath, rootDir);
+	if (children.length === 0) return null;
+	const metadata = await readDirectoryIndexMetadata(fullPath, relativePath);
+	const title = metadata.title ?? formatTitle$2(path.basename(fullPath));
+	return {
+		collapsed: false,
+		items: children,
+		link: metadata.link,
+		order: metadata.order,
+		text: title
+	};
+}
+async function readDirectoryIndexMetadata(fullPath, relativePath) {
+	const frontmatter = await readFrontmatter$1(path.join(fullPath, "index.md"));
+	return {
+		link: frontmatter == null ? void 0 : normalizePath(relativePath),
+		order: frontmatter?.order,
+		title: frontmatter?.title
+	};
+}
+async function createMarkdownSidebarItem(fullPath, relativePath, fileName) {
+	const frontmatter = await readFrontmatter$1(fullPath);
+	if (frontmatter?.sidebar === false) return null;
+	const fallbackTitle = formatTitle$2(fileName.replace(/\.md$/u, ""));
+	const title = frontmatter?.title ?? fallbackTitle;
+	return {
+		link: normalizePath(relativePath.replace(/\.md$/u, "")),
+		order: frontmatter?.order,
+		text: title
+	};
+}
+async function readFrontmatter$1(filePath) {
+	try {
+		return toSidebarFrontmatter(matter(await fs.readFile(filePath, "utf8")).data);
+	} catch {
+		return null;
+	}
+}
+function toSidebarFrontmatter(data) {
+	if (!isRecord$1(data)) return {};
+	return {
+		order: typeof data.order === "number" ? data.order : void 0,
+		sidebar: typeof data.sidebar === "boolean" ? data.sidebar : void 0,
+		title: typeof data.title === "string" ? data.title : void 0
+	};
+}
+function isRecord$1(value) {
+	return value != null && typeof value === "object";
+}
+function sortSidebarItems(items) {
+	items.sort((left, right) => {
+		if (left.order != null && right.order != null) return left.order - right.order;
+		if (left.order != null) return -1;
+		if (right.order != null) return 1;
+		return left.text.localeCompare(right.text);
+	});
+}
+function formatTitle$2(name) {
+	return name.replace(/^\d+-/u, "").replaceAll(/[_-]/gu, " ").replaceAll(/\b\w/gu, (char) => char.toUpperCase());
+}
+function normalizePath(p) {
+	return `/${p.replaceAll("\\", "/").replace(/^\/+/u, "")}`;
+}
+//#endregion
+//#region src/vite/codeblock-scan.ts
+const OPENING_TAG = "<ArdoCodeBlock";
+const CLOSING_TAG = "</ArdoCodeBlock>";
+/**
+* Strips leading/trailing blank lines and removes common leading whitespace.
+* Same logic as the runtime outdent in CodeBlock.tsx.
+*/
 function outdent(text) {
-  const trimmed = text.replace(/^\n+/, "").replace(/\n\s*$/, "");
-  const lines = trimmed.split("\n");
-  const indent = lines.reduce((min, line) => {
-    if (line.trim().length === 0) return min;
-    const match = line.match(/^(\s*)/);
-    return match ? Math.min(min, match[1].length) : min;
-  }, Infinity);
-  if (indent === 0 || indent === Infinity) return trimmed;
-  return lines.map((line) => line.slice(indent)).join("\n");
-}
-function findSelfClosingCodeBlocks(source) {
-  const results = [];
-  const tag = "<CodeBlock";
-  let searchFrom = 0;
-  while (true) {
-    const start = source.indexOf(tag, searchFrom);
-    if (start === -1) break;
-    const afterTag = start + tag.length;
-    if (afterTag >= source.length || !/\s/.test(source[afterTag])) {
-      searchFrom = afterTag;
-      continue;
-    }
-    let i = afterTag;
-    let depth = 0;
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplate = false;
-    let found = false;
-    while (i < source.length) {
-      const ch = source[i];
-      if ((inSingle || inDouble || inTemplate) && ch === "\\") {
-        i += 2;
-        continue;
-      }
-      if (inSingle) {
-        if (ch === "'") inSingle = false;
-        i++;
-        continue;
-      }
-      if (inDouble) {
-        if (ch === '"') inDouble = false;
-        i++;
-        continue;
-      }
-      if (inTemplate) {
-        if (ch === "`") inTemplate = false;
-        i++;
-        continue;
-      }
-      if (ch === "'") {
-        inSingle = true;
-        i++;
-        continue;
-      }
-      if (ch === '"') {
-        inDouble = true;
-        i++;
-        continue;
-      }
-      if (ch === "`") {
-        inTemplate = true;
-        i++;
-        continue;
-      }
-      if (ch === "{") {
-        depth++;
-        i++;
-        continue;
-      }
-      if (ch === "}") {
-        depth--;
-        i++;
-        continue;
-      }
-      if (depth === 0 && ch === "/" && i + 1 < source.length && source[i + 1] === ">") {
-        const fullMatch = source.substring(start, i + 2);
-        const propsStr = source.substring(afterTag, i).trim();
-        results.push({ fullMatch, propsStr, index: start });
-        found = true;
-        searchFrom = i + 2;
-        break;
-      }
-      if (depth === 0 && ch === ">") {
-        searchFrom = i + 1;
-        found = true;
-        break;
-      }
-      i++;
-    }
-    if (!found) break;
-  }
-  return results;
+	const trimmedLines = trimBlankLines(text.split("\n"));
+	if (trimmedLines.length === 0) return "";
+	const commonIndent = getCommonIndent(trimmedLines);
+	if (commonIndent === 0) return trimmedLines.join("\n");
+	return trimmedLines.map((line) => stripIndent(line, commonIndent)).join("\n");
+}
+function trimBlankLines(lines) {
+	const result = [...lines];
+	while (result.length > 0 && result[0].trim().length === 0) result.shift();
+	while (result.length > 0 && result.at(-1)?.trim().length === 0) result.pop();
+	return result;
+}
+function getCommonIndent(lines) {
+	let minIndent = Number.POSITIVE_INFINITY;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const indent = getLeadingWhitespaceLength(line);
+		if (indent < minIndent) minIndent = indent;
+	}
+	return Number.isFinite(minIndent) ? minIndent : 0;
+}
+function stripIndent(line, commonIndent) {
+	const availableIndent = getLeadingWhitespaceLength(line);
+	const removeCount = Math.min(commonIndent, availableIndent);
+	return line.slice(removeCount);
+}
+function getLeadingWhitespaceLength(line) {
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (char !== " " && char !== "	") break;
+		index++;
+	}
+	return index;
+}
+/**
+* Finds all `<ArdoCodeBlock ... />` and `<ArdoCodeBlock ...>...</ArdoCodeBlock>` tags
+* by scanning for balanced quotes and braces.
+*/
+function scanArdoCodeBlocks(source) {
+	const blocks = [];
+	let cursor = 0;
+	while (cursor < source.length) {
+		const scanResult = scanNextCodeBlock(source, cursor);
+		if (scanResult == null) break;
+		const { block, nextCursor } = scanResult;
+		if (block != null) blocks.push(block);
+		cursor = nextCursor;
+	}
+	return blocks;
+}
+function scanNextCodeBlock(source, cursor) {
+	const start = source.indexOf(OPENING_TAG, cursor);
+	if (start === -1) return null;
+	const opening = scanOpeningTag(source, start);
+	if (opening == null) return {
+		block: null,
+		nextCursor: start + 14
+	};
+	const block = createScannedBlock(source, start, opening);
+	if (block == null) return null;
+	return {
+		block,
+		nextCursor: block.end
+	};
+}
+function scanOpeningTag(source, start) {
+	const afterTag = start + 14;
+	if (!isWhitespaceChar(source[afterTag])) return null;
+	let index = afterTag;
+	let braceDepth = 0;
+	let quote = null;
+	while (index < source.length) {
+		const step = advanceOpeningTagScan(source, {
+			braceDepth,
+			index,
+			quote
+		});
+		if (step.tagEndIndex != null) return finalizeOpeningTag(source, afterTag, step.tagEndIndex);
+		index = step.nextIndex;
+		braceDepth = step.nextBraceDepth;
+		quote = step.nextQuote;
+	}
+	return null;
+}
+function finalizeOpeningTag(source, afterTag, endBracketIndex) {
+	const isSelfClosing = source[endBracketIndex - 1] === "/";
+	const propsEnd = isSelfClosing ? endBracketIndex - 1 : endBracketIndex;
+	const props = source.slice(afterTag, propsEnd).trim();
+	return {
+		end: endBracketIndex + 1,
+		isSelfClosing,
+		props
+	};
+}
+function advanceOpeningTagScan(source, state) {
+	const { braceDepth, index, quote } = state;
+	if (quote != null) return scanQuotedStep(source, {
+		braceDepth,
+		index,
+		quote
+	});
+	return scanUnquotedStep(source, index, braceDepth);
+}
+function scanQuotedStep(source, state) {
+	const { braceDepth, index, quote } = state;
+	if (source[index] === "\\") return {
+		nextBraceDepth: braceDepth,
+		nextIndex: Math.min(source.length, index + 2),
+		nextQuote: quote,
+		tagEndIndex: null
+	};
+	const closesQuote = source[index] === quote;
+	return {
+		nextBraceDepth: braceDepth,
+		nextIndex: index + 1,
+		nextQuote: closesQuote ? null : quote,
+		tagEndIndex: null
+	};
+}
+function scanUnquotedStep(source, index, braceDepth) {
+	const char = source[index];
+	if (isQuote(char)) return makeScanStep(index + 1, braceDepth, char);
+	if (char === "{") return makeScanStep(index + 1, braceDepth + 1, null);
+	if (char === "}") return makeScanStep(index + 1, Math.max(0, braceDepth - 1), null);
+	if (braceDepth === 0 && char === ">") return {
+		nextBraceDepth: braceDepth,
+		nextIndex: index + 1,
+		nextQuote: null,
+		tagEndIndex: index
+	};
+	return makeScanStep(index + 1, braceDepth, null);
+}
+function makeScanStep(nextIndex, nextBraceDepth, nextQuote) {
+	return {
+		nextBraceDepth,
+		nextIndex,
+		nextQuote,
+		tagEndIndex: null
+	};
+}
+function createScannedBlock(source, start, opening) {
+	if (opening.isSelfClosing) return {
+		children: null,
+		end: opening.end,
+		fullMatch: source.slice(start, opening.end),
+		props: opening.props,
+		start
+	};
+	const closeStart = source.indexOf(CLOSING_TAG, opening.end);
+	if (closeStart === -1) return null;
+	const end = closeStart + 16;
+	return {
+		children: source.slice(opening.end, closeStart),
+		end,
+		fullMatch: source.slice(start, end),
+		props: opening.props,
+		start
+	};
+}
+function isQuote(char) {
+	return char === "'" || char === "\"" || char === "`";
+}
+function isWhitespaceChar(char) {
+	return char === " " || char === "\n" || char === "\r" || char === "	";
+}
+//#endregion
+//#region src/vite/codeblock-transform.ts
+async function transformArdoCodeBlocks(source, markdownConfig) {
+	let result = source;
+	let offset = 0;
+	const blocks = scanArdoCodeBlocks(source);
+	for (const block of blocks) {
+		const replacement = await createReplacement(block, markdownConfig);
+		if (replacement == null) continue;
+		const adjustedStart = block.start + offset;
+		const adjustedEnd = block.end + offset;
+		result = result.slice(0, adjustedStart) + replacement + result.slice(adjustedEnd);
+		offset += replacement.length - block.fullMatch.length;
+	}
+	return result;
+}
+async function createReplacement(block, markdownConfig) {
+	if (block.props.includes("__html")) return null;
+	if (block.children == null) return createSelfClosingReplacement(block, markdownConfig);
+	return createChildrenReplacement(block, markdownConfig);
+}
+async function createSelfClosingReplacement(block, markdownConfig) {
+	const codeValue = extractCodeValue(block.props);
+	const language = extractPropValue(block.props, "language");
+	if (codeValue == null || language == null) return null;
+	const html = await safeHighlightCode(codeValue, language, markdownConfig);
+	if (html == null) return null;
+	const newProps = `__html={${JSON.stringify(html)}} ${block.props}`;
+	return block.fullMatch.replace(block.props, newProps);
 }
+async function createChildrenReplacement(block, markdownConfig) {
+	const language = extractPropValue(block.props, "language");
+	if (language == null || block.children == null) return null;
+	const codeContent = outdent(unwrapTemplateChildren(block.children));
+	const html = await safeHighlightCode(codeContent, language, markdownConfig);
+	if (html == null) return null;
+	return `<ArdoCodeBlock __html={${JSON.stringify(html)}} code={${JSON.stringify(codeContent)}} ${block.props} />`;
+}
+function unwrapTemplateChildren(rawChildren) {
+	const trimmed = rawChildren.trim();
+	if (!trimmed.startsWith("{`") || !trimmed.endsWith("`}")) return rawChildren;
+	return trimmed.slice(2, -2);
+}
+function extractCodeValue(props) {
+	const code = extractPropValue(props, "code");
+	if (code == null) return null;
+	return decodeEscapedString(code);
+}
+function decodeEscapedString(value) {
+	return value.replaceAll("\\n", "\n").replaceAll("\\\"", "\"").replaceAll("\\\\", "\\");
+}
+function extractPropValue(props, propName) {
+	const patterns = getPropPatterns(propName);
+	for (const pattern of patterns) {
+		const match = pattern.exec(props);
+		if (match?.[1] != null) return match[1];
+	}
+	return null;
+}
+function getPropPatterns(propName) {
+	return [
+		new RegExp(`\\b${propName}="((?:[^"\\\\]|\\\\.)*)"`, "su"),
+		new RegExp(`\\b${propName}=\\{\\s*"((?:[^"\\\\]|\\\\.)*)"\\s*\\}`, "su"),
+		new RegExp(`\\b${propName}=\\{\\s*'((?:[^'\\\\]|\\\\.)*)'\\s*\\}`, "su")
+	];
+}
+async function safeHighlightCode(codeContent, language, markdownConfig) {
+	try {
+		return await highlightCode(codeContent, language, { theme: markdownConfig?.theme });
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/vite/codeblock-plugin.ts
+/**
+* Vite plugin that pre-highlights ArdoCodeBlock components at build time.
+*
+* Runs before the JSX parser, so children can contain arbitrary code
+* (including `<`, `{`, etc.) without causing syntax errors.
+*/
 function ardoCodeBlockPlugin(markdownConfig) {
-  return {
-    name: "ardo:codeblock-highlight",
-    enforce: "pre",
-    async transform(code, id) {
-      if (!/\.[jt]sx$/.test(id)) return;
-      if (!code.includes("CodeBlock")) return;
-      if (id.includes("node_modules")) return;
-      let result = code;
-      let offset = 0;
-      const propMatches = findSelfClosingCodeBlocks(code);
-      for (const match of propMatches) {
-        const { fullMatch, propsStr } = match;
-        const codeMatch = propsStr.match(/\bcode="((?:[^"\\]|\\.)*)"/s) || propsStr.match(/\bcode=\{\s*"((?:[^"\\]|\\.)*)"\s*\}/s) || propsStr.match(/\bcode=\{\s*'((?:[^'\\]|\\.)*)'\s*\}/s);
-        if (!codeMatch) continue;
-        const langMatch = propsStr.match(/\blanguage="([^"]*)"/) || propsStr.match(/\blanguage=\{"([^"]*)"\}/) || propsStr.match(/\blanguage=\{'([^']*)'\}/);
-        if (!langMatch) continue;
-        if (propsStr.includes("__html")) continue;
-        const codeContent = codeMatch[1].replace(/\\n/g, "\n").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-        const language = langMatch[1];
-        try {
-          const html = await highlightCode(codeContent, language, {
-            theme: markdownConfig?.theme
-          });
-          const escapedHtml = JSON.stringify(html);
-          const newPropsStr = `__html={${escapedHtml}} ` + propsStr;
-          const newFullMatch = fullMatch.replace(propsStr, newPropsStr);
-          result = result.slice(0, match.index + offset) + newFullMatch + result.slice(match.index + offset + fullMatch.length);
-          offset += newFullMatch.length - fullMatch.length;
-        } catch {
-        }
-      }
-      const childrenRegex = /<CodeBlock\s+([^>]*?)>([\s\S]*?)<\/CodeBlock>/g;
-      offset = result.length - code.length;
-      let regexMatch;
-      while ((regexMatch = childrenRegex.exec(code)) !== null) {
-        const fullMatch = regexMatch[0];
-        const propsStr = regexMatch[1];
-        let rawChildren = regexMatch[2];
-        const langMatch = propsStr.match(/\blanguage="([^"]*)"/) || propsStr.match(/\blanguage=\{"([^"]*)"\}/) || propsStr.match(/\blanguage=\{'([^']*)'\}/);
-        if (!langMatch) continue;
-        if (propsStr.includes("__html")) continue;
-        const templateMatch = rawChildren.match(/^\s*\{`([\s\S]*)`\}\s*$/);
-        if (templateMatch) {
-          rawChildren = templateMatch[1];
-        }
-        const codeContent = outdent(rawChildren);
-        const language = langMatch[1];
-        try {
-          const html = await highlightCode(codeContent, language, {
-            theme: markdownConfig?.theme
-          });
-          const escapedHtml = JSON.stringify(html);
-          const escapedCode = JSON.stringify(codeContent);
-          const newTag = `<CodeBlock __html={${escapedHtml}} code={${escapedCode}} ${propsStr} />`;
-          result = result.slice(0, regexMatch.index + offset) + newTag + result.slice(regexMatch.index + offset + fullMatch.length);
-          offset += newTag.length - fullMatch.length;
-        } catch {
-        }
-      }
-      if (result !== code) {
-        return { code: result, map: null };
-      }
-    }
-  };
+	return {
+		enforce: "pre",
+		name: "ardo:codeblock-highlight",
+		async transform(code, id) {
+			if (!shouldProcessFile(code, id)) return;
+			const transformed = await transformArdoCodeBlocks(code, markdownConfig);
+			if (transformed === code) return;
+			return {
+				code: transformed,
+				map: null
+			};
+		}
+	};
 }
-
-// src/vite/plugin.ts
+function shouldProcessFile(code, id) {
+	if (!/\.[jt]sx$/u.test(id)) return false;
+	if (id.includes("node_modules")) return false;
+	return code.includes("ArdoCodeBlock");
+}
+//#endregion
+//#region src/vite/git-utils.ts
+/**
+* Finds the package root by looking for package.json in parent directories.
+* Returns the path relative to cwd, or undefined if not found.
+*/
 function findPackageRoot(cwd) {
-  let dir = path2.resolve(cwd);
-  const root = path2.parse(dir).root;
-  while (dir !== root) {
-    const parentDir = path2.dirname(dir);
-    const packageJsonPath = path2.join(parentDir, "package.json");
-    if (fsSync2.existsSync(packageJsonPath)) {
-      return path2.relative(cwd, parentDir) || ".";
-    }
-    dir = parentDir;
-  }
-  return void 0;
+	let currentDir = path.resolve(cwd);
+	const filesystemRoot = path.parse(currentDir).root;
+	while (currentDir !== filesystemRoot) {
+		const parentDir = path.dirname(currentDir);
+		const packageJsonPath = path.join(parentDir, "package.json");
+		if (fsSync.existsSync(packageJsonPath)) {
+			const relativePath = path.relative(cwd, parentDir);
+			return relativePath === "" ? "." : relativePath;
+		}
+		currentDir = parentDir;
+	}
 }
+/**
+* Detects the GitHub repository name from git remote URL.
+* Returns the repo name (e.g., "ardo" from "github.com/sebastian-software/ardo")
+* or undefined if not a GitHub repo.
+*/
 function detectGitHubRepoName(cwd) {
-  try {
-    const remoteUrl = execSync("git remote get-url origin", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const match = remoteUrl.match(/github\.com[/:][\w-]+\/([\w.-]+?)(?:\.git)?$/);
-    return match?.[1];
-  } catch {
-    return void 0;
-  }
+	const remoteUrl = runGitCommand(cwd, "git remote get-url origin");
+	if (remoteUrl == null) return;
+	return parseGitHubRepoName(remoteUrl);
 }
+/**
+* Detects the current short git commit hash.
+*/
 function detectGitHash(cwd) {
-  try {
-    return execSync("git rev-parse --short HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return void 0;
-  }
+	return runGitCommand(cwd, "git rev-parse --short HEAD");
 }
-function readProjectMeta(root) {
-  const pkgPath = path2.join(root, "package.json");
-  try {
-    const raw = fsSync2.readFileSync(pkgPath, "utf-8");
-    const pkg = JSON.parse(raw);
-    let repository;
-    if (typeof pkg.repository === "string") {
-      repository = pkg.repository;
-    } else if (pkg.repository?.url) {
-      repository = pkg.repository.url.replace(/^git\+/, "").replace(/^git:\/\//, "https://").replace(/\.git$/, "");
-    }
-    let author;
-    if (typeof pkg.author === "string") {
-      author = pkg.author;
-    } else if (pkg.author?.name) {
-      author = pkg.author.name;
-    }
-    return {
-      name: pkg.name,
-      homepage: pkg.homepage,
-      repository,
-      version: pkg.version,
-      author,
-      license: pkg.license
-    };
-  } catch {
-    return {};
-  }
+/**
+* Detects the GitHub Pages basename from the git remote URL.
+* Returns "/" in dev mode or when no GitHub repo is detected.
+*/
+function detectGitHubBasename(cwd) {
+	if (process.env.NODE_ENV !== "production") return "/";
+	const repoName = detectGitHubRepoName(cwd ?? process.cwd());
+	return repoName != null ? `/${repoName}/` : "/";
 }
+/**
+* Recursively copies files from src to dest, overwriting existing files.
+*/
 function copyRecursive(src, dest) {
-  const stat = fsSync2.statSync(src);
-  if (stat.isDirectory()) {
-    if (!fsSync2.existsSync(dest)) {
-      fsSync2.mkdirSync(dest, { recursive: true });
-    }
-    for (const item of fsSync2.readdirSync(src)) {
-      copyRecursive(path2.join(src, item), path2.join(dest, item));
-    }
-  } else {
-    fsSync2.copyFileSync(src, dest);
-  }
+	if (!fsSync.statSync(src).isDirectory()) {
+		fsSync.copyFileSync(src, dest);
+		return;
+	}
+	if (!fsSync.existsSync(dest)) fsSync.mkdirSync(dest, { recursive: true });
+	for (const item of fsSync.readdirSync(src)) copyRecursive(path.join(src, item), path.join(dest, item));
 }
-function detectGitHubBasename(cwd) {
-  if (process.env.NODE_ENV !== "production") {
-    return "/";
-  }
-  const repoName = detectGitHubRepoName(cwd || process.cwd());
-  return repoName ? `/${repoName}/` : "/";
-}
-var VIRTUAL_MODULE_ID = "virtual:ardo/config";
-var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-var VIRTUAL_SIDEBAR_ID = "virtual:ardo/sidebar";
-var RESOLVED_VIRTUAL_SIDEBAR_ID = "\0" + VIRTUAL_SIDEBAR_ID;
-var VIRTUAL_SEARCH_ID = "virtual:ardo/search-index";
-var RESOLVED_VIRTUAL_SEARCH_ID = "\0" + VIRTUAL_SEARCH_ID;
-var typedocGenerated = false;
-var flattenExecuted = false;
-function ardoPlugin(options = {}) {
-  let resolvedConfig;
-  let routesDir;
-  const {
-    routes,
-    typedoc,
-    githubPages = true,
-    routesDir: routesDirOption,
-    ...pressConfig
-  } = options;
-  const mainPlugin = {
-    name: "ardo",
-    enforce: "pre",
-    config(userConfig, env) {
-      const root = userConfig.root || process.cwd();
-      routesDir = routesDirOption || path2.join(root, "app", "routes");
-      const result = {
-        define: {
-          __BUILD_TIME__: JSON.stringify((/* @__PURE__ */ new Date()).toISOString())
-        },
-        optimizeDeps: {
-          exclude: ["ardo/ui/styles.css"]
-        },
-        ssr: {
-          noExternal: ["ardo"]
-        }
-      };
-      if (githubPages && env.command === "build" && !userConfig.base) {
-        const repoName = detectGitHubRepoName(root);
-        if (repoName) {
-          result.base = `/${repoName}/`;
-          console.log(`[ardo] GitHub Pages detected, using base: ${result.base}`);
-        }
-      }
-      return result;
-    },
-    async configResolved(config) {
-      const root = config.root;
-      routesDir = routesDirOption || path2.join(root, "app", "routes");
-      const detectedProject = readProjectMeta(root);
-      const project = { ...detectedProject, ...pressConfig.project };
-      const defaultConfig = {
-        title: pressConfig.title ?? "Ardo",
-        description: pressConfig.description ?? "Documentation powered by Ardo"
-      };
-      const configWithRoutes = {
-        ...defaultConfig,
-        ...pressConfig,
-        project,
-        srcDir: routesDir
-      };
-      resolvedConfig = resolveConfig(configWithRoutes, root);
-    },
-    resolveId(id) {
-      if (id === VIRTUAL_MODULE_ID) {
-        return RESOLVED_VIRTUAL_MODULE_ID;
-      }
-      if (id === VIRTUAL_SIDEBAR_ID) {
-        return RESOLVED_VIRTUAL_SIDEBAR_ID;
-      }
-      if (id === VIRTUAL_SEARCH_ID) {
-        return RESOLVED_VIRTUAL_SEARCH_ID;
-      }
-    },
-    async load(id) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        const clientConfig = {
-          title: resolvedConfig.title,
-          description: resolvedConfig.description,
-          base: resolvedConfig.base,
-          lang: resolvedConfig.lang,
-          themeConfig: resolvedConfig.themeConfig,
-          project: resolvedConfig.project,
-          buildTime: (/* @__PURE__ */ new Date()).toISOString(),
-          buildHash: detectGitHash(resolvedConfig.root)
-        };
-        return `export default ${JSON.stringify(clientConfig)}`;
-      }
-      if (id === RESOLVED_VIRTUAL_SIDEBAR_ID) {
-        const sidebar = await generateSidebar(resolvedConfig, routesDir);
-        return `export default ${JSON.stringify(sidebar)}`;
-      }
-      if (id === RESOLVED_VIRTUAL_SEARCH_ID) {
-        const searchIndex = await generateSearchIndex(routesDir);
-        return `export default ${JSON.stringify(searchIndex)}`;
-      }
-    },
-    transform(code, id) {
-      if (!/\.(mdx|md)$/.test(id)) return;
-      if (!id.startsWith(routesDir)) return;
-      if (/export\s+(const|function)\s+meta\b/.test(code)) return;
-      const titleMatch = code.match(
-        /export\s+const\s+frontmatter\s*=\s*\{[^}]*title\s*:\s*"([^"]*)"/
-      );
-      const descMatch = code.match(
-        /export\s+const\s+frontmatter\s*=\s*\{[^}]*description\s*:\s*"([^"]*)"/
-      );
-      const pageTitle = titleMatch?.[1];
-      if (!pageTitle) return;
-      const siteTitle = resolvedConfig.title;
-      const separator = resolvedConfig.titleSeparator;
-      const fullTitle = `${pageTitle}${separator}${siteTitle}`;
-      const description = descMatch?.[1];
-      const metaEntries = [`{ title: ${JSON.stringify(fullTitle)} }`];
-      if (description) {
-        metaEntries.push(`{ name: "description", content: ${JSON.stringify(description)} }`);
-      }
-      return {
-        code: `${code}
-export const meta = () => [${metaEntries.join(", ")}];
-`,
-        map: null
-      };
-    }
-  };
-  const plugins = [mainPlugin];
-  if (routes !== false) {
-    plugins.push(
-      ardoRoutesPlugin({
-        routesDir: routesDirOption,
-        ...routes
-      })
-    );
-  }
-  if (typedoc) {
-    const packageRoot = findPackageRoot(process.cwd());
-    const defaultEntryPoint = packageRoot ? `${packageRoot}/src/index.ts` : "./src/index.ts";
-    const defaultTsconfig = packageRoot ? `${packageRoot}/tsconfig.json` : "./tsconfig.json";
-    const defaultTypedocConfig = {
-      enabled: true,
-      entryPoints: [defaultEntryPoint],
-      tsconfig: defaultTsconfig,
-      out: "api-reference",
-      excludePrivate: true,
-      excludeInternal: true
-    };
-    const typedocConfig = typedoc === true ? defaultTypedocConfig : { ...defaultTypedocConfig, ...typedoc };
-    const typedocPlugin = {
-      name: "ardo:typedoc",
-      async buildStart() {
-        if (typedocGenerated || !typedocConfig.enabled) {
-          return;
-        }
-        console.log("[ardo] Generating API documentation with TypeDoc...");
-        const startTime = Date.now();
-        try {
-          const outputDir = routesDirOption || "./app/routes";
-          const docs = await generateApiDocs(typedocConfig, outputDir);
-          const duration = Date.now() - startTime;
-          console.log(`[ardo] Generated ${docs.length} API documentation pages in ${duration}ms`);
-        } catch (error) {
-          console.warn("[ardo] TypeDoc generation failed. API documentation will not be available.");
-          console.warn("[ardo] Check your typedoc.entryPoints configuration.");
-          if (error instanceof Error) {
-            console.warn(`[ardo] Error: ${error.message}`);
-          }
-        }
-        typedocGenerated = true;
-      }
-    };
-    plugins.unshift(typedocPlugin);
-  }
-  plugins.push(ardoCodeBlockPlugin(pressConfig.markdown));
-  const themeConfig = pressConfig.markdown?.theme ?? defaultMarkdownConfig.theme;
-  const hasThemeObject = themeConfig && typeof themeConfig === "object" && "light" in themeConfig;
-  const lineNumbers = pressConfig.markdown?.lineNumbers || false;
-  const shikiOptions = hasThemeObject ? {
-    themes: {
-      light: themeConfig.light,
-      dark: themeConfig.dark
-    },
-    defaultColor: false,
-    transformers: [ardoLineTransformer({ globalLineNumbers: lineNumbers })]
-  } : {
-    theme: themeConfig,
-    transformers: [ardoLineTransformer({ globalLineNumbers: lineNumbers })]
-  };
-  const mdxPlugin = mdx({
-    include: /\.(md|mdx)$/,
-    remarkPlugins: [
-      remarkFrontmatter,
-      [remarkMdxFrontmatter, { name: "frontmatter" }],
-      remarkGfm,
-      remarkCodeMeta
-    ],
-    rehypePlugins: [[rehypeShiki, shikiOptions]],
-    providerImportSource: "ardo/mdx-provider"
-  });
-  plugins.push(mdxPlugin);
-  plugins.push(...vanillaExtractPlugin());
-  const reactRouterPlugin = reactRouter();
-  const reactRouterPlugins = (Array.isArray(reactRouterPlugin) ? reactRouterPlugin : [reactRouterPlugin]).filter((p) => p != null);
-  plugins.push(...reactRouterPlugins);
-  if (githubPages) {
-    let detectedBase;
-    const flattenPlugin = {
-      name: "ardo:flatten-github-pages",
-      enforce: "post",
-      configResolved(config) {
-        if (config.base && config.base !== "/") {
-          detectedBase = config.base;
-        }
-      },
-      closeBundle() {
-        if (flattenExecuted || !detectedBase) {
-          return;
-        }
-        const baseName = detectedBase.replace(/^\/|\/$/g, "");
-        if (!baseName) return;
-        const buildDir = path2.join(process.cwd(), "build", "client");
-        const nestedDir = path2.join(buildDir, baseName);
-        if (!fsSync2.existsSync(nestedDir)) {
-          return;
-        }
-        console.log(`[ardo] Flattening build/client/${baseName}/ to build/client/ for GitHub Pages`);
-        copyRecursive(nestedDir, buildDir);
-        fsSync2.rmSync(nestedDir, { recursive: true, force: true });
-        console.log("[ardo] Build output flattened successfully.");
-        flattenExecuted = true;
-      }
-    };
-    plugins.push(flattenPlugin);
-  }
-  return plugins;
-}
-async function generateSidebar(config, routesDir) {
-  const { themeConfig } = config;
-  if (themeConfig.sidebar && !Array.isArray(themeConfig.sidebar)) {
-    return themeConfig.sidebar;
-  }
-  if (themeConfig.sidebar && Array.isArray(themeConfig.sidebar) && themeConfig.sidebar.length > 0) {
-    return themeConfig.sidebar;
-  }
-  try {
-    const sidebar = await scanDirectory(routesDir, routesDir);
-    return sidebar;
-  } catch {
-    return [];
-  }
-}
-async function scanDirectory(dir, rootDir) {
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
-  const items = [];
-  for (const entry of entries) {
-    const fullPath = path2.join(dir, entry.name);
-    const relativePath = path2.relative(rootDir, fullPath);
-    if (entry.isDirectory()) {
-      const children = await scanDirectory(fullPath, rootDir);
-      if (children.length > 0) {
-        const indexPath = path2.join(fullPath, "index.mdx");
-        let link;
-        try {
-          await fs2.access(indexPath);
-          link = "/" + relativePath.replace(/\\/g, "/");
-        } catch {
-        }
-        items.push({
-          text: formatTitle(entry.name),
-          link,
-          items: children
-        });
-      }
-    } else if ((entry.name.endsWith(".mdx") || entry.name.endsWith(".md")) && entry.name !== "index.mdx" && entry.name !== "index.md") {
-      const fileContent = await fs2.readFile(fullPath, "utf-8");
-      const { data: frontmatter } = matter(fileContent);
-      const ext = entry.name.endsWith(".mdx") ? ".mdx" : ".md";
-      const title = frontmatter.title || formatTitle(entry.name.replace(ext, ""));
-      const order = typeof frontmatter.order === "number" ? frontmatter.order : void 0;
-      const link = "/" + relativePath.replace(ext, "").replace(/\\/g, "/");
-      items.push({
-        text: title,
-        link,
-        order
-      });
-    }
-  }
-  items.sort((a, b) => {
-    if (a.order !== void 0 && b.order !== void 0) {
-      return a.order - b.order;
-    }
-    if (a.order !== void 0) return -1;
-    if (b.order !== void 0) return 1;
-    return a.text.localeCompare(b.text);
-  });
-  return items.map(({ order: _order, ...item }) => item);
+function runGitCommand(cwd, command) {
+	try {
+		const commandResult = execSync(command, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+		return commandResult === "" ? void 0 : commandResult;
+	} catch {
+		return;
+	}
 }
-function formatTitle(name) {
-  return name.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+function parseGitHubRepoName(remoteUrl) {
+	const normalizedUrl = remoteUrl.trim();
+	if (!normalizedUrl.includes("github.com")) return;
+	const urlSegments = (normalizedUrl.endsWith(".git") ? normalizedUrl.slice(0, -4) : normalizedUrl).replace(":", "/").split("/");
+	const repoName = urlSegments.at(-1);
+	const ownerName = urlSegments.at(-2);
+	if (repoName == null || repoName === "" || ownerName == null || ownerName === "") return;
+	return repoName;
 }
-async function generateSearchIndex(routesDir) {
-  const docs = [];
-  async function scanForSearch(dir, section) {
-    try {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          const newSection = section ? `${section} > ${formatTitle(entry.name)}` : formatTitle(entry.name);
-          await scanForSearch(fullPath, newSection);
-        } else if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md")) {
-          const relativePath = path2.relative(routesDir, fullPath);
-          const fileContent = await fs2.readFile(fullPath, "utf-8");
-          const { data: frontmatter, content: rawContent } = matter(fileContent);
-          const ext = entry.name.endsWith(".mdx") ? ".mdx" : ".md";
-          const title = frontmatter.title || formatTitle(entry.name.replace(ext, ""));
-          let content = rawContent;
-          content = content.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").replace(/import\s+.*?from\s+['"].*?['"]/g, "").replace(/<[^>]+>/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[#*_~>]/g, "").replace(/\n+/g, " ").replace(/\s+/g, " ").trim().slice(0, 2e3);
-          const routePath = entry.name === "index.mdx" || entry.name === "index.md" ? "/" + path2.dirname(relativePath).replace(/\\/g, "/") : "/" + relativePath.replace(ext, "").replace(/\\/g, "/");
-          const finalPath = routePath === "/." ? "/" : routePath;
-          docs.push({
-            id: relativePath,
-            title,
-            content,
-            path: finalPath,
-            section
-          });
-        }
-      }
-    } catch (error) {
-      console.warn(
-        "[ardo] Failed to scan for search index:",
-        error instanceof Error ? error.message : error
-      );
-    }
-  }
-  await scanForSearch(routesDir);
-  return docs;
+//#endregion
+//#region src/vite/flatten-plugin.ts
+let flattenExecuted = false;
+function createFlattenPlugin() {
+	let detectedBase;
+	return {
+		name: "ardo:flatten-github-pages",
+		enforce: "post",
+		configResolved(config) {
+			detectedBase = config.base === "/" ? void 0 : config.base;
+		},
+		closeBundle() {
+			if (flattenExecuted || detectedBase == null) return;
+			const baseName = trimSlashes(detectedBase);
+			if (baseName === "") return;
+			const buildDir = path.join(process.cwd(), "build", "client");
+			const nestedDir = path.join(buildDir, baseName);
+			if (!fsSync.existsSync(nestedDir)) return;
+			console.log(`[ardo] Flattening build/client/${baseName}/ to build/client/ for GitHub Pages`);
+			copyRecursive(nestedDir, buildDir);
+			fsSync.rmSync(nestedDir, {
+				recursive: true,
+				force: true
+			});
+			console.log("[ardo] Build output flattened successfully.");
+			flattenExecuted = true;
+		}
+	};
 }
-
-// src/runtime/loader.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-
-// src/markdown/pipeline.ts
-import { unified } from "unified";
-import remarkParse from "remark-parse";
-import remarkGfm2 from "remark-gfm";
-import remarkFrontmatter2 from "remark-frontmatter";
-import remarkRehype from "remark-rehype";
-import rehypeStringify from "rehype-stringify";
-import matter2 from "gray-matter";
-
-// src/markdown/toc.ts
-import { visit as visit2 } from "unist-util-visit";
-function remarkExtractToc(options) {
-  const { tocExtraction, levels } = options;
-  const [minLevel, maxLevel] = levels;
-  return function(tree) {
-    const headings = [];
-    let headingIndex = 0;
-    visit2(tree, "heading", (node) => {
-      if (node.depth < minLevel || node.depth > maxLevel) {
-        return;
-      }
-      const text = getHeadingText(node);
-      const slug = slugify(text);
-      const id = slug || `heading-${headingIndex}`;
-      headingIndex++;
-      headings.push({
-        text,
-        level: node.depth,
-        id
-      });
-      const data = node.data || (node.data = {});
-      const hProperties = data.hProperties || (data.hProperties = {});
-      hProperties.id = id;
-    });
-    tocExtraction.toc = buildTocTree(headings, minLevel);
-  };
+function trimSlashes(value) {
+	let trimmed = value;
+	while (trimmed.startsWith("/")) trimmed = trimmed.slice(1);
+	while (trimmed.endsWith("/")) trimmed = trimmed.slice(0, -1);
+	return trimmed;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-util-value-to-estree@3.5.0/node_modules/estree-util-value-to-estree/dist/estree-util-value-to-estree.js
+/**
+* Create an ESTree identifier node for a given name.
+*
+* @param name
+*   The name of the identifier.
+* @returns
+*   The identifier node.
+*/
+function identifier(name) {
+	return {
+		type: "Identifier",
+		name
+	};
+}
+/**
+* Create an ESTree literal node for a given value.
+*
+* @param value
+*   The value for which to create a literal.
+* @returns
+*   The literal node.
+*/
+function literal(value) {
+	return {
+		type: "Literal",
+		value
+	};
+}
+/**
+* Create an ESTree call expression on an object member.
+*
+* @param object
+*   The object to call the method on.
+* @param name
+*   The name of the method to call.
+* @param args
+*   Arguments to pass to the function call
+* @returns
+*   The call expression node.
+*/
+function methodCall(object, name, args) {
+	return {
+		type: "CallExpression",
+		optional: false,
+		callee: {
+			type: "MemberExpression",
+			computed: false,
+			optional: false,
+			object,
+			property: identifier(name)
+		},
+		arguments: args
+	};
+}
+/**
+* Turn a number or bigint into an ESTree expression. This handles positive and negative numbers and
+* bigints as well as special numbers.
+*
+* @param number
+*   The value to turn into an ESTree expression.
+* @returns
+*   An expression that represents the given value.
+*/
+function processNumber(number) {
+	if (number < 0 || Object.is(number, -0)) return {
+		type: "UnaryExpression",
+		operator: "-",
+		prefix: true,
+		argument: processNumber(-number)
+	};
+	if (typeof number === "bigint") return {
+		type: "Literal",
+		bigint: String(number)
+	};
+	if (number === Number.POSITIVE_INFINITY || Number.isNaN(number)) return identifier(String(number));
+	return literal(number);
+}
+/**
+* Process an array of numbers. This is a shortcut for iterables whose constructor takes an array of
+* numbers as input.
+*
+* @param numbers
+*   The numbers to add to the array expression.
+* @returns
+*   An ESTree array expression whose elements match the input numbers.
+*/
+function processNumberArray(numbers) {
+	return {
+		type: "ArrayExpression",
+		elements: Array.from(numbers, processNumber)
+	};
+}
+/**
+* Check whether a value can be constructed from its string representation.
+*
+* @param value
+*   The value to check
+* @returns
+*   Whether or not the value can be constructed from its string representation.
+*/
+function isStringReconstructable(value) {
+	return value instanceof URL || value instanceof URLSearchParams;
+}
+/**
+* Check whether a value can be constructed from its `valueOf()` result.
+*
+* @param value
+*   The value to check
+* @returns
+*   Whether or not the value can be constructed from its `valueOf()` result.
+*/
+function isValueReconstructable(value) {
+	return value instanceof Boolean || value instanceof Date || value instanceof Number || value instanceof String;
+}
+const wellKnownSymbols = /* @__PURE__ */ new Map();
+for (const name of Reflect.ownKeys(Symbol)) {
+	const value = Symbol[name];
+	if (typeof value === "symbol") wellKnownSymbols.set(value, name);
+}
+/**
+* Check whether a value is a Temporal value.
+*
+* @param value
+*   The value to check
+* @returns
+*   Whether or not the value is a Temporal value.
+*/
+function isTemporal(value) {
+	return typeof Temporal !== "undefined" && (value instanceof Temporal.Duration || value instanceof Temporal.Instant || value instanceof Temporal.PlainDate || value instanceof Temporal.PlainDateTime || value instanceof Temporal.PlainYearMonth || value instanceof Temporal.PlainMonthDay || value instanceof Temporal.PlainTime || value instanceof Temporal.ZonedDateTime);
+}
+/**
+* Check whether a value is a typed array.
+*
+* @param value
+*   The value to check
+* @returns
+*   Whether or not the value is a typed array.
+*/
+function isTypedArray(value) {
+	return value instanceof BigInt64Array || value instanceof BigUint64Array || typeof Float16Array !== "undefined" && value instanceof Float16Array || value instanceof Float32Array || value instanceof Float64Array || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Uint16Array || value instanceof Uint32Array;
+}
+/**
+* Compare two value contexts for sorting them based on reference count.
+*
+* @param a
+*   The first context to compare.
+* @param b
+*   The second context to compare.
+* @returns
+*   The count of context a minus the count of context b.
+*/
+function compareContexts(a, b) {
+	const aReferencedByB = a.referencedBy.has(b.value);
+	const bReferencedByA = b.referencedBy.has(a.value);
+	if (aReferencedByB) {
+		if (bReferencedByA) return a.count - b.count;
+		return -1;
+	}
+	if (bReferencedByA) return 1;
+	return a.count - b.count;
+}
+/**
+* Replace the assigned right hand expression with the new expression.
+*
+* If there is no assignment expression, the original expression is returned. Otherwise the
+* assignment is modified and returned.
+*
+* @param expression
+*   The expression to use for the assignment.
+* @param assignment
+*   The existing assignmentexpression
+* @returns
+*   The new expression.
+*/
+function replaceAssignment(expression, assignment) {
+	if (!assignment || assignment.type !== "AssignmentExpression") return expression;
+	let node = assignment;
+	while (node.right.type === "AssignmentExpression") node = node.right;
+	node.right = expression;
+	return assignment;
+}
+/**
+* Create an ESTree epxression to represent a symbol. Global and well-known symbols are supported.
+*
+* @param symbol
+*   The symbol to represent.
+* @returns
+*   An ESTree expression to represent the symbol.
+*/
+function symbolToEstree(symbol) {
+	const name = wellKnownSymbols.get(symbol);
+	if (name) return {
+		type: "MemberExpression",
+		computed: false,
+		optional: false,
+		object: identifier("Symbol"),
+		property: identifier(name)
+	};
+	if (symbol.description && symbol === Symbol.for(symbol.description)) return methodCall(identifier("Symbol"), "for", [literal(symbol.description)]);
+	throw new TypeError(`Only global symbols are supported, got: ${String(symbol)}`, { cause: symbol });
+}
+/**
+* Create an ESTree property from a key and a value expression.
+*
+* @param key
+*   The property key value
+* @param value
+*   The property value as an ESTree expression.
+* @returns
+*   The ESTree properry node.
+*/
+function property(key, value) {
+	const isString = typeof key === "string";
+	return {
+		type: "Property",
+		method: false,
+		shorthand: false,
+		computed: key === "__proto__" || !isString,
+		kind: "init",
+		key: isString ? literal(key) : symbolToEstree(key),
+		value
+	};
+}
+/**
+* Convert a value to an ESTree node.
+*
+* @param value
+*   The value to convert.
+* @param options
+*   Additional options to configure the output.
+* @returns
+*   The ESTree node.
+*/
+function valueToEstree(value, options = {}) {
+	const stack = [];
+	const collectedContexts = /* @__PURE__ */ new Map();
+	const namedContexts = [];
+	const customTrees = /* @__PURE__ */ new Map();
+	/**
+	* Analyze a value and collect all reference contexts.
+	*
+	* @param val
+	*   The value to analyze.
+	*/
+	function analyze(val) {
+		if (typeof val !== "object" && typeof val !== "function") return;
+		if (val == null) return;
+		const context = collectedContexts.get(val);
+		if (context) {
+			if (options.preserveReferences) context.count += 1;
+			for (const ancestor of stack) context.referencedBy.add(ancestor);
+			if (stack.includes(val)) {
+				if (!options.preserveReferences) throw new Error(`Found circular reference: ${val}`, { cause: val });
+				const parent = stack.at(-1);
+				const parentContext = collectedContexts.get(parent);
+				parentContext.recursive = true;
+				context.recursive = true;
+			}
+			return;
+		}
+		collectedContexts.set(val, {
+			count: 1,
+			recursive: false,
+			referencedBy: new Set(stack),
+			value: val
+		});
+		const estree = options?.replacer?.(val);
+		if (estree) {
+			customTrees.set(val, estree);
+			return;
+		}
+		if (typeof val === "function") throw new TypeError(`Unsupported value: ${val}`, { cause: val });
+		if (isTypedArray(val)) return;
+		if (isStringReconstructable(val)) return;
+		if (isValueReconstructable(val)) return;
+		if (value instanceof RegExp) return;
+		if (isTemporal(value)) return;
+		stack.push(val);
+		if (val instanceof Map) for (const pair of val) {
+			analyze(pair[0]);
+			analyze(pair[1]);
+		}
+		else if (Array.isArray(val) || val instanceof Set) for (const entry of val) analyze(entry);
+		else {
+			const proto = Object.getPrototypeOf(val);
+			if (proto != null && proto !== Object.prototype && !options.instanceAsObject) throw new TypeError(`Unsupported value: ${val}`, { cause: val });
+			for (const key of Reflect.ownKeys(val)) analyze(val[key]);
+		}
+		stack.pop();
+	}
+	/**
+	* Recursively generate the ESTree expression needed to reconstruct the value.
+	*
+	* @param val
+	*   The value to process.
+	* @param isDeclaration
+	*   Whether or not this is for a variable declaration.
+	* @returns
+	*   The ESTree expression to reconstruct the value.
+	*/
+	function generate(val, isDeclaration) {
+		if (val === void 0) return identifier(String(val));
+		if (val == null || typeof val === "string" || typeof val === "boolean") return literal(val);
+		if (typeof val === "bigint" || typeof val === "number") return processNumber(val);
+		if (typeof val === "symbol") return symbolToEstree(val);
+		const context = collectedContexts.get(val);
+		if (!isDeclaration && context?.name) return identifier(context.name);
+		const tree = customTrees.get(val);
+		if (tree) return tree;
+		if (isValueReconstructable(val)) return {
+			type: "NewExpression",
+			callee: identifier(val.constructor.name),
+			arguments: [generate(val.valueOf())]
+		};
+		if (val instanceof RegExp) return {
+			type: "Literal",
+			regex: {
+				pattern: val.source,
+				flags: val.flags
+			}
+		};
+		if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) return methodCall(identifier("Buffer"), "from", [processNumberArray(val)]);
+		if (isTypedArray(val)) return {
+			type: "NewExpression",
+			callee: identifier(val.constructor.name),
+			arguments: [processNumberArray(val)]
+		};
+		if (isStringReconstructable(val)) return {
+			type: "NewExpression",
+			callee: identifier(val.constructor.name),
+			arguments: [literal(String(val))]
+		};
+		if (isTemporal(val)) return methodCall({
+			type: "MemberExpression",
+			computed: false,
+			optional: false,
+			object: identifier("Temporal"),
+			property: identifier(val.constructor.name)
+		}, "from", [literal(String(val))]);
+		if (Array.isArray(val)) {
+			const elements = Array.from({ length: val.length });
+			let trimmable;
+			for (let index = 0; index < val.length; index += 1) {
+				if (!(index in val)) {
+					elements[index] = null;
+					trimmable = void 0;
+					continue;
+				}
+				const child = val[index];
+				const childContext = collectedContexts.get(child);
+				if (context && childContext && namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) {
+					elements[index] = null;
+					trimmable ||= index;
+					childContext.assignment = {
+						type: "AssignmentExpression",
+						operator: "=",
+						left: {
+							type: "MemberExpression",
+							computed: true,
+							optional: false,
+							object: identifier(context.name),
+							property: literal(index)
+						},
+						right: childContext.assignment || identifier(childContext.name)
+					};
+				} else {
+					elements[index] = generate(child);
+					trimmable = void 0;
+				}
+			}
+			if (trimmable != null) elements.splice(trimmable);
+			return {
+				type: "ArrayExpression",
+				elements
+			};
+		}
+		if (val instanceof Set) {
+			const elements = [];
+			let finalizer;
+			for (const child of val) if (finalizer) finalizer = methodCall(finalizer, "add", [generate(child)]);
+			else {
+				const childContext = collectedContexts.get(child);
+				if (context && childContext && namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) finalizer = methodCall(identifier(context.name), "add", [generate(child)]);
+				else elements.push(generate(child));
+			}
+			if (context && finalizer) context.assignment = replaceAssignment(finalizer, context.assignment);
+			return {
+				type: "NewExpression",
+				callee: identifier("Set"),
+				arguments: elements.length ? [{
+					type: "ArrayExpression",
+					elements
+				}] : []
+			};
+		}
+		if (val instanceof Map) {
+			const elements = [];
+			let finalizer;
+			for (const [key, item] of val) if (finalizer) finalizer = methodCall(finalizer, "set", [generate(key), generate(item)]);
+			else {
+				const keyContext = collectedContexts.get(key);
+				const itemContext = collectedContexts.get(item);
+				if (context && (keyContext && namedContexts.indexOf(keyContext) >= namedContexts.indexOf(context) || itemContext && namedContexts.indexOf(itemContext) >= namedContexts.indexOf(context))) finalizer = methodCall(identifier(context.name), "set", [generate(key), generate(item)]);
+				else elements.push({
+					type: "ArrayExpression",
+					elements: [generate(key), generate(item)]
+				});
+			}
+			if (context && finalizer) context.assignment = replaceAssignment(finalizer, context.assignment);
+			return {
+				type: "NewExpression",
+				callee: identifier("Map"),
+				arguments: elements.length ? [{
+					type: "ArrayExpression",
+					elements
+				}] : []
+			};
+		}
+		const properties = [];
+		if (Object.getPrototypeOf(val) == null) properties.push({
+			type: "Property",
+			method: false,
+			shorthand: false,
+			computed: false,
+			kind: "init",
+			key: identifier("__proto__"),
+			value: literal(null)
+		});
+		const object = val;
+		const propertyDescriptors = [];
+		for (const key of Reflect.ownKeys(val)) {
+			const child = object[key];
+			const { configurable, enumerable, writable } = Object.getOwnPropertyDescriptor(val, key);
+			const childContext = collectedContexts.get(child);
+			if (!configurable || !enumerable || !writable) {
+				const propertyDescriptor = [property("value", generate(child))];
+				if (configurable) propertyDescriptor.push(property("configurable", literal(true)));
+				if (enumerable) propertyDescriptor.push(property("enumerable", literal(true)));
+				if (writable) propertyDescriptor.push(property("writable", literal(true)));
+				propertyDescriptors.push([key, {
+					type: "ObjectExpression",
+					properties: propertyDescriptor
+				}]);
+			} else if (context && childContext && namedContexts.indexOf(childContext) >= namedContexts.indexOf(context)) if (key === "__proto__") propertyDescriptors.push([key, {
+				type: "ObjectExpression",
+				properties: [
+					property("value", generate(child)),
+					property("configurable", literal(true)),
+					property("enumerable", literal(true)),
+					property("writable", literal(true))
+				]
+			}]);
+			else childContext.assignment = {
+				type: "AssignmentExpression",
+				operator: "=",
+				left: {
+					type: "MemberExpression",
+					computed: true,
+					optional: false,
+					object: identifier(context.name),
+					property: generate(key)
+				},
+				right: childContext.assignment || generate(child)
+			};
+			else properties.push(property(key, generate(child)));
+		}
+		const objectExpression = {
+			type: "ObjectExpression",
+			properties
+		};
+		if (propertyDescriptors.length) {
+			let name;
+			let args;
+			if (propertyDescriptors.length === 1) {
+				const [[key, expression]] = propertyDescriptors;
+				name = "defineProperty";
+				args = [typeof key === "string" ? literal(key) : symbolToEstree(key), expression];
+			} else {
+				name = "defineProperties";
+				args = [{
+					type: "ObjectExpression",
+					properties: propertyDescriptors.map(([key, expression]) => property(key, expression))
+				}];
+			}
+			if (!context) return methodCall(identifier("Object"), name, [objectExpression, ...args]);
+			context.assignment = replaceAssignment(methodCall(identifier("Object"), name, [identifier(context.name), ...args]), context.assignment);
+		}
+		return objectExpression;
+	}
+	analyze(value);
+	for (const [val, context] of collectedContexts) if (context.recursive || context.count > 1) {
+		context.name = `$${namedContexts.length}`;
+		namedContexts.push(context);
+	} else collectedContexts.delete(val);
+	if (!namedContexts.length) return generate(value);
+	const params = namedContexts.sort(compareContexts).map((context) => ({
+		type: "AssignmentPattern",
+		left: identifier(context.name),
+		right: generate(context.value, true)
+	}));
+	const rootContext = collectedContexts.get(value);
+	const finalizers = [];
+	for (const context of collectedContexts.values()) if (context !== rootContext && context.assignment) finalizers.push(context.assignment);
+	finalizers.push(rootContext ? rootContext.assignment || identifier(rootContext.name) : generate(value));
+	return {
+		type: "CallExpression",
+		optional: false,
+		arguments: [],
+		callee: {
+			type: "ArrowFunctionExpression",
+			expression: false,
+			params,
+			body: {
+				type: "SequenceExpression",
+				expressions: finalizers
+			}
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-util-is-identifier-name@3.0.0/node_modules/estree-util-is-identifier-name/lib/index.js
+const nameRe = /^[$_\p{ID_Start}][$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+const nameReJsx = /^[$_\p{ID_Start}][-$_\u{200C}\u{200D}\p{ID_Continue}]*$/u;
+/** @type {Options} */
+const emptyOptions = {};
+/**
+* Checks if the given value is a valid identifier name.
+*
+* @param {string} name
+*   Identifier to check.
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {boolean}
+*   Whether `name` can be an identifier.
+*/
+function name(name, options) {
+	return ((options || emptyOptions).jsx ? nameReJsx : nameRe).test(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-util-scope@1.0.0/node_modules/estree-util-scope/lib/index.js
+/**
+* @import {Node, Pattern} from 'estree'
+* @import {Scope, Visitors} from './types.js'
+*/
+/**
+* Create state to track what’s defined.
+*
+* @returns {Visitors}
+*   State.
+*/
+function createVisitors() {
+	/** @type {[topLevel: Scope, ...rest: Array<Scope>]} */
+	const scopes = [{
+		block: false,
+		defined: []
+	}];
+	return {
+		enter,
+		exit,
+		scopes
+	};
+	/**
+	* @param {Node} node
+	*   Node.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function enter(node) {
+		if (node.type === "ArrowFunctionExpression") {
+			scopes.push({
+				block: false,
+				defined: []
+			});
+			for (const parameter of node.params) definePattern(parameter, false);
+		} else if (node.type === "BlockStatement" || node.type === "DoWhileStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "WhileStatement") scopes.push({
+			block: true,
+			defined: []
+		});
+		else if (node.type === "CatchClause") {
+			scopes.push({
+				block: true,
+				defined: []
+			});
+			if (node.param) definePattern(node.param, true);
+		} else if (node.type === "ClassDeclaration") defineIdentifier(node.id.name, false);
+		else if (node.type === "FunctionDeclaration") {
+			defineIdentifier(node.id.name, false);
+			scopes.push({
+				block: false,
+				defined: []
+			});
+			for (const parameter of node.params) definePattern(parameter, false);
+		} else if (node.type === "FunctionExpression") {
+			if (node.id) defineIdentifier(node.id.name, false);
+			scopes.push({
+				block: false,
+				defined: []
+			});
+			for (const parameter of node.params) definePattern(parameter, false);
+		} else if (node.type === "ImportDeclaration") for (const specifier of node.specifiers) defineIdentifier(specifier.local.name, false);
+		else if (node.type === "VariableDeclaration") for (const declaration of node.declarations) definePattern(declaration.id, node.kind !== "var");
+	}
+	/**
+	* @param {Node} node
+	*   Node.
+	* @returns {undefined}
+	*   Nothing.
+	*/
+	function exit(node) {
+		if (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression") scopes.pop().block;
+		else if (node.type === "BlockStatement" || node.type === "CatchClause" || node.type === "DoWhileStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "WhileStatement") scopes.pop().block;
+	}
+	/**
+	* Define an identifier in a scope.
+	*
+	* @param {string} id
+	* @param {boolean} block
+	* @returns {undefined}
+	*/
+	function defineIdentifier(id, block) {
+		let index = scopes.length;
+		/** @type {Scope | undefined} */
+		let scope;
+		while (index--) {
+			scope = scopes[index];
+			if (block || !scope.block) break;
+		}
+		scope.defined.push(id);
+	}
+	/**
+	* Define a pattern in a scope.
+	*
+	* @param {Pattern} pattern
+	* @param {boolean} block
+	*/
+	function definePattern(pattern, block) {
+		if (pattern.type === "ArrayPattern") {
+			for (const element of pattern.elements) if (element) definePattern(element, block);
+		} else if (pattern.type === "AssignmentPattern") definePattern(pattern.left, block);
+		else if (pattern.type === "Identifier") defineIdentifier(pattern.name, block);
+		else if (pattern.type === "ObjectPattern") for (const property of pattern.properties) if (property.type === "Property") definePattern(property.value, block);
+		else {
+			property.type;
+			definePattern(property, block);
+		}
+		else {
+			pattern.type;
+			definePattern(pattern.argument, block);
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef {{
+*   skip: () => void;
+*   remove: () => void;
+*   replace: (node: Node) => void;
+* }} WalkerContext
+*/
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => void} SyncHandler
+*/
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+/**
+* @typedef {import('estree').Node} Node
+* @typedef {import('./sync.js').SyncHandler} SyncHandler
+* @typedef {import('./async.js').AsyncHandler} AsyncHandler
+*/
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {Node | null}
+*/
+function walk(ast, { enter, leave }) {
+	return new SyncWalker(enter, leave).visit(ast, null);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unist-util-mdx-define@1.1.2/node_modules/unist-util-mdx-define/dist/unist-util-mdx-define.js
+/**
+* @param program
+*   The ESTree program to scan.
+* @param file
+*   The {@link VFile} to emit warnings to.
+* @param variables
+*   The variables that should be injected.
+* @param options
+*   {@link define}.options
+* @returns
+*   The position in the body where the export may be injected.
+*/
+function scan(program, file, variables, options) {
+	const visitors = createVisitors();
+	const [scope] = visitors.scopes;
+	const identifiers = /* @__PURE__ */ new Map();
+	let injectIndex = 0;
+	walk(program, {
+		enter(node, parent) {
+			visitors.enter(node);
+			switch (node.type) {
+				case "Identifier":
+					if (scope.defined.includes(node.name) && !identifiers.has(node.name)) identifiers.set(node.name, node);
+					break;
+				case "ArrowFunctionExpression":
+				case "ClassDeclaration":
+				case "ClassExpression":
+				case "FunctionExpression":
+				case "FunctionDeclaration":
+					this.skip();
+					break;
+				case "ExpressionStatement":
+					if (parent === program && node.expression.type === "Literal" && typeof node.expression.value === "string") injectIndex = program.body.indexOf(node) + 1;
+					break;
+				default:
+			}
+		},
+		leave: visitors.exit
+	});
+	for (const name of scope.defined) if (variables.has(name)) {
+		if (options?.conflict !== "skip") {
+			const identifier = identifiers.get(name);
+			const message = file.message(`Variable name conflict: ${name}`, {
+				place: identifier?.loc,
+				ruleId: "conflict",
+				source: "unist-util-mdx-define"
+			});
+			message.url = "https://github.com/remcohaszing/unist-util-mdx-define";
+			if (options?.conflict !== "warn") {
+				message.fatal = true;
+				throw message;
+			}
+		}
+		variables.delete(name);
+	}
+	return injectIndex;
+}
+/**
+* Generate an export named declaration.
+*
+* @param variables
+*   The variables for which to generate an declaration.
+* @param options
+*   {@link define} options
+* @param returnStatement
+*   The return statement of the program to inject into.
+* @returns
+*   The export named declaration.
+*/
+function generate(variables, options, returnStatement) {
+	if (options?.export === "namespace") {
+		const statements = [];
+		for (const [name$1, right] of variables) {
+			const isIdentifier = name(name$1);
+			statements.push({
+				type: "ExpressionStatement",
+				expression: {
+					type: "AssignmentExpression",
+					left: {
+						type: "MemberExpression",
+						computed: !isIdentifier,
+						object: {
+							type: "Identifier",
+							name: "MDXContent"
+						},
+						optional: false,
+						property: isIdentifier ? {
+							type: "Identifier",
+							name: name$1
+						} : {
+							type: "Literal",
+							value: name$1
+						}
+					},
+					operator: "=",
+					right
+				}
+			});
+		}
+		return statements;
+	}
+	const declarations = [];
+	for (const [name, init] of variables) declarations.push({
+		type: "VariableDeclaration",
+		kind: "const",
+		declarations: [{
+			type: "VariableDeclarator",
+			id: {
+				type: "Identifier",
+				name
+			},
+			init
+		}]
+	});
+	if (options?.export === false) return declarations;
+	if (!returnStatement) return declarations.map((declaration) => ({
+		type: "ExportNamedDeclaration",
+		declaration,
+		specifiers: []
+	}));
+	if (returnStatement.argument?.type === "ObjectExpression") returnStatement.argument.properties.splice(-1, 0, ...Array.from(variables.keys(), (name) => ({
+		type: "Property",
+		computed: false,
+		kind: "init",
+		method: false,
+		shorthand: true,
+		key: {
+			type: "Identifier",
+			name
+		},
+		value: {
+			type: "Identifier",
+			name
+		}
+	})));
+	return declarations;
+}
+/**
+* Define variables in an MDX related AST.
+*
+* @param ast
+*   The AST in which to define an export
+* @param file
+*   The {@link VFile} to emit warnings to.
+* @param variables
+*   A mapping of variables to define. They keys are the names. The values are the ESTree expression
+*   to represent them.
+* @param options
+*   Additional options to configure behaviour.
+*/
+function define(ast, file, variables, options) {
+	const map = new Map(Object.entries(variables));
+	if (options?.export !== "namespace") for (const name$2 of map.keys()) {
+		if (name$2 === "_createMdxContent" || name$2 === "_Fragment" || name$2 === "_jsx" || name$2 === "_jsxs" || name$2 === "_missingMdxReference" || name$2 === "MDXContent") {
+			const message = file.message(`MDX internal name conflict: ${name$2}`, {
+				ruleId: "internal",
+				source: "unist-util-mdx-define"
+			});
+			message.url = "https://github.com/remcohaszing/unist-util-mdx-define";
+			message.fatal = true;
+			throw message;
+		}
+		if (!name(name$2)) {
+			const message = file.message(`Invalid identifier name: ${name$2}`, {
+				ruleId: "invalid-identifier",
+				source: "unist-util-mdx-define"
+			});
+			message.url = "https://github.com/remcohaszing/unist-util-mdx-define";
+			message.fatal = true;
+			throw message;
+		}
+	}
+	if (ast.type === "root") {
+		for (const child of ast.children) {
+			if (child.type !== "mdxjsEsm") continue;
+			const program = child.data?.estree;
+			/* c8 ignore start */
+			if (!program) continue;
+			/* c8 ignore stop */
+			scan(program, file, map, options);
+		}
+		if (map.size) ast.children.unshift({
+			type: "mdxjsEsm",
+			value: "",
+			data: { estree: {
+				type: "Program",
+				sourceType: "module",
+				body: generate(map, options)
+			} }
+		});
+	} else {
+		const returnStatement = ast.body.find((node) => node.type === "ReturnStatement");
+		const injectIndex = scan(ast, file, map, options);
+		if (map.size) ast.body.splice(injectIndex, 0, ...generate(map, options, returnStatement));
+	}
+}
+//#endregion
+//#region src/markdown/remark-mdx-toc.ts
+function remarkMdxToc(options = {}) {
+	const { name = "toc", levels = [2, 3] } = options;
+	const [minLevel, maxLevel] = levels;
+	return function(tree, file) {
+		const items = [];
+		let headingIndex = 0;
+		visit(tree, "heading", (node) => {
+			if (node.depth < minLevel || node.depth > maxLevel) return;
+			const text = getHeadingText(node);
+			const slug = slugify(text);
+			const id = slug === "" ? `heading-${String(headingIndex)}` : slug;
+			headingIndex++;
+			items.push({
+				id,
+				text,
+				level: node.depth
+			});
+			const hProperties = ensureHProperties(node);
+			hProperties.id = id;
+		});
+		define(tree, file, { [name]: valueToEstree(items) });
+	};
 }
 function getHeadingText(node) {
-  const textParts = [];
-  function extractText(child) {
-    if (!child || typeof child !== "object") return;
-    const typedChild = child;
-    if (typedChild.type === "text") {
-      textParts.push(typedChild.value || "");
-    } else if (typedChild.type === "inlineCode") {
-      textParts.push(typedChild.value || "");
-    } else if (Array.isArray(typedChild.children)) {
-      typedChild.children.forEach(extractText);
-    }
-  }
-  node.children.forEach(extractText);
-  return textParts.join("");
+	const parts = [];
+	function extract(child) {
+		if (!isRecord(child)) return;
+		if (child.type === "text" || child.type === "inlineCode") parts.push(typeof child.value === "string" ? child.value : "");
+		else if (Array.isArray(child.children)) for (const nested of child.children) extract(nested);
+	}
+	for (const child of node.children) extract(child);
+	return parts.join("");
 }
 function slugify(text) {
-  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function buildTocTree(headings, _minLevel) {
-  const result = [];
-  const stack = [];
-  for (const heading of headings) {
-    const item = {
-      id: heading.id,
-      text: heading.text,
-      level: heading.level
-    };
-    while (stack.length > 0 && stack[stack.length - 1].level >= heading.level) {
-      stack.pop();
-    }
-    if (stack.length === 0) {
-      result.push(item);
-    } else {
-      const parent = stack[stack.length - 1].item;
-      if (!parent.children) {
-        parent.children = [];
-      }
-      parent.children.push(item);
-    }
-    stack.push({ item, level: heading.level });
-  }
-  return result;
+	let slug = text.toLowerCase().trim().replaceAll(/[^\s\w-]/g, "").replaceAll(/[\s_]/g, "-");
+	while (slug.includes("--")) slug = slug.replaceAll("--", "-");
+	return slug.replaceAll(/^-|-$/g, "");
 }
-
-// src/markdown/links.ts
-import { visit as visit3 } from "unist-util-visit";
-function rehypeLinks(options) {
-  const { basePath } = options;
-  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/$/, "");
-  return (tree) => {
-    if (!normalizedBase) {
-      return;
-    }
-    visit3(tree, "element", (node) => {
-      if (node.tagName === "a") {
-        const href = node.properties?.href;
-        if (typeof href === "string") {
-          if (href.startsWith("/") && !href.startsWith("//") && !href.startsWith(normalizedBase)) {
-            node.properties = node.properties || {};
-            node.properties.href = normalizedBase + href;
-          }
-        }
-      }
-    });
-  };
+function ensureHProperties(node) {
+	const data = node.data ?? {};
+	node.data = data;
+	if (!isRecord(data.hProperties)) data.hProperties = {};
+	return data.hProperties;
 }
-
-// src/markdown/pipeline.ts
-async function transformMarkdown(content, config, options = {}) {
-  const { data: frontmatter, content: markdownContent } = matter2(content);
-  const { basePath = "/", highlighter: providedHighlighter } = options;
-  const tocExtraction = { toc: [] };
-  const highlighter = providedHighlighter ?? await createShikiHighlighter(config);
-  const processor = unified().use(remarkParse).use(remarkFrontmatter2, ["yaml"]).use(remarkGfm2).use(remarkExtractToc, { tocExtraction, levels: config.toc?.level ?? [2, 3] }).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeShikiFromHighlighter, { highlighter, config }).use(rehypeLinks, { basePath }).use(rehypeStringify, { allowDangerousHtml: true });
-  if (config.remarkPlugins) {
-    for (const plugin of config.remarkPlugins) {
-      processor.use(plugin);
-    }
-  }
-  if (config.rehypePlugins) {
-    for (const plugin of config.rehypePlugins) {
-      processor.use(plugin);
-    }
-  }
-  const result = await processor.process(markdownContent);
-  return {
-    html: String(result),
-    frontmatter,
-    toc: tocExtraction.toc
-  };
+function isRecord(value) {
+	return value != null && typeof value === "object";
 }
-async function transformMarkdownToReact(content, config) {
-  return transformMarkdown(content, config);
+//#endregion
+//#region src/vite/recma-wrap-export.ts
+function findDefaultExport(body) {
+	for (const [i, node] of body.entries()) if (node.type === "ExportDefaultDeclaration" && node.declaration?.type === "FunctionDeclaration" && node.declaration.id?.name !== void 0 && node.declaration.id.name !== "") return {
+		index: i,
+		name: node.declaration.id.name
+	};
+	return {
+		index: -1,
+		name: ""
+	};
 }
-
-// src/runtime/loader.ts
-async function loadDoc(options) {
-  const { slug, contentDir, config } = options;
-  const possiblePaths = [
-    path3.join(contentDir, `${slug}.md`),
-    path3.join(contentDir, slug, "index.md")
-  ];
-  let filePath = null;
-  let fileContent = null;
-  for (const tryPath of possiblePaths) {
-    try {
-      fileContent = await fs3.readFile(tryPath, "utf-8");
-      filePath = tryPath;
-      break;
-    } catch {
-      continue;
-    }
-  }
-  if (!filePath || !fileContent) {
-    return null;
-  }
-  const result = await transformMarkdown(fileContent, config.markdown);
-  const relativePath = path3.relative(contentDir, filePath);
-  let lastUpdated;
-  try {
-    const stat = await fs3.stat(filePath);
-    lastUpdated = stat.mtimeMs;
-  } catch {
-  }
-  return {
-    content: result.html,
-    frontmatter: result.frontmatter,
-    toc: result.toc,
-    filePath,
-    relativePath,
-    lastUpdated
-  };
+function createImport(imported, local, source) {
+	return {
+		type: "ImportDeclaration",
+		specifiers: [{
+			type: "ImportSpecifier",
+			imported: {
+				type: "Identifier",
+				name: imported
+			},
+			local: {
+				type: "Identifier",
+				name: local
+			}
+		}],
+		source: {
+			type: "Literal",
+			value: source
+		}
+	};
 }
-async function loadAllDocs(contentDir, config) {
-  const docs = [];
-  async function scanDir(dir) {
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await scanDir(fullPath);
-      } else if (entry.name.endsWith(".md")) {
-        const fileContent = await fs3.readFile(fullPath, "utf-8");
-        const result = await transformMarkdown(fileContent, config.markdown);
-        const relativePath = path3.relative(contentDir, fullPath);
-        let lastUpdated;
-        try {
-          const stat = await fs3.stat(fullPath);
-          lastUpdated = stat.mtimeMs;
-        } catch {
-        }
-        docs.push({
-          title: result.frontmatter.title || formatTitle2(entry.name.replace(/\.md$/, "")),
-          description: result.frontmatter.description,
-          frontmatter: result.frontmatter,
-          content: result.html,
-          toc: result.toc,
-          filePath: fullPath,
-          relativePath,
-          lastUpdated
-        });
-      }
-    }
-  }
-  await scanDir(contentDir);
-  return docs;
-}
-function formatTitle2(name) {
-  return name.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+function createShorthandProp(name) {
+	return {
+		type: "Property",
+		key: {
+			type: "Identifier",
+			name
+		},
+		value: {
+			type: "Identifier",
+			name
+		},
+		kind: "init",
+		shorthand: true,
+		computed: false,
+		method: false
+	};
 }
-function getSlugFromPath(relativePath) {
-  return relativePath.replace(/\.md$/, "").replace(/\/index$/, "").replace(/\\/g, "/");
+function createWrapperFunction(fnName) {
+	return {
+		type: "FunctionDeclaration",
+		id: {
+			type: "Identifier",
+			name: "_ArdoWrapped"
+		},
+		params: [{
+			type: "Identifier",
+			name: "props"
+		}],
+		body: {
+			type: "BlockStatement",
+			body: [{
+				type: "ReturnStatement",
+				argument: {
+					type: "CallExpression",
+					callee: {
+						type: "Identifier",
+						name: "_ardoJsx"
+					},
+					arguments: [{
+						type: "Identifier",
+						name: "_ArdoPageDP"
+					}, {
+						type: "ObjectExpression",
+						properties: [
+							createShorthandProp("frontmatter"),
+							createShorthandProp("toc"),
+							{
+								type: "Property",
+								key: {
+									type: "Identifier",
+									name: "children"
+								},
+								value: {
+									type: "CallExpression",
+									callee: {
+										type: "Identifier",
+										name: "_ardoJsx"
+									},
+									arguments: [{
+										type: "Identifier",
+										name: fnName
+									}, {
+										type: "Identifier",
+										name: "props"
+									}],
+									optional: false
+								},
+								kind: "init",
+								shorthand: false,
+								computed: false,
+								method: false
+							}
+						]
+					}],
+					optional: false
+				}
+			}]
+		},
+		generator: false,
+		async: false
+	};
 }
-function getPageDataForRoute(docs, slug) {
-  return docs.find((doc) => {
-    const docSlug = getSlugFromPath(doc.relativePath);
-    return docSlug === slug || docSlug === `${slug}/index`;
-  });
+function recmaWrapExport() {
+	return (tree) => {
+		const { index, name } = findDefaultExport(tree.body);
+		if (index === -1) return;
+		const decl = tree.body[index].declaration;
+		if (decl == null) return;
+		tree.body[index] = decl;
+		tree.body.unshift(createImport("ArdoPageDataProvider", "_ArdoPageDP", "ardo/runtime"), createImport("jsx", "_ardoJsx", "react/jsx-runtime"));
+		tree.body.push(createWrapperFunction(name), {
+			type: "ExportDefaultDeclaration",
+			declaration: {
+				type: "Identifier",
+				name: "_ArdoWrapped"
+			}
+		});
+	};
+}
+//#endregion
+//#region src/vite/mdx-plugin.ts
+function createMdxPlugin(markdownConfig) {
+	const themeConfig = markdownConfig?.theme ?? defaultMarkdownConfig.theme;
+	const lineNumbers = markdownConfig?.lineNumbers ?? false;
+	const shikiOptions = isShikiThemeObject(themeConfig) ? {
+		themes: {
+			light: themeConfig.light,
+			dark: themeConfig.dark
+		},
+		defaultColor: false,
+		transformers: [ardoLineTransformer({ globalLineNumbers: lineNumbers })]
+	} : {
+		theme: themeConfig,
+		transformers: [ardoLineTransformer({ globalLineNumbers: lineNumbers })]
+	};
+	return mdx({
+		include: /\.(md|mdx)$/,
+		remarkPlugins: [
+			remarkFrontmatter,
+			[remarkMdxFrontmatter, { name: "frontmatter" }],
+			remarkGfm,
+			remarkCodeMeta,
+			[remarkMdxToc, { levels: markdownConfig?.toc?.level ?? [2, 3] }]
+		],
+		rehypePlugins: [[rehypeShiki, shikiOptions]],
+		recmaPlugins: [recmaWrapExport],
+		providerImportSource: "ardo/mdx-provider"
+	});
+}
+function getReactRouterPlugins() {
+	const routerPlugin = reactRouter();
+	return Array.isArray(routerPlugin) ? routerPlugin : [routerPlugin];
+}
+function isShikiThemeObject(themeConfig) {
+	return typeof themeConfig === "object" && themeConfig != null && "light" in themeConfig && "dark" in themeConfig;
+}
+//#endregion
+//#region src/vite/project-meta.ts
+/**
+* Reads project metadata from package.json.
+*/
+function readProjectMeta(root) {
+	const packageJsonPath = path.join(root, "package.json");
+	try {
+		const rawPackageJson = fsSync.readFileSync(packageJsonPath, "utf8");
+		const parsedPackageJson = JSON.parse(rawPackageJson);
+		if (!isPackageJsonShape(parsedPackageJson)) return {};
+		const repository = extractRepository(parsedPackageJson.repository);
+		const author = extractAuthor(parsedPackageJson.author);
+		return {
+			name: parsedPackageJson.name,
+			homepage: parsedPackageJson.homepage,
+			repository,
+			version: parsedPackageJson.version,
+			author,
+			license: parsedPackageJson.license
+		};
+	} catch {
+		return {};
+	}
+}
+function extractRepository(repository) {
+	if (typeof repository === "string") return normalizeRepository(repository);
+	if (repository == null || typeof repository.url !== "string") return;
+	return normalizeRepository(repository.url);
+}
+function extractAuthor(author) {
+	if (typeof author === "string") return author;
+	if (author == null || typeof author.name !== "string") return;
+	return author.name;
+}
+function normalizeRepository(repository) {
+	return repository.replace(/^git\+/, "").replace(/^git:\/\//, "https://").replace(/\.git$/, "");
+}
+function isPackageJsonShape(value) {
+	return typeof value === "object" && value != null;
+}
+//#endregion
+//#region src/vite/routes-core.ts
+function scanRoutesSync(params) {
+	const { dir, rootDir } = params;
+	const routes = [];
+	const entries = readDirectoryEntries(dir);
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) {
+			routes.push(...scanRoutesSync({
+				dir: fullPath,
+				rootDir
+			}));
+			continue;
+		}
+		const route = createRouteInfo({
+			entryName: entry.name,
+			fullPath,
+			rootDir
+		});
+		if (route != null) routes.push(route);
+	}
+	return routes;
 }
+function readDirectoryEntries(dir) {
+	try {
+		return fsSync.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+function createRouteInfo(params) {
+	const { entryName, fullPath, rootDir } = params;
+	if (!isRouteFile(entryName) || isIgnoredRouteFile(entryName)) return null;
+	const extension = getRouteExtension(entryName);
+	if (extension == null) return null;
+	const relativePath = path.relative(rootDir, fullPath);
+	const baseName = entryName.replace(extension, "");
+	const urlPath = toRoutePath({
+		baseName,
+		extension,
+		relativePath
+	});
+	return {
+		file: `routes/${relativePath.replaceAll("\\", "/")}`,
+		isIndex: isIndexRoute(baseName),
+		path: urlPath
+	};
+}
+function isRouteFile(entryName) {
+	return entryName.endsWith(".md") || entryName.endsWith(".mdx") || entryName.endsWith(".tsx");
+}
+function isIgnoredRouteFile(entryName) {
+	return entryName === "root.tsx" || entryName.startsWith("_");
+}
+function getRouteExtension(entryName) {
+	if (entryName.endsWith(".mdx")) return ".mdx";
+	if (entryName.endsWith(".md")) return ".md";
+	if (entryName.endsWith(".tsx")) return ".tsx";
+	return null;
+}
+function toRoutePath(params) {
+	const { baseName, extension, relativePath } = params;
+	if (isIndexRoute(baseName)) {
+		const parentDir = path.dirname(relativePath);
+		return applyDynamicSegments(`/${parentDir === "." ? "" : parentDir.replaceAll("\\", "/")}`);
+	}
+	return applyDynamicSegments(`/${relativePath.replace(extension, "").replaceAll("\\", "/")}`);
+}
+function isIndexRoute(baseName) {
+	return baseName === "index" || baseName === "home";
+}
+function applyDynamicSegments(urlPath) {
+	return urlPath.replaceAll(/\$(\w+)/gu, ":$1");
+}
+function generateRoutesFile(routes) {
+	return `// AUTO-GENERATED by Ardo - Do not edit manually
 
-// src/runtime/sidebar.ts
-import fs4 from "fs/promises";
-import path4 from "path";
-import matter3 from "gray-matter";
-async function generateSidebar2(options) {
-  const { contentDir, basePath, config } = options;
-  const configSidebar = config.themeConfig.sidebar;
-  if (configSidebar) {
-    if (Array.isArray(configSidebar) && configSidebar.length > 0) {
-      return configSidebar;
-    }
-    if (!Array.isArray(configSidebar)) {
-      return [];
-    }
-  }
-  return await scanDirectoryForSidebar(contentDir, contentDir, basePath);
-}
-async function scanDirectoryForSidebar(dir, rootDir, _basePath) {
-  let entries;
-  try {
-    entries = await fs4.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const items = [];
-  for (const entry of entries) {
-    const fullPath = path4.join(dir, entry.name);
-    const relativePath = path4.relative(rootDir, fullPath);
-    if (entry.name.startsWith(".") || entry.name.startsWith("_")) {
-      continue;
-    }
-    if (entry.isDirectory()) {
-      const children = await scanDirectoryForSidebar(fullPath, rootDir, _basePath);
-      if (children.length > 0) {
-        const indexPath = path4.join(fullPath, "index.md");
-        let link;
-        let title = formatTitle3(entry.name);
-        let order;
-        try {
-          const indexContent = await fs4.readFile(indexPath, "utf-8");
-          const { data: frontmatter } = matter3(indexContent);
-          if (frontmatter.title) {
-            title = frontmatter.title;
-          }
-          if (typeof frontmatter.order === "number") {
-            order = frontmatter.order;
-          }
-          link = normalizePath(relativePath);
-        } catch {
-        }
-        items.push({
-          text: title,
-          link,
-          collapsed: false,
-          items: children,
-          order
-        });
-      }
-    } else if (entry.name.endsWith(".md") && entry.name !== "index.md") {
-      const fileContent = await fs4.readFile(fullPath, "utf-8");
-      const { data: frontmatter } = matter3(fileContent);
-      if (frontmatter.sidebar === false) {
-        continue;
-      }
-      const title = frontmatter.title || formatTitle3(entry.name.replace(/\.md$/, ""));
-      const order = typeof frontmatter.order === "number" ? frontmatter.order : void 0;
-      const link = normalizePath(relativePath.replace(/\.md$/, ""));
-      items.push({
-        text: title,
-        link,
-        order
-      });
-    }
-  }
-  items.sort((a, b) => {
-    if (a.order !== void 0 && b.order !== void 0) {
-      return a.order - b.order;
-    }
-    if (a.order !== void 0) return -1;
-    if (b.order !== void 0) return 1;
-    return a.text.localeCompare(b.text);
-  });
-  return items.map(({ order: _order, ...item }) => item);
-}
-function formatTitle3(name) {
-  return name.replace(/^\d+-/, "").replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+import { type RouteConfig, route, index } from "@react-router/dev/routes"
+
+export default [
+${sortRoutes(routes).map((routeInfo) => renderRouteEntry(routeInfo)).join("\n")}
+] satisfies RouteConfig
+`;
 }
-function normalizePath(p) {
-  return "/" + p.replace(/\\/g, "/").replace(/^\/+/, "");
-}
-export {
-  ardoPlugin as ardo,
-  ardoPlugin,
-  ardoRoutesPlugin,
-  createShikiHighlighter,
-  ardoPlugin as default,
-  detectGitHubBasename,
-  generateSidebar2 as generateSidebar,
-  getPageDataForRoute,
-  getSlugFromPath,
-  highlightCode,
-  loadAllDocs,
-  loadDoc,
-  transformMarkdown,
-  transformMarkdownToReact
+function sortRoutes(routes) {
+	return [...routes].sort((left, right) => {
+		if (left.path === "/" && right.path !== "/") return -1;
+		if (right.path === "/" && left.path !== "/") return 1;
+		if (left.isIndex && !right.isIndex) return -1;
+		if (right.isIndex && !left.isIndex) return 1;
+		return left.path.localeCompare(right.path);
+	});
+}
+function renderRouteEntry(routeInfo) {
+	if (routeInfo.path === "/") return `  index("${routeInfo.file}"),`;
+	return `  route("${routeInfo.path.slice(1)}", "${routeInfo.file}"),`;
+}
+function writeRoutesFileSync(params) {
+	const { appDir, routesDir, routesFilePath } = params;
+	const routes = scanRoutesSync({
+		dir: routesDir,
+		rootDir: routesDir
+	});
+	if (routes.length === 0) return;
+	const content = generateRoutesFile(routes);
+	if (!hasRoutesContentChangedSync(routesFilePath, content)) return;
+	fsSync.mkdirSync(appDir, { recursive: true });
+	fsSync.writeFileSync(routesFilePath, content, "utf8");
+	console.log(`[ardo] Generated routes.ts with ${routes.length} routes`);
+}
+function hasRoutesContentChangedSync(routesFilePath, nextContent) {
+	try {
+		return fsSync.readFileSync(routesFilePath, "utf8") !== nextContent;
+	} catch {
+		return true;
+	}
+}
+async function writeRoutesFile(params) {
+	const { appDir, routesDir, routesFilePath } = params;
+	const routes = scanRoutesSync({
+		dir: routesDir,
+		rootDir: routesDir
+	});
+	if (routes.length === 0) return;
+	const content = generateRoutesFile(routes);
+	if (!await hasRoutesContentChanged(routesFilePath, content)) return;
+	await fs.mkdir(appDir, { recursive: true });
+	await fs.writeFile(routesFilePath, content, "utf8");
+}
+async function hasRoutesContentChanged(routesFilePath, nextContent) {
+	try {
+		return await fs.readFile(routesFilePath, "utf8") !== nextContent;
+	} catch {
+		return true;
+	}
+}
+//#endregion
+//#region src/vite/routes-plugin.ts
+/**
+* Vite plugin that generates routes.ts for React Router Framework Mode.
+*/
+function ardoRoutesPlugin(options = {}) {
+	let paths = createDefaultPaths(process.cwd(), options);
+	return {
+		name: "ardo:routes",
+		enforce: "pre",
+		config(userConfig) {
+			paths = createDefaultPaths(userConfig.root ?? process.cwd(), options);
+			try {
+				writeRoutesFileSync(paths);
+			} catch (error) {
+				console.warn("[ardo] Could not generate routes.ts in config phase:", error);
+			}
+		},
+		configResolved(resolvedConfig) {
+			paths = createDefaultPaths(resolvedConfig.root, options);
+		},
+		async buildStart() {
+			await writeRoutesFile(paths);
+		},
+		configureServer(server) {
+			server.watcher.add(paths.routesDir);
+			const handleChange = (changedPath) => {
+				if (shouldHandleRouteChange(changedPath, paths.routesDir)) writeRoutesFile(paths);
+			};
+			server.watcher.on("add", handleChange);
+			server.watcher.on("unlink", handleChange);
+		}
+	};
+}
+function createDefaultPaths(root, options) {
+	const appDir = path.join(root, "app");
+	return {
+		appDir,
+		routesDir: options.routesDir ?? path.join(appDir, "routes"),
+		routesFilePath: path.join(appDir, "routes.ts")
+	};
+}
+function shouldHandleRouteChange(changedPath, routesDir) {
+	if (!changedPath.startsWith(routesDir)) return false;
+	return changedPath.endsWith(".md") || changedPath.endsWith(".mdx") || changedPath.endsWith(".tsx");
+}
+//#endregion
+//#region src/vite/search-index.ts
+async function generateSearchIndex(routesDir) {
+	const context = {
+		docs: [],
+		routesDir
+	};
+	await scanDirectoryForSearch(routesDir, void 0, context);
+	return context.docs;
+}
+async function scanDirectoryForSearch(dir, section, context) {
+	let entries;
+	try {
+		entries = await fs.readdir(dir, { withFileTypes: true });
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.warn("[ardo] Failed to scan for search index:", errorMessage);
+		return;
+	}
+	for (const entry of entries) await processSearchEntry(entry, {
+		dir,
+		section,
+		scanContext: context
+	});
+}
+async function processSearchEntry(entry, context) {
+	const fullPath = path.join(context.dir, entry.name);
+	if (entry.isDirectory()) {
+		await scanDirectoryForSearch(fullPath, createNestedSection(context.section, entry.name), context.scanContext);
+		return;
+	}
+	if (entry.name.endsWith(".mdx") || entry.name.endsWith(".md")) {
+		const doc = await createSearchDocFromFile(entry.name, fullPath, {
+			routesDir: context.scanContext.routesDir,
+			section: context.section
+		});
+		if (doc != null) context.scanContext.docs.push(doc);
+	}
+}
+async function createSearchDocFromFile(fileName, filePath, context) {
+	const parsed = matter(await fs.readFile(filePath, "utf8"));
+	const extension = fileName.endsWith(".mdx") ? ".mdx" : ".md";
+	const title = typeof parsed.data.title === "string" ? parsed.data.title : formatTitle$1(fileName.replace(extension, ""));
+	const relativePath = path.relative(context.routesDir, filePath);
+	const routePath = buildRoutePath(relativePath, fileName, extension);
+	return {
+		id: relativePath,
+		title,
+		content: sanitizeSearchContent(parsed.content),
+		path: routePath,
+		section: context.section
+	};
+}
+function sanitizeSearchContent(content) {
+	return collapseWhitespace(replacePunctuationWithSpaces(removeImportLines(removeCodeFences(content)))).slice(0, 2e3);
+}
+function removeCodeFences(content) {
+	const lines = content.split("\n");
+	const keptLines = [];
+	let isInsideFence = false;
+	for (const line of lines) {
+		if (line.trimStart().startsWith("```")) {
+			isInsideFence = !isInsideFence;
+			continue;
+		}
+		if (!isInsideFence) keptLines.push(line);
+	}
+	return keptLines.join("\n");
+}
+function removeImportLines(content) {
+	const lines = content.split("\n");
+	const keptLines = [];
+	for (const line of lines) if (!line.trimStart().startsWith("import ")) keptLines.push(line);
+	return keptLines.join("\n");
+}
+function replacePunctuationWithSpaces(content) {
+	let normalized = content;
+	for (const token of [
+		"`",
+		"#",
+		"*",
+		"_",
+		"~",
+		"[",
+		"]",
+		"(",
+		")",
+		"<",
+		">",
+		"|",
+		"!"
+	]) normalized = normalized.replaceAll(token, " ");
+	return normalized;
+}
+function collapseWhitespace(content) {
+	let result = "";
+	let previousWasSpace = false;
+	for (const character of content) {
+		if (character === " " || character === "\n" || character === "	" || character === "\r") {
+			if (!previousWasSpace) result += " ";
+			previousWasSpace = true;
+			continue;
+		}
+		result += character;
+		previousWasSpace = false;
+	}
+	return result.trim();
+}
+function buildRoutePath(relativePath, fileName, extension) {
+	if (fileName === "index.mdx" || fileName === "index.md") {
+		const directoryPath = path.dirname(relativePath).replaceAll("\\", "/");
+		return directoryPath === "." ? "/" : `/${directoryPath}`;
+	}
+	return `/${relativePath.replace(extension, "").replaceAll("\\", "/")}`;
+}
+function createNestedSection(section, directoryName) {
+	const currentTitle = formatTitle$1(directoryName);
+	return section != null ? `${section} > ${currentTitle}` : currentTitle;
+}
+function formatTitle$1(name) {
+	return name.replaceAll(/[_-]/g, " ").replaceAll(/\b\w/g, (char) => char.toUpperCase());
+}
+//#endregion
+//#region src/vite/sidebar-index.ts
+async function generateSidebar$1(routesDir) {
+	try {
+		return (await scanSidebarDirectory(routesDir, routesDir)).map((node) => stripOrderFromNode(node));
+	} catch {
+		return [];
+	}
+}
+async function scanSidebarDirectory(dir, rootDir) {
+	const entries = await fs.readdir(dir, { withFileTypes: true });
+	const nodes = [];
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		const relativePath = path.relative(rootDir, fullPath);
+		if (entry.isDirectory()) {
+			const directoryNode = await createDirectoryNode(entry, fullPath, rootDir);
+			if (directoryNode != null) nodes.push(directoryNode);
+			continue;
+		}
+		const fileNode = await createMarkdownNode(entry, fullPath, relativePath);
+		if (fileNode != null) nodes.push(fileNode);
+	}
+	sortNodes(nodes);
+	return nodes;
+}
+async function createDirectoryNode(entry, fullPath, rootDir) {
+	const relativePath = path.relative(rootDir, fullPath);
+	const children = await scanSidebarDirectory(fullPath, rootDir);
+	if (children.length === 0) return null;
+	const link = await fileExists(path.join(fullPath, "index.mdx")) ? `/${relativePath.replaceAll("\\", "/")}` : void 0;
+	return {
+		text: formatTitle(entry.name),
+		link,
+		items: children
+	};
+}
+async function createMarkdownNode(entry, fullPath, relativePath) {
+	if (!isSidebarMarkdownFile(entry.name)) return null;
+	const extension = entry.name.endsWith(".mdx") ? ".mdx" : ".md";
+	const frontmatter = readFrontmatter(await fs.readFile(fullPath, "utf8"));
+	return {
+		text: frontmatter.title ?? formatTitle(entry.name.replace(extension, "")),
+		link: `/${relativePath.replace(extension, "").replaceAll("\\", "/")}`,
+		order: frontmatter.order
+	};
+}
+function readFrontmatter(fileContent) {
+	const parsed = matter(fileContent);
+	return {
+		title: typeof parsed.data.title === "string" ? parsed.data.title : void 0,
+		order: typeof parsed.data.order === "number" ? parsed.data.order : void 0
+	};
+}
+function sortNodes(nodes) {
+	nodes.sort((leftNode, rightNode) => {
+		if (leftNode.order != null && rightNode.order != null) return leftNode.order - rightNode.order;
+		if (leftNode.order != null) return -1;
+		if (rightNode.order != null) return 1;
+		return leftNode.text.localeCompare(rightNode.text);
+	});
+}
+function isSidebarMarkdownFile(fileName) {
+	return (fileName.endsWith(".mdx") || fileName.endsWith(".md")) && !(fileName === "index.mdx" || fileName === "index.md");
+}
+function formatTitle(name) {
+	return name.replaceAll(/[_-]/g, " ").replaceAll(/\b\w/g, (char) => char.toUpperCase());
+}
+function stripOrderFromNode(node) {
+	return {
+		text: node.text,
+		link: node.link,
+		items: node.items?.map((item) => stripOrderFromNode(item))
+	};
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/vite/plugin.ts
+const VIRTUAL_MODULE_ID = "virtual:ardo/config";
+const VIRTUAL_SIDEBAR_ID = "virtual:ardo/sidebar";
+const VIRTUAL_SEARCH_ID = "virtual:ardo/search-index";
+const RESOLVED_IDS = {
+	[VIRTUAL_MODULE_ID]: `\0${VIRTUAL_MODULE_ID}`,
+	[VIRTUAL_SIDEBAR_ID]: `\0${VIRTUAL_SIDEBAR_ID}`,
+	[VIRTUAL_SEARCH_ID]: `\0${VIRTUAL_SEARCH_ID}`
 };
+let typedocGenerated = false;
+function ardoPlugin(options = {}) {
+	const { routes, typedoc, githubPages = true, routesDir: routesDirOption, ...pressConfig } = options;
+	const state = { routesDir: resolveRoutesDir(process.cwd(), routesDirOption) };
+	const plugins = [createMainPlugin(state, {
+		githubPages,
+		pressConfig,
+		routesDirOption
+	})];
+	addRoutesPlugin(plugins, routes, routesDirOption);
+	addTypeDocPlugin(plugins, typedoc, state);
+	plugins.push(ardoCodeBlockPlugin(pressConfig.markdown));
+	plugins.push(createMdxPlugin(pressConfig.markdown));
+	plugins.push(...vanillaExtractPlugin({ identifiers: "short" }));
+	plugins.push(...getReactRouterPlugins());
+	if (githubPages) plugins.push(createFlattenPlugin());
+	return plugins;
+}
+function addRoutesPlugin(plugins, routes, routesDirOption) {
+	if (routes === false) return;
+	const routePluginOptions = routes ?? {};
+	plugins.push(ardoRoutesPlugin({
+		routesDir: routesDirOption,
+		...routePluginOptions
+	}));
+}
+function addTypeDocPlugin(plugins, typedoc, state) {
+	const typedocConfig = resolveTypedocConfig(typedoc);
+	if (typedocConfig != null) plugins.unshift(createTypeDocPlugin(typedocConfig, state));
+}
+function createMainPlugin(state, options) {
+	return {
+		name: "ardo",
+		enforce: "pre",
+		config(userConfig, env) {
+			return createMainConfig(state, {
+				userConfig,
+				command: env.command,
+				githubPages: options.githubPages,
+				routesDirOption: options.routesDirOption
+			});
+		},
+		configResolved(config) {
+			state.routesDir = resolveRoutesDir(config.root, options.routesDirOption);
+			state.resolvedConfig = resolveArdoConfig(config.root, state.routesDir, options.pressConfig);
+		},
+		resolveId(id) {
+			return resolveVirtualModuleId(id);
+		},
+		async load(id) {
+			return loadVirtualModule(id, state);
+		},
+		transform(code, id) {
+			return transformMarkdownMeta(code, id, state);
+		}
+	};
+}
+function createMainConfig(state, input) {
+	const { command, githubPages, routesDirOption, userConfig } = input;
+	const root = userConfig.root ?? process.cwd();
+	state.routesDir = resolveRoutesDir(root, routesDirOption);
+	const config = {
+		define: { __BUILD_TIME__: JSON.stringify((/* @__PURE__ */ new Date()).toISOString()) },
+		optimizeDeps: { exclude: ["ardo/ui/styles.css"] },
+		ssr: { noExternal: ["ardo"] }
+	};
+	if (githubPages && command === "build" && userConfig.base == null) {
+		const repoName = detectGitHubRepoName(root);
+		if (repoName != null) {
+			config.base = `/${repoName}/`;
+			console.log(`[ardo] GitHub Pages detected, using base: ${config.base}`);
+		}
+	}
+	return config;
+}
+function resolveArdoConfig(root, routesDir, pressConfig) {
+	const project = {
+		...readProjectMeta(root),
+		...pressConfig.project
+	};
+	return resolveConfig({
+		title: pressConfig.title ?? "Ardo",
+		description: pressConfig.description ?? "Documentation powered by Ardo",
+		...pressConfig,
+		project,
+		srcDir: routesDir
+	}, root);
+}
+function resolveVirtualModuleId(id) {
+	return RESOLVED_IDS[id];
+}
+async function loadVirtualModule(id, state) {
+	if (state.resolvedConfig == null) return;
+	if (id === RESOLVED_IDS[VIRTUAL_MODULE_ID]) {
+		const clientConfig = {
+			title: state.resolvedConfig.title,
+			description: state.resolvedConfig.description,
+			base: state.resolvedConfig.base,
+			lang: state.resolvedConfig.lang,
+			project: state.resolvedConfig.project,
+			buildTime: (/* @__PURE__ */ new Date()).toISOString(),
+			buildHash: detectGitHash(state.resolvedConfig.root)
+		};
+		return `export default ${JSON.stringify(clientConfig)}`;
+	}
+	if (id === RESOLVED_IDS[VIRTUAL_SIDEBAR_ID]) {
+		const sidebar = await generateSidebar$1(state.routesDir);
+		return `export default ${JSON.stringify(sidebar)}`;
+	}
+	if (id === RESOLVED_IDS[VIRTUAL_SEARCH_ID]) {
+		const searchIndex = await generateSearchIndex(state.routesDir);
+		return `export default ${JSON.stringify(searchIndex)}`;
+	}
+}
+function transformMarkdownMeta(code, id, state) {
+	if (!shouldInjectMeta(code, id, state)) return;
+	const pageTitle = extractFrontmatterValue(code, "title");
+	if (pageTitle == null || pageTitle === "") return;
+	return {
+		code: `${code}\nexport const meta = () => [${buildMetaEntries({
+			pageTitle,
+			siteTitle: state.resolvedConfig?.title ?? "Ardo",
+			titleSeparator: state.resolvedConfig?.titleSeparator ?? " | ",
+			description: extractFrontmatterValue(code, "description")
+		}).join(", ")}];\n`,
+		map: null
+	};
+}
+function shouldInjectMeta(code, id, state) {
+	return isMarkdownFile(id) && id.startsWith(state.routesDir) && !hasMetaExport(code);
+}
+function buildMetaEntries(input) {
+	const fullTitle = `${input.pageTitle}${input.titleSeparator}${input.siteTitle}`;
+	const entries = [`{ title: ${JSON.stringify(fullTitle)} }`];
+	if (input.description != null && input.description !== "") entries.push(`{ name: "description", content: ${JSON.stringify(input.description)} }`);
+	return entries;
+}
+function isMarkdownFile(id) {
+	return id.endsWith(".md") || id.endsWith(".mdx");
+}
+function hasMetaExport(code) {
+	return code.includes("export const meta") || code.includes("export function meta");
+}
+function extractFrontmatterValue(code, key) {
+	const frontmatterStart = code.indexOf("export const frontmatter");
+	if (frontmatterStart === -1) return;
+	const valuePrefix = `${key}: "`;
+	const valueStart = code.indexOf(valuePrefix, frontmatterStart);
+	if (valueStart === -1) return;
+	const startIndex = valueStart + valuePrefix.length;
+	const endIndex = code.indexOf("\"", startIndex);
+	if (endIndex === -1) return;
+	return code.slice(startIndex, endIndex);
+}
+function resolveTypedocConfig(typedoc) {
+	if (typedoc == null) return;
+	const packageRoot = findPackageRoot(process.cwd());
+	const defaultEntryPoint = packageRoot != null ? `${packageRoot}/src/index.ts` : "./src/index.ts";
+	const defaultTsconfig = packageRoot != null ? `${packageRoot}/tsconfig.json` : "./tsconfig.json";
+	const defaults = {
+		enabled: true,
+		entryPoints: [defaultEntryPoint],
+		tsconfig: defaultTsconfig,
+		out: "api-reference",
+		excludePrivate: true,
+		excludeInternal: true
+	};
+	return typedoc === true ? defaults : {
+		...defaults,
+		...typedoc
+	};
+}
+function createTypeDocPlugin(typedocConfig, state) {
+	return {
+		name: "ardo:typedoc",
+		async buildStart() {
+			if (!typedocConfig.enabled || typedocGenerated) return;
+			typedocGenerated = true;
+			console.log("[ardo] Generating API documentation with TypeDoc...");
+			const startTime = Date.now();
+			try {
+				const docs = await generateApiDocs(typedocConfig, state.routesDir);
+				const duration = Date.now() - startTime;
+				console.log(`[ardo] Generated ${docs.length} API documentation pages in ${duration}ms`);
+			} catch (error) {
+				console.warn("[ardo] TypeDoc generation failed. API documentation will not be available.");
+				console.warn("[ardo] Check your typedoc.entryPoints configuration.");
+				if (error instanceof Error) console.warn(`[ardo] Error: ${error.message}`);
+			}
+		}
+	};
+}
+function resolveRoutesDir(root, routesDirOption) {
+	return routesDirOption ?? path.join(root, "app", "routes");
+}
+//#endregion
+export { ardoPlugin as ardo, ardoPlugin, ardoPlugin as default, ardoRoutesPlugin, createShikiHighlighter, detectGitHubBasename, generateSidebar, getPageDataForRoute, getSlugFromPath, highlightCode, loadAllDocs, loadDoc, transformMarkdown, transformMarkdownToReact };
+
 //# sourceMappingURL=index.js.map