@readme/markdown 14.11.3 → 14.11.5

package/dist/render-fixture.node.js

@@ -68490,6 +68490,21 @@ function evaluate(source, scope = {}) {
     // eslint-disable-next-line no-new-func
     return new Function(...names, `return (${source})`)(...values);
 }
+/**
+ * Advance a `Point` by the `consumed` substring that follows it, returning the
+ * point at the consumed string's end. Lets split-out sub-nodes carry accurate
+ * document positions so downstream offset shifting stays correct.
+ */
+const pointAfter = (start, consumed) => {
+    const newlineIndex = consumed.lastIndexOf('\n');
+    const newlineCount = newlineIndex === -1 ? 0 : consumed.split('\n').length - 1;
+    return {
+        line: start.line + newlineCount,
+        // Same line → advance the base column; a later line → column is the run since its newline.
+        column: newlineCount === 0 ? start.column + consumed.length : consumed.length - newlineIndex,
+        offset: (start.offset ?? 0) + consumed.length,
+    };
+};
 /**
  * Formats the hProperties of a node as a string, so they can be compiled back into JSX/MDX.
  * This currently sets all the values to a string since we process/compile the MDX on the fly
@@ -92168,10 +92183,10 @@ const Tabs = ({ children }) => {
     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" }, tabs.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.key, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
                 tab.props.icon && (external_react_default().createElement(components_Icon, { className: "TabGroup-icon", icon: tab.props.icon, iconColor: tab.props.iconColor })),
                 tab.props.title))))),
-        external_react_default().createElement("section", null, tabs[activeTab])));
+        external_react_default().createElement("section", null, tabs.map((tab, index) => (external_react_default().createElement("div", { key: tab.key, hidden: index !== activeTab }, tab))))));
 };
 /* harmony default export */ const components_Tabs = (Tabs);
 
@@ -95970,6 +95985,108 @@ const applyInserts = (html, inserts) => {
     return { value: out + html.slice(cursor), inserts: sorted };
 };
 
+;// ./processor/transform/mdxish/tables/escape-crossing-emphasis.ts
+
+
+
+// Maximal run of a single emphasis delimiter (`_`, `*`, `**`, `***`, …).
+const EMPHASIS_RUN_RE = /([*_])\1*/g;
+// String bounds (undefined) count as whitespace, not punctuation, per the
+// CommonMark flanking definition.
+const escape_crossing_emphasis_isWhitespace = (ch) => ch === undefined || unicodeWhitespace(ch.charCodeAt(0));
+const isPunctuation = (ch) => ch !== undefined && unicodePunctuation(ch.charCodeAt(0));
+/**
+ * Whether a delimiter run can open and/or close emphasis, per CommonMark's
+ * left/right-flanking rules. The extra `_` conditions forbid intraword
+ * emphasis, which keeps `snake_case` from being treated as a delimiter.
+ */
+const analyzeFlanking = (source, char, start, end) => {
+    const before = source[start - 1];
+    const after = source[end];
+    const leftFlanking = !escape_crossing_emphasis_isWhitespace(after) && (!isPunctuation(after) || escape_crossing_emphasis_isWhitespace(before) || isPunctuation(before));
+    const rightFlanking = !escape_crossing_emphasis_isWhitespace(before) && (!isPunctuation(before) || escape_crossing_emphasis_isWhitespace(after) || isPunctuation(after));
+    if (char === '_') {
+        return {
+            canOpen: leftFlanking && (!rightFlanking || isPunctuation(before)),
+            canClose: rightFlanking && (!leftFlanking || isPunctuation(after)),
+        };
+    }
+    return { canOpen: leftFlanking, canClose: rightFlanking };
+};
+/**
+ * Collect HTML tag boundaries (via htmlparser2) and emphasis delimiter runs
+ * (via regex over the masked source, so code spans and escaped `<` are skipped)
+ * into one list ordered by position. At a shared offset a tag opener sorts
+ * before a closer, so a self-closing tag brackets rather than swallows a run.
+ */
+const collectEvents = (html) => {
+    const masked = maskNonTagRegions(html);
+    const events = [];
+    walkTags(html, {
+        onOpen: ({ start }) => events.push({ kind: 'tagOpen', offset: start }),
+        onClose: ({ start }) => events.push({ kind: 'tagClose', offset: start }),
+    });
+    EMPHASIS_RUN_RE.lastIndex = 0;
+    let match;
+    while ((match = EMPHASIS_RUN_RE.exec(masked)) !== null) {
+        const [run, char] = match;
+        const start = match.index;
+        // eslint-disable-next-line no-continue
+        if (html[start - 1] === '\\')
+            continue; // already escaped
+        events.push({ kind: 'emphasis', offset: start, char, length: run.length, flanking: analyzeFlanking(html, char, start, start + run.length) });
+    }
+    return events.sort((a, b) => a.offset - b.offset || (a.kind === 'tagClose' ? 1 : 0) - (b.kind === 'tagClose' ? 1 : 0));
+};
+/**
+ * mdxjs rejects a table when a markdown emphasis run opens at one HTML
+ * tag-nesting depth and closes at another — e.g. `_<ul><li>text_</li></ul>`,
+ * where the `_` opens outside the list but closes inside a `<li>`. It throws
+ * "Expected a closing tag for `<li>` before the end of `emphasis`" and the
+ * whole `<Table>` fails to parse.
+ *
+ * We walk tags and emphasis together, tracking tag depth and a stack of open
+ * emphasis. A delimiter only closes an opener at the same depth; any emphasis
+ * still open when its enclosing tag closes (or at end of input), and any closer
+ * with no same-depth opener, is escaped so mdxjs treats it as literal text.
+ * Scoped to the malformed-retry path.
+ */
+const escapeCrossingEmphasis = (html) => {
+    const open = [];
+    const orphans = [];
+    let depth = 0;
+    collectEvents(html).forEach(event => {
+        if (event.kind === 'tagOpen') {
+            depth += 1;
+            return;
+        }
+        if (event.kind === 'tagClose') {
+            depth -= 1;
+            // Emphasis opened deeper than the surviving depth was inside the tag that
+            // just closed, so it crosses the boundary.
+            while (open.length > 0 && open[open.length - 1].depth > depth) {
+                const crossed = open.pop();
+                if (crossed)
+                    orphans.push(crossed);
+            }
+            return;
+        }
+        const top = open[open.length - 1];
+        if (event.flanking.canClose && top?.char === event.char && top.depth === depth) {
+            open.pop();
+        }
+        else if (event.flanking.canOpen) {
+            open.push({ char: event.char, depth, offset: event.offset, length: event.length });
+        }
+        else if (event.flanking.canClose) {
+            orphans.push({ offset: event.offset, length: event.length });
+        }
+    });
+    orphans.push(...open); // anything still open never closed
+    const inserts = orphans.flatMap(({ offset, length }) => Array.from({ length }, (_unused, i) => ({ offset: offset + i, text: '\\' })));
+    return applyInserts(html, inserts);
+};
+
 ;// ./processor/transform/mdxish/tables/escape-stray-less-than.ts
 
 
