@ankhorage/paradox 0.0.5 → 0.0.7

package/dist/render/render.js

@@ -1,95 +1,33 @@
+import { renderBadgeArtifacts } from './renderers/badges.js';
+import { renderDiagramArtifacts } from './renderers/diagrams.js';
+import { renderHtml } from './renderers/html.js';
+import { renderMarkdown } from './renderers/markdown.js';
 /***
  * Renders the documentation model into README and artifact files.
  */
-export function render(model) {
-    return {
-        readme: renderReadme(model),
-        exportsMarkdown: renderExports(model),
-        components: renderComponents(model),
+export function render(model, options = {}) {
+    const badges = renderBadgeArtifacts(model);
+    const diagrams = renderDiagramArtifacts(model);
+    const outputDir = options.outputDir ?? 'paradox';
+    const result = {
+        readme: '',
+        exportsMarkdown: '',
+        components: '',
         exportsJson: `${JSON.stringify(model.exports, null, 2)}\n`,
         paradoxJson: `${JSON.stringify(model, null, 2)}\n`,
+        indexHtml: '',
+        badges,
+        diagrams,
     };
-}
-function renderReadme(model) {
-    const lines = [`# ${model.packageName}`, ''];
-    if (model.description) {
-        lines.push(model.description, '');
-    }
-    if (model.usage !== null) {
-        lines.push('## Usage', '');
-        lines.push('```bash');
-        for (const command of model.usage.commands) {
-            lines.push(command.command);
-        }
-        lines.push('```', '');
-    }
-    if (model.config !== null) {
-        lines.push('## Configuration', '');
-        lines.push(`Create a \`${model.config.configFile}\` file:`, '');
-        lines.push('```ts');
-        if (model.config.factoryName !== null) {
-            lines.push(`import { ${model.config.factoryName} } from '${model.packageId}';`);
-            lines.push('');
-            lines.push(`export default ${model.config.factoryName}({`);
-            lines.push('  // ...');
-            lines.push('});');
-        }
-        else {
-            lines.push(`import type { ${model.config.exportName} } from '${model.packageId}';`);
-            lines.push('');
-            lines.push('const config = {');
-            lines.push('  // ...');
-            lines.push(`} satisfies ${model.config.exportName};`);
-            lines.push('');
-            lines.push('export default config;');
-        }
-        lines.push('```', '');
-    }
-    lines.push('## Path resolution', '');
-    lines.push('- Config discovery: searches upward from `process.cwd()` for `paradox.config.ts/js/mjs/cjs` (required; no fallback).');
-    lines.push('- Package root: defaults to the directory containing `paradox.config.*`; `package.root` (when relative) resolves relative to that directory.');
-    lines.push('- Output directory: defaults to `paradox/`; `output.dir` (when relative) resolves relative to the resolved package root and must stay inside it.');
-    lines.push('- Modes:');
-    lines.push('  - `safe`: writes generated artifacts only under the output directory');
-    lines.push('  - `write`: additionally updates `<packageRoot>/README.md`', '');
-    if (model.exports.length > 0) {
-        lines.push('## Public API', '');
-        for (const item of model.exports) {
-            lines.push(`### ${item.name}`, '');
-            lines.push(item.description ?? `\`${item.kind}\` export.`, '');
-        }
-    }
-    return `${lines.join('\n').trimEnd()}\n`;
-}
-function renderExports(model) {
-    const lines = ['# Public API', ''];
-    for (const item of model.exports) {
-        lines.push(`## ${item.name}`, '');
-        lines.push(`Kind: \`${item.kind}\``, '');
-        if (item.description) {
-            lines.push(item.description, '');
-        }
-    }
-    return `${lines.join('\n').trimEnd()}\n`;
-}
-function renderComponents(model) {
-    const lines = ['# Components', ''];
-    for (const component of model.components) {
-        lines.push(`## ${component.name}`, '');
-        if (component.description) {
-            lines.push(component.description, '');
-        }
-        if (component.props.length > 0) {
-            lines.push('| Prop | Type | Required | Description |');
-            lines.push('| --- | --- | --- | --- |');
-            for (const prop of component.props) {
-                lines.push(`| ${escapeTableCell(prop.name)} | \`${escapeTableCell(prop.type)}\` | ${prop.required ? 'yes' : 'no'} | ${escapeTableCell(prop.description ?? '')} |`);
-            }
-            lines.push('');
-        }
+    const context = {
+        model,
+        outputDir,
+        badges,
+        diagrams,
+        result,
+    };
+    for (const renderer of [renderMarkdown, renderHtml]) {
+        Object.assign(result, renderer(context));
     }
-    return `${lines.join('\n').trimEnd()}\n`;
-}
-function escapeTableCell(value) {
-    return value.replaceAll('|', '\\|');
+    return result;
 }

package/dist/render/renderers/badges.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentationModel } from '../../model/types.js';
+import type { BadgeArtifact } from '../types.js';
+/***
+ * Renders deterministic local SVG badges for repository metadata.
+ */
+export declare function renderBadgeArtifacts(model: DocumentationModel): BadgeArtifact[];

package/dist/render/renderers/badges.js

@@ -0,0 +1,35 @@
+/***
+ * Renders deterministic local SVG badges for repository metadata.
+ */
+export function renderBadgeArtifacts(model) {
+    return model.badges.map((badge) => ({
+        path: `badges/${badge.id}.svg`,
+        content: renderBadgeSvg(badge),
+    }));
+}
+function renderBadgeSvg(badge) {
+    const labelWidth = getTextWidth(badge.label);
+    const valueWidth = getTextWidth(badge.value);
+    const totalWidth = labelWidth + valueWidth;
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${totalWidth}" height="20" role="img" aria-label="${escapeXml(`${badge.label}: ${badge.value}`)}">`,
+        `<title>${escapeXml(`${badge.label}: ${badge.value}`)}</title>`,
+        `<rect width="${labelWidth}" height="20" fill="#374151"/>`,
+        `<rect x="${labelWidth}" width="${valueWidth}" height="20" fill="#${badge.color}"/>`,
+        `<text x="${labelWidth / 2}" y="14" fill="#ffffff" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11" text-anchor="middle">${escapeXml(badge.label)}</text>`,
+        `<text x="${labelWidth + valueWidth / 2}" y="14" fill="#ffffff" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11" text-anchor="middle">${escapeXml(badge.value)}</text>`,
+        '</svg>',
+        '',
+    ].join('\n');
+}
+function getTextWidth(value) {
+    return Math.max(38, value.length * 7 + 10);
+}
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&apos;');
+}

