@readme/markdown 14.1.2 → 14.1.4

package/dist/main.js

@@ -71907,7 +71907,7 @@ const hasFlowContent = (nodes) => {
  * a markdown table (phrasing-only) or keep as JSX <Table> (has flow content).
  */
 const processTableNode = (node, index, parent, documentPosition) => {
-    if (node.name !== 'Table')
+    if (node.name !== 'Table' && node.name !== 'table')
         return;
     const position = documentPosition ?? node.position;
     const { align: alignAttr } = getAttrs(node);
@@ -72021,7 +72021,7 @@ const mdxishTables = () => tree => {
         const node = _node;
         if (typeof index !== 'number' || !parent || !('children' in parent))
             return;
-        if (!node.value.startsWith('<Table'))
+        if (!node.value.startsWith('<Table') && !node.value.startsWith('<table'))
             return;
         try {
             const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(node.value));
@@ -72043,13 +72043,10 @@ const mdxishTables = () => tree => {
                 }
             });
             visit(parsed, isMDXElement, (tableNode) => {
-                if (tableNode.name === 'Table') {
-                    processTableNode(tableNode, index, parent, node.position);
-                    // Stop after the outermost Table so nested Tables don't overwrite parent.children[index]
-                    // we let it get handled naturally
-                    return EXIT;
-                }
-                return undefined;
+                if (tableNode.name !== 'Table' && tableNode.name !== 'table')
+                    return undefined;
+                processTableNode(tableNode, index, parent, node.position);
+                return EXIT;
             });
         }
         catch {
@@ -98914,8 +98911,8 @@ const HTML_ELEMENT_BLOCK_RE = /<([a-zA-Z][a-zA-Z0-9-]*)[\s>][\s\S]*?<\/\1>/g;
 const NEWLINE_WITH_WHITESPACE_RE = /[^\S\n]*\n[^\S\n]*/g;
 /** Matches a closing block-level tag followed by non-tag text or by a newline then non-blank content. */
 const CLOSE_BLOCK_TAG_BOUNDARY_RE = /<\/([a-zA-Z][a-zA-Z0-9-]*)>\s*(?:(?!<)(\S)|\n([^\n]))/g;
-/** Tests whether a string contains a complete HTML element (open + close tag). */
-const COMPLETE_HTML_ELEMENT_RE = /<[a-zA-Z][^>]*>[\s\S]*<\/[a-zA-Z]/;
+/** Strips HTML open/close tags. Used to detect non-tag inner text content. */
+const HTML_TAG_STRIP_RE = /<\/?[a-zA-Z][^>]*>/g;
 
 ;// ./processor/transform/mdxish/magic-blocks/placeholder.ts
 const EMPTY_IMAGE_PLACEHOLDER = {
@@ -99155,10 +99152,12 @@ const parseTableCell = (text) => {
     const trimmedLines = normalized.split('\n').map(line => line.trimStart());
     const processed = trimmedLines.join('\n');
     const tree = contentParser.runSync(contentParser.parse(processed));
-    // Process markdown inside complete HTML elements (e.g. _emphasis_ within <li>).
-    // Bare tags like "<i>" are left for rehypeRaw since rehype-parse would mangle them.
+    // Process markdown inside HTML blocks that have non-tag inner text (e.g. `<div>**x**`
+    // or `<ul><li>_x_</li></ul>`). Pure bare tags like "<i>" or "<br>" are left for rehypeRaw
+    // since rehype-parse would mangle them (auto-closing void/inline elements).
     visit(tree, 'html', (node) => {
-        if (COMPLETE_HTML_ELEMENT_RE.test(node.value)) {
+        const hasInnerText = node.value.replace(HTML_TAG_STRIP_RE, '').trim().length > 0;
+        if (hasInnerText) {
             node.value = processMarkdownInHtmlString(node.value);
         }
         else {
@@ -99481,11 +99480,17 @@ const blockTypes = [
  * Check if a node is a block-level node (cannot be inside a paragraph)
  */
 const isBlockNode = (node) => blockTypes.includes(node.type);
+const isParagraph = (node) => node.type === 'paragraph';
+/**
+ * True for phrasing content that contributes only whitespace at render time
+ * (a soft `break` node or a text node with no non-whitespace characters).
+ */
+const isWhitespacePhrasing = (node) => node.type === 'break' || (node.type === 'text' && !node.value.trim());
 /**
  * Unified plugin that transforms magicBlock nodes into final MDAST nodes.
  */
 const magicBlockTransformer = (options = {}) => tree => {
-    const replacements = [];
+    const lifts = [];
     visitParents(tree, 'magicBlock', (node, ancestors) => {
         const parent = ancestors[ancestors.length - 1]; // direct parent of the current node
         const index = parent.children.indexOf(node);
@@ -99499,51 +99504,60 @@ const magicBlockTransformer = (options = {}) => tree => {
             parent.children.splice(index, 1);
             return;
         }
-        // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs), lift them out
-        if (parent.type === 'paragraph' && children.some(child => isBlockNode(child))) {
+        // If parent is a paragraph and we're inserting block nodes (which must not be in paragraphs)
+        // it means we need to lift them out
+        if (isParagraph(parent) && children.some(isBlockNode)) {
             const blockNodes = [];
-            const inlineNodes = [];
             children.forEach(child => {
-                (isBlockNode(child) ? blockNodes : inlineNodes).push(child);
+                if (isBlockNode(child)) {
+                    blockNodes.push(child);
+                }
             });
-            replacements.push({
-                container: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+            lifts.push({
+                childrenBlockNodes: blockNodes,
+                grandparent: ancestors[ancestors.length - 2] || tree, // grandparent of the current node
+                node,
                 parent,
-                blockNodes,
-                inlineNodes,
-                before: parent.children.slice(0, index),
-                after: parent.children.slice(index + 1),
             });
         }
         else {
             parent.children.splice(index, 1, ...children);
         }
     });
-    // Second pass: apply replacements that require lifting block nodes out of paragraphs
-    // Process in reverse order to maintain correct indices
-    for (let i = replacements.length - 1; i >= 0; i -= 1) {
-        const { after, before, blockNodes, container, inlineNodes, parent } = replacements[i];
-        const containerChildren = container.children;
-        const paraIndex = containerChildren.indexOf(parent);
-        if (paraIndex === -1) {
-            parent.children.splice(before.length, 1, ...blockNodes, ...inlineNodes);
+    // Second pass: apply lifts that move block nodes, and the content after them, out of paragraphs.
+    // Operate on live state (find each node's current index now) and process in reverse so
+    // that container insertions don't disturb earlier paragraphs' positions.
+    for (let i = lifts.length - 1; i >= 0; i -= 1) {
+        const { childrenBlockNodes: blockNodes, grandparent, node, parent: parentParagraph } = lifts[i];
+        const nodePosition = parentParagraph.children.indexOf(node);
+        const parentPosition = grandparent.children.indexOf(parentParagraph);
+        if (nodePosition === -1 || parentPosition === -1) {
             // eslint-disable-next-line no-continue
             continue;
         }
-        if (inlineNodes.length > 0) {
-            parent.children = [...before, ...inlineNodes, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
-        }
-        else if (before.length === 0 && after.length === 0) {
-            containerChildren.splice(paraIndex, 1, ...blockNodes);
+        // Snapshot live siblings to reconstruct the parent paragraph around the lifted node.
+        const parentSiblingsBefore = parentParagraph.children.slice(0, nodePosition);
+        const parentSiblingsAfter = parentParagraph.children.slice(nodePosition + 1);
+        // Remove split-edge whitespace so lifted blocks do not render with extra blank lines.
+        while (parentSiblingsBefore.length > 0 && isWhitespacePhrasing(parentSiblingsBefore[parentSiblingsBefore.length - 1]))
+            parentSiblingsBefore.pop();
+        while (parentSiblingsAfter.length > 0 && isWhitespacePhrasing(parentSiblingsAfter[0]))
+            parentSiblingsAfter.shift();
+        const splitOffContentFromParent = [...blockNodes];
+        if (parentSiblingsAfter.length > 0) {
+            // Keep trailing inline content grouped under a paragraph sibling as it might be an inline node
+            // Even if it contains a block node, it will be hoisted out during its turn in the loop
+            const trailingParagraph = { type: 'paragraph', children: parentSiblingsAfter };
+            splitOffContentFromParent.push(trailingParagraph);
+        }
+        parentParagraph.children = [...parentSiblingsBefore];
+        // If the parent paragraph is empty, just replace it with the lifted block nodes
+        const shouldReplaceParent = parentParagraph.children.length === 0;
+        if (shouldReplaceParent) {
+            grandparent.children.splice(parentPosition, 1, ...splitOffContentFromParent);
         }
         else {
-            parent.children = [...before, ...after];
-            if (blockNodes.length > 0) {
-                containerChildren.splice(paraIndex + 1, 0, ...blockNodes);
-            }
+            grandparent.children.splice(parentPosition + 1, 0, ...splitOffContentFromParent);
         }
     }
 };
@@ -99613,29 +99627,56 @@ function protectHTMLBlockContent(content) {
 function removeJSXComments(content) {
     return content.replace(JSX_COMMENT_REGEX, '');
 }
+const HTML_ELEM_PLACEHOLDER_PREFIX = '___MDXISH_HTML_ELEM_';
+const HTML_ELEM_PLACEHOLDER = new RegExp(`${HTML_ELEM_PLACEHOLDER_PREFIX}(\\d+)___`, 'g');
+// Matches an HTML element that starts at a line boundary and ends at a line boundary.
+// Allows optional leading indentation and lazily matches until the same closing tag.
+const BLOCK_HTML_RE = /(?<=^|\n)[ \t]*<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>[ \t]*(?=\n|$)/g;
 /**
- * Escapes problematic braces in content to prevent MDX expression parsing errors.
- * Handles unbalanced braces and paragraph-spanning expressions. Skips HTML elements
- * so backslashes don't leak into rendered output via rehypeRaw.
+ * Hides line-anchored HTML elements from the brace-escaping pass so we don't leak `\{`
+ * into rendered output (rehypeRaw renders the `\` literally, e.g. `<div>{foo</div>`).
+ *
+ * One carve-out: if an interior line at column 0 has bare text containing `{`, mdxish
+ * parses that line as a paragraph and the mdxExpression step would throw without an
+ * escape — so we leave that case to the brace balancer.
  */
-function escapeProblematicBraces(content) {
-    // Skip HTML elements — their content should never be escaped because
-    // rehypeRaw parses them into hast elements, making `\` literal text in output
+function protectHTMLElements(content) {
     const htmlElements = [];
-    const safe = content.replace(/<([a-z][a-zA-Z0-9]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, match => {
-        const idx = htmlElements.length;
+    const protectedContent = content.replace(BLOCK_HTML_RE, match => {
+        // Look at the lines between the open and close tags. If any of them starts
+        // at column 0 with bare text (not whitespace, not another tag) and contains
+        // `{`, mdxish will parse that line as a paragraph and the brace as an MDX
+        // expression, which would throw an error. So we let the brace balancer escape it.
+        // Otherwise, we need to extract the sequence to protect it from the brace escaping.
+        const interior = match.split('\n').slice(1, -1);
+        const hazard = interior.some(line => line.length > 0 && line[0] !== ' ' && line[0] !== '\t' && line[0] !== '<' && line.includes('{'));
+        if (hazard)
+            return match;
         htmlElements.push(match);
-        return `___HTML_ELEM_${idx}___`;
+        return `${HTML_ELEM_PLACEHOLDER_PREFIX}${htmlElements.length - 1}___`;
     });
-    const toEscape = new Set();
-    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
-    const chars = Array.from(safe);
+    return { htmlElements, protectedContent };
+}
+function restoreHTMLElements(content, htmlElements) {
+    if (htmlElements.length === 0)
+        return content;
+    return content.replace(HTML_ELEM_PLACEHOLDER, (_m, idx) => htmlElements[parseInt(idx, 10)]);
+}
+/**
+ * Escapes unbalanced and paragraph-spanning braces so MDX doesn't trip on them.
+ */
+function escapeProblematicBraces(content) {
+    const { htmlElements, protectedContent } = protectHTMLElements(content);
     let strDelim = null;
     let strEscaped = false;
-    // Stack of open braces with their state
-    const openStack = [];
     // Track position of last newline (outside strings) to detect blank lines
-    let lastNewlinePos = -2; // -2 means no recent newline
+    // -2 means no recent newline
+    let lastNewlinePos = -2;
+    // Character state machine trackers
+    const toEscape = new Set();
+    // Convert to array of Unicode code points so that emojis and multi-byte characters are correctly tracked
+    const chars = Array.from(protectedContent);
+    const openStack = [];
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
         // Track string delimiters inside expressions to ignore braces within them
@@ -99655,22 +99696,17 @@ function escapeProblematicBraces(content) {
                 // eslint-disable-next-line no-continue
                 continue;
             }
-            // Track newlines to detect blank lines (paragraph boundaries)
             if (ch === '\n') {
-                // Check if this newline creates a blank line (only whitespace since last newline)
                 if (lastNewlinePos >= 0) {
                     const between = chars.slice(lastNewlinePos + 1, i).join('');
                     if (/^[ \t]*$/.test(between)) {
-                        // This is a blank line - mark all open expressions as paragraph-spanning
-                        openStack.forEach(entry => {
-                            entry.hasBlankLine = true;
-                        });
+                        openStack.forEach(entry => { entry.hasBlankLine = true; });
                     }
                 }
                 lastNewlinePos = i;
             }
         }
-        // Skip already-escaped braces (count preceding backslashes)
+        // Skip already-escaped braces (odd run of preceding backslashes).
         if (ch === '{' || ch === '}') {
             let bs = 0;
             for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
@@ -99681,10 +99717,9 @@ function escapeProblematicBraces(content) {
             }
         }
         if (ch === '{') {
-            // If preceded by `=` (ignoring whitespace), this is a JSX attribute
-            // expression (e.g. `data={[...]}`). The mdxComponent tokenizer captures
-            // the entire component block, so blank lines inside attribute values
-            // won't split paragraphs — skip the blank-line check for these.
+            // `=` (after whitespace) before `{` ⇒ JSX attribute expression. The
+            // mdxComponent tokenizer captures the whole component, so blank lines
+            // inside attribute values are harmless. Nested `{` inherits the flag.
             let isAttrExpr = false;
             for (let j = i - 1; j >= 0; j -= 1) {
                 const pc = chars[j];
@@ -99698,27 +99733,17 @@ function escapeProblematicBraces(content) {
             // Nested `{ ... }` inside an attribute value (e.g. `data={[{ ... }]}` or
             // `data={{ a: { b: 1 } }}`) must inherit the same exemption; only the
             // outer `{` is directly after `=`.
-            if (!isAttrExpr && openStack.length > 0) {
-                const parent = openStack[openStack.length - 1];
-                if (parent.isAttrExpr) {
-                    isAttrExpr = true;
-                }
+            if (!isAttrExpr && openStack.length > 0 && openStack[openStack.length - 1].isAttrExpr) {
+                isAttrExpr = true;
             }
             openStack.push({ pos: i, hasBlankLine: false, isAttrExpr });
-            lastNewlinePos = -2; // Reset newline tracking for new expression
+            lastNewlinePos = -2;
         }
         else if (ch === '}') {
             if (openStack.length > 0) {
                 const entry = openStack.pop();
-                // Don't escape pure JSX comments, the `jsxComment` tokenizer downstream
-                // already knows how to swallow a whole `{/* ... */}` block in one go,
-                // even if the body has blank lines in it. If we escape the braces here
-                // the tokenizer never gets a shot at it.
-                //
-                // "Pure" means the braces open with `{/*` and close with `*/}` right
-                // next to each other. Something like `{/* c */ expr\n\nmore}` is just
-                // a regular expression that happens to start with a comment, so it
-                // still needs the normal blank-line protection.
+                // Pure `{/* ... */}` comments are handled downstream by the jsxComment
+                // tokenizer — escaping their braces would prevent it from running.
                 const isPureJsxComment = chars[entry.pos + 1] === '/' &&
                     chars[entry.pos + 2] === '*' &&
                     chars[i - 1] === '/' &&
@@ -99729,21 +99754,15 @@ function escapeProblematicBraces(content) {
                 }
             }
             else {
-                // Unbalanced closing brace (no matching open)
                 toEscape.add(i);
             }
         }
     }
-    // Any remaining open braces are unbalanced
+    // Anything still open is unbalanced.
     openStack.forEach(entry => toEscape.add(entry.pos));
-    // If there are no problematic braces, return safe content as-is;
-    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
-    let result = toEscape.size === 0 ? safe : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
-    // Restore HTML elements
-    if (htmlElements.length > 0) {
-        result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
-    }
-    return result;
+    // Reconstruct the content with the escaped braces.
+    const escapedContent = toEscape.size === 0 ? protectedContent : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
+    return restoreHTMLElements(escapedContent, htmlElements);
 }
 /**
  * Preprocesses JSX-like markdown content before parsing.
@@ -101527,8 +101546,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     let codeSpanOpenSize = 0;
     let codeSpanCloseSize = 0;
     let depth = 1;
-    const TABLE_NAME = [codes.uppercaseT, codes.lowercaseA, codes.lowercaseB, codes.lowercaseL, codes.lowercaseE];
-    const ABLE_SUFFIX = TABLE_NAME.slice(1);
+    const ABLE_SUFFIX = [codes.lowercaseA, codes.lowercaseB, codes.lowercaseL, codes.lowercaseE];
     /** Build a state chain that matches a sequence of character codes. */
     function matchChars(chars, onMatch, onFail) {
         if (chars.length === 0)
@@ -101548,7 +101566,14 @@ function tokenizeJsxTable(effects, ok, nok) {
         effects.enter('jsxTable');
         effects.enter('jsxTableData');
         effects.consume(code);
-        return matchChars(TABLE_NAME, afterTagName, nok);
+        return afterLessThan;
+    }
+    function afterLessThan(code) {
+        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+            effects.consume(code);
+            return matchChars(ABLE_SUFFIX, afterTagName, nok);
+        }
+        return nok(code);
     }
     function afterTagName(code) {
         if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
@@ -101620,14 +101645,21 @@ function tokenizeJsxTable(effects, ok, nok) {
     function closeSlash(code) {
         if (code === codes.slash) {
             effects.consume(code);
-            return matchChars(TABLE_NAME, closeGt, body);
+            return closeTagFirstChar;
         }
-        if (code === codes.uppercaseT) {
+        if (code === codes.uppercaseT || code === codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, openAfterTagName, body);
         }
         return body(code);
     }
+    function closeTagFirstChar(code) {
+        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+            effects.consume(code);
+            return matchChars(ABLE_SUFFIX, closeGt, body);
+        }
+        return body(code);
+    }
     function openAfterTagName(code) {
         if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
             depth += 1;
@@ -101703,10 +101735,10 @@ function jsx_table_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
     }
 }
 /**
- * Micromark extension that tokenizes `<Table>...</Table>` as a single flow block.
+ * Micromark extension that tokenizes `<Table>...</Table>` and `<table>...</table>`
+ * as a single flow block.
  *
- * Prevents CommonMark HTML block type 6 from matching `<Table>` (case-insensitive
- * match against `table`) and fragmenting it at blank lines.
+ * Prevents CommonMark HTML block type 6 from fragmenting table blocks at blank lines.
  */
 function jsxTable() {
     return {