@takazudo/mdx-formatter 0.1.0

package/dist/plugins/fix-formatting-issues.js

@@ -0,0 +1,42 @@
+/**
+ * Post-processing fixes for common formatting issues
+ */
+export function fixFormattingIssues(content) {
+    let fixed = content;
+    // Fix 1: Restore spaces between bold elements and operators
+    // When bold text is followed by operators like +, =, etc., ensure there's a space
+    // This must be done BEFORE fixing the internal spaces to preserve the pattern
+    // Use negative lookahead to avoid matching operators that already have a space
+    fixed = fixed.replace(/(\*\*[^*]+\*\*)([+\-=])/g, '$1 $2');
+    // Fix 2: Restore spaces before bold elements after operators
+    // Ensure there's a space after operators before bold text
+    fixed = fixed.replace(/([+\-=])(\*\*[^*]+\*\*)/g, '$1 $2');
+    // Fix 3: Restore spaces between word characters and bold elements
+    fixed = fixed.replace(/([a-zA-Z])\s*(\*\*[^*]+\*\*)/g, '$1 $2');
+    // Fix 4: Remove extra spaces inside bold asterisks (do this LAST)
+    // Sometimes remark adds a space before the closing ** for short words
+    // Pattern: **word ** -> **word**
+    fixed = fixed.replace(/\*\*([^*]+)\s+\*\*/g, '**$1**');
+    // Fix 5: Remove extra trailing spaces inside HTML tags (2+ spaces only)
+    // Pattern: <tag>content  </tag> -> <tag>content </tag> (preserves single space)
+    fixed = fixed.replace(/(<[^/>]+>)([^<]*)\s{2,}(<\/[^>]+>)/g, '$1$2 $3');
+    // Fix 6: Collapse multiple spaces before self-closing HTML tags to single space
+    // Pattern: text  <br/> -> text <br/> (preserves meaningful single space)
+    fixed = fixed.replace(/\s{2,}(<[^>]+\/>)/g, ' $1');
+    // Fix 7: Fix HTML entity encoding for Japanese characters
+    // Specifically fix the common case of を being encoded as &#x3092;
+    fixed = fixed.replace(/&#x3092;/g, 'を');
+    // Fix other common Japanese character encodings if they appear
+    fixed = fixed.replace(/&#x([0-9a-fA-F]{4});/g, (match, hex) => {
+        const code = parseInt(hex, 16);
+        // Only decode Japanese characters (Hiragana, Katakana, Kanji ranges)
+        if ((code >= 0x3040 && code <= 0x309f) || // Hiragana
+            (code >= 0x30a0 && code <= 0x30ff) || // Katakana
+            (code >= 0x4e00 && code <= 0x9faf)) {
+            // CJK Unified Ideographs
+            return String.fromCharCode(code);
+        }
+        return match;
+    });
+    return fixed;
+}

package/dist/plugins/fix-paragraph-spacing.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Plugin to fix paragraph and JSX spacing issues
+ * This runs as a post-processing step after stringify
+ */
+export declare function fixParagraphSpacing(content: string): string;

package/dist/plugins/fix-paragraph-spacing.js

