@readme/markdown 14.1.2 → 14.1.3

package/dist/main.js

@@ -99481,11 +99481,17 @@ const blockTypes = [
  * Check if a node is a block-level node (cannot be inside a paragraph)
  */
 const isBlockNode = (node) => blockTypes.includes(node.type);
+const isParagraph = (node) => node.type === 'paragraph';
+/**
+ * True for phrasing content that contributes only whitespace at render time
+ * (a soft `break` node or a text node with no non-whitespace characters).
+ */
+const isWhitespacePhrasing = (node) => node.type === 'break' || (node.type === 'text' && !node.value.trim());
 /**
  * Unified plugin that transforms magicBlock nodes into final MDAST nodes.
  */
 const magicBlockTransformer = (options = {}) => tree => {
-    const replacements = [];
+    const lifts = [];
     visitParents(tree, 'magicBlock', (node, ancestors) => {
         const parent = ancestors[ancestors.length - 1]; // direct parent of the current node
         const index = parent.children.indexOf(node);
@@ -99499,51 +99505,60 @@ const magicBlockTransformer = (options = {}) => tree => {
             parent.children.splice(index, 1);
             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))) {
+        // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs)
+        // it means we need to lift them out
+        if (isParagraph(parent) && children.some(isBlockNode)) {
             const blockNodes = [];
-            const inlineNodes = [];
             children.forEach(child => {
-                (isBlockNode(child) ? blockNodes : inlineNodes).push(child);
+                if (isBlockNode(child)) {
+                    blockNodes.push(child);
+                }
             });
-            replacements.push({
-                container: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+            lifts.push({
+                childrenBlockNodes: blockNodes,
+                grandparent: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+                node,
                 parent,
-                blockNodes,
-                inlineNodes,
-                before: parent.children.slice(0, index),
-                after: parent.children.slice(index + 1),
             });
         }
         else {
             parent.children.splice(index, 1, ...children);
         }
     });
-    // 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, container, inlineNodes, parent } = replacements[i];
-        const containerChildren = container.children;
-        const paraIndex = containerChildren.indexOf(parent);
-        if (paraIndex === -1) {
-            parent.children.splice(before.length, 1, ...blockNodes, ...inlineNodes);
+    // Second pass: apply lifts that move block nodes, and the content after them, out of paragraphs.
+    // Operate on live state (find each node's current index now) and process in reverse so
+    // that container insertions don't disturb earlier paragraphs' positions.
+    for (let i = lifts.length - 1; i >= 0; i -= 1) {
+        const { childrenBlockNodes: blockNodes, grandparent, node, parent: parentParagraph } = lifts[i];
+        const nodePosition = parentParagraph.children.indexOf(node);
+        const parentPosition = grandparent.children.indexOf(parentParagraph);
+        if (nodePosition === -1 || parentPosition === -1) {
             // eslint-disable-next-line no-continue
             continue;
         }
-        if (inlineNodes.length > 0) {
-            parent.children = [...before, ...inlineNodes, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
-        }
-        else if (before.length === 0 && after.length === 0) {
-            containerChildren.splice(paraIndex, 1, ...blockNodes);
+        // Snapshot live siblings to reconstruct the parent paragraph around the lifted node.
+        const parentSiblingsBefore = parentParagraph.children.slice(0, nodePosition);
+        const parentSiblingsAfter = parentParagraph.children.slice(nodePosition + 1);
+        // Remove split-edge whitespace so lifted blocks do not render with extra blank lines.
+        while (parentSiblingsBefore.length > 0 && isWhitespacePhrasing(parentSiblingsBefore[parentSiblingsBefore.length - 1]))
+            parentSiblingsBefore.pop();
+        while (parentSiblingsAfter.length > 0 && isWhitespacePhrasing(parentSiblingsAfter[0]))
+            parentSiblingsAfter.shift();
+        const splitOffContentFromParent = [...blockNodes];
+        if (parentSiblingsAfter.length > 0) {
+            // Keep trailing inline content grouped under a paragraph sibling as it might be an inline node
+            // Even if it contains a block node, it will be hoisted out during its turn in the loop
+            const trailingParagraph = { type: 'paragraph', children: parentSiblingsAfter };
+            splitOffContentFromParent.push(trailingParagraph);
+        }
+        parentParagraph.children = [...parentSiblingsBefore];
+        // If the parent paragraph is empty, just replace it with the lifted block nodes
+        const shouldReplaceParent = parentParagraph.children.length === 0;
+        if (shouldReplaceParent) {
+            grandparent.children.splice(parentPosition, 1, ...splitOffContentFromParent);
         }
         else {
-            parent.children = [...before, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
+            grandparent.children.splice(parentPosition + 1, 0, ...splitOffContentFromParent);
         }
     }
 };
@@ -99613,29 +99628,56 @@ function protectHTMLBlockContent(content) {
 function removeJSXComments(content) {
     return content.replace(JSX_COMMENT_REGEX, '');
 }
+const HTML_ELEM_PLACEHOLDER_PREFIX = '___MDXISH_HTML_ELEM_';
+const HTML_ELEM_PLACEHOLDER = new RegExp(`${HTML_ELEM_PLACEHOLDER_PREFIX}(\\d+)___`, 'g');
+// Matches an HTML element that starts at a line boundary and ends at a line boundary.
+// Allows optional leading indentation and lazily matches until the same closing tag.
+const BLOCK_HTML_RE = /(?<=^|\n)[ \t]*<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>[ \t]*(?=\n|$)/g;
 /**
- * Escapes problematic braces in content to prevent MDX expression parsing errors.
- * Handles unbalanced braces and paragraph-spanning expressions. Skips HTML elements
- * so backslashes don't leak into rendered output via rehypeRaw.
+ * Hides line-anchored HTML elements from the brace-escaping pass so we don't leak `\{`
+ * into rendered output (rehypeRaw renders the `\` literally, e.g. `<div>{foo</div>`).
+ *
+ * One carve-out: if an interior line at column 0 has bare text containing `{`, mdxish
+ * parses that line as a paragraph and the mdxExpression step would throw without an
+ * escape — so we leave that case to the brace balancer.
  */
-function escapeProblematicBraces(content) {
-    // Skip HTML elements — their content should never be escaped because
-    // rehypeRaw parses them into hast elements, making `\` literal text in output
+function protectHTMLElements(content) {
     const htmlElements = [];
-    const safe = content.replace(/<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, match => {
-        const idx = htmlElements.length;
+    const protectedContent = content.replace(BLOCK_HTML_RE, match => {
+        // Look at the lines between the open and close tags. If any of them starts
+        // at column 0 with bare text (not whitespace, not another tag) and contains
+        // `{`, mdxish will parse that line as a paragraph and the brace as an MDX
+        // expression, which would throw an error. So we let the brace balancer escape it.
+        // Otherwise, we need to extract the sequence to protect it from the brace escaping.
+        const interior = match.split('\n').slice(1, -1);
+        const hazard = interior.some(line => line.length > 0 && line[0] !== ' ' && line[0] !== '\t' && line[0] !== '<' && line.includes('{'));
+        if (hazard)
+            return match;
         htmlElements.push(match);
-        return `___HTML_ELEM_${idx}___`;
+        return `${HTML_ELEM_PLACEHOLDER_PREFIX}${htmlElements.length - 1}___`;
     });
-    const toEscape = new Set();
-    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
-    const chars = Array.from(safe);
+    return { htmlElements, protectedContent };
+}
+function restoreHTMLElements(content, htmlElements) {
+    if (htmlElements.length === 0)
+        return content;
+    return content.replace(HTML_ELEM_PLACEHOLDER, (_m, idx) => htmlElements[parseInt(idx, 10)]);
+}
+/**
+ * Escapes unbalanced and paragraph-spanning braces so MDX doesn't trip on them.
+ */
+function escapeProblematicBraces(content) {
+    const { htmlElements, protectedContent } = protectHTMLElements(content);
     let strDelim = null;
     let strEscaped = false;
-    // Stack of open braces with their state
-    const openStack = [];
     // Track position of last newline (outside strings) to detect blank lines
-    let lastNewlinePos = -2; // -2 means no recent newline
+    // -2 means no recent newline
+    let lastNewlinePos = -2;
+    // Character state machine trackers
+    const toEscape = new Set();
+    // Convert to array of Unicode code points so that emojis and multi-byte characters are correctly tracked
+    const chars = Array.from(protectedContent);
+    const openStack = [];
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
         // Track string delimiters inside expressions to ignore braces within them
@@ -99655,22 +99697,17 @@ function escapeProblematicBraces(content) {
                 // eslint-disable-next-line no-continue
                 continue;
             }
-            // Track newlines to detect blank lines (paragraph boundaries)
             if (ch === '\n') {
-                // Check if this newline creates a blank line (only whitespace since last newline)
                 if (lastNewlinePos >= 0) {
                     const between = chars.slice(lastNewlinePos + 1, i).join('');
                     if (/^[ \t]*$/.test(between)) {
-                        // This is a blank line - mark all open expressions as paragraph-spanning
-                        openStack.forEach(entry => {
-                            entry.hasBlankLine = true;
-                        });
+                        openStack.forEach(entry => { entry.hasBlankLine = true; });
                     }
                 }
                 lastNewlinePos = i;
             }
         }
-        // Skip already-escaped braces (count preceding backslashes)
+        // Skip already-escaped braces (odd run of preceding backslashes).
         if (ch === '{' || ch === '}') {
             let bs = 0;
             for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
@@ -99681,10 +99718,9 @@ function escapeProblematicBraces(content) {
             }
         }
         if (ch === '{') {
-            // If preceded by `=` (ignoring whitespace), this is a JSX attribute
-            // expression (e.g. `data={[...]}`). The mdxComponent tokenizer captures
-            // the entire component block, so blank lines inside attribute values
-            // won't split paragraphs — skip the blank-line check for these.
+            // `=` (after whitespace) before `{` ⇒ JSX attribute expression. The
+            // mdxComponent tokenizer captures the whole component, so blank lines
+            // inside attribute values are harmless. Nested `{` inherits the flag.
             let isAttrExpr = false;
             for (let j = i - 1; j >= 0; j -= 1) {
                 const pc = chars[j];
@@ -99698,27 +99734,17 @@ function escapeProblematicBraces(content) {
             // Nested `{ ... }` inside an attribute value (e.g. `data={[{ ... }]}` or
             // `data={{ a: { b: 1 } }}`) must inherit the same exemption; only the
             // outer `{` is directly after `=`.
-            if (!isAttrExpr && openStack.length > 0) {
-                const parent = openStack[openStack.length - 1];
-                if (parent.isAttrExpr) {
-                    isAttrExpr = true;
-                }
+            if (!isAttrExpr && openStack.length > 0 && openStack[openStack.length - 1].isAttrExpr) {
+                isAttrExpr = true;
             }
             openStack.push({ pos: i, hasBlankLine: false, isAttrExpr });
-            lastNewlinePos = -2; // Reset newline tracking for new expression
+            lastNewlinePos = -2;
         }
         else if (ch === '}') {
             if (openStack.length > 0) {
                 const entry = openStack.pop();
-                // Don't escape pure JSX comments, the `jsxComment` tokenizer downstream
-                // already knows how to swallow a whole `{/* ... */}` block in one go,
-                // even if the body has blank lines in it. If we escape the braces here
-                // the tokenizer never gets a shot at it.
-                //
-                // "Pure" means the braces open with `{/*` and close with `*/}` right
-                // next to each other. Something like `{/* c */ expr\n\nmore}` is just
-                // a regular expression that happens to start with a comment, so it
-                // still needs the normal blank-line protection.
+                // Pure `{/* ... */}` comments are handled downstream by the jsxComment
+                // tokenizer — escaping their braces would prevent it from running.
                 const isPureJsxComment = chars[entry.pos + 1] === '/' &&
                     chars[entry.pos + 2] === '*' &&
                     chars[i - 1] === '/' &&
@@ -99729,21 +99755,15 @@ function escapeProblematicBraces(content) {
                 }
             }
             else {
-                // Unbalanced closing brace (no matching open)
                 toEscape.add(i);
             }
         }
     }
-    // Any remaining open braces are unbalanced
+    // Anything still open is unbalanced.
     openStack.forEach(entry => toEscape.add(entry.pos));
-    // If there are no problematic braces, return safe content as-is;
-    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
-    let result = toEscape.size === 0 ? safe : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
-    // Restore HTML elements
-    if (htmlElements.length > 0) {
-        result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
-    }
-    return result;
+    // Reconstruct the content with the escaped braces.
+    const escapedContent = toEscape.size === 0 ? protectedContent : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
+    return restoreHTMLElements(escapedContent, htmlElements);
 }
 /**
  * Preprocesses JSX-like markdown content before parsing.

package/dist/main.node.js

@@ -119675,11 +119675,17 @@ const blockTypes = [
  * Check if a node is a block-level node (cannot be inside a paragraph)
  */
 const isBlockNode = (node) => blockTypes.includes(node.type);
+const isParagraph = (node) => node.type === 'paragraph';
+/**
+ * True for phrasing content that contributes only whitespace at render time
+ * (a soft `break` node or a text node with no non-whitespace characters).
+ */
+const isWhitespacePhrasing = (node) => node.type === 'break' || (node.type === 'text' && !node.value.trim());
 /**
  * Unified plugin that transforms magicBlock nodes into final MDAST nodes.
  */
 const magicBlockTransformer = (options = {}) => tree => {
-    const replacements = [];
+    const lifts = [];
     visitParents(tree, 'magicBlock', (node, ancestors) => {
         const parent = ancestors[ancestors.length - 1]; // direct parent of the current node
         const index = parent.children.indexOf(node);
@@ -119693,51 +119699,60 @@ const magicBlockTransformer = (options = {}) => tree => {
             parent.children.splice(index, 1);
             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))) {
+        // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs)
+        // it means we need to lift them out
+        if (isParagraph(parent) && children.some(isBlockNode)) {
             const blockNodes = [];
-            const inlineNodes = [];
             children.forEach(child => {
-                (isBlockNode(child) ? blockNodes : inlineNodes).push(child);
+                if (isBlockNode(child)) {
+                    blockNodes.push(child);
+                }
             });
-            replacements.push({
-                container: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+            lifts.push({
+                childrenBlockNodes: blockNodes,
+                grandparent: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+                node,
                 parent,
-                blockNodes,
-                inlineNodes,
-                before: parent.children.slice(0, index),
-                after: parent.children.slice(index + 1),
             });
         }
         else {
             parent.children.splice(index, 1, ...children);
         }
     });
-    // 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, container, inlineNodes, parent } = replacements[i];
-        const containerChildren = container.children;
-        const paraIndex = containerChildren.indexOf(parent);
-        if (paraIndex === -1) {
-            parent.children.splice(before.length, 1, ...blockNodes, ...inlineNodes);
+    // Second pass: apply lifts that move block nodes, and the content after them, out of paragraphs.
+    // Operate on live state (find each node's current index now) and process in reverse so
+    // that container insertions don't disturb earlier paragraphs' positions.
+    for (let i = lifts.length - 1; i >= 0; i -= 1) {
+        const { childrenBlockNodes: blockNodes, grandparent, node, parent: parentParagraph } = lifts[i];
+        const nodePosition = parentParagraph.children.indexOf(node);
+        const parentPosition = grandparent.children.indexOf(parentParagraph);
+        if (nodePosition === -1 || parentPosition === -1) {
             // eslint-disable-next-line no-continue
             continue;
         }
-        if (inlineNodes.length > 0) {
-            parent.children = [...before, ...inlineNodes, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
-        }
-        else if (before.length === 0 && after.length === 0) {
-            containerChildren.splice(paraIndex, 1, ...blockNodes);
+        // Snapshot live siblings to reconstruct the parent paragraph around the lifted node.
+        const parentSiblingsBefore = parentParagraph.children.slice(0, nodePosition);
+        const parentSiblingsAfter = parentParagraph.children.slice(nodePosition + 1);
+        // Remove split-edge whitespace so lifted blocks do not render with extra blank lines.
+        while (parentSiblingsBefore.length > 0 && isWhitespacePhrasing(parentSiblingsBefore[parentSiblingsBefore.length - 1]))
+            parentSiblingsBefore.pop();
+        while (parentSiblingsAfter.length > 0 && isWhitespacePhrasing(parentSiblingsAfter[0]))
+            parentSiblingsAfter.shift();
+        const splitOffContentFromParent = [...blockNodes];
+        if (parentSiblingsAfter.length > 0) {
+            // Keep trailing inline content grouped under a paragraph sibling as it might be an inline node
+            // Even if it contains a block node, it will be hoisted out during its turn in the loop
+            const trailingParagraph = { type: 'paragraph', children: parentSiblingsAfter };
+            splitOffContentFromParent.push(trailingParagraph);
+        }
+        parentParagraph.children = [...parentSiblingsBefore];
+        // If the parent paragraph is empty, just replace it with the lifted block nodes
+        const shouldReplaceParent = parentParagraph.children.length === 0;
+        if (shouldReplaceParent) {
+            grandparent.children.splice(parentPosition, 1, ...splitOffContentFromParent);
         }
         else {
-            parent.children = [...before, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
+            grandparent.children.splice(parentPosition + 1, 0, ...splitOffContentFromParent);
         }
     }
 };
@@ -119807,29 +119822,56 @@ function protectHTMLBlockContent(content) {
 function removeJSXComments(content) {
     return content.replace(JSX_COMMENT_REGEX, '');
 }
+const HTML_ELEM_PLACEHOLDER_PREFIX = '___MDXISH_HTML_ELEM_';
+const HTML_ELEM_PLACEHOLDER = new RegExp(`${HTML_ELEM_PLACEHOLDER_PREFIX}(\\d+)___`, 'g');
+// Matches an HTML element that starts at a line boundary and ends at a line boundary.
+// Allows optional leading indentation and lazily matches until the same closing tag.
+const BLOCK_HTML_RE = /(?<=^|\n)[ \t]*<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>[ \t]*(?=\n|$)/g;
 /**
- * Escapes problematic braces in content to prevent MDX expression parsing errors.
- * Handles unbalanced braces and paragraph-spanning expressions. Skips HTML elements
- * so backslashes don't leak into rendered output via rehypeRaw.
+ * Hides line-anchored HTML elements from the brace-escaping pass so we don't leak `\{`
+ * into rendered output (rehypeRaw renders the `\` literally, e.g. `<div>{foo</div>`).
+ *
+ * One carve-out: if an interior line at column 0 has bare text containing `{`, mdxish
+ * parses that line as a paragraph and the mdxExpression step would throw without an
+ * escape — so we leave that case to the brace balancer.
  */
-function escapeProblematicBraces(content) {
-    // Skip HTML elements — their content should never be escaped because
-    // rehypeRaw parses them into hast elements, making `\` literal text in output
+function protectHTMLElements(content) {
     const htmlElements = [];
-    const safe = content.replace(/<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, match => {
-        const idx = htmlElements.length;
+    const protectedContent = content.replace(BLOCK_HTML_RE, match => {
+        // Look at the lines between the open and close tags. If any of them starts
+        // at column 0 with bare text (not whitespace, not another tag) and contains
+        // `{`, mdxish will parse that line as a paragraph and the brace as an MDX
+        // expression, which would throw an error. So we let the brace balancer escape it.
+        // Otherwise, we need to extract the sequence to protect it from the brace escaping.
+        const interior = match.split('\n').slice(1, -1);
+        const hazard = interior.some(line => line.length > 0 && line[0] !== ' ' && line[0] !== '\t' && line[0] !== '<' && line.includes('{'));
+        if (hazard)
+            return match;
         htmlElements.push(match);
-        return `___HTML_ELEM_${idx}___`;
+        return `${HTML_ELEM_PLACEHOLDER_PREFIX}${htmlElements.length - 1}___`;
     });
-    const toEscape = new Set();
-    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
-    const chars = Array.from(safe);
+    return { htmlElements, protectedContent };
+}
+function restoreHTMLElements(content, htmlElements) {
+    if (htmlElements.length === 0)
+        return content;
+    return content.replace(HTML_ELEM_PLACEHOLDER, (_m, idx) => htmlElements[parseInt(idx, 10)]);
+}
+/**
+ * Escapes unbalanced and paragraph-spanning braces so MDX doesn't trip on them.
+ */
+function escapeProblematicBraces(content) {
+    const { htmlElements, protectedContent } = protectHTMLElements(content);
     let strDelim = null;
     let strEscaped = false;
-    // Stack of open braces with their state
-    const openStack = [];
     // Track position of last newline (outside strings) to detect blank lines
-    let lastNewlinePos = -2; // -2 means no recent newline
+    // -2 means no recent newline
+    let lastNewlinePos = -2;
+    // Character state machine trackers
+    const toEscape = new Set();
+    // Convert to array of Unicode code points so that emojis and multi-byte characters are correctly tracked
+    const chars = Array.from(protectedContent);
+    const openStack = [];
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
         // Track string delimiters inside expressions to ignore braces within them
@@ -119849,22 +119891,17 @@ function escapeProblematicBraces(content) {
                 // eslint-disable-next-line no-continue
                 continue;
             }
-            // Track newlines to detect blank lines (paragraph boundaries)
             if (ch === '\n') {
-                // Check if this newline creates a blank line (only whitespace since last newline)
                 if (lastNewlinePos >= 0) {
                     const between = chars.slice(lastNewlinePos + 1, i).join('');
                     if (/^[ \t]*$/.test(between)) {
-                        // This is a blank line - mark all open expressions as paragraph-spanning
-                        openStack.forEach(entry => {
-                            entry.hasBlankLine = true;
-                        });
+                        openStack.forEach(entry => { entry.hasBlankLine = true; });
                     }
                 }
                 lastNewlinePos = i;
             }
         }
-        // Skip already-escaped braces (count preceding backslashes)
+        // Skip already-escaped braces (odd run of preceding backslashes).
         if (ch === '{' || ch === '}') {
             let bs = 0;
             for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
@@ -119875,10 +119912,9 @@ function escapeProblematicBraces(content) {
             }
         }
         if (ch === '{') {
-            // If preceded by `=` (ignoring whitespace), this is a JSX attribute
-            // expression (e.g. `data={[...]}`). The mdxComponent tokenizer captures
-            // the entire component block, so blank lines inside attribute values
-            // won't split paragraphs — skip the blank-line check for these.
+            // `=` (after whitespace) before `{` ⇒ JSX attribute expression. The
+            // mdxComponent tokenizer captures the whole component, so blank lines
+            // inside attribute values are harmless. Nested `{` inherits the flag.
             let isAttrExpr = false;
             for (let j = i - 1; j >= 0; j -= 1) {
                 const pc = chars[j];
@@ -119892,27 +119928,17 @@ function escapeProblematicBraces(content) {
             // Nested `{ ... }` inside an attribute value (e.g. `data={[{ ... }]}` or
             // `data={{ a: { b: 1 } }}`) must inherit the same exemption; only the
             // outer `{` is directly after `=`.
-            if (!isAttrExpr && openStack.length > 0) {
-                const parent = openStack[openStack.length - 1];
-                if (parent.isAttrExpr) {
-                    isAttrExpr = true;
-                }
+            if (!isAttrExpr && openStack.length > 0 && openStack[openStack.length - 1].isAttrExpr) {
+                isAttrExpr = true;
             }
             openStack.push({ pos: i, hasBlankLine: false, isAttrExpr });
-            lastNewlinePos = -2; // Reset newline tracking for new expression
+            lastNewlinePos = -2;
         }
         else if (ch === '}') {
             if (openStack.length > 0) {
                 const entry = openStack.pop();
-                // Don't escape pure JSX comments, the `jsxComment` tokenizer downstream
-                // already knows how to swallow a whole `{/* ... */}` block in one go,
-                // even if the body has blank lines in it. If we escape the braces here
-                // the tokenizer never gets a shot at it.
-                //
-                // "Pure" means the braces open with `{/*` and close with `*/}` right
-                // next to each other. Something like `{/* c */ expr\n\nmore}` is just
-                // a regular expression that happens to start with a comment, so it
-                // still needs the normal blank-line protection.
+                // Pure `{/* ... */}` comments are handled downstream by the jsxComment
+                // tokenizer — escaping their braces would prevent it from running.
                 const isPureJsxComment = chars[entry.pos + 1] === '/' &&
                     chars[entry.pos + 2] === '*' &&
                     chars[i - 1] === '/' &&
@@ -119923,21 +119949,15 @@ function escapeProblematicBraces(content) {
                 }
             }
             else {
-                // Unbalanced closing brace (no matching open)
                 toEscape.add(i);
             }
         }
     }
-    // Any remaining open braces are unbalanced
+    // Anything still open is unbalanced.
     openStack.forEach(entry => toEscape.add(entry.pos));
-    // If there are no problematic braces, return safe content as-is;
-    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
-    let result = toEscape.size === 0 ? safe : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
-    // Restore HTML elements
-    if (htmlElements.length > 0) {
-        result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
-    }
-    return result;
+    // Reconstruct the content with the escaped braces.
+    const escapedContent = toEscape.size === 0 ? protectedContent : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
+    return restoreHTMLElements(escapedContent, htmlElements);
 }
 /**
  * Preprocesses JSX-like markdown content before parsing.