@readme/markdown 14.11.4 → 14.11.5

package/dist/processor/compile/text.d.ts

@@ -0,0 +1,4 @@
+import type { Parents, Text } from 'mdast';
+import type { Info, State } from 'mdast-util-to-markdown';
+declare const text: (node: Text, parent: Parents | undefined, state: State, info: Info) => string;
+export default text;

package/dist/processor/transform/mdxish/terminate-html-flow-blocks.d.ts

@@ -1,22 +1,8 @@
 /**
- * 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.
+ * CommonMark HTML blocks (types 6/7) end only at a blank line, so markdown on the
+ * next line is swallowed as HTML (`## heading` after `<div>` renders as literal text).
+ * Inserts the missing blank line; the gating rules live in `shouldTerminateBetween`.
  *
  * @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 and not an HTML construct, ensuring micromark's HTML flow
- * tokenizer terminates and subsequent content is parsed independently.
- *
- * Conditions:
- * 1. Only non-indented lines with lowercase tag names are considered. Uppercase tags
- *    (e.g. `<Table>`, `<MyComponent>`) are JSX custom components and don't trigger
- *    CommonMark HTML blocks.
- * 2. Lines inside protected blocks (e.g. fenced code) are left untouched.
- * 3. Lines with an unclosed RAW_CONTENT_TAGS opener are exempted.
  */
 export declare function terminateHtmlFlowBlocks(content: string): string;

package/dist/render-fixture.node.js

