ardo 3.0.2 → 3.0.4

package/dist/vite/index.js

@@ -1,19 +1,1317 @@
 import {
-  ardoPlugin,
-  ardoRoutesPlugin,
-  createShikiHighlighter,
-  detectGitHubBasename,
-  generateSidebar,
-  getPageDataForRoute,
-  getSlugFromPath,
-  highlightCode,
-  loadAllDocs,
-  loadDoc,
-  transformMarkdown,
-  transformMarkdownToReact
-} from "../chunk-7VP5YEX2.js";
-import "../chunk-NBRHGTR2.js";
-import "../chunk-PGHUPTGL.js";
+  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 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 { visit } from "unist-util-visit";
+var 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
+  });
+}
+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 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 getTextContent(node) {
+  if (node.type === "text") {
+    return node.value;
+  }
+  if ("children" in node) {
+    return node.children.map((child) => getTextContent(child)).join("");
+  }
+  return "";
+}
+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 parseTitle(meta) {
+  const match = meta.match(/title="([^"]+)"/);
+  return match ? match[1] : void 0;
+}
+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>
+  </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, "'");
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+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;
+    });
+  };
+}
+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) }]
+        });
+      }
+    }
+  };
+}
+
+// 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);
+    }
+  };
+}
+
+// src/vite/codeblock-plugin.ts
+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;
+}
+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 };
+      }
+    }
+  };
+}
+
+// src/vite/plugin.ts
+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;
+}
+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;
+  }
+}
+function detectGitHash(cwd) {
+  try {
+    return execSync("git rev-parse --short HEAD", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+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 {};
+  }
+}
+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);
+  }
+}
+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);
+  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 formatTitle(name) {
+  return name.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+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;
+}
+
+// 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 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("");
+}
+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;
+}
+
+// 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;
+          }
+        }
+      }
+    });
+  };
+}
+
+// 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
+  };
+}
+async function transformMarkdownToReact(content, config) {
+  return transformMarkdown(content, config);
+}
+
+// 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
+  };
+}
+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 getSlugFromPath(relativePath) {
+  return relativePath.replace(/\.md$/, "").replace(/\/index$/, "").replace(/\\/g, "/");
+}
+function getPageDataForRoute(docs, slug) {
+  return docs.find((doc) => {
+    const docSlug = getSlugFromPath(doc.relativePath);
+    return docSlug === slug || docSlug === `${slug}/index`;
+  });
+}
+
+// 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());
+}
+function normalizePath(p) {
+  return "/" + p.replace(/\\/g, "/").replace(/^\/+/, "");
+}
 export {
   ardoPlugin as ardo,
   ardoPlugin,
@@ -21,7 +1319,7 @@ export {
   createShikiHighlighter,
   ardoPlugin as default,
   detectGitHubBasename,
-  generateSidebar,
+  generateSidebar2 as generateSidebar,
   getPageDataForRoute,
   getSlugFromPath,
   highlightCode,