@@ -96122,6 +96239,21 @@ const buildOffsetMapper = (inserts) => {
         return repaired - shift;
     };
 };
+/**
+ * Compose the per-repair offset mappers into one that maps an offset in the
+ * fully-repaired string back to the original. `layers` are in application
+ * order; each maps its own output space to its input space, so we apply them
+ * last-repair-first to peel every edit back to the original coordinates.
+ */
+const composeOffsetMapper = (layers) => {
+    const mappers = layers.map(buildOffsetMapper);
+    return (repaired) => {
+        let offset = repaired;
+        for (let i = mappers.length - 1; i >= 0; i -= 1)
+            offset = mappers[i](offset);
+        return offset;
+    };
+};
 /**
  * Map an offset in `source` to its 1-based `{ line, column }`. `lineStarts`
  * is the precomputed array of offsets where each line begins.
@@ -96149,14 +96281,11 @@ const computeLineStarts = (source) => {
 };
 /**
  * Walk `tree`, translating every node's position from the repaired source's
- * coordinate space back to the original source. Offsets are remapped via the
- * insert list; line/column are recomputed from the original source so they
- * remain accurate even if repairs introduced newlines.
+ * coordinate space back to the original source via `mapOffset`. Line/column
+ * are recomputed from the original source so they remain accurate even if
+ * repairs introduced newlines.
  */
