livemark 0.0.0-dev → 0.7.0

package/README.md

@@ -1,3 +1,7 @@
 # Livemark
 
-Livemark description
+[![Build](https://img.shields.io/github/actions/workflow/status/datisthq/livemark/general.yaml?branch=main)](https://github.com/datisthq/livemark/actions)
+[![Coverage](https://img.shields.io/codecov/c/github/datisthq/livemark/main)](https://codecov.io/gh/datisthq/livemark)
+[![Version](https://img.shields.io/npm/v/livemark)](https://www.npmjs.com/package/livemark)
+
+Livemark turns your .md files into a fast, modern documentation site — with Shiki, Mermaid, LaTeX, MDX components, blog and changelog sections, all built in. For more information, please read the [project's documentation](https://livemark.dev).

package/build/actions/changelog/build.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from "../../models/config.ts";
+import type { ChangelogSection } from "../../models/section.ts";
+interface ChangelogEntry {
+    slug: string;
+    title: string;
+    date?: string;
+    body: string;
+}
+export declare function cacheIncludeGlob(): string;
+/** Build the per-version changelog cache files for a changelog section */
+export declare function buildChangelog(section: ChangelogSection, config: Config): Promise<void>;
+/** Parse CHANGELOG.md into per-version entries using mdast */
+export declare function splitLocalChangelog(body: string): ChangelogEntry[];
+export {};

package/build/actions/changelog/build.js

@@ -0,0 +1,158 @@
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import slugify from "@sindresorhus/slugify";
+import { toString as mdastToString } from "mdast-util-to-string";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import { isGitHubUrl, parseGitHubRepo, } from "../../website/helpers/changelog-source.js";
+const CACHE_DIR = ".livemark/cache/changelog";
+const META_FILE = ".livemark/cache/changelog.meta.json";
+const parser = unified().use(remarkParse);
+const stringifier = unified().use(remarkStringify, {
+    bullet: "-",
+    fences: true,
+    emphasis: "_",
+});
+export function cacheIncludeGlob() {
+    return `${CACHE_DIR}/**/*.md`;
+}
+/** Build the per-version changelog cache files for a changelog section */
+export async function buildChangelog(section, config) {
+    const cacheDir = join(config.root, CACHE_DIR);
+    const metaPath = join(config.root, META_FILE);
+    const entries = isGitHubUrl(section.source)
+        ? await buildFromGitHub(section.source, metaPath, cacheDir)
+        : await buildFromLocal(section.source, config.root);
+    if (entries === undefined)
+        return;
+    await rm(cacheDir, { recursive: true, force: true });
+    await mkdir(cacheDir, { recursive: true });
+    for (const entry of entries) {
+        const markdown = wrapFrontmatter(entry, section);
+        await writeFile(join(cacheDir, `${entry.slug}.md`), markdown, "utf-8");
+    }
+}
+async function buildFromLocal(source, root) {
+    const filePath = resolve(root, source);
+    const body = await readFile(filePath, "utf-8");
+    return splitLocalChangelog(body);
+}
+/** Parse CHANGELOG.md into per-version entries using mdast */
+export function splitLocalChangelog(body) {
+    const tree = parser.parse(body);
+    const entries = [];
+    let current;
+    for (const child of tree.children) {
+        if (child.type === "heading" && child.depth === 2) {
+            if (current)
+                entries.push(finalizeEntry(current));
+            current = { heading: mdastToString(child), children: [] };
+        }
+        else if (current) {
+            current.children.push(child);
+        }
+    }
+    if (current)
+        entries.push(finalizeEntry(current));
+    return entries;
+}
+function finalizeEntry(input) {
+    const versionMatch = input.heading.match(/^\[?([^\]\s]+)\]?/);
+    const version = versionMatch?.[1] ?? input.heading;
+    const dateMatch = input.heading.match(/\d{4}-\d{2}-\d{2}/);
+    const body = renderEntryBody(input.children);
+    return {
+        slug: slugify(version),
+        title: version,
+        date: dateMatch?.[0],
+        body,
+    };
+}
+/** Serialize an entry's mdast children back to markdown */
+function renderEntryBody(children) {
+    const root = { type: "root", children };
+    return stringifier.stringify(root).trimEnd();
+}
+/** Shift h2–h6 up by one so the version becomes the article's h1 */
+function promoteHeadings(body) {
+    const tree = parser.parse(body);
+    visit(tree, "heading", node => {
+        if (node.depth > 1)
+            node.depth = (node.depth - 1);
+    });
+    return stringifier.stringify(tree).trimEnd();
+}
+async function buildFromGitHub(source, metaPath, cacheDir) {
+    const parsed = parseGitHubRepo(source);
+    if (!parsed) {
+        throw new Error(`Could not parse GitHub repo from source: ${source}`);
+    }
+    const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/releases?per_page=100`;
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const meta = await readMeta(metaPath);
+    const hasCache = await exists(cacheDir);
+    if (meta && hasCache)
+        headers["If-None-Match"] = meta.etag;
+    const res = await fetch(url, { headers });
+    if (res.status === 304)
+        return undefined;
+    if (!res.ok) {
+        const remaining = res.headers.get("x-ratelimit-remaining");
+        const reset = res.headers.get("x-ratelimit-reset");
+        const msg = `GitHub API ${res.status} ${res.statusText} (rate-limit remaining: ${remaining ?? "?"}, reset: ${reset ?? "?"})`;
+        if (hasCache) {
+            console.warn(`${msg} — falling back to cached changelog`);
+            return undefined;
+        }
+        throw new Error(msg);
+    }
+    const releases = (await res.json());
+    const etag = res.headers.get("etag");
+    if (etag) {
+        await writeFile(metaPath, JSON.stringify({ etag, fetchedAt: new Date().toISOString() }, null, 2), "utf-8");
+    }
+    return releases.map(release => ({
+        slug: slugify(release.tag_name),
+        title: release.tag_name,
+        date: release.published_at?.slice(0, 10),
+        body: (release.body ?? "").trim(),
+    }));
+}
+function wrapFrontmatter(entry, section) {
+    const lines = [
+        "---",
+        `title: ${entry.title}`,
+        `path: ${section.prefix}${entry.slug}/`,
+    ];
+    if (entry.date)
+        lines.push(`date: ${entry.date}`);
+    lines.push("---", "", `# ${entry.title}`, "", promoteHeadings(entry.body));
+    return lines.join("\n");
+}
+async function readMeta(metaPath) {
+    try {
+        const raw = await readFile(metaPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../actions/changelog/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { access, mkdir, readFile, rm, writeFile } from \"node:fs/promises\"\nimport { join, resolve } from \"node:path\"\nimport slugify from \"@sindresorhus/slugify\"\nimport type { Root, RootContent } from \"mdast\"\nimport { toString as mdastToString } from \"mdast-util-to-string\"\nimport remarkParse from \"remark-parse\"\nimport remarkStringify from \"remark-stringify\"\nimport { unified } from \"unified\"\nimport { visit } from \"unist-util-visit\"\nimport type { Config } from \"../../models/config.ts\"\nimport type { ChangelogSection } from \"../../models/section.ts\"\nimport {\n  isGitHubUrl,\n  parseGitHubRepo,\n} from \"../../website/helpers/changelog-source.ts\"\n\ninterface Release {\n  tag_name: string\n  name?: string | null\n  published_at?: string | null\n  body?: string | null\n}\n\ninterface CacheMeta {\n  etag: string\n  fetchedAt: string\n}\n\ninterface ChangelogEntry {\n  slug: string\n  title: string\n  date?: string\n  body: string\n}\n\nconst CACHE_DIR = \".livemark/cache/changelog\"\nconst META_FILE = \".livemark/cache/changelog.meta.json\"\n\nconst parser = unified().use(remarkParse)\nconst stringifier = unified().use(remarkStringify, {\n  bullet: \"-\",\n  fences: true,\n  emphasis: \"_\",\n})\n\nexport function cacheIncludeGlob() {\n  return `${CACHE_DIR}/**/*.md`\n}\n\n/** Build the per-version changelog cache files for a changelog section */\nexport async function buildChangelog(\n  section: ChangelogSection,\n  config: Config,\n) {\n  const cacheDir = join(config.root, CACHE_DIR)\n  const metaPath = join(config.root, META_FILE)\n\n  const entries = isGitHubUrl(section.source)\n    ? await buildFromGitHub(section.source, metaPath, cacheDir)\n    : await buildFromLocal(section.source, config.root)\n\n  if (entries === undefined) return\n\n  await rm(cacheDir, { recursive: true, force: true })\n  await mkdir(cacheDir, { recursive: true })\n\n  for (const entry of entries) {\n    const markdown = wrapFrontmatter(entry, section)\n    await writeFile(join(cacheDir, `${entry.slug}.md`), markdown, \"utf-8\")\n  }\n}\n\nasync function buildFromLocal(source: string, root: string) {\n  const filePath = resolve(root, source)\n  const body = await readFile(filePath, \"utf-8\")\n  return splitLocalChangelog(body)\n}\n\n/** Parse CHANGELOG.md into per-version entries using mdast */\nexport function splitLocalChangelog(body: string): ChangelogEntry[] {\n  const tree = parser.parse(body) as Root\n  const entries: ChangelogEntry[] = []\n  let current: { heading: string; children: RootContent[] } | undefined\n\n  for (const child of tree.children) {\n    if (child.type === \"heading\" && child.depth === 2) {\n      if (current) entries.push(finalizeEntry(current))\n      current = { heading: mdastToString(child), children: [] }\n    } else if (current) {\n      current.children.push(child)\n    }\n  }\n  if (current) entries.push(finalizeEntry(current))\n  return entries\n}\n\nfunction finalizeEntry(input: {\n  heading: string\n  children: RootContent[]\n}): ChangelogEntry {\n  const versionMatch = input.heading.match(/^\\[?([^\\]\\s]+)\\]?/)\n  const version = versionMatch?.[1] ?? input.heading\n  const dateMatch = input.heading.match(/\\d{4}-\\d{2}-\\d{2}/)\n  const body = renderEntryBody(input.children)\n  return {\n    slug: slugify(version),\n    title: version,\n    date: dateMatch?.[0],\n    body,\n  }\n}\n\n/** Serialize an entry's mdast children back to markdown */\nfunction renderEntryBody(children: RootContent[]) {\n  const root: Root = { type: \"root\", children }\n  return stringifier.stringify(root).trimEnd()\n}\n\n/** Shift h2–h6 up by one so the version becomes the article's h1 */\nfunction promoteHeadings(body: string) {\n  const tree = parser.parse(body) as Root\n  visit(tree, \"heading\", node => {\n    if (node.depth > 1) node.depth = (node.depth - 1) as 1 | 2 | 3 | 4 | 5\n  })\n  return stringifier.stringify(tree).trimEnd()\n}\n\nasync function buildFromGitHub(\n  source: string,\n  metaPath: string,\n  cacheDir: string,\n): Promise<ChangelogEntry[] | undefined> {\n  const parsed = parseGitHubRepo(source)\n  if (!parsed) {\n    throw new Error(`Could not parse GitHub repo from source: ${source}`)\n  }\n\n  const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/releases?per_page=100`\n  const headers: Record<string, string> = {\n    Accept: \"application/vnd.github+json\",\n    \"X-GitHub-Api-Version\": \"2022-11-28\",\n  }\n\n  const token = process.env.GITHUB_TOKEN\n  if (token) headers.Authorization = `Bearer ${token}`\n\n  const meta = await readMeta(metaPath)\n  const hasCache = await exists(cacheDir)\n  if (meta && hasCache) headers[\"If-None-Match\"] = meta.etag\n\n  const res = await fetch(url, { headers })\n\n  if (res.status === 304) return undefined\n\n  if (!res.ok) {\n    const remaining = res.headers.get(\"x-ratelimit-remaining\")\n    const reset = res.headers.get(\"x-ratelimit-reset\")\n    const msg = `GitHub API ${res.status} ${res.statusText} (rate-limit remaining: ${remaining ?? \"?\"}, reset: ${reset ?? \"?\"})`\n    if (hasCache) {\n      console.warn(`${msg} — falling back to cached changelog`)\n      return undefined\n    }\n    throw new Error(msg)\n  }\n\n  const releases = (await res.json()) as Release[]\n  const etag = res.headers.get(\"etag\")\n  if (etag) {\n    await writeFile(\n      metaPath,\n      JSON.stringify(\n        { etag, fetchedAt: new Date().toISOString() } satisfies CacheMeta,\n        null,\n        2,\n      ),\n      \"utf-8\",\n    )\n  }\n\n  return releases.map(release => ({\n    slug: slugify(release.tag_name),\n    title: release.tag_name,\n    date: release.published_at?.slice(0, 10),\n    body: (release.body ?? \"\").trim(),\n  }))\n}\n\nfunction wrapFrontmatter(entry: ChangelogEntry, section: ChangelogSection) {\n  const lines = [\n    \"---\",\n    `title: ${entry.title}`,\n    `path: ${section.prefix}${entry.slug}/`,\n  ]\n  if (entry.date) lines.push(`date: ${entry.date}`)\n  lines.push(\"---\", \"\", `# ${entry.title}`, \"\", promoteHeadings(entry.body))\n  return lines.join(\"\\n\")\n}\n\nasync function readMeta(metaPath: string): Promise<CacheMeta | undefined> {\n  try {\n    const raw = await readFile(metaPath, \"utf-8\")\n    return JSON.parse(raw) as CacheMeta\n  } catch {\n    return undefined\n  }\n}\n\nasync function exists(path: string) {\n  try {\n    await access(path)\n    return true\n  } catch {\n    return false\n  }\n}\n"]}

package/build/actions/changelog/build.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/actions/changelog/build.unit.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vite-plus/test";
+import { splitLocalChangelog } from "./build.js";
+describe("splitLocalChangelog", () => {
+    it("splits by h2 headings", () => {
+        const input = `# Changelog
+
+## [0.2.0] - 2026-04-15
+
+### Added
+
+- Foo
+
+## [0.1.0] - 2026-04-10
+
+Initial release.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]?.title).toBe("0.2.0");
+        expect(entries[0]?.date).toBe("2026-04-15");
+        expect(entries[0]?.slug).toBe("0-2-0");
+        expect(entries[1]?.title).toBe("0.1.0");
+        expect(entries[1]?.date).toBe("2026-04-10");
+    });
+    it("preserves h3 heading structure in body", () => {
+        const input = `## 1.0.0
+
+### Added
+
+- Thing one
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries[0]?.body).toContain("### Added");
+        expect(entries[0]?.body).toContain("- Thing one");
+    });
+    it("ignores ## inside fenced code blocks", () => {
+        const input = `## 1.0.0
+
+Some prose.
+
+\`\`\`md
+## Not a real version heading
+\`\`\`
+
+## 0.9.0
+
+Older.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]?.title).toBe("1.0.0");
+        expect(entries[0]?.body).toContain("Not a real version heading");
+        expect(entries[1]?.title).toBe("0.9.0");
+    });
+    it("handles bare version headings without brackets or date", () => {
+        const input = `## v1.2.3
+
+Release notes.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries[0]?.title).toBe("v1.2.3");
+        expect(entries[0]?.slug).toBe("v1-2-3");
+        expect(entries[0]?.date).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/config/define.unit.js

@@ -2,33 +2,28 @@ import { describe, expect, it } from "vite-plus/test";
 import { defineConfig } from "./define.js";
 describe("defineConfig", () => {
     it("should accept include as a string", () => {
-        const config = defineConfig({ articles: { include: "articles/**/*.mdx" } });
-        expect(config.articles.include).toBe("articles/**/*.mdx");
+        const config = defineConfig({ include: "articles/**/*.mdx" });
+        expect(config.include).toBe("articles/**/*.mdx");
     });
     it("should accept include as an array", () => {
         const config = defineConfig({
-            articles: { include: ["articles/**/*.mdx", "guides/**/*.mdx"] },
+            include: ["articles/**/*.mdx", "guides/**/*.mdx"],
         });
-        expect(config.articles.include).toEqual([
-            "articles/**/*.mdx",
-            "guides/**/*.mdx",
-        ]);
+        expect(config.include).toEqual(["articles/**/*.mdx", "guides/**/*.mdx"]);
     });
     it("should accept optional exclude", () => {
         const config = defineConfig({
-            articles: { include: "**/*.mdx", exclude: "drafts/**" },
+            include: "**/*.mdx",
+            exclude: "drafts/**",
         });
-        expect(config.articles.exclude).toBe("drafts/**");
+        expect(config.exclude).toBe("drafts/**");
     });
     it("should allow omitting exclude", () => {
-        const config = defineConfig({ articles: { include: "**/*.mdx" } });
-        expect(config.articles.exclude).toBeUndefined();
-    });
-    it("should reject missing articles", () => {
-        expect(() => defineConfig({})).toThrow();
+        const config = defineConfig({ include: "**/*.mdx" });
+        expect(config.exclude).toBeUndefined();
     });
     it("should reject missing include", () => {
-        expect(() => defineConfig({ articles: {} })).toThrow();
+        expect(() => defineConfig({})).toThrow();
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/config/load.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { defineConfig } from "./define.js";
 /**
  * Load and validate a config file, checking --config/-c CLI arg, then cwd.
@@ -15,8 +16,10 @@ export async function loadConfig(path) {
     const configIndex = process.argv.findIndex(a => a === "-c" || a === "--config");
     const cliPath = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
     const resolved = resolve(path ?? cliPath ?? "livemark.config.ts");
-    const module = await import(__rewriteRelativeImportExtension(resolved));
+    // Cache-bust the ESM import so dev-server restart reloads edits on disk.
+    const url = `${pathToFileURL(resolved).href}?t=${Date.now()}`;
+    const module = await import(__rewriteRelativeImportExtension(url));
     const input = defineConfig(module.default);
-    return { ...input, root: dirname(resolved) };
+    return { ...input, root: dirname(resolved), configPath: resolved };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/config/load.unit.js

@@ -9,9 +9,9 @@ describe("loadConfig", () => {
     });
     it("should load config from explicit path", () => temporaryDirectoryTask(async (tmpDir) => {
         const configPath = join(tmpDir, "livemark.config.ts");
-        fs.writeFileSync(configPath, 'export default { articles: { include: "articles/**/*.mdx" } }\n');
+        fs.writeFileSync(configPath, 'export default { include: "articles/**/*.mdx" }\n');
         const config = await loadConfig(configPath);
-        expect(config.articles.include).toBe("articles/**/*.mdx");
+        expect(config.include).toBe("articles/**/*.mdx");
         expect(config.root).toBe(tmpDir);
     }));
     it("should validate loaded config", () => temporaryDirectoryTask(async (tmpDir) => {
@@ -20,4 +20,4 @@ describe("loadConfig", () => {
         await expect(loadConfig(configPath)).rejects.toThrow();
     }));
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/commands/build.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { Command } from "commander";
-import { build as viteBuild } from "vite";
+import { createBuilder } from "vite";
 const configFile = join(import.meta.dirname, "..", "website", "vite.config.ts");
 /**
  * Build the site for production.
@@ -8,6 +8,7 @@ const configFile = join(import.meta.dirname, "..", "website", "vite.config.ts");
 export const build = new Command("build")
     .description("Build the site for production")
     .action(async () => {
-    await viteBuild({ configFile });
+    const builder = await createBuilder({ configFile });
+    await builder.buildApp();
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9jb21tYW5kcy9idWlsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLEtBQUssSUFBSSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFFekMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLGdCQUFnQixDQUFDLENBQUE7QUFFL0U7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDO0tBQ3RDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQztLQUM1QyxNQUFNLENBQUMsS0FBSyxJQUFJLEVBQUU7SUFDakIsTUFBTSxTQUFTLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFBO0FBQ2pDLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIlxuaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gXCJjb21tYW5kZXJcIlxuaW1wb3J0IHsgYnVpbGQgYXMgdml0ZUJ1aWxkIH0gZnJvbSBcInZpdGVcIlxuXG5jb25zdCBjb25maWdGaWxlID0gam9pbihpbXBvcnQubWV0YS5kaXJuYW1lLCBcIi4uXCIsIFwid2Vic2l0ZVwiLCBcInZpdGUuY29uZmlnLnRzXCIpXG5cbi8qKlxuICogQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBidWlsZCA9IG5ldyBDb21tYW5kKFwiYnVpbGRcIilcbiAgLmRlc2NyaXB0aW9uKFwiQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb25cIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgYXdhaXQgdml0ZUJ1aWxkKHsgY29uZmlnRmlsZSB9KVxuICB9KVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9jb21tYW5kcy9idWlsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUVwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtBQUUvRTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUM7S0FDdEMsV0FBVyxDQUFDLCtCQUErQixDQUFDO0tBQzVDLE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtJQUNqQixNQUFNLE9BQU8sR0FBRyxNQUFNLGFBQWEsQ0FBQyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUE7SUFDbkQsTUFBTSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUE7QUFDMUIsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiXG5pbXBvcnQgeyBjcmVhdGVCdWlsZGVyIH0gZnJvbSBcInZpdGVcIlxuXG5jb25zdCBjb25maWdGaWxlID0gam9pbihpbXBvcnQubWV0YS5kaXJuYW1lLCBcIi4uXCIsIFwid2Vic2l0ZVwiLCBcInZpdGUuY29uZmlnLnRzXCIpXG5cbi8qKlxuICogQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBidWlsZCA9IG5ldyBDb21tYW5kKFwiYnVpbGRcIilcbiAgLmRlc2NyaXB0aW9uKFwiQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb25cIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3QgYnVpbGRlciA9IGF3YWl0IGNyZWF0ZUJ1aWxkZXIoeyBjb25maWdGaWxlIH0pXG4gICAgYXdhaXQgYnVpbGRlci5idWlsZEFwcCgpXG4gIH0pXG4iXX0=

package/build/commands/escape.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+/**
+ * List or copy overridable livemark files into `.livemark/`.
+ *
+ * Without an argument, prints every file you can shadow. With a path, copies
+ * the default from the livemark package into `.livemark/<path>`; fails if the
+ * destination already exists.
+ */
+export declare const escape: Command;

package/build/commands/escape.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { Command } from "commander";
+import pc from "picocolors";
+import { OVERRIDE_SUBDIRS } from "../website/plugins/vite-livemark.js";
+const defaultsRoot = join(import.meta.dirname, "..", "website");
+/**
+ * List or copy overridable livemark files into `.livemark/`.
+ *
+ * Without an argument, prints every file you can shadow. With a path, copies
+ * the default from the livemark package into `.livemark/<path>`; fails if the
+ * destination already exists.
+ */
+export const escape = new Command("escape")
+    .description("List or copy overridable livemark files into .livemark/")
+    .argument("[path]", "path relative to .livemark/ (e.g. components/Footer.tsx)")
+    .action((relPath) => {
+    if (!relPath) {
+        for (const file of listOverridable())
+            console.log(file);
+        console.log(pc.dim("\nRun 'livemark escape <path>' to copy a file into .livemark/"));
+        return;
+    }
+    const [first] = relPath.split("/");
+    if (!first || !OVERRIDE_SUBDIRS.includes(first) || relPath.includes("..")) {
+        console.error(pc.red(`Error: '${relPath}' is not under an overridable subdir (${OVERRIDE_SUBDIRS.join(", ")})`));
+        process.exit(1);
+    }
+    const src = join(defaultsRoot, relPath);
+    if (!existsSync(src) || !statSync(src).isFile()) {
+        console.error(pc.red(`Error: '${relPath}' is not a livemark file`));
+        process.exit(1);
+    }
+    const dest = join(process.cwd(), ".livemark", relPath);
+    if (existsSync(dest)) {
+        console.error(pc.red(`Error: .livemark/${relPath} already exists`));
+        process.exit(1);
+    }
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, readFileSync(src));
+    console.log(`Copied ${pc.dim(relPath)} → ${pc.green(`.livemark/${relPath}`)}`);
+});
+function listOverridable() {
+    const files = [];
+    for (const subdir of OVERRIDE_SUBDIRS) {
+        const dir = join(defaultsRoot, subdir);
+        if (!existsSync(dir))
+            continue;
+        for (const entry of readdirSync(dir)) {
+            if (statSync(join(dir, entry)).isFile())
+                files.push(`${subdir}/${entry}`);
+        }
+    }
+    return files.sort();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXNjYXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vY29tbWFuZHMvZXNjYXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxVQUFVLEVBQ1YsU0FBUyxFQUNULFdBQVcsRUFDWCxZQUFZLEVBQ1osUUFBUSxFQUNSLGFBQWEsR0FDZCxNQUFNLFNBQVMsQ0FBQTtBQUNoQixPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUN6QyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ25DLE9BQU8sRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUMzQixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQTtBQUV0RSxNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsT0FBTyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxTQUFTLENBQUMsQ0FBQTtBQUUvRDs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDO0tBQ3hDLFdBQVcsQ0FBQyx5REFBeUQsQ0FBQztLQUN0RSxRQUFRLENBQ1AsUUFBUSxFQUNSLDBEQUEwRCxDQUMzRDtLQUNBLE1BQU0sQ0FBQyxDQUFDLE9BQWdCLEVBQUUsRUFBRTtJQUMzQixJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDYixLQUFLLE1BQU0sSUFBSSxJQUFJLGVBQWUsRUFBRTtZQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDdkQsT0FBTyxDQUFDLEdBQUcsQ0FDVCxFQUFFLENBQUMsR0FBRyxDQUFDLCtEQUErRCxDQUFDLENBQ3hFLENBQUE7UUFDRCxPQUFNO0lBQ1IsQ0FBQztJQUVELE1BQU0sQ0FBQyxLQUFLLENBQUMsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ2xDLElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1FBQzFFLE9BQU8sQ0FBQyxLQUFLLENBQ1gsRUFBRSxDQUFDLEdBQUcsQ0FDSixXQUFXLE9BQU8seUNBQXlDLGdCQUFnQixDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUMxRixDQUNGLENBQUE7UUFDRCxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2pCLENBQUM7SUFFRCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsWUFBWSxFQUFFLE9BQU8sQ0FBQyxDQUFBO0lBQ3ZDLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQztRQUNoRCxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxPQUFPLDBCQUEwQixDQUFDLENBQUMsQ0FBQTtRQUNuRSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQ2pCLENBQUM7SUFFRCxNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUN0RCxJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1FBQ3JCLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxvQkFBb0IsT0FBTyxpQkFBaUIsQ0FBQyxDQUFDLENBQUE7UUFDbkUsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUNqQixDQUFDO0lBRUQsU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0lBQzdDLGFBQWEsQ0FBQyxJQUFJLEVBQUUsWUFBWSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUE7SUFDdEMsT0FBTyxDQUFDLEdBQUcsQ0FDVCxVQUFVLEVBQUUsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLEtBQUssQ0FBQyxhQUFhLE9BQU8sRUFBRSxDQUFDLEVBQUUsQ0FDbEUsQ0FBQTtBQUNILENBQUMsQ0FBQyxDQUFBO0FBRUosU0FBUyxlQUFlO0lBQ3RCLE1BQU0sS0FBSyxHQUFhLEVBQUUsQ0FBQTtJQUMxQixLQUFLLE1BQU0sTUFBTSxJQUFJLGdCQUFnQixFQUFFLENBQUM7UUFDdEMsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLFlBQVksRUFBRSxNQUFNLENBQUMsQ0FBQTtRQUN0QyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQztZQUFFLFNBQVE7UUFDOUIsS0FBSyxNQUFNLEtBQUssSUFBSSxXQUFXLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUNyQyxJQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxFQUFFO2dCQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxNQUFNLElBQUksS0FBSyxFQUFFLENBQUMsQ0FBQTtRQUMzRSxDQUFDO0lBQ0gsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDLElBQUksRUFBRSxDQUFBO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBleGlzdHNTeW5jLFxuICBta2RpclN5bmMsXG4gIHJlYWRkaXJTeW5jLFxuICByZWFkRmlsZVN5bmMsXG4gIHN0YXRTeW5jLFxuICB3cml0ZUZpbGVTeW5jLFxufSBmcm9tIFwibm9kZTpmc1wiXG5pbXBvcnQgeyBkaXJuYW1lLCBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiXG5pbXBvcnQgcGMgZnJvbSBcInBpY29jb2xvcnNcIlxuaW1wb3J0IHsgT1ZFUlJJREVfU1VCRElSUyB9IGZyb20gXCIuLi93ZWJzaXRlL3BsdWdpbnMvdml0ZS1saXZlbWFyay50c1wiXG5cbmNvbnN0IGRlZmF1bHRzUm9vdCA9IGpvaW4oaW1wb3J0Lm1ldGEuZGlybmFtZSwgXCIuLlwiLCBcIndlYnNpdGVcIilcblxuLyoqXG4gKiBMaXN0IG9yIGNvcHkgb3ZlcnJpZGFibGUgbGl2ZW1hcmsgZmlsZXMgaW50byBgLmxpdmVtYXJrL2AuXG4gKlxuICogV2l0aG91dCBhbiBhcmd1bWVudCwgcHJpbnRzIGV2ZXJ5IGZpbGUgeW91IGNhbiBzaGFkb3cuIFdpdGggYSBwYXRoLCBjb3BpZXNcbiAqIHRoZSBkZWZhdWx0IGZyb20gdGhlIGxpdmVtYXJrIHBhY2thZ2UgaW50byBgLmxpdmVtYXJrLzxwYXRoPmA7IGZhaWxzIGlmIHRoZVxuICogZGVzdGluYXRpb24gYWxyZWFkeSBleGlzdHMuXG4gKi9cbmV4cG9ydCBjb25zdCBlc2NhcGUgPSBuZXcgQ29tbWFuZChcImVzY2FwZVwiKVxuICAuZGVzY3JpcHRpb24oXCJMaXN0IG9yIGNvcHkgb3ZlcnJpZGFibGUgbGl2ZW1hcmsgZmlsZXMgaW50byAubGl2ZW1hcmsvXCIpXG4gIC5hcmd1bWVudChcbiAgICBcIltwYXRoXVwiLFxuICAgIFwicGF0aCByZWxhdGl2ZSB0byAubGl2ZW1hcmsvIChlLmcuIGNvbXBvbmVudHMvRm9vdGVyLnRzeClcIixcbiAgKVxuICAuYWN0aW9uKChyZWxQYXRoPzogc3RyaW5nKSA9PiB7XG4gICAgaWYgKCFyZWxQYXRoKSB7XG4gICAgICBmb3IgKGNvbnN0IGZpbGUgb2YgbGlzdE92ZXJyaWRhYmxlKCkpIGNvbnNvbGUubG9nKGZpbGUpXG4gICAgICBjb25zb2xlLmxvZyhcbiAgICAgICAgcGMuZGltKFwiXFxuUnVuICdsaXZlbWFyayBlc2NhcGUgPHBhdGg+JyB0byBjb3B5IGEgZmlsZSBpbnRvIC5saXZlbWFyay9cIiksXG4gICAgICApXG4gICAgICByZXR1cm5cbiAgICB9XG5cbiAgICBjb25zdCBbZmlyc3RdID0gcmVsUGF0aC5zcGxpdChcIi9cIilcbiAgICBpZiAoIWZpcnN0IHx8ICFPVkVSUklERV9TVUJESVJTLmluY2x1ZGVzKGZpcnN0KSB8fCByZWxQYXRoLmluY2x1ZGVzKFwiLi5cIikpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IoXG4gICAgICAgIHBjLnJlZChcbiAgICAgICAgICBgRXJyb3I6ICcke3JlbFBhdGh9JyBpcyBub3QgdW5kZXIgYW4gb3ZlcnJpZGFibGUgc3ViZGlyICgke09WRVJSSURFX1NVQkRJUlMuam9pbihcIiwgXCIpfSlgLFxuICAgICAgICApLFxuICAgICAgKVxuICAgICAgcHJvY2Vzcy5leGl0KDEpXG4gICAgfVxuXG4gICAgY29uc3Qgc3JjID0gam9pbihkZWZhdWx0c1Jvb3QsIHJlbFBhdGgpXG4gICAgaWYgKCFleGlzdHNTeW5jKHNyYykgfHwgIXN0YXRTeW5jKHNyYykuaXNGaWxlKCkpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IocGMucmVkKGBFcnJvcjogJyR7cmVsUGF0aH0nIGlzIG5vdCBhIGxpdmVtYXJrIGZpbGVgKSlcbiAgICAgIHByb2Nlc3MuZXhpdCgxKVxuICAgIH1cblxuICAgIGNvbnN0IGRlc3QgPSBqb2luKHByb2Nlc3MuY3dkKCksIFwiLmxpdmVtYXJrXCIsIHJlbFBhdGgpXG4gICAgaWYgKGV4aXN0c1N5bmMoZGVzdCkpIHtcbiAgICAgIGNvbnNvbGUuZXJyb3IocGMucmVkKGBFcnJvcjogLmxpdmVtYXJrLyR7cmVsUGF0aH0gYWxyZWFkeSBleGlzdHNgKSlcbiAgICAgIHByb2Nlc3MuZXhpdCgxKVxuICAgIH1cblxuICAgIG1rZGlyU3luYyhkaXJuYW1lKGRlc3QpLCB7IHJlY3Vyc2l2ZTogdHJ1ZSB9KVxuICAgIHdyaXRlRmlsZVN5bmMoZGVzdCwgcmVhZEZpbGVTeW5jKHNyYykpXG4gICAgY29uc29sZS5sb2coXG4gICAgICBgQ29waWVkICR7cGMuZGltKHJlbFBhdGgpfSDihpIgJHtwYy5ncmVlbihgLmxpdmVtYXJrLyR7cmVsUGF0aH1gKX1gLFxuICAgIClcbiAgfSlcblxuZnVuY3Rpb24gbGlzdE92ZXJyaWRhYmxlKCkge1xuICBjb25zdCBmaWxlczogc3RyaW5nW10gPSBbXVxuICBmb3IgKGNvbnN0IHN1YmRpciBvZiBPVkVSUklERV9TVUJESVJTKSB7XG4gICAgY29uc3QgZGlyID0gam9pbihkZWZhdWx0c1Jvb3QsIHN1YmRpcilcbiAgICBpZiAoIWV4aXN0c1N5bmMoZGlyKSkgY29udGludWVcbiAgICBmb3IgKGNvbnN0IGVudHJ5IG9mIHJlYWRkaXJTeW5jKGRpcikpIHtcbiAgICAgIGlmIChzdGF0U3luYyhqb2luKGRpciwgZW50cnkpKS5pc0ZpbGUoKSkgZmlsZXMucHVzaChgJHtzdWJkaXJ9LyR7ZW50cnl9YClcbiAgICB9XG4gIH1cbiAgcmV0dXJuIGZpbGVzLnNvcnQoKVxufVxuIl19

package/build/docs/markdown/includes/example.d.ts

@@ -1,9 +1,58 @@
 declare const _default: {
+    site?: string | undefined;
+    favicon?: string | undefined;
+    logo?: string | undefined;
     title: string;
     description: string;
-    articles: {
-        include: string | string[];
-        exclude?: string | string[] | undefined;
-    };
+    include: string | string[];
+    exclude?: string | string[] | undefined;
+    codeThemeLight: "ayu-light" | "catppuccin-latte" | "everforest-light" | "github-light" | "github-light-default" | "github-light-high-contrast" | "gruvbox-light-hard" | "gruvbox-light-medium" | "gruvbox-light-soft" | "horizon-bright" | "kanagawa-lotus" | "light-plus" | "material-theme-lighter" | "min-light" | "night-owl-light" | "one-light" | "rose-pine-dawn" | "slack-ochin" | "snazzy-light" | "solarized-light" | "vitesse-light";
+    codeThemeDark: "andromeeda" | "aurora-x" | "ayu-dark" | "ayu-mirage" | "catppuccin-frappe" | "catppuccin-macchiato" | "catppuccin-mocha" | "dark-plus" | "dracula" | "dracula-soft" | "everforest-dark" | "github-dark" | "github-dark-default" | "github-dark-dimmed" | "github-dark-high-contrast" | "gruvbox-dark-hard" | "gruvbox-dark-medium" | "gruvbox-dark-soft" | "horizon" | "houston" | "kanagawa-dragon" | "kanagawa-wave" | "laserwave" | "material-theme" | "material-theme-darker" | "material-theme-ocean" | "material-theme-palenight" | "min-dark" | "monokai" | "night-owl" | "nord" | "one-dark-pro" | "plastic" | "poimandres" | "red" | "rose-pine" | "rose-pine-moon" | "slack-dark" | "solarized-dark" | "synthwave-84" | "tokyo-night" | "vesper" | "vitesse-black" | "vitesse-dark";
+    links?: {
+        url: string;
+        title: string;
+        icon?: string | undefined;
+        prefix?: string | undefined;
+        position: "header" | "sidebar";
+    }[] | undefined;
+    sections?: ({
+        icon?: string | undefined;
+        title: string;
+        prefix: string;
+        position: "header" | "sidebar";
+        type: "article";
+    } | {
+        icon?: string | undefined;
+        title: string;
+        prefix: string;
+        position: "header" | "sidebar";
+        type: "blog";
+    } | {
+        icon?: string | undefined;
+        title: string;
+        prefix: string;
+        position: "header" | "sidebar";
+        type: "changelog";
+        source: string;
+        version?: boolean | undefined;
+    })[] | undefined;
+    patches?: {
+        file: string;
+        article: {
+            title?: string | undefined;
+            label?: string | undefined;
+            description?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+            path?: string | undefined;
+            group?: string | undefined;
+            sidebar?: boolean | undefined;
+            toc?: boolean | undefined;
+            image?: string | undefined;
+            author?: string | string[] | undefined;
+            date?: string | undefined;
+            tags?: string[] | undefined;
+        };
+    }[] | undefined;
 };
 export default _default;

package/build/docs/markdown/includes/example.js

@@ -1,5 +1,5 @@
 import { defineConfig } from "livemark";
 export default defineConfig({
-    articles: { include: "docs/*.md" },
+    include: "docs/*.md",
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2RvY3MvbWFya2Rvd24vaW5jbHVkZXMvZXhhbXBsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sVUFBVSxDQUFBO0FBRXZDLGVBQWUsWUFBWSxDQUFDO0lBQzFCLFFBQVEsRUFBRSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUU7Q0FDbkMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcImxpdmVtYXJrXCJcblxuZXhwb3J0IGRlZmF1bHQgZGVmaW5lQ29uZmlnKHtcbiAgYXJ0aWNsZXM6IHsgaW5jbHVkZTogXCJkb2NzLyoubWRcIiB9LFxufSlcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhhbXBsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2RvY3MvbWFya2Rvd24vaW5jbHVkZXMvZXhhbXBsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sVUFBVSxDQUFBO0FBRXZDLGVBQWUsWUFBWSxDQUFDO0lBQzFCLE9BQU8sRUFBRSxXQUFXO0NBQ3JCLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZUNvbmZpZyB9IGZyb20gXCJsaXZlbWFya1wiXG5cbmV4cG9ydCBkZWZhdWx0IGRlZmluZUNvbmZpZyh7XG4gIGluY2x1ZGU6IFwiZG9jcy8qLm1kXCIsXG59KVxuIl19