@@ -0,0 +1,96 @@
+/**
+ * Plugin to fix paragraph and JSX spacing issues
+ * This runs as a post-processing step after stringify
+ */
+export function fixParagraphSpacing(content) {
+    let fixed = content;
+    // Fix 0: Split collapsed JSX components (most critical fix)
+    // Pattern: /><Component should be />\n\n<Component
+    // Use a loop to handle all occurrences (in case of multiple collapsed components)
+    let previousFixed = '';
+    while (previousFixed !== fixed) {
+        previousFixed = fixed;
+        fixed = fixed.replace(/(\/>)(<[A-Z][^>]*>)/g, '$1\n\n$2');
+    }
+    // Fix 1: Ensure blank lines between paragraphs
+    // Split content by lines and process
+    const lines = fixed.split('\n');
+    const processedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const nextLine = lines[i + 1];
+        processedLines.push(line);
+        // Check if we need to add a blank line
+        if (line && nextLine && i < lines.length - 1) {
+            const currentEndsWithText = /[。！？\.!?）\]】a-zA-Z0-9]$/.test(line.trim());
+            const nextStartsWithJSX = /^<[A-Z]/.test(nextLine.trim());
+            // Add blank line between text and JSX components
+            if (currentEndsWithText && nextStartsWithJSX) {
+                processedLines.push('');
+            }
+            // Add blank line between heading and content
+            else if (/^#{1,6} /.test(line.trim()) && nextLine.trim() && !lines[i - 1]?.trim()) {
+                processedLines.push('');
+            }
+            // Add blank line between import/export and other content
+            else if ((line.trim().startsWith('import ') || line.trim().startsWith('export ')) &&
+                nextLine.trim() &&
+                !nextLine.trim().startsWith('import ') &&
+                !nextLine.trim().startsWith('export ')) {
+                processedLines.push('');
+            }
+        }
+    }
+    fixed = processedLines.join('\n');
+    // Fix 2: Ensure JSX components are not merged with text on same line
+    // Pattern: text<Component should be text\n\n<Component
+    fixed = fixed.replace(/([。！？\.!?）\]】a-zA-Z0-9])(<[A-Z][^>]*>)/g, '$1\n\n$2');
+    // Fix 3: Ensure import statements are not merged with JSX
+    fixed = fixed.replace(/(import [^;]+;)(<[A-Z])/g, '$1\n\n$2');
+    // Fix 4: Ensure headings are not merged with content
+    fixed = fixed.replace(/(^#{1,6} [^\n]+)(<[A-Z])/gm, '$1\n\n$2');
+    // Fix 5: Split merged paragraphs (Japanese text specific)
+    // Pattern: 。text should be 。\ntext when it's a new sentence
+    fixed = fixed.replace(/([。！？])([ぁ-んァ-ヶー一-龠]+)/g, (match, punct, text) => {
+        // Check if the text after punctuation looks like a new sentence
+        // (starts with a capital-like character or common sentence starters)
+        if (/^[こそたなはまやらわがざだばぱ]/.test(text)) {
+            return `${punct}\n${text}`;
+        }
+        return match;
+    });
+    // Fix 6: Preserve space after question mark in Japanese
+    fixed = fixed.replace(/([？！])([^ \n])/g, '$1 $2');
+    // Fix 7: Clean up excessive blank lines (more than 2 consecutive)
+    fixed = fixed.replace(/\n{4,}/g, '\n\n\n');
+    // Fix 8: Fix JSX indentation issues
+    // When we have closing tags that lost one space of indentation
+    fixed = fixed.replace(/\n( +)<\/([A-Z][^>]+)>/g, (match, spaces, tag) => {
+        // Check if the opening tag had more indentation
+        const openingPattern = new RegExp(`\\n(\\s+)<${tag}[^>]*>`, 'g');
+        const openingMatch = fixed.match(openingPattern);
+        if (openingMatch && openingMatch[0]) {
+            const openingSpacesMatch = openingMatch[0].match(/\n(\s+)</);
+            if (openingSpacesMatch) {
+                const openingSpaces = openingSpacesMatch[1];
+                if (openingSpaces.length === spaces.length + 1) {
+                    // The opening tag has one more space, so add it to closing tag
+                    return '\n' + spaces + ' </' + tag + '>';
+                }
+            }
+        }
+        return match;
+    });
+    // Fix 9: Fix Outro component spacing specifically
+    // Ensure content inside Outro has proper spacing
+    fixed = fixed.replace(/<Outro>([\s\S]*?)<\/Outro>/g, (match, content) => {
+        // Check if there's content
+        const trimmedContent = content.trim();
+        if (trimmedContent) {
+            // Ensure double newlines before and after content
+            return '<Outro>\n\n' + trimmedContent + '\n\n</Outro>';
+        }
+        return match;
+    });
+    return fixed;
+}

package/dist/plugins/html-definition-list.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'mdast';
+/**
+ * Plugin to convert HTML definition lists to markdown
+ */
+export declare function htmlDefinitionListPlugin(): (tree: Root) => void;

package/dist/plugins/html-definition-list.js

@@ -0,0 +1,64 @@
+import { visit } from 'unist-util-visit';
+/**
+ * Plugin to convert HTML definition lists to markdown
+ */
+export function htmlDefinitionListPlugin() {
+    return (tree) => {
+        // In MDX, raw HTML can appear as either 'html' or 'mdxFlowExpression' nodes
+        // We need to handle both cases
+        visit(tree, (node, index, parent) => {
+            if (node.type !== 'html' && node.type !== 'raw')
+                return;
+            const htmlNode = node;
+            const parentNode = parent;
+            // For 'raw' nodes (MDX), the content is in node.value
+            // For 'html' nodes (regular markdown), it's also in node.value
+            if (!htmlNode.value)
+                return;
+            // Check if this is a definition list
+            const dlMatch = htmlNode.value.match(/^<dl[^>]*>([\s\S]*?)<\/dl>$/);
+            if (!dlMatch)
+                return;
+            const content = dlMatch[1];
+            const items = [];
+            // Parse dt/dd pairs
+            const regex = /<dt[^>]*>([\s\S]*?)<\/dt>\s*<dd[^>]*>([\s\S]*?)<\/dd>/g;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const term = cleanHtml(match[1].trim());
+                const definition = cleanHtml(match[2].trim());
+                // Create markdown definition list nodes
+                items.push({
+                    type: 'paragraph',
+                    children: [
+                        {
+                            type: 'strong',
+                            children: [{ type: 'text', value: term }],
+                        },
+                    ],
+                });
+                items.push({
+                    type: 'paragraph',
+                    children: [{ type: 'text', value: ': ' + definition }],
+                });
+            }
+            // Replace the HTML node with markdown nodes
+            if (items.length > 0 && parentNode && typeof index === 'number') {
+                parentNode.children.splice(index, 1, ...items);
+            }
+        });
+    };
+}
+/**
+ * Clean HTML tags from text content
+ */
+function cleanHtml(html) {
+    return html
+        .replace(/<code[^>]*>(.*?)<\/code>/g, '`$1`')
+        .replace(/<strong[^>]*>(.*?)<\/strong>/g, '**$1**')
+        .replace(/<b[^>]*>(.*?)<\/b>/g, '**$1**')
+        .replace(/<em[^>]*>(.*?)<\/em>/g, '*$1*')
+        .replace(/<i[^>]*>(.*?)<\/i>/g, '*$1*')
+        .replace(/<[^>]+>/g, '')
+        .trim();
+}