-const remapPositionsToOriginal = (tree, originalSource, inserts) => {
-    if (inserts.length === 0)
-        return;
-    const mapOffset = buildOffsetMapper(inserts);
+const remapWithMapper = (tree, originalSource, mapOffset) => {
     const lineStarts = computeLineStarts(originalSource);
     lib_visit(tree, child => {
         if (child.position?.start) {
@@ -96175,6 +96304,15 @@ const remapPositionsToOriginal = (tree, originalSource, inserts) => {
         }
     });
 };
+/**
+ * Remap positions produced after a chain of repairs (each applied to the prior
+ * one's output) back to the original source coordinates.
+ */
+const remapPositionsThroughLayers = (tree, originalSource, layers) => {
+    if (layers.length === 0)
+        return;
+    remapWithMapper(tree, originalSource, composeOffsetMapper(layers));
+};
 
 ;// ./processor/transform/mdxish/tables/repair-expression-escapes.ts
 
@@ -96474,6 +96612,83 @@ const repairUnclosedTags = (html) => {
     return applyInserts(html, inserts);
 };
 
+;// ./processor/transform/mdxish/tables/split-nested-tables.ts
+
+
+const TOP_LEVEL_TABLE_TAG_RE = /^<(?:table|Table)(?=[\s/>])/;
+/**
+ * Find every balanced, depth-matched `<table>…</table>` range in an html string.
+ * Uses `walkTags` so `<table>`s inside code spans / fenced blocks (masked away)
+ * are never matched.
+ *
+ * Note: An implicitly-closed table (no `</table>`, so htmlparser2 synthesizes the
+ * close at a later tag) is skipped: splitting there would swallow whatever
+ * followed the table into the fragment and drop it, so we leave such a node
+ * whole for downstream raw-HTML handling instead.
+ */
+const findTableRanges = (html) => {
+    const ranges = [];
+    let depth = 0;
+    let start = 0;
+    walkTags(html, {
+        onOpen: ({ name, start: openStart, isStrayCloser }) => {
+            if (name.toLowerCase() !== 'table' || isStrayCloser)
+                return;
+            if (depth === 0)
+                start = openStart;
+            depth += 1;
+        },
+        onClose: ({ name, end, implicit }) => {
+            if (implicit || name.toLowerCase() !== 'table' || depth === 0)
+                return;
+            depth -= 1;
+            if (depth === 0)
+                ranges.push({ start, end });
+        },
+    });
+    return ranges;
+};
+/**
+ * Given an HTML node that might contain table sequences inside it, split
+ * the node based on the table boundaries so they become a top level node.
+ *
+ * The surrounding raw HTML (the wrapper's open/close tags) would be re-nested
+ * around the parsed tables by rehype-raw.
+ *
+ * Returns null when there is no wrapped table to extract.
+ */
+const splitHtmlWithNestedTables = (node) => {
+    const { value } = node;
+    // This is a top-level table, so we don't need to split it
+    if (TOP_LEVEL_TABLE_TAG_RE.test(value))
+        return null;
+    // No table text anywhere in the value → skip the htmlparser2 walk entirely.
+    if (!/<\/?table/i.test(value))
+        return null;
+    const ranges = findTableRanges(value);
+    if (ranges.length === 0)
+        return null;
+    const base = node.position?.start;
+    const sliceToHtml = (from, to) => ({
+        type: 'html',
+        value: value.slice(from, to),
+        ...(base && {
+            position: { start: pointAfter(base, value.slice(0, from)), end: pointAfter(base, value.slice(0, to)) },
+        }),
+    });
+    const parts = [];
+    let cursor = 0;
+    ranges.forEach(({ start, end }) => {
+        if (start > cursor)
+            parts.push(sliceToHtml(cursor, start));
+        parts.push(sliceToHtml(start, end)); // starts with `<table` → picked up by the main pass
+        cursor = end;
+    });
+    if (cursor < value.length)
+        parts.push(sliceToHtml(cursor, value.length));
+    return parts;
+};
+
 ;// ./processor/transform/mdxish/tables/mdxish-tables.ts
 
 
@@ -96495,6 +96710,8 @@ const repairUnclosedTags = (html) => {
 
 
 
+
+
 
 
 
@@ -96524,6 +96741,21 @@ const buildTableNodeProcessor = (withMdx) => lib_unified()
     .use(lib_remarkGfm);
 const tableNodeProcessor = buildTableNodeProcessor(true);
 const fallbackTableNodeProcessor = buildTableNodeProcessor(false);
+// Targeted repairs for tables mdxjs rejects, tried cumulatively (each runs on
+// the prior's output) since one table can carry independent per-cell defects.
+// Each was added after seeing real customer content fail to parse:
+//  - repairUnclosedTags:      unclosed/orphan HTML tags
+//  - normalizeTagSpacing:     a line mixing text and an opening tag
+//  - repairExpressionEscapes: backslash escapes inside a `{…}` expression
+//  - escapeStrayLessThan:     a `<` that doesn't begin a valid tag (`word <`)
+//  - escapeCrossingEmphasis:  emphasis opening/closing at different tag depths
+const tableRepairs = [
+    repairUnclosedTags,
+    normalizeTagSpacing,
+    repairExpressionEscapes,
+    escapeStrayLessThan,
+    escapeCrossingEmphasis,
+];
 /**
  * Parse the HTML node that contains the full table substring
  * into the table parts (headers, rows, cells).
@@ -96539,10 +96771,10 @@ const parseTableNode = (processor, node, repair) => {
         return undefined;
     }
     // If `node.value` was repaired before parsing, first remap positions back to
-    // the original (unrepaired) coordinates via the insert list — otherwise the
+    // the original (unrepaired) coordinates via the insert layers — otherwise the
     // shift would land on synthetic characters and be inaccurate
     if (repair) {
-        remapPositionsToOriginal(parsed, repair.originalSource, repair.inserts);
+        remapPositionsThroughLayers(parsed, repair.originalSource, repair.layers);
     }
     // The subparser produces positions relative to `node.value`; shift them by
     // the outer node's offset/line so consumers can slice the full source.
@@ -96639,9 +96871,7 @@ const processTableNode = (node, index, parent, documentPosition) => {
     lib_visit(node, utils_isMDXElement, (child) => {
         if (child.name === 'thead')
             hasThead = true;
-        if (tableTags.has(child.name) &&
-            Array.isArray(child.attributes) &&
-            child.attributes.length > 0) {
+        if (tableTags.has(child.name) && Array.isArray(child.attributes) && child.attributes.length > 0) {
             hasStructuralAttributes = true;
         }
     });
@@ -96752,6 +96982,26 @@ const processTableNode = (node, index, parent, documentPosition) => {
     };
     parent.children[index] = mdNode;
 };
+/**
+ * Apply `tableRepairs` cumulatively, re-parsing after every change and stopping
+ * once the accumulated result parses. Each layer's inserts are relative to the
+ * string that repair received, so they stay ordered for position remapping.
+ */
+const repairAndReparse = (node) => {
+    let repairedValue = node.value;
+    const layers = [];
+    let parsed;
+    tableRepairs.some(repair => {
+        const { value, inserts } = repair(repairedValue);
+        if (value === repairedValue)
+            return false;
+        repairedValue = value;
+        layers.push(inserts);
+        parsed = parseTableNode(tableNodeProcessor, { ...node, value: repairedValue }, { layers, originalSource: node.value });
+        return Boolean(parsed);
+    });
+    return parsed;
+};
 /**
  * Converts JSX Table elements to markdown table nodes and re-parses markdown in cells.
  *
@@ -96764,42 +97014,30 @@ const processTableNode = (node, index, parent, documentPosition) => {
  * is kept as a JSX <Table> element so that remarkRehype can properly handle the flow content.
  */
 const mdxish_tables_mdxishTables = () => tree => {
+    // Pre-pass: lift `<table>`s wrapped in a raw HTML block out into their own
+    // html nodes so the main pass below treats them like top-level tables.
+    lib_visit(tree, 'html', (_node, index, parent) => {
+        const node = _node;
+        if (typeof index !== 'number' || !parent || !('children' in parent))
+            return;
+        const parts = splitHtmlWithNestedTables(node);
+        if (!parts)
+            return;
+        // The inserted parts can't re-trigger a split (table parts start with
+        // `<table`; the wrapper slices hold no table), so plain in-place splicing
+        // visits each once without looping.
+        parent.children.splice(index, 1, ...parts);
+    });
     lib_visit(tree, 'html', (_node, index, parent) => {
         const node = _node;
         if (typeof index !== 'number' || !parent || !('children' in parent))
             return;
         if (!node.value.startsWith('<Table') && !node.value.startsWith('<table'))
             return;
-        // Main logic to transform table node to its parts
         // Because the processor uses remarkMdx, it is stricter in what it accepts
-        // and only accepts valid MDX syntax. in the table node.
-        // To get around that, we have some fallback logics after trying to repair the table content.
-        let parsed = parseTableNode(tableNodeProcessor, node);
-        if (!parsed) {
-            // Try a sequence of targeted repairs and re-parse
-            // after each, stopping at the first that yields a parseable tree:
-            //  - repairUnclosedTags:       unclosed/orphan HTML tags
-            //  - normalizeTagSpacing:      a line mixing text and an opening tag
-            //                              (e.g. `text <div> \n <div> text`)
-            //  - repairExpressionEscapes:  backslash escapes inside a `{…}` expression
-            //  - escapeStrayLessThan:      a `<` that doesn't begin a valid tag
-            //                              (e.g. `word <`, `a <1>`)
-            // These repairs are created after seeing real customer content that has failed to parse
-            const repairs = [
-                repairUnclosedTags,
-                normalizeTagSpacing,
-                repairExpressionEscapes,
-                escapeStrayLessThan,
-            ];
-            // Stops at the first repair that yields a parseable tree
-            repairs.some(repair => {
-                const { value, inserts } = repair(node.value);
-                if (value !== node.value) {
-                    parsed = parseTableNode(tableNodeProcessor, { ...node, value }, { inserts, originalSource: node.value });
-                }
-                return Boolean(parsed);
-            });
-        }
+        // and only accepts valid MDX syntax in the table node. To get around that,
+        // fall back to the cumulative repairs when the first parse fails.
+        const parsed = parseTableNode(tableNodeProcessor, node) ?? repairAndReparse(node);
         if (parsed) {
             // If the table is parsed successfully, we can now process it further
             // to build on the markdown / JSX table
@@ -117259,6 +117497,19 @@ const compile_list_item_listItem = (node, parent, state, info) => {
 const plain_plain = (node) => node.value;
 /* harmony default export */ const compile_plain = (plain_plain);
 
+;// ./processor/compile/text.ts
+
+// A `_` flanked by word characters can never open or close emphasis under
+// CommonMark's flanking rules, so the escape mdast-util-to-markdown adds to
+// intraword underscores is unnecessary and only produces noisy `\_` diffs.
+// Uses Unicode letter/number classes so non-ASCII words (e.g. `é_pay`) match.
+const INTRAWORD_UNDERSCORE_ESCAPE = /(?<=[\p{L}\p{N}_])\\_(?=[\p{L}\p{N}_]|\\_)/gu;
+const compile_text_text = (node, parent, state, info) => {
+    const serialized = handle.text(node, parent, state, info);
+    return serialized.replace(INTRAWORD_UNDERSCORE_ESCAPE, '_');
+};
+/* harmony default export */ const compile_text = (compile_text_text);
+
 ;// ./processor/compile/index.ts
 
 
@@ -117271,11 +117522,11 @@ const plain_plain = (node) => node.value;
 
 
 
+
 function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
     const handlers = {
-        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
         [enums_NodeTypes.callout]: compile_callout,
         [enums_NodeTypes.codeTabs]: compile_code_tabs,
         [enums_NodeTypes.embedBlock]: compile_embed,
@@ -117283,15 +117534,18 @@ function compilers(mdxish = false) {
         [enums_NodeTypes.glossary]: compile_compatibility,
         [enums_NodeTypes.htmlBlock]: html_block,
         [enums_NodeTypes.reusableContent]: compile_compatibility,
-        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
         embed: compile_compatibility,
         escape: compile_compatibility,
         figure: compile_compatibility,
         html: compile_compatibility,
         i: compile_compatibility,
-        ...(mdxish && { listItem: list_item }),
         plain: compile_plain,
         yaml: compile_compatibility,
+        // needed only for mdxish
+        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
+        ...(mdxish && { listItem: list_item }),
+        ...(mdxish && { text: compile_text }),
+        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
     };
     toMarkdownExtensions.push({ extensions: [{ handlers }] });
 }
@@ -117668,11 +117922,10 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
 ;// ./processor/plugin/mdxish-handlers.ts
 
 
-// Convert MDX expressions to text nodes (evaluation happens earlier in pipeline)
-const mdxExpressionHandler = (_state, node) => ({
-    type: 'text',
-    value: node.value || '',
-});
+// If hChildren is populated, it means the node holds a renderable value (e.g. React)
+// See evaluate-expressions.ts for more details
+// Otherwise, it's a simple value and we fall back to text
+const mdxExpressionHandler = (_state, node) => node.data?.hChildren ?? { type: 'text', value: node.value || '' };
 // Convert MDX JSX elements to a custom mdx-jsx hast node that bypasses rehypeRaw's
 // HTML serialization round-trip; downstream normalization rewrites it to `element`.
 const mdxJsxElementHandler = (state, node) => {
@@ -120734,81 +120987,168 @@ const mdxishInlineMdxComponents = () => tree => {
 };
 /* harmony default export */ const inline_mdx_blocks = (mdxishInlineMdxComponents);
 
+;// ./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][^<>]*>(?:[^<]*)$/;
+// A line that is exactly one lowercase opening (or self-closing) tag — the shape
+// that opens a CommonMark type-6/7 HTML block and swallows the lines below it.
+const SINGLE_OPENING_TAG_REGEX = /^<[a-z][^<>]*>$/;
+// 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, ...HTML_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);
+}
+// Per-tag {opens, closes} counts of RAW_CONTENT_TAGS on one line — feeds both the
+// per-line net-open check and the cumulative still-open depth tracking.
+function countRawContentTags(line) {
+    return RAW_CONTENT_TAG_MATCHERS.map(({ open, close }) => ({
+        opens: (line.match(open) ?? []).length,
+        closes: (line.match(close) ?? []).length,
+    }));
+}
+// Indentation width in columns, counting a tab as 4 per CommonMark.
+function indentWidth(line) {
+    const leading = line.match(/^[ \t]*/)?.[0] ?? '';
+    return leading.replace(/\t/g, '    ').length;
+}
+/**
+ * Decides whether a blank line belongs between `line` and `next` so the HTML
+ * flow block opened on `line` terminates and `next` parses as markdown.
+ */
+function shouldTerminateBetween(line, next, { insideRawContent, lineLeavesRawOpen }) {
+    if (next.trim().length === 0)
+        return false;
+    const currentIndent = indentWidth(line);
+    const nextIndent = indentWidth(next);
+    // 4+ columns is CommonMark indented-code territory: an inserted blank line
+    // would turn the next line into a code block instead of freeing it (#1344).
+    if (currentIndent > 3 || nextIndent > 3)
+        return false;
+    const currentTrimmed = line.trim();
+    const nextTrimmed = next.trim();
+    if (!isLineHtml(currentTrimmed) || isLineHtml(nextTrimmed) || lineLeavesRawOpen) {
+        return false;
+    }
+    // Column-0 pairs keep the original (pre-relaxation) rule, deliberately ignoring
+    // `insideRawContent`: one unclosed <pre>/<table> typo would otherwise suppress
+    // termination for the whole rest of the document.
+    if (currentIndent === 0 && nextIndent === 0)
+        return true;
+    // Indented shapes (either line at 1–3 columns) are stricter: only a lone opening
+    // tag followed by markdown. A next line opening a tag or expression must stay
+    // glued for the mdxComponent tokenizer; raw-content payloads stay byte-exact.
+    return (!insideRawContent &&
+        SINGLE_OPENING_TAG_REGEX.test(currentTrimmed) &&
+        !nextTrimmed.startsWith('<') &&
+        !nextTrimmed.startsWith('{'));
+}
+/**
+ * CommonMark HTML blocks (types 6/7) end only at a blank line, so markdown on the
+ * next line is swallowed as HTML (`## heading` after `<div>` renders as literal text).
+ * Inserts the missing blank line; the gating rules live in `shouldTerminateBetween`.
+ *
+ * @link https://spec.commonmark.org/0.29/#html-blocks
+ */
+function terminateHtmlFlowBlocks(content) {
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const lines = protectedContent.split('\n');
+    const result = [];
+    // Per-tag count of still-open raw-content elements at the current boundary.
+    const rawContentDepths = RAW_CONTENT_TAG_MATCHERS.map(() => 0);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        result.push(line);
+        const tagCounts = countRawContentTags(line);
+        tagCounts.forEach(({ opens, closes }, tagIndex) => {
+            rawContentDepths[tagIndex] = Math.max(0, rawContentDepths[tagIndex] + opens - closes);
+        });
+        const next = lines[i + 1];
+        const rawContentFacts = {
+            insideRawContent: rawContentDepths.some(depth => depth > 0),
+            lineLeavesRawOpen: tagCounts.some(({ opens, closes }) => opens > closes),
+        };
+        if (next !== undefined && shouldTerminateBetween(line, next, rawContentFacts)) {
+            result.push('');
+        }
+    }
+    return restoreCodeBlocks(result.join('\n'), protectedCode);
+}
+
 ;// ./processor/transform/mdxish/components/mdx-blocks.ts
 
 
 
 
-/** Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
+
+
+
+// Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
-/**
- * Reduce leading whitespace on all lines just enough to prevent
- * remark from treating indented content as code blocks (4+ spaces).
- * Preserves relative indentation so whitespace text nodes are
- * maintained in the HAST output.
+// Name shape mirrors `componentTagPattern`; the lookbehind skips the inner tag
+// of a legacy `<<VARIABLE>>`.
+const NESTED_COMPONENT_TAG_RE = /(?<!<)<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+// Excludes tags with dedicated transformers (`Table`, `HTMLBlock`, inline
+// components), which expect their wrapper to stay raw.
+const hasNestedGenericComponentTag = (content) => [...content.matchAll(NESTED_COMPONENT_TAG_RE)].some(match => !GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(match[1]));
+/**
+ * Strip the shared leading indentation from a component body so readability indentation
+ * isn't parsed as indented code (4+ spaces), e.g. `  <p>` / `   text` -> `<p>` / ` text`.
+ * Relative indentation is kept, so content genuinely 4+ columns deeper stays code. We
+ * only strip when a line actually reaches 4 columns; otherwise the body is left as-is so
+ * its leading whitespace survives as text nodes (mixed component + HTML content needs it).
  */
 function safeDeindent(text) {
     const lines = text.split('\n');
     const nonEmptyLines = lines.filter(line => line.trim().length > 0);
     if (nonEmptyLines.length === 0)
         return text;
-    const minIndent = Math.min(...nonEmptyLines.map(line => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-    }));
-    // Only strip enough indent to keep all lines below the 4-space code threshold
-    const stripAmount = Math.max(0, minIndent - 3);
+    // Indent counts characters (tab = 1), unlike indentWidth's CommonMark columns
+    // (tab = 4) in terminate-html-flow-blocks.
+    const indents = nonEmptyLines.map(line => line.match(/^(\s*)/)?.[1].length ?? 0);
+    const minIndent = Math.min(...indents);
+    const maxIndent = Math.max(...indents);
+    const stripAmount = maxIndent > 3 ? minIndent : 0;
     if (stripAmount === 0)
         return text;
     return lines.map(line => line.slice(stripAmount)).join('\n');
 }
 /**
- * Parse markdown content into mdast children nodes.
- * Dedents the content first to prevent indented component content
- * (from nested components) from being treated as code blocks.
+ * Parse component-body markdown into mdast children. Dedenting shifts columns and
+ * stales the top-level `terminateHtmlFlowBlocks` decisions, so that one preprocessor
+ * re-runs here; other column-anchored fixups (compact headings, tables) do not.
  */
 const parseMdChildren = (value, safeMode) => {
-    const parsed = getInlineMdProcessor({ safeMode }).parse(safeDeindent(value).trim());
+    const parsed = getInlineMdProcessor({ safeMode }).parse(terminateHtmlFlowBlocks(safeDeindent(value).trim()));
     return parsed.children || [];
 };
-/**
- * Parse substring content of a node and update the parent's children to include the new nodes.
- */
+// Parses trailing content into sibling nodes and re-queues the parent so any
+// components among them get processed.
 const parseSibling = (stack, parent, index, sibling, safeMode) => {
     const siblingNodes = parseMdChildren(sibling, safeMode);
-    // The new sibling nodes might contain new components to be processed
     if (siblingNodes.length > 0) {
         parent.children.splice(index + 1, 0, ...siblingNodes);
         stack.push(parent);
     }
 };
-/**
- * Advance a point by the substring of source consumed from it.
- */
-const pointAfter = (start, consumed) => {
-    const newlineIndex = consumed.lastIndexOf('\n');
-    const newlineCount = newlineIndex === -1 ? 0 : consumed.split('\n').length - 1;
-    return {
-        line: start.line + newlineCount,
-        column: newlineCount === 0 ? start.column + consumed.length : consumed.length - newlineIndex,
-        offset: start.offset + consumed.length,
-    };
-};
-/**
- * Build a position ending at `consumedLength` into the html node's value, so the
- * component doesn't claim trailing content the tokenizer swallowed into one node.
- */
+// Ends the position at `consumedLength` so the component doesn't claim trailing
+// content the tokenizer swallowed into the same html node.
 const positionEndingAtConsumed = (nodePosition, value, consumedLength) => {
     if (!nodePosition?.start)
         return nodePosition;
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
 };
-/**
- * Build a position ending right after the last occurrence of `closingTag` within
- * this node's span in the original source. Used in the trailing-content path so
- * the offset is computed against the real source bytes (including blockquote/list
- * prefixes that were stripped from the html node's value).
- */
+// Like `positionEndingAtConsumed`, but measures against the original source so
+// blockquote/list prefixes stripped from the html node's value are counted.
 const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) => {
     if (!nodePosition?.start || !nodePosition.end)
         return nodePosition;
@@ -120819,9 +121159,6 @@ const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) =>
     const consumed = nodeSource.slice(0, closingTagOffset + closingTag.length);
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumed) };
 };
-/**
- * Create an MdxJsxFlowElement node from component data.
- */
 const createComponentNode = ({ tag, attributes, children, startPosition, endPosition }) => ({
     type: 'mdxJsxFlowElement',
     name: tag,
@@ -120874,8 +121211,7 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if ('children' in node && Array.isArray(node.children)) {
             stack.push(node);
         }
-        // Only visit HTML nodes with an actual html tag,
-        // which means a potential unparsed MDX component
+        // Only html nodes can be an unparsed MDX component.
         const value = node.value;
         if (node.type !== 'html' || typeof value !== 'string')
             return;
@@ -120884,32 +121220,25 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if (!parsed)
             return;
         const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
-        // Offset of `trimmed` within the (possibly whitespace-padded) html node value,
-        // so consumed-length math maps back onto the node's real source offsets.
+        // Offsets so consumed-length math maps back onto the node's real source.
         const leadingWhitespace = value.length - value.trimStart().length;
-        // Index right after the opening tag's `>` within `trimmed`.
         const openingTagEnd = trimmed.length - contentAfterTag.length;
-        // Skip tags that have dedicated transformers
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
-            return;
+            return; // owned by dedicated transformers
         const isPascal = isPascalCase(tag);
-        // Lowercase inline tags (inside a paragraph) with `{…}` attributes are
-        // promoted to `mdxJsxTextElement` by mdxishInlineComponentBlocks. Skip
-        // them here so they stay as html for that pass; PascalCase components
-        // keep going through this transformer (they stay flow-level even when
-        // inline, which is how ReadMe's custom components are modeled).
+        // Lowercase inline tags with `{…}` attributes belong to
+        // mdxishInlineComponentBlocks; leave them as html for that pass. PascalCase
+        // components stay flow-level even when inline (ReadMe's component model).
         if (!isPascal && parent.type === 'paragraph')
             return;
-        // Lowercase HTML tags are eligible when they (or a descendant tag in their
-        // content, e.g. a `.map()` body returning JSX with `key={i}`) carry a
-        // JSX-expression attribute. Without this, a wrapper `<div>` with only plain
-        // attributes (or none) swallows its whole nested block — including any
-        // `style={{...}}`/`.map()` JSX inside it — as literal HTML text, which
-        // rehype-raw's parse5 pass then garbles (it has no notion of JS expressions).
-        // Plain HTML with no expressions anywhere stays as an html node so
-        // rehype-raw handles it as normal.
+        // A lowercase wrapper is only promoted when it (or a descendant) carries a
+        // JSX expression or nests a component; otherwise it would swallow that inner
+        // JSX/component as literal text that rehype-raw's parse5 pass can't handle.
+        // Table-structural wrappers are excluded — `mdxishTables` re-parses those.
         const hasNestedExpressionAttr = !selfClosing && NESTED_ATTR_EXPRESSION_RE.test(contentAfterTag);
-        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr)
+        const isTableStructuralTag = tag === 'table' || tableTags.has(tag);
+        const hasNestedComponentTag = !selfClosing && !isTableStructuralTag && hasNestedGenericComponentTag(contentAfterTag);
+        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr && !hasNestedComponentTag)
             return;
         const closingTagStr = `</${tag}>`;
         // Case 1: Self-closing tag
@@ -120923,7 +121252,6 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // Check and parse if there's relevant content after the current closing tag
             const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
                 parseSibling(stack, parent, index, remainingContent, safeMode);
@@ -120932,17 +121260,14 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         }
         // Case 2: Self-contained block (closing tag in content)
         if (contentAfterTag.includes(closingTagStr)) {
-            // Find the first closing tag
             const closingTagIndex = contentAfterTag.lastIndexOf(closingTagStr);
-            // Pass raw (untrimmed) content so dedent in parseMdChildren can
-            // normalize indentation before trimming
+            // Untrimmed so parseMdChildren can dedent before trimming.
             const componentInnerContent = contentAfterTag.substring(0, closingTagIndex);
             const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
             let parsedChildren = componentInnerContent.trim()
                 ? parseMdChildren(componentInnerContent, safeMode)
                 : [];
-            // Lowercase HTML tags are usually inline (e.g. <a>, <span>). Remark wraps
-            // bare text in a paragraph; unwrap when there's exactly one paragraph so
+            // Lowercase tags are usually inline; unwrap a sole paragraph so their
             // phrasing content isn't spuriously block-wrapped.
             if (!isPascal && parsedChildren.length === 1 && parsedChildren[0].type === 'paragraph') {
                 parsedChildren = parsedChildren[0].children;
@@ -120952,12 +121277,9 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
-                // When trailing content follows the closing tag, compute the end position precisely
-                // within the html node's value so the component doesn't claim that content.
-                // Prefer source-based positioning when the original source is available: the html
-                // node's value has '> '/space prefixes stripped for blockquotes/list items, so
-                // positionEndingAtConsumed would undercount source offsets. When the entire node
-                // is consumed, use the original node position directly.
+                // With trailing content, end precisely at the closing tag. Prefer source
+                // offsets when available (the node's value strips blockquote/list
+                // prefixes); otherwise fall back to the whole node position.
                 endPosition: contentAfterClose
                     ? source
                         ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
@@ -120965,17 +121287,16 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                     : node.position,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // After the closing tag, there might be more content to be processed
+            // Re-queue whichever side may hold further components.
             if (contentAfterClose) {
                 parseSibling(stack, parent, index, contentAfterClose, safeMode);
             }
             else if (componentNode.children.length > 0) {
-                // The content inside the component block might contain new components to be processed
                 stack.push(componentNode);
             }
         }
     };
-    // Process the nodes with the components depth-first to maintain the correct order of the nodes
+    // Depth-first so nodes keep their source order.
     while (stack.length) {
         const parent = stack.pop();
         if (parent?.children) {
@@ -121341,26 +121662,183 @@ const evalExpression = (expression, scope) => {
     return evalJsxProgram(program, scope);
 };
 
-;// ./processor/transform/mdxish/evaluate-expressions.ts
+;// ./processor/transform/mdxish/style-object-to-css.ts
+
+/**
+ * CSS properties React treats as unitless — a bare number stays as-is instead of
+ * getting `px` appended. Mirrors React DOM's `isUnitlessNumber` whitelist.
+ * @see https://github.com/facebook/react/blob/main/packages/react-dom-bindings/src/shared/CSSProperty.js
+ */
+const UNITLESS_CSS_PROPERTIES = new Set([
+    'animationIterationCount',
+    'aspectRatio',
+    'borderImageOutset',
+    'borderImageSlice',
+    'borderImageWidth',
+    'boxFlex',
+    'boxFlexGroup',
+    'boxOrdinalGroup',
+    'columnCount',
+    'columns',
+    'flex',
+    'flexGrow',
+    'flexPositive',
+    'flexShrink',
+    'flexNegative',
+    'flexOrder',
+    'gridArea',
+    'gridRow',
+    'gridRowEnd',
+    'gridRowSpan',
+    'gridRowStart',
+    'gridColumn',
+    'gridColumnEnd',
+    'gridColumnSpan',
+    'gridColumnStart',
+    'fontWeight',
+    'lineClamp',
+    'lineHeight',
+    'opacity',
+    'order',
+    'orphans',
+    'tabSize',
+    'widows',
+    'zIndex',
+    'zoom',
+    'fillOpacity',
+    'floodOpacity',
+    'stopOpacity',
+    'strokeDasharray',
+    'strokeDashoffset',
+    'strokeMiterlimit',
+    'strokeOpacity',
+    'strokeWidth',
+]);
+/** Convert a camelCase (or CSS custom property) key into its kebab-case CSS name. */
+const cssPropertyName = (key) => (key.startsWith('--') ? key : key.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`));
+/** React appends `px` to non-zero numeric values, except unitless and custom properties. */
+const cssPropertyValue = (key, value) => typeof value === 'number' && value !== 0 && !key.startsWith('--') && !UNITLESS_CSS_PROPERTIES.has(key)
+    ? `${value}px`
+    : `${value}`;
+/**
+ * True for a value that should be serialized as a style object rather than passed through
+ * as an already-CSS string. React elements are excluded since they're valid objects too.
+ */
+const style_object_to_css_isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !external_react_default().isValidElement(value);
+/**
+ * Serialize a React-style inline style object (`{ color: "red", fontSize: 12 }`) into a
+ * CSS declaration string (`color:red;font-size:12px`), the shape hast/HTML expects for a
+ * `style` attribute. Empty (`undefined`/`null`/`''`) entries are dropped.
+ */
+const styleObjectToCssText = (style) => Object.entries(style)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([key, value]) => `${cssPropertyName(key)}:${cssPropertyValue(key, value)}`)
+    .join(';');
 
+;// ./processor/transform/mdxish/react-element-to-hast.ts
 
 
 
-/** True for an array containing at least one React element, e.g. the result of `.map()` returning JSX. */
-const isRenderableElementArray = (value) => Array.isArray(value) && value.some((external_react_default()).isValidElement);
-/** Given the type of the expression result, create the corresponding mdast node. */
-const createEvaluatedNode = (result, position) => {
-    if (result === null || result === undefined) {
-        return { type: 'text', value: '', position };
+// React props that never map to an HTML/hast attribute.
+const RESERVED_PROPS = new Set(['children', 'key', 'ref']);
+/**
+ * Translate React props into hast `properties`: reserved and function props (event handlers)
+ * are dropped (known gap), `style` objects flatten to CSS text. Names stay as authored (`className`); the
+ * hast → HTML boundary maps them to `class`/`for` downstream.
+ */
+function propsToHastProperties(props) {
+    const properties = {};
+    Object.entries(props).forEach(([key, value]) => {
+        if (RESERVED_PROPS.has(key) || typeof value === 'function' || value === undefined)
+            return;
+        properties[key] = key === 'style' && style_object_to_css_isPlainObject(value) ? styleObjectToCssText(value) : value;
+    });
+    // Values are resolved React props, wider than hast's HTML-attribute `PropertyValue` union.
+    return properties;
+}
+/**
+ * Render an element with React's own renderer as a last resort, wrapped as a hast `raw` node —
+ * the same node type markdown's literal HTML blocks produce, so it re-enters rehypeRaw's
+ * parse5 pass normally. Used for element types this converter can't resolve on its own (wrapped
+ * component types, or a function component that throws when called outside React, e.g. one
+ * using hooks). It's not immune to the invalid-HTML-nesting this module otherwise avoids, but
+ * that's a fair trade against silently dropping the content.
+ */
+function renderFallbackHtml(element) {
+    try {
+        const rawNode = { type: 'raw', value: (0,server_node/* renderToStaticMarkup */.qV)(element) };
+        return [rawNode];
     }
-    else if (external_react_default().isValidElement(result) || isRenderableElementArray(result)) {
-        // Convert react elements (or arrays of them, e.g. `.map()` returning JSX) to their HTML
-        // representation. This must come before the object check as both are a subset of it.
-        return { type: 'html', value: (0,server_node/* renderToStaticMarkup */.qV)(external_react_default().createElement((external_react_default()).Fragment, null, result)), position };
+    catch {
+        return [];
     }
-    else if (typeof result === 'object') {
-        return { type: 'text', value: JSON.stringify(result), position };
+}
+/**
+ * Convert a React element tree into hast. Emitting `mdx-jsx` nodes (rehypeRaw passthrough, later normalized to `element`)
+ * preserves nesting that is valid JSX but not valid HTML, which parse5 would otherwise
+ * restructure — e.g. an `<a>` wrapping another `<a>`.
+ * Recursively converts the tree into an array of hast nodes, dealing with arrays and null/undefined/boolean values.
+ */
+function reactElementToHast(node) {
+    if (Array.isArray(node))
+        return node.flatMap(reactElementToHast);
+    if (node === null || node === undefined || typeof node === 'boolean')
+        return [];
+    if (typeof node === 'string' || typeof node === 'number') {
+        const textNode = { type: 'text', value: String(node) };
+        return [textNode];
     }
+    if (!external_react_default().isValidElement(node))
+        return [];
+    const { type, props } = node;
+    // Fragments contribute their children with no wrapper element.
+    if (type === (external_react_default()).Fragment)
+        return reactElementToHast(props.children);
+    // Resolve function components to their rendered output so the tree is plain intrinsic
+    // elements. If invoking it directly throws (e.g. it uses hooks, which need React's own
+    // render context), fall back to React's renderer for just this subtree.
+    if (typeof type === 'function') {
+        try {
+            return reactElementToHast(type(props));
+        }
+        catch {
+            return renderFallbackHtml(node);
+        }
+    }
+    // Non-intrinsic, non-callable element types — `React.memo`, `React.forwardRef`,
+    // `Context.Provider`/`Consumer`, `React.lazy` — have no `type` we can resolve ourselves.
+    if (typeof type !== 'string')
+        return renderFallbackHtml(node);
+    const mdxJsxNode = {
+        type: 'mdx-jsx',
+        tagName: type,
+        properties: propsToHastProperties(props),
+        children: reactElementToHast(props.children),
+    };
+    return [mdxJsxNode];
+}
+
+;// ./processor/transform/mdxish/evaluate-expressions.ts
+
+
+
+
+/**
+ * We divide the result of an expression into two categories:
+ * 1. Renderable values: HTML, JSX, e.g. .map() returning JSX
+ * 2. Non-renderable values: a string, number, or object, regular JS values
+ */
+const isRenderable = (value) => {
+    if (external_react_default().isValidElement(value))
+        return true;
+    return Array.isArray(value) && value.some(isRenderable);
+};
+/** Turn a non-renderable evaluation result into a text node. */
+const createTextNode = (result, position) => {
+    if (result === null || result === undefined)
+        return { type: 'text', value: '', position };
+    if (typeof result === 'object')
+        return { type: 'text', value: JSON.stringify(result), position };
     return { type: 'text', value: String(result), position };
 };
 /**
@@ -121376,13 +121854,23 @@ const evaluateExpressions = () => (tree, file) => {
     lib_visit(tree, ['mdxFlowExpression', 'mdxTextExpression'], (node, index, parent) => {
         if (!parent || index === null || index === undefined)
             return;
-        const { value, position } = node;
+        const expressionNode = node;
+        const { value, position } = expressionNode;
         const expression = value?.trim();
         if (!expression)
             return;
         try {
             const result = evalExpression(expression, scope);
-            parent.children.splice(index, 1, createEvaluatedNode(result, position));
+            if (isRenderable(result)) {
+                // Stash hast built straight from the React tree; `mdxExpressionHandler` emits it and it 
+                // passes through rehypeRaw/parse5 step later in the pipeline. This ensures that the 
+                // expression result is not parsed by parse5 and fragmenting the nesting that is valid JSX 
+                // but invalid HTML — e.g. an `<a>` wrapping `<a>`.
+                expressionNode.data = { ...expressionNode.data, hChildren: reactElementToHast(result) };
+            }
+            else {
+                parent.children.splice(index, 1, createTextNode(result, position));
+            }
         }
         catch (_error) {
             // Evaluation failed — fall back to literal `{...}` text. The expression
@@ -124713,79 +125201,6 @@ function removeJSXComments(content) {
     return content.replace(JSX_COMMENT_REGEX, '');
 }
 
-;// ./processor/transform/mdxish/style-object-to-css.ts
-
-/**
- * CSS properties React treats as unitless — a bare number stays as-is instead of
- * getting `px` appended. Mirrors React DOM's `isUnitlessNumber` whitelist.
- * @see https://github.com/facebook/react/blob/main/packages/react-dom-bindings/src/shared/CSSProperty.js
- */
-const UNITLESS_CSS_PROPERTIES = new Set([
-    'animationIterationCount',
-    'aspectRatio',
-    'borderImageOutset',
-    'borderImageSlice',
-    'borderImageWidth',
-    'boxFlex',
-    'boxFlexGroup',
-    'boxOrdinalGroup',
-    'columnCount',
-    'columns',
-    'flex',
-    'flexGrow',
-    'flexPositive',
-    'flexShrink',
-    'flexNegative',
-    'flexOrder',
-    'gridArea',
-    'gridRow',
-    'gridRowEnd',
-    'gridRowSpan',
-    'gridRowStart',
-    'gridColumn',
-    'gridColumnEnd',
-    'gridColumnSpan',
-    'gridColumnStart',
-    'fontWeight',
-    'lineClamp',
-    'lineHeight',
-    'opacity',
-    'order',
-    'orphans',
-    'tabSize',
-    'widows',
-    'zIndex',
-    'zoom',
-    'fillOpacity',
-    'floodOpacity',
-    'stopOpacity',
-    'strokeDasharray',
-    'strokeDashoffset',
-    'strokeMiterlimit',
-    'strokeOpacity',
-    'strokeWidth',
-]);
-/** Convert a camelCase (or CSS custom property) key into its kebab-case CSS name. */
-const cssPropertyName = (key) => (key.startsWith('--') ? key : key.replace(/[A-Z]/g, m => `-${m.toLowerCase()}`));
-/** React appends `px` to non-zero numeric values, except unitless and custom properties. */
-const cssPropertyValue = (key, value) => typeof value === 'number' && value !== 0 && !key.startsWith('--') && !UNITLESS_CSS_PROPERTIES.has(key)
-    ? `${value}px`
-    : `${value}`;
-/**
- * True for a value that should be serialized as a style object rather than passed through
- * as an already-CSS string. React elements are excluded since they're valid objects too.
- */
-const style_object_to_css_isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) && !external_react_default().isValidElement(value);
-/**
- * Serialize a React-style inline style object (`{ color: "red", fontSize: 12 }`) into a
- * CSS declaration string (`color:red;font-size:12px`), the shape hast/HTML expects for a
- * `style` attribute. Empty (`undefined`/`null`/`''`) entries are dropped.
- */
-const styleObjectToCssText = (style) => Object.entries(style)
-    .filter(([, value]) => value !== undefined && value !== null && value !== '')
-    .map(([key, value]) => `${cssPropertyName(key)}:${cssPropertyValue(key, value)}`)
-    .join(';');
-
 ;// ./processor/transform/mdxish/resolve-deferred-attribute-expression-props.ts
 
 
@@ -125132,73 +125547,6 @@ function normalizeTableSeparator(content) {
 }
 /* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
 
-;// ./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][^<>]*>(?:[^<]*)$/;
-// 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, ...HTML_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.
- *
- * In CommonMark, HTML blocks (types 6 and 7) only terminate on a blank line.
- * Without one, any content on the next line is consumed as part of the HTML block
- * and never parsed as its own construct. For example, a `[block:callout]` immediately
- * following `<div><p></p></div>` gets swallowed into the HTML flow token.
- *
- * @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, ensuring micromark's HTML flow
- * tokenizer terminates and subsequent content is parsed independently.
- *
- * Conditions:
- * 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);
-    const lines = protectedContent.split('\n');
-    const result = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        result.push(lines[i]);
-        // Skip blank & indented lines
-        if (i >= lines.length - 1 || lines[i + 1].trim().length === 0 || lines[i + 1].startsWith(' ') || lines[i + 1].startsWith('\t')) {
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        const isCurrentLineHtml = isLineHtml(lines[i]);
-        const isNextLineHtml = isLineHtml(lines[i + 1]);
-        if (isCurrentLineHtml && !isNextLineHtml && !hasUnclosedRawContentOpener(lines[i])) {
-            result.push('');
-        }
-    }
-    return restoreCodeBlocks(result.join('\n'), protectedCode);
-}
-
 ;// ./processor/transform/mdxish/variables-code.ts
 
 
@@ -126066,6 +126414,12 @@ function mdxishMdastToMd(mdast) {
         .use(remarkStringify, {
         bullet: '-',
         emphasis: '_',
+        // Escape literal braces in text so they don't parse as (often
+        // unterminated) MDX expressions on the next round trip.
+        unsafe: [
+            { character: '{', inConstruct: 'phrasing' },
+            { character: '}', inConstruct: 'phrasing' },
+        ],
     });
     return processor.stringify(processor.runSync(mdast));
 }