package/dist/render/renderers/diagrams.d.ts

@@ -0,0 +1,6 @@
+import type { DocumentationModel } from '../../model/types.js';
+import type { DiagramArtifact } from '../types.js';
+/***
+ * Generates deterministic Mermaid diagrams for the documentation app.
+ */
+export declare function renderDiagramArtifacts(model: DocumentationModel): DiagramArtifact[];

package/dist/render/renderers/diagrams.js

@@ -0,0 +1,106 @@
+/***
+ * Generates deterministic Mermaid diagrams for the documentation app.
+ */
+export function renderDiagramArtifacts(model) {
+    return [
+        {
+            path: 'diagrams/architecture-overview.mmd',
+            title: 'Architecture overview',
+            content: renderArchitectureOverview(model),
+        },
+        {
+            path: 'diagrams/module-relationships.mmd',
+            title: 'Module relationships',
+            content: renderModuleRelationships(model),
+        },
+        {
+            path: 'diagrams/export-graph.mmd',
+            title: 'Export graph',
+            content: renderExportGraph(model),
+        },
+        {
+            path: 'diagrams/entrypoint-sequence.mmd',
+            title: 'Entrypoint sequence',
+            content: renderEntrypointSequence(model),
+        },
+    ];
+}
+function renderArchitectureOverview(model) {
+    const lines = ['graph TD'];
+    const packageId = toMermaidId(`package-${model.packageId}`);
+    lines.push(`  ${packageId}["${escapeLabel(model.packageName)}"]`);
+    for (const entrypoint of model.entrypoints) {
+        const entrypointId = toMermaidId(`entrypoint-${entrypoint}`);
+        lines.push(`  ${entrypointId}["${escapeLabel(entrypoint)}"]`);
+        lines.push(`  ${packageId} --> ${entrypointId}`);
+    }
+    for (const module of model.modules) {
+        const moduleId = toMermaidId(`module-${module.path}`);
+        lines.push(`  ${moduleId}["${escapeLabel(module.path)}"]`);
+        if (!module.isEntrypoint) {
+            lines.push(`  ${packageId} -.-> ${moduleId}`);
+        }
+        for (const dependency of module.dependencies) {
+            lines.push(`  ${moduleId} --> ${toMermaidId(`module-${dependency}`)}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderModuleRelationships(model) {
+    const lines = ['graph LR'];
+    for (const module of model.modules) {
+        lines.push(`  ${toMermaidId(`module-${module.path}`)}["${escapeLabel(module.path)}"]`);
+    }
+    const edges = model.modules.flatMap((module) => module.dependencies.map((dependency) => `  ${toMermaidId(`module-${module.path}`)} --> ${toMermaidId(`module-${dependency}`)}`));
+    lines.push(...(edges.length > 0 ? edges : renderFallbackEdge(model.modules, 'module')));
+    return `${lines.join('\n')}\n`;
+}
+function renderExportGraph(model) {
+    const lines = ['graph LR'];
+    const exportedNames = new Set(model.exports.map((item) => item.name));
+    for (const module of model.modules) {
+        lines.push(`  ${toMermaidId(`module-${module.path}`)}["${escapeLabel(module.path)}"]`);
+    }
+    for (const item of model.exports) {
+        const exportId = toMermaidId(`export-${item.name}`);
+        lines.push(`  ${exportId}["${escapeLabel(item.name)}"]`);
+        lines.push(`  ${toMermaidId(`module-${item.modulePath}`)} --> ${exportId}`);
+        for (const relatedSymbol of item.relatedSymbols.filter((symbol) => exportedNames.has(symbol))) {
+            lines.push(`  ${exportId} -.-> ${toMermaidId(`export-${relatedSymbol}`)}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderEntrypointSequence(model) {
+    const lines = ['sequenceDiagram'];
+    const participants = new Map();
+    for (const module of model.modules) {
+        participants.set(module.path, `participant ${toMermaidId(`participant-${module.path}`)} as ${module.path}`);
+    }
+    lines.push(...participants.values());
+    const interactions = model.modules.flatMap((module) => module.dependencies.map((dependency) => `  ${toMermaidId(`participant-${module.path}`)}->>${toMermaidId(`participant-${dependency}`)}: imports`));
+    if (interactions.length === 0) {
+        const packageId = toMermaidId(`participant-${model.packageId}`);
+        lines.push(`  participant ${packageId} as ${model.packageName}`);
+        lines.push(`  Note over ${packageId}: No internal module relationships detected.`);
+    }
+    else {
+        lines.push(...interactions);
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderFallbackEdge(modules, prefix) {
+    if (modules.length === 0) {
+        return ['  empty["No modules analyzed"]'];
+    }
+    return modules.slice(1).map((module, index) => {
+        const previous = modules[index];
+        return `  ${toMermaidId(`${prefix}-${previous.path}`)} -.-> ${toMermaidId(`${prefix}-${module.path}`)}`;
+    });
+}
+function toMermaidId(value) {
+    return value.replace(/[^A-Za-z0-9_]/g, '_');
+}
+function escapeLabel(value) {
+    return value.replaceAll('"', '"');
+}

package/dist/render/renderers/html.d.ts

@@ -0,0 +1,5 @@
+import type { RenderContext } from '../types.js';
+/***
+ * Renders a deterministic static HTML documentation app.
+ */
+export declare function renderHtml({ diagrams, model, }: RenderContext): Pick<RenderContext['result'], 'indexHtml'>;

package/dist/render/renderers/html.js

@@ -0,0 +1,317 @@
+/***
+ * Renders a deterministic static HTML documentation app.
+ */
+export function renderHtml({ diagrams, model, }) {
+    const navigationItems = [
+        ...model.exports.map((item) => ({
+            href: `#symbol-${toAnchorId(item.name)}`,
+            label: item.name,
+            meta: `${item.kind} • ${item.modulePath}`,
+        })),
+        ...model.components.map((component) => ({
+            href: `#component-${toAnchorId(component.name)}`,
+            label: component.name,
+            meta: `component • ${component.modulePath}`,
+        })),
+    ].sort((left, right) => left.label.localeCompare(right.label));
+    const exportsByModule = groupBy(model.exports, (item) => item.modulePath);
+    return {
+        indexHtml: `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(model.packageName)} • Paradox</title>
+    <style>
+      :root {
+        color-scheme: light;
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        background: #f5f7fb;
+        color: #11203b;
+      }
+      * { box-sizing: border-box; }
+      body { margin: 0; }
+      a { color: #2459d3; text-decoration: none; }
+      a:hover { text-decoration: underline; }
+      code, pre { font-family: "SFMono-Regular", ui-monospace, SFMono-Regular, Menlo, monospace; }
+      .layout {
+        display: grid;
+        grid-template-columns: minmax(16rem, 22rem) minmax(0, 1fr);
+        min-height: 100vh;
+      }
+      .sidebar {
+        padding: 1.5rem;
+        border-right: 1px solid #d8dfec;
+        background: #ffffff;
+        position: sticky;
+        top: 0;
+        max-height: 100vh;
+        overflow: auto;
+      }
+      .content {
+        padding: 2rem;
+      }
+      .panel, .item {
+        background: #ffffff;
+        border: 1px solid #d8dfec;
+        border-radius: 0.9rem;
+        padding: 1rem 1.2rem;
+        margin-bottom: 1rem;
+        box-shadow: 0 8px 24px rgba(17, 32, 59, 0.06);
+      }
+      .summary {
+        display: grid;
+        gap: 1rem;
+        grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+      }
+      .summary strong {
+        display: block;
+        font-size: 1.5rem;
+      }
+      .search {
+        width: 100%;
+        padding: 0.75rem 0.9rem;
+        border-radius: 0.75rem;
+        border: 1px solid #c7d2e5;
+        margin: 1rem 0 1.5rem;
+      }
+      .nav-list, .meta-list {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+      }
+      .nav-list li + li { margin-top: 0.8rem; }
+      .muted { color: #5e6d8c; }
+      .chips { display: flex; flex-wrap: wrap; gap: 0.5rem; padding: 0; list-style: none; }
+      .chip {
+        border-radius: 999px;
+        background: #e8eefb;
+        color: #24427a;
+        padding: 0.25rem 0.65rem;
+        font-size: 0.85rem;
+      }
+      table { width: 100%; border-collapse: collapse; margin-top: 0.8rem; }
+      th, td { padding: 0.6rem; border-bottom: 1px solid #e2e7f2; text-align: left; vertical-align: top; }
+      pre {
+        overflow: auto;
+        border-radius: 0.75rem;
+        background: #0f1729;
+        color: #e7edf7;
+        padding: 1rem;
+      }
+      .empty { font-style: italic; color: #6f7f9c; }
+      @media (max-width: 900px) {
+        .layout { grid-template-columns: 1fr; }
+        .sidebar { position: static; max-height: none; border-right: 0; border-bottom: 1px solid #d8dfec; }
+        .content { padding: 1rem; }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="layout">
+      <aside class="sidebar">
+        <p class="muted">Generated with Paradox</p>
+        <h1>${escapeHtml(model.packageName)}</h1>
+        <p>${escapeHtml(model.description ?? 'Deterministic package documentation.')}</p>
+        <input id="search" class="search" type="search" placeholder="Search symbols, files, and metadata" />
+        <ul class="nav-list">
+          ${navigationItems
+            .map((item) => `<li><a href="${escapeAttribute(item.href)}">${escapeHtml(item.label)}</a><div class="muted">${escapeHtml(item.meta)}</div></li>`)
+            .join('')}
+        </ul>
+      </aside>
+      <main class="content">
+        <section class="panel">
+          <h2>Package overview</h2>
+          <div class="summary">
+            <div><strong>${model.exports.length}</strong><span class="muted">public exports</span></div>
+            <div><strong>${model.components.length}</strong><span class="muted">components</span></div>
+            <div><strong>${model.modules.length}</strong><span class="muted">modules</span></div>
+            <div><strong>${model.entrypoints.length}</strong><span class="muted">entrypoints</span></div>
+          </div>
+          <h3>Entrypoints</h3>
+          <ul class="meta-list">
+            ${model.entrypoints.map((entrypoint) => `<li><code>${escapeHtml(entrypoint)}</code></li>`).join('')}
+          </ul>
+        </section>
+        <section class="panel">
+          <h2>Modules</h2>
+          ${model.modules.map(renderModuleCard).join('')}
+        </section>
+        <section class="panel">
+          <h2>Exports by module</h2>
+          ${[...exportsByModule.entries()]
+            .map(([modulePath, exports]) => `
+                <section>
+                  <h3>${escapeHtml(modulePath)}</h3>
+                  ${exports.map((item) => renderExportCard(item)).join('')}
+                </section>`)
+            .join('')}
+        </section>
+        <section class="panel">
+          <h2>Component registry</h2>
+          ${model.components.length === 0 ? '<p class="empty">No components were detected.</p>' : model.components.map(renderComponentCard).join('')}
+        </section>
+        <section class="panel">
+          <h2>Diagrams</h2>
+          ${diagrams.map(renderDiagramCard).join('')}
+        </section>
+      </main>
+    </div>
+    <script>
+      const search = document.getElementById('search');
+      const items = Array.from(document.querySelectorAll('[data-search]'));
+      search?.addEventListener('input', () => {
+        const value = search.value.trim().toLowerCase();
+        for (const item of items) {
+          const haystack = (item.getAttribute('data-search') || '').toLowerCase();
+          item.style.display = value === '' || haystack.includes(value) ? '' : 'none';
+        }
+      });
+    </script>
+  </body>
+</html>
+`,
+    };
+}
+function renderModuleCard(module) {
+    return `<article class="item" data-search="${escapeAttribute([module.path, ...module.dependencies, ...module.exports].join(' '))}">
+    <h3>${escapeHtml(module.path)}</h3>
+    <p class="muted">${module.isEntrypoint ? 'Configured entrypoint' : 'Referenced module'}</p>
+    <p><strong>Dependencies:</strong> ${renderInlineCodeList(module.dependencies)}</p>
+    <p><strong>Exports:</strong> ${renderInlineCodeList(module.exports)}</p>
+  </article>`;
+}
+function renderExportCard(item) {
+    return `<article class="item" id="symbol-${toAnchorId(item.name)}" data-search="${escapeAttribute([
+        item.name,
+        item.kind,
+        item.modulePath,
+        item.description ?? '',
+        ...item.relatedSymbols,
+        ...item.signatures.map((signature) => signature.label),
+    ].join(' '))}">
+    <h4>${escapeHtml(item.name)}</h4>
+    <p class="muted">${escapeHtml(item.kind)} • <code>${escapeHtml(item.sourceLocation.filePath)}:${item.sourceLocation.line}:${item.sourceLocation.column}</code></p>
+    ${item.description ? `<p>${escapeHtml(item.description)}</p>` : ''}
+    <p><strong>Export paths:</strong> ${renderInlineCodeList(item.exportPaths)}</p>
+    <div><strong>Related symbols:</strong> ${item.relatedSymbols.length > 0 ? renderChipList(item.relatedSymbols) : '<span class="empty">None</span>'}</div>
+    ${item.signatures.length > 0 ? renderSignatureBlock(item) : ''}
+    ${item.members.length > 0 ? renderMemberTable(item) : ''}
+  </article>`;
+}
+function renderSignatureBlock(item) {
+    return item.signatures
+        .map((signature) => `<div>
+        <h5>Signature</h5>
+        <pre>${escapeHtml(signature.label)}</pre>
+        ${signature.parameters.length > 0
+        ? `<table>
+                <thead><tr><th>Parameter</th><th>Type</th><th>Required</th><th>Description</th></tr></thead>
+                <tbody>
+                  ${signature.parameters
+            .map((parameter) => `<tr>
+                        <td><code>${escapeHtml(parameter.name)}</code></td>
+                        <td><code>${escapeHtml(parameter.type)}</code></td>
+                        <td>${parameter.required ? 'yes' : 'no'}</td>
+                        <td>${escapeHtml(parameter.description ?? '')}</td>
+                      </tr>`)
+            .join('')}
+                </tbody>
+              </table>`
+        : ''}
+        <p><strong>Returns:</strong> <code>${escapeHtml(signature.returnType ?? 'void')}</code>${signature.returnDescription ? ` — ${escapeHtml(signature.returnDescription)}` : ''}</p>
+      </div>`)
+        .join('');
+}
+function renderMemberTable(item) {
+    return `<table>
+    <thead><tr><th>Member</th><th>Kind</th><th>Type</th><th>Required</th><th>Description</th></tr></thead>
+    <tbody>
+      ${item.members
+        .map((member) => `<tr>
+            <td><code>${escapeHtml(member.name)}</code></td>
+            <td>${escapeHtml(member.kind)}</td>
+            <td><code>${escapeHtml(member.type)}</code></td>
+            <td>${member.required ? 'yes' : 'no'}</td>
+            <td>${escapeHtml(member.description ?? '')}</td>
+          </tr>`)
+        .join('')}
+    </tbody>
+  </table>`;
+}
+function renderComponentCard(component) {
+    return `<article class="item" id="component-${toAnchorId(component.name)}" data-search="${escapeAttribute([
+        component.name,
+        component.modulePath,
+        component.description ?? '',
+        ...component.props.map((prop) => `${prop.name} ${prop.type}`),
+    ].join(' '))}">
+    <h3>${escapeHtml(component.name)}</h3>
+    <p class="muted"><code>${escapeHtml(component.sourceLocation.filePath)}:${component.sourceLocation.line}:${component.sourceLocation.column}</code></p>
+    ${component.description ? `<p>${escapeHtml(component.description)}</p>` : ''}
+    <p><strong>Export paths:</strong> ${renderInlineCodeList(component.exportPaths)}</p>
+    <table>
+      <thead><tr><th>Prop</th><th>Type</th><th>Required</th><th>Description</th></tr></thead>
+      <tbody>
+        ${component.props
+        .map((prop) => `<tr>
+              <td><code>${escapeHtml(prop.name)}</code></td>
+              <td><code>${escapeHtml(prop.type)}</code></td>
+              <td>${prop.required ? 'yes' : 'no'}</td>
+              <td>${escapeHtml(prop.description ?? '')}</td>
+            </tr>`)
+        .join('')}
+      </tbody>
+    </table>
+  </article>`;
+}
+function renderDiagramCard(diagram) {
+    return `<article class="item" data-search="${escapeAttribute(`${diagram.title} ${diagram.path}`)}">
+    <h3>${escapeHtml(diagram.title)}</h3>
+    <p class="muted"><code>${escapeHtml(diagram.path)}</code></p>
+    <pre>${escapeHtml(diagram.content)}</pre>
+  </article>`;
+}
+function renderInlineCodeList(values) {
+    if (values.length === 0) {
+        return '<span class="empty">None</span>';
+    }
+    return values.map((value) => `<code>${escapeHtml(value)}</code>`).join(', ');
+}
+function renderChipList(values) {
+    return `<ul class="chips">${values
+        .map((value) => `<li class="chip">${escapeHtml(value)}</li>`)
+        .join('')}</ul>`;
+}
+function groupBy(items, key) {
+    const groups = new Map();
+    for (const item of items) {
+        const groupKey = key(item);
+        const group = groups.get(groupKey);
+        if (group) {
+            group.push(item);
+        }
+        else {
+            groups.set(groupKey, [item]);
+        }
+    }
+    return new Map([...groups.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function toAnchorId(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function escapeAttribute(value) {
+    return escapeHtml(value).replaceAll('\n', '&#10;');
+}

package/dist/render/renderers/markdown.d.ts

@@ -0,0 +1,5 @@
+import type { RenderContext } from '../types.js';
+/***
+ * Renders markdown artifacts from the documentation model.
+ */
+export declare function renderMarkdown({ badges, diagrams, model, outputDir, }: RenderContext): Pick<RenderContext['result'], 'components' | 'exportsMarkdown' | 'readme'>;