@readme/markdown 14.11.5 → 14.12.0

package/dist/render-fixture.node.js

@@ -91765,17 +91765,12 @@ const extractScripts = (html = '') => {
     return [cleaned, () => scripts.map(js => window.eval(js))];
 };
 const HTMLBlock = ({ children = '', html: htmlProp, runScripts, safeMode: safeModeRaw = false }) => {
-    // Determine HTML source: MDXish uses html prop (from HAST), MDX uses children
-    let html = '';
-    if (htmlProp !== undefined) {
-        html = htmlProp;
-    }
-    else {
-        if (typeof children !== 'string') {
-            throw new TypeError('HTMLBlock: children must be a string');
-        }
-        html = children;
-    }
+    // Determine HTML source: MDXish uses html prop (from HAST), MDX uses children.
+    // A non-string child (no html prop) can't be injected as raw HTML — see the
+    // fail-soft fallback below.
+    const htmlSource = htmlProp !== undefined ? htmlProp : children;
+    const nonStringChildren = typeof htmlSource !== 'string';
+    const html = nonStringChildren ? '' : htmlSource;
     // eslint-disable-next-line no-param-reassign
     runScripts = typeof runScripts !== 'boolean' ? runScripts === 'true' : runScripts;
     // In MDX mode, safeMode is passed in as a boolean from JSX parsing
@@ -91786,6 +91781,11 @@ const HTMLBlock = ({ children = '', html: htmlProp, runScripts, safeMode: safeMo
         if (typeof window !== 'undefined' && typeof runScripts === 'boolean' && runScripts)
             exec();
     }, [runScripts, exec]);
+    if (nonStringChildren) {
+        // Fail soft: a non-string child (e.g. JSX that wasn't serialized back to a
+        // raw string) should never throw, so render the child nodes directly
+        return external_react_default().createElement("div", { className: "rdmd-html" }, children);
+    }
     if (safeMode) {
         return (external_react_default().createElement("pre", { className: "html-unsafe" },
             external_react_default().createElement("code", null, html)));
@@ -92855,7 +92855,7 @@ function legacyVariableFromMarkdown() {
  *
  * Unicode basic latin block.
  */
-const codes_codes = /** @type {const} */ ({
+const codes = /** @type {const} */ ({
   carriageReturn: -5,
   lineFeed: -4,
   carriageReturnLineFeed: -3,
@@ -93003,11 +93003,11 @@ const codes_codes = /** @type {const} */ ({
 function isNameChar(code) {
     if (code === null)
         return false;
-    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);
+    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);
 }
 const gemojiConstruct = {
     name: 'gemoji',
@@ -93017,7 +93017,7 @@ function tokenize(effects, ok, nok) {
     let hasName = false;
     // Entry point — expect opening `:`
     const start = (code) => {
-        if (code !== codes_codes.colon)
+        if (code !== codes.colon)
             return nok(code);
         effects.enter('gemoji');
         effects.enter('gemojiMarker');
@@ -93028,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_codes.plusSign) {
+        if (code === codes.plusSign) {
             effects.consume(code); // +
             return plusOne;
         }
@@ -93043,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_codes.digit1) {
+        if (code === codes.digit1) {
             hasName = true;
             effects.consume(code); // 1
             return nameEnd;
@@ -93052,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_codes.colon) {
+        if (code === codes.colon) {
             if (!hasName)
                 return nok(code);
             return nameEnd(code);
@@ -93066,7 +93066,7 @@ function tokenize(effects, ok, nok) {
     };
     // Expect closing `:`
     const nameEnd = (code) => {
-        if (code !== codes_codes.colon)
+        if (code !== codes.colon)
             return nok(code);
         effects.exit('gemojiName');
         effects.enter('gemojiMarker');
@@ -93079,7 +93079,7 @@ function tokenize(effects, ok, nok) {
 }
 function syntax_gemoji() {
     return {
-        text: { [codes_codes.colon]: gemojiConstruct },
+        text: { [codes.colon]: gemojiConstruct },
     };
 }
 
@@ -93094,8 +93094,8 @@ function syntax_gemoji() {
 
 function isAllowedValueChar(code) {
     return (code !== null &&
-        code !== codes_codes.lessThan &&
-        code !== codes_codes.greaterThan &&
+        code !== codes.lessThan &&
+        code !== codes.greaterThan &&
         !markdownLineEnding(code));
 }
 const legacyVariableConstruct = {
@@ -93105,7 +93105,7 @@ const legacyVariableConstruct = {
 function syntax_tokenize(effects, ok, nok) {
     let hasValue = false;
     const start = (code) => {
-        if (code !== codes_codes.lessThan)
+        if (code !== codes.lessThan)
             return nok(code);
         effects.enter('legacyVariable');
         effects.enter('legacyVariableMarkerStart');
@@ -93113,7 +93113,7 @@ function syntax_tokenize(effects, ok, nok) {
         return open2;
     };
     const open2 = (code) => {
-        if (code !== codes_codes.lessThan)
+        if (code !== codes.lessThan)
             return nok(code);
         effects.consume(code); // <<
         effects.exit('legacyVariableMarkerStart');
@@ -93121,7 +93121,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const value = (code) => {
-        if (code === codes_codes.greaterThan) {
+        if (code === codes.greaterThan) {
             if (!hasValue)
                 return nok(code);
             effects.exit('legacyVariableValue');
@@ -93136,7 +93136,7 @@ function syntax_tokenize(effects, ok, nok) {
         return value;
     };
     const close2 = (code) => {
-        if (code !== codes_codes.greaterThan)
+        if (code !== codes.greaterThan)
             return nok(code);
         effects.consume(code); // >>
         effects.exit('legacyVariableMarkerEnd');
@@ -93147,7 +93147,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes_codes.lessThan]: legacyVariableConstruct },
+        text: { [codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -96621,6 +96621,9 @@ const TOP_LEVEL_TABLE_TAG_RE = /^<(?:table|Table)(?=[\s/>])/;
  * Uses `walkTags` so `<table>`s inside code spans / fenced blocks (masked away)
  * are never matched.
  *
+ * `<table>`s inside an `<HTMLBlock>` body are also ignored: that body is opaque
+ * raw HTML, so lifting a table out of it would corrupt the block.
+ *
  * 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
@@ -96628,21 +96631,35 @@ const TOP_LEVEL_TABLE_TAG_RE = /^<(?:table|Table)(?=[\s/>])/;
  */
 const findTableRanges = (html) => {
     const ranges = [];
-    let depth = 0;
+    let tableDepth = 0;
+    let htmlBlockDepth = 0;
     let start = 0;
     walkTags(html, {
-        onOpen: ({ name, start: openStart, isStrayCloser }) => {
-            if (name.toLowerCase() !== 'table' || isStrayCloser)
+        onOpen: ({ name, start: openStart, isSelfClosing, isStrayCloser }) => {
+            if (isStrayCloser)
                 return;
-            if (depth === 0)
+            // `<HTMLBlock/>` has no body to protect; only a real open enters one.
+            if (name === 'HTMLBlock') {
+                if (!isSelfClosing)
+                    htmlBlockDepth += 1;
+                return;
+            }
+            if (htmlBlockDepth > 0 || name.toLowerCase() !== 'table')
+                return;
+            if (tableDepth === 0)
                 start = openStart;
-            depth += 1;
+            tableDepth += 1;
         },
         onClose: ({ name, end, implicit }) => {
-            if (implicit || name.toLowerCase() !== 'table' || depth === 0)
+            if (name === 'HTMLBlock') {
+                if (!implicit && htmlBlockDepth > 0)
+                    htmlBlockDepth -= 1;
                 return;
-            depth -= 1;
-            if (depth === 0)
+            }
+            if (implicit || htmlBlockDepth > 0 || name.toLowerCase() !== 'table' || tableDepth === 0)
+                return;
+            tableDepth -= 1;
+            if (tableDepth === 0)
                 ranges.push({ start, end });
         },
     });
@@ -96662,7 +96679,9 @@ const splitHtmlWithNestedTables = (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.
+    // No table text anywhere → skip the htmlparser2 walk entirely. (A `<table>` that
+    // only appears inside an `<HTMLBlock>` body still yields no ranges below, so it's
+    // left whole for `mdxishHtmlBlocks` to convert to an html-block next.)
     if (!/<\/?table/i.test(value))
         return null;
     const ranges = findTableRanges(value);
@@ -118404,6 +118423,55 @@ function emptyTaskListItemFromMarkdown() {
     };
 }
 
+;// ./lib/mdast-util/jsx-table/index.ts
+const jsx_table_contextMap = new WeakMap();
+function findJsxTableToken() {
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (events[i][0].type === 'jsxTable')
+            return events[i][0];
+    }
+    return undefined;
+}
+function enterJsxTable(token) {
+    jsx_table_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
+    this.enter({ type: 'html', value: '' }, token);
+}
+function exitJsxTableData(token) {
+    const tableToken = findJsxTableToken.call(this);
+    if (!tableToken)
+        return;
+    const ctx = jsx_table_contextMap.get(tableToken);
+    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 exitJsxTable(token) {
+    const ctx = jsx_table_contextMap.get(token);
+    const node = this.stack[this.stack.length - 1];
+    if (ctx) {
+        node.value = ctx.chunks.join('');
+        jsx_table_contextMap.delete(token);
+    }
+    this.exit(token);
+}
+function jsx_table_jsxTableFromMarkdown() {
+    return {
+        enter: {
+            jsxTable: enterJsxTable,
+        },
+        exit: {
+            jsxTableData: exitJsxTableData,
+            jsxTable: exitJsxTable,
+        },
+    };
+}
+
 ;// ./lib/mdast-util/magic-block/index.ts
 const magic_block_contextMap = new WeakMap();
 /**
@@ -118593,6 +118661,698 @@ function mdx_component_mdxComponentFromMarkdown() {
     };
 }
 
+;// ./node_modules/micromark-util-symbol/lib/types.js
+/**
+ * This module is compiled away!
+ *
+ * Here is the list of all types of tokens exposed by micromark, with a short
+ * explanation of what they include and where they are found.
+ * In picking names, generally, the rule is to be as explicit as possible
+ * instead of reusing names.
+ * For example, there is a `definitionDestination` and a `resourceDestination`,
+ * instead of one shared name.
+ */
+
+// Note: when changing the next record, you must also change `TokenTypeMap`
+// in `micromark-util-types/index.d.ts`.
+const types_types = /** @type {const} */ ({
+  // Generic type for data, such as in a title, a destination, etc.
+  data: 'data',
+
+  // Generic type for syntactic whitespace (tabs, virtual spaces, spaces).
+  // Such as, between a fenced code fence and an info string.
+  whitespace: 'whitespace',
+
+  // Generic type for line endings (line feed, carriage return, carriage return +
+  // line feed).
+  lineEnding: 'lineEnding',
+
+  // A line ending, but ending a blank line.
+  lineEndingBlank: 'lineEndingBlank',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the start of a
+  // line.
+  linePrefix: 'linePrefix',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the end of a
+  // line.
+  lineSuffix: 'lineSuffix',
+
+  // Whole ATX heading:
+  //
+  // ```markdown
+  // #
+  // ## Alpha
+  // ### Bravo ###
+  // ```
+  //
+  // Includes `atxHeadingSequence`, `whitespace`, `atxHeadingText`.
+  atxHeading: 'atxHeading',
+
+  // Sequence of number signs in an ATX heading (`###`).
+  atxHeadingSequence: 'atxHeadingSequence',
+
+  // Content in an ATX heading (`alpha`).
+  // Includes text.
+  atxHeadingText: 'atxHeadingText',
+
+  // Whole autolink (`<https://example.com>` or `<admin@example.com>`)
+  // Includes `autolinkMarker` and `autolinkProtocol` or `autolinkEmail`.
+  autolink: 'autolink',
+
+  // Email autolink w/o markers (`admin@example.com`)
+  autolinkEmail: 'autolinkEmail',
+
+  // Marker around an `autolinkProtocol` or `autolinkEmail` (`<` or `>`).
+  autolinkMarker: 'autolinkMarker',
+
+  // Protocol autolink w/o markers (`https://example.com`)
+  autolinkProtocol: 'autolinkProtocol',
+
+  // A whole character escape (`\-`).
+  // Includes `escapeMarker` and `characterEscapeValue`.
+  characterEscape: 'characterEscape',
+
+  // The escaped character (`-`).
+  characterEscapeValue: 'characterEscapeValue',
+
+  // A whole character reference (`&amp;`, `&#8800;`, or `&#x1D306;`).
+  // Includes `characterReferenceMarker`, an optional
+  // `characterReferenceMarkerNumeric`, in which case an optional
+  // `characterReferenceMarkerHexadecimal`, and a `characterReferenceValue`.
+  characterReference: 'characterReference',
+
+  // The start or end marker (`&` or `;`).
+  characterReferenceMarker: 'characterReferenceMarker',
+
+  // Mark reference as numeric (`#`).
+  characterReferenceMarkerNumeric: 'characterReferenceMarkerNumeric',
+
+  // Mark reference as numeric (`x` or `X`).
+  characterReferenceMarkerHexadecimal: 'characterReferenceMarkerHexadecimal',
+
+  // Value of character reference w/o markers (`amp`, `8800`, or `1D306`).
+  characterReferenceValue: 'characterReferenceValue',
+
+  // Whole fenced code:
+  //
+  // ````markdown
+  // ```js
+  // alert(1)
+  // ```
+  // ````
+  codeFenced: 'codeFenced',
+
+  // A fenced code fence, including whitespace, sequence, info, and meta
+  // (` ```js `).
+  codeFencedFence: 'codeFencedFence',
+
+  // Sequence of grave accent or tilde characters (` ``` `) in a fence.
+  codeFencedFenceSequence: 'codeFencedFenceSequence',
+
+  // Info word (`js`) in a fence.
+  // Includes string.
+  codeFencedFenceInfo: 'codeFencedFenceInfo',
+
+  // Meta words (`highlight="1"`) in a fence.
+  // Includes string.
+  codeFencedFenceMeta: 'codeFencedFenceMeta',
+
+  // A line of code.
+  codeFlowValue: 'codeFlowValue',
+
+  // Whole indented code:
+  //
+  // ```markdown
+  //     alert(1)
+  // ```
+  //
+  // Includes `lineEnding`, `linePrefix`, and `codeFlowValue`.
+  codeIndented: 'codeIndented',
+
+  // A text code (``` `alpha` ```).
+  // Includes `codeTextSequence`, `codeTextData`, `lineEnding`, and can include
+  // `codeTextPadding`.
+  codeText: 'codeText',
+
+  codeTextData: 'codeTextData',
+
+  // A space or line ending right after or before a tick.
+  codeTextPadding: 'codeTextPadding',
+
+  // A text code fence (` `` `).
+  codeTextSequence: 'codeTextSequence',
+
+  // Whole content:
+  //
+  // ```markdown
+  // [a]: b
+  // c
+  // =
+  // d
+  // ```
+  //
+  // Includes `paragraph` and `definition`.
+  content: 'content',
+  // Whole definition:
+  //
+  // ```markdown
+  // [micromark]: https://github.com/micromark/micromark
+  // ```
+  //
+  // Includes `definitionLabel`, `definitionMarker`, `whitespace`,
+  // `definitionDestination`, and optionally `lineEnding` and `definitionTitle`.
+  definition: 'definition',
+
+  // Destination of a definition (`https://github.com/micromark/micromark` or
+  // `<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteral` or `definitionDestinationRaw`.
+  definitionDestination: 'definitionDestination',
+
+  // Enclosed destination of a definition
+  // (`<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteralMarker` and optionally
+  // `definitionDestinationString`.
+  definitionDestinationLiteral: 'definitionDestinationLiteral',
+
+  // Markers of an enclosed definition destination (`<` or `>`).
+  definitionDestinationLiteralMarker: 'definitionDestinationLiteralMarker',
+
+  // Unenclosed destination of a definition
+  // (`https://github.com/micromark/micromark`).
+  // Includes `definitionDestinationString`.
+  definitionDestinationRaw: 'definitionDestinationRaw',
+
+  // Text in an destination (`https://github.com/micromark/micromark`).
+  // Includes string.
+  definitionDestinationString: 'definitionDestinationString',
+
+  // Label of a definition (`[micromark]`).
+  // Includes `definitionLabelMarker` and `definitionLabelString`.
+  definitionLabel: 'definitionLabel',
+
+  // Markers of a definition label (`[` or `]`).
+  definitionLabelMarker: 'definitionLabelMarker',
+
+  // Value of a definition label (`micromark`).
+  // Includes string.
+  definitionLabelString: 'definitionLabelString',
+
+  // Marker between a label and a destination (`:`).
+  definitionMarker: 'definitionMarker',
+
+  // Title of a definition (`"x"`, `'y'`, or `(z)`).
+  // Includes `definitionTitleMarker` and optionally `definitionTitleString`.
+  definitionTitle: 'definitionTitle',
+
+  // Marker around a title of a definition (`"`, `'`, `(`, or `)`).
+  definitionTitleMarker: 'definitionTitleMarker',
+
+  // Data without markers in a title (`z`).
+  // Includes string.
+  definitionTitleString: 'definitionTitleString',
+
+  // Emphasis (`*alpha*`).
+  // Includes `emphasisSequence` and `emphasisText`.
+  emphasis: 'emphasis',
+
+  // Sequence of emphasis markers (`*` or `_`).
+  emphasisSequence: 'emphasisSequence',
+
+  // Emphasis text (`alpha`).
+  // Includes text.
+  emphasisText: 'emphasisText',
+
+  // The character escape marker (`\`).
+  escapeMarker: 'escapeMarker',
+
+  // A hard break created with a backslash (`\\n`).
+  // Note: does not include the line ending.
+  hardBreakEscape: 'hardBreakEscape',
+
+  // A hard break created with trailing spaces (`  \n`).
+  // Does not include the line ending.
+  hardBreakTrailing: 'hardBreakTrailing',
+
+  // Flow HTML:
+  //
+  // ```markdown
+  // <div
+  // ```
+  //
+  // Inlcudes `lineEnding`, `htmlFlowData`.
+  htmlFlow: 'htmlFlow',
+
+  htmlFlowData: 'htmlFlowData',
+
+  // HTML in text (the tag in `a <i> b`).
+  // Includes `lineEnding`, `htmlTextData`.
+  htmlText: 'htmlText',
+
+  htmlTextData: 'htmlTextData',
+
+  // Whole image (`![alpha](bravo)`, `![alpha][bravo]`, `![alpha][]`, or
+  // `![alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  image: 'image',
+
+  // Whole link label (`[*alpha*]`).
+  // Includes `labelLink` or `labelImage`, `labelText`, and `labelEnd`.
+  label: 'label',
+
+  // Text in an label (`*alpha*`).
+  // Includes text.
+  labelText: 'labelText',
+
+  // Start a link label (`[`).
+  // Includes a `labelMarker`.
+  labelLink: 'labelLink',
+
+  // Start an image label (`![`).
+  // Includes `labelImageMarker` and `labelMarker`.
+  labelImage: 'labelImage',
+
+  // Marker of a label (`[` or `]`).
+  labelMarker: 'labelMarker',
+
+  // Marker to start an image (`!`).
+  labelImageMarker: 'labelImageMarker',
+
+  // End a label (`]`).
+  // Includes `labelMarker`.
+  labelEnd: 'labelEnd',
+
+  // Whole link (`[alpha](bravo)`, `[alpha][bravo]`, `[alpha][]`, or `[alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  link: 'link',
+
+  // Whole paragraph:
+  //
+  // ```markdown
+  // alpha
+  // bravo.
+  // ```
+  //
+  // Includes text.
+  paragraph: 'paragraph',
+
+  // A reference (`[alpha]` or `[]`).
+  // Includes `referenceMarker` and an optional `referenceString`.
+  reference: 'reference',
+
+  // A reference marker (`[` or `]`).
+  referenceMarker: 'referenceMarker',
+
+  // Reference text (`alpha`).
+  // Includes string.
+  referenceString: 'referenceString',
+
+  // A resource (`(https://example.com "alpha")`).
+  // Includes `resourceMarker`, an optional `resourceDestination` with an optional
+  // `whitespace` and `resourceTitle`.
+  resource: 'resource',
+
+  // A resource destination (`https://example.com`).
+  // Includes `resourceDestinationLiteral` or `resourceDestinationRaw`.
+  resourceDestination: 'resourceDestination',
+
+  // A literal resource destination (`<https://example.com>`).
+  // Includes `resourceDestinationLiteralMarker` and optionally
+  // `resourceDestinationString`.
+  resourceDestinationLiteral: 'resourceDestinationLiteral',
+
+  // A resource destination marker (`<` or `>`).
+  resourceDestinationLiteralMarker: 'resourceDestinationLiteralMarker',
+
+  // A raw resource destination (`https://example.com`).
+  // Includes `resourceDestinationString`.
+  resourceDestinationRaw: 'resourceDestinationRaw',
+
+  // Resource destination text (`https://example.com`).
+  // Includes string.
+  resourceDestinationString: 'resourceDestinationString',
+
+  // A resource marker (`(` or `)`).
+  resourceMarker: 'resourceMarker',
+
+  // A resource title (`"alpha"`, `'alpha'`, or `(alpha)`).
+  // Includes `resourceTitleMarker` and optionally `resourceTitleString`.
+  resourceTitle: 'resourceTitle',
+
+  // A resource title marker (`"`, `'`, `(`, or `)`).
+  resourceTitleMarker: 'resourceTitleMarker',
+
+  // Resource destination title (`alpha`).
+  // Includes string.
+  resourceTitleString: 'resourceTitleString',
+
+  // Whole setext heading:
+  //
+  // ```markdown
+  // alpha
+  // bravo
+  // =====
+  // ```
+  //
+  // Includes `setextHeadingText`, `lineEnding`, `linePrefix`, and
+  // `setextHeadingLine`.
+  setextHeading: 'setextHeading',
+
+  // Content in a setext heading (`alpha\nbravo`).
+  // Includes text.
+  setextHeadingText: 'setextHeadingText',
+
+  // Underline in a setext heading, including whitespace suffix (`==`).
+  // Includes `setextHeadingLineSequence`.
+  setextHeadingLine: 'setextHeadingLine',
+
+  // Sequence of equals or dash characters in underline in a setext heading (`-`).
+  setextHeadingLineSequence: 'setextHeadingLineSequence',
+
+  // Strong (`**alpha**`).
+  // Includes `strongSequence` and `strongText`.
+  strong: 'strong',
+
+  // Sequence of strong markers (`**` or `__`).
+  strongSequence: 'strongSequence',
+
+  // Strong text (`alpha`).
+  // Includes text.
+  strongText: 'strongText',
+
+  // Whole thematic break:
+  //
+  // ```markdown
+  // * * *
+  // ```
+  //
+  // Includes `thematicBreakSequence` and `whitespace`.
+  thematicBreak: 'thematicBreak',
+
+  // A sequence of one or more thematic break markers (`***`).
+  thematicBreakSequence: 'thematicBreakSequence',
+
+  // Whole block quote:
+  //
+  // ```markdown
+  // > a
+  // >
+  // > b
+  // ```
+  //
+  // Includes `blockQuotePrefix` and flow.
+  blockQuote: 'blockQuote',
+  // The `>` or `> ` of a block quote.
+  blockQuotePrefix: 'blockQuotePrefix',
+  // The `>` of a block quote prefix.
+  blockQuoteMarker: 'blockQuoteMarker',
+  // The optional ` ` of a block quote prefix.
+  blockQuotePrefixWhitespace: 'blockQuotePrefixWhitespace',
+
+  // Whole ordered list:
+  //
+  // ```markdown
+  // 1. a
+  //    b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listOrdered: 'listOrdered',
+
+  // Whole unordered list:
+  //
+  // ```markdown
+  // - a
+  //   b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listUnordered: 'listUnordered',
+
+  // The indent of further list item lines.
+  listItemIndent: 'listItemIndent',
+
+  // A marker, as in, `*`, `+`, `-`, `.`, or `)`.
+  listItemMarker: 'listItemMarker',
+
+  // The thing that starts a list item, such as `1. `.
+  // Includes `listItemValue` if ordered, `listItemMarker`, and
+  // `listItemPrefixWhitespace` (unless followed by a line ending).
+  listItemPrefix: 'listItemPrefix',
+
+  // The whitespace after a marker.
+  listItemPrefixWhitespace: 'listItemPrefixWhitespace',
+
+  // The numerical value of an ordered item.
+  listItemValue: 'listItemValue',
+
+  // Internal types used for subtokenizers, compiled away
+  chunkDocument: 'chunkDocument',
+  chunkContent: 'chunkContent',
+  chunkFlow: 'chunkFlow',
+  chunkText: 'chunkText',
+  chunkString: 'chunkString'
+})
+
+;// ./lib/micromark/jsx-table/syntax.ts
+
+
+const syntax_nonLazyContinuationStart = {
+    tokenize: syntax_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+function resolveToJsxTable(events) {
+    let index = events.length;
+    while (index > 0) {
+        index -= 1;
+        if (events[index][0] === 'enter' && events[index][1].type === 'jsxTable') {
+            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 jsxTableConstruct = {
+    name: 'jsxTable',
+    tokenize: tokenizeJsxTable,
+    resolveTo: resolveToJsxTable,
+    concrete: true,
+};
+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];
+    /** Build a state chain that matches a sequence of character codes. */
+    function matchChars(chars, onMatch, onFail) {
+        if (chars.length === 0)
+            return onMatch;
+        return ((code) => {
+            if (code === chars[0]) {
+                effects.consume(code);
+                return matchChars(chars.slice(1), onMatch, onFail);
+            }
+            return onFail(code);
+        });
+    }
+    return start;
+    function start(code) {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.enter('jsxTable');
+        effects.enter('jsxTableData');
+        effects.consume(code);
+        return afterLessThan;
+    }
+    function afterLessThan(code) {
+        if (code === codes.uppercaseT || code === 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) {
+            effects.consume(code);
+            return body;
+        }
+        return nok(code);
+    }
+    function body(code) {
+        // Reject unclosed <Table> so it falls back to normal HTML block parsing
+        // instead of swallowing all subsequent content to EOF
+        if (code === null) {
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('jsxTableData');
+            return continuationStart(code);
+        }
+        if (code === codes.backslash) {
+            effects.consume(code);
+            return escapedChar;
+        }
+        if (code === 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) {
+            codeSpanOpenSize = 0;
+            return countOpenTicks(code);
+        }
+        effects.consume(code);
+        return body;
+    }
+    function countOpenTicks(code) {
+        if (code === codes.graveAccent) {
+            codeSpanOpenSize += 1;
+            effects.consume(code);
+            return countOpenTicks;
+        }
+        return inCodeSpan(code);
+    }
+    function inCodeSpan(code) {
+        if (code === null || markdownLineEnding(code))
+            return body(code);
+        if (code === codes.graveAccent) {
+            codeSpanCloseSize = 0;
+            return countCloseTicks(code);
+        }
+        effects.consume(code);
+        return inCodeSpan;
+    }
+    function countCloseTicks(code) {
+        if (code === codes.graveAccent) {
+            codeSpanCloseSize += 1;
+            effects.consume(code);
+            return countCloseTicks;
+        }
+        return codeSpanCloseSize === codeSpanOpenSize ? body(code) : inCodeSpan(code);
+    }
+    function escapedChar(code) {
+        if (code === null || markdownLineEnding(code)) {
+            return body(code);
+        }
+        effects.consume(code);
+        return body;
+    }
+    function closeSlash(code) {
+        if (code === codes.slash) {
+            effects.consume(code);
+            return closeTagFirstChar;
+        }
+        if (code === codes.uppercaseT || code === codes.lowercaseT) {
+            effects.consume(code);
+            return matchChars(ABLE_SUFFIX, openAfterTagName, body);
+        }
+        return body(code);
+    }
+    function closeTagFirstChar(code) {
+        if (code === codes.uppercaseT || code === 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) {
+            depth += 1;
+            effects.consume(code);
+            return body;
+        }
+        return body(code);
+    }
+    function closeGt(code) {
+        if (code === codes.greaterThan) {
+            depth -= 1;
+            effects.consume(code);
+            if (depth === 0) {
+                return afterClose;
+            }
+            return body;
+        }
+        return body(code);
+    }
+    function afterClose(code) {
+        if (code === null || markdownLineEnding(code)) {
+            effects.exit('jsxTableData');
+            effects.exit('jsxTable');
+            return ok(code);
+        }
+        effects.consume(code);
+        return afterClose;
+    }
+    // Line ending handling — follows the htmlFlow pattern
+    function continuationStart(code) {
+        return effects.check(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('jsxTableData');
+        return body(code);
+    }
+    function continuationAfter(code) {
+        // At EOF without </Table>, reject so content isn't swallowed
+        if (code === null) {
+            return nok(code);
+        }
+        effects.exit('jsxTable');
+        return ok(code);
+    }
+}
+function 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);
+    }
+}
+/**
+ * Micromark extension that tokenizes `<Table>...</Table>` and `<table>...</table>`
+ * as a single flow block.
+ *
+ * Prevents CommonMark HTML block type 6 from fragmenting table blocks at blank lines.
+ */
+function syntax_jsxTable() {
+    return {
+        flow: {
+            [codes.lessThan]: [jsxTableConstruct],
+        },
+    };
+}
+
+;// ./lib/micromark/jsx-table/index.ts
+
+
 ;// ./lib/micromark/magic-block/syntax.ts
 
 
@@ -118617,7 +119377,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_codes.dash;
+    return asciiAlphanumeric(code) || code === codes.dash;
 }
 /**
  * Creates the opening marker state machine: [block:
@@ -118625,37 +119385,37 @@ function isTypeChar(code) {
  */
 function createOpeningMarkerParser(effects, nok, onComplete) {
     const expectB = (code) => {
-        if (code !== codes_codes.lowercaseB)
+        if (code !== codes.lowercaseB)
             return nok(code);
         effects.consume(code);
         return expectL;
     };
     const expectL = (code) => {
-        if (code !== codes_codes.lowercaseL)
+        if (code !== codes.lowercaseL)
             return nok(code);
         effects.consume(code);
         return expectO;
     };
     const expectO = (code) => {
-        if (code !== codes_codes.lowercaseO)
+        if (code !== codes.lowercaseO)
             return nok(code);
         effects.consume(code);
         return expectC;
     };
     const expectC = (code) => {
-        if (code !== codes_codes.lowercaseC)
+        if (code !== codes.lowercaseC)
             return nok(code);
         effects.consume(code);
         return expectK;
     };
     const expectK = (code) => {
-        if (code !== codes_codes.lowercaseK)
+        if (code !== codes.lowercaseK)
             return nok(code);
         effects.consume(code);
         return expectColon;
     };
     const expectColon = (code) => {
-        if (code !== codes_codes.colon)
+        if (code !== codes.colon)
             return nok(code);
         effects.consume(code);
         effects.exit('magicBlockMarkerStart');
@@ -118671,7 +119431,7 @@ function createOpeningMarkerParser(effects, nok, onComplete) {
 function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
     const captureTypeFirst = (code) => {
         // Reject empty type name [block:]
-        if (code === codes_codes.rightSquareBracket) {
+        if (code === codes.rightSquareBracket) {
             return nok(code);
         }
         if (isTypeChar(code)) {
@@ -118682,7 +119442,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
         return nok(code);
     };
     const captureType = (code) => {
-        if (code === codes_codes.rightSquareBracket) {
+        if (code === codes.rightSquareBracket) {
             if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
                 return nok(code);
             }
@@ -118707,7 +119467,7 @@ function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
  */
 function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
     const handleMismatch = (code) => {
-        if (jsonState && code === codes_codes.quotationMark) {
+        if (jsonState && code === codes.quotationMark) {
             jsonState.inString = true;
         }
         return onMismatch(code);
@@ -118715,7 +119475,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectSlash = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.slash)
+        if (code !== codes.slash)
             return handleMismatch(code);
         effects.consume(code);
         return expectB;
@@ -118723,7 +119483,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectB = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.lowercaseB)
+        if (code !== codes.lowercaseB)
             return handleMismatch(code);
         effects.consume(code);
         return expectL;
@@ -118731,7 +119491,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectL = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.lowercaseL)
+        if (code !== codes.lowercaseL)
             return handleMismatch(code);
         effects.consume(code);
         return expectO;
@@ -118739,7 +119499,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectO = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.lowercaseO)
+        if (code !== codes.lowercaseO)
             return handleMismatch(code);
         effects.consume(code);
         return expectC;
@@ -118747,7 +119507,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectC = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.lowercaseC)
+        if (code !== codes.lowercaseC)
             return handleMismatch(code);
         effects.consume(code);
         return expectK;
@@ -118755,7 +119515,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectK = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.lowercaseK)
+        if (code !== codes.lowercaseK)
             return handleMismatch(code);
         effects.consume(code);
         return expectBracket;
@@ -118763,7 +119523,7 @@ function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonSt
     const expectBracket = (code) => {
         if (code === null)
             return onEof(code);
-        if (code !== codes_codes.rightSquareBracket)
+        if (code !== codes.rightSquareBracket)
             return handleMismatch(code);
         effects.consume(code);
         return onSuccess;
@@ -118819,7 +119579,7 @@ function syntax_magicBlock() {
         // Flow construct - handles block-level magic blocks at document root
         // Marked as concrete to prevent interruption by containers
         flow: {
-            [codes_codes.leftSquareBracket]: {
+            [codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 concrete: true,
                 tokenize: tokenizeMagicBlockFlow,
@@ -118827,7 +119587,7 @@ function syntax_magicBlock() {
         },
         // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
         text: {
-            [codes_codes.leftSquareBracket]: {
+            [codes.leftSquareBracket]: {
                 name: 'magicBlock',
                 tokenize: tokenizeMagicBlockText,
             },
@@ -118848,7 +119608,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
     const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
     return start;
     function start(code) {
-        if (code !== codes_codes.leftSquareBracket)
+        if (code !== codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -118871,7 +119631,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_codes.leftSquareBracket) {
+        if (code === codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -118883,11 +119643,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_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes_codes.leftCurlyBrace) {
+        if (code !== codes.leftCurlyBrace) {
             effects.exit('magicBlock');
             return nok(code);
         }
@@ -118908,14 +119668,14 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
         if (markdownLineEnding(code)) {
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === 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_codes.leftCurlyBrace) {
+        if (code === codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -118936,11 +119696,11 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockData');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes_codes.leftCurlyBrace) {
+        if (code === codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -118975,23 +119735,23 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes_codes.backslash) {
+            if (code === codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes_codes.quotationMark) {
+            if (code === codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes_codes.quotationMark) {
+        if (code === codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes_codes.leftSquareBracket) {
+        if (code === codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -119024,7 +119784,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_codes.leftSquareBracket) {
+        if (code === codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return expectSlashFromContinuation;
@@ -119046,7 +119806,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
         }
-        if (code === codes_codes.slash) {
+        if (code === codes.slash) {
             effects.consume(code);
             return expectClosingB;
         }
@@ -119057,7 +119817,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_codes.quotationMark)
+        if (code === codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -119073,10 +119833,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlockMarkerEnd');
             return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
         }
-        if (code !== codes_codes.slash) {
+        if (code !== codes.slash) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119090,10 +119850,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.lowercaseB) {
+        if (code !== codes.lowercaseB) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119107,10 +119867,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.lowercaseL) {
+        if (code !== codes.lowercaseL) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119124,10 +119884,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.lowercaseO) {
+        if (code !== codes.lowercaseO) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119141,10 +119901,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.lowercaseC) {
+        if (code !== codes.lowercaseC) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119158,10 +119918,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.lowercaseK) {
+        if (code !== codes.lowercaseK) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119175,10 +119935,10 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             effects.exit('magicBlock');
             return nok(code);
         }
-        if (code !== codes_codes.rightSquareBracket) {
+        if (code !== codes.rightSquareBracket) {
             effects.exit('magicBlockMarkerEnd');
             effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
+            if (code === codes.quotationMark)
                 jsonState.inString = true;
             effects.consume(code);
             return captureData;
@@ -119205,7 +119965,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // Space or tab - consume as trailing whitespace
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             effects.enter('magicBlockTrailing');
             effects.consume(code);
             return consumeTrailingContinue;
@@ -119231,7 +119991,7 @@ function tokenizeMagicBlockFlow(effects, ok, nok) {
             return ok(code);
         }
         // More space or tab - keep consuming
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             effects.consume(code);
             return consumeTrailingContinue;
         }
@@ -119271,7 +120031,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingMismatch = (code) => {
         effects.exit('magicBlockMarkerEnd');
         effects.enter('magicBlockData');
-        if (code === codes_codes.quotationMark)
+        if (code === codes.quotationMark)
             jsonState.inString = true;
         effects.consume(code);
         return captureData;
@@ -119283,7 +120043,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
     const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
     return start;
     function start(code) {
-        if (code !== codes_codes.leftSquareBracket)
+        if (code !== codes.leftSquareBracket)
             return nok(code);
         effects.enter('magicBlock');
         effects.enter('magicBlockMarkerStart');
@@ -119307,7 +120067,7 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return beforeData;
         }
         // Check for closing marker directly (without entering data)
-        if (code === codes_codes.leftSquareBracket) {
+        if (code === codes.leftSquareBracket) {
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
             return closingFromBeforeData.expectSlash;
@@ -119318,11 +120078,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData(code);
         }
         // Skip whitespace (spaces/tabs) before the data
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             return beforeDataWhitespace(code);
         }
         // Data must start with '{' for valid JSON
-        if (code !== codes_codes.leftCurlyBrace) {
+        if (code !== codes.leftCurlyBrace) {
             return nok(code);
         }
         // We have '{' - enter data token and start capturing
@@ -119343,12 +120103,12 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             effects.enter('magicBlockData');
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes_codes.leftCurlyBrace) {
+        if (code === codes.leftCurlyBrace) {
             seenOpenBrace = true;
             effects.enter('magicBlockData');
             return captureData(code);
@@ -119370,11 +120130,11 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             effects.exit('magicBlockLineEnding');
             return beforeData;
         }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+        if (code === codes.space || code === codes.horizontalTab) {
             effects.consume(code);
             return beforeDataWhitespaceContinue;
         }
-        if (code === codes_codes.leftCurlyBrace) {
+        if (code === codes.leftCurlyBrace) {
             seenOpenBrace = true;
             return captureData(code);
         }
@@ -119402,23 +120162,23 @@ function tokenizeMagicBlockText(effects, ok, nok) {
             return captureData;
         }
         if (jsonState.inString) {
-            if (code === codes_codes.backslash) {
+            if (code === codes.backslash) {
                 jsonState.escapeNext = true;
                 effects.consume(code);
                 return captureData;
             }
-            if (code === codes_codes.quotationMark) {
+            if (code === codes.quotationMark) {
                 jsonState.inString = false;
             }
             effects.consume(code);
             return captureData;
         }
-        if (code === codes_codes.quotationMark) {
+        if (code === codes.quotationMark) {
             jsonState.inString = true;
             effects.consume(code);
             return captureData;
         }
-        if (code === codes_codes.leftSquareBracket) {
+        if (code === codes.leftSquareBracket) {
             effects.exit('magicBlockData');
             effects.enter('magicBlockMarkerEnd');
             effects.consume(code);
@@ -119444,461 +120204,6 @@ function tokenizeMagicBlockText(effects, ok, nok) {
  */
 
 
-;// ./node_modules/micromark-util-symbol/lib/types.js
-/**
- * This module is compiled away!
- *
- * Here is the list of all types of tokens exposed by micromark, with a short
- * explanation of what they include and where they are found.
- * In picking names, generally, the rule is to be as explicit as possible
- * instead of reusing names.
- * For example, there is a `definitionDestination` and a `resourceDestination`,
- * instead of one shared name.
- */
-
-// Note: when changing the next record, you must also change `TokenTypeMap`
-// in `micromark-util-types/index.d.ts`.
-const types_types = /** @type {const} */ ({
-  // Generic type for data, such as in a title, a destination, etc.
-  data: 'data',
-
-  // Generic type for syntactic whitespace (tabs, virtual spaces, spaces).
-  // Such as, between a fenced code fence and an info string.
-  whitespace: 'whitespace',
-
-  // Generic type for line endings (line feed, carriage return, carriage return +
-  // line feed).
-  lineEnding: 'lineEnding',
-
-  // A line ending, but ending a blank line.
-  lineEndingBlank: 'lineEndingBlank',
-
-  // Generic type for whitespace (tabs, virtual spaces, spaces) at the start of a
-  // line.
-  linePrefix: 'linePrefix',
-
-  // Generic type for whitespace (tabs, virtual spaces, spaces) at the end of a
-  // line.
-  lineSuffix: 'lineSuffix',
-
-  // Whole ATX heading:
-  //
-  // ```markdown
-  // #
-  // ## Alpha
-  // ### Bravo ###
-  // ```
-  //
-  // Includes `atxHeadingSequence`, `whitespace`, `atxHeadingText`.
-  atxHeading: 'atxHeading',
-
-  // Sequence of number signs in an ATX heading (`###`).
-  atxHeadingSequence: 'atxHeadingSequence',
-
-  // Content in an ATX heading (`alpha`).
-  // Includes text.
-  atxHeadingText: 'atxHeadingText',
-
-  // Whole autolink (`<https://example.com>` or `<admin@example.com>`)
-  // Includes `autolinkMarker` and `autolinkProtocol` or `autolinkEmail`.
-  autolink: 'autolink',
-
-  // Email autolink w/o markers (`admin@example.com`)
-  autolinkEmail: 'autolinkEmail',
-
-  // Marker around an `autolinkProtocol` or `autolinkEmail` (`<` or `>`).
-  autolinkMarker: 'autolinkMarker',
-
-  // Protocol autolink w/o markers (`https://example.com`)
-  autolinkProtocol: 'autolinkProtocol',
-
-  // A whole character escape (`\-`).
-  // Includes `escapeMarker` and `characterEscapeValue`.
-  characterEscape: 'characterEscape',
-
-  // The escaped character (`-`).
-  characterEscapeValue: 'characterEscapeValue',
-
-  // A whole character reference (`&amp;`, `&#8800;`, or `&#x1D306;`).
-  // Includes `characterReferenceMarker`, an optional
-  // `characterReferenceMarkerNumeric`, in which case an optional
-  // `characterReferenceMarkerHexadecimal`, and a `characterReferenceValue`.
-  characterReference: 'characterReference',
-
-  // The start or end marker (`&` or `;`).
-  characterReferenceMarker: 'characterReferenceMarker',
-
-  // Mark reference as numeric (`#`).
-  characterReferenceMarkerNumeric: 'characterReferenceMarkerNumeric',
-
-  // Mark reference as numeric (`x` or `X`).
-  characterReferenceMarkerHexadecimal: 'characterReferenceMarkerHexadecimal',
-
-  // Value of character reference w/o markers (`amp`, `8800`, or `1D306`).
-  characterReferenceValue: 'characterReferenceValue',
-
-  // Whole fenced code:
-  //
-  // ````markdown
-  // ```js
-  // alert(1)
-  // ```
-  // ````
-  codeFenced: 'codeFenced',
-
-  // A fenced code fence, including whitespace, sequence, info, and meta
-  // (` ```js `).
-  codeFencedFence: 'codeFencedFence',
-
-  // Sequence of grave accent or tilde characters (` ``` `) in a fence.
-  codeFencedFenceSequence: 'codeFencedFenceSequence',
-
-  // Info word (`js`) in a fence.
-  // Includes string.
-  codeFencedFenceInfo: 'codeFencedFenceInfo',
-
-  // Meta words (`highlight="1"`) in a fence.
-  // Includes string.
-  codeFencedFenceMeta: 'codeFencedFenceMeta',
-
-  // A line of code.
-  codeFlowValue: 'codeFlowValue',
-
-  // Whole indented code:
-  //
-  // ```markdown
-  //     alert(1)
-  // ```
-  //
-  // Includes `lineEnding`, `linePrefix`, and `codeFlowValue`.
-  codeIndented: 'codeIndented',
-
-  // A text code (``` `alpha` ```).
-  // Includes `codeTextSequence`, `codeTextData`, `lineEnding`, and can include
-  // `codeTextPadding`.
-  codeText: 'codeText',
-
-  codeTextData: 'codeTextData',
-
-  // A space or line ending right after or before a tick.
-  codeTextPadding: 'codeTextPadding',
-
-  // A text code fence (` `` `).
-  codeTextSequence: 'codeTextSequence',
-
-  // Whole content:
-  //
-  // ```markdown
-  // [a]: b
-  // c
-  // =
-  // d
-  // ```
-  //
-  // Includes `paragraph` and `definition`.
-  content: 'content',
-  // Whole definition:
-  //
-  // ```markdown
-  // [micromark]: https://github.com/micromark/micromark
-  // ```
-  //
-  // Includes `definitionLabel`, `definitionMarker`, `whitespace`,
-  // `definitionDestination`, and optionally `lineEnding` and `definitionTitle`.
-  definition: 'definition',
-
-  // Destination of a definition (`https://github.com/micromark/micromark` or
-  // `<https://github.com/micromark/micromark>`).
-  // Includes `definitionDestinationLiteral` or `definitionDestinationRaw`.
-  definitionDestination: 'definitionDestination',
-
-  // Enclosed destination of a definition
-  // (`<https://github.com/micromark/micromark>`).
-  // Includes `definitionDestinationLiteralMarker` and optionally
-  // `definitionDestinationString`.
-  definitionDestinationLiteral: 'definitionDestinationLiteral',
-
-  // Markers of an enclosed definition destination (`<` or `>`).
-  definitionDestinationLiteralMarker: 'definitionDestinationLiteralMarker',
-
-  // Unenclosed destination of a definition
-  // (`https://github.com/micromark/micromark`).
-  // Includes `definitionDestinationString`.
-  definitionDestinationRaw: 'definitionDestinationRaw',
-
-  // Text in an destination (`https://github.com/micromark/micromark`).
-  // Includes string.
-  definitionDestinationString: 'definitionDestinationString',
-
-  // Label of a definition (`[micromark]`).
-  // Includes `definitionLabelMarker` and `definitionLabelString`.
-  definitionLabel: 'definitionLabel',
-
-  // Markers of a definition label (`[` or `]`).
-  definitionLabelMarker: 'definitionLabelMarker',
-
-  // Value of a definition label (`micromark`).
-  // Includes string.
-  definitionLabelString: 'definitionLabelString',
-
-  // Marker between a label and a destination (`:`).
-  definitionMarker: 'definitionMarker',
-
-  // Title of a definition (`"x"`, `'y'`, or `(z)`).
-  // Includes `definitionTitleMarker` and optionally `definitionTitleString`.
-  definitionTitle: 'definitionTitle',
-
-  // Marker around a title of a definition (`"`, `'`, `(`, or `)`).
-  definitionTitleMarker: 'definitionTitleMarker',
-
-  // Data without markers in a title (`z`).
-  // Includes string.
-  definitionTitleString: 'definitionTitleString',
-
-  // Emphasis (`*alpha*`).
-  // Includes `emphasisSequence` and `emphasisText`.
-  emphasis: 'emphasis',
-
-  // Sequence of emphasis markers (`*` or `_`).
-  emphasisSequence: 'emphasisSequence',
-
-  // Emphasis text (`alpha`).
-  // Includes text.
-  emphasisText: 'emphasisText',
-
-  // The character escape marker (`\`).
-  escapeMarker: 'escapeMarker',
-
-  // A hard break created with a backslash (`\\n`).
-  // Note: does not include the line ending.
-  hardBreakEscape: 'hardBreakEscape',
-
-  // A hard break created with trailing spaces (`  \n`).
-  // Does not include the line ending.
-  hardBreakTrailing: 'hardBreakTrailing',
-
-  // Flow HTML:
-  //
-  // ```markdown
-  // <div
-  // ```
-  //
-  // Inlcudes `lineEnding`, `htmlFlowData`.
-  htmlFlow: 'htmlFlow',
-
-  htmlFlowData: 'htmlFlowData',
-
-  // HTML in text (the tag in `a <i> b`).
-  // Includes `lineEnding`, `htmlTextData`.
-  htmlText: 'htmlText',
-
-  htmlTextData: 'htmlTextData',
-
-  // Whole image (`![alpha](bravo)`, `![alpha][bravo]`, `![alpha][]`, or
-  // `![alpha]`).
-  // Includes `label` and an optional `resource` or `reference`.
-  image: 'image',
-
-  // Whole link label (`[*alpha*]`).
-  // Includes `labelLink` or `labelImage`, `labelText`, and `labelEnd`.
-  label: 'label',
-
-  // Text in an label (`*alpha*`).
-  // Includes text.
-  labelText: 'labelText',
-
-  // Start a link label (`[`).
-  // Includes a `labelMarker`.
-  labelLink: 'labelLink',
-
-  // Start an image label (`![`).
-  // Includes `labelImageMarker` and `labelMarker`.
-  labelImage: 'labelImage',
-
-  // Marker of a label (`[` or `]`).
-  labelMarker: 'labelMarker',
-
-  // Marker to start an image (`!`).
-  labelImageMarker: 'labelImageMarker',
-
-  // End a label (`]`).
-  // Includes `labelMarker`.
-  labelEnd: 'labelEnd',
-
-  // Whole link (`[alpha](bravo)`, `[alpha][bravo]`, `[alpha][]`, or `[alpha]`).
-  // Includes `label` and an optional `resource` or `reference`.
-  link: 'link',
-
-  // Whole paragraph:
-  //
-  // ```markdown
-  // alpha
-  // bravo.
-  // ```
-  //
-  // Includes text.
-  paragraph: 'paragraph',
-
-  // A reference (`[alpha]` or `[]`).
-  // Includes `referenceMarker` and an optional `referenceString`.
-  reference: 'reference',
-
-  // A reference marker (`[` or `]`).
-  referenceMarker: 'referenceMarker',
-
-  // Reference text (`alpha`).
-  // Includes string.
-  referenceString: 'referenceString',
-
-  // A resource (`(https://example.com "alpha")`).
-  // Includes `resourceMarker`, an optional `resourceDestination` with an optional
-  // `whitespace` and `resourceTitle`.
-  resource: 'resource',
-
-  // A resource destination (`https://example.com`).
-  // Includes `resourceDestinationLiteral` or `resourceDestinationRaw`.
-  resourceDestination: 'resourceDestination',
-
-  // A literal resource destination (`<https://example.com>`).
-  // Includes `resourceDestinationLiteralMarker` and optionally
-  // `resourceDestinationString`.
-  resourceDestinationLiteral: 'resourceDestinationLiteral',
-
-  // A resource destination marker (`<` or `>`).
-  resourceDestinationLiteralMarker: 'resourceDestinationLiteralMarker',
-
-  // A raw resource destination (`https://example.com`).
-  // Includes `resourceDestinationString`.
-  resourceDestinationRaw: 'resourceDestinationRaw',
-
-  // Resource destination text (`https://example.com`).
-  // Includes string.
-  resourceDestinationString: 'resourceDestinationString',
-
-  // A resource marker (`(` or `)`).
-  resourceMarker: 'resourceMarker',
-
-  // A resource title (`"alpha"`, `'alpha'`, or `(alpha)`).
-  // Includes `resourceTitleMarker` and optionally `resourceTitleString`.
-  resourceTitle: 'resourceTitle',
-
-  // A resource title marker (`"`, `'`, `(`, or `)`).
-  resourceTitleMarker: 'resourceTitleMarker',
-
-  // Resource destination title (`alpha`).
-  // Includes string.
-  resourceTitleString: 'resourceTitleString',
-
-  // Whole setext heading:
-  //
-  // ```markdown
-  // alpha
-  // bravo
-  // =====
-  // ```
-  //
-  // Includes `setextHeadingText`, `lineEnding`, `linePrefix`, and
-  // `setextHeadingLine`.
-  setextHeading: 'setextHeading',
-
-  // Content in a setext heading (`alpha\nbravo`).
-  // Includes text.
-  setextHeadingText: 'setextHeadingText',
-
-  // Underline in a setext heading, including whitespace suffix (`==`).
-  // Includes `setextHeadingLineSequence`.
-  setextHeadingLine: 'setextHeadingLine',
-
-  // Sequence of equals or dash characters in underline in a setext heading (`-`).
-  setextHeadingLineSequence: 'setextHeadingLineSequence',
-
-  // Strong (`**alpha**`).
-  // Includes `strongSequence` and `strongText`.
-  strong: 'strong',
-
-  // Sequence of strong markers (`**` or `__`).
-  strongSequence: 'strongSequence',
-
-  // Strong text (`alpha`).
-  // Includes text.
-  strongText: 'strongText',
-
-  // Whole thematic break:
-  //
-  // ```markdown
-  // * * *
-  // ```
-  //
-  // Includes `thematicBreakSequence` and `whitespace`.
-  thematicBreak: 'thematicBreak',
-
-  // A sequence of one or more thematic break markers (`***`).
-  thematicBreakSequence: 'thematicBreakSequence',
-
-  // Whole block quote:
-  //
-  // ```markdown
-  // > a
-  // >
-  // > b
-  // ```
-  //
-  // Includes `blockQuotePrefix` and flow.
-  blockQuote: 'blockQuote',
-  // The `>` or `> ` of a block quote.
-  blockQuotePrefix: 'blockQuotePrefix',
-  // The `>` of a block quote prefix.
-  blockQuoteMarker: 'blockQuoteMarker',
-  // The optional ` ` of a block quote prefix.
-  blockQuotePrefixWhitespace: 'blockQuotePrefixWhitespace',
-
-  // Whole ordered list:
-  //
-  // ```markdown
-  // 1. a
-  //    b
-  // ```
-  //
-  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
-  // lines.
-  listOrdered: 'listOrdered',
-
-  // Whole unordered list:
-  //
-  // ```markdown
-  // - a
-  //   b
-  // ```
-  //
-  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
-  // lines.
-  listUnordered: 'listUnordered',
-
-  // The indent of further list item lines.
-  listItemIndent: 'listItemIndent',
-
-  // A marker, as in, `*`, `+`, `-`, `.`, or `)`.
-  listItemMarker: 'listItemMarker',
-
-  // The thing that starts a list item, such as `1. `.
-  // Includes `listItemValue` if ordered, `listItemMarker`, and
-  // `listItemPrefixWhitespace` (unless followed by a line ending).
-  listItemPrefix: 'listItemPrefix',
-
-  // The whitespace after a marker.
-  listItemPrefixWhitespace: 'listItemPrefixWhitespace',
-
-  // The numerical value of an ordered item.
-  listItemValue: 'listItemValue',
-
-  // Internal types used for subtokenizers, compiled away
-  chunkDocument: 'chunkDocument',
-  chunkContent: 'chunkContent',
-  chunkFlow: 'chunkFlow',
-  chunkText: 'chunkText',
-  chunkString: 'chunkString'
-})
-
 ;// ./lib/micromark/mdx-component/syntax.ts
 
 
@@ -119914,8 +120219,8 @@ const htmlFlowTagNames = new Set([...htmlRawNames, ...htmlBlockNames]);
 // blank lines between nested JSX siblings don't fragment the block. Excludes table
 // tags (mdxishTables owns their blank lines) and voids (never close).
 const plainBlockClaimTagNames = new Set([...htmlBlockNames].filter(tag => !HTML_TABLE_STRUCTURE_TAGS.has(tag) && !HTML_VOID_ELEMENTS.has(tag)));
-const syntax_nonLazyContinuationStart = {
-    tokenize: syntax_tokenizeNonLazyContinuationStart,
+const mdx_component_syntax_nonLazyContinuationStart = {
+    tokenize: mdx_component_syntax_tokenizeNonLazyContinuationStart,
     partial: true,
 };
 // Lookahead for `plainClaimLineStart`: is this line markup-only, or a paragraph
@@ -120009,11 +120314,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_codes.uppercaseA && code <= codes_codes.uppercaseZ) ||
-            (code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ);
+        const isAlpha = (code) => (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+            (code >= codes.lowercaseA && code <= codes.lowercaseZ);
         const isSameCaseAsTag = (code) => isLowercaseTag
-            ? code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ
-            : code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ;
+            ? code >= codes.lowercaseA && code <= codes.lowercaseZ
+            : code >= codes.uppercaseA && code <= codes.uppercaseZ;
         // Shared brace-expression state machine. The two call sites differ only in where
         // to continue after a line ending and where to return when braceDepth reaches zero.
         function createBraceExprStates(continuationStart, afterBraceClose) {
@@ -120026,22 +120331,22 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
+                if (code === codes.quotationMark || code === codes.apostrophe) {
                     quoteChar = code;
                     effects.consume(code);
                     return braceString;
                 }
-                if (code === codes_codes.graveAccent) {
+                if (code === codes.graveAccent) {
                     inTemplateLit = true;
                     effects.consume(code);
                     return braceTemplateLiteral;
                 }
-                if (code === codes_codes.leftCurlyBrace) {
+                if (code === codes.leftCurlyBrace) {
                     braceDepth += 1;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes_codes.rightCurlyBrace) {
+                if (code === codes.rightCurlyBrace) {
                     braceDepth -= 1;
                     effects.consume(code);
                     if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
@@ -120066,7 +120371,7 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes_codes.backslash) {
+                if (code === codes.backslash) {
                     effects.consume(code);
                     return braceStringEscape;
                 }
@@ -120094,16 +120399,16 @@ function createTokenize(mode) {
                     effects.exit('mdxComponentData');
                     return continuationStart(code);
                 }
-                if (code === codes_codes.graveAccent) {
+                if (code === codes.graveAccent) {
                     inTemplateLit = false;
                     effects.consume(code);
                     return braceExpr;
                 }
-                if (code === codes_codes.backslash) {
+                if (code === codes.backslash) {
                     effects.consume(code);
                     return braceTemplateLiteralEscape;
                 }
-                if (code === codes_codes.dollarSign) {
+                if (code === codes.dollarSign) {
                     effects.consume(code);
                     return braceTemplateLiteralDollar;
                 }
@@ -120118,7 +120423,7 @@ function createTokenize(mode) {
                 return braceTemplateLiteral;
             }
             function braceTemplateLiteralDollar(code) {
-                if (code === codes_codes.leftCurlyBrace) {
+                if (code === codes.leftCurlyBrace) {
                     templateStack.push(braceDepth);
                     braceDepth += 1;
                     inTemplateLit = false;
@@ -120134,7 +120439,7 @@ function createTokenize(mode) {
         return start;
         // ── Start ──────────────────────────────────────────────────────────────
         function start(code) {
-            if (code !== codes_codes.lessThan)
+            if (code !== codes.lessThan)
                 return nok(code);
             effects.enter('mdxComponent');
             effects.enter('mdxComponentData');
@@ -120146,7 +120451,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_codes.uppercaseA && code <= codes_codes.uppercaseZ) {
+            if (code !== null && code >= codes.uppercaseA && code <= codes.uppercaseZ) {
                 tagName = String.fromCharCode(code);
                 isLowercaseTag = false;
                 sawBraceAttr = false;
@@ -120156,7 +120461,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_codes.lowercaseA && code <= codes_codes.lowercaseZ) {
+            if (code !== null && code >= codes.lowercaseA && code <= codes.lowercaseZ) {
                 if (isFlow && self.interrupt)
                     return nok(code);
                 tagName = String.fromCharCode(code);
@@ -120169,10 +120474,10 @@ function createTokenize(mode) {
         }
         function tagNameRest(code) {
             if (code !== null &&
-                ((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)) {
+                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
+                    (code >= codes.digit0 && code <= codes.digit9) ||
+                    code === codes.underscore)) {
                 tagName += String.fromCharCode(code);
                 effects.consume(code);
                 return tagNameRest;
@@ -120207,14 +120512,14 @@ function createTokenize(mode) {
                 return openTagContinuationStart(code);
             }
             // Self-closing />
-            if (code === codes_codes.slash) {
+            if (code === codes.slash) {
                 if (requiresBraceAttr && !sawBraceAttr)
                     return nok(code);
                 effects.consume(code);
                 return selfCloseGt;
             }
             // End of opening tag
-            if (code === codes_codes.greaterThan) {
+            if (code === codes.greaterThan) {
                 if (requiresBraceAttr && !sawBraceAttr) {
                     // Plain lowercase block tags stay claimable in flow, gated per line by
                     // `plainClaimLineStart`; everything else falls through to CommonMark.
@@ -120227,13 +120532,13 @@ function createTokenize(mode) {
                 return body;
             }
             // Quoted attribute value
-            if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
+            if (code === codes.quotationMark || code === codes.apostrophe) {
                 quoteChar = code;
                 effects.consume(code);
                 return inQuotedAttr;
             }
             // JSX expression attribute
-            if (code === codes_codes.leftCurlyBrace) {
+            if (code === codes.leftCurlyBrace) {
                 braceDepth = 1;
                 sawBraceAttr = true;
                 effects.consume(code);
@@ -120251,7 +120556,7 @@ function createTokenize(mode) {
                 effects.exit('mdxComponentData');
                 return openTagContinuationStart(code);
             }
-            if (code === codes_codes.backslash) {
+            if (code === codes.backslash) {
                 effects.consume(code);
                 return inQuotedAttrEscape;
             }
@@ -120271,7 +120576,7 @@ function createTokenize(mode) {
             return inQuotedAttr;
         }
         function selfCloseGt(code) {
-            if (code === codes_codes.greaterThan) {
+            if (code === codes.greaterThan) {
                 effects.consume(code);
                 // Self-closing tag completes the token
                 return afterClose;
@@ -120281,7 +120586,7 @@ function createTokenize(mode) {
         }
         // Continuation for multi-line opening tags
         function openTagContinuationStart(code) {
-            return effects.check(syntax_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
+            return effects.check(mdx_component_syntax_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
         }
         function openTagContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120324,25 +120629,25 @@ function createTokenize(mode) {
                 atLineStart = true;
                 return bodyContinuationStart(code);
             }
-            if (code !== codes_codes.space && code !== codes_codes.horizontalTab) {
+            if (code !== codes.space && code !== codes.horizontalTab) {
                 openerLineHasContent = true;
             }
-            if (code === codes_codes.backslash) {
+            if (code === codes.backslash) {
                 effects.consume(code);
                 return bodyEscapedChar;
             }
-            if (code === codes_codes.lessThan) {
+            if (code === codes.lessThan) {
                 effects.consume(code);
                 return bodyLessThan;
             }
             // Code span tracking
-            if (code === codes_codes.graveAccent) {
+            if (code === 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_codes.leftCurlyBrace) {
+            if (code === codes.leftCurlyBrace) {
                 braceDepth = 1;
                 inTemplateLit = false;
                 effects.consume(code);
@@ -120362,14 +120667,14 @@ function createTokenize(mode) {
         }
         // ── Code span handling ─────────────────────────────────────────────────
         function countOpenTicks(code) {
-            if (code === codes_codes.graveAccent) {
+            if (code === codes.graveAccent) {
                 codeSpanOpenSize += 1;
                 effects.consume(code);
                 return countOpenTicks;
             }
             // 3+ backticks at line start = fenced code block
             if (atLineStart && codeSpanOpenSize >= 3) {
-                fenceChar = codes_codes.graveAccent;
+                fenceChar = codes.graveAccent;
                 fenceLength = codeSpanOpenSize;
                 atLineStart = false;
                 return inFencedCode(code);
@@ -120379,7 +120684,7 @@ function createTokenize(mode) {
         function inCodeSpan(code) {
             if (code === null || markdownLineEnding(code))
                 return body(code);
-            if (code === codes_codes.graveAccent) {
+            if (code === codes.graveAccent) {
                 codeSpanCloseSize = 0;
                 return countCloseTicks(code);
             }
@@ -120387,7 +120692,7 @@ function createTokenize(mode) {
             return inCodeSpan;
         }
         function countCloseTicks(code) {
-            if (code === codes_codes.graveAccent) {
+            if (code === codes.graveAccent) {
                 codeSpanCloseSize += 1;
                 effects.consume(code);
                 return countCloseTicks;
@@ -120406,7 +120711,7 @@ function createTokenize(mode) {
             return inFencedCode;
         }
         function fencedCodeContinuationStart(code) {
-            return effects.check(syntax_nonLazyContinuationStart, fencedCodeContinuationNonLazy, continuationAfter)(code);
+            return effects.check(mdx_component_syntax_nonLazyContinuationStart, fencedCodeContinuationNonLazy, continuationAfter)(code);
         }
         function fencedCodeContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120421,6 +120726,16 @@ function createTokenize(mode) {
             }
             effects.enter('mdxComponentData');
             fenceCloseLength = 0;
+            return fencedCodeMaybeClose(code);
+        }
+        // Skip leading indentation before the closing-fence check: an indented fence
+        // (the norm in a component body) closes on an equally-indented line, else the
+        // closer is never matched and scanning runs to EOF (CX-3704).
+        function fencedCodeMaybeClose(code) {
+            if (markdownSpace(code)) {
+                effects.consume(code);
+                return fencedCodeMaybeClose;
+            }
             // Check for closing fence
             if (code === fenceChar) {
                 fenceCloseLength = 1;
@@ -120450,7 +120765,7 @@ function createTokenize(mode) {
                 return body(code);
             }
             // Only spaces/tabs allowed after closing fence
-            if (code === codes_codes.space || code === codes_codes.horizontalTab) {
+            if (code === codes.space || code === codes.horizontalTab) {
                 effects.consume(code);
                 return fenceCloseTrailing;
             }
@@ -120459,7 +120774,7 @@ function createTokenize(mode) {
         }
         // ── Tilde fenced code detection ────────────────────────────────────────
         function bodyAfterLineStart(code) {
-            if (code === codes_codes.tilde) {
+            if (code === codes.tilde) {
                 fenceCloseLength = 1;
                 effects.consume(code);
                 return countTildes;
@@ -120468,13 +120783,13 @@ function createTokenize(mode) {
             return body(code);
         }
         function countTildes(code) {
-            if (code === codes_codes.tilde) {
+            if (code === codes.tilde) {
                 fenceCloseLength += 1;
                 effects.consume(code);
                 return countTildes;
             }
             if (fenceCloseLength >= 3) {
-                fenceChar = codes_codes.tilde;
+                fenceChar = codes.tilde;
                 fenceLength = fenceCloseLength;
                 return inFencedCode(code);
             }
@@ -120484,7 +120799,7 @@ function createTokenize(mode) {
         }
         // ── Tag detection inside body ──────────────────────────────────────────
         function bodyLessThan(code) {
-            if (code === codes_codes.slash) {
+            if (code === codes.slash) {
                 if (onOpenerLine)
                     openerLineCloses += 1;
                 effects.consume(code);
@@ -120511,10 +120826,10 @@ function createTokenize(mode) {
         // ── Nested opening tag ─────────────────────────────────────────────────
         function nestedOpenTagName(code) {
             if (code !== null &&
-                ((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)) {
+                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
+                    (code >= codes.digit0 && code <= codes.digit9) ||
+                    code === codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return nestedOpenTagName;
@@ -120522,10 +120837,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_codes.greaterThan ||
-                    code === codes_codes.slash ||
-                    code === codes_codes.space ||
-                    code === codes_codes.horizontalTab ||
+                (code === codes.greaterThan ||
+                    code === codes.slash ||
+                    code === codes.space ||
+                    code === codes.horizontalTab ||
                     markdownLineEnding(code))) {
                 depth += 1;
             }
@@ -120544,15 +120859,15 @@ function createTokenize(mode) {
         }
         function closingTagNameRest(code) {
             if (code !== null &&
-                ((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)) {
+                ((code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+                    (code >= codes.lowercaseA && code <= codes.lowercaseZ) ||
+                    (code >= codes.digit0 && code <= codes.digit9) ||
+                    code === codes.underscore)) {
                 closingTagName += String.fromCharCode(code);
                 effects.consume(code);
                 return closingTagNameRest;
             }
-            if (closingTagName === tagName && code === codes_codes.greaterThan) {
+            if (closingTagName === tagName && code === codes.greaterThan) {
                 depth -= 1;
                 effects.consume(code);
                 if (depth === 0) {
@@ -120604,7 +120919,7 @@ function createTokenize(mode) {
         }
         // ── Body continuation (line endings) ───────────────────────────────────
         function bodyContinuationStart(code) {
-            return effects.check(syntax_nonLazyContinuationStart, bodyContinuationNonLazy, continuationAfter)(code);
+            return effects.check(mdx_component_syntax_nonLazyContinuationStart, bodyContinuationNonLazy, continuationAfter)(code);
         }
         function bodyContinuationNonLazy(code) {
             sawLineEnding = true;
@@ -120636,9 +120951,16 @@ function createTokenize(mode) {
         }
         // Dispatch a non-blank continuation line: fenced code at line start, else body.
         function bodyLineStart(code) {
-            if (atLineStart && code === codes_codes.tilde)
+            // Skip leading indentation while staying "at line start" so an indented
+            // fence is still recognized. Otherwise the first space clears `atLineStart`
+            // and its content — including any unbalanced `{` — stays live text (CX-3704).
+            if (atLineStart && markdownSpace(code)) {
+                effects.consume(code);
+                return bodyLineStart;
+            }
+            if (atLineStart && code === codes.tilde)
                 return bodyAfterLineStart(code);
-            if (atLineStart && code === codes_codes.graveAccent) {
+            if (atLineStart && code === 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
@@ -120653,7 +120975,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_codes.space || code === codes_codes.horizontalTab) {
+            if (code === codes.space || code === codes.horizontalTab) {
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -120666,7 +120988,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_codes.lessThan)
+                if (code !== codes.lessThan)
                     return nok(code);
                 return effects.check(markupOnlyContinuation, plainClaimContinue, nok)(code);
             }
@@ -120686,7 +121008,7 @@ function createTokenize(mode) {
         }
     };
 }
-function syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
+function mdx_component_syntax_tokenizeNonLazyContinuationStart(effects, ok, nok) {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     return start;
@@ -120719,7 +121041,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
         return afterLessThan;
     }
     function afterLessThan(code) {
-        if (code === codes_codes.slash) {
+        if (code === codes.slash) {
             effects.consume(code);
             return afterSlash;
         }
@@ -120738,7 +121060,7 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
     function scanToLineEnd(code) {
         if (code === null || markdownLineEnding(code)) {
             effects.exit(types_types.data);
-            return lastNonSpace === codes_codes.greaterThan ? ok(code) : nok(code);
+            return lastNonSpace === codes.greaterThan ? ok(code) : nok(code);
         }
         if (!markdownSpace(code))
             lastNonSpace = code;
@@ -120771,8 +121093,8 @@ function tokenizeMarkupOnlyContinuation(effects, ok, nok) {
  */
 function syntax_mdxComponent() {
     return {
-        flow: { [codes_codes.lessThan]: [mdxComponentFlowConstruct] },
-        text: { [codes_codes.lessThan]: [mdxComponentTextConstruct] },
+        flow: { [codes.lessThan]: [mdxComponentFlowConstruct] },
+        text: { [codes.lessThan]: [mdxComponentTextConstruct] },
     };
 }
 
@@ -120794,9 +121116,20 @@ function syntax_mdxComponent() {
 
 
 
+
+
+
+
+
+
 const buildInlineMdProcessor = (safeMode) => {
-    const micromarkExts = [syntax_mdxComponent(), syntax_gemoji(), legacyVariable(), syntax_magicBlock()];
+    // `jsxTable` must be present so a `<Table>`/`<table>` nested in a component
+    // body (e.g. a `<Callout>`) is captured as one html node. Without it, blank
+    // lines between rows let CommonMark HTML block type 6 fragment the table and
+    // its rows spill out as text / indented code blocks (CX-3705).
+    const micromarkExts = [syntax_jsxTable(), syntax_mdxComponent(), syntax_gemoji(), legacyVariable(), syntax_magicBlock()];
     const fromMarkdownExts = [
+        jsx_table_jsxTableFromMarkdown(),
         mdx_component_mdxComponentFromMarkdown(),
         gemojiFromMarkdown(),
         legacyVariableFromMarkdown(),
@@ -120856,6 +121189,65 @@ const toMdxJsxTextElement = (name, attributes, children, position) => ({
     children,
     ...(position ? { position } : {}),
 });
+// Raw-body tags (pre/script/style/textarea) must stay byte-exact; table
+// structure (`table` + `tableTags`) is owned by `mdxishTables` and figures by
+// `mdxishJsxToMdast`, both of which run later on raw html nodes.
+const NON_PROMOTABLE_PLAIN_TAGS = new Set([...htmlRawNames, ...tableTags, 'table', 'figure', 'figcaption']);
+const NESTED_TABLE_RE = /<table[\s>]/i;
+const isMarkdownPromotableHtmlTag = (tag) => !NON_PROMOTABLE_PLAIN_TAGS.has(tag);
+// Expression nodes count as plain so `<div>{1+1}</div>` keeps its current
+// literal-brace behavior; variables/glossary already resolve inside raw html.
+const PLAIN_CONTENT_TYPES = new Set([
+    'paragraph',
+    'text',
+    'html',
+    'mdxTextExpression',
+    'mdxFlowExpression',
+    enums_NodeTypes.variable,
+    enums_NodeTypes.glossary,
+]);
+// Promoting plain HTML is only worth bypassing rehype-raw's parse5 pass when
+// the body parses into an actual markdown construct.
+const containsMarkdownConstruct = (nodes) => nodes.some(node => !PLAIN_CONTENT_TYPES.has(node.type) ||
+    ('children' in node && Array.isArray(node.children) && containsMarkdownConstruct(node.children)));
+/**
+ * Index of the `</tag>` that balances the already-consumed opening tag (the
+ * caller starts us one level deep). `lastIndexOf` mis-slices sibling same-tag
+ * pairs like `<div>**a**</div><div>**b**</div>`, so we depth-match instead —
+ * delegating to `walkTags` (htmlparser2) so quoted attributes (`title="</div>"`),
+ * code spans, and legacy `<<VARIABLE>>` are handled for free. Returns -1 when
+ * the wrapper is left open.
+ */
+function findBalancedClosingTagIndex(content, tag) {
+    const target = tag.toLowerCase();
+    const canonicalCloserLength = tag.length + 3; // `</tag>`
+    // The caller already stripped the opening tag, so re-attach one: htmlparser2
+    // drops an unmatched closer, and we want it balanced. Offsets shift by the
+    // prefix length.
+    const prefix = `<${tag}>`;
+    let depth = 0;
+    let closeIndex = -1;
+    walkTags(prefix + content, {
+        onOpen: ({ name, isSelfClosing, isStrayCloser }) => {
+            if (closeIndex >= 0 || isSelfClosing || isStrayCloser)
+                return;
+            if (name.toLowerCase() === target)
+                depth += 1;
+        },
+        onClose: ({ name, start, end, implicit }) => {
+            if (closeIndex >= 0 || implicit || name.toLowerCase() !== target)
+                return;
+            // Only canonical `</tag>` closers — the caller slices by that length, so a
+            // whitespaced `</tag >` would misalign; leaving it unmatched keeps it raw.
+            if (end - start !== canonicalCloserLength)
+                return;
+            depth -= 1;
+            if (depth === 0)
+                closeIndex = start - prefix.length;
+        },
+    });
+    return closeIndex;
+}
 
 ;// ./processor/transform/mdxish/components/inline-html.ts
 
@@ -121180,6 +121572,10 @@ const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
  * This transformer identifies these patterns and converts them to proper MDX JSX elements so they
  * can be accurately recognized and rendered later with their component definition code.
  *
+ * Note: The main goal is to promote PascalCase tags to MDX elements, but we want to promote
+ * normal HTML to MDX elements in some cases so they get the full custom parsing behavior.
+ * E.g. tags with JSX expressions, nested components, etc.
+ *
  * The mdx-component micromark tokenizer ensures that multi-line components are captured
  * as single HTML nodes, so this transformer only needs to handle two cases:
  *
@@ -121226,6 +121622,7 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
             return; // owned by dedicated transformers
         const isPascal = isPascalCase(tag);
+        // ==== SPECIAL CASES TO PROMOTE NORMAL HTML TO MDX ELEMENTS ====
         // Lowercase inline tags with `{…}` attributes belong to
         // mdxishInlineComponentBlocks; leave them as html for that pass. PascalCase
         // components stay flow-level even when inline (ReadMe's component model).
@@ -121234,11 +121631,19 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         // A lowercase wrapper is only promoted when it (or a descendant) carries a
         // JSX expression or nests a component; otherwise it would swallow that inner
         // JSX/component as literal text that rehype-raw's parse5 pass can't handle.
-        // Table-structural wrappers are excluded — `mdxishTables` re-parses those.
-        const hasNestedExpressionAttr = !selfClosing && NESTED_ATTR_EXPRESSION_RE.test(contentAfterTag);
+        // Table-structural wrappers are excluded from both — `mdxishTables` re-parses
+        // those, so a `{…}` in a cell (e.g. `<code>--depth={n}</code>`) must not
+        // accidentally promote the table to an MDX element prematurely.
         const isTableStructuralTag = tag === 'table' || tableTags.has(tag);
+        const hasNestedExpressionAttr = !selfClosing && !isTableStructuralTag && NESTED_ATTR_EXPRESSION_RE.test(contentAfterTag);
         const hasNestedComponentTag = !selfClosing && !isTableStructuralTag && hasNestedGenericComponentTag(contentAfterTag);
-        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr && !hasNestedComponentTag)
+        // Promotion: By default commonmark doesn't parse markdown in single line HTML tags (e.g. <div>**bold**</div>)
+        // To support that, we try to promote them to MDX elements so the markdown gets parsed
+        const isPlainLowercaseHtml = !isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr && !hasNestedComponentTag;
+        const plainClosingTagIndex = isPlainLowercaseHtml && !selfClosing && isMarkdownPromotableHtmlTag(tag) && !NESTED_TABLE_RE.test(contentAfterTag)
+            ? findBalancedClosingTagIndex(contentAfterTag, tag)
+            : -1;
+        if (isPlainLowercaseHtml && plainClosingTagIndex < 0)
             return;
         const closingTagStr = `</${tag}>`;
         // Case 1: Self-closing tag
@@ -121259,14 +121664,26 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
             return;
         }
         // Case 2: Self-contained block (closing tag in content)
-        if (contentAfterTag.includes(closingTagStr)) {
-            const closingTagIndex = contentAfterTag.lastIndexOf(closingTagStr);
+        const closingTagIndex = isPlainLowercaseHtml ? plainClosingTagIndex : contentAfterTag.lastIndexOf(closingTagStr);
+        if (closingTagIndex >= 0) {
             // Untrimmed so parseMdChildren can dedent before trimming.
             const componentInnerContent = contentAfterTag.substring(0, closingTagIndex);
             const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
-            let parsedChildren = componentInnerContent.trim()
-                ? parseMdChildren(componentInnerContent, safeMode)
-                : [];
+            let parsedChildren = [];
+            if (componentInnerContent.trim()) {
+                try {
+                    parsedChildren = parseMdChildren(componentInnerContent, safeMode);
+                }
+                catch (error) {
+                    // Plain HTML bodies can hold anything (e.g. stray braces the strict
+                    // expression parser rejects) — keep the node raw instead of throwing.
+                    if (isPlainLowercaseHtml)
+                        return;
+                    throw error;
+                }
+            }
+            if (isPlainLowercaseHtml && !containsMarkdownConstruct(parsedChildren))
+                return;
             // Lowercase tags are usually inline; unwrap a sole paragraph so their
             // phrasing content isn't spuriously block-wrapped.
             if (!isPascal && parsedChildren.length === 1 && parsedChildren[0].type === 'paragraph') {
@@ -123467,21 +123884,21 @@ function resolveEntity(name) {
 function tokenizeLooseHtmlEntity(effects, ok, nok) {
     let length = 0;
     const start = (code) => {
-        if (code !== codes_codes.ampersand)
+        if (code !== codes.ampersand)
             return nok(code);
         effects.enter('looseHtmlEntity');
         effects.consume(code);
         return afterAmpersand;
     };
     const afterAmpersand = (code) => {
-        if (code === codes_codes.numberSign) {
+        if (code === codes.numberSign) {
             effects.consume(code);
             return afterHash;
         }
         return accumulateNamed(code);
     };
     const afterHash = (code) => {
-        if (code === codes_codes.lowercaseX || code === codes_codes.uppercaseX) {
+        if (code === codes.lowercaseX || code === codes.uppercaseX) {
             effects.consume(code);
             return accumulateHex;
         }
@@ -123495,7 +123912,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes_codes.semicolon)
+        if (code === codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -123508,7 +123925,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes_codes.semicolon)
+        if (code === codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -123521,7 +123938,7 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
         }
         if (length === 0)
             return nok(code);
-        if (code === codes_codes.semicolon)
+        if (code === codes.semicolon)
             return nok(code);
         effects.exit('looseHtmlEntity');
         return ok(code);
@@ -123556,7 +123973,7 @@ function exitLooseHtmlEntity(token) {
 }
 function looseHtmlEntity() {
     return {
-        text: { [codes_codes.ampersand]: looseHtmlEntityConstruct },
+        text: { [codes.ampersand]: looseHtmlEntityConstruct },
     };
 }
 function looseHtmlEntityFromMarkdown() {
@@ -124249,9 +124666,6 @@ const magicBlockTransformer = (options = {}) => tree => {
 // single-line `<div>…</div>`). CommonMark slurps the whole div as one `html`
 // node, so the tokenizer never sees the HTMLBlock — we recover it here.
 const RAW_HTML_BLOCK_RE = /<HTMLBlock\b([^>]*)>\s*\{\s*`((?:[^`\\]|\\.)*)`\s*\}\s*<\/HTMLBlock>/g;
-// Opening `<HTMLBlock …>` as its own `html` node — produced inside a paragraph
-// when an HTMLBlock appears inline alongside text.
-const HTML_BLOCK_OPEN_RE = /^<HTMLBlock\b([^>]*)>$/;
 /**
  * Builds the canonical `html-block` MDAST node the renderer expects.
  */
@@ -124332,13 +124746,14 @@ const splitRawHtmlBlocks = (node) => {
 /**
  * Converts every `<HTMLBlock>` shape that survives parsing into the canonical
  * `html-block` MDAST node, reading the body from the tokenizer's template-literal
- * expression. Three shapes occur:
+ * expression. Two shapes occur:
  *
- *   1. JSX element (`mdxJsxFlowElement`/`mdxJsxTextElement`) — multiline/block
- *      context and table cells (after their remarkMdx re-parse).
- *   2. Raw `html` blob (`splitRawHtmlBlocks`) — single-line top-level, or nested
- *      in raw HTML like an inline `<div>`.
- *   3. Inline-in-paragraph — split into `html` + expression + `html` siblings.
+ *   1. JSX element (`mdxJsxFlowElement`/`mdxJsxTextElement`) — table cells, after
+ *      their remarkMdx re-parse (that re-parse runs without the htmlBlockComponent
+ *      tokenizer, so `<HTMLBlock>` arrives as JSX rather than an opaque `html` node).
+ *   2. Raw `html` blob (`splitRawHtmlBlocks`) — the htmlBlockComponent tokenizer's
+ *      opaque output (top-level and inline), or an `<HTMLBlock>` embedded in a
+ *      larger raw-HTML node like an inline `<div>` that the tokenizer never saw.
  *
  * Runs *after* `mdxishTables` so table cells are re-parsed first;
  * `mdxishTables` recognizes the still-JSX `<HTMLBlock>` element when deciding to
@@ -124363,36 +124778,6 @@ const mdxishHtmlBlocks = () => tree => {
         if (replacement)
             parent.children.splice(index, 1, ...replacement);
     });
-    // Shape 3: inline within a paragraph — `<HTMLBlock>` open/close arrive as
-    // separate `html` siblings with the template-literal expression between them.
-    lib_visit(tree, 'paragraph', (paragraph) => {
-        // An html-block is block content, so it isn't a valid PhrasingContent child;
-        // widen to RootContent (which HTMLBlock belongs to) for the in-place splice.
-        const children = paragraph.children;
-        for (let i = 0; i < children.length; i += 1) {
-            const open = children[i];
-            const openMatch = open.type === 'html' ? open.value.match(HTML_BLOCK_OPEN_RE) : null;
-            if (!openMatch)
-                continue; // eslint-disable-line no-continue
-            const closeIdx = children.findIndex((child, j) => j > i && child.type === 'html' && child.value === '</HTMLBlock>');
-            if (closeIdx === -1)
-                continue; // eslint-disable-line no-continue
-            const body = children
-                .slice(i + 1, closeIdx)
-                .map(child => {
-                if (child.type === 'mdxTextExpression' || child.type === 'mdxFlowExpression') {
-                    return extractTemplateLiteral(child.value);
-                }
-                // Preserve raw text from any other phrasing sibling (e.g. stray
-                // whitespace or content the tokenizer didn't claim) so it isn't
-                // silently dropped from the html payload.
-                return 'value' in child && typeof child.value === 'string' ? child.value : '';
-            })
-                .join('');
-            const openingTagIndent = (open.position?.start.column ?? 1) - 1;
-            children.splice(i, closeIdx - i + 1, htmlBlockFromRaw(openMatch[1], body, open.position, openingTagIndent));
-        }
-    });
 };
 /* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
 
@@ -125092,6 +125477,29 @@ const mdxishMermaidTransformer = () => (tree) => {
 };
 /* harmony default export */ const mdxish_mermaid = (mdxishMermaidTransformer);
 
+;// ./processor/transform/mdxish/normalize-closing-tag-whitespace.ts
+
+
+// Spaces/tabs only — newlines would let prose `<` / `>` across lines look like one tag.
+const SPACED_CLOSING_TAG_RE = /<\/[ \t]*([a-zA-Z][a-zA-Z0-9-]*)[ \t]*>/g;
+/**
+ * Canonicalize spaced closing tags (`</ td >` → `</td>`) for known HTML names.
+ *
+ * In HTML, `</` + whitespace is a bogus comment, so `</ table >` never closes the
+ * table (jsxTable misses it → empty table + pre; CX-3706). Only standard HTML tags;
+ * custom components, prose (`a </ b`), and code blocks are left alone.
+ *
+ * @example
+ * normalizeClosingTagWhitespace('</ td >')   // '</td>'
+ * normalizeClosingTagWhitespace('</table >') // '</table>'
+ * normalizeClosingTagWhitespace('a </ b >')  // unchanged
+ */
+function normalizeClosingTagWhitespace(content) {
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const result = protectedContent.replace(SPACED_CLOSING_TAG_RE, (match, tagName) => STANDARD_HTML_TAGS.has(tagName.toLowerCase()) ? `</${tagName}>` : match);
+    return restoreCodeBlocks(result, protectedCode);
+}
+
 ;// ./processor/transform/mdxish/normalize-compact-headings.ts
 
 /**
@@ -125703,25 +126111,25 @@ const variablesTextTransformer = () => tree => {
 };
 /* harmony default export */ const variables_text = (variablesTextTransformer);
 
-;// ./lib/mdast-util/jsx-table/index.ts
-const jsx_table_contextMap = new WeakMap();
-function findJsxTableToken() {
+;// ./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 === 'jsxTable')
+        if (events[i][0].type === 'htmlBlockComponent')
             return events[i][0];
     }
     return undefined;
 }
-function enterJsxTable(token) {
-    jsx_table_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
+function enterHtmlBlockComponent(token) {
+    html_block_component_contextMap.set(token, { chunks: [], lastEndLine: token.start.line });
     this.enter({ type: 'html', value: '' }, token);
 }
-function exitJsxTableData(token) {
-    const tableToken = findJsxTableToken.call(this);
-    if (!tableToken)
+function exitHtmlBlockComponentData(token) {
+    const componentToken = findHtmlBlockComponentToken.call(this);
+    if (!componentToken)
         return;
-    const ctx = jsx_table_contextMap.get(tableToken);
+    const ctx = html_block_component_contextMap.get(componentToken);
     if (ctx) {
         const gap = token.start.line - ctx.lastEndLine;
         if (ctx.chunks.length > 0 && gap > 0) {
@@ -125731,27 +126139,304 @@ function exitJsxTableData(token) {
         ctx.lastEndLine = token.end.line;
     }
 }
-function exitJsxTable(token) {
-    const ctx = jsx_table_contextMap.get(token);
+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('');
-        jsx_table_contextMap.delete(token);
+        html_block_component_contextMap.delete(token);
     }
     this.exit(token);
 }
-function jsx_table_jsxTableFromMarkdown() {
+function html_block_component_htmlBlockComponentFromMarkdown() {
     return {
         enter: {
-            jsxTable: enterJsxTable,
+            htmlBlockComponent: enterHtmlBlockComponent,
         },
         exit: {
-            jsxTableData: exitJsxTableData,
-            jsxTable: exitJsxTable,
+            htmlBlockComponentData: exitHtmlBlockComponentData,
+            htmlBlockComponent: exitHtmlBlockComponent,
         },
     };
 }
 
+;// ./lib/micromark/html-block-component/syntax.ts
+
+
+const TAG_SUFFIX = [
+    codes.uppercaseT,
+    codes.uppercaseM,
+    codes.uppercaseL,
+    codes.uppercaseB,
+    codes.lowercaseL,
+    codes.lowercaseO,
+    codes.lowercaseC,
+    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.uppercaseH) {
+                    effects.consume(code);
+                    return matchChars(TAG_SUFFIX, onMatch, onFail);
+                }
+                return onFail(code);
+            };
+            return next;
+        }
+        return start;
+        function start(code) {
+            if (code !== codes.lessThan)
+                return nok(code);
+            effects.enter('htmlBlockComponent');
+            effects.enter('htmlBlockComponentData');
+            effects.consume(code);
+            return matchTagName(afterTagName, nok);
+        }
+        function afterTagName(code) {
+            if (code === codes.greaterThan) {
+                effects.consume(code);
+                return body;
+            }
+            if (code === codes.space || code === codes.horizontalTab) {
+                effects.consume(code);
+                return inAttributes;
+            }
+            if (mode === 'flow' && markdownLineEnding(code)) {
+                effects.exit('htmlBlockComponentData');
+                return attributeContinuationStart(code);
+            }
+            if (code === codes.slash) {
+                effects.consume(code);
+                return selfClose;
+            }
+            return nok(code);
+        }
+        function inAttributes(code) {
+            if (code === 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.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.lessThan) {
+                effects.consume(code);
+                return closeSlash;
+            }
+            effects.consume(code);
+            return body;
+        }
+        function closeSlash(code) {
+            if (code === codes.slash) {
+                effects.consume(code);
+                return matchTagName(closeGt, body);
+            }
+            return matchTagName(openAfterTagName, body)(code);
+        }
+        function openAfterTagName(code) {
+            if (code === codes.greaterThan || code === codes.space || code === codes.horizontalTab) {
+                depth += 1;
+                effects.consume(code);
+                return body;
+            }
+            return body(code);
+        }
+        function closeGt(code) {
+            if (code === 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.space || code === 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/micromark/jsx-comment/syntax.ts
 
 
@@ -125773,7 +126458,7 @@ function jsx_table_jsxTableFromMarkdown() {
 function tokenizeJsxComment(effects, ok, nok) {
     return start;
     function start(code) {
-        if (code !== codes_codes.leftCurlyBrace)
+        if (code !== codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxFlowExpression');
         effects.enter('mdxFlowExpressionMarker');
@@ -125782,7 +126467,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectSlash;
     }
     function expectSlash(code) {
-        if (code !== codes_codes.slash) {
+        if (code !== codes.slash) {
             effects.exit('mdxFlowExpression');
             return nok(code);
         }
@@ -125791,7 +126476,7 @@ function tokenizeJsxComment(effects, ok, nok) {
         return expectStar;
     }
     function expectStar(code) {
-        if (code !== codes_codes.asterisk) {
+        if (code !== codes.asterisk) {
             effects.exit('mdxFlowExpressionChunk');
             effects.exit('mdxFlowExpression');
             return nok(code);
@@ -125818,7 +126503,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes_codes.asterisk) {
+        if (code === codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125830,11 +126515,11 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes_codes.slash) {
+        if (code === codes.slash) {
             effects.consume(code);
             return expectClosingBrace;
         }
-        if (code === codes_codes.asterisk) {
+        if (code === codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125846,7 +126531,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpressionChunk');
             return before(code);
         }
-        if (code === codes_codes.rightCurlyBrace) {
+        if (code === codes.rightCurlyBrace) {
             effects.exit('mdxFlowExpressionChunk');
             effects.enter('mdxFlowExpressionMarker');
             effects.consume(code);
@@ -125854,7 +126539,7 @@ function tokenizeJsxComment(effects, ok, nok) {
             effects.exit('mdxFlowExpression');
             return ok;
         }
-        if (code === codes_codes.asterisk) {
+        if (code === codes.asterisk) {
             effects.consume(code);
             return maybeClosed;
         }
@@ -125865,7 +126550,7 @@ function tokenizeJsxComment(effects, ok, nok) {
 function jsxComment() {
     return {
         flow: {
-            [codes_codes.leftCurlyBrace]: {
+            [codes.leftCurlyBrace]: {
                 name: 'jsxComment',
                 concrete: true,
                 tokenize: tokenizeJsxComment,
@@ -125874,243 +126559,6 @@ function jsxComment() {
     };
 }
 
-;// ./lib/micromark/jsx-table/syntax.ts
-
-
-const jsx_table_syntax_nonLazyContinuationStart = {
-    tokenize: jsx_table_syntax_tokenizeNonLazyContinuationStart,
-    partial: true,
-};
-function resolveToJsxTable(events) {
-    let index = events.length;
-    while (index > 0) {
-        index -= 1;
-        if (events[index][0] === 'enter' && events[index][1].type === 'jsxTable') {
-            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 jsxTableConstruct = {
-    name: 'jsxTable',
-    tokenize: tokenizeJsxTable,
-    resolveTo: resolveToJsxTable,
-    concrete: true,
-};
-function tokenizeJsxTable(effects, ok, nok) {
-    let codeSpanOpenSize = 0;
-    let codeSpanCloseSize = 0;
-    let depth = 1;
-    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)
-            return onMatch;
-        return ((code) => {
-            if (code === chars[0]) {
-                effects.consume(code);
-                return matchChars(chars.slice(1), onMatch, onFail);
-            }
-            return onFail(code);
-        });
-    }
-    return start;
-    function start(code) {
-        if (code !== codes_codes.lessThan)
-            return nok(code);
-        effects.enter('jsxTable');
-        effects.enter('jsxTableData');
-        effects.consume(code);
-        return afterLessThan;
-    }
-    function afterLessThan(code) {
-        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_codes.greaterThan || code === codes_codes.slash || code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.consume(code);
-            return body;
-        }
-        return nok(code);
-    }
-    function body(code) {
-        // Reject unclosed <Table> so it falls back to normal HTML block parsing
-        // instead of swallowing all subsequent content to EOF
-        if (code === null) {
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            effects.exit('jsxTableData');
-            return continuationStart(code);
-        }
-        if (code === codes_codes.backslash) {
-            effects.consume(code);
-            return escapedChar;
-        }
-        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_codes.graveAccent) {
-            codeSpanOpenSize = 0;
-            return countOpenTicks(code);
-        }
-        effects.consume(code);
-        return body;
-    }
-    function countOpenTicks(code) {
-        if (code === codes_codes.graveAccent) {
-            codeSpanOpenSize += 1;
-            effects.consume(code);
-            return countOpenTicks;
-        }
-        return inCodeSpan(code);
-    }
-    function inCodeSpan(code) {
-        if (code === null || markdownLineEnding(code))
-            return body(code);
-        if (code === codes_codes.graveAccent) {
-            codeSpanCloseSize = 0;
-            return countCloseTicks(code);
-        }
-        effects.consume(code);
-        return inCodeSpan;
-    }
-    function countCloseTicks(code) {
-        if (code === codes_codes.graveAccent) {
-            codeSpanCloseSize += 1;
-            effects.consume(code);
-            return countCloseTicks;
-        }
-        return codeSpanCloseSize === codeSpanOpenSize ? body(code) : inCodeSpan(code);
-    }
-    function escapedChar(code) {
-        if (code === null || markdownLineEnding(code)) {
-            return body(code);
-        }
-        effects.consume(code);
-        return body;
-    }
-    function closeSlash(code) {
-        if (code === codes_codes.slash) {
-            effects.consume(code);
-            return closeTagFirstChar;
-        }
-        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_codes.uppercaseT || code === codes_codes.lowercaseT) {
-            effects.consume(code);
-            return matchChars(ABLE_SUFFIX, closeGt, body);
-        }
-        return body(code);
-    }
-    function openAfterTagName(code) {
-        if (code === codes_codes.greaterThan || code === codes_codes.slash || 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 afterClose;
-            }
-            return body;
-        }
-        return body(code);
-    }
-    function afterClose(code) {
-        if (code === null || markdownLineEnding(code)) {
-            effects.exit('jsxTableData');
-            effects.exit('jsxTable');
-            return ok(code);
-        }
-        effects.consume(code);
-        return afterClose;
-    }
-    // Line ending handling — follows the htmlFlow pattern
-    function continuationStart(code) {
-        return effects.check(jsx_table_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('jsxTableData');
-        return body(code);
-    }
-    function continuationAfter(code) {
-        // At EOF without </Table>, reject so content isn't swallowed
-        if (code === null) {
-            return nok(code);
-        }
-        effects.exit('jsxTable');
-        return ok(code);
-    }
-}
-function jsx_table_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);
-    }
-}
-/**
- * Micromark extension that tokenizes `<Table>...</Table>` and `<table>...</table>`
- * as a single flow block.
- *
- * Prevents CommonMark HTML block type 6 from fragmenting table blocks at blank lines.
- */
-function syntax_jsxTable() {
-    return {
-        flow: {
-            [codes_codes.lessThan]: [jsxTableConstruct],
-        },
-    };
-}
-
-;// ./lib/micromark/jsx-table/index.ts
-
-
 ;// ./lib/micromark/mdx-expression-lenient/syntax.ts
 
 
@@ -126130,7 +126578,7 @@ function tokenizeTextExpression(effects, ok, nok) {
     let depth = 0;
     return start;
     function start(code) {
-        if (code !== codes_codes.leftCurlyBrace)
+        if (code !== codes.leftCurlyBrace)
             return nok(code);
         effects.enter('mdxTextExpression');
         effects.enter('mdxTextExpressionMarker');
@@ -126139,7 +126587,7 @@ function tokenizeTextExpression(effects, ok, nok) {
         return before;
     }
     function before(code) {
-        if (code === codes_codes.eof) {
+        if (code === codes.eof) {
             effects.exit('mdxTextExpression');
             return nok(code);
         }
@@ -126149,24 +126597,24 @@ function tokenizeTextExpression(effects, ok, nok) {
             effects.exit('lineEnding');
             return before;
         }
-        if (code === codes_codes.rightCurlyBrace && depth === 0) {
+        if (code === codes.rightCurlyBrace && depth === 0) {
             return close(code);
         }
         effects.enter('mdxTextExpressionChunk');
         return inside(code);
     }
     function inside(code) {
-        if (code === codes_codes.eof || markdownLineEnding(code)) {
+        if (code === codes.eof || markdownLineEnding(code)) {
             effects.exit('mdxTextExpressionChunk');
             return before(code);
         }
-        if (code === codes_codes.rightCurlyBrace && depth === 0) {
+        if (code === codes.rightCurlyBrace && depth === 0) {
             effects.exit('mdxTextExpressionChunk');
             return close(code);
         }
-        if (code === codes_codes.leftCurlyBrace)
+        if (code === codes.leftCurlyBrace)
             depth += 1;
-        else if (code === codes_codes.rightCurlyBrace)
+        else if (code === codes.rightCurlyBrace)
             depth -= 1;
         effects.consume(code);
         return inside;
@@ -126182,7 +126630,7 @@ function tokenizeTextExpression(effects, ok, nok) {
 function mdxExpressionLenient() {
     return {
         text: {
-            [codes_codes.leftCurlyBrace]: {
+            [codes.leftCurlyBrace]: {
                 name: 'mdxTextExpression',
                 tokenize: tokenizeTextExpression,
             },
@@ -126286,6 +126734,9 @@ function loadComponents() {
 
 
 
+
+
+
 
 
 
@@ -126300,15 +126751,19 @@ const defaultTransformers = [
  * CommonMark/remark limitations and reach parity with legacy (rdmd) rendering.
  *
  * Runs a series of string-level transformations before micromark/remark parsing:
- * 1. Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
- * 2. Terminate HTML flow blocks so subsequent content isn't swallowed
- * 3. Close invalid "self-closing" HTML tags (e.g., `<i />` → `<i></i>`)
- * 4. Normalize compact ATX headings (e.g., `#Heading` → `# Heading`)
- * 5. Replace snake_case component names with parser-safe placeholders
+ * 1. Canonicalize closing tags with stray whitespace (e.g., `</ td >` → `</td>`)
+ * 2. Normalize malformed table separator syntax (e.g., `|: ---` → `| :---`)
+ * 3. Terminate HTML flow blocks so subsequent content isn't swallowed
+ * 4. Close invalid "self-closing" HTML tags (e.g., `<i />` → `<i></i>`)
+ * 5. Normalize compact ATX headings (e.g., `#Heading` → `# Heading`)
+ * 6. Replace snake_case component names with parser-safe placeholders
  */
 function preprocessContent(content, opts) {
     const { knownComponents } = opts;
-    let result = normalizeTableSeparator(content);
+    // Runs first so `jsxTable` sees a literal `</table>` (and the HTML-line
+    // classification in `terminateHtmlFlowBlocks` is accurate)
+    let result = normalizeClosingTagWhitespace(content);
+    result = normalizeTableSeparator(result);
     result = terminateHtmlFlowBlocks(result);
     result = closeSelfClosingHtmlTags(result);
     result = normalizeCompactHeadings(result);
@@ -126337,6 +126792,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         syntax_gemoji(),
         legacyVariable(),
         looseHtmlEntity(),
+        syntax_htmlBlockComponent(),
     ];
     const fromMarkdownExts = [
         jsx_table_jsxTableFromMarkdown(),
@@ -126346,6 +126802,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         legacyVariableFromMarkdown(),
         emptyTaskListItemFromMarkdown(),
         looseHtmlEntityFromMarkdown(),
+        html_block_component_htmlBlockComponentFromMarkdown(),
     ];
     if (!safeMode) {
         // Insert mdx expression (text-only, no flow) after gemoji at index 3
@@ -126359,6 +126816,10 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         // JSX comment tokenizer must come before magicBlock so it claims `{/* ... */}` first
         micromarkExts.unshift(jsxComment());
     }
+    // Claim `<HTMLBlock>` as one opaque token so broad tokenizers can't fragment its body
+    // We put this last as micromark tries the last-registered extension first, so push (not unshift) to win the `<` race.
+    // micromarkExts.push(htmlBlockComponent());
+    // fromMarkdownExts.push(htmlBlockComponentFromMarkdown());
     const processor = lib_unified()
         .data('micromarkExtensions', micromarkExts)
         .data('fromMarkdownExtensions', fromMarkdownExts)
@@ -126902,332 +127363,6 @@ 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