@readme/markdown 14.3.0 → 14.4.0

package/dist/main.node.js

@@ -24834,9 +24834,10 @@ const LightboxPortal = ({ children }) => {
     return (0,external_react_dom_namespaceObject.createPortal)(children, document.body);
 };
 const Image = (Props) => {
-    const { align = '', alt = '', border: borderProp = false, caption, className = '', height = 'auto', src, title = '', width = 'auto', lazy = true, children, } = Props;
-    // Normalize border: MDXish passes {false} as the string "false", not a boolean
+    const { align = '', alt = '', border: borderProp = false, caption, className = '', framed: framedProp = false, height = 'auto', src, title = '', width = 'auto', lazy = true, children, } = Props;
+    // Normalize border/framed: MDXish passes {false} as the string "false", not a boolean
     const border = borderProp === true || borderProp === 'true';
+    const framed = framedProp === true || framedProp === 'true';
     const [lightbox, setLightbox] = external_react_.useState(false);
     if (className === 'emoji') {
         return external_react_.createElement("img", { alt: alt, height: height, loading: lazy ? 'lazy' : 'eager', src: src, title: title, width: width });
@@ -24865,7 +24866,10 @@ const Image = (Props) => {
             return;
         setLightbox(!lightbox);
     };
-    const imgElement = (external_react_.createElement("img", { alt: alt, className: `img ${caption || children ? 'img-align-center' : align ? `img-align-${align}` : ''} ${border ? 'border' : ''}`, height: height, loading: lazy ? 'lazy' : 'eager', src: src, title: title, width: width }));
+    // Framed images center the <img> itself; outer wrapper handles left/right alignment via text-align.
+    const imgElement = (external_react_.createElement("img", { alt: alt, className: `img ${caption || children || framed ? 'img-align-center' : align ? `img-align-${align}` : ''} ${border ? 'border' : ''}`, height: height, loading: lazy ? 'lazy' : 'eager', src: src, title: title, width: width }));
+    const closedLightbox = (ariaLabel, content) => (external_react_.createElement("span", { "aria-label": ariaLabel, className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
+        external_react_.createElement("span", { className: "lightbox-inner" }, content)));
     const lightboxOverlay = lightbox ? (external_react_.createElement(LightboxPortal, null,
         external_react_.createElement("div", { className: "markdown-body" },
             external_react_.createElement("span", { "aria-label": alt || 'Collapse image', className: "img lightbox open", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
@@ -24874,17 +24878,27 @@ const Image = (Props) => {
                     (children || caption) && external_react_.createElement("figcaption", null, children || caption))),
             external_react_.createElement("button", { "aria-label": "Minimize image", className: "lightbox-close", onClick: toggle, type: "button" },
                 external_react_.createElement("i", { "aria-hidden": "true", className: "fa-solid fa-xmark" }))))) : null;
+    if (framed) {
+        const frameClass = `img-frame img-frame-${align || 'center'}`;
+        if (children || caption) {
+            return (external_react_.createElement("figure", { className: frameClass },
+                closedLightbox(alt || 'Expand image', imgElement),
+                lightboxOverlay,
+                external_react_.createElement("figcaption", null, children || caption)));
+        }
+        return (external_react_.createElement("div", { className: frameClass },
+            closedLightbox(alt || 'Expand image', imgElement),
+            lightboxOverlay));
+    }
     if (children || caption) {
         return (external_react_.createElement("figure", null,
-            external_react_.createElement("span", { "aria-label": alt, className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
-                external_react_.createElement("span", { className: "lightbox-inner" },
-                    imgElement,
-                    external_react_.createElement("figcaption", null, children || caption))),
+            closedLightbox(alt || 'Expand image', external_react_.createElement(external_react_.Fragment, null,
+                imgElement,
+                external_react_.createElement("figcaption", null, children || caption))),
             lightboxOverlay));
     }
     return (external_react_.createElement(external_react_.Fragment, null,
-        external_react_.createElement("span", { "aria-label": "Expand image", className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
-            external_react_.createElement("span", { className: "lightbox-inner" }, imgElement)),
+        closedLightbox('Expand image', imgElement),
         lightboxOverlay));
 };
 /* harmony default export */ const components_Image = (Image);
@@ -25122,12 +25136,14 @@ const Tab = ({ children }) => {
 };
 const Tabs = ({ children }) => {
     const [activeTab, setActiveTab] = (0,external_react_.useState)(0);
+    // React passes `children` as a single element when there's only one child, so normalize.
+    const tabs = external_react_default().Children.toArray(children);
     return (external_react_default().createElement("div", { className: "TabGroup" },
         external_react_default().createElement("header", null,
-            external_react_default().createElement("nav", { className: "TabGroup-nav" }, children?.map((tab, index) => (external_react_default().createElement("button", { key: tab.props.title, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
+            external_react_default().createElement("nav", { className: "TabGroup-nav" }, tabs.map((tab, index) => (external_react_default().createElement("button", { key: tab.props.title, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
                 tab.props.icon && (external_react_default().createElement("i", { className: `TabGroup-icon fa-duotone fa-solid ${tab.props.icon}`, style: { color: `${tab.props.iconColor}` } })),
                 tab.props.title))))),
-        external_react_default().createElement("section", null, children && children[activeTab])));
+        external_react_default().createElement("section", null, tabs[activeTab])));
 };
 /* harmony default export */ const components_Tabs = (Tabs);
 
@@ -95806,13 +95822,14 @@ const applyInserts = (html, inserts) => {
     const sorted = [...inserts].sort((a, b) => a.offset - b.offset);
     let out = '';
     let cursor = 0;
-    sorted.forEach(({ offset, text }) => {
+    sorted.forEach(({ offset, text, consumes = 0 }) => {
         const clamped = Math.min(Math.max(offset, cursor), html.length);
         if (clamped > cursor) {
             out += html.slice(cursor, clamped);
             cursor = clamped;
         }
         out += text;
+        cursor = Math.min(cursor + consumes, html.length);
     });
     return { value: out + html.slice(cursor), inserts: sorted };
 };
@@ -95924,9 +95941,10 @@ const buildOffsetMapper = (inserts) => {
     // Pre-compute each insert's start in repaired-space.
     let acc = 0;
     const segments = inserts.map(ins => {
+        const consumes = ins.consumes ?? 0;
         const repairedStart = ins.offset + acc;
-        acc += ins.text.length;
-        return { origOffset: ins.offset, len: ins.text.length, repairedStart };
+        acc += ins.text.length - consumes;
+        return { origOffset: ins.offset, consumes, len: ins.text.length, repairedStart };
     });
     return (repaired) => {
         // Offsets inside an insert's synthetic span have no original counterpart;
@@ -95934,7 +95952,7 @@ const buildOffsetMapper = (inserts) => {
         const hit = segments.find(seg => seg.repairedStart < repaired && repaired < seg.repairedStart + seg.len);
         if (hit)
             return hit.origOffset;
-        const shift = segments.reduce((acc2, seg) => (seg.repairedStart < repaired ? acc2 + seg.len : acc2), 0);
+        const shift = segments.reduce((acc2, seg) => (seg.repairedStart < repaired ? acc2 + seg.len - seg.consumes : acc2), 0);
         return repaired - shift;
     };
 };
@@ -96113,6 +96131,43 @@ const HTML_VOID_ELEMENTS = new Set([
 
 
 const isStandardHtmlTag = (name) => STANDARD_HTML_TAGS.has(name.toLowerCase());
+// Intentionally simpler than htmlparser2: `[^>]*` does not honor `>` inside
+// quoted attribute values. That's acceptable here because the main walker
+// (htmlparser2) handles attribute parsing; this scan only needs to locate
+// orphan closers, which can't appear inside an attribute value anyway.
+const HTML_TAG_TOKEN_RE = /<(\/)?([a-zA-Z][a-zA-Z0-9-]*)\b[^>]*>/g;
+/**
+ * htmlparser2 silently drops closing tags that have no matching opener
+ * (e.g. the trailing `</li>` in `<ul><li>x</ul></li>`), leaving them in the
+ * source makes mdxjs choke on the dangling closer. Scan the masked
+ * source for `</name>` tokens that don't pair with any prior unmatched
+ * `<name>` and return their spans so the caller can drop them.
+ */
+const findOrphanClosers = (html) => {
+    const masked = maskNonTagRegions(html);
+    const stack = [];
+    const orphans = [];
+    HTML_TAG_TOKEN_RE.lastIndex = 0;
+    let match;
+    while ((match = HTML_TAG_TOKEN_RE.exec(masked)) !== null) {
+        const name = match[2].toLowerCase();
+        // Non-HTML names and void elements are handled by the main walker.
+        // eslint-disable-next-line no-continue
+        if (!isStandardHtmlTag(name) || HTML_VOID_ELEMENTS.has(name))
+            continue;
+        if (match[1] === '/') {
+            const idx = stack.lastIndexOf(name);
+            if (idx === -1)
+                orphans.push({ offset: match.index, length: match[0].length });
+            else
+                stack.length = idx;
+        }
+        else if (!match[0].endsWith('/>')) {
+            stack.push(name);
+        }
+    }
+    return orphans;
+};
 /**
  * MDX requires a JSX inline tag and its closer to live on the same line — not
  * just the same paragraph. (`<td>\nArray <object>\n</object></td>` still
@@ -96169,6 +96224,7 @@ const repairUnclosedTags = (html) => {
             inserts.push({ offset: findOffsetToPlaceCloser(html, openTag.end, start), text: `</${name}>` });
         },
     });
+    findOrphanClosers(html).forEach(({ offset, length }) => inserts.push({ offset, text: '', consumes: length }));
     return applyInserts(html, inserts);
 };
 
@@ -118598,6 +118654,12 @@ function parseTextChildren(node, processMarkdown, components) {
     node.children = node.children.flatMap(child => {
         if (child.type !== 'text' || !child.value.trim())
             return [child];
+        // Store multiline template-literal children (e.g. {`...\n...`}) as a bare string prop
+        // via node.properties.children so hast-to-hyperscript doesn't wrap them in an array.
+        if (child.value.includes('\n')) {
+            node.properties = { ...node.properties, children: child.value };
+            return [];
+        }
         const hast = processMarkdown(child.value.trim());
         const children = (hast.children ?? []).filter(isElementContentNode);
         // For inline components, preserve plain text instead of wrapping in <p>
@@ -120749,6 +120811,123 @@ function createTokenize(mode) {
         const isSameCaseAsTag = (code) => isLowercaseTag
             ? code >= codes.lowercaseA && code <= codes.lowercaseZ
             : code >= codes.uppercaseA && code <= codes.uppercaseZ;
+        // Shared brace-expression state machine. The two call sites differ only in where
+        // to continue after a line ending and where to return when braceDepth reaches zero.
+        function createBraceExprStates(continuationStart, afterBraceClose) {
+            function braceExpr(code) {
+                if (code === null)
+                    return nok(code);
+                if (markdownLineEnding(code)) {
+                    if (!isFlow)
+                        return nok(code);
+                    effects.exit('mdxComponentData');
+                    return continuationStart(code);
+                }
+                if (code === codes.quotationMark || code === codes.apostrophe) {
+                    quoteChar = code;
+                    effects.consume(code);
+                    return braceString;
+                }
+                if (code === codes.graveAccent) {
+                    inTemplateLit = true;
+                    effects.consume(code);
+                    return braceTemplateLiteral;
+                }
+                if (code === codes.leftCurlyBrace) {
+                    braceDepth += 1;
+                    effects.consume(code);
+                    return braceExpr;
+                }
+                if (code === codes.rightCurlyBrace) {
+                    braceDepth -= 1;
+                    effects.consume(code);
+                    if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
+                        templateStack.pop();
+                        inTemplateLit = true;
+                        return braceTemplateLiteral;
+                    }
+                    if (braceDepth === 0) {
+                        return afterBraceClose;
+                    }
+                    return braceExpr;
+                }
+                effects.consume(code);
+                return braceExpr;
+            }
+            function braceString(code) {
+                if (code === null)
+                    return nok(code);
+                if (markdownLineEnding(code)) {
+                    if (!isFlow)
+                        return nok(code);
+                    effects.exit('mdxComponentData');
+                    return continuationStart(code);
+                }
+                if (code === codes.backslash) {
+                    effects.consume(code);
+                    return braceStringEscape;
+                }
+                if (code === quoteChar) {
+                    effects.consume(code);
+                    quoteChar = null;
+                    return braceExpr;
+                }
+                effects.consume(code);
+                return braceString;
+            }
+            function braceStringEscape(code) {
+                if (code === null || markdownLineEnding(code)) {
+                    return braceString(code);
+                }
+                effects.consume(code);
+                return braceString;
+            }
+            function braceTemplateLiteral(code) {
+                if (code === null)
+                    return nok(code);
+                if (markdownLineEnding(code)) {
+                    if (!isFlow)
+                        return nok(code);
+                    effects.exit('mdxComponentData');
+                    return continuationStart(code);
+                }
+                if (code === codes.graveAccent) {
+                    inTemplateLit = false;
+                    effects.consume(code);
+                    return braceExpr;
+                }
+                if (code === codes.backslash) {
+                    effects.consume(code);
+                    return braceTemplateLiteralEscape;
+                }
+                if (code === codes.dollarSign) {
+                    effects.consume(code);
+                    return braceTemplateLiteralDollar;
+                }
+                effects.consume(code);
+                return braceTemplateLiteral;
+            }
+            function braceTemplateLiteralEscape(code) {
+                if (code === null || markdownLineEnding(code)) {
+                    return braceTemplateLiteral(code);
+                }
+                effects.consume(code);
+                return braceTemplateLiteral;
+            }
+            function braceTemplateLiteralDollar(code) {
+                if (code === codes.leftCurlyBrace) {
+                    templateStack.push(braceDepth);
+                    braceDepth += 1;
+                    inTemplateLit = false;
+                    effects.consume(code);
+                    return braceExpr;
+                }
+                return braceTemplateLiteral(code);
+            }
+            return { braceExpr, braceString, braceTemplateLiteral };
+        }
+        const { braceExpr: inBraceExpr, braceString: inBraceString, braceTemplateLiteral: inBraceTemplateLiteral, } = createBraceExprStates(openTagContinuationStart, afterOpenTagName);
+        const { braceExpr: inBodyBraceExpr, braceString: inBodyBraceString, braceTemplateLiteral: inBodyBraceTemplateLiteral, } = createBraceExprStates(bodyContinuationStart, body);
         return start;
         // ── Start ──────────────────────────────────────────────────────────────
         function start(code) {
@@ -120871,126 +121050,6 @@ function createTokenize(mode) {
             effects.consume(code);
             return inQuotedAttr;
         }
-        function inBraceExpr(code) {
-            if (code === null)
-                return nok(code);
-            if (markdownLineEnding(code)) {
-                if (!isFlow)
-                    return nok(code);
-                effects.exit('mdxComponentData');
-                return openTagContinuationStart(code);
-            }
-            // Handle strings inside braces
-            if (code === codes.quotationMark || code === codes.apostrophe) {
-                quoteChar = code;
-                effects.consume(code);
-                return inBraceString;
-            }
-            // Handle template literals inside braces
-            if (code === codes.graveAccent) {
-                inTemplateLit = true;
-                effects.consume(code);
-                return inBraceTemplateLiteral;
-            }
-            if (code === codes.leftCurlyBrace) {
-                braceDepth += 1;
-                effects.consume(code);
-                return inBraceExpr;
-            }
-            if (code === codes.rightCurlyBrace) {
-                braceDepth -= 1;
-                effects.consume(code);
-                // Check if this } closes a ${...} interpolation
-                if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
-                    templateStack.pop();
-                    inTemplateLit = true; // back inside the template literal
-                    return inBraceTemplateLiteral;
-                }
-                if (braceDepth === 0) {
-                    return afterOpenTagName;
-                }
-                return inBraceExpr;
-            }
-            effects.consume(code);
-            return inBraceExpr;
-        }
-        function inBraceString(code) {
-            if (code === null)
-                return nok(code);
-            if (markdownLineEnding(code)) {
-                if (!isFlow)
-                    return nok(code);
-                effects.exit('mdxComponentData');
-                return openTagContinuationStart(code);
-            }
-            if (code === codes.backslash) {
-                effects.consume(code);
-                return inBraceStringEscape;
-            }
-            if (code === quoteChar) {
-                effects.consume(code);
-                quoteChar = null;
-                return inBraceExpr;
-            }
-            effects.consume(code);
-            return inBraceString;
-        }
-        function inBraceStringEscape(code) {
-            if (code === null || markdownLineEnding(code)) {
-                return inBraceString(code);
-            }
-            effects.consume(code);
-            return inBraceString;
-        }
-        // ── Template literal handling inside brace expressions ─────────────────
-        function inBraceTemplateLiteral(code) {
-            if (code === null)
-                return nok(code);
-            if (markdownLineEnding(code)) {
-                if (!isFlow)
-                    return nok(code);
-                effects.exit('mdxComponentData');
-                return openTagContinuationStart(code);
-            }
-            // Closing backtick ends the template literal
-            if (code === codes.graveAccent) {
-                inTemplateLit = false;
-                effects.consume(code);
-                return inBraceExpr;
-            }
-            // Backslash escape (e.g., \` or \$)
-            if (code === codes.backslash) {
-                effects.consume(code);
-                return inBraceTemplateLiteralEscape;
-            }
-            // ${ starts an interpolation
-            if (code === codes.dollarSign) {
-                effects.consume(code);
-                return inBraceTemplateLiteralDollar;
-            }
-            effects.consume(code);
-            return inBraceTemplateLiteral;
-        }
-        function inBraceTemplateLiteralEscape(code) {
-            if (code === null || markdownLineEnding(code)) {
-                return inBraceTemplateLiteral(code);
-            }
-            effects.consume(code);
-            return inBraceTemplateLiteral;
-        }
-        function inBraceTemplateLiteralDollar(code) {
-            if (code === codes.leftCurlyBrace) {
-                // Enter ${...} interpolation. Save current braceDepth so we know
-                // when the matching } returns us to this template literal.
-                templateStack.push(braceDepth);
-                braceDepth += 1;
-                inTemplateLit = false; // now inside interpolation expression
-                effects.consume(code);
-                return inBraceExpr;
-            }
-            // Just a $ not followed by { — back to template literal
-            return inBraceTemplateLiteral(code);
-        }
         function selfCloseGt(code) {
             if (code === codes.greaterThan) {
                 effects.consume(code);
@@ -121060,6 +121119,15 @@ function createTokenize(mode) {
                 codeSpanOpenSize = 0;
                 return countOpenTicks(code);
             }
+            // JSX expression child — track braces/template literals so the closing
+            // backtick of `{`...`}` is not misread as a code span opener
+            if (code === codes.leftCurlyBrace) {
+                braceDepth = 1;
+                inTemplateLit = false;
+                effects.consume(code);
+                atLineStart = false;
+                return inBodyBraceExpr;
+            }
             effects.consume(code);
             atLineStart = false;
             return body;
@@ -121300,6 +121368,14 @@ function createTokenize(mode) {
                 return bodyContinuationStart(code);
             }
             effects.enter('mdxComponentData');
+            // Resume inside a body brace expression if a line ending interrupted one
+            if (braceDepth > 0) {
+                if (inTemplateLit)
+                    return inBodyBraceTemplateLiteral(code);
+                if (quoteChar !== null)
+                    return inBodyBraceString(code);
+                return inBodyBraceExpr(code);
+            }
             // Detect tilde fences at line start
             if (atLineStart && code === codes.tilde) {
                 return bodyAfterLineStart(code);
@@ -121402,7 +121478,8 @@ const buildInlineMdProcessor = (safeMode) => {
     // 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 });
+        // We include both flow and text extensions to support both single-line and multi-line expressions
+        micromarkExts.push({ flow: mdxExprExt.flow, text: mdxExprExt.text });
         fromMarkdownExts.push(mdxExpressionFromMarkdown());
     }
     return unified()
@@ -122060,7 +122137,7 @@ const createEvaluatedNode = (result, position) => {
     else if (typeof result === 'object') {
         return { type: 'text', value: JSON.stringify(result), position };
     }
-    return { type: 'text', value: String(result).replace(/\s+/g, ' ').trim(), position };
+    return { type: 'text', value: String(result), position };
 };
 /**
  * AST transformer to evaluate MDX expressions.
@@ -123770,7 +123847,7 @@ const transformAnchor = (jsx) => {
  */
 const transformImage = (jsx) => {
     const attrs = getAttrs(jsx);
-    const { align, alt = '', border, caption, className, height, lazy, src = '', title = '', width } = attrs;
+    const { align, alt = '', border, caption, className, framed, height, lazy, src = '', title = '', width } = attrs;
     const validAlign = toImageAlign(align);
     const sizing = width !== undefined ? String(width) : undefined;
     const hProperties = {
@@ -123781,6 +123858,7 @@ const transformImage = (jsx) => {
         ...(border !== undefined && { border: toBool(border) }),
         ...(caption && { caption }),
         ...(className && { className }),
+        ...(framed !== undefined && { framed: toBool(framed) }),
         ...(height !== undefined && { height: String(height) }),
         ...(lazy !== undefined && { lazy: toBool(lazy) }),
         ...(sizing && { sizing }),
@@ -123794,6 +123872,7 @@ const transformImage = (jsx) => {
         caption,
         children: caption ? lib_mdast(caption).children : [],
         className,
+        framed: toBool(framed),
         height: height !== undefined ? String(height) : undefined,
         lazy: toBool(lazy),
         sizing,
@@ -124162,6 +124241,14 @@ const mdxishJsxToMdast = () => tree => {
         else if (node.border !== undefined) {
             node.border = toBool(node.border);
         }
+        if (hProps.framed !== undefined) {
+            const val = toBool(hProps.framed);
+            node.framed = val;
+            hProps.framed = val;
+        }
+        else if (node.framed !== undefined) {
+            node.framed = toBool(node.framed);
+        }
         // Validate align
         const validAlign = toImageAlign(hProps.align) || toImageAlign(node.align);
         node.align = validAlign;
@@ -124616,11 +124703,30 @@ function normalizeTableSeparator(content) {
 
 ;// ./processor/transform/mdxish/terminate-html-flow-blocks.ts
 
+
 const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
 const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
+const terminate_html_flow_blocks_TABLE_STRUCTURE_TAGS = ['table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th', 'caption', 'colgroup'];
+// Tags whose contents must be preserved as is, inserting a blank line after the
+// opener corrupts the payload.
+// htmlRawNames here refer to <pre>, <textarea>, <script>, <style>
+const RAW_CONTENT_TAGS = [...htmlRawNames, ...terminate_html_flow_blocks_TABLE_STRUCTURE_TAGS];
+// The `(?=[\s/>])` lookahead avoids false matches on lookalike names like `<script-foo>`.
+const RAW_CONTENT_TAG_MATCHERS = RAW_CONTENT_TAGS.map(tag => ({
+    open: new RegExp(`<${tag}(?=[\\s/>])[^>]*?(?<!/)>`, 'gi'),
+    close: new RegExp(`</${tag}(?=[\\s>])[^>]*>`, 'gi'),
+}));
 function isLineHtml(line) {
     return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
 }
+// True if any RAW_CONTENT_TAGS opener on this line is not closed on the same line.
+function hasUnclosedRawContentOpener(line) {
+    return RAW_CONTENT_TAG_MATCHERS.some(({ open, close }) => {
+        const opens = (line.match(open) ?? []).length;
+        const closes = (line.match(close) ?? []).length;
+        return opens > closes;
+    });
+}
 /**
  * Preprocessor to terminate HTML flow blocks.
  *
@@ -124631,15 +124737,16 @@ function isLineHtml(line) {
  *
  * @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 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.
+ * This preprocessor inserts a blank line after standalone HTML lines when the next
+ * line is non-blank and not an HTML construct, ensuring micromark's HTML flow
+ * tokenizer terminates and subsequent content is parsed independently.
  *
  * 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.
- * 2. Lines inside protected blocks (e.g., code blocks) should be left untouched.
+ * 1. Only non-indented lines with lowercase tag names are considered. Uppercase tags
+ *    (e.g. `<Table>`, `<MyComponent>`) are JSX custom components and don't trigger
+ *    CommonMark HTML blocks.
+ * 2. Lines inside protected blocks (e.g. fenced code) are left untouched.
+ * 3. Lines with an unclosed RAW_CONTENT_TAGS opener are exempted.
  */
 function terminateHtmlFlowBlocks(content) {
     const { protectedContent, protectedCode } = protectCodeBlocks(content);
@@ -124654,7 +124761,7 @@ function terminateHtmlFlowBlocks(content) {
         }
         const isCurrentLineHtml = isLineHtml(lines[i]);
         const isNextLineHtml = isLineHtml(lines[i + 1]);
-        if (isCurrentLineHtml && !isNextLineHtml) {
+        if (isCurrentLineHtml && !isNextLineHtml && !hasUnclosedRawContentOpener(lines[i])) {
             result.push('');
         }
     }
@@ -125472,8 +125579,8 @@ function mdxish(mdContent, opts = {}) {
     const { processor, parserReadyContent } = mdxishAstProcessor(contentWithoutComments, opts);
     processor
         .use(safeMode ? undefined : evaluate_exports) // Evaluate `export const/function` and stash scope on file.data.mdxishScope
+        .use(remarkBreaks) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
         .use(safeMode ? undefined : evaluate_expressions) // Evaluate self-contained MDX expressions (e.g. `{1+1}`)
-        .use(remarkBreaks)
         .use(variables_code, { variables }) // Resolve <<...>> and {user.*} inside code and inline code nodes
         .use(remarkRehype, { allowDangerousHtml: true, handlers: mdxComponentHandlers })
         .use(preserveBooleanProperties) // RehypeRaw converts boolean properties to empty strings
@@ -125725,7 +125832,10 @@ function exportComponentsForRehype(components) {
 function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
-        return external_react_default().createElement(type, { ...rest, ...node.properties }, ...children);
+        const mergedProps = { ...rest, ...node.properties };
+        // Strip undefined so positional args don't shadow node.properties.children
+        const definedChildren = children.filter(c => c !== undefined);
+        return external_react_default().createElement(type, mergedProps, ...definedChildren);
     }
     return external_react_default().createElement(type, props, ...children);
 }