@readme/markdown 14.11.2 → 14.11.4

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);
 
@@ -92840,7 +92855,7 @@ function legacyVariableFromMarkdown() {
  *
  * Unicode basic latin block.
  */
-const codes = /** @type {const} */ ({
+const codes_codes = /** @type {const} */ ({
   carriageReturn: -5,
   lineFeed: -4,
   carriageReturnLineFeed: -3,
@@ -92988,11 +93003,11 @@ const codes = /** @type {const} */ ({
 function isNameChar(code) {
     if (code === null)
         return false;
-    return ((code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-        (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-        (code >= codes.digit0 && code <= codes.digit9) ||
-        code === codes.dash ||
-        code === codes.underscore);
+    return ((code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+        (code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+        (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+        code === codes_codes.dash ||
+        code === codes_codes.underscore);
 }
 const gemojiConstruct = {
     name: 'gemoji',
@@ -93002,7 +93017,7 @@ function tokenize(effects, ok, nok) {
     let hasName = false;
     // Entry point — expect opening `:`
     const start = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.enter('gemoji');
         effects.enter('gemojiMarker');
@@ -93013,7 +93028,7 @@ function tokenize(effects, ok, nok) {
     };
     // First char after `:`, branch on `+` for :+1:, otherwise start normal name
     const nameStart = (code) => {
-        if (code === codes.plusSign) {
+        if (code === codes_codes.plusSign) {
             effects.consume(code); // +
             return plusOne;
         }
@@ -93028,7 +93043,7 @@ function tokenize(effects, ok, nok) {
     // After `+`, only `1` is valid (for :+1:), anything else rejects
     // this is a special case for :+1: 👍 since + isnt a normal name character
     const plusOne = (code) => {
-        if (code === codes.digit1) {
+        if (code === codes_codes.digit1) {
             hasName = true;
             effects.consume(code); // 1
             return nameEnd;
@@ -93037,7 +93052,7 @@ function tokenize(effects, ok, nok) {
     };
     // Consume name characters until we hit closing `:` or an invalid char
     const name = (code) => {
-        if (code === codes.colon) {
+        if (code === codes_codes.colon) {
             if (!hasName)
                 return nok(code);
             return nameEnd(code);
@@ -93051,7 +93066,7 @@ function tokenize(effects, ok, nok) {
     };
     // Expect closing `:`
     const nameEnd = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.exit('gemojiName');
         effects.enter('gemojiMarker');
@@ -93064,7 +93079,7 @@ function tokenize(effects, ok, nok) {
 }
 function syntax_gemoji() {
     return {
-        text: { [codes.colon]: gemojiConstruct },
+        text: { [codes_codes.colon]: gemojiConstruct },
     };
 }
 
@@ -93079,8 +93094,8 @@ function syntax_gemoji() {
 
 function isAllowedValueChar(code) {
     return (code !== null &&
-        code !== codes.lessThan &&
-        code !== codes.greaterThan &&
+        code !== codes_codes.lessThan &&
+        code !== codes_codes.greaterThan &&
         !markdownLineEnding(code));
 }
 const legacyVariableConstruct = {
@@ -93090,7 +93105,7 @@ const legacyVariableConstruct = {
 function syntax_tokenize(effects, ok, nok) {
     let hasValue = false;
     const start = (code) => {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.enter('legacyVariable');
         effects.enter('legacyVariableMarkerStart');
@@ -93098,7 +93113,7 @@ function syntax_tokenize(effects, ok, nok) {
         return open2;
     };
     const open2 = (code) => {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.consume(code); // <<
         effects.exit('legacyVariableMarkerStart');
@@ -93106,7 +93121,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const value = (code) => {
-        if (code === codes.greaterThan) {
+        if (code === codes_codes.greaterThan) {
             if (!hasValue)
                 return nok(code);
             effects.exit('legacyVariableValue');
@@ -93121,7 +93136,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const close2 = (code) => {
-        if (code !== codes.greaterThan)
+        if (code !== codes_codes.greaterThan)
             return nok(code);
         effects.consume(code); // >>
         effects.exit('legacyVariableMarkerEnd');
@@ -93132,7 +93147,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes_codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -95970,6 +95985,134 @@ 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
+
+
+// A `<` only starts a JSX/HTML construct when followed by a tag-name start
+// (letter, `_`, `$`), a closer `/`, a fragment `>`, or a comment/declaration
+// `!`. Anything else (whitespace, EOL, a digit, …) is a literal `<` that acorn
+// rejects with "before name, expected a character that can start a name".
+const STRAY_LESS_THAN_RE = /<(?![a-zA-Z_$/>!])/g;
+/**
+ * Escapes stray `<` characters that don't begin a valid tag so the strict mdxjs
+ * parse treats them as literal text instead of throwing (`word <`, `a <1>`).
+ *
+ * Runs against the masked source so `<` inside code spans, legacy `<<var>>`
+ * syntax, or already-escaped `\<` are left untouched.
+ */
+const escapeStrayLessThan = (html) => {
+    const masked = maskNonTagRegions(html);
+    const inserts = [];
+    STRAY_LESS_THAN_RE.lastIndex = 0;
+    let match;
+    while ((match = STRAY_LESS_THAN_RE.exec(masked)) !== null) {
+        inserts.push({ offset: match.index, text: '\\' });
+    }
+    return applyInserts(html, inserts);
+};
+
 ;// ./processor/transform/mdxish/tables/normalize-tag-spacing.ts
 
 
@@ -96096,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.
@@ -96123,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) {
@@ -96149,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
 
@@ -96448,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
 
 
@@ -96467,6 +96708,9 @@ const repairUnclosedTags = (html) => {
 
 
 
+
+
+
 
 
 
@@ -96497,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).
@@ -96512,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.
@@ -96612,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;
         }
     });
@@ -96725,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.
  *
@@ -96737,39 +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
-            // These repairs are created after seeing real customer content that has failed to parse
-            const repairs = [
-                repairUnclosedTags,
-                normalizeTagSpacing,
-                repairExpressionEscapes,
-            ];
-            // 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
@@ -117498,6 +117766,21 @@ function isActualHtmlTag(tagName, originalExcerpt) {
         return true;
     return false;
 }
+/**
+ * Re-parsing a component's text child treats it as a standalone document, so
+ * content that happens to start with the literal word `export`/`import`
+ * (e.g. link text like "export Lorem Ipsum") sits at true column 1 and
+ * gets mistaken for an MDX ESM statement, which then fails to parse as JS.
+ * Fall back to `undefined` rather than letting one such child crash the page.
+ */
+function tryProcessMarkdown(processMarkdown, content) {
+    try {
+        return processMarkdown(content);
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Parse and replace text children with processed markdown */
 function parseTextChildren(node, processMarkdown, components) {
     if (!node.children?.length)
@@ -117512,7 +117795,9 @@ function parseTextChildren(node, processMarkdown, components) {
             node.properties = { ...node.properties, children: child.value };
             return [];
         }
-        const hast = processMarkdown(child.value.trim());
+        const hast = tryProcessMarkdown(processMarkdown, child.value.trim());
+        if (!hast)
+            return [child];
         const children = (hast.children ?? []).filter(isElementContentNode);
         // For inline components, preserve plain text instead of wrapping in <p>
         if (INLINE_COMPONENT_TAGS_LOWER.has(node.tagName.toLowerCase()) && isSingleParagraphTextNode(children)) {
@@ -117586,8 +117871,9 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
             // rehypeRaw strips children from <img> (void element), so we must
             // re-process the caption here, after rehypeRaw.
             if (node.tagName === 'img' && typeof node.properties?.caption === 'string' && !node.children?.length) {
-                const captionHast = processMarkdown(node.properties.caption);
-                node.children = (captionHast.children ?? []).filter(isElementContentNode);
+                const caption = node.properties.caption;
+                const captionHast = tryProcessMarkdown(processMarkdown, caption);
+                node.children = captionHast ? (captionHast.children ?? []).filter(isElementContentNode) : [{ type: 'text', value: caption }];
             }
             // Skip runtime components and standard HTML tags
             if (RUNTIME_COMPONENT_TAGS.has(node.tagName))
@@ -117620,11 +117906,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) => {
@@ -118316,7 +118601,7 @@ const KNOWN_BLOCK_TYPES = new Set([
  * Types can contain alphanumeric characters and hyphens (e.g., "api-header", "tutorial-tile")
  */
 function isTypeChar(code) {
-    return asciiAlphanumeric(code) || code === codes.dash;
+    return asciiAlphanumeric(code) || code === codes_codes.dash;
 }
 /**
  * Creates the opening marker state machine: [block:
@@ -118324,37 +118609,37 @@ function isTypeChar(code) {
  */
 function createOpeningMarkerParser(effects, nok, onComplete) {
     const expectB = (code) => {
-        if (code !== codes.lowercaseB)
+        if (code !== codes_codes.lowercaseB)
             return nok(code);
         effects.consume(code);
         return expectL;
     };
     const expectL = (code) => {
-        if (code !== codes.lowercaseL)
+        if (code !== codes_codes.lowercaseL)
             return nok(code);
         effects.consume(code);
         return expectO;
     };
     const expectO = (code) => {
-        if (code !== codes.lowercaseO)
+        if (code !== codes_codes.lowercaseO)
             return nok(code);
         effects.consume(code);
         return expectC;
     };
     const expectC = (code) => {
-        if (code !== codes.lowercaseC)
+        if (code !== codes_codes.lowercaseC)
             return nok(code);
         effects.consume(code);
         return expectK;
     };
     const expectK = (code) => {
-        if (code !== codes.lowercaseK)
+        if (code !== codes_codes.lowercaseK)
             return nok(code);
         effects.consume(code);
         return expectColon;
     };
     const expectColon = (code) => {
-        if (code !== codes.colon)
+        if (code !== codes_codes.colon)
             return nok(code);
         effects.consume(code);
         effects.exit('magicBlockMarkerStart');
@@ -118370,7 +118655,7 @@ function createOpeningMarkerParser(effects, nok, onComplete) {
 function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
     const captureTypeFirst = (code) => {
         // Reject empty type name [block:]
-        if (code === codes.rightSquareBracket) {
+        if (code === codes_codes.rightSquareBracket) {
             return nok(code);
         }
         if (isTypeChar(code)) {
@@ -118381,7 +118666,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
         return nok(code);
     };
     const captureType = (code) => {
-        if (code === codes.rightSquareBracket) {
+        if (code === codes_codes.rightSquareBracket) {
             if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
                 return nok(code);
             }
@@ -118406,7 +118691,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
  */
 function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
     const handleMismatch = (code) => {
-        if (jsonState && code === codes.quotationMark) {
+        if (jsonState && code === codes_codes.quotationMark) {
             jsonState.inString = true;
         }
         return onMismatch(code);
@@ -118414,7 +118699,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectSlash = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.slash)
+        if (code !== codes_codes.slash)
             return handleMismatch(code);
         effects.consume(code);
         return expectB;
@@ -118422,7 +118707,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectB = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseB)
+        if (code !== codes_codes.lowercaseB)
             return handleMismatch(code);
         effects.consume(code);
         return expectL;
@@ -118430,7 +118715,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectL = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseL)
+        if (code !== codes_codes.lowercaseL)
             return handleMismatch(code);
         effects.consume(code);
         return expectO;
@@ -118438,7 +118723,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectO = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseO)
+        if (code !== codes_codes.lowercaseO)
             return handleMismatch(code);
         effects.consume(code);
         return expectC;
@@ -118446,7 +118731,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectC = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseC)
+        if (code !== codes_codes.lowercaseC)
             return handleMismatch(code);
         effects.consume(code);
         return expectK;
@@ -118454,7 +118739,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectK = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.lowercaseK)
+        if (code !== codes_codes.lowercaseK)
             return handleMismatch(code);
         effects.consume(code);
         return expectBracket;
@@ -118462,7 +118747,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectBracket = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes.rightSquareBracket)
+        if (code !== codes_codes.rightSquareBracket)
             return handleMismatch(code);
         effects.consume(code);
         return onSuccess;
@@ -118518,7 +118803,7 @@ function syntax_magicBlock() {
         // Flow construct - handles block-level magic blocks at document root
         // Marked as concrete to prevent interruption by containers
         flow: {
-            [codes.leftSquareBracket]: {
+            [codes_codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 concrete: true,
                 tokenize: tokenizeMagicBlockFlow,
@@ -118526,7 +118811,7 @@ function syntax_magicBlock() {
         },
         // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
         text: {
-            [codes.leftSquareBracket]: {
+            [codes_codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 tokenize: tokenizeMagicBlockText,
             },
@@ -118547,7 +118832,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
     const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
     return start;
     function start(code) {
-        if (code !== codes.leftSquareBracket)
+        if (code !== codes_codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -118570,7 +118855,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         // Check for closing marker directly (without entering data)
         // This handles cases like [block:type]\n{}\n\n[/block] where there are
         // newlines after the data object
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -118582,11 +118867,11 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         }
         // Skip whitespace (spaces/tabs) before the data - stay in beforeData
         // Don't enter magicBlockData token yet until we confirm there's a '{'
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes.leftCurlyBrace) {
+        if (code !== codes_codes.leftCurlyBrace) {
             effects.exit('magicBlock');
             return nok(code);
         }
@@ -118607,14 +118892,14 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         if (markdownLineEnding(code)) {
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             // We need to consume this but can't without a token - use magicBlockData
             // and track that we haven't seen '{' yet
             effects.enter('magicBlockData');
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -118635,11 +118920,11 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockData');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -118674,23 +118959,23 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes.quotationMark) {
+            if (code === codes_codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.quotationMark) {
+        if (code === codes_codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -118723,7 +119008,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         }
         // Check if this is the start of the closing marker [/block]
         // If so, handle it directly without entering magicBlockData
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -118745,7 +119030,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return expectClosingB;
         }
@@ -118756,7 +119041,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         // The [ was consumed by the marker, so we need to conceptually "have it" in our data
         // But since we already consumed it into the marker, we need a different approach
         // Re-classify: consume this character as data and continue
-        if (code === codes.quotationMark)
+        if (code === codes_codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -118772,10 +119057,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code !== codes.slash) {
+        if (code !== codes_codes.slash) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118789,10 +119074,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseB) {
+        if (code !== codes_codes.lowercaseB) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118806,10 +119091,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseL) {
+        if (code !== codes_codes.lowercaseL) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118823,10 +119108,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseO) {
+        if (code !== codes_codes.lowercaseO) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118840,10 +119125,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseC) {
+        if (code !== codes_codes.lowercaseC) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118857,10 +119142,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.lowercaseK) {
+        if (code !== codes_codes.lowercaseK) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118874,10 +119159,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes.rightSquareBracket) {
+        if (code !== codes_codes.rightSquareBracket) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes.quotationMark)
+            if (code === codes_codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -118904,7 +119189,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // Space or tab - consume as trailing whitespace
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.enter('magicBlockTrailing');
             effects.consume(code);
             return consumeTrailingContinue;
@@ -118930,7 +119215,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // More space or tab - keep consuming
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return consumeTrailingContinue;
         }
@@ -118970,7 +119255,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingMismatch = (code) => {
         effects.exit('magicBlockMarkerEnd');
         effects.enter('magicBlockData');
-        if (code === codes.quotationMark)
+        if (code === codes_codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -118982,7 +119267,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
     return start;
     function start(code) {
-        if (code !== codes.leftSquareBracket)
+        if (code !== codes_codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -119006,7 +119291,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return beforeData;
         }
         // Check for closing marker directly (without entering data)
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return closingFromBeforeData.expectSlash;
@@ -119017,11 +119302,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData(code);
         }
         // Skip whitespace (spaces/tabs) before the data
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes.leftCurlyBrace) {
+        if (code !== codes_codes.leftCurlyBrace) {
             return nok(code);
         }
         // We have '{' - enter data token and start capturing
@@ -119042,12 +119327,12 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.enter('magicBlockData');
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -119069,11 +119354,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes.leftCurlyBrace) {
+        if (code === codes_codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -119101,23 +119386,23 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes.quotationMark) {
+            if (code === codes_codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.quotationMark) {
+        if (code === codes_codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes.leftSquareBracket) {
+        if (code === codes_codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -119708,11 +119993,11 @@ function createTokenize(mode) {
         // When a } brings braceDepth back to a saved value, we return to the
         // template literal instead of continuing in the brace expression.
         const templateStack = [];
-        const isAlpha = (code) => (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-            (code >= codes.lowercaseA && code <= codes.lowercaseZ);
+        const isAlpha = (code) => (code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+            (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ);
         const isSameCaseAsTag = (code) => isLowercaseTag
-            ? code >= codes.lowercaseA && code <= codes.lowercaseZ
-            : code >= codes.uppercaseA && code <= codes.uppercaseZ;
+            ? code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ
+            : code >= codes_codes.uppercaseA && code <= codes_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) {
@@ -119725,22 +120010,22 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.quotationMark || code === codes.apostrophe) {
+                if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
                     quoteChar = code;
                     effects.consume(code);
                     return braceString;
                 }
-                if (code === codes.graveAccent) {
+                if (code === codes_codes.graveAccent) {
                     inTemplateLit = true;
                     effects.consume(code);
                     return braceTemplateLiteral;
                 }
-                if (code === codes.leftCurlyBrace) {
+                if (code === codes_codes.leftCurlyBrace) {
                     braceDepth += 1;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes.rightCurlyBrace) {
+                if (code === codes_codes.rightCurlyBrace) {
                     braceDepth -= 1;
                     effects.consume(code);
                     if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
@@ -119765,7 +120050,7 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.backslash) {
+                if (code === codes_codes.backslash) {
                     effects.consume(code);
                     return braceStringEscape;
                 }
@@ -119793,16 +120078,16 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes.graveAccent) {
+                if (code === codes_codes.graveAccent) {
                     inTemplateLit = false;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes.backslash) {
+                if (code === codes_codes.backslash) {
                     effects.consume(code);
                     return braceTemplateLiteralEscape;
                 }
-                if (code === codes.dollarSign) {
+                if (code === codes_codes.dollarSign) {
                     effects.consume(code);
                     return braceTemplateLiteralDollar;
                 }
@@ -119817,7 +120102,7 @@ function createTokenize(mode) {
                 return braceTemplateLiteral;
             }
             function braceTemplateLiteralDollar(code) {
-                if (code === codes.leftCurlyBrace) {
+                if (code === codes_codes.leftCurlyBrace) {
                     templateStack.push(braceDepth);
                     braceDepth += 1;
                     inTemplateLit = false;
@@ -119833,7 +120118,7 @@ function createTokenize(mode) {
         return start;
         // ── Start ──────────────────────────────────────────────────────────────
         function start(code) {
-            if (code !== codes.lessThan)
+            if (code !== codes_codes.lessThan)
                 return nok(code);
             effects.enter('mdxComponent');
             effects.enter('mdxComponentData');
@@ -119845,7 +120130,7 @@ function createTokenize(mode) {
             // Uppercase A-Z → PascalCase MDX component. Flow mode claims block
             // components; text mode only claims inline components (Anchor, Glossary),
             // which is enforced once the full name is known in `tagNameRest`.
-            if (code !== null && code >= codes.uppercaseA && code <= codes.uppercaseZ) {
+            if (code !== null && code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) {
                 tagName = String.fromCharCode(code);
                 isLowercaseTag = false;
                 sawBraceAttr = false;
@@ -119855,7 +120140,7 @@ function createTokenize(mode) {
             // Lowercase a-z → HTML tag (claim only if `{...}` attr appears). In
             // flow mode, refuse to interrupt a paragraph — same rule as html-flow
             // type-7. The text variant picks these up during inline parsing.
-            if (code !== null && code >= codes.lowercaseA && code <= codes.lowercaseZ) {
+            if (code !== null && code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) {
                 if (isFlow && self.interrupt)
                     return nok(code);
                 tagName = String.fromCharCode(code);
@@ -119868,10 +120153,10 @@ function createTokenize(mode) {
         }
         function tagNameRest(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 tagName += String.fromCharCode(code);
                 effects.consume(code);
                 return tagNameRest;
@@ -119906,14 +120191,14 @@ function createTokenize(mode) {
                 return openTagContinuationStart(code);
             }
             // Self-closing />
-            if (code === codes.slash) {
+            if (code === codes_codes.slash) {
                 if (requiresBraceAttr && !sawBraceAttr)
                     return nok(code);
                 effects.consume(code);
                 return selfCloseGt;
             }
             // End of opening tag
-            if (code === codes.greaterThan) {
+            if (code === codes_codes.greaterThan) {
                 if (requiresBraceAttr && !sawBraceAttr) {
                     // Plain lowercase block tags stay claimable in flow, gated per line by
                     // `plainClaimLineStart`; everything else falls through to CommonMark.
@@ -119926,13 +120211,13 @@ function createTokenize(mode) {
                 return body;
             }
             // Quoted attribute value
-            if (code === codes.quotationMark || code === codes.apostrophe) {
+            if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
                 quoteChar = code;
                 effects.consume(code);
                 return inQuotedAttr;
             }
             // JSX expression attribute
-            if (code === codes.leftCurlyBrace) {
+            if (code === codes_codes.leftCurlyBrace) {
                 braceDepth = 1;
                 sawBraceAttr = true;
                 effects.consume(code);
@@ -119950,7 +120235,7 @@ function createTokenize(mode) {
                 effects.exit('mdxComponentData');
                 return openTagContinuationStart(code);
             }
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 effects.consume(code);
                 return inQuotedAttrEscape;
             }
@@ -119970,7 +120255,7 @@ function createTokenize(mode) {
             return inQuotedAttr;
         }
         function selfCloseGt(code) {
-            if (code === codes.greaterThan) {
+            if (code === codes_codes.greaterThan) {
                 effects.consume(code);
                 // Self-closing tag completes the token
                 return afterClose;
@@ -120023,25 +120308,25 @@ function createTokenize(mode) {
                 atLineStart = true;
                 return bodyContinuationStart(code);
             }
-            if (code !== codes.space && code !== codes.horizontalTab) {
+            if (code !== codes_codes.space && code !== codes_codes.horizontalTab) {
                 openerLineHasContent = true;
             }
-            if (code === codes.backslash) {
+            if (code === codes_codes.backslash) {
                 effects.consume(code);
                 return bodyEscapedChar;
             }
-            if (code === codes.lessThan) {
+            if (code === codes_codes.lessThan) {
                 effects.consume(code);
                 return bodyLessThan;
             }
             // Code span tracking
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 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) {
+            if (code === codes_codes.leftCurlyBrace) {
                 braceDepth = 1;
                 inTemplateLit = false;
                 effects.consume(code);
@@ -120061,14 +120346,14 @@ function createTokenize(mode) {
         }
         // ── Code span handling ─────────────────────────────────────────────────
         function countOpenTicks(code) {
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanOpenSize += 1;
                 effects.consume(code);
                 return countOpenTicks;
             }
             // 3+ backticks at line start = fenced code block
             if (atLineStart && codeSpanOpenSize >= 3) {
-                fenceChar = codes.graveAccent;
+                fenceChar = codes_codes.graveAccent;
                 fenceLength = codeSpanOpenSize;
                 atLineStart = false;
                 return inFencedCode(code);
@@ -120078,7 +120363,7 @@ function createTokenize(mode) {
         function inCodeSpan(code) {
             if (code === null || markdownLineEnding(code))
                 return body(code);
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanCloseSize = 0;
                 return countCloseTicks(code);
             }
@@ -120086,7 +120371,7 @@ function createTokenize(mode) {
             return inCodeSpan;
         }
         function countCloseTicks(code) {
-            if (code === codes.graveAccent) {
+            if (code === codes_codes.graveAccent) {
                 codeSpanCloseSize += 1;
                 effects.consume(code);
                 return countCloseTicks;
@@ -120149,7 +120434,7 @@ function createTokenize(mode) {
                 return body(code);
             }
             // Only spaces/tabs allowed after closing fence
-            if (code === codes.space || code === codes.horizontalTab) {
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
                 effects.consume(code);
                 return fenceCloseTrailing;
             }
@@ -120158,7 +120443,7 @@ function createTokenize(mode) {
         }
         // ── Tilde fenced code detection ────────────────────────────────────────
         function bodyAfterLineStart(code) {
-            if (code === codes.tilde) {
+            if (code === codes_codes.tilde) {
                 fenceCloseLength = 1;
                 effects.consume(code);
                 return countTildes;
@@ -120167,13 +120452,13 @@ function createTokenize(mode) {
             return body(code);
         }
         function countTildes(code) {
-            if (code === codes.tilde) {
+            if (code === codes_codes.tilde) {
                 fenceCloseLength += 1;
                 effects.consume(code);
                 return countTildes;
             }
             if (fenceCloseLength >= 3) {
-                fenceChar = codes.tilde;
+                fenceChar = codes_codes.tilde;
                 fenceLength = fenceCloseLength;
                 return inFencedCode(code);
             }
@@ -120183,7 +120468,7 @@ function createTokenize(mode) {
         }
         // ── Tag detection inside body ──────────────────────────────────────────
         function bodyLessThan(code) {
-            if (code === codes.slash) {
+            if (code === codes_codes.slash) {
                 if (onOpenerLine)
                     openerLineCloses += 1;
                 effects.consume(code);
@@ -120210,10 +120495,10 @@ function createTokenize(mode) {
         // ── Nested opening tag ─────────────────────────────────────────────────
         function nestedOpenTagName(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return nestedOpenTagName;
@@ -120221,10 +120506,10 @@ function createTokenize(mode) {
             // Same-name opener followed by a tag-end char bumps depth. A line ending
             // counts too: Prettier puts a newline right after the name (`<div\n …\n>`).
             if (closingTagName === tagName &&
-                (code === codes.greaterThan ||
-                    code === codes.slash ||
-                    code === codes.space ||
-                    code === codes.horizontalTab ||
+                (code === codes_codes.greaterThan ||
+                    code === codes_codes.slash ||
+                    code === codes_codes.space ||
+                    code === codes_codes.horizontalTab ||
                     markdownLineEnding(code))) {
                 depth += 1;
             }
@@ -120243,15 +120528,15 @@ function createTokenize(mode) {
         }
         function closingTagNameRest(code) {
             if (code !== null &&
-                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
-                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
-                    (code >= codes.digit0 && code <= codes.digit9) ||
-                    code === codes.underscore)) {
+                ((code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
+                    (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ) ||
+                    (code >= codes_codes.digit0 && code <= codes_codes.digit9) ||
+                    code === codes_codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return closingTagNameRest;
             }
-            if (closingTagName === tagName && code === codes.greaterThan) {
+            if (closingTagName === tagName && code === codes_codes.greaterThan) {
                 depth -= 1;
                 effects.consume(code);
                 if (depth === 0) {
@@ -120335,9 +120620,9 @@ function createTokenize(mode) {
         }
         // Dispatch a non-blank continuation line: fenced code at line start, else body.
         function bodyLineStart(code) {
-            if (atLineStart && code === codes.tilde)
+            if (atLineStart && code === codes_codes.tilde)
                 return bodyAfterLineStart(code);
-            if (atLineStart && code === codes.graveAccent) {
+            if (atLineStart && code === codes_codes.graveAccent) {
                 codeSpanOpenSize = 0;
                 // Leave `atLineStart` set — `countOpenTicks` needs it to tell a fence from an
                 // inline code span once the run of backticks is fully counted; it's cleared once
@@ -120352,7 +120637,7 @@ function createTokenize(mode) {
         // fence) refuses so CommonMark html-flow reparses it exactly as it does today.
         function plainClaimLineStart(code) {
             // Leading whitespace only → treat as a blank line, matching CommonMark.
-            if (code === codes.space || code === codes.horizontalTab) {
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -120365,7 +120650,7 @@ function createTokenize(mode) {
             // paragraph that merely starts with a tag must fall back so its markdown
             // parses and rehype-raw re-nests it into the wrapper.
             if (pendingBlankLine) {
-                if (code !== codes.lessThan)
+                if (code !== codes_codes.lessThan)
                     return nok(code);
                 return effects.check(markupOnlyContinuation, plainClaimContinue, nok)(code);
             }
@@ -120418,7 +120703,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
         return afterLessThan;
     }
     function afterLessThan(code) {
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return afterSlash;
         }
@@ -120437,7 +120722,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
     function scanToLineEnd(code) {
         if (code === null || markdownLineEnding(code)) {
             effects.exit(types_types.data);
-            return lastNonSpace === codes.greaterThan ? ok(code) : nok(code);
+            return lastNonSpace === codes_codes.greaterThan ? ok(code) : nok(code);
         }
         if (!markdownSpace(code))
             lastNonSpace = code;
@@ -120470,8 +120755,8 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
  */
 function syntax_mdxComponent() {
     return {
-        flow: { [codes.lessThan]: [mdxComponentFlowConstruct] },
-        text: { [codes.lessThan]: [mdxComponentTextConstruct] },
+        flow: { [codes_codes.lessThan]: [mdxComponentFlowConstruct] },
+        text: { [codes_codes.lessThan]: [mdxComponentTextConstruct] },
     };
 }
 
@@ -120691,6 +120976,7 @@ const mdxishInlineMdxComponents = () => tree => {
 
 
 
+
 /** Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
 /**
@@ -120734,18 +121020,6 @@ const parseSibling = (stack, parent, index, sibling, safeMode) => {
         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.
@@ -121293,26 +121567,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];
+    }
+    catch {
+        return [];
     }
-    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 };
+}
+/**
+ * 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];
     }
-    else if (typeof result === 'object') {
-        return { type: 'text', value: JSON.stringify(result), position };
+    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 };
 };
 /**
@@ -121328,13 +121759,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
@@ -122931,21 +123372,21 @@ function resolveEntity(name) {
 function tokenizeLooseHtmlEntity(effects, ok, nok) {
     let length = 0;
     const start = (code) => {
-        if (code !== codes.ampersand)
+        if (code !== codes_codes.ampersand)
             return nok(code);
         effects.enter('looseHtmlEntity');
         effects.consume(code);
         return afterAmpersand;
     };
     const afterAmpersand = (code) => {
-        if (code === codes.numberSign) {
+        if (code === codes_codes.numberSign) {
             effects.consume(code);
             return afterHash;
         }
         return accumulateNamed(code);
     };
     const afterHash = (code) => {
-        if (code === codes.lowercaseX || code === codes.uppercaseX) {
+        if (code === codes_codes.lowercaseX || code === codes_codes.uppercaseX) {
             effects.consume(code);
             return accumulateHex;
         }
@@ -122959,7 +123400,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -122972,7 +123413,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -122985,7 +123426,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes.semicolon)
+        if (code === codes_codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -123020,7 +123461,7 @@ function exitLooseHtmlEntity(token) {
 }
 function looseHtmlEntity() {
     return {
-        text: { [codes.ampersand]: looseHtmlEntityConstruct },
+        text: { [codes_codes.ampersand]: looseHtmlEntityConstruct },
     };
 }
 function looseHtmlEntityFromMarkdown() {
@@ -124665,79 +125106,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
 
 
@@ -125377,7 +125745,7 @@ function jsx_table_jsxTableFromMarkdown() {
 function tokenizeJsxComment(effects, ok, nok) {
     return start;
     function start(code) {
-        if (code !== codes.leftCurlyBrace)
+        if (code !== codes_codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxFlowExpression');
         effects.enter('mdxFlowExpressionMarker');
@@ -125386,7 +125754,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectSlash;
     }
     function expectSlash(code) {
-        if (code !== codes.slash) {
+        if (code !== codes_codes.slash) {
             effects.exit('mdxFlowExpression');
             return nok(code);
         }
@@ -125395,7 +125763,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectStar;
     }
     function expectStar(code) {
-        if (code !== codes.asterisk) {
+        if (code !== codes_codes.asterisk) {
             effects.exit('mdxFlowExpressionChunk');
             effects.exit('mdxFlowExpression');
             return nok(code);
@@ -125422,7 +125790,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125434,11 +125802,11 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return expectClosingBrace;
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125450,7 +125818,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes.rightCurlyBrace) {
+        if (code === codes_codes.rightCurlyBrace) {
             effects.exit('mdxFlowExpressionChunk');
             effects.enter('mdxFlowExpressionMarker');
             effects.consume(code);
@@ -125458,7 +125826,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpression');
             return ok;
         }
-        if (code === codes.asterisk) {
+        if (code === codes_codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125469,7 +125837,7 @@ function tokenizeJsxComment(effects, ok, nok) {
 function jsxComment() {
     return {
         flow: {
-            [codes.leftCurlyBrace]: {
+            [codes_codes.leftCurlyBrace]: {
                 name: 'jsxComment',
                 concrete: true,
                 tokenize: tokenizeJsxComment,
@@ -125510,7 +125878,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     let codeSpanOpenSize = 0;
     let codeSpanCloseSize = 0;
     let depth = 1;
-    const ABLE_SUFFIX = [codes.lowercaseA, codes.lowercaseB, codes.lowercaseL, codes.lowercaseE];
+    const ABLE_SUFFIX = [codes_codes.lowercaseA, codes_codes.lowercaseB, codes_codes.lowercaseL, codes_codes.lowercaseE];
     /** Build a state chain that matches a sequence of character codes. */
     function matchChars(chars, onMatch, onFail) {
         if (chars.length === 0)
@@ -125525,7 +125893,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     }
     return start;
     function start(code) {
-        if (code !== codes.lessThan)
+        if (code !== codes_codes.lessThan)
             return nok(code);
         effects.enter('jsxTable');
         effects.enter('jsxTableData');
@@ -125533,14 +125901,14 @@ function tokenizeJsxTable(effects, ok, nok) {
         return afterLessThan;
     }
     function afterLessThan(code) {
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, afterTagName, nok);
         }
         return nok(code);
     }
     function afterTagName(code) {
-        if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.greaterThan || code === codes_codes.slash || code === codes_codes.space || code === codes_codes.horizontalTab) {
             effects.consume(code);
             return body;
         }
@@ -125556,17 +125924,17 @@ function tokenizeJsxTable(effects, ok, nok) {
             effects.exit('jsxTableData');
             return continuationStart(code);
         }
-        if (code === codes.backslash) {
+        if (code === codes_codes.backslash) {
             effects.consume(code);
             return escapedChar;
         }
-        if (code === codes.lessThan) {
+        if (code === codes_codes.lessThan) {
             effects.consume(code);
             return closeSlash;
         }
         // Skip over backtick code spans so `</Table>` in inline code isn't
         // treated as the closing tag
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanOpenSize = 0;
             return countOpenTicks(code);
         }
@@ -125574,7 +125942,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body;
     }
     function countOpenTicks(code) {
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanOpenSize += 1;
             effects.consume(code);
             return countOpenTicks;
@@ -125584,7 +125952,7 @@ function tokenizeJsxTable(effects, ok, nok) {
     function inCodeSpan(code) {
         if (code === null || markdownLineEnding(code))
             return body(code);
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanCloseSize = 0;
             return countCloseTicks(code);
         }
@@ -125592,7 +125960,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return inCodeSpan;
     }
     function countCloseTicks(code) {
-        if (code === codes.graveAccent) {
+        if (code === codes_codes.graveAccent) {
             codeSpanCloseSize += 1;
             effects.consume(code);
             return countCloseTicks;
@@ -125607,25 +125975,25 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body;
     }
     function closeSlash(code) {
-        if (code === codes.slash) {
+        if (code === codes_codes.slash) {
             effects.consume(code);
             return closeTagFirstChar;
         }
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, openAfterTagName, body);
         }
         return body(code);
     }
     function closeTagFirstChar(code) {
-        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+        if (code === codes_codes.uppercaseT || code === codes_codes.lowercaseT) {
             effects.consume(code);
             return matchChars(ABLE_SUFFIX, closeGt, body);
         }
         return body(code);
     }
     function openAfterTagName(code) {
-        if (code === codes.greaterThan || code === codes.slash || code === codes.space || code === codes.horizontalTab) {
+        if (code === codes_codes.greaterThan || code === codes_codes.slash || code === codes_codes.space || code === codes_codes.horizontalTab) {
             depth += 1;
             effects.consume(code);
             return body;
@@ -125633,7 +126001,7 @@ function tokenizeJsxTable(effects, ok, nok) {
         return body(code);
     }
     function closeGt(code) {
-        if (code === codes.greaterThan) {
+        if (code === codes_codes.greaterThan) {
             depth -= 1;
             effects.consume(code);
             if (depth === 0) {
@@ -125707,7 +126075,7 @@ function jsx_table_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
 function syntax_jsxTable() {
     return {
         flow: {
-            [codes.lessThan]: [jsxTableConstruct],
+            [codes_codes.lessThan]: [jsxTableConstruct],
         },
     };
 }
@@ -125734,7 +126102,7 @@ function tokenizeTextExpression(effects, ok, nok) {
     let depth = 0;
     return start;
     function start(code) {
-        if (code !== codes.leftCurlyBrace)
+        if (code !== codes_codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxTextExpression');
         effects.enter('mdxTextExpressionMarker');
@@ -125743,7 +126111,7 @@ function tokenizeTextExpression(effects, ok, nok) {
         return before;
     }
     function before(code) {
-        if (code === codes.eof) {
+        if (code === codes_codes.eof) {
             effects.exit('mdxTextExpression');
             return nok(code);
         }
@@ -125753,24 +126121,24 @@ function tokenizeTextExpression(effects, ok, nok) {
             effects.exit('lineEnding');
             return before;
         }
-        if (code === codes.rightCurlyBrace && depth === 0) {
+        if (code === codes_codes.rightCurlyBrace && depth === 0) {
             return close(code);
         }
         effects.enter('mdxTextExpressionChunk');
         return inside(code);
     }
     function inside(code) {
-        if (code === codes.eof || markdownLineEnding(code)) {
+        if (code === codes_codes.eof || markdownLineEnding(code)) {
             effects.exit('mdxTextExpressionChunk');
             return before(code);
         }
-        if (code === codes.rightCurlyBrace && depth === 0) {
+        if (code === codes_codes.rightCurlyBrace && depth === 0) {
             effects.exit('mdxTextExpressionChunk');
             return close(code);
         }
-        if (code === codes.leftCurlyBrace)
+        if (code === codes_codes.leftCurlyBrace)
             depth += 1;
-        else if (code === codes.rightCurlyBrace)
+        else if (code === codes_codes.rightCurlyBrace)
             depth -= 1;
         effects.consume(code);
         return inside;
@@ -125786,7 +126154,7 @@ function tokenizeTextExpression(effects, ok, nok) {
 function mdxExpressionLenient() {
     return {
         text: {
-            [codes.leftCurlyBrace]: {
+            [codes_codes.leftCurlyBrace]: {
                 name: 'mdxTextExpression',
                 tokenize: tokenizeTextExpression,
             },
@@ -126500,6 +126868,332 @@ const mdxishTags_tags = (doc) => {
 };
 /* harmony default export */ const mdxishTags = ((/* unused pure expression or super */ null && (mdxishTags_tags)));
 
+;// ./lib/mdast-util/html-block-component/index.ts
+const html_block_component_contextMap = new WeakMap();
+function findHtmlBlockComponentToken() {
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (events[i][0].type === 'htmlBlockComponent')
+            return events[i][0];
+    }
+    return undefined;
+}
+function enterHtmlBlockComponent(token) {
+    html_block_component_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
+    this.enter({ type: 'html', value: '' }, token);
+}
+function exitHtmlBlockComponentData(token) {
+    const componentToken = findHtmlBlockComponentToken.call(this);
+    if (!componentToken)
+        return;
+    const ctx = html_block_component_contextMap.get(componentToken);
+    if (ctx) {
+        const gap = token.start.line - ctx.lastEndLine;
+        if (ctx.chunks.length > 0 && gap > 0) {
+            ctx.chunks.push('\n'.repeat(gap));
+        }
+        ctx.chunks.push(this.sliceSerialize(token));
+        ctx.lastEndLine = token.end.line;
+    }
+}
+function exitHtmlBlockComponent(token) {
+    const ctx = html_block_component_contextMap.get(token);
+    const node = this.stack[this.stack.length - 1];
+    if (ctx) {
+        node.value = ctx.chunks.join('');
+        html_block_component_contextMap.delete(token);
+    }
+    this.exit(token);
+}
+function html_block_component_htmlBlockComponentFromMarkdown() {
+    return {
+        enter: {
+            htmlBlockComponent: enterHtmlBlockComponent,
+        },
+        exit: {
+            htmlBlockComponentData: exitHtmlBlockComponentData,
+            htmlBlockComponent: exitHtmlBlockComponent,
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/syntax.ts
+
+
+const TAG_SUFFIX = [
+    codes_codes.uppercaseT,
+    codes_codes.uppercaseM,
+    codes_codes.uppercaseL,
+    codes_codes.uppercaseB,
+    codes_codes.lowercaseL,
+    codes_codes.lowercaseO,
+    codes_codes.lowercaseC,
+    codes_codes.lowercaseK,
+];
+// ---------------------------------------------------------------------------
+// Shared tokenizer factory
+// ---------------------------------------------------------------------------
+/**
+ * Creates a tokenize function for `<HTMLBlock>...</HTMLBlock>`.
+ *
+ * - **flow** (block-level): supports multiline content via line continuations,
+ *   consumes trailing whitespace after the closing tag.
+ * - **text** (inline): single-line only, exits immediately after the closing tag.
+ */
+function syntax_createTokenize(mode) {
+    return function tokenize(effects, ok, nok) {
+        let depth = 1;
+        function matchChars(chars, onMatch, onFail) {
+            if (chars.length === 0)
+                return onMatch;
+            const next = (code) => {
+                if (code === chars[0]) {
+                    effects.consume(code);
+                    return matchChars(chars.slice(1), onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        function matchTagName(onMatch, onFail) {
+            const next = (code) => {
+                if (code === codes_codes.uppercaseH) {
+                    effects.consume(code);
+                    return matchChars(TAG_SUFFIX, onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        return start;
+        function start(code) {
+            if (code !== codes_codes.lessThan)
+                return nok(code);
+            effects.enter('htmlBlockComponent');
+            effects.enter('htmlBlockComponentData');
+            effects.consume(code);
+            return matchTagName(afterTagName, nok);
+        }
+        function afterTagName(code) {
+            if (code === codes_codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+                effects.consume(code);
+                return inAttributes;
+            }
+            if (mode === 'flow' && markdownLineEnding(code)) {
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            if (code === codes_codes.slash) {
+                effects.consume(code);
+                return selfClose;
+            }
+            return nok(code);
+        }
+        function inAttributes(code) {
+            if (code === codes_codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === null) {
+                return nok(code);
+            }
+            if (markdownLineEnding(code)) {
+                if (mode === 'text')
+                    return nok(code);
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            effects.consume(code);
+            return inAttributes;
+        }
+        function attributeContinuationStart(code) {
+            return effects.check(html_block_component_syntax_nonLazyContinuationStart, attributeContinuationNonLazy, continuationAfter)(code);
+        }
+        function attributeContinuationNonLazy(code) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return attributeContinuationBefore;
+        }
+        function attributeContinuationBefore(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return attributeContinuationStart(code);
+            }
+            effects.enter('htmlBlockComponentData');
+            return inAttributes(code);
+        }
+        function selfClose(code) {
+            if (code === codes_codes.greaterThan) {
+                effects.consume(code);
+                return mode === 'flow' ? afterClose : done(code);
+            }
+            return nok(code);
+        }
+        function body(code) {
+            if (code === null)
+                return nok(code);
+            if (markdownLineEnding(code)) {
+                if (mode === 'text') {
+                    // Text constructs operate on paragraph content which spans lines
+                    effects.consume(code);
+                    return body;
+                }
+                effects.exit('htmlBlockComponentData');
+                return continuationStart(code);
+            }
+            if (code === codes_codes.lessThan) {
+                effects.consume(code);
+                return closeSlash;
+            }
+            effects.consume(code);
+            return body;
+        }
+        function closeSlash(code) {
+            if (code === codes_codes.slash) {
+                effects.consume(code);
+                return matchTagName(closeGt, body);
+            }
+            return matchTagName(openAfterTagName, body)(code);
+        }
+        function openAfterTagName(code) {
+            if (code === codes_codes.greaterThan || code === codes_codes.space || code === codes_codes.horizontalTab) {
+                depth += 1;
+                effects.consume(code);
+                return body;
+            }
+            return body(code);
+        }
+        function closeGt(code) {
+            if (code === codes_codes.greaterThan) {
+                depth -= 1;
+                effects.consume(code);
+                if (depth === 0) {
+                    return mode === 'flow' ? afterClose : done(code);
+                }
+                return body;
+            }
+            return body(code);
+        }
+        // -- flow-only states ---------------------------------------------------
+        function afterClose(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return done(code);
+            }
+            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+                effects.consume(code);
+                return afterClose;
+            }
+            // Reject so the block re-parses as a paragraph, deferring to the
+            // text tokenizer which preserves trailing content in the same line.
+            return nok(code);
+        }
+        // -- flow-only: line continuation ---------------------------------------
+        function continuationStart(code) {
+            return effects.check(html_block_component_syntax_nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);
+        }
+        function continuationStartNonLazy(code) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return continuationBefore;
+        }
+        function continuationBefore(code) {
+            if (code === null || markdownLineEnding(code)) {
+                return continuationStart(code);
+            }
+            effects.enter('htmlBlockComponentData');
+            return body(code);
+        }
+        function continuationAfter(code) {
+            if (code === null)
+                return nok(code);
+            effects.exit('htmlBlockComponent');
+            return ok(code);
+        }
+        // -- shared exit --------------------------------------------------------
+        function done(_code) {
+            effects.exit('htmlBlockComponentData');
+            effects.exit('htmlBlockComponent');
+            return ok(_code);
+        }
+    };
+}
+// ---------------------------------------------------------------------------
+// Flow construct (block-level)
+// ---------------------------------------------------------------------------
+const html_block_component_syntax_nonLazyContinuationStart = {
+    tokenize: html_block_component_syntax_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+function resolveToHtmlBlockComponent(events) {
+    let index = events.length;
+    while (index > 0) {
+        index -= 1;
+        if (events[index][0] === 'enter' && events[index][1].type === 'htmlBlockComponent') {
+            break;
+        }
+    }
+    if (index > 1 && events[index - 2][1].type === types_types.linePrefix) {
+        events[index][1].start = events[index - 2][1].start;
+        events[index + 1][1].start = events[index - 2][1].start;
+        events.splice(index - 2, 2);
+    }
+    return events;
+}
+const htmlBlockComponentFlowConstruct = {
+    name: 'htmlBlockComponent',
+    tokenize: syntax_createTokenize('flow'),
+    resolveTo: resolveToHtmlBlockComponent,
+    concrete: true,
+};
+function html_block_component_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    return start;
+    function start(code) {
+        if (markdownLineEnding(code)) {
+            effects.enter(types_types.lineEnding);
+            effects.consume(code);
+            effects.exit(types_types.lineEnding);
+            return after;
+        }
+        return nok(code);
+    }
+    function after(code) {
+        if (self.parser.lazy[self.now().line]) {
+            return nok(code);
+        }
+        return ok(code);
+    }
+}
+// ---------------------------------------------------------------------------
+// Text construct (inline)
+// ---------------------------------------------------------------------------
+const htmlBlockComponentTextConstruct = {
+    name: 'htmlBlockComponent',
+    tokenize: syntax_createTokenize('text'),
+};
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+function syntax_htmlBlockComponent() {
+    return {
+        flow: {
+            [codes.lessThan]: [htmlBlockComponentFlowConstruct],
+        },
+        text: {
+            [codes.lessThan]: [htmlBlockComponentTextConstruct],
+        },
+    };
+}
+
+;// ./lib/micromark/html-block-component/index.ts
+
+
 ;// ./lib/stripComments.ts
 
 
@@ -126514,19 +127208,22 @@ const mdxishTags_tags = (doc) => {
 
 
 
+
+
 /**
  * Removes Markdown and MDX comments.
  */
 async function stripComments(doc, { mdx, mdxish } = {}) {
     const { replaced, blocks } = extractMagicBlocks(doc);
     const processor = unified();
-    // we still require these two extensions because:
+    // we still require these extensions because:
     // 1. we can rely on remarkMdx to parse MDXish
     // 2. we need to parse JSX comments into mdxTextExpression nodes so that the transformers can pick them up
+    // 3. we need to claim <HTMLBlock> before htmlFlow intercepts its inner HTML tags
     if (mdxish) {
         processor
-            .data('micromarkExtensions', [jsxTable(), mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
+            .data('micromarkExtensions', [htmlBlockComponent(), jsxTable(), mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [htmlBlockComponentFromMarkdown(), jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
             .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor