@readme/markdown 13.5.0 → 13.6.0

package/dist/main.js

@@ -41028,6 +41028,7 @@ function remarkMdx(options) {
 ;// ./enums.ts
 var NodeTypes;
 (function (NodeTypes) {
+    NodeTypes["anchor"] = "readme-anchor";
     NodeTypes["callout"] = "rdme-callout";
     NodeTypes["codeTabs"] = "code-tabs";
     NodeTypes["embedBlock"] = "embed-block";
@@ -53041,6 +53042,13 @@ const extractText = (node) => {
 
 
 
+
+
+
+
+
+const titleParser = unified().use(remarkParse).use(remarkGfm);
+const toMarkdownExtensions = [gfmStrikethroughToMarkdown()];
 const callouts_regex = `^(${emoji_regex().source}|⚠)(\\s+|$)`;
 const findFirst = (node) => {
     if ('children' in node)
@@ -53157,31 +53165,65 @@ const processBlockquote = (node, index, parent) => {
         // Example: "> ⚠️ **Bold heading**\nBody text here"
         const bodyChildren = splitParagraphAtNewline(firstParagraph);
         const didSplit = bodyChildren !== null;
-        // Extract heading text after removing the icon prefix.
-        // Use `plain()` to handle complex markdown structures (bold, inline code, etc.)
-        const headingText = lib_plain(firstParagraph)
-            .toString()
-            .slice(match.length);
-        // Clean up the raw AST by removing the icon prefix from the first text node
         removeIconPrefix(firstParagraph, match.length);
-        const empty = !headingText.length && firstParagraph.children.length === 1;
+        const firstText = findFirst(firstParagraph);
+        const rawValue = firstText?.value ?? '';
+        const hasContent = rawValue.trim().length > 0 || firstParagraph.children.length > 1;
+        const empty = !hasContent;
         const theme = themes[icon] || 'default';
-        // Convert the first paragraph (first children of node) to a heading if it has content or was split
-        if (headingText || didSplit) {
-            node.children[0] = wrapHeading(node);
-            // Adjust position to account for the stripped icon prefix
-            node.children[0].position.start.offset += match.length;
-            node.children[0].position.start.column += match.length;
+        if (hasContent || didSplit) {
+            const headingMatch = rawValue.match(/^(#{1,6})\s*/);
+            // # heading syntax is handled via direct AST manipulation so we can
+            // set the depth while preserving the original inline children (bold, etc.)
+            if (headingMatch) {
+                firstText.value = rawValue.slice(headingMatch[0].length);
+                const heading = wrapHeading(node);
+                heading.depth = headingMatch[1].length;
+                node.children[0] = heading;
+                node.children[0].position.start.offset += match.length;
+                node.children[0].position.start.column += match.length;
+            }
+            else {
+                const headingText = toMarkdown({ type: 'root', children: [firstParagraph] }, {
+                    extensions: toMarkdownExtensions,
+                })
+                    .trim()
+                    .replace(/^\\(?=[>#+\-*])/, '');
+                const parsedTitle = titleParser.parse(headingText);
+                const parsedFirstChild = parsedTitle.children[0];
+                // Block-level syntax ("> quote", "- list") produces non-paragraph nodes;
+                // inline text parses as a paragraph and falls through to wrapHeading().
+                if (parsedFirstChild && parsedFirstChild.type !== 'paragraph') {
+                    // Strip positions from re-parsed nodes since they're relative to the heading text, not the original source
+                    visit(parsedTitle, (n) => {
+                        delete n.position;
+                    });
+                    const heading = wrapHeading(node);
+                    heading.children = parsedTitle.children;
+                    delete heading.position;
+                    node.children[0] = heading;
+                }
+                else {
+                    node.children[0] = wrapHeading(node);
+                    node.children[0].position.start.offset += match.length;
+                    node.children[0].position.start.column += match.length;
+                }
+            }
         }
         // Insert body content as a separate paragraph after the heading
         if (bodyChildren) {
+            const headingPosition = node.children[0].position;
             node.children.splice(1, 0, {
                 type: 'paragraph',
                 children: bodyChildren,
-                position: {
-                    start: node.children[0].position.end,
-                    end: firstParagraphOriginalEnd,
-                },
+                ...(headingPosition && firstParagraphOriginalEnd
+                    ? {
+                        position: {
+                            start: headingPosition.end,
+                            end: firstParagraphOriginalEnd,
+                        },
+                    }
+                    : {}),
             });
         }
         Object.assign(node, {
@@ -53198,11 +53240,24 @@ const processBlockquote = (node, index, parent) => {
     }
 };
 const calloutTransformer = () => {
-    return (tree) => {
-        visit(tree, 'blockquote', (node, index, parent) => {
+    const processNode = (root) => {
+        visit(root, 'blockquote', (node, index, parent) => {
             processBlockquote(node, index, parent);
+            if (node.type === NodeTypes.callout) {
+                // SKIP prevents re-processing synthetic blockquotes in parsed title content
+                // (e.g., blockquotes from "> Quote" titles). Recursively process body children
+                // (index 1+, skipping the heading at 0) to handle nested callouts.
+                for (let i = 1; i < node.children.length; i += 1) {
+                    processNode(node.children[i]);
+                }
+                return SKIP;
+            }
+            return undefined;
         });
     };
+    return (tree) => {
+        processNode(tree);
+    };
 };
 /* harmony default export */ const callouts = (calloutTransformer);
 
@@ -53227,8 +53282,18 @@ const codeTabsTransformer = ({ copyButtons } = {}) => (tree) => {
             const sibling = parent.children[walker];
             if (!isCode(sibling))
                 break;
+            // Check that the two code blocks are truly adjacent (no blank lines or
+            // other content between them). The `gap` is the number of raw characters
+            // between the end of the previous block and the start of this one.
+            // For a LF-separated pair the gap equals `start.column` (the newline
+            // char(s) plus any indentation). CRLF line endings add one extra byte
+            // (\r) without advancing the line count, so we also accept
+            // `start.column + 1` provided the blocks are still on consecutive lines.
             const olderSibling = parent.children[walker - 1];
-            if (olderSibling.position.end.offset + sibling.position.start.column !== sibling.position.start.offset)
+            const gap = sibling.position.start.offset - olderSibling.position.end.offset;
+            const lineDiff = sibling.position.start.line - olderSibling.position.end.line;
+            const isCRLF = gap === sibling.position.start.column + 1 && lineDiff === 1;
+            if (gap !== sibling.position.start.column && !isCRLF)
                 break;
             children.push(sibling);
             // eslint-disable-next-line no-plusplus
@@ -71162,6 +71227,13 @@ function legacyVariable() {
  */
 
 
+;// ./processor/transform/mdxish/constants.ts
+/**
+ * Inline component tags handled by mdxish-inline-components.ts.
+ * Also excluded from block-level handling in mdxish-component-blocks.ts.
+ */
+const INLINE_COMPONENT_TAGS = new Set(['Anchor']);
+
 ;// ./processor/transform/mdxish/mdxish-component-blocks.ts
 
 
@@ -71169,6 +71241,7 @@ function legacyVariable() {
 
 
 
+
 const pascalCaseTagPattern = /^<([A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>([\s\S]*)?$/;
 const tagAttributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>]+))?/g;
 /**
@@ -71181,10 +71254,8 @@ const MAX_LOOKAHEAD = 30;
  * These components either have special parsing requirements that the generic component
  * block transformer cannot handle correctly, or are inline components that we don't
  * want to convert to mdxJsxFlowElement which is a block level element.
- *
- * Glossary and Anchor are inline components.
  */
-const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', 'Anchor']);
+const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', ...INLINE_COMPONENT_TAGS]);
 const inlineMdProcessor = unified()
     .data('micromarkExtensions', [legacyVariable()])
     .data('fromMarkdownExtensions', [legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown()])
@@ -71448,10 +71519,10 @@ const mdxishComponentBlocks = () => tree => {
         const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
         // Collect all intermediate siblings between opening tag and closing tag
         const intermediateChildren = parent.children.slice(index + 1, closingIndex);
-        // For paragraph siblings, include the paragraph's children (with closing tag stripped)
+        // For paragraph siblings, include the full paragraph (with closing tag stripped)
         // For HTML siblings, include any content parsed from before the closing tag
         const closingChildren = strippedParagraph
-            ? strippedParagraph.children
+            ? (strippedParagraph.children.length > 0 ? [strippedParagraph] : [])
             : extraClosingChildren;
         const componentNode = createComponentNode({
             tag,
@@ -93829,7 +93900,7 @@ function getComponentName(componentName, components) {
 
 
 
-const INLINE_COMPONENT_TAGS = new Set(['anchor', 'glossary']);
+const mdxish_components_INLINE_COMPONENT_TAGS = new Set(['anchor', 'glossary']);
 function isElementContentNode(node) {
     return node.type === 'element' || node.type === 'text' || node.type === 'comment';
 }
@@ -93911,7 +93982,7 @@ function parseTextChildren(node, processMarkdown, components) {
         const hast = processMarkdown(child.value.trim());
         const children = (hast.children ?? []).filter(isElementContentNode);
         // For inline components, preserve plain text instead of wrapping in <p>
-        if (INLINE_COMPONENT_TAGS.has(node.tagName.toLowerCase()) && isSingleParagraphTextNode(children)) {
+        if (mdxish_components_INLINE_COMPONENT_TAGS.has(node.tagName.toLowerCase()) && isSingleParagraphTextNode(children)) {
             return [child];
         }
         return children;
@@ -94284,10 +94355,14 @@ function extractBalancedBraces(content, start) {
     return { content: content.slice(start, pos - 1), end: pos };
 }
 /**
- * Escapes unbalanced braces in content to prevent MDX expression parsing errors.
- * Handles: already-escaped braces, string literals inside expressions, nested balanced braces.
+ * Escapes problematic braces in content to prevent MDX expression parsing errors.
+ * Handles three cases:
+ * 1. Unbalanced braces (e.g., `{foo` without closing `}`)
+ * 2. Paragraph-spanning expressions (e.g., `{\n\n}` where blank line splits paragraphs)
+ * 3. Skips HTML elements to prevent backslashes appearing in output
+ *
  */
-function escapeUnbalancedBraces(content) {
+function escapeProblematicBraces(content) {
     // Skip HTML elements — their content should never be escaped because
     // rehypeRaw parses them into hast elements, making `\` literal text in output
     const htmlElements = [];
@@ -94296,16 +94371,19 @@ function escapeUnbalancedBraces(content) {
         htmlElements.push(match);
         return `___HTML_ELEM_${idx}___`;
     });
-    const opens = [];
-    const unbalanced = new Set();
-    let strDelim = null;
-    let strEscaped = false;
+    const toEscape = new Set();
     // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
     const chars = Array.from(safe);
+    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
     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) {
+        // Track string delimiters inside expressions to ignore braces within them
+        if (openStack.length > 0) {
             if (strDelim) {
                 if (strEscaped)
                     strEscaped = false;
@@ -94321,6 +94399,20 @@ function escapeUnbalancedBraces(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;
+                        });
+                    }
+                }
+                lastNewlinePos = i;
+            }
         }
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
@@ -94332,21 +94424,33 @@ function escapeUnbalancedBraces(content) {
                 continue;
             }
         }
-        if (ch === '{')
-            opens.push(i);
+        if (ch === '{') {
+            openStack.push({ pos: i, hasBlankLine: false });
+            lastNewlinePos = -2; // Reset newline tracking for new expression
+        }
         else if (ch === '}') {
-            if (opens.length > 0)
-                opens.pop();
-            else
-                unbalanced.add(i);
+            if (openStack.length > 0) {
+                const entry = openStack.pop();
+                // If expression spans paragraph boundary, escape both braces
+                if (entry.hasBlankLine) {
+                    toEscape.add(entry.pos);
+                    toEscape.add(i);
+                }
+            }
+            else {
+                // Unbalanced closing brace (no matching open)
+                toEscape.add(i);
+            }
         }
     }
-    opens.forEach(pos => unbalanced.add(pos));
-    // If there are no unbalanced braces, return content as-is;
-    // otherwise, escape each unbalanced `{` or `}` so MDX doesn't treat them as expressions.
-    let result = unbalanced.size === 0
+    // Any remaining open braces are 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) => (unbalanced.has(i) ? `\\${ch}` : ch)).join('');
+        : 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)]);
     }
@@ -94444,8 +94548,9 @@ function preprocessJSXExpressions(content, context = {}) {
     // For inline expressions, we use a library to parse the expression & evaluate it later
     // For attribute expressions, it was difficult to use a library to parse them, so do it manually
     processed = evaluateAttributeExpressions(protectedContent, context, protectedCode);
-    // Step 3: Escape unbalanced braces to prevent MDX expression parsing errors
-    processed = escapeUnbalancedBraces(processed);
+    // Step 3: Escape problematic braces to prevent MDX expression parsing errors
+    // This handles both unbalanced braces and paragraph-spanning expressions in one pass
+    processed = escapeProblematicBraces(processed);
     // Step 4: Restore protected code blocks
     processed = restoreCodeBlocks(processed, protectedCode);
     return processed;
@@ -96210,10 +96315,82 @@ const mdxishHtmlBlocks = () => tree => {
 };
 /* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
 
+;// ./processor/transform/mdxish/mdxish-inline-components.ts
+
+
+
+// Matches any PascalCase inline component opening tag. Groups: (name, attrs).
+// Uses [A-Za-z0-9_]* to match block version in mdxish-component-blocks.ts
+const INLINE_COMPONENT_OPEN_RE = /^<([A-Z][A-Za-z0-9_]*)(\s[^>]*)?>$/;
+function toMdxJsxTextElement(name, attributes, children) {
+    return {
+        type: 'mdxJsxTextElement',
+        name,
+        attributes,
+        children,
+    };
+}
+/**
+ * Transforms inline html component nodes (e.g. <Anchor>) into proper MDAST phrasing content.
+ *
+ * Inline components are excluded from mdxishComponentBlocks (which only handles block-level
+ * elements), so they remain as scattered html/text/html sibling nodes inside a paragraph.
+ * This plugin merges them into a single typed MDAST node.
+ */
+const mdxishInlineComponents = () => tree => {
+    visit(tree, 'html', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        const match = node.value?.match(INLINE_COMPONENT_OPEN_RE);
+        if (!match)
+            return;
+        const [, name, attrStr] = match;
+        if (!INLINE_COMPONENT_TAGS.has(name))
+            return;
+        // Parse attributes directly - preserves all attribute types (strings, booleans, objects, arrays)
+        const attributes = parseAttributes(attrStr ?? '');
+        // Find closing tag with whitespace-tolerant matching
+        let closeIdx = index + 1;
+        while (closeIdx < parent.children.length) {
+            const sib = parent.children[closeIdx];
+            if (sib.type === 'html' && sib.value?.trim() === `</${name}>`)
+                break;
+            closeIdx += 1;
+        }
+        if (closeIdx >= parent.children.length)
+            return;
+        // Extract all nodes between opening tag (index) and closing tag (closeIdx).
+        // These are the inline component's children (e.g., text, emphasis, links).
+        // Example: "<Anchor>click **here**</Anchor>" → children = [text, strong]
+        const children = parent.children.slice(index + 1, closeIdx);
+        const newNode = toMdxJsxTextElement(name, attributes, children);
+        parent.children.splice(index, closeIdx - index + 1, newNode);
+    });
+};
+/* harmony default export */ const mdxish_inline_components = (mdxishInlineComponents);
+
 ;// ./processor/transform/mdxish/mdxish-jsx-to-mdast.ts
 
 
 
+const transformAnchor = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { href = '', label, target, title } = attrs;
+    return {
+        type: NodeTypes.anchor,
+        children: jsx.children,
+        data: {
+            hName: 'Anchor',
+            hProperties: {
+                href,
+                ...(label && { label }),
+                ...(target && { target }),
+                ...(title && { title }),
+            },
+        },
+        position: jsx.position,
+    };
+};
 const transformImage = (jsx) => {
     const attrs = getAttrs(jsx);
     const { align, alt = '', border, caption, className, height, lazy, src = '', title = '', width } = attrs;
@@ -96267,7 +96444,7 @@ const transformCallout = (jsx) => {
 };
 const transformEmbed = (jsx) => {
     const attrs = getAttrs(jsx);
-    const { favicon, html, iframe, image, providerName, providerUrl, title = '', url = '' } = attrs;
+    const { favicon, height, html, iframe, image, providerName, providerUrl, title = '', typeOfEmbed, url = '', width } = attrs;
     return {
         type: NodeTypes.embedBlock,
         title,
@@ -96278,11 +96455,14 @@ const transformEmbed = (jsx) => {
                 title,
                 url,
                 ...(favicon && { favicon }),
+                ...(height && { height }),
                 ...(html && { html }),
                 ...(iframe !== undefined && { iframe }),
                 ...(image && { image }),
                 ...(providerName && { providerName }),
                 ...(providerUrl && { providerUrl }),
+                ...(typeOfEmbed && { typeOfEmbed }),
+                ...(width && { width }),
             },
         },
         position: jsx.position,
@@ -96378,7 +96558,7 @@ const COMPONENT_MAP = {
  * This is controlled by the `newEditorTypes` flag to maintain backwards compatibility.
  */
 const mdxishJsxToMdast = () => tree => {
-    // Transform JSX components (Image, Callout, Embed, Recipe)
+    // Block JSX components (Image, Callout, Embed, Recipe)
     visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
         if (!parent || index === undefined || !node.name)
             return;
@@ -96389,6 +96569,15 @@ const mdxishJsxToMdast = () => tree => {
         // Replace the JSX node with the MDAST node
         parent.children[index] = newNode;
     });
+    // Inline JSX components (Anchor)
+    visit(tree, 'mdxJsxTextElement', (node, index, parent) => {
+        if (!parent || index === undefined || !node.name)
+            return;
+        if (node.name === 'Anchor') {
+            const newNode = transformAnchor(node);
+            parent.children[index] = newNode;
+        }
+    });
     // Transform magic block images (type: 'image') to image-block
     // Note: Standard markdown images are wrapped in paragraphs and handled by imageTransformer
     // Magic block images are direct children of root, so we handle them here
@@ -97982,6 +98171,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
@@ -98043,7 +98233,9 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         .use(restore_snake_case_component_name, { mapping: snakeCaseMapping })
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
-        .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert JSX elements to MDAST types
+        .use(newEditorTypes ? mdxish_inline_components : undefined) // Merge inline html components (e.g. <Anchor>) into MDAST nodes
+        .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert block JSX elements to MDAST types
+        .use(safeMode ? undefined : evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
         .use(variables_text) // Parse {user.*} patterns from text nodes
         .use(useTailwind ? transform_tailwind : undefined, { components: tempComponentsMap })
         .use(remarkGfm);