docmedown 0.1.0

package/dist/cli.js

@@ -0,0 +1,1053 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var import_fs7 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+
+// src/cli/commands/init.ts
+var import_fs4 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_chalk3 = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+
+// src/cli/utils/server.ts
+var import_http = __toESM(require("http"));
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_mime_types = __toESM(require("mime-types"));
+var import_ws = require("ws");
+var import_chokidar2 = __toESM(require("chokidar"));
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/cli/commands/build.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_chokidar = __toESM(require("chokidar"));
+
+// src/cli/utils/scanner.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_gray_matter = __toESM(require("gray-matter"));
+
+// src/runtime/loader/auto-indexer.ts
+function formatTitleFromFilename(name) {
+  let clean = name.replace(/\.(md|mdx|html)$/i, "");
+  clean = clean.replace(/^\d+[-_.]/, "");
+  if (clean.toLowerCase() === "readme" || clean.toLowerCase() === "index") {
+    return "Overview";
+  }
+  return clean.split(/[-_]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function buildSidebarTree(files, frontmatters = {}, manualSidebar) {
+  if (manualSidebar && manualSidebar.length > 0) {
+    return mapManualSidebar(manualSidebar);
+  }
+  const rootNodes = [];
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const filePath of files) {
+    const cleanPath = filePath.replace(/^\.?\//, "");
+    const parts = cleanPath.split("/");
+    const fm = frontmatters[cleanPath] || {};
+    if (fm.hidden) continue;
+    if (parts.length === 1) {
+      const filename = parts[0];
+      const slug = filename.replace(/\.(md|mdx)$/i, "");
+      const isOverview = slug.toLowerCase() === "readme" || slug.toLowerCase() === "index";
+      rootNodes.push({
+        id: slug,
+        title: fm.title || fm.sidebar_label || (isOverview ? "Overview" : formatTitleFromFilename(filename)),
+        slug: isOverview ? "README" : slug,
+        path: cleanPath,
+        icon: fm.icon,
+        badge: fm.badge,
+        badgeType: fm.badge_type,
+        order: fm.order ?? fm.sidebar_position ?? (isOverview ? -999 : 0),
+        isCategory: false
+      });
+    } else {
+      let currentCategory = "";
+      let parentNodeList = rootNodes;
+      for (let i = 0; i < parts.length - 1; i++) {
+        const catSegment = parts[i];
+        currentCategory = currentCategory ? `${currentCategory}/${catSegment}` : catSegment;
+        let catNode = categoryMap.get(currentCategory);
+        if (!catNode) {
+          catNode = {
+            id: currentCategory,
+            title: formatTitleFromFilename(catSegment),
+            order: 10,
+            isCategory: true,
+            collapsed: false,
+            children: []
+          };
+          categoryMap.set(currentCategory, catNode);
+          parentNodeList.push(catNode);
+        }
+        parentNodeList = catNode.children;
+      }
+      const filename = parts[parts.length - 1];
+      const slug = cleanPath.replace(/\.(md|mdx)$/i, "");
+      const isOverview = filename.replace(/\.(md|mdx)$/i, "").toLowerCase() === "readme" || filename.replace(/\.(md|mdx)$/i, "").toLowerCase() === "index";
+      parentNodeList.push({
+        id: slug,
+        title: fm.title || fm.sidebar_label || (isOverview ? "Overview" : formatTitleFromFilename(filename)),
+        slug,
+        path: cleanPath,
+        icon: fm.icon,
+        badge: fm.badge,
+        badgeType: fm.badge_type,
+        order: fm.order ?? fm.sidebar_position ?? (isOverview ? -100 : 0),
+        isCategory: false
+      });
+    }
+  }
+  sortTreeNodes(rootNodes);
+  return rootNodes;
+}
+function sortTreeNodes(nodes) {
+  nodes.sort((a, b) => {
+    if (a.order !== b.order) {
+      return a.order - b.order;
+    }
+    if (a.slug === "README") return -1;
+    if (b.slug === "README") return 1;
+    return a.title.localeCompare(b.title);
+  });
+  for (const node of nodes) {
+    if (node.children && node.children.length > 0) {
+      sortTreeNodes(node.children);
+    }
+  }
+}
+function mapManualSidebar(items) {
+  return items.map((item, idx) => {
+    const isCategory = Boolean(item.children && item.children.length > 0);
+    const slug = item.slug || (item.path ? item.path.replace(/\.(md|mdx)$/i, "") : `item-${idx}`);
+    return {
+      id: slug,
+      title: item.title || formatTitleFromFilename(slug),
+      slug: isCategory ? void 0 : slug,
+      path: item.path,
+      icon: item.icon,
+      badge: item.badge,
+      badgeType: item.badgeType,
+      order: idx,
+      isCategory,
+      collapsed: item.collapsed ?? false,
+      children: item.children ? mapManualSidebar(item.children) : void 0
+    };
+  });
+}
+
+// src/cli/utils/scanner.ts
+function extractHeadings(content) {
+  const headings = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(#{1,4})\s+(.+)$/);
+    if (match) {
+      const level = match[1].length;
+      const text = match[2].trim().replace(/[#*`_]/g, "");
+      const id = text.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/[\s_-]+/g, "-");
+      headings.push({ level, text, id });
+    }
+  }
+  return headings;
+}
+function scanDirectory(dir, baseDir = dir, excludeList = ["node_modules", ".git", ".dmd", "dist", "bin"], stopAtNestedDocsRoots = true) {
+  const results = [];
+  if (!import_fs.default.existsSync(dir)) return results;
+  const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (excludeList.includes(entry.name) || entry.name.startsWith(".")) {
+      continue;
+    }
+    const fullPath = import_path.default.join(dir, entry.name);
+    const relPath = import_path.default.relative(baseDir, fullPath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      const isNestedDocsRoot = stopAtNestedDocsRoots && fullPath !== baseDir && import_fs.default.existsSync(import_path.default.join(fullPath, "docs.json"));
+      if (!isNestedDocsRoot) {
+        results.push(...scanDirectory(fullPath, baseDir, excludeList, stopAtNestedDocsRoots));
+      }
+    } else if (entry.isFile() && /\.(md|mdx)$/i.test(entry.name)) {
+      results.push(relPath);
+    }
+  }
+  return results;
+}
+function generateManifest(docDir, config) {
+  const files = scanDirectory(docDir);
+  const docItems = [];
+  const frontmatters = {};
+  for (const relFile of files) {
+    const fullPath = import_path.default.join(docDir, relFile);
+    const raw = import_fs.default.readFileSync(fullPath, "utf-8");
+    const { data: fm, content } = (0, import_gray_matter.default)(raw);
+    const cleanSlug = relFile.replace(/\.(md|mdx)$/i, "");
+    const isOverview = cleanSlug.toLowerCase() === "readme" || cleanSlug.toLowerCase() === "index";
+    const slug = isOverview ? "README" : cleanSlug;
+    const title = fm.title || fm.sidebar_label || formatTitleFromFilename(import_path.default.basename(relFile));
+    frontmatters[relFile] = fm;
+    const headings = extractHeadings(content);
+    const words = content.trim().split(/\s+/).length;
+    const readingTimeMinutes = Math.max(1, Math.ceil(words / 200));
+    docItems.push({
+      slug,
+      path: relFile,
+      title,
+      category: relFile.includes("/") ? relFile.substring(0, relFile.lastIndexOf("/")) : void 0,
+      frontmatter: fm,
+      headings,
+      content,
+      readingTimeMinutes,
+      lastModified: import_fs.default.statSync(fullPath).mtime.toISOString()
+    });
+  }
+  const tree = buildSidebarTree(files, frontmatters, config.sidebar);
+  return {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    config,
+    docs: docItems,
+    tree
+  };
+}
+
+// src/runtime/config.ts
+var DEFAULT_CONFIG = {
+  name: "DocMeDown",
+  tagline: "The simplest Markdown documenter yet",
+  description: "Instant documentation site powered by DocMeDown",
+  version: "1.0.0",
+  rootDoc: "README.md",
+  theme: {
+    preset: "indigo",
+    defaultMode: "auto",
+    codeTheme: "github"
+  },
+  autoIndex: {
+    enabled: true,
+    sort: "natural",
+    defaultCollapsed: false,
+    exclude: ["node_modules", ".git", ".dmd", "dist", "bin", "package.json", "tsconfig.json"]
+  },
+  search: {
+    enabled: true,
+    placeholder: "Search documentation...",
+    maxResults: 10
+  },
+  footer: {
+    copyright: `\xA9 ${(/* @__PURE__ */ new Date()).getFullYear()} DocMeDown. All rights reserved.`,
+    showBuiltWith: true
+  }
+};
+
+// src/cli/commands/build.ts
+var DEFAULT_OFFLINE_OUTPUT_DIRECTORY = ".dist";
+function getBuildOutputPaths(targetDir, offlineOutDir) {
+  return {
+    onlineDir: targetDir,
+    offlineDir: offlineOutDir ? import_path2.default.resolve(process.cwd(), offlineOutDir) : import_path2.default.join(targetDir, DEFAULT_OFFLINE_OUTPUT_DIRECTORY)
+  };
+}
+function encodeOfflinePayload(value) {
+  return Buffer.from(JSON.stringify(value), "utf-8").toString("base64");
+}
+function escapeInlineScriptContent(value) {
+  return value.replace(/<\/script/gi, "<\\/script");
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+var GENERATED_DOC_OUTPUTS = ["_manifest.json", "_docs.js", "docmedown.iife.js"];
+function findNestedDocumentationRoots(targetDir) {
+  const roots = [];
+  function visit(directory) {
+    if (!import_fs2.default.existsSync(directory)) return;
+    for (const entry of import_fs2.default.readdirSync(directory, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".") || ["node_modules", ".git", "dist", "bin"].includes(entry.name)) {
+        continue;
+      }
+      const fullPath = import_path2.default.join(directory, entry.name);
+      if (import_fs2.default.existsSync(import_path2.default.join(fullPath, "docs.json"))) {
+        roots.push(fullPath);
+        visit(fullPath);
+      } else {
+        visit(fullPath);
+      }
+    }
+  }
+  visit(targetDir);
+  return roots;
+}
+function shouldWatchDocumentationSource(rootDir, changedPath) {
+  const relativePath = import_path2.default.relative(rootDir, changedPath).replace(/\\/g, "/");
+  const firstSegment = relativePath.split("/")[0];
+  const isCustomComponentModule = /(^|\/)\.dmd\/(components|index)\.js$/i.test(relativePath);
+  return Boolean(relativePath) && !relativePath.startsWith("..") && (!relativePath.startsWith(".") || isCustomComponentModule) && !GENERATED_DOC_OUTPUTS.includes(relativePath) && firstSegment !== "node_modules" && firstSegment !== "dist";
+}
+async function buildCommand(targetDirArg = "./docs", options = {}) {
+  const targetDir = import_path2.default.resolve(process.cwd(), targetDirArg);
+  const { onlineDir, offlineDir } = getBuildOutputPaths(targetDir, options.outDir);
+  const buildOfflineBundle = options.singleFile !== false;
+  console.log(import_chalk.default.bold.magenta("\n\u26A1 DocMeDown Build\n"));
+  if (!import_fs2.default.existsSync(targetDir)) {
+    console.error(import_chalk.default.red(`\u2716 Directory not found: ${targetDir}`));
+    process.exit(1);
+  }
+  if (!import_fs2.default.existsSync(onlineDir)) {
+    import_fs2.default.mkdirSync(onlineDir, { recursive: true });
+  }
+  if (buildOfflineBundle && !import_fs2.default.existsSync(offlineDir)) {
+    import_fs2.default.mkdirSync(offlineDir, { recursive: true });
+  }
+  let config = DEFAULT_CONFIG;
+  const configPath = import_path2.default.join(targetDir, "docs.json");
+  if (import_fs2.default.existsSync(configPath)) {
+    try {
+      config = { ...DEFAULT_CONFIG, ...JSON.parse(import_fs2.default.readFileSync(configPath, "utf-8")) };
+    } catch (err) {
+      console.warn(import_chalk.default.yellow(`\u26A0 Could not parse docs.json, using defaults.`));
+    }
+  }
+  console.log(import_chalk.default.cyan("  Indexing documentation pages..."));
+  const manifest = generateManifest(targetDir, config);
+  const manifestPath = import_path2.default.join(onlineDir, "_manifest.json");
+  import_fs2.default.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  console.log(import_chalk.default.green(`  \u2714 Generated _manifest.json (${manifest.docs.length} pages indexed)`));
+  const docsMap = {};
+  const files = scanDirectory(targetDir);
+  for (const file of files) {
+    const full = import_path2.default.join(targetDir, file);
+    const raw = import_fs2.default.readFileSync(full, "utf-8");
+    const slug = file.replace(/\.(md|mdx)$/i, "");
+    const cleanSlug = slug.toLowerCase() === "readme" || slug.toLowerCase() === "index" ? "README" : slug;
+    docsMap[cleanSlug] = raw;
+    docsMap[file] = raw;
+  }
+  const componentsPath = import_path2.default.join(targetDir, ".dmd", "components.js");
+  const componentsSource = import_fs2.default.existsSync(componentsPath) ? import_fs2.default.readFileSync(componentsPath, "utf-8") : void 0;
+  const docsJsContent = `window.__DOCMEDOWN_DATA__ = ${JSON.stringify({ manifest, docs: docsMap, componentsSource }, null, 2)};
+`;
+  const docsJsPath = import_path2.default.join(onlineDir, "_docs.js");
+  import_fs2.default.writeFileSync(docsJsPath, docsJsContent, "utf-8");
+  console.log(import_chalk.default.green(`  \u2714 Generated _docs.js for offline file:/// double-click usage`));
+  if (buildOfflineBundle) {
+    console.log(import_chalk.default.cyan("\n  Compiling standalone single-file offline index.html..."));
+    const candidates2 = [
+      import_path2.default.resolve(__dirname, "docmedown.iife.js"),
+      import_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+      import_path2.default.resolve(__dirname, "../docmedown.iife.js")
+    ];
+    const distIifePath2 = candidates2.find((p) => import_fs2.default.existsSync(p));
+    let bundleJs = "";
+    if (distIifePath2) {
+      bundleJs = import_fs2.default.readFileSync(distIifePath2, "utf-8");
+    } else {
+      console.warn(import_chalk.default.yellow("  \u26A0 Local runtime bundle not found, linking CDN script."));
+    }
+    const offlinePayload = encodeOfflinePayload({ manifest, docs: docsMap, componentsSource });
+    const safeBundleJs = escapeInlineScriptContent(bundleJs);
+    const singleFileHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${escapeHtml(config.name || "Documentation")}</title>
+</head>
+<body>
+  <div id="dmd-app"></div>
+  <script>
+    (function () {
+      const encoded = '${offlinePayload}';
+      const bytes = Uint8Array.from(atob(encoded), (character) => character.charCodeAt(0));
+      const data = JSON.parse(new TextDecoder().decode(bytes));
+      window.__DOCMEDOWN_DATA__ = data;
+      window.__DOCMEDOWN_CONFIG__ = data.manifest.config;
+      if (data.componentsSource) {
+        const componentModule = new Blob([data.componentsSource], { type: 'text/javascript' });
+        const componentModuleUrl = URL.createObjectURL(componentModule);
+        window.__DOCMEDOWN_COMPONENTS_READY__ = import(componentModuleUrl)
+          .then((module) => module.default || module)
+          .finally(() => URL.revokeObjectURL(componentModuleUrl));
+      }
+    })();
+  </script>
+  <script>
+${safeBundleJs}
+  </script>
+</body>
+</html>`;
+    const singleFilePath = import_path2.default.join(offlineDir, "index.html");
+    import_fs2.default.writeFileSync(singleFilePath, singleFileHtml, "utf-8");
+    console.log(import_chalk.default.bold.green(`  \u2714 Built self-contained offline bundle: ${singleFilePath}`));
+    console.log(import_chalk.default.dim(`    You can now double-click index.html to view offline without any server!
+`));
+  }
+  const candidates = [
+    import_path2.default.resolve(__dirname, "docmedown.iife.js"),
+    import_path2.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+    import_path2.default.resolve(__dirname, "../docmedown.iife.js")
+  ];
+  const distIifePath = candidates.find((p) => import_fs2.default.existsSync(p));
+  const targetBundlePath = import_path2.default.join(onlineDir, "docmedown.iife.js");
+  if (distIifePath) {
+    import_fs2.default.copyFileSync(distIifePath, targetBundlePath);
+    console.log(import_chalk.default.green(`  \u2714 Updated serveable runtime: ${targetBundlePath}`));
+  }
+  if (options.buildNested !== false) {
+    const nestedRoots = findNestedDocumentationRoots(targetDir);
+    for (const nestedRoot of nestedRoots) {
+      console.log(import_chalk.default.cyan(`
+  Building nested documentation site: ${import_path2.default.relative(targetDir, nestedRoot)}...`));
+      await buildCommand(nestedRoot, { buildNested: false });
+    }
+  }
+  console.log(import_chalk.default.bold.green("\u2728 Build completed successfully!\n"));
+}
+async function watchBuildCommand(targetDirArg = "./docs", options = {}) {
+  const targetDir = import_path2.default.resolve(process.cwd(), targetDirArg);
+  await buildCommand(targetDir, { ...options, watch: false });
+  console.log(import_chalk.default.dim(`  Watching source files in: ${targetDir}`));
+  console.log(import_chalk.default.dim("  Source changes rebuild serveable files and .dist/index.html. Press Ctrl+C to stop.\n"));
+  const watcher = import_chokidar.default.watch(targetDir, {
+    ignored: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/.dist/**",
+      "**/_manifest.json",
+      "**/_docs.js",
+      "**/docmedown.iife.js"
+    ],
+    ignoreInitial: true
+  });
+  let rebuildTimeout = null;
+  watcher.on("all", (_event, changedPath) => {
+    if (!shouldWatchDocumentationSource(targetDir, changedPath)) return;
+    if (rebuildTimeout) clearTimeout(rebuildTimeout);
+    rebuildTimeout = setTimeout(async () => {
+      const relativePath = import_path2.default.relative(targetDir, changedPath);
+      console.log(import_chalk.default.cyan(`[DocMeDown] Changed: ${relativePath} -> Rebuilding documentation...`));
+      try {
+        await buildCommand(targetDir, { ...options, watch: false });
+      } catch (err) {
+        console.error(import_chalk.default.red(`[DocMeDown] Rebuild failed: ${err.message}`));
+      }
+    }, 100);
+  });
+  return new Promise(() => void 0);
+}
+
+// src/cli/utils/server.ts
+function shouldRebuildDocumentation(rootDir, changedPath) {
+  return shouldWatchDocumentationSource(rootDir, changedPath);
+}
+function startDevServer(options) {
+  const { rootDir, host = "localhost", port: initialPort = 3e3, onSourceChange } = options;
+  return new Promise((resolve, reject) => {
+    let port = initialPort;
+    const liveReloadScript = `
+<script>
+(function() {
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  let ws = null;
+  function connect() {
+    ws = new WebSocket(protocol + '//' + window.location.host + '/__dmd_reload');
+    ws.onmessage = function(e) {
+      if (e.data === 'reload') {
+        console.log('[DocMeDown] File changed, reloading...');
+        window.location.reload();
+      }
+    };
+    ws.onclose = function() {
+      setTimeout(connect, 1500);
+    };
+  }
+  connect();
+})();
+</script>
+`;
+    const server = import_http.default.createServer((req, res) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      let reqPath = decodeURIComponent(req.url?.split("?")[0] || "/");
+      if (reqPath === "/" || reqPath === "") {
+        reqPath = "/index.html";
+      }
+      let filePath = import_path3.default.join(rootDir, reqPath);
+      if (!import_fs3.default.existsSync(filePath) || import_fs3.default.statSync(filePath).isDirectory()) {
+        const potentialIndex = import_path3.default.join(rootDir, "index.html");
+        if (import_fs3.default.existsSync(potentialIndex)) {
+          filePath = potentialIndex;
+        } else {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+<!DOCTYPE html>
+<html>
+<head><title>DocMeDown</title></head>
+<body>
+  <div id="dmd-app"></div>
+  <script src="/docmedown.iife.js"></script>
+  ${liveReloadScript}
+</body>
+</html>
+          `);
+          return;
+        }
+      }
+      if (reqPath === "/docmedown.iife.js" && !import_fs3.default.existsSync(filePath)) {
+        const bundleCandidates = [
+          import_path3.default.resolve(__dirname, "docmedown.iife.js"),
+          import_path3.default.resolve(__dirname, "../dist/docmedown.iife.js"),
+          import_path3.default.resolve(__dirname, "../docmedown.iife.js")
+        ];
+        const distFile = bundleCandidates.find((p) => import_fs3.default.existsSync(p));
+        if (distFile) {
+          filePath = distFile;
+        }
+      }
+      try {
+        const stat = import_fs3.default.statSync(filePath);
+        if (stat.isDirectory()) {
+          filePath = import_path3.default.join(filePath, "index.html");
+        }
+        const mimeType = import_mime_types.default.lookup(filePath) || "application/octet-stream";
+        res.setHeader("Content-Type", mimeType);
+        if (mimeType.includes("html")) {
+          let content = import_fs3.default.readFileSync(filePath, "utf-8");
+          if (!content.includes("/__dmd_reload")) {
+            content = content.replace("</body>", `${liveReloadScript}</body>`);
+          }
+          res.writeHead(200);
+          res.end(content);
+        } else {
+          const stream = import_fs3.default.createReadStream(filePath);
+          res.writeHead(200);
+          stream.pipe(res);
+        }
+      } catch (err) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+      }
+    });
+    const wss = new import_ws.WebSocketServer({ noServer: true });
+    const clients = /* @__PURE__ */ new Set();
+    server.on("upgrade", (request, socket, head) => {
+      if (request.url === "/__dmd_reload") {
+        wss.handleUpgrade(request, socket, head, (ws) => {
+          clients.add(ws);
+          ws.on("close", () => clients.delete(ws));
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+    const watcher = import_chokidar2.default.watch(rootDir, {
+      ignored: [
+        "**/node_modules/**",
+        "**/.git/**",
+        "**/dist/**",
+        "**/.dist/**",
+        "**/_manifest.json",
+        "**/_docs.js",
+        "**/docmedown.iife.js"
+      ],
+      ignoreInitial: true
+    });
+    let reloadTimeout = null;
+    watcher.on("all", (event, changedPath) => {
+      if (!shouldRebuildDocumentation(rootDir, changedPath)) return;
+      if (reloadTimeout) clearTimeout(reloadTimeout);
+      reloadTimeout = setTimeout(async () => {
+        const rel = import_path3.default.relative(rootDir, changedPath);
+        try {
+          if (onSourceChange) {
+            console.log(import_chalk2.default.cyan(`[DocMeDown] Changed: ${rel} -> Rebuilding documentation...`));
+            await onSourceChange(event, changedPath);
+          } else {
+            console.log(import_chalk2.default.cyan(`[DocMeDown] Changed: ${rel} -> Reloading preview...`));
+          }
+        } catch (err) {
+          console.error(import_chalk2.default.red(`[DocMeDown] Rebuild failed: ${err.message}`));
+        }
+        clients.forEach((ws) => {
+          if (ws.readyState === import_ws.WebSocket.OPEN) {
+            ws.send("reload");
+          }
+        });
+      }, 100);
+    });
+    function tryListen() {
+      server.listen(port, host, () => {
+        resolve({
+          server,
+          port,
+          close: () => {
+            watcher.close();
+            wss.close();
+            server.close();
+          }
+        });
+      });
+      server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          port++;
+          tryListen();
+        } else {
+          reject(err);
+        }
+      });
+    }
+    tryListen();
+  });
+}
+
+// src/cli/commands/init.ts
+var import_open = __toESM(require("open"));
+async function initCommand(targetDirArg = "./docs", options = {}) {
+  const targetDir = import_path4.default.resolve(process.cwd(), targetDirArg);
+  console.log(import_chalk3.default.bold.magenta("\n\u26A1 DocMeDown - Instant Documentation Initializer\n"));
+  if (!import_fs4.default.existsSync(targetDir)) {
+    import_fs4.default.mkdirSync(targetDir, { recursive: true });
+  }
+  const templatesDir = import_path4.default.resolve(__dirname, "../../templates");
+  const fallbackTemplatesDir = import_path4.default.resolve(__dirname, "../templates");
+  const activeTemplateDir = import_fs4.default.existsSync(templatesDir) ? templatesDir : fallbackTemplatesDir;
+  const indexPath = import_path4.default.join(targetDir, "index.html");
+  if (!import_fs4.default.existsSync(indexPath)) {
+    const templateHtml = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "index.html"), "utf-8");
+    import_fs4.default.writeFileSync(indexPath, templateHtml, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created index.html"));
+  }
+  const configPath = import_path4.default.join(targetDir, "docs.json");
+  if (!import_fs4.default.existsSync(configPath)) {
+    const templateConfig = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "docs.json"), "utf-8");
+    import_fs4.default.writeFileSync(configPath, templateConfig, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created docs.json"));
+  }
+  const readmePath = import_path4.default.join(targetDir, "README.md");
+  if (!import_fs4.default.existsSync(readmePath)) {
+    const templateReadme = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "README.md"), "utf-8");
+    import_fs4.default.writeFileSync(readmePath, templateReadme, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created README.md"));
+  }
+  const gsPath = import_path4.default.join(targetDir, "getting-started.md");
+  if (!import_fs4.default.existsSync(gsPath)) {
+    const templateGs = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "getting-started.md"), "utf-8");
+    import_fs4.default.writeFileSync(gsPath, templateGs, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created getting-started.md"));
+  }
+  const guidesDir = import_path4.default.join(targetDir, "guides");
+  if (!import_fs4.default.existsSync(guidesDir)) {
+    import_fs4.default.mkdirSync(guidesDir, { recursive: true });
+  }
+  const guidePath = import_path4.default.join(guidesDir, "custom-components.md");
+  if (!import_fs4.default.existsSync(guidePath)) {
+    const templateGuide = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, "guides/custom-components.md"), "utf-8");
+    import_fs4.default.writeFileSync(guidePath, templateGuide, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created guides/custom-components.md"));
+  }
+  const dmdDir = import_path4.default.join(targetDir, ".dmd");
+  if (!import_fs4.default.existsSync(dmdDir)) {
+    import_fs4.default.mkdirSync(dmdDir, { recursive: true });
+  }
+  const dmdComponentPath = import_path4.default.join(dmdDir, "components.js");
+  if (!import_fs4.default.existsSync(dmdComponentPath)) {
+    const templateDmd = import_fs4.default.readFileSync(import_path4.default.join(activeTemplateDir, ".dmd/components.js"), "utf-8");
+    import_fs4.default.writeFileSync(dmdComponentPath, templateDmd, "utf-8");
+    console.log(import_chalk3.default.green("  \u2714 Created .dmd/components.js"));
+  }
+  await buildCommand(targetDir);
+  console.log(import_chalk3.default.bold.green("\n\u2728 DocMeDown site successfully initialized!\n"));
+  console.log(import_chalk3.default.dim(`  Location: ${targetDir}
+`));
+  console.log(import_chalk3.default.cyan("  To preview your docs:"));
+  console.log(import_chalk3.default.white(`    npx docmedown serve ${targetDirArg}
+`));
+  console.log(import_chalk3.default.cyan("  To customize settings:"));
+  console.log(import_chalk3.default.white(`    npx docmedown config ${targetDirArg}/docs.json
+`));
+  if (options.start !== false && process.stdout.isTTY) {
+    const response = await (0, import_prompts.default)({
+      type: "confirm",
+      name: "startServer",
+      message: "Would you like to start the local preview server now?",
+      initial: true
+    });
+    if (response.startServer) {
+      console.log(import_chalk3.default.cyan("\n\u{1F680} Starting local live preview server..."));
+      const devServer = await startDevServer({ rootDir: targetDir, port: 3e3 });
+      const url = `http://localhost:${devServer.port}`;
+      console.log(import_chalk3.default.bold.green(`
+\u2714 Documentation live at: ${import_chalk3.default.underline(url)}
+`));
+      console.log(import_chalk3.default.dim("  Press Ctrl+C to stop the server\n"));
+      await (0, import_open.default)(url);
+    }
+  }
+}
+
+// src/cli/commands/serve.ts
+var import_path5 = __toESM(require("path"));
+var import_fs5 = __toESM(require("fs"));
+var import_chalk4 = __toESM(require("chalk"));
+var import_open2 = __toESM(require("open"));
+async function serveCommand(targetDirArg = "./docs", options = {}) {
+  let targetDir = import_path5.default.resolve(process.cwd(), targetDirArg);
+  if (!import_fs5.default.existsSync(targetDir)) {
+    if (import_fs5.default.existsSync(import_path5.default.resolve(process.cwd(), "docs"))) {
+      targetDir = import_path5.default.resolve(process.cwd(), "docs");
+    } else {
+      targetDir = process.cwd();
+    }
+  }
+  console.log(import_chalk4.default.bold.magenta("\n\u26A1 DocMeDown Dev Server\n"));
+  console.log(import_chalk4.default.dim(`  Serving directory: ${targetDir}`));
+  try {
+    console.log(import_chalk4.default.dim("  Building serveable and offline documentation artifacts..."));
+    await buildCommand(targetDir);
+    const devServer = await startDevServer({
+      rootDir: targetDir,
+      host: options.host || "localhost",
+      port: options.port ? Number(options.port) : 3e3,
+      onSourceChange: () => buildCommand(targetDir)
+    });
+    const url = `http://${options.host || "localhost"}:${devServer.port}`;
+    console.log(import_chalk4.default.bold.green(`
+\u2714 Live Documentation Server running at:`));
+    console.log(import_chalk4.default.bold.cyan(`  \u279C  Local:   ${import_chalk4.default.underline(url)}`));
+    console.log(import_chalk4.default.dim(`  \u279C  Watch: Source changes rebuild preview and .dist/index.html`));
+    console.log(import_chalk4.default.dim(`
+  Press Ctrl+C to stop.
+`));
+    if (options.open !== false) {
+      await (0, import_open2.default)(url);
+    }
+  } catch (err) {
+    console.error(import_chalk4.default.red(`
+\u2716 Error starting server: ${err.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/config-tui.ts
+var import_fs6 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_chalk5 = __toESM(require("chalk"));
+var import_prompts2 = __toESM(require("prompts"));
+async function configTuiCommand(configPathArg) {
+  console.log(import_chalk5.default.bold.magenta("\n\u26A1 DocMeDown - Interactive Configuration Wizard\n"));
+  let configPath = "";
+  if (configPathArg) {
+    configPath = import_path6.default.resolve(process.cwd(), configPathArg);
+    if (import_fs6.default.existsSync(configPath) && import_fs6.default.statSync(configPath).isDirectory()) {
+      configPath = import_path6.default.join(configPath, "docs.json");
+    }
+  } else {
+    const candidates = [
+      import_path6.default.resolve(process.cwd(), "docs.json"),
+      import_path6.default.resolve(process.cwd(), "docs/docs.json"),
+      import_path6.default.resolve(process.cwd(), "dmd.json")
+    ];
+    configPath = candidates.find((p) => import_fs6.default.existsSync(p)) || import_path6.default.resolve(process.cwd(), "docs/docs.json");
+  }
+  let existingConfig = DEFAULT_CONFIG;
+  if (import_fs6.default.existsSync(configPath)) {
+    try {
+      existingConfig = { ...DEFAULT_CONFIG, ...JSON.parse(import_fs6.default.readFileSync(configPath, "utf-8")) };
+      console.log(import_chalk5.default.dim(`  Loaded existing configuration from: ${configPath}
+`));
+    } catch {
+      console.warn(import_chalk5.default.yellow(`  \u26A0 Error reading ${configPath}, starting fresh.
+`));
+    }
+  } else {
+    console.log(import_chalk5.default.dim(`  Creating new configuration at: ${configPath}
+`));
+  }
+  const response = await (0, import_prompts2.default)([
+    {
+      type: "text",
+      name: "name",
+      message: "Project Name:",
+      initial: existingConfig.name || "My Project Docs"
+    },
+    {
+      type: "text",
+      name: "tagline",
+      message: "Tagline / Short description:",
+      initial: existingConfig.tagline || "The simplest Markdown documenter yet"
+    },
+    {
+      type: "select",
+      name: "preset",
+      message: "Select Theme Color Palette:",
+      choices: [
+        { title: "Indigo (Modern & Clean)", value: "indigo" },
+        { title: "Emerald (Fresh & Tech)", value: "emerald" },
+        { title: "Sunset (Warm Amber)", value: "sunset" },
+        { title: "Violet (Vibrant Purple)", value: "violet" },
+        { title: "Rose (Bold Quartz)", value: "rose" },
+        { title: "Slate (Minimalist Monochrome)", value: "slate" },
+        { title: "Cyberpunk (Neon Glow)", value: "cyberpunk" }
+      ],
+      initial: ["indigo", "emerald", "sunset", "violet", "rose", "slate", "cyberpunk"].indexOf(
+        existingConfig.theme?.preset || "indigo"
+      )
+    },
+    {
+      type: "select",
+      name: "defaultMode",
+      message: "Default Color Mode:",
+      choices: [
+        { title: "Auto (Follows OS system preference)", value: "auto" },
+        { title: "Dark (Default dark theme)", value: "dark" },
+        { title: "Light (Default light theme)", value: "light" }
+      ],
+      initial: ["auto", "dark", "light"].indexOf(existingConfig.theme?.defaultMode || "auto")
+    },
+    {
+      type: "select",
+      name: "sourceType",
+      message: "Documentation Source Mode:",
+      choices: [
+        { title: "Local Markdown Files (hosted together in folder)", value: "local" },
+        { title: "Remote GitHub Repository (live dynamic fetch)", value: "github" },
+        { title: "Remote GitLab Repository (live dynamic fetch)", value: "gitlab" }
+      ],
+      initial: existingConfig.source?.type ? existingConfig.source.type === "github" ? 1 : 2 : 0
+    },
+    {
+      type: (prev) => prev === "github" ? "text" : null,
+      name: "githubRepo",
+      message: "GitHub Repository (owner/repo):",
+      initial: existingConfig.source?.repo || "facebook/react"
+    },
+    {
+      type: (prev, values) => values.sourceType === "github" ? "text" : null,
+      name: "githubBranch",
+      message: "GitHub Branch:",
+      initial: existingConfig.source?.branch || "main"
+    },
+    {
+      type: (prev, values) => values.sourceType === "github" ? "text" : null,
+      name: "githubDocsDir",
+      message: "GitHub Docs Subfolder (leave empty for root):",
+      initial: existingConfig.source?.docsDir || "docs"
+    },
+    {
+      type: "text",
+      name: "githubSocial",
+      message: "GitHub Repository URL for Navbar link (optional):",
+      initial: existingConfig.socials?.find((s) => s.type === "github")?.url || ""
+    }
+  ]);
+  if (!response.name) {
+    console.log(import_chalk5.default.yellow("\nConfiguration cancelled."));
+    return;
+  }
+  const updatedConfig = {
+    ...existingConfig,
+    name: response.name,
+    tagline: response.tagline,
+    theme: {
+      ...existingConfig.theme,
+      preset: response.preset,
+      defaultMode: response.defaultMode
+    },
+    socials: response.githubSocial ? [{ type: "github", url: response.githubSocial }] : existingConfig.socials
+  };
+  if (response.sourceType === "github") {
+    updatedConfig.source = {
+      type: "github",
+      repo: response.githubRepo,
+      branch: response.githubBranch,
+      docsDir: response.githubDocsDir
+    };
+  } else if (response.sourceType === "local") {
+    delete updatedConfig.source;
+  }
+  const dir = import_path6.default.dirname(configPath);
+  if (!import_fs6.default.existsSync(dir)) {
+    import_fs6.default.mkdirSync(dir, { recursive: true });
+  }
+  import_fs6.default.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2), "utf-8");
+  console.log(import_chalk5.default.bold.green(`
+\u2714 Configuration successfully saved to: ${configPath}
+`));
+}
+
+// package.json
+var package_default = {
+  name: "docmedown",
+  version: "0.1.0",
+  description: "The simplest MarkDown documenter yet. CLI & Web Script React SPA documentation engine.",
+  main: "./dist/docmedown.cjs",
+  module: "./dist/docmedown.mjs",
+  types: "./dist/types/runtime/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/types/runtime/index.d.ts",
+      import: "./dist/docmedown.mjs",
+      require: "./dist/docmedown.cjs"
+    },
+    "./iife": "./dist/docmedown.iife.js"
+  },
+  unpkg: "./dist/docmedown.iife.js",
+  jsdelivr: "./dist/docmedown.iife.js",
+  bin: {
+    docmedown: "bin/docmedown.js",
+    dmd: "bin/docmedown.js"
+  },
+  files: [
+    "dist",
+    "bin",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    "dev:runtime": "vite build --watch",
+    "build:runtime": "vite build",
+    "build:cli": "tsup",
+    typecheck: "tsc --noEmit",
+    "build:types": "tsc -p tsconfig.runtime.json",
+    build: "npm run build:runtime && npm run build:cli && npm run build:types",
+    docmedown: "node ./bin/docmedown.js",
+    dmd: "node ./bin/docmedown.js",
+    "init:docs": "node ./bin/docmedown.js init",
+    serve: "node ./bin/docmedown.js serve ./docs",
+    dev: "node ./bin/docmedown.js serve ./docs",
+    "build:docs": "node ./bin/docmedown.js build ./docs",
+    "build:docs:watch": "node ./bin/docmedown.js build ./docs --watch",
+    "build:offline": "node ./bin/docmedown.js build ./docs",
+    "config:docs": "node ./bin/docmedown.js config ./docs/docs.json",
+    test: "npx tsx --test tests/parser.test.ts tests/scanner.test.ts tests/runtime-integration.test.ts tests/package-smoke.test.ts",
+    "test:release": "npm run typecheck && npm run test && npm run build && npm run build:docs && npm pack --dry-run",
+    prepublishOnly: "npm run test:release"
+  },
+  keywords: [
+    "markdown",
+    "documentation",
+    "docs",
+    "docusaurus",
+    "docsify",
+    "react",
+    "spa",
+    "cli",
+    "offline-docs",
+    "github-docs"
+  ],
+  author: "Gabriel M. Silva",
+  license: "MIT",
+  engines: {
+    node: ">=20.19.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gabrielmsilva00/docmedown.git"
+  },
+  bugs: {
+    url: "https://github.com/gabrielmsilva00/docmedown/issues"
+  },
+  homepage: "https://github.com/gabrielmsilva00/docmedown#readme",
+  packageManager: "npm@11.16.0",
+  overrides: {
+    tsup: {
+      esbuild: "0.28.2"
+    }
+  },
+  dependencies: {
+    chalk: "^4.1.2",
+    chokidar: "^3.6.0",
+    commander: "^12.1.0",
+    "gray-matter": "^4.0.3",
+    "mime-types": "^2.1.35",
+    open: "^10.1.0",
+    prompts: "^2.4.2",
+    ws: "^8.18.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.5.0",
+    "@types/prismjs": "^1.26.6",
+    "@types/prompts": "^2.4.9",
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "@types/ws": "^8.5.12",
+    "@vitejs/plugin-react": "^6.1.0",
+    katex: "^0.16.11",
+    marked: "^14.1.1",
+    minisearch: "^7.1.0",
+    prismjs: "^1.29.0",
+    react: "^18.3.1",
+    "react-dom": "^18.3.1",
+    tsup: "^8.2.4",
+    tsx: "^4.19.0",
+    typescript: "^5.5.4",
+    vite: "^8.2.2",
+    "vite-plugin-css-injected-by-js": "^5.0.2"
+  }
+};
+
+// src/cli/index.ts
+var program = new import_commander.Command();
+program.name("docmedown").description("DocMeDown - The simplest MarkDown documenter yet. CLI & Web Script React SPA.").version(package_default.version);
+program.argument("[dir]", "Documentation directory to initialize or serve", "./docs").option("-p, --port <number>", "Port for local dev server", "3000").option("--no-open", "Do not automatically open the browser").action(async (dir, options) => {
+  const targetDir = import_path7.default.resolve(process.cwd(), dir);
+  const hasIndex = import_fs7.default.existsSync(import_path7.default.join(targetDir, "index.html"));
+  const hasDocs = import_fs7.default.existsSync(import_path7.default.join(targetDir, "README.md")) || import_fs7.default.existsSync(import_path7.default.join(targetDir, "docs.json"));
+  if (!hasIndex && !hasDocs) {
+    await initCommand(dir, { start: options.open });
+  } else {
+    await serveCommand(dir, { port: options.port, open: options.open });
+  }
+});
+program.command("init [dir]").description("Scaffold a new DocMeDown documentation site").option("--no-start", "Do not start the local preview server after initialization").action(async (dir = "./docs", options) => {
+  await initCommand(dir, { start: options.start });
+});
+program.command("serve [dir]").alias("dev").description("Start local live-reload development server").option("-p, --port <number>", "Port to listen on", "3000").option("-H, --host <string>", "Host to bind server to", "localhost").option("--no-open", "Do not automatically open browser").action(async (dir = "./docs", options) => {
+  await serveCommand(dir, options);
+});
+program.command("build [dir]").description("Build serveable documentation and a standalone offline bundle").option("-w, --watch", "Watch source files and rebuild both outputs after changes").option("--no-single-file", "Skip the default standalone offline index.html bundle").option("-o, --out-dir <path>", "Offline bundle output directory (default: <dir>/.dist)").action(async (dir = "./docs", options) => {
+  if (options.watch) {
+    await watchBuildCommand(dir, options);
+  } else {
+    await buildCommand(dir, options);
+  }
+});
+program.command("config [path]").description("Launch the interactive TUI configuration wizard for docs.json").action(async (configPath) => {
+  await configTuiCommand(configPath);
+});
+program.parse(process.argv);