ted-mosby 1.0.0 → 1.1.1

package/dist/site-generator.js

@@ -0,0 +1,694 @@
+/**
+ * Static Site Generator for Architectural Wiki
+ *
+ * Transforms markdown wiki into an interactive, experiential static site
+ * with guided tours, code exploration, and magical onboarding features.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { marked } from 'marked';
+import { getTemplates } from './site/templates.js';
+import { getStyles } from './site/styles.js';
+import { getClientScripts } from './site/scripts.js';
+export class SiteGenerator {
+    options;
+    pages = [];
+    navigation = { sections: [] };
+    tours = [];
+    mermaidPlaceholders = new Map();
+    constructor(options) {
+        this.options = {
+            wikiDir: path.resolve(options.wikiDir),
+            outputDir: path.resolve(options.outputDir),
+            title: options.title || 'Architecture Wiki',
+            description: options.description || 'Interactive architectural documentation',
+            theme: options.theme || 'auto',
+            features: {
+                guidedTour: true,
+                codeExplorer: true,
+                search: true,
+                progressTracking: true,
+                keyboardNav: true,
+                ...options.features
+            },
+            repoUrl: options.repoUrl || '',
+            repoPath: options.repoPath || ''
+        };
+        this.configureMarked();
+    }
+    /**
+     * Configure marked with custom renderers for enhanced features
+     */
+    configureMarked() {
+        const renderer = new marked.Renderer();
+        // Enhanced code block rendering with copy button and source links
+        renderer.code = (code, language) => {
+            const lang = language || 'text';
+            const escapedCode = this.escapeHtml(code);
+            // Check for source reference in the code block
+            const sourceMatch = code.match(/^\/\/\s*Source:\s*(.+)$/m) ||
+                code.match(/^#\s*Source:\s*(.+)$/m);
+            const sourceRef = sourceMatch ? sourceMatch[1].trim() : '';
+            return `
+        <div class="code-block" data-language="${lang}">
+          <div class="code-header">
+            <span class="code-language">${lang}</span>
+            ${sourceRef ? `<a href="#" class="code-source" data-source="${sourceRef}">${sourceRef}</a>` : ''}
+            <button class="code-copy" title="Copy code">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
+                <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
+              </svg>
+            </button>
+          </div>
+          <pre><code class="language-${lang}">${escapedCode}</code></pre>
+        </div>
+      `;
+        };
+        // Enhanced heading rendering with anchor links
+        renderer.heading = (text, level) => {
+            const id = this.slugify(text);
+            return `
+        <h${level} id="${id}" class="heading-anchor">
+          <a href="#${id}" class="anchor-link" aria-hidden="true">#</a>
+          ${text}
+        </h${level}>
+      `;
+        };
+        // Enhanced link rendering
+        renderer.link = (href, title, text) => {
+            const isExternal = href.startsWith('http://') || href.startsWith('https://');
+            const isSourceLink = href.includes(':') && !isExternal && href.match(/\.(ts|js|py|go|rs|java|rb|php|c|cpp|swift):/);
+            if (isSourceLink) {
+                return `<a href="#" class="source-link" data-source="${href}" title="${title || 'View source'}">${text}</a>`;
+            }
+            if (isExternal) {
+                return `<a href="${href}" title="${title || ''}" target="_blank" rel="noopener noreferrer" class="external-link">${text}<svg class="external-icon" width="12" height="12" viewBox="0 0 24 24"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6M15 3h6v6M10 14L21 3" stroke="currentColor" stroke-width="2" fill="none"/></svg></a>`;
+            }
+            // Convert .md links to .html
+            const htmlHref = href.replace(/\.md(#.*)?$/, '.html$1');
+            return `<a href="${htmlHref}" title="${title || ''}" class="internal-link">${text}</a>`;
+        };
+        // Enhanced image rendering
+        renderer.image = (href, title, text) => {
+            return `
+        <figure class="image-figure">
+          <img src="${href}" alt="${text}" title="${title || ''}" loading="lazy" />
+          ${title ? `<figcaption>${title}</figcaption>` : ''}
+        </figure>
+      `;
+        };
+        // Enhanced blockquote rendering (for callouts)
+        renderer.blockquote = (quote) => {
+            // Check for callout type markers
+            const calloutMatch = quote.match(/^\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]/i);
+            if (calloutMatch) {
+                const type = calloutMatch[1].toLowerCase();
+                const content = quote.replace(calloutMatch[0], '').trim();
+                return `<div class="callout callout-${type}"><div class="callout-title">${calloutMatch[1]}</div><div class="callout-content">${content}</div></div>`;
+            }
+            return `<blockquote>${quote}</blockquote>`;
+        };
+        marked.use({ renderer });
+    }
+    /**
+     * Generate the complete static site
+     */
+    async generate() {
+        console.log('🌐 Generating static site...');
+        // Step 1: Discover and parse all wiki pages
+        await this.discoverPages();
+        console.log(`  Found ${this.pages.length} wiki pages`);
+        // Step 2: Build navigation structure
+        this.buildNavigation();
+        // Step 3: Generate guided tours from content analysis
+        if (this.options.features.guidedTour) {
+            this.generateTours();
+        }
+        // Step 4: Create output directory structure
+        this.createOutputDirs();
+        // Step 5: Write static assets (CSS, JS)
+        await this.writeAssets();
+        // Step 6: Generate HTML pages
+        await this.generatePages();
+        // Step 7: Generate site manifest for client-side features
+        await this.generateManifest();
+        console.log(`✅ Static site generated at: ${this.options.outputDir}`);
+    }
+    /**
+     * Discover and parse all markdown files in the wiki directory
+     */
+    async discoverPages() {
+        const files = this.findMarkdownFiles(this.options.wikiDir);
+        for (const filePath of files) {
+            const page = await this.parsePage(filePath);
+            if (page) {
+                this.pages.push(page);
+            }
+        }
+        // Sort pages: README first, then alphabetically
+        this.pages.sort((a, b) => {
+            if (a.relativePath === 'README.md')
+                return -1;
+            if (b.relativePath === 'README.md')
+                return 1;
+            return a.relativePath.localeCompare(b.relativePath);
+        });
+    }
+    /**
+     * Recursively find all markdown files
+     */
+    findMarkdownFiles(dir) {
+        const files = [];
+        if (!fs.existsSync(dir))
+            return files;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip hidden directories and cache
+                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                    files.push(...this.findMarkdownFiles(fullPath));
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    /**
+     * Parse a single markdown page
+     */
+    async parsePage(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const { data: frontmatter, content: markdownContent } = matter(content);
+            const relativePath = path.relative(this.options.wikiDir, filePath);
+            // Extract headings
+            const headings = this.extractHeadings(markdownContent);
+            // Extract code blocks
+            const codeBlocks = this.extractCodeBlocks(markdownContent);
+            // Extract mermaid diagrams
+            const mermaidDiagrams = this.extractMermaidDiagrams(markdownContent);
+            // Process mermaid blocks before markdown conversion (replaces with placeholders)
+            const processedMarkdown = this.processMermaidBlocks(markdownContent);
+            // Convert markdown to HTML
+            const parsedHtml = await marked.parse(processedMarkdown);
+            // Restore mermaid diagrams after markdown processing to preserve their syntax
+            const htmlContent = this.restoreMermaidBlocks(parsedHtml);
+            return {
+                path: filePath,
+                relativePath,
+                title: frontmatter.title || this.extractTitle(markdownContent) || path.basename(filePath, '.md'),
+                description: frontmatter.description,
+                content: markdownContent,
+                htmlContent,
+                frontmatter,
+                sources: frontmatter.sources,
+                related: frontmatter.related,
+                headings,
+                codeBlocks,
+                mermaidDiagrams
+            };
+        }
+        catch (error) {
+            console.error(`Failed to parse ${filePath}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Extract headings from markdown content
+     */
+    extractHeadings(content) {
+        const headings = [];
+        const regex = /^(#{1,6})\s+(.+)$/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const level = match[1].length;
+            const text = match[2].trim();
+            headings.push({
+                level,
+                text,
+                id: this.slugify(text)
+            });
+        }
+        return headings;
+    }
+    /**
+     * Extract code blocks from markdown
+     */
+    extractCodeBlocks(content) {
+        const blocks = [];
+        const regex = /```(\w*)\n([\s\S]*?)```/g;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const language = match[1] || 'text';
+            const code = match[2];
+            // Skip mermaid blocks
+            if (language === 'mermaid')
+                continue;
+            // Look for source reference
+            const sourceMatch = code.match(/(?:\/\/|#)\s*Source:\s*(.+)/);
+            blocks.push({
+                language,
+                code,
+                sourceRef: sourceMatch ? sourceMatch[1].trim() : undefined
+            });
+        }
+        return blocks;
+    }
+    /**
+     * Extract mermaid diagram definitions
+     */
+    extractMermaidDiagrams(content) {
+        const diagrams = [];
+        const regex = /```mermaid\n([\s\S]*?)```/g;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            diagrams.push(match[1].trim());
+        }
+        return diagrams;
+    }
+    /**
+     * Process mermaid blocks by replacing them with placeholders before markdown processing.
+     * This prevents marked from corrupting the mermaid diagram syntax.
+     */
+    processMermaidBlocks(content) {
+        this.mermaidPlaceholders.clear();
+        let diagramIndex = 0;
+        return content.replace(/```mermaid\n([\s\S]*?)```/g, (_, diagram) => {
+            const id = `mermaid-${diagramIndex++}`;
+            const placeholder = `MERMAID_PLACEHOLDER_${id}_END`;
+            // Store the original diagram content with its HTML wrapper
+            this.mermaidPlaceholders.set(placeholder, `<div class="mermaid-container" id="${id}">
+        <div class="mermaid">${diagram.trim()}</div>
+        <button class="mermaid-fullscreen" title="Fullscreen" data-diagram="${id}">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <path d="M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"/>
+          </svg>
+        </button>
+      </div>`);
+            return placeholder;
+        });
+    }
+    /**
+     * Restore mermaid diagrams after markdown processing
+     */
+    restoreMermaidBlocks(html) {
+        let result = html;
+        for (const [placeholder, diagram] of this.mermaidPlaceholders) {
+            // The placeholder might be wrapped in <p> tags by marked, so handle both cases
+            result = result.replace(new RegExp(`<p>${placeholder}</p>`, 'g'), diagram);
+            result = result.replace(new RegExp(placeholder, 'g'), diagram);
+        }
+        return result;
+    }
+    /**
+     * Extract title from first H1 heading
+     */
+    extractTitle(content) {
+        const match = content.match(/^#\s+(.+)$/m);
+        return match ? match[1].trim() : null;
+    }
+    /**
+     * Build navigation structure from pages
+     */
+    buildNavigation() {
+        const sections = new Map();
+        for (const page of this.pages) {
+            const parts = page.relativePath.split(path.sep);
+            const section = parts.length > 1 ? parts[0] : 'Overview';
+            const htmlPath = page.relativePath.replace(/\.md$/, '.html');
+            if (!sections.has(section)) {
+                sections.set(section, []);
+            }
+            sections.get(section).push({
+                title: page.title,
+                path: htmlPath,
+                description: page.description
+            });
+        }
+        // Define section order
+        const sectionOrder = ['Overview', 'architecture', 'components', 'guides', 'api', 'reference'];
+        this.navigation.sections = Array.from(sections.entries())
+            .sort((a, b) => {
+            const aIndex = sectionOrder.indexOf(a[0]);
+            const bIndex = sectionOrder.indexOf(b[0]);
+            if (aIndex === -1 && bIndex === -1)
+                return a[0].localeCompare(b[0]);
+            if (aIndex === -1)
+                return 1;
+            if (bIndex === -1)
+                return -1;
+            return aIndex - bIndex;
+        })
+            .map(([title, pages]) => ({
+            title: this.formatSectionTitle(title),
+            path: pages[0]?.path || '',
+            pages
+        }));
+    }
+    /**
+     * Format section title for display
+     */
+    formatSectionTitle(title) {
+        return title
+            .split('-')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join(' ');
+    }
+    /**
+     * Generate guided tours based on content analysis
+     */
+    generateTours() {
+        // Architecture Overview Tour
+        const architectureTour = {
+            id: 'architecture-overview',
+            name: 'Architecture Overview',
+            description: 'Get a bird\'s-eye view of the system architecture',
+            steps: []
+        };
+        // Find architecture pages and create tour steps
+        const archPages = this.pages.filter(p => p.relativePath.includes('architecture') ||
+            p.relativePath === 'README.md');
+        for (const page of archPages.slice(0, 5)) {
+            architectureTour.steps.push({
+                id: `arch-${this.slugify(page.title)}`,
+                title: page.title,
+                description: page.description || `Learn about ${page.title}`,
+                targetSelector: '.main-content',
+                page: page.relativePath.replace(/\.md$/, '.html')
+            });
+        }
+        if (architectureTour.steps.length > 0) {
+            this.tours.push(architectureTour);
+        }
+        // Getting Started Tour
+        const gettingStartedTour = {
+            id: 'getting-started',
+            name: 'Getting Started',
+            description: 'Quick introduction to navigating this documentation',
+            steps: [
+                {
+                    id: 'welcome',
+                    title: 'Welcome!',
+                    description: 'This is your interactive architecture wiki. Let\'s take a quick tour!',
+                    targetSelector: '.site-header',
+                    position: 'bottom'
+                },
+                {
+                    id: 'navigation',
+                    title: 'Navigation',
+                    description: 'Use the sidebar to browse different sections of the documentation.',
+                    targetSelector: '.sidebar-nav',
+                    position: 'right'
+                },
+                {
+                    id: 'search',
+                    title: 'Quick Search',
+                    description: 'Press "/" or click here to search across all documentation.',
+                    targetSelector: '.search-trigger',
+                    position: 'bottom'
+                },
+                {
+                    id: 'code-blocks',
+                    title: 'Interactive Code',
+                    description: 'Code blocks are syntax highlighted. Click the copy button or source link to explore.',
+                    targetSelector: '.code-block',
+                    position: 'top'
+                },
+                {
+                    id: 'diagrams',
+                    title: 'Architecture Diagrams',
+                    description: 'Diagrams are interactive! Click to zoom, or use fullscreen mode.',
+                    targetSelector: '.mermaid-container',
+                    position: 'top'
+                },
+                {
+                    id: 'progress',
+                    title: 'Track Your Progress',
+                    description: 'Your reading progress is saved. Pages you\'ve visited are marked in the sidebar.',
+                    targetSelector: '.progress-indicator',
+                    position: 'left'
+                }
+            ]
+        };
+        this.tours.push(gettingStartedTour);
+        // Component Deep Dive Tour
+        const componentPages = this.pages.filter(p => p.relativePath.includes('component'));
+        if (componentPages.length > 0) {
+            const componentTour = {
+                id: 'component-deep-dive',
+                name: 'Component Deep Dive',
+                description: 'Explore the core components of the system',
+                steps: componentPages.slice(0, 8).map(page => ({
+                    id: `comp-${this.slugify(page.title)}`,
+                    title: page.title,
+                    description: page.description || `Understand the ${page.title} component`,
+                    targetSelector: '.main-content',
+                    page: page.relativePath.replace(/\.md$/, '.html')
+                }))
+            };
+            this.tours.push(componentTour);
+        }
+    }
+    /**
+     * Create output directory structure
+     */
+    createOutputDirs() {
+        if (!fs.existsSync(this.options.outputDir)) {
+            fs.mkdirSync(this.options.outputDir, { recursive: true });
+        }
+        // Create subdirectories for pages
+        const dirs = new Set();
+        for (const page of this.pages) {
+            const dir = path.dirname(page.relativePath);
+            if (dir !== '.') {
+                dirs.add(dir);
+            }
+        }
+        for (const dir of dirs) {
+            const fullPath = path.join(this.options.outputDir, dir);
+            if (!fs.existsSync(fullPath)) {
+                fs.mkdirSync(fullPath, { recursive: true });
+            }
+        }
+        // Create assets directory
+        const assetsDir = path.join(this.options.outputDir, 'assets');
+        if (!fs.existsSync(assetsDir)) {
+            fs.mkdirSync(assetsDir, { recursive: true });
+        }
+    }
+    /**
+     * Write static assets (CSS, JS)
+     */
+    async writeAssets() {
+        const assetsDir = path.join(this.options.outputDir, 'assets');
+        // Write CSS
+        const styles = getStyles();
+        fs.writeFileSync(path.join(assetsDir, 'styles.css'), styles);
+        // Write JavaScript
+        const scripts = getClientScripts(this.options.features);
+        fs.writeFileSync(path.join(assetsDir, 'app.js'), scripts);
+        console.log('  Wrote static assets');
+    }
+    /**
+     * Generate HTML pages
+     */
+    async generatePages() {
+        const templates = getTemplates();
+        for (const page of this.pages) {
+            const htmlPath = page.relativePath.replace(/\.md$/, '.html');
+            const outputPath = path.join(this.options.outputDir, htmlPath);
+            // Calculate relative path to root for asset links
+            const depth = page.relativePath.split(path.sep).length - 1;
+            const rootPath = depth > 0 ? '../'.repeat(depth) : './';
+            // Generate table of contents
+            const toc = this.generateTOC(page.headings);
+            // Generate breadcrumbs
+            const breadcrumbs = this.generateBreadcrumbs(page.relativePath);
+            // Generate related pages section
+            const relatedPages = this.generateRelatedPages(page);
+            // Build the full HTML page
+            const html = templates.page({
+                title: page.title,
+                siteTitle: this.options.title,
+                description: page.description || this.options.description,
+                content: page.htmlContent,
+                toc,
+                breadcrumbs,
+                relatedPages,
+                navigation: this.navigation,
+                rootPath,
+                currentPath: htmlPath,
+                features: this.options.features,
+                theme: this.options.theme
+            });
+            fs.writeFileSync(outputPath, html);
+        }
+        // Generate index.html (redirect to README.html or first page)
+        const indexPage = this.pages.find(p => p.relativePath === 'README.md') || this.pages[0];
+        if (indexPage) {
+            const indexHtml = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="refresh" content="0; url=${indexPage.relativePath.replace(/\.md$/, '.html')}">
+  <title>${this.options.title}</title>
+</head>
+<body>
+  <p>Redirecting to <a href="${indexPage.relativePath.replace(/\.md$/, '.html')}">${indexPage.title}</a>...</p>
+</body>
+</html>`;
+            fs.writeFileSync(path.join(this.options.outputDir, 'index.html'), indexHtml);
+        }
+        console.log(`  Generated ${this.pages.length} HTML pages`);
+    }
+    /**
+     * Generate table of contents from headings
+     */
+    generateTOC(headings) {
+        if (headings.length === 0)
+            return '';
+        // Filter to h2 and h3 only for cleaner TOC
+        const tocHeadings = headings.filter(h => h.level >= 2 && h.level <= 3);
+        if (tocHeadings.length < 2)
+            return '';
+        let html = '<nav class="toc"><h3 class="toc-title">On This Page</h3><ul class="toc-list">';
+        for (const heading of tocHeadings) {
+            const indent = heading.level - 2;
+            html += `<li class="toc-item toc-level-${indent}"><a href="#${heading.id}">${heading.text}</a></li>`;
+        }
+        html += '</ul></nav>';
+        return html;
+    }
+    /**
+     * Generate breadcrumb navigation
+     */
+    generateBreadcrumbs(relativePath) {
+        const parts = relativePath.split(path.sep);
+        if (parts.length === 1)
+            return '';
+        let html = '<nav class="breadcrumbs" aria-label="Breadcrumb"><ol>';
+        let currentPath = '';
+        // Add home link
+        html += `<li><a href="${'../'.repeat(parts.length - 1)}index.html">Home</a></li>`;
+        for (let i = 0; i < parts.length - 1; i++) {
+            currentPath += parts[i] + '/';
+            html += `<li><a href="${'../'.repeat(parts.length - 1 - i)}${currentPath}index.html">${this.formatSectionTitle(parts[i])}</a></li>`;
+        }
+        // Current page (not a link)
+        const page = this.pages.find(p => p.relativePath === relativePath);
+        html += `<li aria-current="page">${page?.title || parts[parts.length - 1]}</li>`;
+        html += '</ol></nav>';
+        return html;
+    }
+    /**
+     * Generate related pages section
+     */
+    generateRelatedPages(page) {
+        const related = [];
+        // Add explicitly related pages
+        if (page.related) {
+            for (const relPath of page.related) {
+                const relPage = this.pages.find(p => p.relativePath === relPath || p.relativePath === relPath + '.md');
+                if (relPage)
+                    related.push(relPage);
+            }
+        }
+        // Add pages in same section
+        const section = path.dirname(page.relativePath);
+        if (section !== '.') {
+            const sectionPages = this.pages.filter(p => path.dirname(p.relativePath) === section &&
+                p.relativePath !== page.relativePath);
+            for (const sp of sectionPages.slice(0, 3)) {
+                if (!related.includes(sp))
+                    related.push(sp);
+            }
+        }
+        if (related.length === 0)
+            return '';
+        let html = '<aside class="related-pages"><h3>Related Pages</h3><ul>';
+        for (const rp of related.slice(0, 5)) {
+            const href = this.getRelativeLink(page.relativePath, rp.relativePath);
+            html += `<li><a href="${href}">${rp.title}</a>${rp.description ? `<span class="related-desc">${rp.description}</span>` : ''}</li>`;
+        }
+        html += '</ul></aside>';
+        return html;
+    }
+    /**
+     * Get relative link between two pages
+     */
+    getRelativeLink(fromPath, toPath) {
+        const fromDir = path.dirname(fromPath);
+        const toHtml = toPath.replace(/\.md$/, '.html');
+        if (fromDir === '.') {
+            return toHtml;
+        }
+        const depth = fromDir.split(path.sep).length;
+        return '../'.repeat(depth) + toHtml;
+    }
+    /**
+     * Generate site manifest for client-side features
+     */
+    async generateManifest() {
+        const manifest = {
+            title: this.options.title,
+            description: this.options.description,
+            generated: new Date().toISOString(),
+            pages: this.pages.map(p => ({
+                path: p.relativePath.replace(/\.md$/, '.html'),
+                title: p.title,
+                description: p.description
+            })),
+            navigation: this.navigation,
+            tours: this.tours,
+            searchIndex: this.pages.map(p => ({
+                path: p.relativePath.replace(/\.md$/, '.html'),
+                title: p.title,
+                content: this.stripMarkdown(p.content).slice(0, 5000), // Limit for performance
+                headings: p.headings.map(h => h.text)
+            }))
+        };
+        fs.writeFileSync(path.join(this.options.outputDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        console.log('  Generated site manifest');
+    }
+    /**
+     * Strip markdown formatting from content
+     */
+    stripMarkdown(content) {
+        return content
+            .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+            .replace(/`[^`]+`/g, '') // Remove inline code
+            .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Remove links
+            .replace(/[*_~]+/g, '') // Remove emphasis
+            .replace(/^#+\s*/gm, '') // Remove headings
+            .replace(/\n{3,}/g, '\n\n') // Normalize newlines
+            .trim();
+    }
+    /**
+     * Create URL-safe slug from text
+     */
+    slugify(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/\s+/g, '-')
+            .replace(/-+/g, '-')
+            .trim();
+    }
+    /**
+     * Escape HTML entities
+     */
+    escapeHtml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#039;');
+    }
+}
+//# sourceMappingURL=site-generator.js.map