package/dist/plugins/japanese-text.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'mdast';
+/**
+ * Plugin to handle Japanese text formatting rules
+ */
+export declare function japaneseTextPlugin(): (tree: Root) => void;

package/dist/plugins/japanese-text.js

@@ -0,0 +1,79 @@
+import { visit } from 'unist-util-visit';
+/**
+ * Plugin to handle Japanese text formatting rules
+ */
+export function japaneseTextPlugin() {
+    return (tree) => {
+        // Note: Japanese URLs are now pre-processed in the main format function
+        // to prevent GFM from incorrectly parsing them
+        // Clean up Japanese text
+        visit(tree, 'text', (node, index, parent) => {
+            const textNode = node;
+            const parentNode = parent;
+            if (!textNode.value)
+                return;
+            // Check if this text node is adjacent to inline code or strong/emphasis
+            // If so, preserve spaces around it
+            const isBeforeInlineCode = parentNode &&
+                parentNode.children &&
+                typeof index === 'number' &&
+                index < parentNode.children.length - 1 &&
+                parentNode.children[index + 1].type === 'inlineCode';
+            const isAfterInlineCode = parentNode &&
+                parentNode.children &&
+                typeof index === 'number' &&
+                index > 0 &&
+                parentNode.children[index - 1].type === 'inlineCode';
+            // Check if adjacent to strong or emphasis elements
+            const isBeforeStrong = parentNode &&
+                parentNode.children &&
+                typeof index === 'number' &&
+                index < parentNode.children.length - 1 &&
+                (parentNode.children[index + 1].type === 'strong' ||
+                    parentNode.children[index + 1].type === 'emphasis');
+            const isAfterStrong = parentNode &&
+                parentNode.children &&
+                typeof index === 'number' &&
+                index > 0 &&
+                (parentNode.children[index - 1].type === 'strong' ||
+                    parentNode.children[index - 1].type === 'emphasis');
+            // Preserve Japanese punctuation and spacing
+            // Don't add extra spaces around Japanese punctuation
+            textNode.value = textNode.value
+                .replace(/\s+([、。！？])/g, '$1') // Remove spaces before Japanese punctuation
+                .replace(/([、。！？])\s+/g, '$1'); // Remove spaces after Japanese punctuation
+            // Only trim trailing spaces if:
+            // 1. Not adjacent to code or strong/emphasis elements
+            // 2. The text node doesn't contain operators that need spacing
+            // This preserves spaces between bold elements like "**VCA** + **Envelope**"
+            const hasOperators = /[+\-=*/<>]/.test(textNode.value);
+            if (!isBeforeInlineCode &&
+                !isAfterInlineCode &&
+                !isBeforeStrong &&
+                !isAfterStrong &&
+                !hasOperators) {
+                // Only trim if the entire value is whitespace or ends with multiple spaces
+                if (textNode.value.trim() === '') {
+                    textNode.value = '';
+                }
+                else if (/\s{2,}$/.test(textNode.value)) {
+                    // Only trim if there are 2+ trailing spaces
+                    textNode.value = textNode.value.replace(/\s+$/g, ' ');
+                }
+            }
+        });
+        // Handle spacing around Japanese headings
+        visit(tree, 'heading', (node) => {
+            const heading = node;
+            if (heading.children && heading.children[0] && heading.children[0].type === 'text') {
+                const textChild = heading.children[0];
+                const text = textChild.value;
+                // Check if the heading contains Japanese characters
+                if (/[\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\uff00-\uffef\u4e00-\u9faf]/.test(text)) {
+                    // Ensure proper formatting for Japanese headings
+                    textChild.value = text.trim();
+                }
+            }
+        });
+    };
+}

package/dist/plugins/normalize-lists.d.ts

@@ -0,0 +1,5 @@
+import type { Root } from 'mdast';
+/**
+ * Plugin to normalize list markers and merge adjacent lists
+ */
+export declare function normalizeListsPlugin(): (tree: Root) => void;

package/dist/plugins/normalize-lists.js

@@ -0,0 +1,58 @@
+import { visit } from 'unist-util-visit';
+/**
+ * Plugin to normalize list markers and merge adjacent lists
+ */
+export function normalizeListsPlugin() {
+    return (tree) => {
+        // First, merge consecutive lists of the same type
+        visit(tree, (node) => {
+            const parent = node;
+            // Check if this node has children array
+            if (!parent.children || !Array.isArray(parent.children))
+                return;
+            const newChildren = [];
+            let i = 0;
+            while (i < parent.children.length) {
+                const child = parent.children[i];
+                // Check if this is a list and the next child is also a list of the same type
+                if (child.type === 'list' && i + 1 < parent.children.length) {
+                    const nextChild = parent.children[i + 1];
+                    if (nextChild.type === 'list' &&
+                        child.ordered === nextChild.ordered &&
+                        child.start === nextChild.start) {
+                        // Merge the lists
+                        child.children = [...child.children, ...nextChild.children];
+                        i++; // Skip the next child since we merged it
+                    }
+                }
+                newChildren.push(child);
+                i++;
+            }
+            parent.children = newChildren;
+        });
+        // Normalize all unordered list items to use - as marker
+        visit(tree, 'listItem', (node, _index, parent) => {
+            const listItem = node;
+            const parentList = parent;
+            if (parentList && parentList.ordered === false) {
+                // This is an unordered list item
+                // The marker is controlled by stringify options, but we ensure consistency
+                if (listItem.data) {
+                    delete listItem.data.marker; // Remove any specific marker data
+                }
+            }
+        });
+        // Ensure list structure is correct
+        visit(tree, 'list', (node) => {
+            const list = node;
+            // Ensure ordered property is set correctly
+            if (list.ordered === undefined) {
+                list.ordered = false; // Default to unordered
+            }
+            // Mark as tight list if items are not spread
+            if (list.children && list.children.every((item) => !item.spread)) {
+                list.spread = false;
+            }
+        });
+    };
+}

package/dist/plugins/preprocess-japanese.d.ts

@@ -0,0 +1,7 @@
+import type { Root } from 'mdast';
+import type { VFile } from 'vfile';
+/**
+ * Pre-processing plugin to normalize Japanese text before parsing
+ * This runs on the raw text before the markdown parser
+ */
+export declare function preprocessJapanesePlugin(): (_tree: Root, file: VFile) => void;

package/dist/plugins/preprocess-japanese.js

@@ -0,0 +1,15 @@
+/**
+ * Pre-processing plugin to normalize Japanese text before parsing
+ * This runs on the raw text before the markdown parser
+ */
+export function preprocessJapanesePlugin() {
+    return function (_tree, file) {
+        // Work on the raw content before parsing
+        const content = String(file);
+        // Convert Japanese parentheses with URLs to standard markdown links
+        const urlInParensPattern = /([^（）]+)（(https?:\/\/[^）]+)）/g;
+        const processed = content.replace(urlInParensPattern, '[$1]($2)');
+        // Update the file content
+        file.value = processed;
+    };
+}

