@readme/markdown 11.10.1 → 11.12.0

package/dist/main.node.js

@@ -90788,7 +90788,7 @@ const mdxToHast = () => tree => {
 ;// ./processor/transform/mdxish/mdxish-component-blocks.ts
 
 
-const tagPattern = /^<([A-Z][A-Za-z0-9]*)([^>]*?)(\/?)>([\s\S]*)?$/;
+const tagPattern = /^<([A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>([\s\S]*)?$/;
 const attributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>]+))?/g;
 const inlineMdProcessor = unified().use(remarkParse);
 const isClosingTag = (value, tag) => value.trim() === `</${tag}>`;
@@ -113185,82 +113185,7 @@ const mdxComponentHandlers = {
     [NodeTypes.htmlBlock]: htmlBlockHandler,
 };
 
-;// ./processor/transform/mdxish/evaluate-expressions.ts
-
-/**
- * AST transformer to evaluate MDX expressions using the provided context.
- * Replaces mdxFlowExpression and mdxTextExpression nodes with their evaluated values.
- */
-const evaluateExpressions = ({ context = {} } = {}) => tree => {
-    visit(tree, ['mdxFlowExpression', 'mdxTextExpression'], (node, index, parent) => {
-        if (!parent || index === null || index === undefined)
-            return;
-        const expressionNode = node;
-        if (!('value' in expressionNode))
-            return;
-        // JSX attribute expressions are handled by preprocessing; code blocks are protected
-        const expression = expressionNode.value.trim();
-        // Skip if expression is empty (shouldn't happen, but defensive)
-        if (!expression)
-            return;
-        try {
-            // Evaluate the expression using the context
-            const contextKeys = Object.keys(context);
-            const contextValues = Object.values(context);
-            // If no context provided, leave expression as-is
-            if (contextKeys.length === 0) {
-                parent.children.splice(index, 1, {
-                    type: 'text',
-                    value: `{${expression}}`,
-                    position: node.position,
-                });
-                return;
-            }
-            // eslint-disable-next-line no-new-func
-            const func = new Function(...contextKeys, `return ${expression}`);
-            const result = func(...contextValues);
-            // Convert result to text node(s)
-            if (result === null || result === undefined) {
-                // Replace with empty text node (don't remove, as it affects positioning)
-                parent.children.splice(index, 1, {
-                    type: 'text',
-                    value: '',
-                    position: node.position,
-                });
-                return;
-            }
-            let textValue;
-            if (typeof result === 'object') {
-                textValue = JSON.stringify(result);
-            }
-            else {
-                textValue = String(result).replace(/\s+/g, ' ').trim();
-            }
-            // Replace expression node with text node
-            parent.children.splice(index, 1, {
-                type: 'text',
-                value: textValue,
-                position: node.position,
-            });
-        }
-        catch (_error) {
-            // If evaluation fails, leave the expression as-is (fallback to text)
-            parent.children.splice(index, 1, {
-                type: 'text',
-                value: `{${expression}}`,
-                position: node.position,
-            });
-        }
-    });
-    return tree;
-};
-/* harmony default export */ const evaluate_expressions = (evaluateExpressions);
-
 ;// ./processor/transform/mdxish/preprocess-jsx-expressions.ts
