@readme/markdown 15.6.0 → 15.7.1

package/dist/render-fixture.node.js

@@ -96172,31 +96172,11 @@ const HTML_VOID_ELEMENTS = new Set([
 
 
 /**
- * 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
+ * Partial construct the `mdxComponent` tokenizer runs via `effects.check` to
+ * decide whether the next line continues the block. It lives here (not in
+ * `syntax.ts`) because it holds none of `createTokenize`'s closure state — it
  * 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*`.
@@ -96237,12 +96217,6 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
         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 = {
@@ -96658,14 +96632,7 @@ function syntax_createTokenize(mode) {
         }
         // Continuation for multi-line opening tags
         function openTagContinuationStart(code) {
-            return effects.check(continuation_checks_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
-        }
-        function openTagContinuationNonLazy(code) {
-            sawLineEnding = true;
-            effects.enter(types_types.lineEnding);
-            effects.consume(code);
-            effects.exit(types_types.lineEnding);
-            return openTagContinuationBefore;
+            return continueOnNextLine(code, openTagContinuationBefore);
         }
         function openTagContinuationBefore(code) {
             if (code === null || markdownLineEnding(code)) {
@@ -96783,14 +96750,7 @@ function syntax_createTokenize(mode) {
             return inFencedCode;
         }
         function fencedCodeContinuationStart(code) {
-            return effects.check(continuation_checks_nonLazyContinuationStart, fencedCodeContinuationNonLazy, continuationAfter)(code);
-        }
-        function fencedCodeContinuationNonLazy(code) {
-            sawLineEnding = true;
-            effects.enter(types_types.lineEnding);
-            effects.consume(code);
-            effects.exit(types_types.lineEnding);
-            return fencedCodeContinuationBefore;
+            return continueOnNextLine(code, fencedCodeContinuationBefore);
         }
         function fencedCodeContinuationBefore(code) {
             if (code === null || markdownLineEnding(code)) {
@@ -97007,14 +96967,7 @@ function syntax_createTokenize(mode) {
         }
         // ── Body continuation (line endings) ───────────────────────────────────
         function bodyContinuationStart(code) {
-            return effects.check(continuation_checks_nonLazyContinuationStart, bodyContinuationNonLazy, continuationAfter)(code);
-        }
-        function bodyContinuationNonLazy(code) {
-            sawLineEnding = true;
-            effects.enter(types_types.lineEnding);
-            effects.consume(code);
-            effects.exit(types_types.lineEnding);
-            return bodyContinuationBefore;
+            return continueOnNextLine(code, bodyContinuationBefore);
         }
         function bodyContinuationBefore(code) {
             if (code === null || markdownLineEnding(code)) {
@@ -97083,13 +97036,18 @@ function syntax_createTokenize(mode) {
             pendingBlankLine = false;
             return bodyLineStart(code);
         }
-        // ── Shared lazy continuation failure ───────────────────────────────────
-        function continuationAfter(code) {
-            if (code === null) {
+        // ── Shared line-ending continuation ────────────────────────────────────
+        // Consumes one line ending and resumes at `nextLine`. Lazy lines (under-indented
+        // under a list item or blockquote) continue too: a claim only ends at its closing
+        // tag, and an unclosed one fails whole at EOF instead of leaving a truncated opener (CX-3940).
+        function continueOnNextLine(code, nextLine) {
+            if (!markdownLineEnding(code))
                 return nok(code);
-            }
-            effects.exit('mdxComponent');
-            return ok(code);
+            sawLineEnding = true;
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return nextLine;
         }
     };
 }
@@ -101217,6 +101175,8 @@ const processTableNode = (node, index, parent, documentPosition) => {
         type: 'table',
         position,
         children,
+        // Remember the author's spelling so the serializer can write `<table>` back instead of `<Table>`
+        ...(node.name === 'table' && { data: { lowercaseTable: true } }),
     };
     parent.children[index] = mdNode;
 };
@@ -116819,7 +116779,7 @@ const rehypeToc = ({ components = {} }) => {
         });
     };
 };
-const MAX_DEPTH = 2;
+const MAX_DEPTH = 3;
 /**
  * Get the depth of a heading element based on its tag name.
  *
@@ -123344,7 +123304,7 @@ const parseMdChildren = (value, safeMode) => {
     // 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);
+    promoteComponentBlocks(parsed, safeMode, reparseSource);
     const children = parsed.children || [];
     // These children root a new coordinate space: their offsets index into `reparseSource`.
     stampReparseSource(children, reparseSource);
@@ -123363,23 +123323,26 @@ const parseSibling = (parent, index, sibling, safeMode, promoted) => {
     }
 };
 // 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) => {
+// content the tokenizer swallowed into the same html node. Measured against the source
+// when available: each value line is its source line minus the container prefix
+// (list indent, `> `) micromark stripped, so those prefixes are counted back in.
+const positionEndingAtConsumed = (nodePosition, value, consumedLength, source) => {
     if (!nodePosition?.start)
         return nodePosition;
-    return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
-};
-// 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;
-    const nodeSource = source.slice(nodePosition.start.offset, nodePosition.end.offset);
-    const closingTagOffset = nodeSource.lastIndexOf(closingTag);
-    if (closingTagOffset === -1)
-        return nodePosition;
-    const consumed = nodeSource.slice(0, closingTagOffset + closingTag.length);
-    return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumed) };
+    const consumedValue = value.slice(0, consumedLength);
+    const sourceLines = source?.slice(nodePosition.start.offset, nodePosition.end?.offset).split('\n');
+    const valueLines = value.split('\n');
+    if (!sourceLines || sourceLines.length !== valueLines.length) {
+        return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumedValue) };
+    }
+    const consumedLines = consumedValue.split('\n');
+    const lastLineIndex = consumedLines.length - 1;
+    const prefixWidth = sourceLines[lastLineIndex].length - valueLines[lastLineIndex].length;
+    const consumedSource = [
+        ...sourceLines.slice(0, lastLineIndex),
+        sourceLines[lastLineIndex].slice(0, prefixWidth + consumedLines[lastLineIndex].length),
+    ].join('\n');
+    return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumedSource) };
 };
 const createComponentNode = ({ tag, attributes, children, startPosition, endPosition, }) => ({
     type: 'mdxJsxFlowElement',
@@ -123486,16 +123449,18 @@ function promoteComponentBlocks(tree, safeMode, source) {
         const closingTagStr = `</${tag}>`;
         // Case 1: Self-closing tag
         if (selfClosing) {
+            const remainingContent = contentAfterTag.trim();
             const componentNode = createComponentNode({
                 tag,
                 attributes,
                 children: [],
                 startPosition: node.position,
-                // End at the self-closing tag, not at any trailing content.
-                endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
+                // Without trailing content the whole node position is correct; with it, end at the tag.
+                endPosition: remainingContent
+                    ? positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd, source)
+                    : node.position,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
                 parseSibling(parent, index, remainingContent, safeMode, promoted);
             }
@@ -123534,14 +123499,10 @@ function promoteComponentBlocks(tree, safeMode, source) {
                     stampReparseSource(parsedChildren, soleParagraph.data.reparseSource);
                 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.
+            // Without trailing content the whole node position is correct; with it, end at the closing tag.
             let endPosition = node.position;
             if (contentAfterClose) {
-                endPosition = source
-                    ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
-                    : positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length);
+                endPosition = positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd + closingTagIndex + closingTagStr.length, source);
             }
             const componentNode = createComponentNode({
                 tag,
@@ -127590,13 +127551,22 @@ const mdxishTablesToJsx = () => tree => {
             gfmCells.push([cell, normalized]);
             return undefined;
         });
-        if (!requiresJsxTable) {
+        const stayLowercase = table.data?.lowercaseTable === true;
+        // We transform to GFM tables if:
+        // 1. If it doesn't contain complex elements that the syntax can't represent
+        // 2. The original table is not lowercase HTML <table>, because we want to 
+        // preserve original tables as much as possible
+        if (!requiresJsxTable && !stayLowercase) {
             gfmCells.forEach(([cell, children]) => {
                 cell.children = children;
             });
             table.type = 'table';
             return;
         }
+        // Nothing to build a JSX table from; leave the empty node to the GFM stringifier.
+        const [headerRow, ...bodyRows] = table.children;
+        if (!headerRow)
+            return;
         mdxish_tables_to_jsx_visit(table, mdxish_tables_to_jsx_isTableCell, flattenBreaksToNewlines);
         const styles = table.align.map(mdxish_tables_to_jsx_alignToStyle);
         const head = {
@@ -127608,7 +127578,7 @@ const mdxishTablesToJsx = () => tree => {
                     attributes: [],
                     type: 'mdxJsxFlowElement',
                     name: 'tr',
-                    children: table.children[0].children.map((cell, cellIndex) => {
+                    children: headerRow.children.map((cell, cellIndex) => {
                         return {
                             attributes: [],
                             type: 'mdxJsxFlowElement',
@@ -127624,7 +127594,7 @@ const mdxishTablesToJsx = () => tree => {
             attributes: [],
             type: 'mdxJsxFlowElement',
             name: 'tbody',
-            children: table.children.splice(1).map(row => {
+            children: bodyRows.map(row => {
                 return {
                     attributes: [],
                     type: 'mdxJsxFlowElement',
@@ -127652,8 +127622,8 @@ const mdxishTablesToJsx = () => tree => {
         ];
         const jsx = {
             type: 'mdxJsxFlowElement',
-            name: 'Table',
-            attributes: table.align.find(a => a) ? attributes : [],
+            name: stayLowercase ? 'table' : 'Table',
+            attributes: !stayLowercase && table.align.find(a => a) ? attributes : [],
             children: [head, body],
         };
         parent.children[index] = jsx;