@readme/markdown 14.13.0 → 14.13.2

package/dist/render-fixture.node.js

@@ -92197,6 +92197,10 @@ const tailwindPrefix = 'readme-tailwind';
 
 
 const TailwindRoot = ({ children, flow }) => {
+    // `styles/gfm.scss` spaces the wrapped block children through this element and
+    // relies on their margins collapsing through it. Keep it a plain block — no
+    // border, padding, or block formatting context (overflow, display: flow-root/
+    // flex/grid) — or the spacing breaks.
     const Tag = flow ? 'div' : 'span';
     return external_react_default().createElement(Tag, { className: tailwindPrefix }, children);
 };
@@ -96476,6 +96480,15 @@ 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
@@ -117853,7 +117866,7 @@ function normalizeProperties(node) {
  * Identifies custom MDX components and recursively parses markdown children.
  * Replaces tagName with PascalCase component name for React component resolution.
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  * @param {Options} options - Configuration options
  * @param {CustomComponents} options.components - Available custom components
  * @param {Function} options.processMarkdown - Function to process markdown content
@@ -120253,12 +120266,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
@@ -120268,16 +120364,19 @@ 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,
-};
+const foreignContentTags = new Set(FOREIGN_CONTENT_TAGS);
+// Type-7 lowercase tags (a, span, button, and unknown names): CommonMark ends their
+// block at a blank line, fragmenting 4+ column children into indented code. Claimable
+// only in block-wrapper shape (see `blockWrapperOpenerRest`); lookalike openers
+// (`<https://…>`) never find a closer, so their claim retreats cleanly to CommonMark.
+// Voids never close and raw/foreign-content bodies have dedicated owners.
+const isBlockWrapperClaimTagName = (tag) => !htmlFlowTagNames.has(tag) && !HTML_VOID_ELEMENTS.has(tag) && !foreignContentTags.has(tag);
+// 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) {
@@ -120336,6 +120435,23 @@ function createTokenize(mode) {
         // `plainClaimLineStart`: after a blank line it may only continue on a tag line.
         let isPlainBlockClaim = false;
         let pendingBlankLine = false;
+        // Type-7 tag claimed pending the block-wrapper (opener alone on its line) check.
+        let pendingBlockWrapperClaim = false;
+        // True once a block-wrapper claim is confirmed; relaxes the top-of-body island gate
+        // below (type-7 fallback is the fragmentation bug, not intentional indented code).
+        let isBlockWrapperClaim = 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;
@@ -120569,16 +120685,11 @@ function createTokenize(mode) {
             }
             // End of opening tag
             if (code === codes.greaterThan) {
-                if (requiresBraceAttr && !sawBraceAttr) {
-                    // Plain lowercase block tags stay claimable in flow, gated per line by
-                    // `plainClaimLineStart`; everything else falls through to CommonMark.
-                    if (!isFlow || !plainBlockClaimTagNames.has(tagName))
-                        return nok(code);
-                    isPlainBlockClaim = true;
-                }
+                if (requiresBraceAttr && !sawBraceAttr && !claimBraceLessTag())
+                    return nok(code);
                 effects.consume(code);
                 onOpenerLine = isFlow;
-                return body;
+                return pendingBlockWrapperClaim ? blockWrapperOpenerRest : body;
             }
             // Quoted attribute value
             if (code === codes.quotationMark || code === codes.apostrophe) {
@@ -120633,9 +120744,38 @@ function createTokenize(mode) {
             // `/ ` without `>` is just part of the attribute area
             return afterOpenTagName(code);
         }
+        // Whether a brace-less lowercase flow tag is claimable: type-6 tags immediately,
+        // type-7 tags pending the block-wrapper check; anything else is CommonMark's.
+        function claimBraceLessTag() {
+            if (!isFlow)
+                return false;
+            if (plainBlockClaimTagNames.has(tagName)) {
+                isPlainBlockClaim = true;
+                return true;
+            }
+            if (isBlockWrapperClaimTagName(tagName)) {
+                pendingBlockWrapperClaim = true;
+                return true;
+            }
+            return false;
+        }
+        // A type-7 tag is claimed only as a block wrapper: opener alone on its line
+        // (trailing spaces ok). Inline content after the opener bails to CommonMark.
+        function blockWrapperOpenerRest(code) {
+            if (markdownSpace(code)) {
+                effects.consume(code);
+                return blockWrapperOpenerRest;
+            }
+            if (!markdownLineEnding(code))
+                return nok(code);
+            pendingBlockWrapperClaim = false;
+            isPlainBlockClaim = true;
+            isBlockWrapperClaim = true;
+            return body(code);
+        }
         // 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;
@@ -120680,6 +120820,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);
@@ -120760,7 +120903,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;
@@ -120968,7 +121111,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;
@@ -120994,8 +121137,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.
@@ -121023,8 +121168,16 @@ function createTokenize(mode) {
         // continue on a tag line (`<…`); any markdown island (`**bold**`, `[block:…]`, a
         // fence) refuses so CommonMark html-flow reparses it exactly as it does today.
         function plainClaimLineStart(code) {
-            // Leading whitespace only → treat as a blank line, matching CommonMark.
-            if (code === codes.space || code === codes.horizontalTab) {
+            // Leading whitespace only → treat as a blank line, matching CommonMark. A tab
+            // advances to the next stop; its trailing `virtualSpace` fillers add nothing
+            // but must still be consumed or they'd read as line content below.
+            if (markdownSpace(code)) {
+                if (code === codes.horizontalTab) {
+                    plainClaimIndentColumns += TAB_STOP_WIDTH - (plainClaimIndentColumns % TAB_STOP_WIDTH);
+                }
+                else if (code === codes.space) {
+                    plainClaimIndentColumns += 1;
+                }
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -121033,10 +121186,19 @@ 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).
+                // Block-wrapper claims extend this to top-of-body islands — their CommonMark
+                // fallback is the fragmentation bug, not intentional indented code. Tags whose
+                // bodies stay raw are excluded: a claimed island there would leak as literal text.
+                if (plainClaimIndentColumns >= INDENTED_CODE_MIN_COLUMNS &&
+                    (sawPlainBlockBodyContent || isBlockWrapperClaim) &&
+                    !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);
@@ -121057,66 +121219,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.
  *
@@ -121170,6 +121272,7 @@ function syntax_mdxComponent() {
 
 
 
+
 
 const buildInlineMdProcessor = (safeMode) => {
     // `jsxTable` must be present so a `<Table>`/`<table>` nested in a component
@@ -121241,7 +121344,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
@@ -121600,15 +121703,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
@@ -121674,16 +121784,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.
@@ -121738,7 +121851,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;
         }
@@ -121765,43 +121878,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);
 
@@ -126973,7 +127100,7 @@ function mdxishMdastToMd(mdast) {
  * Processes markdown content with MDX syntax support and returns a HAST.
  * Detects and renders custom component tags from the components hash.
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  */
 function mdxish_mdxish(mdContent, opts = {}) {
     const { components: userComponents = {}, safeMode = false, variables } = opts;
@@ -127257,7 +127384,7 @@ function buildRMDXModule(content, headings, tocHast, opts) {
  * @param opts - The options for the render
  * @returns The React component
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  */
 const renderMdxish = (tree, opts = {}) => {
     const { components: userComponents = {}, variables, ...contextOpts } = opts;