@@ -117497,6 +117497,19 @@ const compile_list_item_listItem = (node, parent, state, info) => {
 const plain_plain = (node) => node.value;
 /* harmony default export */ const compile_plain = (plain_plain);
 
+;// ./processor/compile/text.ts
+
+// A `_` flanked by word characters can never open or close emphasis under
+// CommonMark's flanking rules, so the escape mdast-util-to-markdown adds to
+// intraword underscores is unnecessary and only produces noisy `\_` diffs.
+// Uses Unicode letter/number classes so non-ASCII words (e.g. `é_pay`) match.
+const INTRAWORD_UNDERSCORE_ESCAPE = /(?<=[\p{L}\p{N}_])\\_(?=[\p{L}\p{N}_]|\\_)/gu;
+const compile_text_text = (node, parent, state, info) => {
+    const serialized = handle.text(node, parent, state, info);
+    return serialized.replace(INTRAWORD_UNDERSCORE_ESCAPE, '_');
+};
+/* harmony default export */ const compile_text = (compile_text_text);
+
 ;// ./processor/compile/index.ts
 
 
@@ -117509,11 +117522,11 @@ const plain_plain = (node) => node.value;
 
 
 
+
 function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
     const handlers = {
-        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
         [enums_NodeTypes.callout]: compile_callout,
         [enums_NodeTypes.codeTabs]: compile_code_tabs,
         [enums_NodeTypes.embedBlock]: compile_embed,
@@ -117521,15 +117534,18 @@ function compilers(mdxish = false) {
         [enums_NodeTypes.glossary]: compile_compatibility,
         [enums_NodeTypes.htmlBlock]: html_block,
         [enums_NodeTypes.reusableContent]: compile_compatibility,
-        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
         embed: compile_compatibility,
         escape: compile_compatibility,
         figure: compile_compatibility,
         html: compile_compatibility,
         i: compile_compatibility,
-        ...(mdxish && { listItem: list_item }),
         plain: compile_plain,
         yaml: compile_compatibility,
+        // needed only for mdxish
+        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
+        ...(mdxish && { listItem: list_item }),
+        ...(mdxish && { text: compile_text }),
+        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
     };
     toMarkdownExtensions.push({ extensions: [{ handlers }] });
 }
@@ -120971,70 +120987,168 @@ const mdxishInlineMdxComponents = () => tree => {
 };
 /* harmony default export */ const inline_mdx_blocks = (mdxishInlineMdxComponents);
 
+;// ./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][^<>]*>(?:[^<]*)$/;
+// A line that is exactly one lowercase opening (or self-closing) tag — the shape
+// that opens a CommonMark type-6/7 HTML block and swallows the lines below it.
+const SINGLE_OPENING_TAG_REGEX = /^<[a-z][^<>]*>$/;
+// Tags whose contents must be preserved as is, inserting a blank line after the
+// opener corrupts the payload.
+// htmlRawNames here refer to <pre>, <textarea>, <script>, <style>
+const RAW_CONTENT_TAGS = [...htmlRawNames, ...HTML_TABLE_STRUCTURE_TAGS];
+// The `(?=[\s/>])` lookahead avoids false matches on lookalike names like `<script-foo>`.
+const RAW_CONTENT_TAG_MATCHERS = RAW_CONTENT_TAGS.map(tag => ({
+    open: new RegExp(`<${tag}(?=[\\s/>])[^>]*?(?<!/)>`, 'gi'),
+    close: new RegExp(`</${tag}(?=[\\s>])[^>]*>`, 'gi'),
+}));
+function isLineHtml(line) {
+    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
+}
+// Per-tag {opens, closes} counts of RAW_CONTENT_TAGS on one line — feeds both the
+// per-line net-open check and the cumulative still-open depth tracking.
+function countRawContentTags(line) {
+    return RAW_CONTENT_TAG_MATCHERS.map(({ open, close }) => ({
+        opens: (line.match(open) ?? []).length,
+        closes: (line.match(close) ?? []).length,
+    }));
+}
+// Indentation width in columns, counting a tab as 4 per CommonMark.
+function indentWidth(line) {
+    const leading = line.match(/^[ \t]*/)?.[0] ?? '';
+    return leading.replace(/\t/g, '    ').length;
+}
+/**
+ * Decides whether a blank line belongs between `line` and `next` so the HTML
+ * flow block opened on `line` terminates and `next` parses as markdown.
+ */
+function shouldTerminateBetween(line, next, { insideRawContent, lineLeavesRawOpen }) {
+    if (next.trim().length === 0)
+        return false;
+    const currentIndent = indentWidth(line);
+    const nextIndent = indentWidth(next);
+    // 4+ columns is CommonMark indented-code territory: an inserted blank line
+    // would turn the next line into a code block instead of freeing it (#1344).
+    if (currentIndent > 3 || nextIndent > 3)
+        return false;
+    const currentTrimmed = line.trim();
+    const nextTrimmed = next.trim();
+    if (!isLineHtml(currentTrimmed) || isLineHtml(nextTrimmed) || lineLeavesRawOpen) {
+        return false;
+    }
+    // Column-0 pairs keep the original (pre-relaxation) rule, deliberately ignoring
+    // `insideRawContent`: one unclosed <pre>/<table> typo would otherwise suppress
+    // termination for the whole rest of the document.
+    if (currentIndent === 0 && nextIndent === 0)
+        return true;
+    // Indented shapes (either line at 1–3 columns) are stricter: only a lone opening
+    // tag followed by markdown. A next line opening a tag or expression must stay
+    // glued for the mdxComponent tokenizer; raw-content payloads stay byte-exact.
+    return (!insideRawContent &&
+        SINGLE_OPENING_TAG_REGEX.test(currentTrimmed) &&
+        !nextTrimmed.startsWith('<') &&
+        !nextTrimmed.startsWith('{'));
+}
+/**
+ * CommonMark HTML blocks (types 6/7) end only at a blank line, so markdown on the
+ * next line is swallowed as HTML (`## heading` after `<div>` renders as literal text).
+ * Inserts the missing blank line; the gating rules live in `shouldTerminateBetween`.
+ *
+ * @link https://spec.commonmark.org/0.29/#html-blocks
+ */
+function terminateHtmlFlowBlocks(content) {
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const lines = protectedContent.split('\n');
+    const result = [];
+    // Per-tag count of still-open raw-content elements at the current boundary.
+    const rawContentDepths = RAW_CONTENT_TAG_MATCHERS.map(() => 0);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        result.push(line);
+        const tagCounts = countRawContentTags(line);
+        tagCounts.forEach(({ opens, closes }, tagIndex) => {
+            rawContentDepths[tagIndex] = Math.max(0, rawContentDepths[tagIndex] + opens - closes);
+        });
+        const next = lines[i + 1];
+        const rawContentFacts = {
+            insideRawContent: rawContentDepths.some(depth => depth > 0),
+            lineLeavesRawOpen: tagCounts.some(({ opens, closes }) => opens > closes),
+        };
+        if (next !== undefined && shouldTerminateBetween(line, next, rawContentFacts)) {
+            result.push('');
+        }
+    }
+    return restoreCodeBlocks(result.join('\n'), protectedCode);
+}
+
 ;// ./processor/transform/mdxish/components/mdx-blocks.ts
 
 
 
 
 
