@readme/markdown 14.13.0 → 14.13.1

package/dist/main.node.js

@@ -96525,6 +96525,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
@@ -121722,12 +121731,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
@@ -121737,16 +121829,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) {
@@ -121805,6 +121893,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;
@@ -122104,7 +122204,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;
@@ -122149,6 +122249,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);
@@ -122229,7 +122332,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;
@@ -122437,7 +122540,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;
@@ -122463,8 +122566,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.
@@ -122494,6 +122599,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;
             }
@@ -122502,10 +122609,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);
@@ -122526,66 +122641,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.
  *
@@ -122639,6 +122694,7 @@ function mdxComponent() {
 
 
 
+
 
 const buildInlineMdProcessor = (safeMode) => {
     // `jsxTable` must be present so a `<Table>`/`<table>` nested in a component
@@ -122710,7 +122766,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
@@ -123069,15 +123125,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
@@ -123143,16 +123206,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 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.
@@ -123207,7 +123273,7 @@ const 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;
         }
@@ -123234,43 +123300,57 @@ const 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 mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
+    const source = file?.value ? String(file.value) : null;
+    return promoteComponentBlocks(tree, !!opts.safeMode, source);
 };
 /* harmony default export */ const mdx_blocks = (mdxishMdxComponentBlocks);