package/dist/plugins/preserve-image-alt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Pre-process content to preserve image alt text from directive parsing
+ */
+export declare function protectImageAltText(content: string): string;
+/**
+ * Post-process content to restore image alt text
+ */
+export declare function restoreImageAltText(content: string): string;

package/dist/plugins/preserve-image-alt.js

@@ -0,0 +1,19 @@
+/**
+ * Pre-process content to preserve image alt text from directive parsing
+ */
+export function protectImageAltText(content) {
+    // Replace colons in image alt text with a placeholder that won't be parsed as a directive
+    // Match ![...] patterns and protect ALL colons within them
+    return content.replace(/!\[([^\]]*)\]/g, (_match, altText) => {
+        // Replace all colons in the alt text with a placeholder
+        const protectedAlt = altText.replace(/:/g, '___COLON___');
+        return `![${protectedAlt}]`;
+    });
+}
+/**
+ * Post-process content to restore image alt text
+ */
+export function restoreImageAltText(content) {
+    // Restore the colons in image alt text - handle both escaped and unescaped versions
+    return content.replace(/___COLON___/g, ':').replace(/\\_\\_\\_COLON\\_\\_\\_/g, ':'); // In case underscores got escaped
+}

package/dist/plugins/preserve-jsx.d.ts

@@ -0,0 +1,6 @@
+import type { Root } from 'mdast';
+import type { VFile } from 'vfile';
+/**
+ * Plugin to preserve JSX/MDX component formatting and indentation
+ */
+export declare function preserveJsxPlugin(): (tree: Root, file: VFile) => void;

package/dist/plugins/preserve-jsx.js

@@ -0,0 +1,48 @@
+import { visit } from 'unist-util-visit';
+/**
+ * Plugin to preserve JSX/MDX component formatting and indentation
+ */
+export function preserveJsxPlugin() {
+    return (tree, file) => {
+        const originalContent = String(file);
+        const lines = originalContent.split('\n');
+        visit(tree, ['mdxJsxFlowElement', 'mdxJsxTextElement'], (node) => {
+            const jsxNode = node;
+            // Store the original JSX content to preserve formatting
+            if (jsxNode.position && jsxNode.position.start && jsxNode.position.end) {
+                const startLine = jsxNode.position.start.line - 1;
+                const startCol = jsxNode.position.start.column - 1;
+                const endLine = jsxNode.position.end.line - 1;
+                const endCol = jsxNode.position.end.column;
+                // Extract the original JSX content preserving indentation
+                let originalJsx = '';
+                if (startLine === endLine) {
+                    // Single line JSX
+                    originalJsx = lines[startLine].substring(startCol, endCol);
+                }
+                else {
+                    // Multi-line JSX - preserve exact formatting
+                    for (let i = startLine; i <= endLine; i++) {
+                        if (i === startLine) {
+                            originalJsx += lines[i].substring(startCol);
+                        }
+                        else if (i === endLine) {
+                            originalJsx += '\n' + lines[i].substring(0, endCol);
+                        }
+                        else {
+                            originalJsx += '\n' + lines[i];
+                        }
+                    }
+                }
+                // Store the original content in node data
+                jsxNode.data = jsxNode.data || {};
+                jsxNode.data.originalJsx = originalJsx;
+                jsxNode.data.preserveOriginal = true;
+            }
+            // Handle self-closing tags
+            if (!jsxNode.children || jsxNode.children.length === 0) {
+                jsxNode.selfClosing = true;
+            }
+        });
+    };
+}

package/dist/settings.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Markdown Formatter Settings - 7 Core Rules
+ * Each option can be toggled on/off independently
+ */
+import type { FormatterSettings } from './types.js';
+export declare const formatterSettings: FormatterSettings;
+export declare function getEnabledRules(): Partial<FormatterSettings>;

package/dist/settings.js