-/** Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
+
+
+// Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
-/**
- * Reduce leading whitespace on all lines just enough to prevent
- * remark from treating indented content as code blocks (4+ spaces).
- * Preserves relative indentation so whitespace text nodes are
- * maintained in the HAST output.
+// Name shape mirrors `componentTagPattern`; the lookbehind skips the inner tag
+// of a legacy `<<VARIABLE>>`.
+const NESTED_COMPONENT_TAG_RE = /(?<!<)<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+// Excludes tags with dedicated transformers (`Table`, `HTMLBlock`, inline
+// components), which expect their wrapper to stay raw.
+const hasNestedGenericComponentTag = (content) => [...content.matchAll(NESTED_COMPONENT_TAG_RE)].some(match => !GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(match[1]));
+/**
+ * Strip the shared leading indentation from a component body so readability indentation
+ * isn't parsed as indented code (4+ spaces), e.g. `  <p>` / `   text` -> `<p>` / ` text`.
+ * Relative indentation is kept, so content genuinely 4+ columns deeper stays code. We
+ * only strip when a line actually reaches 4 columns; otherwise the body is left as-is so
+ * its leading whitespace survives as text nodes (mixed component + HTML content needs it).
  */
 function safeDeindent(text) {
     const lines = text.split('\n');
     const nonEmptyLines = lines.filter(line => line.trim().length > 0);
     if (nonEmptyLines.length === 0)
         return text;
-    const minIndent = Math.min(...nonEmptyLines.map(line => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-    }));
-    // Only strip enough indent to keep all lines below the 4-space code threshold
-    const stripAmount = Math.max(0, minIndent - 3);
+    // Indent counts characters (tab = 1), unlike indentWidth's CommonMark columns
+    // (tab = 4) in terminate-html-flow-blocks.
+    const indents = nonEmptyLines.map(line => line.match(/^(\s*)/)?.[1].length ?? 0);
+    const minIndent = Math.min(...indents);
+    const maxIndent = Math.max(...indents);
+    const stripAmount = maxIndent > 3 ? minIndent : 0;
     if (stripAmount === 0)
         return text;
     return lines.map(line => line.slice(stripAmount)).join('\n');
 }
 /**
- * Parse markdown content into mdast children nodes.
- * Dedents the content first to prevent indented component content
- * (from nested components) from being treated as code blocks.
+ * Parse component-body markdown into mdast children. Dedenting shifts columns and
+ * stales the top-level `terminateHtmlFlowBlocks` decisions, so that one preprocessor
+ * re-runs here; other column-anchored fixups (compact headings, tables) do not.
  */
 const parseMdChildren = (value, safeMode) => {
-    const parsed = getInlineMdProcessor({ safeMode }).parse(safeDeindent(value).trim());
+    const parsed = getInlineMdProcessor({ safeMode }).parse(terminateHtmlFlowBlocks(safeDeindent(value).trim()));
     return parsed.children || [];
 };
-/**
- * Parse substring content of a node and update the parent's children to include the new nodes.
- */
+// Parses trailing content into sibling nodes and re-queues the parent so any
+// components among them get processed.
 const parseSibling = (stack, parent, index, sibling, safeMode) => {
     const siblingNodes = parseMdChildren(sibling, safeMode);
-    // The new sibling nodes might contain new components to be processed
     if (siblingNodes.length > 0) {
         parent.children.splice(index + 1, 0, ...siblingNodes);
         stack.push(parent);
     }
 };
-/**
- * Build a position ending at `consumedLength` into the html node's value, so the
- * component doesn't claim trailing content the tokenizer swallowed into one node.
- */
+// Ends the position at `consumedLength` so the component doesn't claim trailing
+// content the tokenizer swallowed into the same html node.
 const positionEndingAtConsumed = (nodePosition, value, consumedLength) => {
     if (!nodePosition?.start)
         return nodePosition;
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
 };
-/**
- * Build a position ending right after the last occurrence of `closingTag` within
- * this node's span in the original source. Used in the trailing-content path so
- * the offset is computed against the real source bytes (including blockquote/list
- * prefixes that were stripped from the html node's value).
- */
+// Like `positionEndingAtConsumed`, but measures against the original source so
+// blockquote/list prefixes stripped from the html node's value are counted.
 const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) => {
     if (!nodePosition?.start || !nodePosition.end)
         return nodePosition;
@@ -121045,9 +121159,6 @@ const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) =>
     const consumed = nodeSource.slice(0, closingTagOffset + closingTag.length);
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumed) };
 };
-/**
- * Create an MdxJsxFlowElement node from component data.
- */
 const createComponentNode = ({ tag, attributes, children, startPosition, endPosition }) => ({
     type: 'mdxJsxFlowElement',
     name: tag,
@@ -121100,8 +121211,7 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if ('children' in node && Array.isArray(node.children)) {
             stack.push(node);
         }
-        // Only visit HTML nodes with an actual html tag,
-        // which means a potential unparsed MDX component
+        // Only html nodes can be an unparsed MDX component.
         const value = node.value;
         if (node.type !== 'html' || typeof value !== 'string')
             return;
@@ -121110,32 +121220,25 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if (!parsed)
             return;
         const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
-        // Offset of `trimmed` within the (possibly whitespace-padded) html node value,
-        // so consumed-length math maps back onto the node's real source offsets.
+        // Offsets so consumed-length math maps back onto the node's real source.
         const leadingWhitespace = value.length - value.trimStart().length;
-        // Index right after the opening tag's `>` within `trimmed`.
         const openingTagEnd = trimmed.length - contentAfterTag.length;
-        // Skip tags that have dedicated transformers
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
-            return;
+            return; // owned by dedicated transformers
         const isPascal = isPascalCase(tag);
-        // Lowercase inline tags (inside a paragraph) with `{…}` attributes are
-        // promoted to `mdxJsxTextElement` by mdxishInlineComponentBlocks. Skip
-        // them here so they stay as html for that pass; PascalCase components
-        // keep going through this transformer (they stay flow-level even when
-        // inline, which is how ReadMe's custom components are modeled).
+        // Lowercase inline tags with `{…}` attributes belong to
+        // mdxishInlineComponentBlocks; leave them as html for that pass. PascalCase
+        // components stay flow-level even when inline (ReadMe's component model).
         if (!isPascal && parent.type === 'paragraph')
             return;
-        // Lowercase HTML tags are eligible when they (or a descendant tag in their
-        // content, e.g. a `.map()` body returning JSX with `key={i}`) carry a
-        // JSX-expression attribute. Without this, a wrapper `<div>` with only plain
-        // attributes (or none) swallows its whole nested block — including any
-        // `style={{...}}`/`.map()` JSX inside it — as literal HTML text, which
-        // rehype-raw's parse5 pass then garbles (it has no notion of JS expressions).
-        // Plain HTML with no expressions anywhere stays as an html node so
-        // rehype-raw handles it as normal.
+        // A lowercase wrapper is only promoted when it (or a descendant) carries a
+        // JSX expression or nests a component; otherwise it would swallow that inner
+        // JSX/component as literal text that rehype-raw's parse5 pass can't handle.
+        // Table-structural wrappers are excluded — `mdxishTables` re-parses those.
         const hasNestedExpressionAttr = !selfClosing && NESTED_ATTR_EXPRESSION_RE.test(contentAfterTag);
-        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr)
+        const isTableStructuralTag = tag === 'table' || tableTags.has(tag);
+        const hasNestedComponentTag = !selfClosing && !isTableStructuralTag && hasNestedGenericComponentTag(contentAfterTag);
+        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr && !hasNestedComponentTag)
             return;
         const closingTagStr = `</${tag}>`;
         // Case 1: Self-closing tag
@@ -121149,7 +121252,6 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // Check and parse if there's relevant content after the current closing tag
             const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
                 parseSibling(stack, parent, index, remainingContent, safeMode);
