@readme/markdown 13.0.0 → 13.1.1

package/dist/main.node.js

@@ -73306,6 +73306,59 @@ const isCalloutStructure = (node) => {
     const firstTextChild = firstChild.children?.[0];
     return firstTextChild?.type === 'text';
 };
+/**
+ * Finds the first text node containing a newline in a paragraph's children.
+ * Returns the index and the newline position within that text node.
+ */
+const findNewlineInParagraph = (paragraph) => {
+    for (let i = 0; i < paragraph.children.length; i += 1) {
+        const child = paragraph.children[i];
+        if (child.type === 'text' && typeof child.value === 'string') {
+            const newlineIndex = child.value.indexOf('\n');
+            if (newlineIndex !== -1) {
+                return { index: i, newlineIndex };
+            }
+        }
+    }
+    return null;
+};
+/**
+ * Splits a paragraph at the first newline, separating heading content (before \n)
+ * from body content (after \n). Mutates the paragraph to contain only heading children.
+ */
+const splitParagraphAtNewline = (paragraph) => {
+    const splitPoint = findNewlineInParagraph(paragraph);
+    if (!splitPoint)
+        return null;
+    const { index, newlineIndex } = splitPoint;
+    const originalChildren = paragraph.children;
+    const textNode = originalChildren[index];
+    const beforeNewline = textNode.value.slice(0, newlineIndex);
+    const afterNewline = textNode.value.slice(newlineIndex + 1);
+    // Split paragraph: heading = children[0..index-1] + text before newline
+    const headingChildren = originalChildren.slice(0, index);
+    if (beforeNewline.length > 0 || headingChildren.length === 0) {
+        headingChildren.push({ type: 'text', value: beforeNewline });
+    }
+    paragraph.children = headingChildren;
+    // Body = text after newline + remaining children from original array
+    const bodyChildren = [];
+    if (afterNewline.length > 0) {
+        bodyChildren.push({ type: 'text', value: afterNewline });
+    }
+    bodyChildren.push(...originalChildren.slice(index + 1));
+    return bodyChildren.length > 0 ? bodyChildren : null;
+};
+/**
+ * Removes the icon/match prefix from the first text node in a paragraph.
+ * This is needed to clean up the raw AST after we've extracted the icon.
+ */
+const removeIconPrefix = (paragraph, prefixLength) => {
+    const firstTextNode = findFirst(paragraph);
+    if (firstTextNode && 'value' in firstTextNode && typeof firstTextNode.value === 'string') {
+        firstTextNode.value = firstTextNode.value.slice(prefixLength);
+    }
+};
 const processBlockquote = (node, index, parent) => {
     if (!isCalloutStructure(node)) {
         // Only stringify empty blockquotes (no extractable text content)
@@ -73330,22 +73383,39 @@ const processBlockquote = (node, index, parent) => {
     const firstParagraph = node.children[0];
     const startText = lib_plain(firstParagraph).toString();
     const [match, icon] = startText.match(callouts_regex) || [];
+    const firstParagraphOriginalEnd = firstParagraph.position.end;
     if (icon && match) {
-        const heading = startText.slice(match.length);
-        const empty = !heading.length && firstParagraph.children.length === 1;
+        // Handle cases where heading and body are on the same line separated by a newline.
+        // 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 theme = themes[icon] || 'default';
-        const firstChild = findFirst(node.children[0]);
-        if (firstChild && 'value' in firstChild && typeof firstChild.value === 'string') {
-            firstChild.value = firstChild.value.slice(match.length);
-        }
-        if (heading) {
+        // 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);
-            // @note: We add to the offset/column the length of the unicode
-            // character that was stripped off, so that the start position of the
-            // heading/text matches where it actually starts.
+            // 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;
         }
+        // Insert body content as a separate paragraph after the heading
+        if (bodyChildren) {
+            node.children.splice(1, 0, {
+                type: 'paragraph',
+                children: bodyChildren,
+                position: {
+                    start: node.children[0].position.end,
+                    end: firstParagraphOriginalEnd,
+                },
+            });
+        }
         Object.assign(node, {
             type: NodeTypes.callout,
             data: {
@@ -106760,7 +106830,7 @@ const CUSTOM_PROP_BOUNDARIES = [
 /**
  * Tags that should be passed through and handled at runtime (not by the mdxish plugin)
  */
-const RUNTIME_COMPONENT_TAGS = new Set(['Variable', 'variable', 'rdme-pin']);
+const RUNTIME_COMPONENT_TAGS = new Set(['Variable', 'variable', 'html-block', 'rdme-pin']);
 /**
  * Standard HTML tags that should never be treated as custom components.
  * Uses the html-tags package, converted to a Set<string> for efficient lookups.
@@ -114056,6 +114126,349 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
 };
 /* harmony default export */ const evaluate_expressions = (evaluateExpressions);
 
+;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
+
+// Marker patterns for multi-node emphasis detection
+const MARKER_PATTERNS = [
+    { isBold: true, marker: '**' },
+    { isBold: true, marker: '__' },
+    { isBold: false, marker: '*' },
+    { isBold: false, marker: '_' },
+];
+// Patterns to detect for bold (** and __) and italic (* and _) syntax:
+// Bold: ** text**, **text **, word** text**, ** text **
+// Italic: * text*, *text *, word* text*, * text *
+// Same patterns for underscore variants
+// We use separate patterns for each marker type to allow this flexibility.
+// Pattern for ** bold **
+// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
+// 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;
+// 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;
+// 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;
+// Pattern for intraword __word__ in words like hello__world__
+const intrawordUnderscoreBoldRegex = /(\w)__([a-zA-Z0-9]+)__(?![\w_])/g;
+// Pattern for intraword *word* in words like hello*world*
+const intrawordAsteriskItalicRegex = /(\w)\*(?!\*)([a-zA-Z0-9]+)\*(?![\w*])/g;
+// Pattern for intraword **word** in words like hello**world**
+const intrawordAsteriskBoldRegex = /(\w)\*\*([a-zA-Z0-9]+)\*\*(?![\w*])/g;
+/**
+ * Finds opening emphasis marker in a text value.
+ * Returns marker info if found, null otherwise.
+ */
+function findOpeningMarker(text) {
+    const results = MARKER_PATTERNS.map(({ isBold, marker }) => {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        if (text.startsWith(marker) && text.length > marker.length) {
+            return { isBold, marker, textAfter: text.slice(marker.length), textBefore: '' };
+        }
+        const idx = text.indexOf(marker);
+        if (idx > 0 && !/\s/.test(text[idx - 1])) {
+            if (marker === '*' && text.slice(idx).startsWith('**'))
+                return null;
+            if (marker === '_' && text.slice(idx).startsWith('__'))
+                return null;
+            const after = text.slice(idx + marker.length);
+            if (after.length > 0) {
+                return { isBold, marker, textAfter: after, textBefore: text.slice(0, idx) };
+            }
+        }
+        return null;
+    });
+    return results.find(r => r !== null) ?? null;
+}
+/**
+ * Finds the end/closing marker in a text node for multi-node emphasis.
+ */
+function findEndMarker(text, marker) {
+    const spacePattern = ` ${marker}`;
+    const spaceIdx = text.indexOf(spacePattern);
+    if (spaceIdx >= 0) {
+        if (marker === '*' && text.slice(spaceIdx + 1).startsWith('**'))
+            return null;
+        if (marker === '_' && text.slice(spaceIdx + 1).startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(spaceIdx + spacePattern.length),
+            textBefore: text.slice(0, spaceIdx),
+        };
+    }
+    if (text.startsWith(marker)) {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(marker.length),
+            textBefore: '',
+        };
+    }
+    return null;
+}
+/**
+ * Scan children for an opening emphasis marker in a text node.
+ */
+function findOpeningInChildren(children) {
+    let result = null;
+    children.some((child, idx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findOpeningMarker(child.value);
+        if (found) {
+            result = { idx, opening: found };
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
+/**
+ * Scan children (after openingIdx) for a closing emphasis marker.
+ */
+function findClosingInChildren(children, openingIdx, marker) {
+    let result = null;
+    children.slice(openingIdx + 1).some((child, relativeIdx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findEndMarker(child.value, marker);
+        if (found) {
+            result = { closingIdx: openingIdx + 1 + relativeIdx, closing: found };
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
+/**
+ * Build the replacement nodes for a matched emphasis pair.
+ */
+function buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx }) {
+    const newNodes = [];
+    if (opening.textBefore) {
+        newNodes.push({ type: 'text', value: `${opening.textBefore} ` });
+    }
+    const emphasisChildren = [];
+    const openingText = opening.textAfter.replace(/^\s+/, '');
+    if (openingText) {
+        emphasisChildren.push({ type: 'text', value: openingText });
+    }
+    container.children.slice(openingIdx + 1, closingIdx).forEach(child => {
+        emphasisChildren.push(child);
+    });
+    const closingText = closing.textBefore.replace(/\s+$/, '');
+    if (closingText) {
+        emphasisChildren.push({ type: 'text', value: closingText });
+    }
+    if (emphasisChildren.length > 0) {
+        const emphasisNode = opening.isBold
+            ? { type: 'strong', children: emphasisChildren }
+            : { type: 'emphasis', children: emphasisChildren };
+        newNodes.push(emphasisNode);
+    }
+    if (closing.textAfter) {
+        newNodes.push({ type: 'text', value: closing.textAfter });
+    }
+    return newNodes;
+}
+/**
+ * Find and transform one multi-node emphasis pair in the container.
+ * Returns true if a pair was found and transformed, false otherwise.
+ */
+function processOneEmphasisPair(container) {
+    const openingResult = findOpeningInChildren(container.children);
+    if (!openingResult)
+        return false;
+    const { idx: openingIdx, opening } = openingResult;
+    const closingResult = findClosingInChildren(container.children, openingIdx, opening.marker);
+    if (!closingResult)
+        return false;
+    const { closingIdx, closing } = closingResult;
+    const newNodes = buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx });
+    const deleteCount = closingIdx - openingIdx + 1;
+    container.children.splice(openingIdx, deleteCount, ...newNodes);
+    return true;
+}
+/**
+ * Handle malformed emphasis that spans multiple AST nodes.
+ * E.g., "**bold [link](url)**" where markers are in different text nodes.
+ */
+function visitMultiNodeEmphasis(tree) {
+    const containerTypes = ['paragraph', 'heading', 'tableCell', 'listItem', 'blockquote'];
+    visit(tree, node => {
+        if (!containerTypes.includes(node.type))
+            return;
+        if (!('children' in node) || !Array.isArray(node.children))
+            return;
+        const container = node;
+        let foundPair = true;
+        while (foundPair) {
+            foundPair = processOneEmphasisPair(container);
+        }
+    });
+}
+/**
+ * A remark plugin that normalizes malformed bold and italic markers in text nodes.
+ * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
+ * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
+ * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
+ *
+ * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
+ * Also supports snake_case content like `** some_snake_case**`.
+ *
+ * This runs after remark-parse, which (in v11+) is strict and doesn't parse
+ * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
+ */
+const normalizeEmphasisAST = () => (tree) => {
+    visit(tree, 'text', function visitor(node, index, parent) {
+        if (index === undefined || !parent)
+            return undefined;
+        // Skip if inside code blocks or inline code
+        if (parent.type === 'inlineCode' || parent.type === 'code') {
+            return undefined;
+        }
+        const text = node.value;
+        const allMatches = [];
+        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '**', match });
+        });
+        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '__', match });
+        });
+        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '*', match });
+        });
+        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '__', match });
+        });
+        [...text.matchAll(intrawordAsteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '*', match });
+        });
+        [...text.matchAll(intrawordAsteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '**', match });
+        });
+        if (allMatches.length === 0)
+            return undefined;
+        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
+        const filteredMatches = [];
+        let lastEnd = 0;
+        allMatches.forEach(info => {
+            const start = info.match.index ?? 0;
+            const end = start + info.match[0].length;
+            if (start >= lastEnd) {
+                filteredMatches.push(info);
+                lastEnd = end;
+            }
+        });
+        if (filteredMatches.length === 0)
+            return undefined;
+        const parts = [];
+        let lastIndex = 0;
+        filteredMatches.forEach(({ isBold, isIntraword, marker, match }) => {
+            const matchIndex = match.index ?? 0;
+            const fullMatch = match[0];
+            if (isIntraword) {
+                // handles cases like hello_world_ where we only want to italicize 'world'
+                const charBefore = match[1] || ''; // e.g., "l" in "hello_world_"
+                const content = match[2]; // e.g., "world"
+                const combinedBefore = text.slice(lastIndex, matchIndex) + charBefore;
+                if (combinedBefore) {
+                    parts.push({ type: 'text', value: combinedBefore });
+                }
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                lastIndex = matchIndex + fullMatch.length;
+                return;
+            }
+            if (matchIndex > lastIndex) {
+                const beforeText = text.slice(lastIndex, matchIndex);
+                if (beforeText) {
+                    parts.push({ type: 'text', value: beforeText });
+                }
+            }
+            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
+            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
+            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
+            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
+            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
+            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
+            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
+            const afterChar = match[7]; // Character after closing markers (if any)
+            const markerPos = fullMatch.indexOf(marker);
+            const spacesBeforeMarkers = wordBefore
+                ? fullMatch.slice(wordBefore.length, markerPos)
+                : fullMatch.slice(0, markerPos);
+            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
+            if (wordBefore) {
+                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
+                parts.push({ type: 'text', value: wordBefore + spacing });
+            }
+            else if (spacesBeforeMarkers) {
+                parts.push({ type: 'text', value: spacesBeforeMarkers });
+            }
+            if (content) {
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+            }
+            if (afterChar) {
+                const prefix = trailingSpace ? ' ' : '';
+                parts.push({ type: 'text', value: prefix + afterChar });
+            }
+            lastIndex = matchIndex + fullMatch.length;
+        });
+        if (lastIndex < text.length) {
+            const remainingText = text.slice(lastIndex);
+            if (remainingText) {
+                parts.push({ type: 'text', value: remainingText });
+            }
+        }
+        if (parts.length > 0) {
+            parent.children.splice(index, 1, ...parts);
+            return [SKIP, index + parts.length];
+        }
+        return undefined;
+    });
+    // Handle malformed emphasis spanning multiple nodes (e.g., **text [link](url) **)
+    visitMultiNodeEmphasis(tree);
+    return tree;
+};
+/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
+
 ;// ./processor/transform/mdxish/magic-blocks/placeholder.ts
 const EMPTY_IMAGE_PLACEHOLDER = {
     type: 'image',
@@ -114108,6 +114521,7 @@ const EMPTY_CODE_PLACEHOLDER = {
 
 
 
+
 /**
  * Wraps a node in a "pinned" container if sidebar: true is set.
  */
@@ -114135,7 +114549,8 @@ const imgWidthBySize = new Proxy(imgSizeValues, {
 });
 const textToInline = (text) => [{ type: 'text', value: text }];
 const textToBlock = (text) => [{ children: textToInline(text), type: 'paragraph' }];
-const contentParser = unified().use(remarkParse).use(remarkGfm);
+/** Parses markdown and html to markdown nodes */
+const contentParser = unified().use(remarkParse).use(remarkGfm).use(normalize_malformed_md_syntax);
 const parseTableCell = (text) => {
     if (!text.trim())
         return [{ type: 'text', value: '' }];
@@ -115173,139 +115588,6 @@ function restoreSnakeCase(placeholderName, mapping) {
     return matchingKey ? mapping[matchingKey] : placeholderName;
 }
 
-;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
-
-// Patterns to detect for bold (** and __) and italic (* and _) syntax:
-// Bold: ** text**, **text **, word** text**, ** text **
-// Italic: * text*, *text *, word* text*, * text *
-// Same patterns for underscore variants
-// We use separate patterns for each marker type to allow this flexibility.
-// Pattern for ** bold **
-// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
-// 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;
-// 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;
-/**
- * A remark plugin that normalizes malformed bold and italic markers in text nodes.
- * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
- * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
- * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
- *
- * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
- * Also supports snake_case content like `** some_snake_case**`.
- *
- * This runs after remark-parse, which (in v11+) is strict and doesn't parse
- * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
- */
-const normalizeEmphasisAST = () => (tree) => {
-    visit(tree, 'text', function visitor(node, index, parent) {
-        if (index === undefined || !parent)
-            return undefined;
-        // Skip if inside code blocks or inline code
-        if (parent.type === 'inlineCode' || parent.type === 'code') {
-            return undefined;
-        }
-        const text = node.value;
-        const allMatches = [];
-        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '**', match });
-        });
-        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '__', match });
-        });
-        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '*', match });
-        });
-        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '_', match });
-        });
-        if (allMatches.length === 0)
-            return undefined;
-        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
-        const filteredMatches = [];
-        let lastEnd = 0;
-        allMatches.forEach(info => {
-            const start = info.match.index ?? 0;
-            const end = start + info.match[0].length;
-            if (start >= lastEnd) {
-                filteredMatches.push(info);
-                lastEnd = end;
-            }
-        });
-        if (filteredMatches.length === 0)
-            return undefined;
-        const parts = [];
-        let lastIndex = 0;
-        filteredMatches.forEach(({ match, marker, isBold }) => {
-            const matchIndex = match.index ?? 0;
-            const fullMatch = match[0];
-            if (matchIndex > lastIndex) {
-                const beforeText = text.slice(lastIndex, matchIndex);
-                if (beforeText) {
-                    parts.push({ type: 'text', value: beforeText });
-                }
-            }
-            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
-            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
-            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
-            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
-            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
-            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
-            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
-            const afterChar = match[7]; // Character after closing markers (if any)
-            const markerPos = fullMatch.indexOf(marker);
-            const spacesBeforeMarkers = wordBefore
-                ? fullMatch.slice(wordBefore.length, markerPos)
-                : fullMatch.slice(0, markerPos);
-            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
-            if (wordBefore) {
-                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
-                parts.push({ type: 'text', value: wordBefore + spacing });
-            }
-            else if (spacesBeforeMarkers) {
-                parts.push({ type: 'text', value: spacesBeforeMarkers });
-            }
-            if (content) {
-                if (isBold) {
-                    parts.push({
-                        type: 'strong',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-                else {
-                    parts.push({
-                        type: 'emphasis',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-            }
-            if (afterChar) {
-                const prefix = trailingSpace ? ' ' : '';
-                parts.push({ type: 'text', value: prefix + afterChar });
-            }
-            lastIndex = matchIndex + fullMatch.length;
-        });
-        if (lastIndex < text.length) {
-            const remainingText = text.slice(lastIndex);
-            if (remainingText) {
-                parts.push({ type: 'text', value: remainingText });
-            }
-        }
-        if (parts.length > 0) {
-            parent.children.splice(index, 1, ...parts);
-            return [SKIP, index + parts.length];
-        }
-        return undefined;
-    });
-    return tree;
-};
-/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
-
 ;// ./processor/transform/mdxish/normalize-table-separator.ts
 /**
  * Preprocessor to normalize malformed GFM table separator syntax.
@@ -116777,7 +117059,7 @@ function loadComponents() {
 
 const defaultTransformers = [callouts, code_tabs, gemoji_, transform_embeds];
 function mdxishAstProcessor(mdContent, opts = {}) {
-    const { components: userComponents = {}, jsxContext = {}, newEditorTypes = false, useTailwind } = opts;
+    const { components: userComponents = {}, jsxContext = {}, newEditorTypes = false, safeMode = false, useTailwind, } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
@@ -116788,7 +117070,9 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     // Step 1: Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
     const contentAfterTableNormalization = normalizeTableSeparator(mdContent);
     // Step 2: Evaluate JSX expressions in attributes
-    const contentAfterJSXEvaluation = preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
+    const contentAfterJSXEvaluation = safeMode
+        ? contentAfterTableNormalization
+        : preprocessJSXExpressions(contentAfterTableNormalization, jsxContext);
     // Step 3: Replace snake_case component names with parser-safe placeholders
     const { content: parserReadyContent, mapping: snakeCaseMapping } = processSnakeCaseComponent(contentAfterJSXEvaluation, { knownComponents });
     // Create string map for tailwind transformer
@@ -116803,8 +117087,8 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         text: mdxExprExt.text,
     };
     const processor = unified()
-        .data('micromarkExtensions', [magicBlock(), mdxExprTextOnly])
-        .data('fromMarkdownExtensions', [magicBlockFromMarkdown(), mdxExpressionFromMarkdown()])
+        .data('micromarkExtensions', safeMode ? [magicBlock()] : [magicBlock(), mdxExprTextOnly])
+        .data('fromMarkdownExtensions', safeMode ? [magicBlockFromMarkdown()] : [magicBlockFromMarkdown(), mdxExpressionFromMarkdown()])
         .use(remarkParse)
         .use(remarkFrontmatter)
         .use(normalize_malformed_md_syntax)
@@ -116816,8 +117100,8 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
         .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert JSX elements to MDAST types
-        .use(evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
-        .use(variables_text) // Parse {user.*} patterns from text (can't rely on remarkMdx)
+        .use(safeMode ? undefined : evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
+        .use(variables_text) // Parse {user.*} patterns from text
         .use(useTailwind ? transform_tailwind : undefined, { components: tempComponentsMap })
         .use(remarkGfm);
     return {
@@ -117438,6 +117722,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 ;// ./index.tsx