@@ -0,0 +1,91 @@
+/**
+ * Markdown Formatter Settings - 7 Core Rules
+ * Each option can be toggled on/off independently
+ */
+export const formatterSettings = {
+    // Rule 1: Add 1 empty line between markdown elements (headings, paragraphs, lists)
+    addEmptyLineBetweenElements: {
+        enabled: true,
+        description: 'Add single empty line between markdown elements',
+    },
+    // Rule 2: Format multi-line JSX/HTML components with proper indentation
+    formatMultiLineJsx: {
+        enabled: true,
+        description: 'Format JSX/HTML with proper indentation',
+        indentSize: 2,
+        // Components to ignore (preserve their formatting completely)
+        ignoreComponents: [],
+    },
+    // Rule 3: Format all HTML blocks within MDX using Prettier
+    formatHtmlBlocksInMdx: {
+        enabled: true,
+        description: 'Format all HTML blocks within MDX using Prettier',
+        formatterConfig: {
+            parser: 'html',
+            tabWidth: 2,
+            useTabs: false,
+        },
+    },
+    // Rule 4: Convert single-line JSX with multiple props to multi-line format
+    expandSingleLineJsx: {
+        enabled: false, // disabled until inline JSX content-loss bug is fixed
+        description: 'Expand single-line JSX components with multiple props to multi-line',
+        propsThreshold: 2, // Expand if this many props or more
+        // Also respects ignoreComponents from formatMultiLineJsx
+    },
+    // Rule 5: Indent content inside JSX container components (DISABLED)
+    // Disabled: We prefer flat formatting for simplicity in MDX files
+    indentJsxContent: {
+        enabled: false,
+        description: 'Add indentation to content inside JSX components like <Outro>',
+        indentSize: 2,
+        // Components that should have their content indented
+        containerComponents: [],
+    },
+    // Rule 6: Add empty lines inside block JSX components
+    // Adds empty lines after opening tag and before closing tag for better readability
+    addEmptyLinesInBlockJsx: {
+        enabled: true,
+        description: 'Add empty lines after opening and before closing tags in block JSX components',
+        // Components that should have empty lines added
+        blockComponents: [],
+    },
+    // Rule 7: Format YAML frontmatter
+    formatYamlFrontmatter: {
+        enabled: true,
+        description: 'Format YAML frontmatter using proper YAML formatting rules',
+        // YAML formatting options
+        indent: 2, // Number of spaces for indentation
+        lineWidth: 100, // Maximum line width for folded strings
+        quotingType: '"', // Quote type for strings that need quoting: '"' or "'"
+        forceQuotes: false, // Force quotes on all string values
+        noCompatMode: true, // Use YAML 1.2 spec (not 1.1)
+    },
+    // Rule 8: Preserve Docusaurus admonitions
+    preserveAdmonitions: {
+        enabled: true,
+        description: 'Keep Docusaurus admonitions (:::note, :::tip, etc.) intact',
+    },
+    // Rule 9: Error handling behavior
+    errorHandling: {
+        throwOnError: false, // Don't throw error, return original content with warning
+        description: 'How to handle parsing errors - return original or throw',
+    },
+    // Rule 10: Auto-detect indentation from file content
+    autoDetectIndent: {
+        enabled: false,
+        description: 'Automatically detect indentation style from file content',
+        fallbackIndentSize: 2, // Default indent size if detection fails
+        fallbackIndentType: 'space', // Default indent type ('space' or 'tab')
+        minConfidence: 0.7, // Minimum confidence score to use detected indentation
+    },
+};
+// Export function to get only enabled rules
+export function getEnabledRules() {
+    return Object.entries(formatterSettings)
+        .filter(([_, config]) => config.enabled)
+        .reduce((acc, [key, config]) => {
+        acc[key] = config;
+        return acc;
+    }, {});
+}

package/dist/specific-formatter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * SpecificFormatter - Applies only specific formatting rules to MDX content
+ * Does NOT reformat everything, only applies targeted fixes
+ */
+import type { FormatterSettings } from './types.js';
+export declare class SpecificFormatter {
+    private content;
+    private lines;
+    settings: FormatterSettings;
+    constructor(content: string, settings?: FormatterSettings | null);
+    format(): Promise<string>;
+    /**
+     * Rule 1: Add 1 empty line between elements
+     */
+    addEmptyLineBetweenElements(content: string): string;
+    shouldAddEmptyLine(currentLine: string, nextLine: string): boolean;
+    /**
+     * Combined JSX formatting - handles structure and content indentation together
+     */
+    formatJsxStructure(content: string): string;
+    /**
+     * Rule 4: Expand single-line JSX with 2+ props
+     */
+    expandSingleLineJsx(content: string): string;
+    parseJsxProps(propsString: string): string[];
+    /**
+     * Rule 7: Validate MDX and throw errors on invalid content
+     */
+    validateMdx(content: string): boolean;
+}