@@ -121158,17 +121260,14 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         }
         // Case 2: Self-contained block (closing tag in content)
         if (contentAfterTag.includes(closingTagStr)) {
-            // Find the first closing tag
             const closingTagIndex = contentAfterTag.lastIndexOf(closingTagStr);
-            // Pass raw (untrimmed) content so dedent in parseMdChildren can
-            // normalize indentation before trimming
+            // Untrimmed so parseMdChildren can dedent before trimming.
             const componentInnerContent = contentAfterTag.substring(0, closingTagIndex);
             const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
             let parsedChildren = componentInnerContent.trim()
                 ? parseMdChildren(componentInnerContent, safeMode)
                 : [];
-            // Lowercase HTML tags are usually inline (e.g. <a>, <span>). Remark wraps
-            // bare text in a paragraph; unwrap when there's exactly one paragraph so
+            // Lowercase tags are usually inline; unwrap a sole paragraph so their
             // phrasing content isn't spuriously block-wrapped.
             if (!isPascal && parsedChildren.length === 1 && parsedChildren[0].type === 'paragraph') {
                 parsedChildren = parsedChildren[0].children;
@@ -121178,12 +121277,9 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
-                // When trailing content follows the closing tag, compute the end position precisely
-                // within the html node's value so the component doesn't claim that content.
-                // Prefer source-based positioning when the original source is available: the html
-                // node's value has '> '/space prefixes stripped for blockquotes/list items, so
-                // positionEndingAtConsumed would undercount source offsets. When the entire node
-                // is consumed, use the original node position directly.
+                // With trailing content, end precisely at the closing tag. Prefer source
+                // offsets when available (the node's value strips blockquote/list
+                // prefixes); otherwise fall back to the whole node position.
                 endPosition: contentAfterClose
                     ? source
                         ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
@@ -121191,17 +121287,16 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                     : node.position,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // After the closing tag, there might be more content to be processed
+            // Re-queue whichever side may hold further components.
             if (contentAfterClose) {
                 parseSibling(stack, parent, index, contentAfterClose, safeMode);
             }
             else if (componentNode.children.length > 0) {
-                // The content inside the component block might contain new components to be processed
                 stack.push(componentNode);
             }
         }
     };
-    // Process the nodes with the components depth-first to maintain the correct order of the nodes
+    // Depth-first so nodes keep their source order.
     while (stack.length) {
         const parent = stack.pop();
         if (parent?.children) {
@@ -125452,73 +125547,6 @@ function normalizeTableSeparator(content) {
 }
 /* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
 
-;// ./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][^<>]*>(?:[^<]*)$/;
-// Tags whose contents must be preserved as is, inserting a blank line after the
-// opener corrupts the payload.
-// htmlRawNames here refer to <pre>, <textarea>, <script>, <style>
-const RAW_CONTENT_TAGS = [...htmlRawNames, ...HTML_TABLE_STRUCTURE_TAGS];
-// The `(?=[\s/>])` lookahead avoids false matches on lookalike names like `<script-foo>`.
-const RAW_CONTENT_TAG_MATCHERS = RAW_CONTENT_TAGS.map(tag => ({
-    open: new RegExp(`<${tag}(?=[\\s/>])[^>]*?(?<!/)>`, 'gi'),
-    close: new RegExp(`</${tag}(?=[\\s>])[^>]*>`, 'gi'),
-}));
-function isLineHtml(line) {
-    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
-}
-// True if any RAW_CONTENT_TAGS opener on this line is not closed on the same line.
-function hasUnclosedRawContentOpener(line) {
-    return RAW_CONTENT_TAG_MATCHERS.some(({ open, close }) => {
-        const opens = (line.match(open) ?? []).length;
-        const closes = (line.match(close) ?? []).length;
-        return opens > closes;
-    });
-}
-/**
- * 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 and not an HTML construct, ensuring micromark's HTML flow
- * tokenizer terminates and subsequent content is parsed independently.
- *
- * Conditions:
- * 1. Only non-indented lines with lowercase tag names are considered. Uppercase tags
- *    (e.g. `<Table>`, `<MyComponent>`) are JSX custom components and don't trigger
- *    CommonMark HTML blocks.
- * 2. Lines inside protected blocks (e.g. fenced code) are left untouched.
- * 3. Lines with an unclosed RAW_CONTENT_TAGS opener are exempted.
- */
-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]);
-        // Skip blank & indented lines
-        if (i >= lines.length - 1 || lines[i + 1].trim().length === 0 || lines[i + 1].startsWith(' ') || lines[i + 1].startsWith('\t')) {
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        const isCurrentLineHtml = isLineHtml(lines[i]);
-        const isNextLineHtml = isLineHtml(lines[i + 1]);
-        if (isCurrentLineHtml && !isNextLineHtml && !hasUnclosedRawContentOpener(lines[i])) {
-            result.push('');
-        }
-    }
-    return restoreCodeBlocks(result.join('\n'), protectedCode);
-}
-
 ;// ./processor/transform/mdxish/variables-code.ts
 
 
@@ -126386,6 +126414,12 @@ function mdxishMdastToMd(mdast) {
         .use(remarkStringify, {
         bullet: '-',
         emphasis: '_',
+        // Escape literal braces in text so they don't parse as (often
+        // unterminated) MDX expressions on the next round trip.
+        unsafe: [
+            { character: '{', inConstruct: 'phrasing' },
+            { character: '}', inConstruct: 'phrasing' },
+        ],
     });
     return processor.stringify(processor.runSync(mdast));
 }