mermaid-formatter 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 chenyanchen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# mermaid-formatter
+
+A formatter for [Mermaid](https://mermaid.js.org/) diagram syntax.
+
+## Features
+
+- Format all Mermaid diagram types (sequenceDiagram, flowchart, classDiagram, etc.)
+- Normalize indentation and whitespace
+- Format Mermaid code blocks in Markdown
+- CLI tool and programmatic API
+- Zero dependencies (lightweight)
+
+## Installation
+
+```bash
+npm install mermaid-formatter
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Format file to stdout
+npx mmdfmt diagram.mmd
+
+# Format file in-place
+npx mmdfmt -w diagram.mmd
+
+# Format from stdin
+echo "sequenceDiagram
+  A->>B: hello" | npx mmdfmt
+
+# Custom indent (default: 4 spaces)
+npx mmdfmt --indent 2 diagram.mmd
+
+# Use tabs instead of spaces
+npx mmdfmt --tabs diagram.mmd
+```
+
+### Programmatic API
+
+```typescript
+import { formatMermaid, formatMarkdownMermaidBlocks } from 'mermaid-formatter';
+
+// Format Mermaid code
+const input = `sequenceDiagram
+      participant A
+        A->>B:  Hello`;
+
+const formatted = formatMermaid(input);
+// Output:
+// sequenceDiagram
+//     participant A
+//     A->>B: Hello
+
+// With options
+const formatted2 = formatMermaid(input, { indentSize: 2, useTabs: false });
+
+// Format Mermaid blocks in Markdown
+const markdown = `
+# My Document
+
+\`\`\`mermaid
+sequenceDiagram
+  A->>B: hello
+\`\`\`
+`;
+
+const formattedMarkdown = formatMarkdownMermaidBlocks(markdown);
+```
+
+### API Reference
+
+#### `formatMermaid(input: string, options?: FormatOptions): string`
+
+Format Mermaid diagram source code.
+
+**Options:**
+
+- `indentSize` (number, default: 4) - Number of spaces for indentation
+- `useTabs` (boolean, default: false) - Use tabs instead of spaces
+
+#### `formatMarkdownMermaidBlocks(markdown: string, options?: FormatOptions): string`
+
+Format all Mermaid code blocks in a Markdown document.
+
+#### `parse(input: string): Diagram`
+
+Parse Mermaid source into an AST.
+
+#### `detectDiagramType(input: string): DiagramType`
+
+Detect the diagram type from source code.
+
+## Formatting Rules
+
+- Diagram declaration at column 0
+- Block keywords (`critical`, `alt`, `loop`, `par`, `opt`, `break`, `rect`, `subgraph`, `end`) at column 0
+- Content inside blocks indented by configured amount
+- Consecutive blank lines collapsed to single blank line
+- Blank line inserted before block starts
+- Whitespace normalized (multiple spaces → single, bracket padding removed)
+
+## Supported Diagram Types
+
+- sequenceDiagram
+- flowchart / graph
+- classDiagram
+- stateDiagram / stateDiagram-v2
+- erDiagram
+- journey
+- gantt
+- pie
+- quadrantChart
+- requirementDiagram
+- gitGraph
+- mindmap
+- timeline
+- sankey-beta
+- xychart-beta
+- block-beta
+- architecture-beta
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from 'node:fs';
+import { formatMermaid } from './index.js';
+function parseArgs(args) {
+    const result = {
+        write: false,
+        indent: 4,
+        tabs: false,
+        help: false,
+        version: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-h' || arg === '--help') {
+            result.help = true;
+        }
+        else if (arg === '-v' || arg === '--version') {
+            result.version = true;
+        }
+        else if (arg === '-w' || arg === '--write') {
+            result.write = true;
+        }
+        else if (arg === '--tabs') {
+            result.tabs = true;
+        }
+        else if (arg === '--indent') {
+            const next = args[++i];
+            const parsed = parseInt(next, 10);
+            result.indent = Number.isNaN(parsed) ? 4 : parsed;
+        }
+        else if (arg.startsWith('--indent=')) {
+            const parsed = parseInt(arg.slice(9), 10);
+            result.indent = Number.isNaN(parsed) ? 4 : parsed;
+        }
+        else if (!arg.startsWith('-')) {
+            result.file = arg;
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+mmdfmt - Mermaid diagram formatter
+
+USAGE:
+    mmdfmt [OPTIONS] [FILE]
+
+ARGS:
+    <FILE>    Input file (reads from stdin if not provided)
+
+OPTIONS:
+    -w, --write         Write result to source file instead of stdout
+    --indent <N>        Number of spaces for indentation (default: 4)
+    --tabs              Use tabs instead of spaces
+    -h, --help          Print help information
+    -v, --version       Print version information
+
+EXAMPLES:
+    # Format file to stdout
+    mmdfmt diagram.mmd
+
+    # Format file in-place
+    mmdfmt -w diagram.mmd
+
+    # Format from stdin
+    echo "sequenceDiagram" | mmdfmt
+
+    # Custom indent
+    mmdfmt --indent 2 diagram.mmd
+    mmdfmt --tabs diagram.mmd
+`);
+}
+function printVersion() {
+    // Read version from package.json
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+        console.log(`mmdfmt ${pkg.version}`);
+    }
+    catch {
+        console.log('mmdfmt 0.1.0');
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        process.stdin.on('data', (chunk) => chunks.push(chunk));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        process.stdin.on('error', reject);
+    });
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (args.version) {
+        printVersion();
+        process.exit(0);
+    }
+    const options = {
+        indentSize: args.indent,
+        useTabs: args.tabs,
+    };
+    let input;
+    if (args.file) {
+        try {
+            input = readFileSync(args.file, 'utf-8');
+        }
+        catch (_err) {
+            console.error(`Error reading file: ${args.file}`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Check if stdin is a TTY (no piped input)
+        if (process.stdin.isTTY) {
+            printHelp();
+            process.exit(0);
+        }
+        input = await readStdin();
+    }
+    try {
+        const formatted = formatMermaid(input, options);
+        if (args.write && args.file) {
+            writeFileSync(args.file, formatted, 'utf-8');
+        }
+        else {
+            process.stdout.write(formatted);
+        }
+    }
+    catch (err) {
+        console.error(`Error formatting: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/formatter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Formatter for Mermaid diagram AST.
+ * Converts AST back to formatted source code.
+ */
+import type { Diagram, FormatOptions } from './types.js';
+/**
+ * Format a parsed diagram AST back to string.
+ */
+export declare function format(diagram: Diagram, options?: FormatOptions): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/formatter.js

@@ -0,0 +1,220 @@
+/**
+ * Formatter for Mermaid diagram AST.
+ * Converts AST back to formatted source code.
+ */
+// ============================================================================
+// Configuration
+// ============================================================================
+const DEFAULT_OPTIONS = {
+    indentSize: 4,
+    useTabs: false,
+};
+const STATEMENT_FORMATTERS = {
+    'block-start': (stmt) => {
+        const s = stmt;
+        return s.label ? `${s.blockKind} ${s.label}` : s.blockKind;
+    },
+    'brace-block-start': (stmt) => {
+        const s = stmt;
+        return `${s.blockKind} ${s.name} {`;
+    },
+    'block-option': (stmt) => {
+        const label = stmt.label;
+        return label ? `option ${label}` : 'option';
+    },
+    'block-else': (stmt) => {
+        const label = stmt.label;
+        return label ? `else ${label}` : 'else';
+    },
+};
+// Statements that need content normalization
+const NORMALIZABLE_TYPES = [
+    'generic-line',
+    'participant',
+    'note',
+];
+const CONTENT_NORMALIZERS = [
+    // Collapse multiple spaces to single space
+    (content) => content.replace(/  +/g, ' '),
+    // Normalize spaces after colon (A:  B -> A: B)
+    (content) => content.replace(/:\s{2,}/g, ': '),
+    // Normalize bracket padding: [ text ] -> [text]
+    (content) => normalizeBracketPair(content, '[', ']'),
+    // Normalize brace padding: { text } -> {text}
+    (content) => normalizeBracketPair(content, '{', '}'),
+    // Normalize paren padding: ( text ) -> (text)
+    (content) => normalizeBracketPair(content, '(', ')'),
+    // Normalize pipe labels: | text | -> |text|
+    (content) => content.replace(/\|\s+([^|]*?)\s*\|/g, (_, inner) => `|${inner.trim()}|`),
+];
+function normalizeContent(content) {
+    return CONTENT_NORMALIZERS.reduce((acc, fn) => fn(acc), content);
+}
+// ============================================================================
+// Indentation Rules
+// ============================================================================
+/** Statements that always appear at column 0 (relative to brace depth) */
+const COLUMN_ZERO_TYPES = [
+    'diagram-decl',
+    'directive',
+    'block-start',
+    'block-option',
+    'block-else',
+    'block-end',
+];
+function getIndentDepth(stmt, seenDiagramDecl, braceBlockDepth) {
+    // Diagram declaration and directives: always at column 0
+    if (stmt.type === 'diagram-decl' || stmt.type === 'directive') {
+        return 0;
+    }
+    // Block control statements: at column 0 (relative to brace depth)
+    if (COLUMN_ZERO_TYPES.includes(stmt.type)) {
+        return braceBlockDepth;
+    }
+    // Brace block start/end: at brace depth level
+    if (stmt.type === 'brace-block-start' || stmt.type === 'brace-block-end') {
+        return braceBlockDepth;
+    }
+    // Inside brace blocks: use brace depth directly
+    if (braceBlockDepth > 0) {
+        return braceBlockDepth;
+    }
+    // At top level (after diagram decl): indent by 1
+    if (seenDiagramDecl) {
+        return 1;
+    }
+    return 0;
+}
+// ============================================================================
+// Blank Line Rules
+// ============================================================================
+/** Types that trigger blank line insertion before block starts */
+const BLANK_BEFORE_BLOCK_TYPES = [
+    'diagram-decl',
+    'generic-line',
+    'participant',
+    'note',
+    'block-end',
+    'brace-block-end',
+];
+function shouldInsertBlankBefore(stmt, lastNonBlankType) {
+    if (!lastNonBlankType)
+        return false;
+    // Insert blank before block-start or brace-block-start
+    if (stmt.type === 'block-start' || stmt.type === 'brace-block-start') {
+        return BLANK_BEFORE_BLOCK_TYPES.includes(lastNonBlankType);
+    }
+    return false;
+}
+// ============================================================================
+// Main Format Function
+// ============================================================================
+/**
+ * Format a parsed diagram AST back to string.
+ */
+export function format(diagram, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const indentStr = opts.useTabs ? '\t' : ' '.repeat(opts.indentSize);
+    const lines = [];
+    let braceBlockDepth = 0;
+    let seenDiagramDecl = false;
+    let lastNonBlankType = null;
+    for (let i = 0; i < diagram.statements.length; i++) {
+        const stmt = diagram.statements[i];
+        // Handle blank lines: collapse consecutive blanks, skip trailing
+        if (stmt.type === 'blank-line') {
+            if (lastNonBlankType === 'blank-line' ||
+                i === diagram.statements.length - 1) {
+                continue;
+            }
+            if (lines.length === 0) {
+                continue;
+            }
+            lines.push('');
+            lastNonBlankType = 'blank-line';
+            continue;
+        }
+        // Insert blank line before block-start if needed
+        if (shouldInsertBlankBefore(stmt, lastNonBlankType)) {
+            if (lines.length > 0 && lines[lines.length - 1] !== '') {
+                lines.push('');
+            }
+        }
+        // Decrement brace depth before formatting brace-block-end
+        if (stmt.type === 'brace-block-end' && braceBlockDepth > 0) {
+            braceBlockDepth--;
+        }
+        // Calculate indentation depth
+        const depth = getIndentDepth(stmt, seenDiagramDecl, braceBlockDepth);
+        // Format the statement
+        const content = formatStatement(stmt);
+        const formatted = depth > 0 ? indentStr.repeat(depth) + content : content;
+        lines.push(formatted);
+        // Update state
+        if (stmt.type === 'diagram-decl') {
+            seenDiagramDecl = true;
+        }
+        if (stmt.type === 'brace-block-start') {
+            braceBlockDepth++;
+        }
+        lastNonBlankType = stmt.type;
+    }
+    // Ensure single trailing newline
+    return lines.join('\n') + '\n';
+}
+/**
+ * Format a single statement's content.
+ */
+function formatStatement(stmt) {
+    // Use custom formatter if available
+    const formatter = STATEMENT_FORMATTERS[stmt.type];
+    if (formatter) {
+        return formatter(stmt);
+    }
+    // Normalize content for specific types
+    if (NORMALIZABLE_TYPES.includes(stmt.type)) {
+        return normalizeContent(stmt.content);
+    }
+    // Default: return content as-is
+    return stmt.content;
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Normalize padding inside bracket pairs.
+ * Only normalizes when there's space after opening bracket.
+ */
+function normalizeBracketPair(content, open, close) {
+    const chars = [...content];
+    const result = [];
+    let i = 0;
+    while (i < chars.length) {
+        if (chars[i] === open && chars[i + 1] === ' ') {
+            // Find matching close bracket
+            let depth = 1;
+            let j = i + 1;
+            while (j < chars.length && depth > 0) {
+                if (chars[j] === open)
+                    depth++;
+                else if (chars[j] === close)
+                    depth--;
+                j++;
+            }
+            if (depth === 0) {
+                // Extract inner content (excluding brackets)
+                const inner = chars
+                    .slice(i + 1, j - 1)
+                    .join('')
+                    .trim();
+                result.push(open, inner, close);
+                i = j;
+                continue;
+            }
+        }
+        result.push(chars[i]);
+        i++;
+    }
+    return result.join('');
+}
+//# sourceMappingURL=formatter.js.map

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Mermaid Formatter - Public API
+ *
+ * Format Mermaid diagram syntax for consistent code style.
+ */
+export type { FormatOptions, DiagramType, Statement, Diagram, StatementType, BlockKind, BraceBlockKind, } from './types.js';
+export { parse, detectDiagramType } from './parser.js';
+export { format } from './formatter.js';
+export { isIndentSensitive, INDENT_SENSITIVE_DIAGRAMS } from './rules.js';
+import type { FormatOptions } from './types.js';
+/**
+ * Format Mermaid diagram source code.
+ *
+ * @param input - Mermaid diagram source code
+ * @param options - Formatting options
+ * @returns Formatted Mermaid code
+ *
+ * @example
+ * ```ts
+ * import { formatMermaid } from 'mermaid-formatter';
+ *
+ * const formatted = formatMermaid(`
+ * sequenceDiagram
+ *     participant A
+ *         A->>B: Hello
+ * `);
+ * ```
+ */
+export declare function formatMermaid(input: string, options?: FormatOptions): string;
+/**
+ * Format Mermaid code blocks in Markdown.
+ *
+ * Preserves indentation for nested code blocks (in lists, blockquotes, etc.)
+ *
+ * @param markdown - Markdown content
+ * @param options - Formatting options
+ * @returns Markdown with formatted Mermaid blocks
+ *
+ * @example
+ * ```ts
+ * import { formatMarkdownMermaidBlocks } from 'mermaid-formatter';
+ *
+ * const formatted = formatMarkdownMermaidBlocks(`
+ * # My Document
+ *
+ * \`\`\`mermaid
+ * sequenceDiagram
+ *     A->>B: Hello
+ * \`\`\`
+ * `);
+ * ```
+ */
+export declare function formatMarkdownMermaidBlocks(markdown: string, options?: FormatOptions): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,99 @@
+/**
+ * Mermaid Formatter - Public API
+ *
+ * Format Mermaid diagram syntax for consistent code style.
+ */
+// Function exports
+export { parse, detectDiagramType } from './parser.js';
+export { format } from './formatter.js';
+export { isIndentSensitive, INDENT_SENSITIVE_DIAGRAMS } from './rules.js';
+// Internal imports
+import { parse, detectDiagramType } from './parser.js';
+import { format } from './formatter.js';
+import { isIndentSensitive } from './rules.js';
+// ============================================================================
+// Main API
+// ============================================================================
+/**
+ * Format Mermaid diagram source code.
+ *
+ * @param input - Mermaid diagram source code
+ * @param options - Formatting options
+ * @returns Formatted Mermaid code
+ *
+ * @example
+ * ```ts
+ * import { formatMermaid } from 'mermaid-formatter';
+ *
+ * const formatted = formatMermaid(`
+ * sequenceDiagram
+ *     participant A
+ *         A->>B: Hello
+ * `);
+ * ```
+ */
+export function formatMermaid(input, options) {
+    // Pipeline: detect -> check policy -> parse -> format
+    const diagramType = detectDiagramType(input);
+    // Policy: skip formatting for indent-sensitive diagrams
+    if (isIndentSensitive(diagramType)) {
+        return ensureTrailingNewline(input);
+    }
+    const diagram = parse(input);
+    return format(diagram, options);
+}
+/**
+ * Format Mermaid code blocks in Markdown.
+ *
+ * Preserves indentation for nested code blocks (in lists, blockquotes, etc.)
+ *
+ * @param markdown - Markdown content
+ * @param options - Formatting options
+ * @returns Markdown with formatted Mermaid blocks
+ *
+ * @example
+ * ```ts
+ * import { formatMarkdownMermaidBlocks } from 'mermaid-formatter';
+ *
+ * const formatted = formatMarkdownMermaidBlocks(`
+ * # My Document
+ *
+ * \`\`\`mermaid
+ * sequenceDiagram
+ *     A->>B: Hello
+ * \`\`\`
+ * `);
+ * ```
+ */
+export function formatMarkdownMermaidBlocks(markdown, options) {
+    // Pattern captures:
+    // 1. Leading indentation (spaces/tabs before ```)
+    // 2. Code content between fences
+    // Supports both LF and CRLF line endings
+    return markdown.replace(/^([ \t]*)```mermaid\r?\n([\s\S]*?)```/gm, (_, indent, code) => {
+        const formatted = formatMermaid(code, options);
+        const indentedCode = applyIndent(formatted, indent);
+        return `${indent}\`\`\`mermaid\n${indentedCode}${indent}\`\`\``;
+    });
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Ensure string ends with exactly one newline.
+ */
+function ensureTrailingNewline(input) {
+    return input.endsWith('\n') ? input : input + '\n';
+}
+/**
+ * Apply indentation to each non-empty line.
+ */
+function applyIndent(content, indent) {
+    if (!indent)
+        return content;
+    return content
+        .split('\n')
+        .map((line) => (line ? indent + line : line))
+        .join('\n');
+}
+//# sourceMappingURL=index.js.map

package/dist/parser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightweight parser for Mermaid diagram syntax.
+ * Converts source code into an AST for formatting.
+ */
+import type { Diagram, DiagramType } from './types.js';
+/**
+ * Parse Mermaid diagram source into AST.
+ */
+export declare function parse(input: string): Diagram;
+/**
+ * Detect diagram type from source code.
+ */
+export declare function detectDiagramType(input: string): DiagramType;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.js

@@ -0,0 +1,116 @@
+/**
+ * Lightweight parser for Mermaid diagram syntax.
+ * Converts source code into an AST for formatting.
+ */
+import { matchDiagramType, matchBlockKeyword, matchBraceBlockStart, } from './rules.js';
+/**
+ * Parse Mermaid diagram source into AST.
+ */
+export function parse(input) {
+    const lines = input.split('\n');
+    const statements = [];
+    let diagramType = 'unknown';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const statement = parseLine(trimmed, diagramType);
+        if (statement) {
+            // Track diagram type from first declaration
+            if (statement.type === 'diagram-decl' && diagramType === 'unknown') {
+                diagramType = statement.diagramType;
+            }
+            statements.push(statement);
+        }
+    }
+    return { type: diagramType, statements };
+}
+/**
+ * Parse a single line into a statement.
+ */
+function parseLine(trimmed, currentDiagramType) {
+    // Blank line
+    if (trimmed === '') {
+        return { type: 'blank-line', content: '' };
+    }
+    // Comment (but not directive)
+    if (trimmed.startsWith('%%') && !trimmed.startsWith('%%{')) {
+        return { type: 'comment', content: trimmed };
+    }
+    // Directive %%{ ... }%%
+    if (trimmed.startsWith('%%{')) {
+        return { type: 'directive', content: trimmed };
+    }
+    // Diagram declaration
+    const detectedType = matchDiagramType(trimmed);
+    if (detectedType && currentDiagramType === 'unknown') {
+        return {
+            type: 'diagram-decl',
+            diagramType: detectedType,
+            content: trimmed,
+        };
+    }
+    // Block end: 'end'
+    if (trimmed === 'end') {
+        return { type: 'block-end', content: 'end' };
+    }
+    // Brace block end: '}'
+    if (trimmed === '}') {
+        return { type: 'brace-block-end', content: '}' };
+    }
+    // Block option (sequence diagram)
+    if (/^option\b/.test(trimmed)) {
+        const label = trimmed.slice(6).trim() || undefined;
+        return { type: 'block-option', label, content: trimmed };
+    }
+    // Block else (sequence diagram)
+    if (/^else\b/.test(trimmed)) {
+        const label = trimmed.slice(4).trim() || undefined;
+        return { type: 'block-else', label, content: trimmed };
+    }
+    // Block start with 'end' keyword
+    const blockKind = matchBlockKeyword(trimmed);
+    if (blockKind) {
+        const label = trimmed.slice(blockKind.length).trim() || undefined;
+        return {
+            type: 'block-start',
+            blockKind,
+            label,
+            content: trimmed,
+        };
+    }
+    // Brace block start (state/class/namespace with {)
+    const braceBlock = matchBraceBlockStart(trimmed);
+    if (braceBlock) {
+        return {
+            type: 'brace-block-start',
+            blockKind: braceBlock.kind,
+            name: braceBlock.name,
+            content: trimmed,
+        };
+    }
+    // Participant declaration (sequence diagram)
+    if (/^participant\b/.test(trimmed) || /^actor\b/.test(trimmed)) {
+        return { type: 'participant', content: trimmed };
+    }
+    // Note
+    if (/^note\b/i.test(trimmed)) {
+        return { type: 'note', content: trimmed };
+    }
+    // Generic line (arrows, relationships, nodes, etc.)
+    return { type: 'generic-line', content: trimmed };
+}
+/**
+ * Detect diagram type from source code.
+ */
+export function detectDiagramType(input) {
+    const lines = input.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '' || trimmed.startsWith('%%'))
+            continue;
+        const type = matchDiagramType(trimmed);
+        if (type)
+            return type;
+    }
+    return 'unknown';
+}
+//# sourceMappingURL=parser.js.map

package/dist/rules.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Centralized grammar rules and patterns for Mermaid diagrams.
+ * All syntax definitions in one place for easy maintenance.
+ */
+import type { DiagramType, BlockKind, BraceBlockKind } from './types.js';
+/**
+ * Patterns for detecting diagram types.
+ * Order matters: more specific patterns should come first.
+ */
+export declare const DIAGRAM_PATTERNS: [RegExp, DiagramType][];
+/**
+ * Block keywords that close with 'end' keyword.
+ * Used in sequence diagrams, flowcharts, etc.
+ */
+export declare const BLOCK_KEYWORDS: BlockKind[];
+/**
+ * Block keywords that close with '}'.
+ * Used in class diagrams, state diagrams, etc.
+ */
+export declare const BRACE_BLOCK_KEYWORDS: BraceBlockKind[];
+/**
+ * Diagram types where indentation represents hierarchy.
+ * These should NOT be reformatted as it would change semantics.
+ */
+export declare const INDENT_SENSITIVE_DIAGRAMS: DiagramType[];
+/**
+ * Check if a diagram type is indent-sensitive.
+ */
+export declare function isIndentSensitive(diagramType: DiagramType): boolean;
+/**
+ * Match diagram type from a line of text.
+ */
+export declare function matchDiagramType(line: string): DiagramType | null;
+/**
+ * Match block start keyword (critical, alt, loop, etc.)
+ */
+export declare function matchBlockKeyword(line: string): BlockKind | null;
+/**
+ * Match brace block start (state Name {, class Name {, namespace Name {)
+ */
+export declare function matchBraceBlockStart(line: string): {
+    kind: BraceBlockKind;
+    name: string;
+} | null;
+//# sourceMappingURL=rules.d.ts.map

package/dist/rules.js

@@ -0,0 +1,100 @@
+/**
+ * Centralized grammar rules and patterns for Mermaid diagrams.
+ * All syntax definitions in one place for easy maintenance.
+ */
+/**
+ * Patterns for detecting diagram types.
+ * Order matters: more specific patterns should come first.
+ */
+export const DIAGRAM_PATTERNS = [
+    [/^sequenceDiagram\b/, 'sequenceDiagram'],
+    [/^flowchart(\s+(TD|TB|BT|LR|RL))?\b/, 'flowchart'],
+    [/^graph(\s+(TD|TB|BT|LR|RL))?\b/, 'graph'],
+    [/^classDiagram\b/, 'classDiagram'],
+    [/^stateDiagram-v2\b/, 'stateDiagram-v2'],
+    [/^stateDiagram\b/, 'stateDiagram'],
+    [/^erDiagram\b/, 'erDiagram'],
+    [/^journey\b/, 'journey'],
+    [/^gantt\b/, 'gantt'],
+    [/^pie(\s+showData)?\b/, 'pie'],
+    [/^quadrantChart\b/, 'quadrantChart'],
+    [/^requirementDiagram\b/, 'requirementDiagram'],
+    [/^gitGraph\b/, 'gitGraph'],
+    [/^mindmap\b/, 'mindmap'],
+    [/^timeline\b/, 'timeline'],
+    [/^sankey-beta\b/, 'sankey-beta'],
+    [/^xychart-beta\b/, 'xychart-beta'],
+    [/^block-beta\b/, 'block-beta'],
+    [/^architecture-beta\b/, 'architecture-beta'],
+];
+/**
+ * Block keywords that close with 'end' keyword.
+ * Used in sequence diagrams, flowcharts, etc.
+ */
+export const BLOCK_KEYWORDS = [
+    'critical',
+    'alt',
+    'loop',
+    'par',
+    'opt',
+    'break',
+    'rect',
+    'subgraph',
+];
+/**
+ * Block keywords that close with '}'.
+ * Used in class diagrams, state diagrams, etc.
+ */
+export const BRACE_BLOCK_KEYWORDS = [
+    'state',
+    'class',
+    'namespace',
+];
+/**
+ * Diagram types where indentation represents hierarchy.
+ * These should NOT be reformatted as it would change semantics.
+ */
+export const INDENT_SENSITIVE_DIAGRAMS = ['mindmap', 'timeline'];
+/**
+ * Check if a diagram type is indent-sensitive.
+ */
+export function isIndentSensitive(diagramType) {
+    return INDENT_SENSITIVE_DIAGRAMS.includes(diagramType);
+}
+/**
+ * Match diagram type from a line of text.
+ */
+export function matchDiagramType(line) {
+    for (const [pattern, type] of DIAGRAM_PATTERNS) {
+        if (pattern.test(line)) {
+            return type;
+        }
+    }
+    return null;
+}
+/**
+ * Match block start keyword (critical, alt, loop, etc.)
+ */
+export function matchBlockKeyword(line) {
+    for (const keyword of BLOCK_KEYWORDS) {
+        const pattern = new RegExp(`^${keyword}\\b`);
+        if (pattern.test(line)) {
+            return keyword;
+        }
+    }
+    return null;
+}
+/**
+ * Match brace block start (state Name {, class Name {, namespace Name {)
+ */
+export function matchBraceBlockStart(line) {
+    for (const keyword of BRACE_BLOCK_KEYWORDS) {
+        const pattern = new RegExp(`^${keyword}\\s+(.+?)\\s*\\{\\s*$`);
+        const match = line.match(pattern);
+        if (match) {
+            return { kind: keyword, name: match[1].trim() };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=rules.js.map

package/dist/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Type definitions for Mermaid formatter AST and options.
+ */
+/**
+ * Formatting configuration options.
+ */
+export interface FormatOptions {
+    /** Number of spaces for indentation (default: 4) */
+    indentSize?: number;
+    /** Use tabs instead of spaces (default: false) */
+    useTabs?: boolean;
+}
+/**
+ * Supported Mermaid diagram types.
+ */
+export type DiagramType = 'sequenceDiagram' | 'flowchart' | 'graph' | 'classDiagram' | 'stateDiagram' | 'stateDiagram-v2' | 'erDiagram' | 'journey' | 'gantt' | 'pie' | 'quadrantChart' | 'requirementDiagram' | 'gitGraph' | 'mindmap' | 'timeline' | 'sankey-beta' | 'xychart-beta' | 'block-beta' | 'architecture-beta' | 'unknown';
+/**
+ * Block types that close with 'end' keyword.
+ */
+export type BlockKind = 'critical' | 'alt' | 'loop' | 'par' | 'opt' | 'break' | 'rect' | 'subgraph';
+/**
+ * Block types that close with '}'.
+ */
+export type BraceBlockKind = 'state' | 'class' | 'namespace';
+/** Base interface for all statement nodes */
+interface StatementBase {
+    type: string;
+}
+/** Diagram type declaration (e.g., "sequenceDiagram", "flowchart TD") */
+export interface DiagramDeclStatement extends StatementBase {
+    type: 'diagram-decl';
+    diagramType: DiagramType;
+    content: string;
+}
+/** Directive (e.g., "%%{init: {...}}%%") */
+export interface DirectiveStatement extends StatementBase {
+    type: 'directive';
+    content: string;
+}
+/** Participant declaration (sequence diagram) */
+export interface ParticipantStatement extends StatementBase {
+    type: 'participant';
+    content: string;
+}
+/** Block start with 'end' keyword (critical, alt, loop, etc.) */
+export interface BlockStartStatement extends StatementBase {
+    type: 'block-start';
+    blockKind: BlockKind;
+    label?: string;
+    content: string;
+}
+/** Brace block start (state {, class {, namespace {) */
+export interface BraceBlockStartStatement extends StatementBase {
+    type: 'brace-block-start';
+    blockKind: BraceBlockKind;
+    name: string;
+    content: string;
+}
+/** Block option (sequence diagram) */
+export interface BlockOptionStatement extends StatementBase {
+    type: 'block-option';
+    label?: string;
+    content: string;
+}
+/** Block else (sequence diagram) */
+export interface BlockElseStatement extends StatementBase {
+    type: 'block-else';
+    label?: string;
+    content: string;
+}
+/** Block end ('end' keyword) */
+export interface BlockEndStatement extends StatementBase {
+    type: 'block-end';
+    content: string;
+}
+/** Brace block end ('}') */
+export interface BraceBlockEndStatement extends StatementBase {
+    type: 'brace-block-end';
+    content: string;
+}
+/** Note statement */
+export interface NoteStatement extends StatementBase {
+    type: 'note';
+    content: string;
+}
+/** Comment (e.g., "%% comment") */
+export interface CommentStatement extends StatementBase {
+    type: 'comment';
+    content: string;
+}
+/** Generic line (arrows, relationships, nodes, etc.) */
+export interface GenericLineStatement extends StatementBase {
+    type: 'generic-line';
+    content: string;
+}
+/** Blank line */
+export interface BlankLineStatement extends StatementBase {
+    type: 'blank-line';
+    content: '';
+}
+/**
+ * Union of all statement types.
+ */
+export type Statement = DiagramDeclStatement | DirectiveStatement | ParticipantStatement | BlockStartStatement | BraceBlockStartStatement | BlockOptionStatement | BlockElseStatement | BlockEndStatement | BraceBlockEndStatement | NoteStatement | CommentStatement | GenericLineStatement | BlankLineStatement;
+/**
+ * Statement type discriminator.
+ */
+export type StatementType = Statement['type'];
+/**
+ * Parsed diagram AST.
+ */
+export interface Diagram {
+    type: DiagramType;
+    statements: Statement[];
+}
+export { INDENT_SENSITIVE_DIAGRAMS } from './rules.js';
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Type definitions for Mermaid formatter AST and options.
+ */
+// Re-export from rules for backwards compatibility
+export { INDENT_SENSITIVE_DIAGRAMS } from './rules.js';
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "mermaid-formatter",
+  "version": "0.1.0",
+  "description": "A formatter for Mermaid diagram syntax",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "mmdfmt": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "npm run lint && npm run test && npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "mermaid",
+    "formatter",
+    "diagram",
+    "markdown",
+    "sequence-diagram",
+    "flowchart",
+    "ast"
+  ],
+  "author": "chenyanchen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chenyanchen/mermaid-formatter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/chenyanchen/mermaid-formatter/issues"
+  },
+  "homepage": "https://github.com/chenyanchen/mermaid-formatter#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "eslint": "^9.0.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^2.0.0"
+  }
+}