-/**
- * Pre-processes JSX-like expressions before markdown parsing.
- * Converts href={'value'} to href="value", evaluates {expressions}, etc.
- */
 // Base64 encode (Node.js + browser compatible)
 function base64Encode(str) {
     if (typeof Buffer !== 'undefined') {
@@ -113516,6 +113441,57 @@ function preprocessJSXExpressions(content, context = {}) {
     return processed;
 }
 
+;// ./processor/transform/mdxish/evaluate-expressions.ts
+
+
+/**
+ * AST transformer to evaluate MDX expressions using the provided context.
+ * Replaces mdxFlowExpression and mdxTextExpression nodes with their evaluated values.
+ */
+const evaluateExpressions = ({ context = {} } = {}) => tree => {
+    visit(tree, ['mdxFlowExpression', 'mdxTextExpression'], (node, index, parent) => {
+        if (!parent || index === null || index === undefined)
+            return;
+        const expressionNode = node;
+        if (!('value' in expressionNode))
+            return;
+        const expression = expressionNode.value.trim();
+        // Skip if expression is empty (shouldn't happen, but defensive)
+        if (!expression)
+            return;
+        try {
+            const result = evaluateExpression(expression, context);
+            // Extract evaluated value text
+            let textValue;
+            if (result === null || result === undefined) {
+                textValue = '';
+            }
+            else if (typeof result === 'object') {
+                textValue = JSON.stringify(result);
+            }
+            else {
+                textValue = String(result).replace(/\s+/g, ' ').trim();
+            }
+            // Replace expression node with text node since the expression is conceptually a text
+            parent.children.splice(index, 1, {
+                type: 'text',
+                value: textValue,
+                position: node.position,
+            });
+        }
+        catch (_error) {
+            // If evaluation fails, leave the expression as-is (fallback to text)
+            parent.children.splice(index, 1, {
+                type: 'text',
+                value: `{${expression}}`,
+                position: node.position,
+            });
+        }
+    });
+    return tree;
+};
+/* harmony default export */ const evaluate_expressions = (evaluateExpressions);
+
 ;// ./processor/transform/mdxish/mdxish-html-blocks.ts
 
 
@@ -113856,6 +113832,7 @@ const mdxishHtmlBlocks = () => tree => {
 
 
 
+
 /**
  * Matches legacy magic block syntax: [block:TYPE]...JSON...[/block]
  * Group 1: block type (e.g., "image", "code", "callout")
@@ -113903,6 +113880,10 @@ const parseInline = (text) => {
     if (!text.trim())
         return [{ type: 'text', value: '' }];
     const tree = cellParser.runSync(cellParser.parse(text));
+    // If there are multiple block-level nodes, keep them as-is to preserve the document structure and spacing
+    if (tree.children.length > 1) {
+        return tree.children;
+    }
     return tree.children.flatMap(n => 
     // This unwraps the extra p node that might appear & wrapping the content
     n.type === 'paragraph' && 'children' in n ? n.children : [n]);
@@ -114024,16 +114005,34 @@ function parseMagicBlock(raw, options = {}) {
             const [icon, theme] = Array.isArray(resolvedType) ? resolvedType : ['👍', 'default'];
             if (!(calloutJson.title || calloutJson.body))
                 return [];
-            return [
-                wrapPinnedBlocks({
-                    children: [...textToBlock(calloutJson.title || ''), ...textToBlock(calloutJson.body || '')],
-                    data: {
-                        hName: 'rdme-callout',
-                        hProperties: { icon, theme: theme || 'default', title: calloutJson.title, value: calloutJson.body },
-                    },
-                    type: 'rdme-callout',
-                }, json),
-            ];
+            const titleBlocks = textToBlock(calloutJson.title || '');
+            const bodyBlocks = textToBlock(calloutJson.body || '');
+            const children = [];
+            if (titleBlocks.length > 0 && titleBlocks[0].type === 'paragraph') {
+                const firstTitle = titleBlocks[0];
+                const heading = {
+                    type: 'heading',
+                    depth: 3,
+                    children: (firstTitle.children || []),
+                };
+                children.push(heading);
+                children.push(...titleBlocks.slice(1), ...bodyBlocks);
+            }
+            else {
+                children.push(...titleBlocks, ...bodyBlocks);
+            }
+            // Create mdxJsxFlowElement directly for mdxish
+            const calloutElement = {
+                type: 'mdxJsxFlowElement',
+                name: 'Callout',
+                attributes: toAttributes({ icon, theme: theme || 'default', type: theme || 'default' }, [
+                    'icon',
+                    'theme',
+                    'type',
+                ]),
+                children: children,
+            };
+            return [wrapPinnedBlocks(calloutElement, json)];
         }
         // Parameters: renders as a table (used for API parameters, etc.)
         case 'parameters': {
@@ -114107,6 +114106,25 @@ function parseMagicBlock(raw, options = {}) {
                 }, json),
             ];
         }
+        // Recipe/TutorialTile: renders as Recipe component
+        case 'recipe':
+        case 'tutorial-tile': {
+            const recipeJson = json;
+            if (!recipeJson.slug || !recipeJson.title)
+                return [];
+            // Create mdxJsxFlowElement directly for mdxish flow
+            // Note: Don't wrap in pinned blocks for mdxish - rehypeMdxishComponents handles component resolution
+            // The node structure matches what mdxishComponentBlocks creates for JSX tags
+            const recipeNode = {
+                type: 'mdxJsxFlowElement',
+                name: 'Recipe',
+                attributes: toAttributes(recipeJson, ['slug', 'title']),
+                children: [],
+                // Position is optional but helps with debugging
+                position: undefined,
+            };
+            return [recipeNode];
+        }
         // Unknown block types: render as generic div with JSON properties
         default: {
             const text = json.text || json.html || '';
@@ -114116,6 +114134,12 @@ function parseMagicBlock(raw, options = {}) {
         }
     }
 }
+/**
+ * Check if a child node is a flow element that needs unwrapping (mdxJsxFlowElement, etc.)
+ */
+const needsUnwrapping = (child) => {
+    return child.type === 'mdxJsxFlowElement';
+};
 /**
  * Unified plugin that restores magic blocks from placeholder tokens.
  *
@@ -114129,21 +114153,271 @@ const magicBlockRestorer = ({ blocks }) => tree => {
     // Map: key → original raw magic block content
     const magicBlockKeys = new Map(blocks.map(({ key, raw }) => [key, raw]));
     // Find inlineCode nodes that match our placeholder tokens
+    const modifications = [];
     visit(tree, 'inlineCode', (node, index, parent) => {
         if (!parent || index == null)
-            return;
+            return undefined;
         const raw = magicBlockKeys.get(node.value);
         if (!raw)
-            return;
-        // Parse the original magic block and replace the placeholder with the result
+            return undefined;
         const children = parseMagicBlock(raw);
         if (!children.length)
-            return;
+            return undefined;
+        if (children[0] && needsUnwrapping(children[0]) && parent.type === 'paragraph') {
+            // Find paragraph's parent and unwrap
+            let paragraphParent;
+            visit(tree, 'paragraph', (p, pIndex, pParent) => {
+                if (p === parent && pParent && 'children' in pParent) {
+                    paragraphParent = pParent;
+                    return false;
+                }
+                return undefined;
+            });
+            if (paragraphParent) {
+                const paragraphIndex = paragraphParent.children.indexOf(parent);
+                if (paragraphIndex !== -1) {
+                    modifications.push({ children, index: paragraphIndex, parent: paragraphParent });
+                }
+            }
+            return SKIP;
+        }
+        parent.children.splice(index, 1, ...children);
+        return [SKIP, index + children.length];
+    });
+    // Apply modifications in reverse order to avoid index shifting
+    modifications.reverse().forEach(({ children, index, parent }) => {
         parent.children.splice(index, 1, ...children);
     });
 };
 /* harmony default export */ const mdxish_magic_blocks = (magicBlockRestorer);
 
+;// ./lib/constants.ts
+/**
+ * Pattern to match component tags (PascalCase or snake_case)
+ */
+const componentTagPattern = /<(\/?[A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>/g;
+
+;// ./processor/transform/mdxish/mdxish-snake-case-components.ts
+
+/**
+ * Replaces snake_case component names with valid HTML placeholders.
+ * Required because remark-parse rejects tags with underscores.
+ * Example: `<Snake_case />` → `<MDXishSnakeCase0 />`
+ */
+function processSnakeCaseComponent(content) {
+    // Early exit if no potential snake_case components
+    if (!/[A-Z][A-Za-z0-9]*_[A-Za-z0-9_]*/.test(content)) {
+        return { content, mapping: {} };
+    }
+    const mapping = {};
+    const reverseMap = new Map();
+    let counter = 0;
+    const processedContent = content.replace(componentTagPattern, (match, tagName, attrs, selfClosing) => {
+        if (!tagName.includes('_')) {
+            return match;
+        }
+        const isClosing = tagName.startsWith('/');
+        const cleanTagName = isClosing ? tagName.slice(1) : tagName;
+        let placeholder = reverseMap.get(cleanTagName);
+        if (!placeholder) {
+            // eslint-disable-next-line no-plusplus
+            placeholder = `MDXishSnakeCase${counter++}`;
+            mapping[placeholder] = cleanTagName;
+            reverseMap.set(cleanTagName, placeholder);
+        }
+        const processedTagName = isClosing ? `/${placeholder}` : placeholder;
+        return `<${processedTagName}${attrs}${selfClosing}>`;
+    });
+    return {
+        content: processedContent,
+        mapping,
+    };
+}
+/**
+ * Restores placeholder name to original snake_case name.
+ * Uses case-insensitive matching since HTML parsers normalize to lowercase.
+ */
+function restoreSnakeCase(placeholderName, mapping) {
+    if (mapping[placeholderName]) {
+        return mapping[placeholderName];
+    }
+    const lowerName = placeholderName.toLowerCase();
+    const matchingKey = Object.keys(mapping).find(key => key.toLowerCase() === lowerName);
+    return matchingKey ? mapping[matchingKey] : placeholderName;
+}
+
+;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
+
+// Patterns to detect for bold (** and __) and italic (* and _) syntax:
+// Bold: ** text**, **text **, word** text**, ** text **
+// Italic: * text*, *text *, word* text*, * text *
+// Same patterns for underscore variants
+// We use separate patterns for each marker type to allow this flexibility.
+// Pattern for ** bold **
+// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
+// trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
+const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
+// Pattern for __ bold __
+const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:[^_\n]|_(?!_))+?)(\s*)\2|((?:[^_\n]|_(?!_))+?)(\s+)\2)(\S|$)?/g;
+// Pattern for * italic *
+const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
+// Pattern for _ italic _
+const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+([^_\n]+?)(\s*)\2|([^_\n]+?)(\s+)\2)(\S|$)?/g;
+/**
+ * A remark plugin that normalizes malformed bold and italic markers in text nodes.
+ * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
+ * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
+ * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
+ *
+ * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
+ * Also supports snake_case content like `** some_snake_case**`.
+ *
+ * This runs after remark-parse, which (in v11+) is strict and doesn't parse
+ * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
+ */
+const normalizeEmphasisAST = () => (tree) => {
+    visit(tree, 'text', function visitor(node, index, parent) {
+        if (index === undefined || !parent)
+            return undefined;
+        // Skip if inside code blocks or inline code
+        if (parent.type === 'inlineCode' || parent.type === 'code') {
+            return undefined;
+        }
+        const text = node.value;
+        const allMatches = [];
+        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '**', match });
+        });
+        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '__', match });
+        });
+        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '*', match });
+        });
+        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '_', match });
+        });
+        if (allMatches.length === 0)
+            return undefined;
+        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
+        const filteredMatches = [];
+        let lastEnd = 0;
+        allMatches.forEach(info => {
+            const start = info.match.index ?? 0;
+            const end = start + info.match[0].length;
+            if (start >= lastEnd) {
+                filteredMatches.push(info);
+                lastEnd = end;
+            }
+        });
+        if (filteredMatches.length === 0)
+            return undefined;
+        const parts = [];
+        let lastIndex = 0;
+        filteredMatches.forEach(({ match, marker, isBold }) => {
+            const matchIndex = match.index ?? 0;
+            const fullMatch = match[0];
+            if (matchIndex > lastIndex) {
+                const beforeText = text.slice(lastIndex, matchIndex);
+                if (beforeText) {
+                    parts.push({ type: 'text', value: beforeText });
+                }
+            }
+            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
+            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
+            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
+            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
+            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
+            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
+            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
+            const afterChar = match[7]; // Character after closing markers (if any)
+            const markerPos = fullMatch.indexOf(marker);
+            const spacesBeforeMarkers = wordBefore
+                ? fullMatch.slice(wordBefore.length, markerPos)
+                : fullMatch.slice(0, markerPos);
+            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
+            if (wordBefore) {
+                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
+                parts.push({ type: 'text', value: wordBefore + spacing });
+            }
+            else if (spacesBeforeMarkers) {
+                parts.push({ type: 'text', value: spacesBeforeMarkers });
+            }
+            if (content) {
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+            }
+            if (afterChar) {
+                const prefix = trailingSpace ? ' ' : '';
+                parts.push({ type: 'text', value: prefix + afterChar });
+            }
+            lastIndex = matchIndex + fullMatch.length;
+        });
+        if (lastIndex < text.length) {
+            const remainingText = text.slice(lastIndex);
+            if (remainingText) {
+                parts.push({ type: 'text', value: remainingText });
+            }
+        }
+        if (parts.length > 0) {
+            parent.children.splice(index, 1, ...parts);
+            return [SKIP, index + parts.length];
+        }
+        return undefined;
+    });
+    return tree;
+};
+/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
+
+;// ./processor/transform/mdxish/restore-snake-case-component-name.ts
+
+
+/**
+ * Restores snake_case component names from placeholders after parsing.
+ * Runs after mdxishComponentBlocks converts HTML nodes to mdxJsxFlowElement.
+ */
+const restoreSnakeCaseComponentNames = (options) => {
+    const { mapping } = options;
+    return tree => {
+        if (!mapping || Object.keys(mapping).length === 0) {
+            return tree;
+        }
+        visit(tree, 'mdxJsxFlowElement', (node) => {
+            if (node.name) {
+                node.name = restoreSnakeCase(node.name, mapping);
+            }
+        });
+        // Pre-compile regex patterns for better performance
+        const regexPatterns = Object.entries(mapping).map(([placeholder, original]) => ({
+            regex: new RegExp(`(<\\/?)(${placeholder})(\\s|\\/?>)`, 'gi'),
+            original,
+        }));
+        visit(tree, 'html', (node) => {
+            if (node.value) {
+                let newValue = node.value;
+                regexPatterns.forEach(({ regex, original }) => {
+                    newValue = newValue.replace(regex, `$1${original}$3`);
+                });
+                if (newValue !== node.value) {
+                    node.value = newValue;
+                }
+            }
+        });
+        return tree;
+    };
+};
+/* harmony default export */ const restore_snake_case_component_name = (restoreSnakeCaseComponentNames);
+
 ;// ./processor/transform/mdxish/variables-text.ts
 
 
