@readme/markdown 13.1.1 → 13.1.3

package/dist/main.js

@@ -13007,8 +13007,7 @@ function color(d) {
 
 ;// ./node_modules/unist-util-visit-parents/lib/index.js
 /**
- * @typedef {import('unist').Node} UnistNode
- * @typedef {import('unist').Parent} UnistParent
+ * @import {Node as UnistNode, Parent as UnistParent} from 'unist'
  */
 
 /**
@@ -13056,8 +13055,10 @@ function color(d) {
 
 /**
  * @typedef {(
- *   Check extends Array<any>
- *   ? MatchesOne<Value, Check[keyof Check]>
+ *   Check extends ReadonlyArray<infer T>
+ *   ? MatchesOne<Value, T>
+ *   : Check extends Array<infer T>
+ *   ? MatchesOne<Value, T>
  *   : MatchesOne<Value, Check>
  * )} Matches
  *   Check whether a node matches a check in the type system.
@@ -13327,9 +13328,9 @@ function visitParents(tree, test, visitor, reverse) {
         typeof value.tagName === 'string'
           ? value.tagName
           : // `xast`
-          typeof value.name === 'string'
-          ? value.name
-          : undefined
+            typeof value.name === 'string'
+            ? value.name
+            : undefined
 
       Object.defineProperty(visit, 'name', {
         value:
@@ -71359,6 +71360,10 @@ const types = {
     Recipe: NodeTypes.recipe,
     TutorialTile: NodeTypes.recipe, // coerce to recipe for backwards compatibility
 };
+// Node types that are phrasing (inline) content per the mdast spec. Phrasing
+// content at the document root violates the spec and causes mdx() to collapse
+// blank lines, so these must be wrapped in a paragraph when at root level.
+const phrasingTypes = new Set([NodeTypes.variable]);
 var TableNames;
 (function (TableNames) {
     TableNames["td"] = "td";
@@ -71514,6 +71519,28 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             type: types[node.name],
             position: node.position,
         };
+        // Wrap in a paragraph if at root level. Links are phrasing content and
+        // root children must all be the same category (per mdast spec). Mixing
+        // phrasing with flow content (headings, paragraphs, etc.) causes mdx()
+        // to collapse blank lines in the document.
+        if (parent.type === 'root') {
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
+    }
+    else if (node.name === 'Recipe' || node.name === 'TutorialTile') {
+        const hProperties = getAttrs(node);
+        const mdNode = {
+            ...hProperties,
+            type: types[node.name],
+            data: {
+                hName: node.name,
+                ...(Object.keys(hProperties).length && { hProperties }),
+            },
+            position: node.position,
+        };
         parent.children[index] = mdNode;
     }
     else if (node.name in types) {
@@ -71527,7 +71554,13 @@ const coerceJsxToMd = ({ components = {}, html = false } = {}) => (node, index,
             },
             position: node.position,
         };
-        parent.children[index] = mdNode;
+        if (parent.type === 'root' && phrasingTypes.has(types[node.name])) {
+            // @ts-expect-error mdNode is typed as BlockContent but is actually phrasing content
+            parent.children[index] = { type: 'paragraph', children: [mdNode], position: node.position };
+        }
+        else {
+            parent.children[index] = mdNode;
+        }
     }
 };
 const readmeComponents = (opts) => () => tree => {
@@ -93244,6 +93277,63 @@ function rehypeStringify(options) {
   }
 }
 
+;// ./node_modules/mdast-util-newline-to-break/lib/index.js
+/**
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
+ */
+
+
+
+/**
+ * Turn normal line endings into hard breaks.
+ *
+ * @param {Nodes} tree
+ *   Tree to change.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function newlineToBreak(tree) {
+  findAndReplace(tree, [/\r?\n|\r/g, lib_replace])
+}
+
+/**
+ * Replace line endings.
+ *
+ * @type {ReplaceFunction}
+ */
+function lib_replace() {
+  return {type: 'break'}
+}
+
+;// ./node_modules/remark-breaks/lib/index.js
+/**
+ * @typedef {import('mdast').Root} Root
+ */
+
+
+
+/**
+ * Support hard breaks without needing spaces or escapes (turns enters into
+ * `<br>`s).
+ *
+ * @returns
+ *   Transform.
+ */
+function remarkBreaks() {
+  /**
+   * Transform.
+   *
+   * @param {Root} tree
+   *   Tree.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  return function (tree) {
+    newlineToBreak(tree)
+  }
+}
+
 ;// ./lib/utils/mdxish/mdxish-get-component-name.ts
 /** Convert a string to PascalCase */
 function toPascalCase(str) {
@@ -93922,6 +94012,71 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
 };
 /* harmony default export */ const evaluate_expressions = (evaluateExpressions);
 
+;// ./node_modules/rehype-parse/lib/index.js
+/**
+ * @import {Root} from 'hast'
+ * @import {Options as FromHtmlOptions} from 'hast-util-from-html'
+ * @import {Parser, Processor} from 'unified'
+ */
+
+/**
+ * @typedef {Omit<FromHtmlOptions, 'onerror'> & RehypeParseFields} Options
+ *   Configuration.
+ *
+ * @typedef RehypeParseFields
+ *   Extra fields.
+ * @property {boolean | null | undefined} [emitParseErrors=false]
+ *   Whether to emit parse errors while parsing (default: `false`).
+ *
+ *   > 👉 **Note**: parse errors are currently being added to HTML.
+ *   > Not all errors emitted by parse5 (or us) are specced yet.
+ *   > Some documentation may still be missing.
+ */
+
+
+
+/**
+ * Plugin to add support for parsing from HTML.
+ *
+ * > 👉 **Note**: this is not an XML parser.
+ * > It supports SVG as embedded in HTML.
+ * > It does not support the features available in XML.
+ * > Passing SVG files might break but fragments of modern SVG should be fine.
+ * > Use [`xast-util-from-xml`][xast-util-from-xml] to parse XML.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+function rehypeParse(options) {
+  /** @type {Processor<Root>} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+  const {emitParseErrors, ...settings} = {...self.data('settings'), ...options}
+
+  self.parser = parser
+
+  /**
+   * @type {Parser<Root>}
+   */
+  function parser(document, file) {
+    return fromHtml(document, {
+      ...settings,
+      onerror: emitParseErrors
+        ? function (message) {
+            if (file.path) {
+              message.name = file.path + ':' + message.name
+              message.file = file.path
+            }
+
+            file.messages.push(message)
+          }
+        : undefined
+    })
+  }
+}
+
 ;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
 
 // Marker patterns for multi-node emphasis detection
@@ -94265,6 +94420,18 @@ const normalizeEmphasisAST = () => (tree) => {
 };
 /* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
 
+;// ./processor/transform/mdxish/magic-blocks/patterns.ts
+/** Matches HTML tags (open, close, self-closing) with optional attributes. */
+const HTML_TAG_RE = /<\/?([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']*(?:"[^"]*"|'[^']*'))*[^>"']*)>/g;
+/** Matches an HTML element from its opening tag to the matching closing tag. */
+const HTML_ELEMENT_BLOCK_RE = /<([a-zA-Z][a-zA-Z0-9-]*)[\s>][\s\S]*?<\/\1>/g;
+/** Matches a newline with surrounding horizontal whitespace. */
+const NEWLINE_WITH_WHITESPACE_RE = /[^\S\n]*\n[^\S\n]*/g;
+/** Matches a closing block-level tag followed by non-tag text or by a newline then non-blank content. */
+const CLOSE_BLOCK_TAG_BOUNDARY_RE = /<\/([a-zA-Z][a-zA-Z0-9-]*)>\s*(?:(?!<)(\S)|\n([^\n]))/g;
+/** Tests whether a string contains a complete HTML element (open + close tag). */
+const COMPLETE_HTML_ELEMENT_RE = /<[a-zA-Z][^>]*>[\s\S]*<\/[a-zA-Z]/;
+
 ;// ./processor/transform/mdxish/magic-blocks/placeholder.ts
 const EMPTY_IMAGE_PLACEHOLDER = {
     type: 'image',
@@ -94318,6 +94485,14 @@ const EMPTY_CODE_PLACEHOLDER = {
 
 
 
+
+
+
+
+
+
+
+
 /**
  * Wraps a node in a "pinned" container if sidebar: true is set.
  */
@@ -94345,12 +94520,125 @@ const imgWidthBySize = new Proxy(imgSizeValues, {
 });
 const textToInline = (text) => [{ type: 'text', value: text }];
 const textToBlock = (text) => [{ children: textToInline(text), type: 'paragraph' }];
-/** Parses markdown and html to markdown nodes */
-const contentParser = unified().use(remarkParse).use(remarkGfm).use(normalize_malformed_md_syntax);
+/**
+ * Converts leading newlines in magic block content to `<br>` tags.
+ * Leading newlines are stripped by remark-parse before they become soft break nodes,
+ * so remark-breaks cannot handle them. We convert them to HTML `<br>` tags instead.
+ */
+const ensureLeadingBreaks = (text) => text.replace(/^\n+/, match => '<br>'.repeat(match.length));
+/** Preprocesses magic block body content before parsing. */
+const preprocessBody = (text) => {
+    return ensureLeadingBreaks(text);
+};
+/** Markdown parser */
+const contentParser = unified().use(remarkParse).use(remarkBreaks).use(remarkGfm).use(normalize_malformed_md_syntax);
+/** Markdown to HTML processor (mdast → hast → HTML string) */
+const markdownToHtml = unified()
+    .use(remarkParse)
+    .use(remarkGfm)
+    .use(normalize_malformed_md_syntax)
+    .use(remarkRehype)
+    .use(rehypeStringify);
+/** HTML parser (HTML string → hast) */
+const htmlParser = unified().use(rehypeParse, { fragment: true });
+/** HTML stringifier (hast → HTML string) */
+const htmlStringifier = unified().use(rehypeStringify);
+/** Process \|, \<, \> backslash escapes. Only < is entity-escaped; > is left literal to avoid double-encoding by rehype. */
+const processBackslashEscapes = (text) => text.replace(/\\<([^>]*)>/g, '&lt;$1>').replace(/\\([<>|])/g, (_, c) => (c === '<' ? '&lt;' : c === '>' ? '>' : c));
+/** Block-level HTML tags that trigger CommonMark type 6 HTML blocks (condition 6). */
+const BLOCK_LEVEL_TAGS = new Set(htmlBlockNames);
+const escapeInvalidTags = (str) => str.replace(HTML_TAG_RE, (match, tag, rest) => {
+    const tagName = tag.replace(/^\//, '');
+    if (STANDARD_HTML_TAGS.has(tagName.toLowerCase()))
+        return match;
+    // Preserve PascalCase tags (custom components like <Glossary>) for the main pipeline
+    if (/^[A-Z]/.test(tagName))
+        return match;
+    return `&lt;${tag}${rest}&gt;`;
+});
+/**
+ * Process markdown within HTML string.
+ * 1. Parse HTML to HAST
+ * 2. Find text nodes, parse as markdown, convert to HAST
+ * 3. Stringify back to HTML
+ *
+ * PascalCase component tags (e.g. `<Glossary>`) are temporarily replaced with
+ * placeholders before HTML parsing so `rehype-parse` doesn't mangle them
+ * (it treats unknown tags as void elements, stripping their children).
+ */
+const processMarkdownInHtmlString = (html) => {
+    const placeholders = [];
+    let counter = 0;
+    const safened = escapeInvalidTags(html).replace(HTML_TAG_RE, match => {
+        if (!/^<\/?[A-Z]/.test(match))
+            return match;
+        const id = `<!--PC${(counter += 1)}-->`;
+        placeholders.push([id, match]);
+        return id;
+    });
+    const hast = htmlParser.parse(safened);
+    const textToHast = (text) => {
+        if (!text.trim())
+            return [{ type: 'text', value: text }];
+        const parsed = markdownToHtml.runSync(markdownToHtml.parse(escapeInvalidTags(text)));
+        const nodes = parsed.children.flatMap(n => n.type === 'element' && n.tagName === 'p' ? n.children : [n]);
+        const leading = text.match(/^\s+/)?.[0];
+        const trailing = text.match(/\s+$/)?.[0];
+        if (leading)
+            nodes.unshift({ type: 'text', value: leading });
+        if (trailing)
+            nodes.push({ type: 'text', value: trailing });
+        return nodes;
+    };
+    const processChildren = (children) => children.flatMap(child => (child.type === 'text' ? textToHast(child.value) : [child]));
+    hast.children = processChildren(hast.children);
+    visit(hast, 'element', (node) => {
+        node.children = processChildren(node.children);
+    });
+    return placeholders.reduce((res, [id, original]) => res.replace(id, original), htmlStringifier.stringify(hast));
+};
+/**
+ * Separate a closing block-level tag from the content that follows it.
+ *
+ * Each \n in the original text becomes a <br> tag to preserve spacing, then a
+ * blank line (\n\n) is appended so CommonMark ends the HTML block and parses
+ * the following content as markdown.
+ */
+const separateBlockTagFromContent = (match, tag, inlineChar, nextLineChar) => {
+    if (!BLOCK_LEVEL_TAGS.has(tag.toLowerCase()))
+        return match;
+    const newlineCount = (match.match(/\n/g) ?? []).length;
+    const breaks = '<br>'.repeat(newlineCount);
+    return `</${tag}>${breaks}\n\n${inlineChar || nextLineChar}`;
+};
+/**
+ * CommonMark doesn't process markdown inside HTML blocks -
+ * so `<ul><li>_text_</li></ul>` won't convert underscores to emphasis.
+ * We parse first, then visit html nodes and process their text content.
+ */
 const parseTableCell = (text) => {
     if (!text.trim())
         return [{ type: 'text', value: '' }];
-    const tree = contentParser.runSync(contentParser.parse(text));
+    // Convert \n (and surrounding whitespace) to <br> inside HTML blocks so
+    // CommonMark doesn't split them on blank lines.
+    // Then strip leading whitespace to prevent indented code blocks.
+    const escaped = processBackslashEscapes(text);
+    const normalized = escaped
+        .replace(HTML_ELEMENT_BLOCK_RE, match => match.replace(NEWLINE_WITH_WHITESPACE_RE, '<br>'))
+        .replace(CLOSE_BLOCK_TAG_BOUNDARY_RE, separateBlockTagFromContent);
+    const trimmedLines = normalized.split('\n').map(line => line.trimStart());
+    const processed = trimmedLines.join('\n');
+    const tree = contentParser.runSync(contentParser.parse(processed));
+    // Process markdown inside complete HTML elements (e.g. _emphasis_ within <li>).
+    // Bare tags like "<i>" are left for rehypeRaw since rehype-parse would mangle them.
+    visit(tree, 'html', (node) => {
+        if (COMPLETE_HTML_ELEMENT_RE.test(node.value)) {
+            node.value = processMarkdownInHtmlString(node.value);
+        }
+        else {
+            node.value = escapeInvalidTags(node.value);
+        }
+    });
     if (tree.children.length > 1) {
         return tree.children;
     }
@@ -94505,7 +94793,7 @@ function transformMagicBlock(blockType, data, rawValue, options = {}) {
                 });
             }
             if (hasBody) {
-                const bodyBlocks = parseBlock(calloutJson.body || '');
+                const bodyBlocks = parseBlock(preprocessBody(calloutJson.body || ''));
                 children.push(...bodyBlocks);
             }
             const calloutElement = {
@@ -94540,7 +94828,7 @@ function transformMagicBlock(blockType, data, rawValue, options = {}) {
             const tokenizeCell = compatibilityMode ? textToBlock : parseTableCell;
             const tableChildren = Array.from({ length: rows + 1 }, (_, y) => ({
                 children: Array.from({ length: cols }, (__, x) => ({
-                    children: sparseData[y]?.[x] ? tokenizeCell(sparseData[y][x]) : [{ type: 'text', value: '' }],
+                    children: sparseData[y]?.[x] ? tokenizeCell(preprocessBody(sparseData[y][x])) : [{ type: 'text', value: '' }],
                     type: y === 0 ? 'tableHead' : 'tableCell',
                 })),
                 type: 'tableRow',
@@ -94641,79 +94929,63 @@ const isBlockNode = (node) => blockTypes.includes(node.type);
  */
 const magicBlockTransformer = (options = {}) => tree => {
     const replacements = [];
-    visit(tree, 'magicBlock', (node, index, parent) => {
-        if (!parent || index === undefined)
-            return undefined;
+    visitParents(tree, 'magicBlock', (node, ancestors) => {
+        const parent = ancestors[ancestors.length - 1]; // direct parent of the current node
+        const index = parent.children.indexOf(node);
+        if (index === -1)
+            return;
         const children = transformMagicBlock(node.blockType, node.data, node.value, options);
         if (!children.length) {
-            // Remove the node if transformation returns nothing
+            // `visitParents` doesn't support [Action, Index] returns like `visit` does;
+            // a bare return after splicing is sufficient since `visitParents` walks by
+            // tree structure rather than index.
             parent.children.splice(index, 1);
-            return [SKIP, index];
+            return;
         }
         // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs), lift them out
         if (parent.type === 'paragraph' && children.some(child => isBlockNode(child))) {
             const blockNodes = [];
             const inlineNodes = [];
-            // Separate block and inline nodes
             children.forEach(child => {
-                if (isBlockNode(child)) {
-                    blockNodes.push(child);
-                }
-                else {
-                    inlineNodes.push(child);
-                }
+                (isBlockNode(child) ? blockNodes : inlineNodes).push(child);
             });
-            const before = parent.children.slice(0, index);
-            const after = parent.children.slice(index + 1);
             replacements.push({
+                container: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
                 parent,
                 blockNodes,
                 inlineNodes,
-                before,
-                after,
+                before: parent.children.slice(0, index),
+                after: parent.children.slice(index + 1),
             });
         }
         else {
-            // Normal case: just replace the inlineCode with the children
             parent.children.splice(index, 1, ...children);
         }
-        return undefined;
     });
     // Second pass: apply replacements that require lifting block nodes out of paragraphs
     // Process in reverse order to maintain correct indices
     for (let i = replacements.length - 1; i >= 0; i -= 1) {
-        const { after, before, blockNodes, inlineNodes, parent } = replacements[i];
-        // Find the paragraph's position in the root
-        const rootChildren = tree.children;
-        const paraIndex = rootChildren.findIndex(child => child === parent);
+        const { after, before, blockNodes, container, inlineNodes, parent } = replacements[i];
+        const containerChildren = container.children;
+        const paraIndex = containerChildren.indexOf(parent);
         if (paraIndex === -1) {
-            // Paragraph not found in root - fall back to normal replacement
-            // This shouldn't happen normally, but handle it gracefully
-            // Reconstruct the original index from before.length
-            const originalIndex = before.length;
-            parent.children.splice(originalIndex, 1, ...blockNodes, ...inlineNodes);
+            parent.children.splice(before.length, 1, ...blockNodes, ...inlineNodes);
             // eslint-disable-next-line no-continue
             continue;
         }
-        // Update or remove the paragraph
         if (inlineNodes.length > 0) {
-            // Keep paragraph with inline nodes
             parent.children = [...before, ...inlineNodes, ...after];
-            // Insert block nodes after the paragraph
             if (blockNodes.length > 0) {
-                rootChildren.splice(paraIndex + 1, 0, ...blockNodes);
+                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
             }
         }
         else if (before.length === 0 && after.length === 0) {
-            // Remove empty paragraph and replace with block nodes
-            rootChildren.splice(paraIndex, 1, ...blockNodes);
+            containerChildren.splice(paraIndex, 1, ...blockNodes);
         }
         else {
-            // Keep paragraph with remaining content
             parent.children = [...before, ...after];
-            // Insert block nodes after the paragraph
             if (blockNodes.length > 0) {
-                rootChildren.splice(paraIndex + 1, 0, ...blockNodes);
+                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
             }
         }
     }
@@ -95548,6 +95820,45 @@ const restoreBooleanProperties = () => tree => {
 };
 
 
+;// ./processor/transform/mdxish/terminate-html-flow-blocks.ts
+
+const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
+const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
+/**
+ * Preprocessor to terminate HTML flow blocks.
+ *
+ * In CommonMark, HTML blocks (types 6 and 7) only terminate on a blank line.
+ * Without one, any content on the next line is consumed as part of the HTML block
+ * and never parsed as its own construct. For example, a `[block:callout]` immediately
+ * following `<div><p></p></div>` gets swallowed into the HTML flow token.
+ *
+ * @link https://spec.commonmark.org/0.29/#html-blocks
+ *
+ * This preprocessor inserts a blank line after standalone HTML lines when the
+ * next line is non-blank, ensuring micromark's HTML flow tokenizer terminates
+ * and subsequent content is parsed independently.
+ *
+ * Only targets non-indented lines with lowercase tag names. Uppercase tags
+ * (e.g., `<Table>`, `<MyComponent>`) are JSX custom components and don't
+ * trigger CommonMark HTML blocks, so they are left untouched.
+ *
+ * Lines inside fenced code blocks are skipped entirely.
+ */
+function terminateHtmlFlowBlocks(content) {
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const lines = protectedContent.split('\n');
+    const result = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        result.push(lines[i]);
+        if (i < lines.length - 1 &&
+            (STANDALONE_HTML_LINE_REGEX.test(lines[i]) || HTML_LINE_WITH_CONTENT_REGEX.test(lines[i])) &&
+            lines[i + 1].trim().length > 0) {
+            result.push('');
+        }
+    }
+    return restoreCodeBlocks(result.join('\n'), protectedCode);
+}
+
 ;// ./processor/transform/mdxish/variables-text.ts
 
 
@@ -96850,10 +97161,29 @@ function loadComponents() {
 
 
 
+
+
 
 
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
+/**
+ * Preprocessing pipeline: applies string-level transformations to work around
+ * CommonMark/remark limitations and reach parity with legacy (rdmd) rendering.
+ *
+ * Runs a series of string-level transformations before micromark/remark parsing:
+ * 1. Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
+ * 2. Terminate HTML flow blocks so subsequent content isn't swallowed
+ * 3. Evaluate JSX expressions in attributes (unless safeMode)
+ * 4. Replace snake_case component names with parser-safe placeholders
+ */
+function preprocessContent(content, opts) {
+    const { safeMode, jsxContext, knownComponents } = opts;
+    let result = normalizeTableSeparator(content);
+    result = terminateHtmlFlowBlocks(result);
+    result = safeMode ? result : preprocessJSXExpressions(result, jsxContext);
+    return processSnakeCaseComponent(result, { knownComponents });
+}
 function mdxishAstProcessor(mdContent, opts = {}) {
     const { components: userComponents = {}, jsxContext = {}, newEditorTypes = false, safeMode = false, useTailwind, } = opts;
     const components = {
@@ -96862,15 +97192,11 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     };
     // Build set of known component names for snake_case filtering
     const knownComponents = new Set(Object.keys(components));
-    // Preprocessing pipeline: Transform content to be parser-ready
-    // Step 1: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
-    const contentAfterTableNormalization = normalizeTableSeparator(mdContent);
-    // Step 2: Evaluate JSX expressions in attributes
-    const contentAfterJSXEvaluation = safeMode
-        ? contentAfterTableNormalization
-        : preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
-    // Step 3: Replace snake_case component names with parser-safe placeholders
-    const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation, { knownComponents });
+    const { content: parserReadyContent, mapping: snakeCaseMapping } = preprocessContent(mdContent, {
+        safeMode,
+        jsxContext,
+        knownComponents,
+    });
     // Create string map for tailwind transformer
     const tempComponentsMap = Object.entries(components).reduce((acc, [key, value]) => {
         acc[key] = String(value);
@@ -96938,6 +97264,7 @@ function mdxish(mdContent, opts = {}) {
     };
     const { processor, parserReadyContent } = mdxishAstProcessor(mdContent, opts);
     processor
+        .use(remarkBreaks)
         .use(remarkRehype, { allowDangerousHtml: true, handlers: mdxComponentHandlers })
         .use(preserveBooleanProperties) // RehypeRaw converts boolean properties to empty strings
         .use(rehypeRaw, { passThrough: ['html-block'] })
@@ -97434,8 +97761,59 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = (mdxishTags_tags);
 
-;// ./lib/stripComments.ts
+;// ./lib/utils/extractMagicBlocks.ts
+/**
+ * The content matching in this regex captures everything between `[block:TYPE]`
+ * and `[/block]`, including new lines. Negative lookahead for the closing
+ * `[/block]` tag is required to prevent greedy matching to ensure it stops at
+ * the first closing tag it encounters preventing vulnerability to polynomial
+ * backtracking issues.
+ */
+const MAGIC_BLOCK_REGEX = /\[block:[^\]]{1,100}\](?:(?!\[block:)(?!\[\/block\])[\s\S])*\[\/block\]/g;
+/**
+ * Extract legacy magic block syntax from a markdown string.
+ * Returns the modified markdown and an array of extracted blocks.
+ */
+function extractMagicBlocks(markdown) {
+    const blocks = [];
+    let index = 0;
+    const replaced = markdown.replace(MAGIC_BLOCK_REGEX, match => {
+        /**
+         * Key is the unique identifier for the magic block
+         */
+        const key = `__MAGIC_BLOCK_${index}__`;
+        /**
+         * 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;
+    });
+    return { replaced, blocks };
+}
+/**
+ * Restore extracted magic blocks back into a markdown string.
+ */
+function restoreMagicBlocks(replaced, blocks) {
+    // 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/stripComments.ts
 
 
 
@@ -97450,10 +97828,8 @@ const mdxishTags_tags = (doc) => {
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
-    const processor = unified()
-        .data('micromarkExtensions', [magicBlock()])
-        .data('fromMarkdownExtensions', [magicBlockFromMarkdown()])
-        .data('toMarkdownExtensions', [magicBlockToMarkdown()]);
+    const { replaced, blocks } = extractMagicBlocks(doc);
+    const processor = unified();
     // we still require these two extensions because:
     // 1. we can rely on remarkMdx to parse MDXish
     // 2. we need to parse JSX comments into mdxTextExpression nodes so that the transformers can pick them up
@@ -97495,8 +97871,10 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 },
             ],
         });
-    const file = await processor.process(doc);
-    return String(file).trim();
+    const file = await processor.process(replaced);
+    const stringified = String(file).trim();
+    const restored = restoreMagicBlocks(stringified, blocks);
+    return restored;
 }
 /* harmony default export */ const lib_stripComments = (stripComments);