@readme/markdown 14.1.1 → 14.1.3

package/dist/main.node.js

@@ -107805,7 +107805,12 @@ const tocHastToMdx = (toc, components, variables) => {
 
 
 const sanitizeSchema = cjs_default()(defaultSchema, {
-    protocols: ['doc', 'ref', 'blog', 'changelog', 'page'],
+    attributes: {
+        a: ['target'],
+    },
+    protocols: {
+        href: ['doc', 'ref', 'blog', 'changelog', 'page'],
+    },
 });
 const compile_compile = (text, { components = {}, missingComponents, copyButtons, useTailwind, ...opts } = {}) => {
     // Destructure at runtime to avoid circular dependency issues
@@ -117396,17 +117401,46 @@ function mdxComponent() {
 
 
 
+
+
+
+
+const buildInlineMdProcessor = (safeMode) => {
+    const micromarkExts = [mdxComponent(), syntax_gemoji(), legacyVariable(), magicBlock()];
+    const fromMarkdownExts = [
+        mdxComponentFromMarkdown(),
+        gemojiFromMarkdown(),
+        legacyVariableFromMarkdown(),
+        emptyTaskListItemFromMarkdown(),
+        magicBlockFromMarkdown(),
+    ];
+    // Since evaluating expressions can be dangerous, do so only when safeMode is off
+    if (!safeMode) {
+        const mdxExprExt = mdxExpression({ allowEmpty: true });
+        micromarkExts.push({ text: mdxExprExt.text });
+        fromMarkdownExts.push(mdxExpressionFromMarkdown());
+    }
+    return unified()
+        .data('micromarkExtensions', micromarkExts)
+        .data('fromMarkdownExtensions', fromMarkdownExts)
+        .use(remarkParse)
+        .use(remarkGfm);
+};
+const processorCache = new Map();
 /**
- * Shared unified processor for re-parsing the body of an MDX-ish component.
- * Used by both the block and inline-block transformers so a nested component
- * (e.g. `<Anchor>text with <b>bold</b></Anchor>`) goes through the same
- * tokenizer chain as the top-level parse.
+ * Unified processor for re-parsing the body of an MDX component
+ * Memoized based on the argument value so we don't pay the construction cost on every parse
+ * Currently the argument is only safeMode, but we could add more arguments in the future,
+ * in which case the key would need to be extend to include the new arguments.
  */
-const inlineMdProcessor = unified()
-    .data('micromarkExtensions', [mdxComponent(), legacyVariable(), magicBlock()])
-    .data('fromMarkdownExtensions', [mdxComponentFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), magicBlockFromMarkdown()])
-    .use(remarkParse)
-    .use(remarkGfm);
+const getInlineMdProcessor = ({ safeMode = false } = {}) => {
+    let processor = processorCache.get(safeMode);
+    if (!processor) {
+        processor = buildInlineMdProcessor(safeMode);
+        processorCache.set(safeMode, processor);
+    }
+    return processor;
+};
 /**
  * True when a tag name starts with an uppercase letter — ReadMe's marker for
  * a custom MDX component (vs a lowercase HTML tag).
@@ -117447,11 +117481,11 @@ const toMdxJsxTextElement = (name, attributes, children, position) => ({
  * rejects line endings), so the paragraph-flatten path covers every case we
  * actually produce; other shapes fall back to empty children.
  */
-const parsePhrasingChildren = (value) => {
+const parsePhrasingChildren = (value, safeMode) => {
     const trimmed = value.trim();
     if (!trimmed)
         return [];
-    const [first] = inlineMdProcessor.parse(trimmed).children;
+    const [first] = getInlineMdProcessor({ safeMode }).parse(trimmed).children;
     return first?.type === 'paragraph' ? first.children : [];
 };
 /**
@@ -117464,7 +117498,7 @@ const parsePhrasingChildren = (value) => {
  *
  * Returns the original node unchanged when it doesn't qualify.
  */
-const promoteInlineHtml = (node, parseOpts) => {
+const promoteInlineHtml = (node, parseOpts, safeMode) => {
     const parsed = parseTag((node.value ?? '').trim(), parseOpts);
     if (!parsed)
         return node;
@@ -117489,7 +117523,7 @@ const promoteInlineHtml = (node, parseOpts) => {
     if (closeIdx < 0)
         return node;
     const inner = contentAfterTag.slice(0, closeIdx);
-    return toMdxJsxTextElement(tag, attributes, parsePhrasingChildren(inner), node.position);
+    return toMdxJsxTextElement(tag, attributes, parsePhrasingChildren(inner, safeMode), node.position);
 };
 /**
  * Transform inline html nodes with expression attributes
@@ -117508,9 +117542,10 @@ const promoteInlineHtml = (node, parseOpts) => {
  * `<a href="x">` stays as an html node for rehype-raw.
  */
 const mdxishInlineMdxHtmlBlocks = (opts = {}) => tree => {
-    const parseOpts = { preserveExpressionsAsText: !!opts.safeMode };
+    const safeMode = !!opts.safeMode;
+    const parseOpts = { preserveExpressionsAsText: safeMode };
     visit(tree, 'paragraph', (paragraph) => {
-        paragraph.children = paragraph.children.map(child => child.type === 'html' ? promoteInlineHtml(child, parseOpts) : child);
+        paragraph.children = paragraph.children.map(child => child.type === 'html' ? promoteInlineHtml(child, parseOpts, safeMode) : child);
     });
 };
 /* harmony default export */ const inline_html = (mdxishInlineMdxHtmlBlocks);
@@ -117593,15 +117628,15 @@ function safeDeindent(text) {
  * Dedents the content first to prevent indented component content
  * (from nested components) from being treated as code blocks.
  */
-const parseMdChildren = (value) => {
-    const parsed = inlineMdProcessor.parse(safeDeindent(value).trim());
+const parseMdChildren = (value, safeMode) => {
+    const parsed = getInlineMdProcessor({ safeMode }).parse(safeDeindent(value).trim());
     return parsed.children || [];
 };
 /**
  * Parse substring content of a node and update the parent's children to include the new nodes.
  */
-const parseSibling = (stack, parent, index, sibling) => {
-    const siblingNodes = parseMdChildren(sibling);
+const parseSibling = (stack, parent, index, sibling, safeMode) => {
+    const siblingNodes = parseMdChildren(sibling, safeMode);
     // The new sibling nodes might contain new components to be processed
     if (siblingNodes.length > 0) {
         parent.children.splice(index + 1, 0, ...siblingNodes);
@@ -117653,7 +117688,8 @@ const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
  */
 const mdxishMdxComponentBlocks = (opts = {}) => tree => {
     const stack = [tree];
-    const parseOpts = { preserveExpressionsAsText: !!opts.safeMode };
+    const safeMode = !!opts.safeMode;
+    const parseOpts = { preserveExpressionsAsText: safeMode };
     const processChildNode = (parent, index) => {
         const node = parent.children[index];
         if (!node)
@@ -117699,7 +117735,7 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
             // Check and parse if there's relevant content after the current closing tag
             const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
-                parseSibling(stack, parent, index, remainingContent);
+                parseSibling(stack, parent, index, remainingContent, safeMode);
             }
             return;
         }
@@ -117712,7 +117748,7 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
             const componentInnerContent = contentAfterTag.substring(0, closingTagIndex);
             const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
             let parsedChildren = componentInnerContent.trim()
-                ? parseMdChildren(componentInnerContent)
+                ? parseMdChildren(componentInnerContent, safeMode)
                 : [];
             // Lowercase HTML tags are usually inline (e.g. <a>, <span>). Remark wraps
             // bare text in a paragraph; unwrap when there's exactly one paragraph so
@@ -117729,7 +117765,7 @@ const mdxishMdxComponentBlocks = (opts = {}) => tree => {
             substituteNodeWithMdxNode(parent, index, componentNode);
             // After the closing tag, there might be more content to be processed
             if (contentAfterClose) {
-                parseSibling(stack, parent, index, contentAfterClose);
+                parseSibling(stack, parent, index, contentAfterClose, safeMode);
             }
             else if (componentNode.children.length > 0) {
                 // The content inside the component block might contain new components to be processed
@@ -119639,11 +119675,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);
@@ -119657,51 +119699,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);
         }
     }
 };
@@ -119771,29 +119822,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
@@ -119813,22 +119891,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)
@@ -119839,10 +119912,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];
@@ -119856,27 +119928,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] === '/' &&
@@ -119887,21 +119949,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.
@@ -122047,15 +122103,18 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         .use(remarkParse)
         .use(remarkFrontmatter)
         .use(normalize_malformed_md_syntax)
-        .use(magic_block_transformer)
-        .use(transform_images, { isMdxish: true })
-        .use(defaultTransformers)
         .use(self_closing_blocks)
         .use(mdx_blocks, { safeMode })
         .use(inline_html, { safeMode })
         .use(restore_snake_case_component_name, { mapping: snakeCaseMapping })
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
+        // The next few transformers must appear after mdxishMdxComponentBlocks
+        // so nodes produced by the inline re-parse of component bodies
+        // (e.g. code/image/embed inside <Tabs>) get visited too
+        .use(magic_block_transformer)
+        .use(transform_images, { isMdxish: true })
+        .use(defaultTransformers)
         .use(newEditorTypes ? inline_mdx_blocks : 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(variables_text) // Parse {user.*} patterns from text nodes