@@ -114229,14 +114503,17 @@ function extractMagicBlocks(markdown) {
     const replaced = markdown.replace(MAGIC_BLOCK_REGEX, match => {
         /**
          * Key is the unique identifier for the magic block
-         * Token is a wrapper around the key to serialize & influences how the block is parsed in the pipeline
-         * with the temporary key
-         * - Use backticks so it becomes a code span, preventing remarkParse from parsing
-         *   special characters in the token as markdown syntax
-         * - Prepend a newline to the token to ensure it is parsed as a block level node
          */
         const key = `__MAGIC_BLOCK_${index}__`;
-        const token = `\n\`${key}\``;
+        /**
+         * Token is a wrapper around the `key` to serialize & influence how the
+         * magic block is parsed in the remark pipeline.
+         * - Use backticks so it becomes a code span, preventing `remarkParse` from
+         *   parsing special characters in the token as markdown syntax
+         * - Prepend a newline to ensure it is parsed as a block level node
+         * - Append a newline to ensure it is separated from following content
+         */
+        const token = `\n\`${key}\`\n`;
         blocks.push({ key, raw: match, token });
         index += 1;
         return token;
@@ -114247,17 +114524,16 @@ function extractMagicBlocks(markdown) {
  * Restore extracted magic blocks back into a markdown string.
  */
 function restoreMagicBlocks(replaced, blocks) {
-    let content = replaced;
-    // If a magic block is at the start of the document, the extraction token's prepended 
-    // newline will have been trimmed during processing. We need to account for that here
-    // to ensure the token is found and replaced correctly.
-    const isTokenAtStart = content.startsWith(blocks[0]?.token.trimStart());
-    if (isTokenAtStart) {
-        content = `\n${content}`;
-    }
-    return blocks.reduce((acc, { token, raw }) => {
-        return acc.split(token).join(raw);
+    // If a magic block is at the start or end of the document, the extraction
+    // token's newlines will have been trimmed during processing. We need to
+    // account for that here to ensure the token is found and replaced correctly.
+    // These extra newlines will be removed again when the final string is trimmed.
+    const content = `\n${replaced}\n`;
+    const restoredContent = blocks.reduce((acc, { token, raw }) => {
+        // Ensure each magic block is separated by newlines when restored.
+        return acc.split(token).join(`\n${raw}\n`);
     }, content);
+    return restoredContent.trim();
 }
 
 ;// ./lib/utils/mdxish/mdxish-load-components.ts
@@ -114316,6 +114592,9 @@ function loadComponents() {
 
 
 
+
+
+
 
 
 
@@ -114333,10 +114612,15 @@ function mdxish(mdContent, opts = {}) {
         ...loadComponents(),
         ...userComponents,
     };
-    // Preprocess content: extract legacy magic blocks and evaluate JSX attribute expressions
-    const { replaced, blocks } = extractMagicBlocks(mdContent);
-    const processedContent = preprocessJSXExpressions(replaced, jsxContext);
-    // Create string map of components for tailwind transformer
+    // Preprocessing pipeline: Transform content to be parser-ready
+    // Step 1: Extract legacy magic blocks
+    const { replaced: contentAfterMagicBlocks, blocks } = extractMagicBlocks(mdContent);
+    // Step 2: Evaluate JSX expressions in attributes
+    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterMagicBlocks, jsxContext);
+    // Step 3: Replace snake_case component names with parser-safe placeholders
+    // (e.g., <Snake_case /> → <MDXishSnakeCase0 /> which will be restored after parsing)
+    const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation);
+    // Create string map for tailwind transformer
     const tempComponentsMap = Object.entries(components).reduce((acc, [key, value]) => {
         acc[key] = String(value);
         return acc;
@@ -114346,10 +114630,12 @@ function mdxish(mdContent, opts = {}) {
         .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()])
         .use(remarkParse)
         .use(remarkFrontmatter)
+        .use(normalize_malformed_md_syntax)
         .use(mdxish_magic_blocks, { blocks })
         .use(transform_images, { isMdxish: true })
         .use(defaultTransformers)
         .use(mdxish_component_blocks)
+        .use(restore_snake_case_component_name, { mapping: snakeCaseMapping })
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
         .use(evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
@@ -114363,8 +114649,8 @@ function mdxish(mdContent, opts = {}) {
         components,
         processMarkdown: (markdown) => mdxish(markdown, opts),
     });
-    const vfile = new VFile({ value: processedContent });
-    const hast = processor.runSync(processor.parse(processedContent), vfile);
+    const vfile = new VFile({ value: parserReadyContent });
+    const hast = processor.runSync(processor.parse(parserReadyContent), vfile);
     if (!hast) {
         throw new Error('Markdown pipeline did not produce a HAST tree.');
     }
@@ -114801,8 +115087,7 @@ const tags = (doc) => {
 const mdxishTags_tags = (doc) => {
     const { replaced: sanitizedDoc } = extractMagicBlocks(doc);
     const set = new Set();
-    const processor = remark()
-        .use(mdxish_component_blocks);
+    const processor = remark().use(mdxish_component_blocks);
     const tree = processor.parse(sanitizedDoc);
     visit(processor.runSync(tree), isMDXElement, (node) => {
         if (node.name?.match(/^[A-Z]/)) {
@@ -114888,7 +115173,7 @@ async function stripComments(doc, { mdx } = {}) {
                 // Our markdown renderer uses this to group these code blocks into a tabbed interface.
                 (left, right) => {
                     // 0 = no newline between blocks
-                    return (left.type === 'code' && right.type === 'code') ? 0 : undefined;
+                    return left.type === 'code' && right.type === 'code' ? 0 : undefined;
                 },
             ],
         });