@readme/markdown 13.1.3 → 13.2.0

package/dist/main.js

@@ -70954,13 +70954,15 @@ const scanForClosingTag = (parent, startIndex, tag) => {
             if (isClosingTag(siblingValue, tag)) {
                 return { closingIndex: i, extraClosingChildren: [] };
             }
-            // Embedded closing tag (closing tag at end of HTML block content)
+            // Embedded closing tag (closing tag within HTML block content)
             if (siblingValue.includes(closingTagStr)) {
-                const contentBeforeClose = siblingValue.substring(0, siblingValue.lastIndexOf(closingTagStr)).trim();
+                const closeTagPos = siblingValue.indexOf(closingTagStr);
+                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
+                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
                 const extraChildren = contentBeforeClose
                     ? parseMdChildren(contentBeforeClose)
                     : [];
-                return { closingIndex: i, extraClosingChildren: extraChildren };
+                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
             }
         }
         // Check paragraph siblings
@@ -71105,7 +71107,7 @@ const mdxishComponentBlocks = () => tree => {
         const scanResult = scanForClosingTag(parent, index, tag);
         if (!scanResult)
             return;
-        const { closingIndex, extraClosingChildren, strippedParagraph } = scanResult;
+        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
         const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
         // Collect all intermediate siblings between opening tag and closing tag
         const intermediateChildren = parent.children.slice(index + 1, closingIndex);
@@ -71128,6 +71130,11 @@ const mdxishComponentBlocks = () => tree => {
         if (componentNode.children.length > 0) {
             stack.push(componentNode);
         }
+        // If the closing tag sibling had content after it (e.g., another component opening tag),
+        // re-insert it as a sibling so it can be processed in subsequent iterations
+        if (remainingAfterClose) {
+            parseSibling(stack, parent, index, remainingAfterClose);
+        }
     };
     // Process the nodes with the components depth-first to maintain the correct order of the nodes
     while (stack.length) {
@@ -93444,7 +93451,7 @@ function isActualHtmlTag(tagName, originalExcerpt) {
     return false;
 }
 /** Parse and replace text children with processed markdown */
-function parseTextChildren(node, processMarkdown) {
+function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
         return;
     // First pass: Recursively process text children as they may contain stringified markdown / mdx content
@@ -93459,6 +93466,27 @@ function parseTextChildren(node, processMarkdown) {
         }
         return children;
     });
+    // Unwrap <p> elements whose meaningful children are ALL components.
+    // The markdown parser wraps inline content in <p> tags, but when that content
+    // is actually component children (e.g., <Tab> inside <Tabs>), the wrapper
+    // should be removed so components appear as direct children.
+    // Only unwrap when every non-whitespace, non-br child is a known component
+    // to avoid breaking paragraphs with mixed content (text + inline HTML like <code>).
+    node.children = node.children.flatMap(child => {
+        if (child.type !== 'element' || child.tagName !== 'p')
+            return [child];
+        const meaningfulChildren = child.children.filter(gc => {
+            if (gc.type === 'text' && !gc.value.trim())
+                return false;
+            if (gc.type === 'element' && gc.tagName === 'br')
+                return false;
+            return true;
+        });
+        const allComponents = meaningfulChildren.length > 0 && meaningfulChildren.every(gc => gc.type === 'element' && getComponentName(gc.tagName, components));
+        if (!allComponents)
+            return [child];
+        return meaningfulChildren;
+    });
     // Post-processing: remove whitespace-only text nodes if all siblings are components
     // This prevents whitespace between component children from being counted as extra children
     if (areAllChildrenComponents(node.children)) {
@@ -93513,7 +93541,7 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             }
             node.tagName = componentName;
             normalizeProperties(node);
-            parseTextChildren(node, processMarkdown);
+            parseTextChildren(node, processMarkdown, components);
         });
         // Remove unknown components in reverse order to preserve indices
         for (let i = nodesToRemove.length - 1; i >= 0; i -= 1) {
@@ -93814,8 +93842,10 @@ function escapeUnbalancedBraces(content) {
     const unbalanced = new Set();
     let strDelim = null;
     let strEscaped = false;
-    for (let i = 0; i < content.length; i += 1) {
-        const ch = content[i];
+    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
+    const chars = Array.from(content);
+    for (let i = 0; i < chars.length; i += 1) {
+        const ch = chars[i];
         // Track strings inside expressions to ignore braces within them
         if (opens.length > 0) {
             if (strDelim) {
@@ -93837,7 +93867,7 @@ function escapeUnbalancedBraces(content) {
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
             let bs = 0;
-            for (let j = i - 1; j >= 0 && content[j] === '\\'; j -= 1)
+            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
                 bs += 1;
             if (bs % 2 === 1) {
                 // eslint-disable-next-line no-continue
@@ -93856,7 +93886,7 @@ function escapeUnbalancedBraces(content) {
     opens.forEach(pos => unbalanced.add(pos));
     if (unbalanced.size === 0)
         return content;
-    return Array.from(content)
+    return chars
         .map((ch, i) => (unbalanced.has(i) ? `\\${ch}` : ch))
         .join('');
 }
@@ -94001,9 +94031,12 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
         }
         catch (_error) {
             // If evaluation fails, leave the expression as-is (fallback to text)
+            // we still need to manually escape escaped characters because the expression
+            // parser treats the contents as code instead of text, skipping the backslash escapes
+            const processed = expression.replace(/\\([!-/:-@[-`{-~])/g, '$1');
             parent.children.splice(index, 1, {
                 type: 'text',
-                value: `{${expression}}`,
+                value: `{${processed}}`,
                 position: node.position,
             });
         }
@@ -94096,11 +94129,11 @@ const MARKER_PATTERNS = [
 // trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
 const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
 // Pattern for __ bold __
-const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:[^_\n]|_(?!_))+?)(\s*)\2|((?:[^_\n]|_(?!_))+?)(\s+)\2)(\S|$)?/g;
+const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n])+?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n])+?)(\s+)\2)(\S|$)?/g;
 // Pattern for * italic *
 const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
 // Pattern for _ italic _
-const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+([^_\n]+?)(\s*)\2|([^_\n]+?)(\s+)\2)(\S|$)?/g;
+const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+((?:[^_\n]|_(?! ))+?)(\s*)\2|((?:[^_\n]|_(?! ))+?)(\s+)\2)(\S|$)?/g;
 // CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
 // Pattern for intraword _word_ in words like hello_world_
 const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
@@ -95824,6 +95857,9 @@ const restoreBooleanProperties = () => tree => {
 
 const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
 const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
+function isLineHtml(line) {
+    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
+}
 /**
  * Preprocessor to terminate HTML flow blocks.
  *
@@ -95835,14 +95871,14 @@ const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/
  * @link https://spec.commonmark.org/0.29/#html-blocks
  *
  * This preprocessor inserts a blank line after standalone HTML lines when the
- * next line is non-blank, ensuring micromark's HTML flow tokenizer terminates
- * and subsequent content is parsed independently.
+ * next line is non-blank and not an HTML construct (because they still might be part of the HTML flow),
+ * ensuring micromark's HTML flow tokenizer terminates and subsequent content is parsed independently.
  *
- * Only targets non-indented lines with lowercase tag names. Uppercase tags
+ * Conditions:
+ * 1. Only targets non-indented lines with lowercase tag names. Uppercase tags
  * (e.g., `<Table>`, `<MyComponent>`) are JSX custom components and don't
  * trigger CommonMark HTML blocks, so they are left untouched.
- *
- * Lines inside fenced code blocks are skipped entirely.
+ * 2. Lines inside protected blocks (e.g., code blocks) should be left untouched.
  */
 function terminateHtmlFlowBlocks(content) {
     const { protectedContent, protectedCode } = protectCodeBlocks(content);
@@ -95850,9 +95886,14 @@ function terminateHtmlFlowBlocks(content) {
     const result = [];
     for (let i = 0; i < lines.length; i += 1) {
         result.push(lines[i]);
-        if (i < lines.length - 1 &&
-            (STANDALONE_HTML_LINE_REGEX.test(lines[i]) || HTML_LINE_WITH_CONTENT_REGEX.test(lines[i])) &&
-            lines[i + 1].trim().length > 0) {
+        // Skip blank & indented lines
+        if (i >= lines.length - 1 || lines[i + 1].trim().length === 0 || lines[i + 1].startsWith(' ') || lines[i + 1].startsWith('\t')) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const isCurrentLineHtml = isLineHtml(lines[i]);
+        const isNextLineHtml = isLineHtml(lines[i + 1]);
+        if (isCurrentLineHtml && !isNextLineHtml) {
             result.push('');
         }
     }
@@ -97836,7 +97877,8 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
     if (mdxish) {
         processor
             .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()]);
+            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()])
+            .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor
         .use(remarkParse)
@@ -97861,9 +97903,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 // Our markdown renderer uses this to group these code blocks into a tabbed interface.
                 (left, right) => {
                     if (left.type === 'code' && right.type === 'code') {
-                        const isTight = left.position &&
-                            right.position &&
-                            right.position.start.line - left.position.end.line === 1; // Are the blocks on adjacent lines?
+                        const isTight = left.position && right.position && right.position.start.line - left.position.end.line === 1; // Are the blocks on adjacent lines?
                         // 0 = no newline between blocks
                         return isTight ? 0 : undefined;
                     }

package/dist/main.node.js

@@ -91158,13 +91158,15 @@ const scanForClosingTag = (parent, startIndex, tag) => {
             if (isClosingTag(siblingValue, tag)) {
                 return { closingIndex: i, extraClosingChildren: [] };
             }
-            // Embedded closing tag (closing tag at end of HTML block content)
+            // Embedded closing tag (closing tag within HTML block content)
             if (siblingValue.includes(closingTagStr)) {
-                const contentBeforeClose = siblingValue.substring(0, siblingValue.lastIndexOf(closingTagStr)).trim();
+                const closeTagPos = siblingValue.indexOf(closingTagStr);
+                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
+                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
                 const extraChildren = contentBeforeClose
                     ? parseMdChildren(contentBeforeClose)
                     : [];
-                return { closingIndex: i, extraClosingChildren: extraChildren };
+                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
             }
         }
         // Check paragraph siblings
@@ -91309,7 +91311,7 @@ const mdxishComponentBlocks = () => tree => {
         const scanResult = scanForClosingTag(parent, index, tag);
         if (!scanResult)
             return;
-        const { closingIndex, extraClosingChildren, strippedParagraph } = scanResult;
+        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
         const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
         // Collect all intermediate siblings between opening tag and closing tag
         const intermediateChildren = parent.children.slice(index + 1, closingIndex);
@@ -91332,6 +91334,11 @@ const mdxishComponentBlocks = () => tree => {
         if (componentNode.children.length > 0) {
             stack.push(componentNode);
         }
+        // If the closing tag sibling had content after it (e.g., another component opening tag),
+        // re-insert it as a sibling so it can be processed in subsequent iterations
+        if (remainingAfterClose) {
+            parseSibling(stack, parent, index, remainingAfterClose);
+        }
     };
     // Process the nodes with the components depth-first to maintain the correct order of the nodes
     while (stack.length) {
@@ -113648,7 +113655,7 @@ function isActualHtmlTag(tagName, originalExcerpt) {
     return false;
 }
 /** Parse and replace text children with processed markdown */
-function parseTextChildren(node, processMarkdown) {
+function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
         return;
     // First pass: Recursively process text children as they may contain stringified markdown / mdx content
@@ -113663,6 +113670,27 @@ function parseTextChildren(node, processMarkdown) {
         }
         return children;
     });
+    // Unwrap <p> elements whose meaningful children are ALL components.
+    // The markdown parser wraps inline content in <p> tags, but when that content
+    // is actually component children (e.g., <Tab> inside <Tabs>), the wrapper
+    // should be removed so components appear as direct children.
+    // Only unwrap when every non-whitespace, non-br child is a known component
+    // to avoid breaking paragraphs with mixed content (text + inline HTML like <code>).
+    node.children = node.children.flatMap(child => {
+        if (child.type !== 'element' || child.tagName !== 'p')
+            return [child];
+        const meaningfulChildren = child.children.filter(gc => {
+            if (gc.type === 'text' && !gc.value.trim())
+                return false;
+            if (gc.type === 'element' && gc.tagName === 'br')
+                return false;
+            return true;
+        });
+        const allComponents = meaningfulChildren.length > 0 && meaningfulChildren.every(gc => gc.type === 'element' && getComponentName(gc.tagName, components));
+        if (!allComponents)
+            return [child];
+        return meaningfulChildren;
+    });
     // Post-processing: remove whitespace-only text nodes if all siblings are components
     // This prevents whitespace between component children from being counted as extra children
     if (areAllChildrenComponents(node.children)) {
@@ -113717,7 +113745,7 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             }
             node.tagName = componentName;
             normalizeProperties(node);
-            parseTextChildren(node, processMarkdown);
+            parseTextChildren(node, processMarkdown, components);
         });
         // Remove unknown components in reverse order to preserve indices
         for (let i = nodesToRemove.length - 1; i >= 0; i -= 1) {
@@ -114018,8 +114046,10 @@ function escapeUnbalancedBraces(content) {
     const unbalanced = new Set();
     let strDelim = null;
     let strEscaped = false;
-    for (let i = 0; i < content.length; i += 1) {
-        const ch = content[i];
+    // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
+    const chars = Array.from(content);
+    for (let i = 0; i < chars.length; i += 1) {
+        const ch = chars[i];
         // Track strings inside expressions to ignore braces within them
         if (opens.length > 0) {
             if (strDelim) {
@@ -114041,7 +114071,7 @@ function escapeUnbalancedBraces(content) {
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
             let bs = 0;
-            for (let j = i - 1; j >= 0 && content[j] === '\\'; j -= 1)
+            for (let j = i - 1; j >= 0 && chars[j] === '\\'; j -= 1)
                 bs += 1;
             if (bs % 2 === 1) {
                 // eslint-disable-next-line no-continue
@@ -114060,7 +114090,7 @@ function escapeUnbalancedBraces(content) {
     opens.forEach(pos => unbalanced.add(pos));
     if (unbalanced.size === 0)
         return content;
-    return Array.from(content)
+    return chars
         .map((ch, i) => (unbalanced.has(i) ? `\\${ch}` : ch))
         .join('');
 }
@@ -114205,9 +114235,12 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
         }
         catch (_error) {
             // If evaluation fails, leave the expression as-is (fallback to text)
+            // we still need to manually escape escaped characters because the expression
+            // parser treats the contents as code instead of text, skipping the backslash escapes
+            const processed = expression.replace(/\\([!-/:-@[-`{-~])/g, '$1');
             parent.children.splice(index, 1, {
                 type: 'text',
-                value: `{${expression}}`,
+                value: `{${processed}}`,
                 position: node.position,
             });
         }
@@ -114300,11 +114333,11 @@ const MARKER_PATTERNS = [
 // trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
 const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
 // Pattern for __ bold __
-const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:[^_\n]|_(?!_))+?)(\s*)\2|((?:[^_\n]|_(?!_))+?)(\s+)\2)(\S|$)?/g;
+const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n])+?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n])+?)(\s+)\2)(\S|$)?/g;
 // Pattern for * italic *
 const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
 // Pattern for _ italic _
-const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+([^_\n]+?)(\s*)\2|([^_\n]+?)(\s+)\2)(\S|$)?/g;
+const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+((?:[^_\n]|_(?! ))+?)(\s*)\2|((?:[^_\n]|_(?! ))+?)(\s+)\2)(\S|$)?/g;
 // CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
 // Pattern for intraword _word_ in words like hello_world_
 const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
