@readme/markdown 14.12.1 → 14.13.1

package/dist/render-fixture.node.js

@@ -86449,8 +86449,8 @@ function Anchor(props) {
 
 
 
-const Card = ({ badge, children, href, kind = 'card', icon, iconColor, target, title }) => {
-    const Tag = href ? 'a' : 'div';
+const Card = ({ badge, children, href, kind = 'card', icon, iconColor, LinkComponent = 'a', target, title, }) => {
+    const Tag = href ? LinkComponent : 'div';
     return (external_react_default().createElement(Tag, { className: `Card Card_${kind}`, href: href, target: target },
         icon && external_react_default().createElement(components_Icon, { className: "Card-icon", icon: icon, iconColor: iconColor }),
         external_react_default().createElement("div", { className: "Card-content" },
@@ -96476,6 +96476,21 @@ const HTML_TABLE_STRUCTURE_TAGS = new Set([
     'caption',
     'colgroup',
 ]);
+/**
+ * Tags whose bodies a later mdxish transform keeps raw and never re-parses as
+ * markdown. Both layers depend on this property, not on the tags being figures:
+ * the transformer treats them as non-promotable, and the tokenizer must not claim
+ * markdown islands inside them (a claimed island would never be re-parsed and would
+ * leak as literal text). Currently just the figure tags, whose bodies are owned by
+ * the figure reassembly transform (`mdxishJsxToMdast`).
+ */
+const NON_REPARSED_BODY_TAGS = new Set(['figure', 'figcaption']);
+/**
+ * The two HTML "foreign content" namespaces: SVG and MathML. Their descendants
+ * (`<path>`, `<mrow>`, …) are namespaced XML, not HTML tags or components. A closed
+ * set per the HTML spec, so transforms can treat these roots as opaque islands.
+ */
+const FOREIGN_CONTENT_TAGS = ['svg', 'math'];
 /**
  * HTML void elements — elements that have no closing tag and no children.
  *
@@ -117685,6 +117700,9 @@ function getComponentName(componentName, components) {
 
 
 
+// Foreign-content (SVG/MathML) roots — subtrees the component transform leaves
+// untouched (their children are namespaced XML, not HTML tags/components).
+const FOREIGN_CONTENT_ROOTS = new Set(FOREIGN_CONTENT_TAGS);
 function isElementContentNode(node) {
     return node.type === 'element' || node.type === 'text' || node.type === 'comment';
 }
@@ -117860,6 +117878,12 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
         lib_visit(tree, 'element', (node, index, parent) => {
             if (index === undefined || !parent)
                 return;
+            // Skip foreign-content subtrees: their namespaced children (<path>, <mrow>, …)
+            // aren't HTML tags or components, so the "unknown component" removal below would
+            // otherwise delete them. (svg/math themselves are standard HTML tags, kept.)
+            // eslint-disable-next-line consistent-return
+            if (FOREIGN_CONTENT_ROOTS.has(node.tagName))
+                return lib_SKIP;
             // Parse Image caption as markdown so it renders formatted (bold, code,
             // decoded entities) in the figcaption instead of as a raw string.
             // rehypeRaw strips children from <img> (void element), so we must
@@ -118171,6 +118195,81 @@ function closeSelfClosingHtmlTags(content) {
     return restoreCodeBlocks(result, protectedCode);
 }
 
+;// ./processor/transform/mdxish/collapse-foreign-content-blank-lines.ts
+
+
+// `svg|math`, from the canonical list so this stays in sync with the component transform.
+const ROOT_ALT = FOREIGN_CONTENT_TAGS.join('|');
+// A foreign-content opener. The `[\s/>]` boundary requires a real tag delimiter after the
+// root name, so lookalikes like `<svgfoo>` and custom elements like `<svg-icon>` are ignored.
+const ANY_ROOT_RE = new RegExp(`<(?:${ROOT_ALT})(?=[\\s/>])`, 'i');
+// Tag body: swallows whole quoted attribute values so a `>` inside a quote (e.g.
+// `<svg data-x="a > b" />`) can't be mistaken for the tag terminator; other non-`>`
+// chars (including newlines) are consumed one at a time.
+const TAG_BODY = '(?:"[^"]*"|\'[^\']*\'|[^>\'"])*?';
+// One whole svg/math tag (opener, self-closer, or closer), matched whole so attributes
+// and `>` may span lines. The `[\s/>]` boundary after the root name keeps `<svgfoo>`/
+// `<svg-icon>` out. Group 1 is `/` only for a self-closer.
+const FOREIGN_TAG_RE = new RegExp(`<(?:${ROOT_ALT})(?=[\\s/>])${TAG_BODY}(/)?>|</(?:${ROOT_ALT})(?=[\\s/>])${TAG_BODY}>`, 'gi');
+// An HTML comment. Foreign markup inside one is inert and must not open an island.
+const HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+const withinAny = (spans, offset) => spans.some(([start, end]) => offset >= start && offset < end);
+/**
+ * `[start, end)` spans of every *matched* SVG/MathML pair — the regions whose blank
+ * lines are known-insignificant XML. Matching whole tags (not per-line open/close
+ * counts) keeps multi-line openers and self-closers balanced, so a wrapped
+ * `<svg … />` can't latch and swallow the doc (#1545).
+ *
+ * Tags are paired innermost-first, as a parser would; an opener still unpaired at EOF
+ * closed nothing and so covers nothing. That keeps a stray `<svg>` in prose from
+ * swallowing every blank line after it, without hiding the real islands that follow.
+ */
+function findForeignContentSpans(text) {
+    const spans = [];
+    // Foreign tags inside an HTML comment are inert; a stray `<svg>`/`<math>` in a comment
+    // must not open an island and latch onto the rest of the doc.
+    const comments = [...text.matchAll(HTML_COMMENT_RE)].map((m) => [m.index ?? 0, (m.index ?? 0) + m[0].length]);
+    // Offsets of openers still waiting for their closer, innermost last.
+    const openOffsets = [];
+    [...text.matchAll(FOREIGN_TAG_RE)].forEach(match => {
+        const offset = match.index ?? 0;
+        if (withinAny(comments, offset))
+            return; // markup inside an HTML comment is inert
+        if (match[1] === '/')
+            return; // self-closing tag opens no island
+        if (match[0].startsWith('</')) {
+            const start = openOffsets.pop();
+            if (start !== undefined)
+                spans.push([start, offset + match[0].length]); // a closer with no opener closes nothing
+        }
+        else {
+            openOffsets.push(offset);
+        }
+    });
+    return spans;
+}
+/**
+ * Drop blank lines inside `<svg>`/`<math>` islands: their whitespace is
+ * insignificant XML, but a blank line ends the CommonMark HTML block and spills the
+ * children out as a code block (#1545). Collapsing keeps the island one block.
+ */
+function collapseForeignContentBlankLines(content) {
+    // Fast path: nothing to do when the doc has no foreign-content island.
+    if (!ANY_ROOT_RE.test(content))
+        return content;
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const islands = findForeignContentSpans(protectedContent);
+    // Drop blank lines inside an island; keep everything else verbatim.
+    const lines = [];
+    let lineStart = 0;
+    protectedContent.split('\n').forEach(line => {
+        if (line.trim().length > 0 || !withinAny(islands, lineStart))
+            lines.push(line);
+        lineStart += line.length + 1; // +1 for the '\n' that split() removed
+    });
+    return restoreCodeBlocks(lines.join('\n'), protectedCode);
+}
+
 ;// ./lib/utils/mdxish/mdxish-component-tag-parser.ts
 // Extract the tag name (PascalCase or lowercase HTML) at the start of a tag string.
 const tagNamePattern = /^<([A-Za-z][A-Za-z0-9_-]*)/;
@@ -120163,12 +120262,95 @@ function tokenizeMagicBlockText(effects, ok, nok) {
  */
 
 
+;// ./lib/micromark/mdx-component/continuation-checks.ts
+
+
+/**
+ * Partial constructs the `mdxComponent` tokenizer runs via `effects.check` to
+ * decide whether the next line continues the block. They live here (not in
+ * `syntax.ts`) because they hold none of `createTokenize`'s closure state — each
+ * is a self-contained, single-line lookahead.
+ */
+function continuation_checks_tokenizeNonLazyContinuationStart(effects, ok, nok) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    return start;
+    function start(code) {
+        if (markdownLineEnding(code)) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return after;
+        }
+        return nok(code);
+    }
+    function after(code) {
+        if (self.parser.lazy[self.now().line]) {
+            return nok(code);
+        }
+        return ok(code);
+    }
+}
+// A markup-only line opens with a tag (`<x`/`</x`) and ends (ignoring trailing
+// spaces) at a `>`. That distinguishes a structural continuation like
+// `<span>b</span></div>` from a paragraph like `<b>Note:</b> read *this*`.
+function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
+    let lastNonSpace = null;
+    return start;
+    function start(code) {
+        // Caller guarantees we are at `<` at the (already de-indented) line start.
+        effects.enter(types_types.data);
+        effects.consume(code);
+        return afterLessThan;
+    }
+    function afterLessThan(code) {
+        if (code === codes.slash) {
+            effects.consume(code);
+            return afterSlash;
+        }
+        return afterSlash(code);
+    }
+    // The `<` (or `</`) must introduce a real tag, not a stray `<` in prose.
+    function afterSlash(code) {
+        if (asciiAlpha(code)) {
+            lastNonSpace = code;
+            effects.consume(code);
+            return scanToLineEnd;
+        }
+        effects.exit(types_types.data);
+        return nok(code);
+    }
+    function scanToLineEnd(code) {
+        if (code === null || markdownLineEnding(code)) {
+            effects.exit(types_types.data);
+            return lastNonSpace === codes.greaterThan ? ok(code) : nok(code);
+        }
+        if (!markdownSpace(code))
+            lastNonSpace = code;
+        effects.consume(code);
+        return scanToLineEnd;
+    }
+}
+// A line ending whose next line isn't a lazy paragraph continuation. Checked so a
+// component body's blank/continuation lines aren't stolen by an interrupted paragraph.
+const continuation_checks_nonLazyContinuationStart = {
+    tokenize: continuation_checks_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+// Lookahead for `plainClaimLineStart`: is this line markup-only, or a paragraph
+// that merely starts with a tag? Run via `effects.check` so it never consumes.
+const markupOnlyContinuation = {
+    tokenize: tokenizeMarkupOnlyContinuation,
+    partial: true,
+};
+
 ;// ./lib/micromark/mdx-component/syntax.ts
 
 
 
 
 
+
 // Raw tags (type-1: pre/script/style/textarea) and block tags (type-6: div,
 // section, …) always start a block, so they stay flow even with trailing
 // content. Other lowercase tags (i, span, …) follow the type-7 rule and only
@@ -120178,16 +120360,12 @@ const htmlFlowTagNames = new Set([...htmlRawNames, ...htmlBlockNames]);
 // blank lines between nested JSX siblings don't fragment the block. Excludes table
 // tags (mdxishTables owns their blank lines) and voids (never close).
 const plainBlockClaimTagNames = new Set([...htmlBlockNames].filter(tag => !HTML_TABLE_STRUCTURE_TAGS.has(tag) && !HTML_VOID_ELEMENTS.has(tag)));
-const mdx_component_syntax_nonLazyContinuationStart = {
-    tokenize: mdx_component_syntax_tokenizeNonLazyContinuationStart,
-    partial: true,
-};
-// Lookahead for `plainClaimLineStart`: is this line markup-only, or a paragraph
-// that merely starts with a tag? Run via `effects.check` so it never consumes.
-const markupOnlyContinuation = {
-    tokenize: tokenizeMarkupOnlyContinuation,
-    partial: true,
-};
+// Both are 4 columns per CommonMark, but they mean different things: a tab advances
+// to the next multiple of TAB_STOP_WIDTH, and INDENTED_CODE_MIN_COLUMNS is the depth
+// at which a line would fragment into indented code. Named separately so the two
+// concepts don't read as one incidental literal.
+const TAB_STOP_WIDTH = 4;
+const INDENTED_CODE_MIN_COLUMNS = 4;
 function resolveToMdxComponent(events) {
     let index = events.length;
     while (index > 0) {
@@ -120246,6 +120424,18 @@ function createTokenize(mode) {
         // `plainClaimLineStart`: after a blank line it may only continue on a tag line.
         let isPlainBlockClaim = false;
         let pendingBlankLine = false;
+        // Leading indent columns of the current plain-claim line, reset per line; ≥4 is
+        // where CommonMark would fragment the island as indented code. Tabs advance to the
+        // next 4-column stop — the same rule `expandIndentToColumns`
+        // (processor/transform/mdxish/indentation.ts) applies, kept in sync by hand since
+        // this side works on a `Code` stream, not a string. NB: do NOT swap this for
+        // `self.now().column`; micromark bumps the point column by 1 per `horizontalTab`
+        // code (the trailing `virtualSpace` codes don't move it), so it measures a tab as
+        // 1 column, reviving the tab-under-measurement bug this math exists to avoid.
+        let plainClaimIndentColumns = 0;
+        // True once a non-blank line follows the opener: a deep island below it is nested
+        // (cosmetic indent), not top-of-body indented code.
+        let sawPlainBlockBodyContent = false;
         // Code span tracking
         let codeSpanOpenSize = 0;
         let codeSpanCloseSize = 0;
@@ -120545,7 +120735,7 @@ function createTokenize(mode) {
         }
         // Continuation for multi-line opening tags
         function openTagContinuationStart(code) {
-            return effects.check(mdx_component_syntax_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
+            return effects.check(continuation_checks_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
         }
         function openTagContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120590,6 +120780,9 @@ function createTokenize(mode) {
             }
             if (code !== codes.space && code !== codes.horizontalTab) {
                 openerLineHasContent = true;
+                // Continuation content marks a later deep island as nested, not indented code.
+                if (!onOpenerLine)
+                    sawPlainBlockBodyContent = true;
             }
             if (code === codes.backslash) {
                 effects.consume(code);
@@ -120670,7 +120863,7 @@ function createTokenize(mode) {
             return inFencedCode;
         }
         function fencedCodeContinuationStart(code) {
-            return effects.check(mdx_component_syntax_nonLazyContinuationStart, fencedCodeContinuationNonLazy, continuationAfter)(code);
+            return effects.check(continuation_checks_nonLazyContinuationStart, fencedCodeContinuationNonLazy, continuationAfter)(code);
         }
         function fencedCodeContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120878,7 +121071,7 @@ function createTokenize(mode) {
         }
         // ── Body continuation (line endings) ───────────────────────────────────
         function bodyContinuationStart(code) {
-            return effects.check(mdx_component_syntax_nonLazyContinuationStart, bodyContinuationNonLazy, continuationAfter)(code);
+            return effects.check(continuation_checks_nonLazyContinuationStart, bodyContinuationNonLazy, continuationAfter)(code);
         }
         function bodyContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120904,8 +121097,10 @@ function createTokenize(mode) {
                     return inBodyBraceString(code);
                 return inBodyBraceExpr(code);
             }
-            if (isPlainBlockClaim)
+            if (isPlainBlockClaim) {
+                plainClaimIndentColumns = 0;
                 return plainClaimLineStart(code);
+            }
             return bodyLineStart(code);
         }
         // Dispatch a non-blank continuation line: fenced code at line start, else body.
@@ -120935,6 +121130,8 @@ function createTokenize(mode) {
         function plainClaimLineStart(code) {
             // Leading whitespace only → treat as a blank line, matching CommonMark.
             if (code === codes.space || code === codes.horizontalTab) {
+                plainClaimIndentColumns +=
+                    code === codes.horizontalTab ? TAB_STOP_WIDTH - (plainClaimIndentColumns % TAB_STOP_WIDTH) : 1;
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -120943,10 +121140,18 @@ function createTokenize(mode) {
                 effects.exit('mdxComponentData');
                 return bodyContinuationStart(code);
             }
-            // Across a blank line the block only continues onto a markup-only line; a
-            // paragraph that merely starts with a tag must fall back so its markdown
-            // parses and rehype-raw re-nests it into the wrapper.
             if (pendingBlankLine) {
+                // A 4+ col island nested under other tags is cosmetic nesting indent, not code:
+                // keep claiming so promotion dedents + re-parses it as markdown (RM-17560).
+                // Tags whose bodies stay raw are excluded — a claimed island there would never
+                // be re-parsed and would leak as literal text.
+                if (plainClaimIndentColumns >= INDENTED_CODE_MIN_COLUMNS &&
+                    sawPlainBlockBodyContent &&
+                    !NON_REPARSED_BODY_TAGS.has(tagName)) {
+                    return plainClaimContinue(code);
+                }
+                // Otherwise only a markup-only tag line continues; markdown/prose falls back to
+                // CommonMark so it parses and rehype-raw re-nests it into the wrapper.
                 if (code !== codes.lessThan)
                     return nok(code);
                 return effects.check(markupOnlyContinuation, plainClaimContinue, nok)(code);
@@ -120967,66 +121172,6 @@ function createTokenize(mode) {
         }
     };
 }
-function mdx_component_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this;
-    return start;
-    function start(code) {
-        if (markdownLineEnding(code)) {
-            effects.enter(types_types.lineEnding);
-            effects.consume(code);
-            effects.exit(types_types.lineEnding);
-            return after;
-        }
-        return nok(code);
-    }
-    function after(code) {
-        if (self.parser.lazy[self.now().line]) {
-            return nok(code);
-        }
-        return ok(code);
-    }
-}
-// A markup-only line opens with a tag (`<x`/`</x`) and ends (ignoring trailing
-// spaces) at a `>`. That distinguishes a structural continuation like
-// `<span>b</span></div>` from a paragraph like `<b>Note:</b> read *this*`.
-function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
-    let lastNonSpace = null;
-    return start;
-    function start(code) {
-        // Caller guarantees we are at `<` at the (already de-indented) line start.
-        effects.enter(types_types.data);
-        effects.consume(code);
-        return afterLessThan;
-    }
-    function afterLessThan(code) {
-        if (code === codes.slash) {
-            effects.consume(code);
-            return afterSlash;
-        }
-        return afterSlash(code);
-    }
-    // The `<` (or `</`) must introduce a real tag, not a stray `<` in prose.
-    function afterSlash(code) {
-        if (asciiAlpha(code)) {
-            lastNonSpace = code;
-            effects.consume(code);
-            return scanToLineEnd;
-        }
-        effects.exit(types_types.data);
-        return nok(code);
-    }
-    function scanToLineEnd(code) {
-        if (code === null || markdownLineEnding(code)) {
-            effects.exit(types_types.data);
-            return lastNonSpace === codes.greaterThan ? ok(code) : nok(code);
-        }
-        if (!markdownSpace(code))
-            lastNonSpace = code;
-        effects.consume(code);
-        return scanToLineEnd;
-    }
-}
 /**
  * Micromark extension that tokenizes MDX-like components.
  *
@@ -121080,6 +121225,7 @@ function syntax_mdxComponent() {
 
 
 
+
 
 const buildInlineMdProcessor = (safeMode) => {
     // `jsxTable` must be present so a `<Table>`/`<table>` nested in a component
@@ -121151,7 +121297,7 @@ const toMdxJsxTextElement = (name, attributes, children, position) => ({
 // Raw-body tags (pre/script/style/textarea) must stay byte-exact; table
 // structure (`table` + `tableTags`) is owned by `mdxishTables` and figures by
 // `mdxishJsxToMdast`, both of which run later on raw html nodes.
-const NON_PROMOTABLE_PLAIN_TAGS = new Set([...htmlRawNames, ...tableTags, 'table', 'figure', 'figcaption']);
+const NON_PROMOTABLE_PLAIN_TAGS = new Set([...htmlRawNames, ...tableTags, 'table', ...NON_REPARSED_BODY_TAGS]);
 const NESTED_TABLE_RE = /<table[\s>]/i;
 const isMarkdownPromotableHtmlTag = (tag) => !NON_PROMOTABLE_PLAIN_TAGS.has(tag);
 // Expression nodes count as plain so `<div>{1+1}</div>` keeps its current
@@ -121510,15 +121656,22 @@ function safeDeindent(text) {
  */
 const parseMdChildren = (value, safeMode) => {
     const parsed = getInlineMdProcessor({ safeMode }).parse(terminateHtmlFlowBlocks(safeDeindent(value).trim()));
+    // Promote nested wrappers bottom-up so an outer wrapper sees markdown buried in a
+    // child claimed whole (e.g. `<li>` in `<ol>`) before its containsMarkdownConstruct check (RM-17560).
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- mutually recursive; hoisted decl, safe at runtime
+    promoteComponentBlocks(parsed, safeMode, null);
     return parsed.children || [];
 };
-// 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) => {
+// Splices trailing content in as sibling nodes. parseMdChildren has already
+// promoted any components nested among them (bottom-up); the main loop's
+// index-based walk then reaches these spliced siblings and the original children
+// they shift down, so no parent re-queue is needed. Each spliced subtree is marked
+// `promoted` so the walk doesn't redundantly re-descend into it (its html is gone).
+const parseSibling = (parent, index, sibling, safeMode, promoted) => {
     const siblingNodes = parseMdChildren(sibling, safeMode);
     if (siblingNodes.length > 0) {
         parent.children.splice(index + 1, 0, ...siblingNodes);
-        stack.push(parent);
+        siblingNodes.forEach(siblingNode => promoted.add(siblingNode));
     }
 };
 // Ends the position at `consumedLength` so the component doesn't claim trailing
@@ -121584,16 +121737,19 @@ const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
  * The opening tag, content, and closing tag are all captured in one HTML node
  * (guaranteed by the mdx-component tokenizer).
  */
-const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
+function promoteComponentBlocks(tree, safeMode, source) {
     const stack = [tree];
-    const safeMode = !!opts.safeMode;
-    const source = file?.value ? String(file.value) : null;
     const parseOpts = { preserveExpressionsAsText: safeMode };
+    // Subtrees a nested parseMdChildren already promoted wholesale (spliced siblings):
+    // re-descending them finds no html to promote, so skip them.
+    const promoted = new WeakSet();
     const processChildNode = (parent, index) => {
         const node = parent.children[index];
         if (!node)
             return;
-        if ('children' in node && Array.isArray(node.children)) {
+        // Descend into container nodes (lists, blockquotes, …) so their html children
+        // are reached — unless the subtree was already promoted upstream.
+        if ('children' in node && Array.isArray(node.children) && !promoted.has(node)) {
             stack.push(node);
         }
         // Only html nodes can be an unparsed MDX component.
@@ -121648,7 +121804,7 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
             substituteNodeWithMdxNode(parent, index, componentNode);
             const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
-                parseSibling(stack, parent, index, remainingContent, safeMode);
+                parseSibling(parent, index, remainingContent, safeMode, promoted);
             }
             return;
         }
@@ -121675,43 +121831,57 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 return;
             // Lowercase tags are usually inline; unwrap a sole paragraph so their
             // phrasing content isn't spuriously block-wrapped.
+            let unwrappedSoleParagraph = false;
             if (!isPascal && parsedChildren.length === 1 && parsedChildren[0].type === 'paragraph') {
                 parsedChildren = parsedChildren[0].children;
+                unwrappedSoleParagraph = true;
+            }
+            // Without trailing content the whole node position is correct. With it, end
+            // precisely at the closing tag — preferring source offsets when available (the
+            // node's value strips blockquote/list prefixes), else the consumed span.
+            let endPosition = node.position;
+            if (contentAfterClose) {
+                endPosition = source
+                    ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
+                    : positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length);
             }
             const componentNode = createComponentNode({
                 tag,
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
-                // 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)
-                        : positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length)
-                    : node.position,
+                endPosition,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // Re-queue whichever side may hold further components.
-            if (contentAfterClose) {
-                parseSibling(stack, parent, index, contentAfterClose, safeMode);
-            }
-            else if (componentNode.children.length > 0) {
+            // The unwrap reparented the children out of their paragraph, so re-walk them
+            // since the children HTML may contain promotable syntax (e.g. `{…}`-attr tags)
+            if (unwrappedSoleParagraph) {
                 stack.push(componentNode);
             }
+            // Trailing content after the close becomes siblings; parseMdChildren has
+            // already promoted any components nested inside both sides, so the promoted
+            // subtree itself needs no re-queue.
+            if (contentAfterClose) {
+                parseSibling(parent, index, contentAfterClose, safeMode, promoted);
+            }
         }
     };
-    // Depth-first so nodes keep their source order.
+    // Depth-first so nodes keep their source order. Index-based (not forEach) and
+    // re-reading length each step: parseSibling splices siblings in mid-iteration, and
+    // those — plus the original children they shift down — must all stay eligible.
     while (stack.length) {
         const parent = stack.pop();
         if (parent?.children) {
-            parent.children.forEach((_child, index) => {
+            for (let index = 0; index < parent.children.length; index += 1) {
                 processChildNode(parent, index);
-            });
+            }
         }
     }
     return tree;
+}
+const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
+    const source = file?.value ? String(file.value) : null;
+    return promoteComponentBlocks(tree, !!opts.safeMode, source);
 };
 /* harmony default export */ const mdx_blocks = (mdx_blocks_mdxishMdxComponentBlocks);
 
@@ -126728,6 +126898,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -126742,10 +126913,11 @@ const defaultTransformers = [
  * Runs a series of string-level transformations before micromark/remark parsing:
  * 1. Canonicalize closing tags with stray whitespace (e.g., `</ td >` → `</td>`)
  * 2. Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
- * 3. Terminate HTML flow blocks so subsequent content isn't swallowed
- * 4. Close invalid "self-closing" HTML tags (e.g., `<i />` → `<i></i>`)
- * 5. Normalize compact ATX headings (e.g., `#Heading` → `# Heading`)
- * 6. Replace snake_case component names with parser-safe placeholders
+ * 3. Collapse blank lines inside `<svg>`/`<math>` so their children aren't fragmented
+ * 4. Terminate HTML flow blocks so subsequent content isn't swallowed
+ * 5. Close invalid "self-closing" HTML tags (e.g., `<i />` → `<i></i>`)
+ * 6. Normalize compact ATX headings (e.g., `#Heading` → `# Heading`)
+ * 7. Replace snake_case component names with parser-safe placeholders
  */
 function preprocessContent(content, opts) {
     const { knownComponents } = opts;
@@ -126753,6 +126925,10 @@ function preprocessContent(content, opts) {
     // classification in `terminateHtmlFlowBlocks` is accurate)
     let result = normalizeClosingTagWhitespace(content);
     result = normalizeTableSeparator(result);
+    // Before terminateHtmlFlowBlocks: a blank line inside an <svg>/<math> island
+    // would otherwise fragment it (children spill out as an indented code block once
+    // a wrapper re-parses its deindented body — #1545).
+    result = collapseForeignContentBlankLines(result);
     result = terminateHtmlFlowBlocks(result);
     result = closeSelfClosingHtmlTags(result);
     result = normalizeCompactHeadings(result);
@@ -127368,6 +127544,8 @@ const mdxishTags_tags = (doc) => {
 
 
 
+
+
 /**
  * Removes Markdown and MDX comments.
  */
@@ -127378,10 +127556,16 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
     // 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
     // 3. we need to claim <HTMLBlock> before htmlFlow intercepts its inner HTML tags
+    // 4. we need mdxComponent to parse custom components as one node, and prevent the tag from getting escaped
     if (mdxish) {
         processor
-            .data('micromarkExtensions', [htmlBlockComponent(), jsxTable(), mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [htmlBlockComponentFromMarkdown(), jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
+            .data('micromarkExtensions', [htmlBlockComponent(), jsxTable(), mdxComponent(), mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [
+            htmlBlockComponentFromMarkdown(),
+            jsxTableFromMarkdown(),
+            mdxComponentFromMarkdown(),
+            mdxExpressionFromMarkdown(),
+        ])
             .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor