@readme/markdown 14.3.0 → 14.4.1

package/dist/main.js

@@ -11594,6 +11594,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   Components: () => (/* reexport */ components_namespaceObject),
   FLOW_TYPES: () => (/* reexport */ FLOW_TYPES),
+  INLINE_ONLY_PARENT_TYPES: () => (/* reexport */ INLINE_ONLY_PARENT_TYPES),
   NodeTypes: () => (/* reexport */ NodeTypes),
   Owlmoji: () => (/* reexport */ Owlmoji),
   compile: () => (/* reexport */ lib_compile),
@@ -12208,9 +12209,10 @@ const LightboxPortal = ({ children }) => {
     return (0,external_amd_react_dom_commonjs2_react_dom_commonjs_react_dom_root_ReactDOM_umd_react_dom_.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_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.useState(false);
     if (className === 'emoji') {
         return external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("img", { alt: alt, height: height, loading: lazy ? 'lazy' : 'eager', src: src, title: title, width: width });
@@ -12239,7 +12241,10 @@ const Image = (Props) => {
             return;
         setLightbox(!lightbox);
     };
-    const imgElement = (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_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_amd_react_commonjs_react_commonjs2_react_root_React_umd_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_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { "aria-label": ariaLabel, className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
+        external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { className: "lightbox-inner" }, content)));
     const lightboxOverlay = lightbox ? (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement(LightboxPortal, null,
         external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("div", { className: "markdown-body" },
             external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { "aria-label": alt || 'Collapse image', className: "img lightbox open", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
@@ -12248,17 +12253,27 @@ const Image = (Props) => {
                     (children || caption) && external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figcaption", null, children || caption))),
             external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("button", { "aria-label": "Minimize image", className: "lightbox-close", onClick: toggle, type: "button" },
                 external_amd_react_commonjs_react_commonjs2_react_root_React_umd_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_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figure", { className: frameClass },
+                closedLightbox(alt || 'Expand image', imgElement),
+                lightboxOverlay,
+                external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figcaption", null, children || caption)));
+        }
+        return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("div", { className: frameClass },
+            closedLightbox(alt || 'Expand image', imgElement),
+            lightboxOverlay));
+    }
     if (children || caption) {
         return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figure", null,
-            external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { "aria-label": alt, className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
-                external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { className: "lightbox-inner" },
-                    imgElement,
-                    external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figcaption", null, children || caption))),
+            closedLightbox(alt || 'Expand image', external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement(external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.Fragment, null,
+                imgElement,
+                external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("figcaption", null, children || caption))),
             lightboxOverlay));
     }
     return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement(external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.Fragment, null,
-        external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { "aria-label": "Expand image", className: "img lightbox closed", onClick: toggle, onKeyDown: handleKeyDown, role: 'button', tabIndex: 0 },
-            external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.createElement("span", { className: "lightbox-inner" }, imgElement)),
+        closedLightbox('Expand image', imgElement),
         lightboxOverlay));
 };
 /* harmony default export */ const components_Image = (Image);
@@ -12496,12 +12511,14 @@ const Tab = ({ children }) => {
 };
 const Tabs = ({ children }) => {
     const [activeTab, setActiveTab] = (0,external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_.useState)(0);
+    // React passes `children` as a single element when there's only one child, so normalize.
+    const tabs = external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().Children.toArray(children);
     return (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("div", { className: "TabGroup" },
         external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("header", null,
-            external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("nav", { className: "TabGroup-nav" }, children?.map((tab, index) => (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("button", { key: tab.props.title, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
+            external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("nav", { className: "TabGroup-nav" }, tabs.map((tab, index) => (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("button", { key: tab.props.title, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
                 tab.props.icon && (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("i", { className: `TabGroup-icon fa-duotone fa-solid ${tab.props.icon}`, style: { color: `${tab.props.iconColor}` } })),
                 tab.props.title))))),
-        external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("section", null, children && children[activeTab])));
+        external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement("section", null, tabs[activeTab])));
 };
 /* harmony default export */ const components_Tabs = (Tabs);
 
@@ -13045,6 +13062,34 @@ const FLOW_TYPES = new Set([
     'table',
     'thematicBreak',
 ]);
+/**
+ * MDAST parent types whose children are restricted to inline content. A block-level
+ * node placed inside any of these violates the parent's content model and breaks
+ * downstream consumers
+ *
+ * Derived from the mdast spec. Seven of these are direct "phrasing content" parents:
+ *   - paragraph, heading, link, linkReference, emphasis, strong
+ *   - tableCell (phrasing minus Break)
+ *
+ * @link {https://github.com/syntax-tree/mdast}
+ *
+ * `delete` is GFM and has *transparent* content, see:
+ * @link {https://github.com/syntax-tree/mdast-util-gfm-strikethrough}
+ *
+ * its children must also be phrasing, so it belongs here too.
+ *
+ * NOTE: exported so downstream consumers can reuse and not drift away
+ */
+const INLINE_ONLY_PARENT_TYPES = new Set([
+    'paragraph',
+    'heading',
+    'tableCell',
+    'link',
+    'linkReference',
+    'emphasis',
+    'strong',
+    'delete',
+]);
 // HELPER CONSTANTS FOR MDXISH RENDERING
 /**
  * Inline-only custom components that appear as phrasing content within
@@ -75527,7 +75572,15 @@ const walkTags = (html, handlers) => {
     const tagEnd = (parser) => (parser.endIndex ?? parser.startIndex) + 1;
     const parser = new Parser_Parser({
         onopentag(name) {
-            handlers.onOpen?.({ name, start: parser.startIndex, end: tagEnd(parser) });
+            const start = parser.startIndex;
+            const end = tagEnd(parser);
+            handlers.onOpen?.({
+                name,
+                start,
+                end,
+                isSelfClosing: html[end - 2] === '/',
+                isStrayCloser: html[start + 1] === '/',
+            });
         },
         onclosetag(name, implicit) {
             handlers.onClose?.({ name, start: parser.startIndex, end: tagEnd(parser), implicit });
@@ -75582,13 +75635,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 };
 };
@@ -75700,9 +75754,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;
@@ -75710,7 +75765,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;
     };
 };
@@ -75889,6 +75944,48 @@ 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;
+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();
+        // eslint-disable-next-line no-continue
+        if (!isStandardHtmlTag(name))
+            continue;
+        // Special case for <br>: htmlparser2 will normalize orphan </br> to <br>
+        // so we don't need to handle it here.
+        // eslint-disable-next-line no-continue
+        if (name === 'br' && match[1] === '/')
+            continue;
+        const isVoid = HTML_VOID_ELEMENTS.has(name);
+        if (match[1] === '/') {
+            // Other void closers (`</hr>`, `</img>`, ...) have no HTML5 rewrite rule
+            // and must be stripped before the strict mdxjs parse runs.
+            if (isVoid) {
+                orphans.push({ offset: match.index, length: match[0].length });
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            const idx = stack.lastIndexOf(name);
+            if (idx === -1)
+                orphans.push({ offset: match.index, length: match[0].length });
+            else
+                stack.length = idx;
+        }
+        else if (!isVoid && !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
@@ -75916,7 +76013,7 @@ const repairUnclosedTags = (html) => {
     const inserts = [];
     const openTags = [];
     walkTags(html, {
-        onOpen({ name, start, end }) {
+        onOpen({ name, start, end, isSelfClosing, isStrayCloser }) {
             // Escape non-HTML names (custom components, typos, `<arbitrary-tag>`)
             // so MDX treats them as literal text instead of expecting a closer
             if (!isStandardHtmlTag(name)) {
@@ -75924,12 +76021,19 @@ const repairUnclosedTags = (html) => {
                 return;
             }
             if (HTML_VOID_ELEMENTS.has(name.toLowerCase())) {
-                // MDX requires void elements to be self-closing (`<br/>`, not `<br>`).
-                // If the source open tag doesn't end with `/`, inject one before the
-                // `>` so it parses. `end` is one past `>`, so `end - 2` is the char
-                // immediately before `>`.
-                if (html[end - 2] !== '/')
+                // MDX requires void elements to be self-closing (`<br/>`, not `<br>`)
+                // so we need to rewrite them to self closing tags.
+                if (isStrayCloser) {
+                    // htmlparser2 may normalize some stray closers like `</br>` into opener
+                    // events <br> per the HTML5 spec. In this case remove the closing /
+                    // and fully rewrite the tag to self closing.
+                    inserts.push({ offset: start, text: `<${name}/>`, consumes: end - start });
+                    return;
+                }
+                else if (!isSelfClosing) {
+                    // Slots in the / right before the closing >
                     inserts.push({ offset: end - 1, text: '/' });
+                }
                 return;
             }
             openTags.push({ name, start, end });
@@ -75945,6 +76049,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);
 };
 
@@ -98374,6 +98479,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>
@@ -100525,6 +100636,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) {
@@ -100647,126 +100875,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);
@@ -100836,6 +100944,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;
@@ -101076,6 +101193,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);
@@ -101178,7 +101303,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()
@@ -101836,7 +101962,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.
@@ -103325,6 +103451,7 @@ const mdxishHtmlBlocks = () => tree => {
 
 
 
+
 function toImageAlign(value) {
     if (value === 'left' || value === 'center' || value === 'right') {
         return value;
@@ -103546,7 +103673,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 = {
@@ -103557,6 +103684,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 }),
@@ -103570,6 +103698,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,
@@ -103875,16 +104004,12 @@ const mdxishJsxToMdast = () => tree => {
             parent.children[index] = newNode;
         }
     });
-    // Transform magic block images (type: 'image') to image-block
-    // Images inside paragraphs are standard markdown — handled by imageTransformer, normalized below
+    // Promote magic-block images (type: 'image') to image-block, except inside inline-only
+    // parents where the image must stay inline (authors use `<Image caption="…" />` instead).
     visit(tree, 'image', (node, index, parent) => {
         if (!parent || index === undefined)
             return SKIP;
-        if (parent.type === 'paragraph')
-            return SKIP;
-        // `![](url)` in any tableCell stays inline. Authors who want a captioned figure use
-        // `<Image caption="…" />` JSX, which becomes `image-block` via `COMPONENT_MAP` above.
-        if (parent.type === 'tableCell')
+        if (INLINE_ONLY_PARENT_TYPES.has(parent.type))
             return SKIP;
         const newNode = transformMagicBlockImage(node);
         parent.children[index] = newNode;
@@ -103938,6 +104063,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;
@@ -104392,11 +104525,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.
  *
@@ -104407,15 +104559,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);
@@ -104430,7 +104583,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('');
         }
     }
@@ -105248,8 +105401,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
@@ -105501,7 +105654,10 @@ function exportComponentsForRehype(components) {
 function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
-        return external_amd_react_commonjs_react_commonjs2_react_root_React_umd_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_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement(type, mergedProps, ...definedChildren);
     }
     return external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default().createElement(type, props, ...children);
 }