@@ -116028,6 +116061,9 @@ const restoreBooleanProperties = () => tree => {
 
 const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
 const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
+function isLineHtml(line) {
+    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
+}
 /**
  * Preprocessor to terminate HTML flow blocks.
  *
@@ -116039,14 +116075,14 @@ const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/
  * @link https://spec.commonmark.org/0.29/#html-blocks
  *
  * This preprocessor inserts a blank line after standalone HTML lines when the
- * next line is non-blank, ensuring micromark's HTML flow tokenizer terminates
- * and subsequent content is parsed independently.
+ * next line is non-blank and not an HTML construct (because they still might be part of the HTML flow),
+ * ensuring micromark's HTML flow tokenizer terminates and subsequent content is parsed independently.
  *
- * Only targets non-indented lines with lowercase tag names. Uppercase tags
+ * Conditions:
+ * 1. Only targets non-indented lines with lowercase tag names. Uppercase tags
  * (e.g., `<Table>`, `<MyComponent>`) are JSX custom components and don't
  * trigger CommonMark HTML blocks, so they are left untouched.
- *
- * Lines inside fenced code blocks are skipped entirely.
+ * 2. Lines inside protected blocks (e.g., code blocks) should be left untouched.
  */
 function terminateHtmlFlowBlocks(content) {
     const { protectedContent, protectedCode } = protectCodeBlocks(content);
@@ -116054,9 +116090,14 @@ function terminateHtmlFlowBlocks(content) {
     const result = [];
     for (let i = 0; i < lines.length; i += 1) {
         result.push(lines[i]);
-        if (i < lines.length - 1 &&
-            (STANDALONE_HTML_LINE_REGEX.test(lines[i]) || HTML_LINE_WITH_CONTENT_REGEX.test(lines[i])) &&
-            lines[i + 1].trim().length > 0) {
+        // Skip blank & indented lines
+        if (i >= lines.length - 1 || lines[i + 1].trim().length === 0 || lines[i + 1].startsWith(' ') || lines[i + 1].startsWith('\t')) {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        const isCurrentLineHtml = isLineHtml(lines[i]);
+        const isNextLineHtml = isLineHtml(lines[i + 1]);
+        if (isCurrentLineHtml && !isNextLineHtml) {
             result.push('');
         }
     }
@@ -118040,7 +118081,8 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
     if (mdxish) {
         processor
             .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()]);
+            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()])
+            .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor
         .use(remarkParse)
@@ -118065,9 +118107,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
                 // Our markdown renderer uses this to group these code blocks into a tabbed interface.
                 (left, right) => {
                     if (left.type === 'code' && right.type === 'code') {
-                        const isTight = left.position &&
-                            right.position &&
-                            right.position.start.line - left.position.end.line === 1; // Are the blocks on adjacent lines?
+                        const isTight = left.position && right.position && right.position.start.line - left.position.end.line === 1; // Are the blocks on adjacent lines?
                         // 0 = no newline between blocks
                         return isTight ? 0 : undefined;
                     }