docula 0.90.0 → 1.0.0

package/dist/docula.js

@@ -1,7 +1,7 @@
 // src/docula.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import http from "http";
-import path5 from "path";
+import path6 from "path";
 import process4 from "process";
 import { pathToFileURL } from "url";
 import { createJiti } from "jiti";
@@ -9,8 +9,8 @@ import handler from "serve-handler";
 import updateNotifier from "update-notifier";
 
 // src/builder.ts
-import fs2 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import { Ecto } from "ecto";
 import { Writr } from "writr";
 
@@ -691,6 +691,8 @@ var DoculaConsole = class {
 };
 
 // src/github.ts
+import fs from "fs";
+import path2 from "path";
 import process2 from "process";
 import { CacheableNet } from "@cacheable/net";
 var Github = class {
@@ -700,18 +702,32 @@ var Github = class {
     repo: ""
   };
   net;
-  constructor(options) {
+  cacheConfig;
+  constructor(options, cacheConfig) {
     this.parseOptions(options);
     this.net = new CacheableNet();
+    if (cacheConfig) {
+      this.cacheConfig = cacheConfig;
+    }
   }
   async getData() {
+    if (this.cacheConfig && this.cacheConfig.ttl > 0) {
+      const cached = this.loadCache();
+      if (cached) {
+        return cached;
+      }
+    }
     const data = {
       releases: {},
       contributors: {}
     };
     data.releases = await this.getReleases();
     data.contributors = await this.getContributors();
-    return data;
+    const result = data;
+    if (this.cacheConfig && this.cacheConfig.ttl > 0) {
+      this.saveCache(result);
+    }
+    return result;
   }
   // biome-ignore lint/suspicious/noExplicitAny: need to fix
   async getReleases() {
@@ -775,6 +791,41 @@ var Github = class {
     this.options.author = options.author;
     this.options.repo = options.repo;
   }
+  getCacheFilePath() {
+    if (!this.cacheConfig) {
+      throw new Error("Cache config is not set");
+    }
+    const cacheDir = path2.join(this.cacheConfig.cachePath, "github");
+    return path2.join(cacheDir, "github-data.json");
+  }
+  loadCache() {
+    try {
+      const cacheFile = this.getCacheFilePath();
+      if (!fs.existsSync(cacheFile)) {
+        return void 0;
+      }
+      const stat = fs.statSync(cacheFile);
+      const ageInSeconds = (Date.now() - stat.mtimeMs) / 1e3;
+      if (ageInSeconds > (this.cacheConfig?.ttl ?? 0)) {
+        return void 0;
+      }
+      const raw = fs.readFileSync(cacheFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  saveCache(data) {
+    try {
+      const cacheFile = this.getCacheFilePath();
+      const cacheDir = path2.dirname(cacheFile);
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    } catch {
+    }
+  }
   // biome-ignore lint/suspicious/noExplicitAny: need to fix
   addAnchorLink(data) {
     return data.map((release) => {
@@ -786,7 +837,7 @@ var Github = class {
 };
 
 // src/options.ts
-import path2 from "path";
+import path3 from "path";
 import process3 from "process";
 var DoculaOptions = class {
   /**
@@ -800,11 +851,11 @@ var DoculaOptions = class {
   /**
    * Path to the output directory
    */
-  output = path2.join(process3.cwd(), "./dist");
+  output = path3.join(process3.cwd(), "./dist");
   /**
    * Path to the site directory
    */
-  sitePath = path2.join(process3.cwd(), "./site");
+  sitePath = path3.join(process3.cwd(), "./site");
   /**
    * Path to the github repository
    */
@@ -860,6 +911,28 @@ var DoculaOptions = class {
    * site directory's .gitignore file if not already present.
    */
   autoUpdateIgnores = true;
+  /**
+   * File extensions to copy as assets from docs/ and changelog/ directories.
+   * Override in docula.config to customize.
+   */
+  /**
+   * Cookie-based authentication. When set, shows a Login/Logout button
+   * in the header based on whether a JWT cookie is present.
+   */
+  cookieAuth;
+  /**
+   * File extensions to copy as assets from docs/ and changelog/ directories.
+   * Override in docula.config to customize.
+   */
+  /**
+   * Cache settings. Controls caching of external data (e.g., GitHub API responses)
+   * in the .cache directory within the site path.
+   */
+  cache = {
+    github: {
+      ttl: 3600
+    }
+  };
   /**
    * File extensions to copy as assets from docs/ and changelog/ directories.
    * Override in docula.config to customize.
@@ -899,15 +972,15 @@ var DoculaOptions = class {
     }
     if (options.templatePath) {
       this.templatePath = options.templatePath;
-      this.templatePath = path2.join(process3.cwd(), this.templatePath);
+      this.templatePath = path3.join(process3.cwd(), this.templatePath);
     }
     if (options.output) {
       this.output = options.output;
-      this.output = path2.join(process3.cwd(), this.output);
+      this.output = path3.join(process3.cwd(), this.output);
     }
     if (options.sitePath) {
       this.sitePath = options.sitePath;
-      this.sitePath = path2.join(process3.cwd(), this.sitePath);
+      this.sitePath = path3.join(process3.cwd(), this.sitePath);
     }
     if (options.githubPath) {
       this.githubPath = options.githubPath;
@@ -945,33 +1018,39 @@ var DoculaOptions = class {
     if (options.autoUpdateIgnores !== void 0 && typeof options.autoUpdateIgnores === "boolean") {
       this.autoUpdateIgnores = options.autoUpdateIgnores;
     }
+    if (options.cache && typeof options.cache === "object" && options.cache.github !== null && typeof options.cache.github === "object" && typeof options.cache.github.ttl === "number") {
+      this.cache = options.cache;
+    }
     if (options.allowedAssets && Array.isArray(options.allowedAssets)) {
       this.allowedAssets = options.allowedAssets;
     }
+    if (options.cookieAuth && typeof options.cookieAuth === "object" && typeof options.cookieAuth.loginUrl === "string") {
+      this.cookieAuth = options.cookieAuth;
+    }
   }
 };
 
 // src/template-resolver.ts
-import fs from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path4 from "path";
 function getBuiltInTemplatesDir() {
-  return path3.join(import.meta.url, "../../templates").replace("file:", "");
+  return path4.join(import.meta.url, "../../templates").replace("file:", "");
 }
 function listBuiltInTemplates() {
   const templatesDir = getBuiltInTemplatesDir();
-  if (!fs.existsSync(templatesDir)) {
+  if (!fs2.existsSync(templatesDir)) {
     return [];
   }
-  return fs.readdirSync(templatesDir).filter(
-    (entry) => fs.statSync(path3.join(templatesDir, entry)).isDirectory()
+  return fs2.readdirSync(templatesDir).filter(
+    (entry) => fs2.statSync(path4.join(templatesDir, entry)).isDirectory()
   );
 }
 function resolveTemplatePath(templatePath, templateName) {
   if (templatePath) {
     return templatePath;
   }
-  const resolvedPath = path3.join(getBuiltInTemplatesDir(), templateName);
-  if (!fs.existsSync(resolvedPath)) {
+  const resolvedPath = path4.join(getBuiltInTemplatesDir(), templateName);
+  if (!fs2.existsSync(resolvedPath)) {
     const available = listBuiltInTemplates();
     throw new Error(
       `Built-in template "${templateName}" not found. Available templates: ${available.join(", ")}`
@@ -1014,9 +1093,10 @@ var DoculaBuilder = class {
       sections: this.options.sections,
       openApiUrl: this.options.openApiUrl,
       homePage: this.options.homePage,
-      themeMode: this.options.themeMode
+      themeMode: this.options.themeMode,
+      cookieAuth: this.options.cookieAuth
     };
-    if (!doculaData.openApiUrl && fs2.existsSync(`${doculaData.sitePath}/api/swagger.json`)) {
+    if (!doculaData.openApiUrl && fs3.existsSync(`${doculaData.sitePath}/api/swagger.json`)) {
       doculaData.openApiUrl = "/api/swagger.json";
     }
     if (this.options.githubPath) {
@@ -1105,43 +1185,43 @@ var DoculaBuilder = class {
     }
     const siteRelativePath = this.options.sitePath;
     this._console.step("Copying assets...");
-    if (fs2.existsSync(`${siteRelativePath}/favicon.ico`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/favicon.ico`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/favicon.ico`,
         `${this.options.output}/favicon.ico`
       );
       this._console.fileCopied("favicon.ico");
     }
-    if (fs2.existsSync(`${siteRelativePath}/logo.svg`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/logo.svg`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/logo.svg`,
         `${this.options.output}/logo.svg`
       );
       this._console.fileCopied("logo.svg");
     }
-    if (fs2.existsSync(`${siteRelativePath}/logo_horizontal.png`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/logo_horizontal.png`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/logo_horizontal.png`,
         `${this.options.output}/logo_horizontal.png`
       );
       this._console.fileCopied("logo_horizontal.png");
     }
-    if (fs2.existsSync(`${resolvedTemplatePath}/css`)) {
+    if (fs3.existsSync(`${resolvedTemplatePath}/css`)) {
       this.copyDirectory(
         `${resolvedTemplatePath}/css`,
         `${this.options.output}/css`
       );
       this._console.fileCopied("css/");
     }
-    if (fs2.existsSync(`${resolvedTemplatePath}/js`)) {
+    if (fs3.existsSync(`${resolvedTemplatePath}/js`)) {
       this.copyDirectory(
         `${resolvedTemplatePath}/js`,
         `${this.options.output}/js`
       );
       this._console.fileCopied("js/");
     }
-    if (fs2.existsSync(`${siteRelativePath}/variables.css`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/variables.css`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/variables.css`,
         `${this.options.output}/css/variables.css`
       );
@@ -1183,14 +1263,21 @@ var DoculaBuilder = class {
       author: paths[0],
       repo: paths[1]
     };
-    const github = new Github(options);
+    let cacheConfig;
+    if (this._options.cache.github.ttl > 0) {
+      cacheConfig = {
+        cachePath: path5.join(this._options.sitePath, ".cache"),
+        ttl: this._options.cache.github.ttl
+      };
+    }
+    const github = new Github(options, cacheConfig);
     return github.getData();
   }
   async getTemplates(templatePath, hasDocuments, hasChangelog = false) {
     const templates = {
       home: ""
     };
-    if (fs2.existsSync(templatePath)) {
+    if (fs3.existsSync(templatePath)) {
       const home = await this.getTemplateFile(templatePath, "home");
       if (home) {
         templates.home = home;
@@ -1216,9 +1303,9 @@ var DoculaBuilder = class {
     }
     return templates;
   }
-  async getTemplateFile(path6, name) {
+  async getTemplateFile(path7, name) {
     let result;
-    const files = await fs2.promises.readdir(path6);
+    const files = await fs3.promises.readdir(path7);
     for (const file of files) {
       const fileName = file.split(".");
       if (fileName[0].toString().toLowerCase() === name.toLowerCase()) {
@@ -1232,8 +1319,8 @@ var DoculaBuilder = class {
     const { sitePath } = options;
     const { output } = options;
     const robotsPath = `${output}/robots.txt`;
-    await fs2.promises.mkdir(output, { recursive: true });
-    await (fs2.existsSync(`${sitePath}/robots.txt`) ? fs2.promises.copyFile(`${sitePath}/robots.txt`, robotsPath) : fs2.promises.writeFile(robotsPath, "User-agent: *\nDisallow:"));
+    await fs3.promises.mkdir(output, { recursive: true });
+    await (fs3.existsSync(`${sitePath}/robots.txt`) ? fs3.promises.copyFile(`${sitePath}/robots.txt`, robotsPath) : fs3.promises.writeFile(robotsPath, "User-agent: *\nDisallow:"));
   }
   async buildSiteMapPage(data) {
     const sitemapPath = `${data.output}/sitemap.xml`;
@@ -1264,14 +1351,14 @@ var DoculaBuilder = class {
       xml += "</url>";
     }
     xml += "</urlset>";
-    await fs2.promises.mkdir(data.output, { recursive: true });
-    await fs2.promises.writeFile(sitemapPath, xml, "utf8");
+    await fs3.promises.mkdir(data.output, { recursive: true });
+    await fs3.promises.writeFile(sitemapPath, xml, "utf8");
   }
   async buildLlmsFiles(data) {
     if (!this.options.enableLlmsTxt) {
       return;
     }
-    await fs2.promises.mkdir(data.output, { recursive: true });
+    await fs3.promises.mkdir(data.output, { recursive: true });
     const llmsOutputPath = `${data.output}/llms.txt`;
     const llmsFullOutputPath = `${data.output}/llms-full.txt`;
     const llmsOverrideContent = await this.getSafeSiteOverrideFileContent(
@@ -1283,21 +1370,21 @@ var DoculaBuilder = class {
       "llms-full.txt"
     );
     if (llmsOverrideContent !== void 0) {
-      await fs2.promises.writeFile(llmsOutputPath, llmsOverrideContent, "utf8");
+      await fs3.promises.writeFile(llmsOutputPath, llmsOverrideContent, "utf8");
     } else {
       const llmsContent = this.generateLlmsIndexContent(data);
-      await fs2.promises.writeFile(llmsOutputPath, llmsContent, "utf8");
+      await fs3.promises.writeFile(llmsOutputPath, llmsContent, "utf8");
     }
     this._console.fileBuilt("llms.txt");
     if (llmsFullOverrideContent !== void 0) {
-      await fs2.promises.writeFile(
+      await fs3.promises.writeFile(
         llmsFullOutputPath,
         llmsFullOverrideContent,
         "utf8"
       );
     } else {
       const llmsFullContent = await this.generateLlmsFullContent(data);
-      await fs2.promises.writeFile(llmsFullOutputPath, llmsFullContent, "utf8");
+      await fs3.promises.writeFile(llmsFullOutputPath, llmsFullContent, "utf8");
     }
     this._console.fileBuilt("llms-full.txt");
   }
@@ -1466,17 +1553,17 @@ var DoculaBuilder = class {
       return void 0;
     }
     const normalizedPath = openApiPathWithoutQuery.startsWith("/") ? openApiPathWithoutQuery.slice(1) : openApiPathWithoutQuery;
-    return path4.join(data.sitePath, normalizedPath);
+    return path5.join(data.sitePath, normalizedPath);
   }
   async getSafeSiteOverrideFileContent(sitePath, fileName) {
-    const resolvedSitePath = path4.resolve(sitePath);
-    const candidatePath = path4.resolve(sitePath, fileName);
+    const resolvedSitePath = path5.resolve(sitePath);
+    const candidatePath = path5.resolve(sitePath, fileName);
     if (!this.isPathWithinBasePath(candidatePath, resolvedSitePath)) {
       return void 0;
     }
     let candidateStats;
     try {
-      candidateStats = await fs2.promises.lstat(candidatePath);
+      candidateStats = await fs3.promises.lstat(candidatePath);
     } catch {
       return void 0;
     }
@@ -1486,29 +1573,29 @@ var DoculaBuilder = class {
     let realSitePath;
     let realCandidatePath;
     try {
-      realSitePath = await fs2.promises.realpath(resolvedSitePath);
-      realCandidatePath = await fs2.promises.realpath(candidatePath);
+      realSitePath = await fs3.promises.realpath(resolvedSitePath);
+      realCandidatePath = await fs3.promises.realpath(candidatePath);
     } catch {
       return void 0;
     }
     if (!this.isPathWithinBasePath(realCandidatePath, realSitePath)) {
       return void 0;
     }
-    return fs2.promises.readFile(realCandidatePath, "utf8");
+    return fs3.promises.readFile(realCandidatePath, "utf8");
   }
   async getSafeLocalOpenApiSpec(data) {
     const localOpenApiPath = this.resolveLocalOpenApiPath(data);
     if (!localOpenApiPath) {
       return void 0;
     }
-    const resolvedSitePath = path4.resolve(data.sitePath);
-    const resolvedLocalOpenApiPath = path4.resolve(localOpenApiPath);
+    const resolvedSitePath = path5.resolve(data.sitePath);
+    const resolvedLocalOpenApiPath = path5.resolve(localOpenApiPath);
     if (!this.isPathWithinBasePath(resolvedLocalOpenApiPath, resolvedSitePath)) {
       return void 0;
     }
     let localOpenApiStats;
     try {
-      localOpenApiStats = await fs2.promises.lstat(resolvedLocalOpenApiPath);
+      localOpenApiStats = await fs3.promises.lstat(resolvedLocalOpenApiPath);
     } catch {
       return void 0;
     }
@@ -1518,8 +1605,8 @@ var DoculaBuilder = class {
     let realSitePath;
     let realLocalOpenApiPath;
     try {
-      realSitePath = await fs2.promises.realpath(resolvedSitePath);
-      realLocalOpenApiPath = await fs2.promises.realpath(
+      realSitePath = await fs3.promises.realpath(resolvedSitePath);
+      realLocalOpenApiPath = await fs3.promises.realpath(
         resolvedLocalOpenApiPath
       );
     } catch {
@@ -1528,26 +1615,26 @@ var DoculaBuilder = class {
     if (!this.isPathWithinBasePath(realLocalOpenApiPath, realSitePath)) {
       return void 0;
     }
-    const localOpenApiContent = (await fs2.promises.readFile(realLocalOpenApiPath, "utf8")).trim();
+    const localOpenApiContent = (await fs3.promises.readFile(realLocalOpenApiPath, "utf8")).trim();
     return {
       sourcePath: realLocalOpenApiPath,
       content: localOpenApiContent
     };
   }
   isPathWithinBasePath(candidatePath, basePath) {
-    const relativePath = path4.relative(
-      path4.resolve(basePath),
-      path4.resolve(candidatePath)
+    const relativePath = path5.relative(
+      path5.resolve(basePath),
+      path5.resolve(candidatePath)
     );
-    return relativePath === "" || !relativePath.startsWith("..") && !path4.isAbsolute(relativePath);
+    return relativePath === "" || !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
   }
   toPosixPath(filePath) {
-    return filePath.replaceAll(path4.sep, path4.posix.sep);
+    return filePath.replaceAll(path5.sep, path5.posix.sep);
   }
   async buildIndexPage(data) {
     if (data.templates) {
       const indexPath = `${data.output}/index.html`;
-      await fs2.promises.mkdir(data.output, { recursive: true });
+      await fs3.promises.mkdir(data.output, { recursive: true });
       const indexTemplate = `${data.templatePath}/${data.templates.home}`;
       let content;
       if (!data.hasDocuments) {
@@ -1559,7 +1646,7 @@ var DoculaBuilder = class {
         { ...data, content, announcement },
         data.templatePath
       );
-      await fs2.promises.writeFile(indexPath, indexContent, "utf8");
+      await fs3.promises.writeFile(indexPath, indexContent, "utf8");
     } else {
       throw new Error("No templates found");
     }
@@ -1572,7 +1659,7 @@ var DoculaBuilder = class {
       throw new Error("No documents found for homePage");
     }
     const indexPath = `${data.output}/index.html`;
-    await fs2.promises.mkdir(data.output, { recursive: true });
+    await fs3.promises.mkdir(data.output, { recursive: true });
     const documentsTemplate = `${data.templatePath}/${data.templates.docPage}`;
     const firstDocument = data.documents[0];
     if (!data.sidebarItems) {
@@ -1583,12 +1670,12 @@ var DoculaBuilder = class {
       { ...data, ...firstDocument },
       data.templatePath
     );
-    await fs2.promises.writeFile(indexPath, documentContent, "utf8");
+    await fs3.promises.writeFile(indexPath, documentContent, "utf8");
   }
   async buildReadmeSection(data) {
     let htmlReadme = "";
-    if (fs2.existsSync(`${data.sitePath}/README.md`)) {
-      const readmeContent = fs2.readFileSync(
+    if (fs3.existsSync(`${data.sitePath}/README.md`)) {
+      const readmeContent = fs3.readFileSync(
         `${data.sitePath}/README.md`,
         "utf8"
       );
@@ -1598,8 +1685,8 @@ var DoculaBuilder = class {
   }
   async buildAnnouncementSection(data) {
     const announcementPath = `${data.sitePath}/announcement.md`;
-    if (fs2.existsSync(announcementPath)) {
-      const announcementContent = fs2.readFileSync(announcementPath, "utf8");
+    if (fs3.existsSync(announcementPath)) {
+      const announcementContent = fs3.readFileSync(announcementPath, "utf8");
       return new Writr(announcementContent).render();
     }
     return void 0;
@@ -1607,11 +1694,11 @@ var DoculaBuilder = class {
   async buildDocsPages(data) {
     if (data.templates && data.documents?.length) {
       const documentsTemplate = `${data.templatePath}/${data.templates.docPage}`;
-      await fs2.promises.mkdir(`${data.output}/docs`, { recursive: true });
+      await fs3.promises.mkdir(`${data.output}/docs`, { recursive: true });
       data.sidebarItems = this.generateSidebarItems(data);
       const promises = data.documents.map(async (document) => {
         const folder = document.urlPath.split("/").slice(0, -1).join("/");
-        await fs2.promises.mkdir(`${data.output}/${folder}`, {
+        await fs3.promises.mkdir(`${data.output}/${folder}`, {
           recursive: true
         });
         const slug = `${data.output}${document.urlPath}`;
@@ -1620,7 +1707,7 @@ var DoculaBuilder = class {
           { ...data, ...document },
           data.templatePath
         );
-        return fs2.promises.writeFile(slug, documentContent, "utf8");
+        return fs3.promises.writeFile(slug, documentContent, "utf8");
       });
       await Promise.all(promises);
     } else {
@@ -1633,10 +1720,10 @@ var DoculaBuilder = class {
     }
     const apiPath = `${data.output}/api/index.html`;
     const apiOutputPath = `${data.output}/api`;
-    await fs2.promises.mkdir(apiOutputPath, { recursive: true });
+    await fs3.promises.mkdir(apiOutputPath, { recursive: true });
     const swaggerSource = `${data.sitePath}/api/swagger.json`;
-    if (fs2.existsSync(swaggerSource)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(swaggerSource)) {
+      await fs3.promises.copyFile(
         swaggerSource,
         `${apiOutputPath}/swagger.json`
       );
@@ -1670,17 +1757,17 @@ var DoculaBuilder = class {
       { ...data, specUrl: data.openApiUrl, apiSpec },
       data.templatePath
     );
-    await fs2.promises.writeFile(apiPath, apiContent, "utf8");
+    await fs3.promises.writeFile(apiPath, apiContent, "utf8");
   }
   getChangelogEntries(changelogPath) {
     const entries = [];
-    if (!fs2.existsSync(changelogPath)) {
+    if (!fs3.existsSync(changelogPath)) {
       return entries;
     }
-    const files = fs2.readdirSync(changelogPath);
+    const files = fs3.readdirSync(changelogPath);
     for (const file of files) {
       const filePath = `${changelogPath}/${file}`;
-      const stats = fs2.statSync(filePath);
+      const stats = fs3.statSync(filePath);
       if (stats.isFile() && (file.endsWith(".md") || file.endsWith(".mdx"))) {
         const entry = this.parseChangelogEntry(filePath);
         entries.push(entry);
@@ -1703,11 +1790,11 @@ var DoculaBuilder = class {
     return entries;
   }
   parseChangelogEntry(filePath) {
-    const fileContent = fs2.readFileSync(filePath, "utf8");
+    const fileContent = fs3.readFileSync(filePath, "utf8");
     const writr = new Writr(fileContent);
     const matterData = writr.frontMatter;
     const markdownContent = writr.body;
-    const fileName = path4.basename(filePath, path4.extname(filePath));
+    const fileName = path5.basename(filePath, path5.extname(filePath));
     const slug = fileName.replace(/^\d{4}-\d{2}-\d{2}-/, "");
     const isMdx = filePath.endsWith(".mdx");
     const tag = matterData.tag;
@@ -1789,14 +1876,14 @@ var DoculaBuilder = class {
     }
     const changelogOutputPath = `${data.output}/changelog`;
     const changelogIndexPath = `${changelogOutputPath}/index.html`;
-    await fs2.promises.mkdir(changelogOutputPath, { recursive: true });
+    await fs3.promises.mkdir(changelogOutputPath, { recursive: true });
     const changelogTemplate = `${data.templatePath}/${data.templates.changelog}`;
     const changelogContent = await this._ecto.renderFromFile(
       changelogTemplate,
       { ...data, entries: data.changelogEntries },
       data.templatePath
     );
-    await fs2.promises.writeFile(changelogIndexPath, changelogContent, "utf8");
+    await fs3.promises.writeFile(changelogIndexPath, changelogContent, "utf8");
   }
   async buildChangelogEntryPages(data) {
     if (!data.hasChangelog || !data.templates?.changelogEntry || !data.changelogEntries?.length) {
@@ -1805,14 +1892,14 @@ var DoculaBuilder = class {
     const entryTemplate = `${data.templatePath}/${data.templates.changelogEntry}`;
     const promises = data.changelogEntries.map(async (entry) => {
       const entryOutputPath = `${data.output}/changelog/${entry.slug}`;
-      await fs2.promises.mkdir(entryOutputPath, { recursive: true });
+      await fs3.promises.mkdir(entryOutputPath, { recursive: true });
       const entryContent = await this._ecto.renderFromFile(
         entryTemplate,
         { ...data, ...entry, entries: data.changelogEntries },
         data.templatePath
       );
       const entryFilePath = `${entryOutputPath}/index.html`;
-      return fs2.promises.writeFile(entryFilePath, entryContent, "utf8");
+      return fs3.promises.writeFile(entryFilePath, entryContent, "utf8");
     });
     await Promise.all(promises);
   }
@@ -1868,7 +1955,7 @@ var DoculaBuilder = class {
   }
   getDocuments(sitePath, doculaData) {
     let documents = [];
-    if (fs2.existsSync(sitePath)) {
+    if (fs3.existsSync(sitePath)) {
       documents = this.getDocumentInDirectory(sitePath);
       doculaData.sections = this.getSections(sitePath, this.options);
       for (const section of doculaData.sections) {
@@ -1881,11 +1968,11 @@ var DoculaBuilder = class {
   }
   getDocumentInDirectory(sitePath) {
     const documents = [];
-    const documentList = fs2.readdirSync(sitePath);
+    const documentList = fs3.readdirSync(sitePath);
     if (documentList.length > 0) {
       for (const document of documentList) {
         const documentPath = `${sitePath}/${document}`;
-        const stats = fs2.statSync(documentPath);
+        const stats = fs3.statSync(documentPath);
         if (stats.isFile() && (document.endsWith(".md") || document.endsWith(".mdx"))) {
           const documentData = this.parseDocumentData(documentPath);
           documents.push(documentData);
@@ -1899,12 +1986,12 @@ var DoculaBuilder = class {
   }
   getSections(sitePath, doculaOptions) {
     const sections = [];
-    if (fs2.existsSync(sitePath)) {
-      const documentList = fs2.readdirSync(sitePath);
+    if (fs3.existsSync(sitePath)) {
+      const documentList = fs3.readdirSync(sitePath);
       if (documentList.length > 0) {
         for (const document of documentList) {
           const documentPath = `${sitePath}/${document}`;
-          const stats = fs2.statSync(documentPath);
+          const stats = fs3.statSync(documentPath);
           if (stats.isDirectory() && this.directoryContainsMarkdown(documentPath)) {
             const section = {
               name: document.replaceAll("-", " ").replaceAll(/\b\w/g, (l) => l.toUpperCase()),
@@ -1935,7 +2022,7 @@ var DoculaBuilder = class {
     return section;
   }
   parseDocumentData(documentPath) {
-    const documentContent = fs2.readFileSync(documentPath, "utf8");
+    const documentContent = fs3.readFileSync(documentPath, "utf8");
     const writr = new Writr(documentContent);
     const matterData = writr.frontMatter;
     let markdownContent = writr.body;
@@ -1987,10 +2074,10 @@ ${markdownContent.slice(firstH2)}`;
     return atxHeading.test(normalized) || setextHeading.test(normalized) || htmlHeading.test(normalized);
   }
   directoryContainsMarkdown(dirPath) {
-    const entries = fs2.readdirSync(dirPath);
+    const entries = fs3.readdirSync(dirPath);
     for (const entry of entries) {
       const fullPath = `${dirPath}/${entry}`;
-      const stat = fs2.statSync(fullPath);
+      const stat = fs3.statSync(fullPath);
       if (stat.isFile() && (entry.endsWith(".md") || entry.endsWith(".mdx"))) {
         return true;
       }
@@ -2001,16 +2088,16 @@ ${markdownContent.slice(firstH2)}`;
     if (this.options.templatePath) {
       return resolvedTemplatePath;
     }
-    const overrideDir = path4.join(sitePath, "templates", templateName);
-    const cacheDir = path4.join(sitePath, ".cache", "templates", templateName);
+    const overrideDir = path5.join(sitePath, "templates", templateName);
+    const cacheDir = path5.join(sitePath, ".cache", "templates", templateName);
     if (!this.isPathWithinBasePath(overrideDir, sitePath) || !this.isPathWithinBasePath(cacheDir, sitePath)) {
       return resolvedTemplatePath;
     }
-    if (!fs2.existsSync(overrideDir)) {
+    if (!fs3.existsSync(overrideDir)) {
       return resolvedTemplatePath;
     }
     const overrideFiles = this.listFilesRecursive(overrideDir);
-    if (fs2.existsSync(cacheDir) && this.isCacheFresh(overrideDir, cacheDir, overrideFiles)) {
+    if (fs3.existsSync(cacheDir) && this.isCacheFresh(overrideDir, cacheDir, overrideFiles)) {
       this._console.step("Using cached template overrides...");
       return cacheDir;
     }
@@ -2021,48 +2108,48 @@ ${markdownContent.slice(firstH2)}`;
       }
     }
     this.ensureCacheInGitignore(sitePath);
-    if (fs2.existsSync(cacheDir)) {
-      fs2.rmSync(cacheDir, { recursive: true, force: true });
+    if (fs3.existsSync(cacheDir)) {
+      fs3.rmSync(cacheDir, { recursive: true, force: true });
     }
-    fs2.mkdirSync(cacheDir, { recursive: true });
+    fs3.mkdirSync(cacheDir, { recursive: true });
     this.copyDirectory(resolvedTemplatePath, cacheDir);
     this.copyDirectory(overrideDir, cacheDir);
-    const manifestPath = path4.join(cacheDir, ".manifest.json");
-    fs2.writeFileSync(manifestPath, JSON.stringify(overrideFiles));
+    const manifestPath = path5.join(cacheDir, ".manifest.json");
+    fs3.writeFileSync(manifestPath, JSON.stringify(overrideFiles));
     return cacheDir;
   }
   ensureCacheInGitignore(sitePath) {
     if (!this.options.autoUpdateIgnores) {
       return;
     }
-    const cacheDir = path4.join(sitePath, ".cache");
-    if (fs2.existsSync(cacheDir)) {
+    const cacheDir = path5.join(sitePath, ".cache");
+    if (fs3.existsSync(cacheDir)) {
       return;
     }
-    const gitignorePath = path4.join(sitePath, ".gitignore");
+    const gitignorePath = path5.join(sitePath, ".gitignore");
     const entry = ".cache";
-    if (fs2.existsSync(gitignorePath)) {
-      const content = fs2.readFileSync(gitignorePath, "utf8");
+    if (fs3.existsSync(gitignorePath)) {
+      const content = fs3.readFileSync(gitignorePath, "utf8");
       if (!content.split("\n").some((line) => line.trim() === entry)) {
-        fs2.appendFileSync(gitignorePath, `
+        fs3.appendFileSync(gitignorePath, `
 ${entry}
 `);
         this._console.info(`Added ${entry} to .gitignore`);
       }
     } else {
-      fs2.writeFileSync(gitignorePath, `${entry}
+      fs3.writeFileSync(gitignorePath, `${entry}
 `);
       this._console.info("Created .gitignore with .cache");
     }
   }
   isCacheFresh(overrideDir, cacheDir, overrideFiles) {
-    const manifestPath = path4.join(cacheDir, ".manifest.json");
-    if (!fs2.existsSync(manifestPath)) {
+    const manifestPath = path5.join(cacheDir, ".manifest.json");
+    if (!fs3.existsSync(manifestPath)) {
       return false;
     }
     try {
       const previousFiles = JSON.parse(
-        fs2.readFileSync(manifestPath, "utf8")
+        fs3.readFileSync(manifestPath, "utf8")
       );
       if (previousFiles.length !== overrideFiles.length || !previousFiles.every((f, i) => f === overrideFiles[i])) {
         return false;
@@ -2071,13 +2158,13 @@ ${entry}
       return false;
     }
     for (const file of overrideFiles) {
-      const overridePath = path4.join(overrideDir, file);
-      const cachedPath = path4.join(cacheDir, file);
-      if (!fs2.existsSync(cachedPath)) {
+      const overridePath = path5.join(overrideDir, file);
+      const cachedPath = path5.join(cacheDir, file);
+      if (!fs3.existsSync(cachedPath)) {
         return false;
       }
-      const overrideMtime = fs2.statSync(overridePath).mtimeMs;
-      const cachedMtime = fs2.statSync(cachedPath).mtimeMs;
+      const overrideMtime = fs3.statSync(overridePath).mtimeMs;
+      const cachedMtime = fs3.statSync(cachedPath).mtimeMs;
       if (overrideMtime > cachedMtime) {
         return false;
       }
@@ -2086,14 +2173,14 @@ ${entry}
   }
   listFilesRecursive(dir, prefix = "") {
     const results = [];
-    const entries = fs2.readdirSync(dir);
+    const entries = fs3.readdirSync(dir);
     for (const entry of entries) {
       if (entry.startsWith(".")) {
         continue;
       }
-      const fullPath = path4.join(dir, entry);
+      const fullPath = path5.join(dir, entry);
       const relativePath = prefix ? `${prefix}/${entry}` : entry;
-      const stat = fs2.lstatSync(fullPath);
+      const stat = fs3.lstatSync(fullPath);
       if (stat.isSymbolicLink()) {
         continue;
       }
@@ -2106,55 +2193,55 @@ ${entry}
     return results;
   }
   copyDirectory(source, target) {
-    const files = fs2.readdirSync(source);
+    const files = fs3.readdirSync(source);
     for (const file of files) {
       if (file.startsWith(".")) {
         continue;
       }
       const sourcePath = `${source}/${file}`;
       const targetPath = `${target}/${file}`;
-      const stat = fs2.lstatSync(sourcePath);
+      const stat = fs3.lstatSync(sourcePath);
       if (stat.isSymbolicLink()) {
         continue;
       }
       if (stat.isDirectory()) {
-        fs2.mkdirSync(targetPath, { recursive: true });
+        fs3.mkdirSync(targetPath, { recursive: true });
         this.copyDirectory(sourcePath, targetPath);
       } else {
-        fs2.mkdirSync(target, { recursive: true });
-        fs2.copyFileSync(sourcePath, targetPath);
+        fs3.mkdirSync(target, { recursive: true });
+        fs3.copyFileSync(sourcePath, targetPath);
       }
     }
   }
   copyPublicFolder(sitePath, output) {
     const publicPath = `${sitePath}/public`;
-    if (!fs2.existsSync(publicPath)) {
+    if (!fs3.existsSync(publicPath)) {
       return;
     }
     this._console.step("Copying public folder...");
-    const resolvedOutput = path4.resolve(output);
+    const resolvedOutput = path5.resolve(output);
     this.copyPublicDirectory(publicPath, output, publicPath, resolvedOutput);
   }
   copyPublicDirectory(source, target, basePath, output) {
-    const files = fs2.readdirSync(source);
+    const files = fs3.readdirSync(source);
     for (const file of files) {
       const sourcePath = `${source}/${file}`;
       const targetPath = `${target}/${file}`;
       const relativePath = sourcePath.replace(`${basePath}/`, "");
-      const resolvedSourcePath = path4.resolve(sourcePath);
-      if (resolvedSourcePath === output || resolvedSourcePath.startsWith(`${output}${path4.sep}`)) {
+      const resolvedSourcePath = path5.resolve(sourcePath);
+      if (resolvedSourcePath === output || resolvedSourcePath.startsWith(`${output}${path5.sep}`)) {
         continue;
       }
-      const stat = fs2.lstatSync(sourcePath);
+      const stat = fs3.lstatSync(sourcePath);
       if (stat.isSymbolicLink()) {
         continue;
       }
       if (stat.isDirectory()) {
-        fs2.mkdirSync(targetPath, { recursive: true });
+        fs3.mkdirSync(targetPath, { recursive: true });
         this.copyPublicDirectory(sourcePath, targetPath, basePath, output);
       } else {
-        fs2.mkdirSync(target, { recursive: true });
-        fs2.copyFileSync(sourcePath, targetPath);
+        fs3.mkdirSync(target, { recursive: true });
+        fs3.copyFileSync(sourcePath, targetPath);
         this._console.fileCopied(relativePath);
       }
     }
@@ -2164,18 +2251,18 @@ ${entry}
       return;
     }
     for (const document of data.documents) {
-      const sourceDir = path4.dirname(document.documentPath);
-      const outputDir = `${data.output}${path4.dirname(document.urlPath)}`;
+      const sourceDir = path5.dirname(document.documentPath);
+      const outputDir = `${data.output}${path5.dirname(document.urlPath)}`;
       const availableAssets = this.listContentAssets(sourceDir);
       for (const assetRelPath of availableAssets) {
         if (document.markdown.includes(assetRelPath)) {
-          const source = path4.join(sourceDir, assetRelPath);
-          if (fs2.lstatSync(source).isSymbolicLink()) {
+          const source = path5.join(sourceDir, assetRelPath);
+          if (fs3.lstatSync(source).isSymbolicLink()) {
             continue;
           }
-          const target = path4.join(outputDir, assetRelPath);
-          fs2.mkdirSync(path4.dirname(target), { recursive: true });
-          fs2.copyFileSync(source, target);
+          const target = path5.join(outputDir, assetRelPath);
+          fs3.mkdirSync(path5.dirname(target), { recursive: true });
+          fs3.copyFileSync(source, target);
         }
       }
     }
@@ -2183,52 +2270,52 @@ ${entry}
   listContentAssets(sourcePath, basePath) {
     const root = basePath ?? sourcePath;
     const results = [];
-    if (!fs2.existsSync(sourcePath)) {
+    if (!fs3.existsSync(sourcePath)) {
       return results;
     }
-    const files = fs2.readdirSync(sourcePath);
+    const files = fs3.readdirSync(sourcePath);
     for (const file of files) {
       if (file.startsWith(".")) {
         continue;
       }
       const fullPath = `${sourcePath}/${file}`;
-      const stat = fs2.lstatSync(fullPath);
+      const stat = fs3.lstatSync(fullPath);
       if (stat.isSymbolicLink()) {
         continue;
       }
       if (stat.isDirectory()) {
         results.push(...this.listContentAssets(fullPath, root));
       } else {
-        const ext = path4.extname(file).toLowerCase();
+        const ext = path5.extname(file).toLowerCase();
         if (this.options.allowedAssets.includes(ext)) {
-          results.push(path4.relative(root, fullPath));
+          results.push(path5.relative(root, fullPath));
         }
       }
     }
     return results;
   }
   copyContentAssets(sourcePath, targetPath) {
-    if (!fs2.existsSync(sourcePath)) {
+    if (!fs3.existsSync(sourcePath)) {
       return;
     }
-    const files = fs2.readdirSync(sourcePath);
+    const files = fs3.readdirSync(sourcePath);
     for (const file of files) {
       if (file.startsWith(".")) {
         continue;
       }
       const source = `${sourcePath}/${file}`;
       const target = `${targetPath}/${file}`;
-      const stat = fs2.lstatSync(source);
+      const stat = fs3.lstatSync(source);
       if (stat.isSymbolicLink()) {
         continue;
       }
       if (stat.isDirectory()) {
         this.copyContentAssets(source, target);
       } else {
-        const ext = path4.extname(file).toLowerCase();
+        const ext = path5.extname(file).toLowerCase();
         if (this.options.allowedAssets.includes(ext)) {
-          fs2.mkdirSync(targetPath, { recursive: true });
-          fs2.copyFileSync(source, target);
+          fs3.mkdirSync(targetPath, { recursive: true });
+          fs3.copyFileSync(source, target);
         }
       }
     }
@@ -2304,13 +2391,13 @@ var Docula = class {
    * @param {string} sitePath
    */
   cleanCache(sitePath) {
-    const resolvedSitePath = path5.resolve(sitePath);
-    const cachePath = path5.resolve(resolvedSitePath, ".cache");
-    if (!cachePath.startsWith(resolvedSitePath + path5.sep) && cachePath !== resolvedSitePath) {
+    const resolvedSitePath = path6.resolve(sitePath);
+    const cachePath = path6.resolve(resolvedSitePath, ".cache");
+    if (!cachePath.startsWith(resolvedSitePath + path6.sep) && cachePath !== resolvedSitePath) {
       return;
     }
-    if (fs3.existsSync(cachePath)) {
-      fs3.rmSync(cachePath, { recursive: true, force: true });
+    if (fs4.existsSync(cachePath)) {
+      fs4.rmSync(cachePath, { recursive: true, force: true });
     }
   }
   /**
@@ -2318,9 +2405,9 @@ var Docula = class {
    * @returns {void}
    */
   checkForUpdates() {
-    const packageJsonPath = path5.join(process4.cwd(), "package.json");
-    if (fs3.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    const packageJsonPath = path6.join(process4.cwd(), "package.json");
+    if (fs4.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
       updateNotifier({ pkg: packageJson }).notify();
     }
   }
@@ -2376,8 +2463,8 @@ var Docula = class {
       }
       case "serve": {
         if (consoleProcess.args.build || consoleProcess.args.watch) {
-          if (consoleProcess.args.clean && fs3.existsSync(this.options.output)) {
-            fs3.rmSync(this.options.output, { recursive: true, force: true });
+          if (consoleProcess.args.clean && fs4.existsSync(this.options.output)) {
+            fs4.rmSync(this.options.output, { recursive: true, force: true });
           }
           if (consoleProcess.args.clean) {
             this.cleanCache(this.options.sitePath);
@@ -2392,8 +2479,8 @@ var Docula = class {
         break;
       }
       default: {
-        if (consoleProcess.args.clean && fs3.existsSync(this.options.output)) {
-          fs3.rmSync(this.options.output, { recursive: true, force: true });
+        if (consoleProcess.args.clean && fs4.existsSync(this.options.output)) {
+          fs4.rmSync(this.options.output, { recursive: true, force: true });
         }
         if (consoleProcess.args.clean) {
           this.cleanCache(this.options.sitePath);
@@ -2411,8 +2498,8 @@ var Docula = class {
    * @returns {void}
    */
   generateInit(sitePath, typescript = false) {
-    if (!fs3.existsSync(sitePath)) {
-      fs3.mkdirSync(sitePath);
+    if (!fs4.existsSync(sitePath)) {
+      fs4.mkdirSync(sitePath);
     }
     const configExtension = typescript ? "ts" : "mjs";
     const doculaConfigFile = `${sitePath}/docula.config.${configExtension}`;
@@ -2420,11 +2507,11 @@ var Docula = class {
       typescript ? doculaconfigts : doculaconfigmjs,
       "base64"
     );
-    fs3.writeFileSync(doculaConfigFile, doculaConfigFileBuffer);
+    fs4.writeFileSync(doculaConfigFile, doculaConfigFileBuffer);
     const logoBuffer = Buffer.from(logopng, "base64");
-    fs3.writeFileSync(`${sitePath}/logo.png`, logoBuffer);
+    fs4.writeFileSync(`${sitePath}/logo.png`, logoBuffer);
     const faviconBuffer = Buffer.from(faviconico, "base64");
-    fs3.writeFileSync(`${sitePath}/favicon.ico`, faviconBuffer);
+    fs4.writeFileSync(`${sitePath}/favicon.ico`, faviconBuffer);
     this._console.log(
       `docula initialized. Please update the ${doculaConfigFile} file with your site information. In addition, you can replace the image and favicon.`
     );
@@ -2434,7 +2521,7 @@ var Docula = class {
    * @returns {string}
    */
   getVersion() {
-    const packageJson = fs3.readFileSync("./package.json", "utf8");
+    const packageJson = fs4.readFileSync("./package.json", "utf8");
     const packageObject = JSON.parse(packageJson);
     return packageObject.version;
   }
@@ -2445,21 +2532,21 @@ var Docula = class {
    * @returns {Promise<void>}
    */
   async loadConfigFile(sitePath) {
-    if (!fs3.existsSync(sitePath)) {
+    if (!fs4.existsSync(sitePath)) {
       return;
     }
     const tsConfigFile = `${sitePath}/docula.config.ts`;
     const mjsConfigFile = `${sitePath}/docula.config.mjs`;
-    if (fs3.existsSync(tsConfigFile)) {
-      const absolutePath = path5.resolve(tsConfigFile);
+    if (fs4.existsSync(tsConfigFile)) {
+      const absolutePath = path6.resolve(tsConfigFile);
       const jiti = createJiti(import.meta.url, {
         interopDefault: true
       });
       this._configFileModule = await jiti.import(absolutePath);
       return;
     }
-    if (fs3.existsSync(mjsConfigFile)) {
-      const absolutePath = path5.resolve(mjsConfigFile);
+    if (fs4.existsSync(mjsConfigFile)) {
+      const absolutePath = path6.resolve(mjsConfigFile);
       this._configFileModule = await import(pathToFileURL(absolutePath).href);
     }
   }
@@ -2476,7 +2563,7 @@ var Docula = class {
     let debounceTimer;
     let isBuilding = false;
     let pendingRebuild = false;
-    const outputRelative = path5.relative(options.sitePath, options.output);
+    const outputRelative = path6.relative(options.sitePath, options.output);
     const runBuild = async (filename) => {
       isBuilding = true;
       this._console.info(`File changed: ${filename}, rebuilding...`);
@@ -2493,11 +2580,11 @@ var Docula = class {
         }
       }
     };
-    this._watcher = fs3.watch(
+    this._watcher = fs4.watch(
       options.sitePath,
       { recursive: true },
       (_eventType, filename) => {
-        if (filename && outputRelative && !outputRelative.startsWith("..") && (String(filename) === outputRelative || String(filename).startsWith(`${outputRelative}${path5.sep}`))) {
+        if (filename && outputRelative && !outputRelative.startsWith("..") && (String(filename) === outputRelative || String(filename).startsWith(`${outputRelative}${path6.sep}`))) {
           return;
         }
         if (isBuilding) {
@@ -2526,8 +2613,8 @@ var Docula = class {
     }
     const { port } = options;
     const { output } = options;
-    if (!fs3.existsSync(output)) {
-      fs3.mkdirSync(output, { recursive: true });
+    if (!fs4.existsSync(output)) {
+      fs4.mkdirSync(output, { recursive: true });
     }
     const config = {
       public: output
@@ -2561,9 +2648,9 @@ export {
   Docula as default
 };
 /* v8 ignore next -- @preserve */
+/* v8 ignore next 3 -- @preserve */
 /* v8 ignore next 2 -- @preserve */
 /* v8 ignore next 9 -- @preserve */
-/* v8 ignore next 3 -- @preserve */
 /* v8 ignore next 4 -- @preserve */
 /* v8 ignore start -- @preserve */
 /* v8 ignore stop -- @preserve */