@readme/markdown 14.11.4 → 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);
@@ -117497,6 +117516,19 @@ const compile_list_item_listItem = (node, parent, state, info) => {
 const plain_plain = (node) => node.value;
 /* harmony default export */ const compile_plain = (plain_plain);
 
+;// ./processor/compile/text.ts
+
+// A `_` flanked by word characters can never open or close emphasis under
+// CommonMark's flanking rules, so the escape mdast-util-to-markdown adds to
+// intraword underscores is unnecessary and only produces noisy `\_` diffs.
+// Uses Unicode letter/number classes so non-ASCII words (e.g. `é_pay`) match.
+const INTRAWORD_UNDERSCORE_ESCAPE = /(?<=[\p{L}\p{N}_])\\_(?=[\p{L}\p{N}_]|\\_)/gu;
+const compile_text_text = (node, parent, state, info) => {
+    const serialized = handle.text(node, parent, state, info);
+    return serialized.replace(INTRAWORD_UNDERSCORE_ESCAPE, '_');
+};
+/* harmony default export */ const compile_text = (compile_text_text);
+
 ;// ./processor/compile/index.ts
 
 
@@ -117509,11 +117541,11 @@ const plain_plain = (node) => node.value;
 
 
 
+
 function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
     const handlers = {
-        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
         [enums_NodeTypes.callout]: compile_callout,
         [enums_NodeTypes.codeTabs]: compile_code_tabs,
         [enums_NodeTypes.embedBlock]: compile_embed,
@@ -117521,15 +117553,18 @@ function compilers(mdxish = false) {
         [enums_NodeTypes.glossary]: compile_compatibility,
         [enums_NodeTypes.htmlBlock]: html_block,
         [enums_NodeTypes.reusableContent]: compile_compatibility,
-        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
         embed: compile_compatibility,
         escape: compile_compatibility,
         figure: compile_compatibility,
         html: compile_compatibility,
         i: compile_compatibility,
-        ...(mdxish && { listItem: list_item }),
         plain: compile_plain,
         yaml: compile_compatibility,
+        // needed only for mdxish
+        ...(mdxish && { [enums_NodeTypes.anchor]: compile_anchor }),
+        ...(mdxish && { listItem: list_item }),
+        ...(mdxish && { text: compile_text }),
+        ...(mdxish && { [enums_NodeTypes.variable]: compile_variable }),
     };
     toMarkdownExtensions.push({ extensions: [{ handlers }] });
 }
@@ -118388,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();
 /**
@@ -118577,867 +118661,16 @@ function mdx_component_mdxComponentFromMarkdown() {
     };
 }
 
-;// ./lib/micromark/magic-block/syntax.ts
-
-
-/**
- * Known magic block types that the tokenizer will recognize.
- * Unknown types will not be tokenized as magic blocks.
- */
-const KNOWN_BLOCK_TYPES = new Set([
-    'code',
-    'api-header',
-    'image',
-    'callout',
-    'parameters',
-    'table',
-    'embed',
-    'html',
-    'recipe',
-    'tutorial-tile',
-]);
-/**
- * Check if a character is valid for a magic block type identifier.
- * Types can contain alphanumeric characters and hyphens (e.g., "api-header", "tutorial-tile")
- */
-function isTypeChar(code) {
-    return asciiAlphanumeric(code) || code === codes_codes.dash;
-}
-/**
- * Creates the opening marker state machine: [block:
- * Returns the first state function to start parsing.
- */
-function createOpeningMarkerParser(effects, nok, onComplete) {
-    const expectB = (code) => {
-        if (code !== codes_codes.lowercaseB)
-            return nok(code);
-        effects.consume(code);
-        return expectL;
-    };
-    const expectL = (code) => {
-        if (code !== codes_codes.lowercaseL)
-            return nok(code);
-        effects.consume(code);
-        return expectO;
-    };
-    const expectO = (code) => {
-        if (code !== codes_codes.lowercaseO)
-            return nok(code);
-        effects.consume(code);
-        return expectC;
-    };
-    const expectC = (code) => {
-        if (code !== codes_codes.lowercaseC)
-            return nok(code);
-        effects.consume(code);
-        return expectK;
-    };
-    const expectK = (code) => {
-        if (code !== codes_codes.lowercaseK)
-            return nok(code);
-        effects.consume(code);
-        return expectColon;
-    };
-    const expectColon = (code) => {
-        if (code !== codes_codes.colon)
-            return nok(code);
-        effects.consume(code);
-        effects.exit('magicBlockMarkerStart');
-        effects.enter('magicBlockType');
-        return onComplete;
-    };
-    return expectB;
-}
-/**
- * Creates the type capture state machine.
- * Captures type characters until ] and validates against known types.
- */
-function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
-    const captureTypeFirst = (code) => {
-        // Reject empty type name [block:]
-        if (code === codes_codes.rightSquareBracket) {
-            return nok(code);
-        }
-        if (isTypeChar(code)) {
-            blockTypeRef.value += String.fromCharCode(code);
-            effects.consume(code);
-            return captureType;
-        }
-        return nok(code);
-    };
-    const captureType = (code) => {
-        if (code === codes_codes.rightSquareBracket) {
-            if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
-                return nok(code);
-            }
-            effects.exit('magicBlockType');
-            effects.enter('magicBlockMarkerTypeEnd');
-            effects.consume(code);
-            effects.exit('magicBlockMarkerTypeEnd');
-            return onComplete;
-        }
-        if (isTypeChar(code)) {
-            blockTypeRef.value += String.fromCharCode(code);
-            effects.consume(code);
-            return captureType;
-        }
-        return nok(code);
-    };
-    return { first: captureTypeFirst, remaining: captureType };
-}
-/**
- * Creates the closing marker state machine: /block]
- * Handles partial matches by calling onMismatch to fall back to data capture.
- */
-function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
-    const handleMismatch = (code) => {
-        if (jsonState && code === codes_codes.quotationMark) {
-            jsonState.inString = true;
-        }
-        return onMismatch(code);
-    };
-    const expectSlash = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.slash)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectB;
-    };
-    const expectB = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.lowercaseB)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectL;
-    };
-    const expectL = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.lowercaseL)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectO;
-    };
-    const expectO = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.lowercaseO)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectC;
-    };
-    const expectC = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.lowercaseC)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectK;
-    };
-    const expectK = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.lowercaseK)
-            return handleMismatch(code);
-        effects.consume(code);
-        return expectBracket;
-    };
-    const expectBracket = (code) => {
-        if (code === null)
-            return onEof(code);
-        if (code !== codes_codes.rightSquareBracket)
-            return handleMismatch(code);
-        effects.consume(code);
-        return onSuccess;
-    };
-    return { expectSlash };
-}
-/**
- * Partial construct for checking non-lazy continuation.
- * This is used by the flow tokenizer to check if we can continue
- * parsing on the next line.
- */
-const syntax_nonLazyContinuation = {
-    partial: true,
-    tokenize: syntax_tokenizeNonLazyContinuation,
-};
-/**
- * Tokenizer for non-lazy continuation checking.
- * Returns ok if the next line is non-lazy (can continue), nok if lazy.
- */
-function syntax_tokenizeNonLazyContinuation(effects, ok, nok) {
-    const lineStart = (code) => {
-        // `this` here refers to the micromark parser
-        // since we are just passing functions as references and not actually calling them
-        // micromarks's internal parser will call this automatically with appropriate arguments
-        return this.parser.lazy[this.now().line] ? nok(code) : ok(code);
-    };
-    const start = (code) => {
-        if (code === null) {
-            return nok(code);
-        }
-        if (!markdownLineEnding(code)) {
-            return nok(code);
-        }
-        effects.enter('magicBlockLineEnding');
-        effects.consume(code);
-        effects.exit('magicBlockLineEnding');
-        return lineStart;
-    };
-    return start;
-}
+;// ./node_modules/micromark-util-symbol/lib/types.js
 /**
- * Create a micromark extension for magic block syntax.
- *
- * This extension handles both single-line and multiline magic blocks:
- * - Flow construct (concrete): Handles block-level multiline magic blocks at document level
- * - Text construct: Handles inline magic blocks in lists, paragraphs, etc.
+ * This module is compiled away!
  *
- * The flow construct is marked as "concrete" which prevents it from being
- * interrupted by container markers (like `>` for blockquotes or `-` for lists).
- */
-function syntax_magicBlock() {
-    return {
-        // Flow construct - handles block-level magic blocks at document root
-        // Marked as concrete to prevent interruption by containers
-        flow: {
-            [codes_codes.leftSquareBracket]: {
-                name: 'magicBlock',
-                concrete: true,
-                tokenize: tokenizeMagicBlockFlow,
-            },
-        },
-        // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
-        text: {
-            [codes_codes.leftSquareBracket]: {
-                name: 'magicBlock',
-                tokenize: tokenizeMagicBlockText,
-            },
-        },
-    };
-}
-/**
- * Flow tokenizer for block-level magic blocks (multiline).
- * Uses the continuation checking pattern from code fences.
- */
-function tokenizeMagicBlockFlow(effects, ok, nok) {
-    // State for tracking JSON content
-    const jsonState = { escapeNext: false, inString: false };
-    const blockTypeRef = { value: '' };
-    let seenOpenBrace = false;
-    // Create shared parsers for opening marker and type capture
-    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
-    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
-    return start;
-    function start(code) {
-        if (code !== codes_codes.leftSquareBracket)
-            return nok(code);
-        effects.enter('magicBlock');
-        effects.enter('magicBlockMarkerStart');
-        effects.consume(code);
-        return openingMarkerParser;
-    }
-    /**
-     * State before data content - handles line endings or starts data capture.
-     */
-    function beforeData(code) {
-        // EOF - magic block must be closed
-        if (code === null) {
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        // Line ending before any data - check continuation
-        if (markdownLineEnding(code)) {
-            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
-        }
-        // 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) {
-            effects.enter('magicBlockMarkerEnd');
-            effects.consume(code);
-            return expectSlashFromContinuation;
-        }
-        // If we've already seen the opening brace, just continue capturing data
-        if (seenOpenBrace) {
-            effects.enter('magicBlockData');
-            return captureData(code);
-        }
-        // 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) {
-            return beforeDataWhitespace(code);
-        }
-        // Data must start with '{' for valid JSON
-        if (code !== codes_codes.leftCurlyBrace) {
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        // We have '{' - enter data token and start capturing
-        seenOpenBrace = true;
-        effects.enter('magicBlockData');
-        return captureData(code);
-    }
-    /**
-     * Consume whitespace before the data without creating a token.
-     * Uses a temporary token to satisfy micromark's requirement.
-     */
-    function beforeDataWhitespace(code) {
-        if (code === null) {
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
-        }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            // We need to consume this but can't without a token - use magicBlockData
-            // and track that we haven't seen '{' yet
-            effects.enter('magicBlockData');
-            effects.consume(code);
-            return beforeDataWhitespaceContinue;
-        }
-        if (code === codes_codes.leftCurlyBrace) {
-            seenOpenBrace = true;
-            effects.enter('magicBlockData');
-            return captureData(code);
-        }
-        effects.exit('magicBlock');
-        return nok(code);
-    }
-    /**
-     * Continue consuming whitespace or validate the opening brace.
-     */
-    function beforeDataWhitespaceContinue(code) {
-        if (code === null) {
-            effects.exit('magicBlockData');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockData');
-            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
-        }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.consume(code);
-            return beforeDataWhitespaceContinue;
-        }
-        if (code === codes_codes.leftCurlyBrace) {
-            seenOpenBrace = true;
-            return captureData(code);
-        }
-        effects.exit('magicBlockData');
-        effects.exit('magicBlock');
-        return nok(code);
-    }
-    /**
-     * Continuation OK before we've entered data token.
-     */
-    function continuationOkBeforeData(code) {
-        effects.enter('magicBlockLineEnding');
-        effects.consume(code);
-        effects.exit('magicBlockLineEnding');
-        return beforeData; // Stay in beforeData state - don't enter magicBlockData yet
-    }
-    function captureData(code) {
-        // EOF - magic block must be closed
-        if (code === null) {
-            effects.exit('magicBlockData');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        // At line ending, check if we can continue on the next line
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockData');
-            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
-        }
-        if (jsonState.escapeNext) {
-            jsonState.escapeNext = false;
-            effects.consume(code);
-            return captureData;
-        }
-        if (jsonState.inString) {
-            if (code === codes_codes.backslash) {
-                jsonState.escapeNext = true;
-                effects.consume(code);
-                return captureData;
-            }
-            if (code === codes_codes.quotationMark) {
-                jsonState.inString = false;
-            }
-            effects.consume(code);
-            return captureData;
-        }
-        if (code === codes_codes.quotationMark) {
-            jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        if (code === codes_codes.leftSquareBracket) {
-            effects.exit('magicBlockData');
-            effects.enter('magicBlockMarkerEnd');
-            effects.consume(code);
-            return expectSlash;
-        }
-        effects.consume(code);
-        return captureData;
-    }
-    /**
-     * Called when non-lazy continuation check passes - we can continue parsing.
-     */
-    function continuationOk(code) {
-        // Consume the line ending
-        effects.enter('magicBlockLineEnding');
-        effects.consume(code);
-        effects.exit('magicBlockLineEnding');
-        return continuationStart;
-    }
-    /**
-     * Start of continuation line - check for more line endings, closing marker, or start capturing data.
-     */
-    function continuationStart(code) {
-        // Handle consecutive line endings
-        if (code === null) {
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
-        }
-        // Check if this is the start of the closing marker [/block]
-        // If so, handle it directly without entering magicBlockData
-        if (code === codes_codes.leftSquareBracket) {
-            effects.enter('magicBlockMarkerEnd');
-            effects.consume(code);
-            return expectSlashFromContinuation;
-        }
-        effects.enter('magicBlockData');
-        return captureData(code);
-    }
-    /**
-     * Check for closing marker slash when coming from continuation.
-     * If not a closing marker, create an empty data token and continue.
-     */
-    function expectSlashFromContinuation(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockMarkerEnd');
-            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
-        }
-        if (code === codes_codes.slash) {
-            effects.consume(code);
-            return expectClosingB;
-        }
-        // Not a closing marker - this is data content
-        // Exit marker and enter data
-        effects.exit('magicBlockMarkerEnd');
-        effects.enter('magicBlockData');
-        // 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)
-            jsonState.inString = true;
-        effects.consume(code);
-        return captureData;
-    }
-    function expectSlash(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        // At line ending during marker parsing
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockMarkerEnd');
-            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
-        }
-        if (code !== codes_codes.slash) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingB;
-    }
-    function expectClosingB(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.lowercaseB) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingL;
-    }
-    function expectClosingL(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.lowercaseL) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingO;
-    }
-    function expectClosingO(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.lowercaseO) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingC;
-    }
-    function expectClosingC(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.lowercaseC) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingK;
-    }
-    function expectClosingK(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.lowercaseK) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        return expectClosingBracket;
-    }
-    function expectClosingBracket(code) {
-        if (code === null) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.exit('magicBlock');
-            return nok(code);
-        }
-        if (code !== codes_codes.rightSquareBracket) {
-            effects.exit('magicBlockMarkerEnd');
-            effects.enter('magicBlockData');
-            if (code === codes_codes.quotationMark)
-                jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        effects.consume(code);
-        effects.exit('magicBlockMarkerEnd');
-        // Check for trailing whitespace on the same line
-        return consumeTrailing;
-    }
-    /**
-     * Consume trailing whitespace (spaces/tabs) on the same line after [/block].
-     * For concrete flow constructs, we must end at eol/eof or fail.
-     * Trailing whitespace is consumed; other content causes nok (text tokenizer handles it).
-     */
-    function consumeTrailing(code) {
-        // End of file - done
-        if (code === null) {
-            effects.exit('magicBlock');
-            return ok(code);
-        }
-        // Line ending - done
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlock');
-            return ok(code);
-        }
-        // Space or tab - consume as trailing whitespace
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.enter('magicBlockTrailing');
-            effects.consume(code);
-            return consumeTrailingContinue;
-        }
-        // Any other character - fail flow tokenizer, let text tokenizer handle it
-        effects.exit('magicBlock');
-        return nok(code);
-    }
-    /**
-     * Continue consuming trailing whitespace.
-     */
-    function consumeTrailingContinue(code) {
-        // End of file - done
-        if (code === null) {
-            effects.exit('magicBlockTrailing');
-            effects.exit('magicBlock');
-            return ok(code);
-        }
-        // Line ending - done
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockTrailing');
-            effects.exit('magicBlock');
-            return ok(code);
-        }
-        // More space or tab - keep consuming
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.consume(code);
-            return consumeTrailingContinue;
-        }
-        // Non-whitespace after whitespace - fail flow tokenizer
-        effects.exit('magicBlockTrailing');
-        effects.exit('magicBlock');
-        return nok(code);
-    }
-    /**
-     * Called when we can't continue (lazy line or EOF) - exit the construct.
-     */
-    function after(code) {
-        effects.exit('magicBlock');
-        return nok(code);
-    }
-}
-/**
- * Text tokenizer for single-line magic blocks only.
- * Used in inline contexts like list items and paragraphs.
- * Multiline blocks are handled by the flow tokenizer.
- */
-function tokenizeMagicBlockText(effects, ok, nok) {
-    // State for tracking JSON content
-    const jsonState = { escapeNext: false, inString: false };
-    const blockTypeRef = { value: '' };
-    let seenOpenBrace = false;
-    // Create shared parsers for opening marker and type capture
-    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
-    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
-    // Success handler for closing marker - exits tokens and returns ok
-    const closingSuccess = (code) => {
-        effects.exit('magicBlockMarkerEnd');
-        effects.exit('magicBlock');
-        return ok(code);
-    };
-    // Mismatch handler - falls back to data capture
-    const closingMismatch = (code) => {
-        effects.exit('magicBlockMarkerEnd');
-        effects.enter('magicBlockData');
-        if (code === codes_codes.quotationMark)
-            jsonState.inString = true;
-        effects.consume(code);
-        return captureData;
-    };
-    // EOF handler
-    const closingEof = (_code) => nok(_code);
-    // Create closing marker parsers
-    const closingFromBeforeData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
-    const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
-    return start;
-    function start(code) {
-        if (code !== codes_codes.leftSquareBracket)
-            return nok(code);
-        effects.enter('magicBlock');
-        effects.enter('magicBlockMarkerStart');
-        effects.consume(code);
-        return openingMarkerParser;
-    }
-    /**
-     * State before data content - handles line endings before entering data token.
-     * Whitespace before '{' is allowed.
-     */
-    function beforeData(code) {
-        // Fail on EOF - magic block must be closed
-        if (code === null) {
-            return nok(code);
-        }
-        // Handle line endings before any data - consume them without entering data token
-        if (markdownLineEnding(code)) {
-            effects.enter('magicBlockLineEnding');
-            effects.consume(code);
-            effects.exit('magicBlockLineEnding');
-            return beforeData;
-        }
-        // Check for closing marker directly (without entering data)
-        if (code === codes_codes.leftSquareBracket) {
-            effects.enter('magicBlockMarkerEnd');
-            effects.consume(code);
-            return closingFromBeforeData.expectSlash;
-        }
-        // If we've already seen the opening brace, just continue capturing data
-        if (seenOpenBrace) {
-            effects.enter('magicBlockData');
-            return captureData(code);
-        }
-        // Skip whitespace (spaces/tabs) before the data
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            return beforeDataWhitespace(code);
-        }
-        // Data must start with '{' for valid JSON
-        if (code !== codes_codes.leftCurlyBrace) {
-            return nok(code);
-        }
-        // We have '{' - enter data token and start capturing
-        seenOpenBrace = true;
-        effects.enter('magicBlockData');
-        return captureData(code);
-    }
-    /**
-     * Consume whitespace before the data.
-     */
-    function beforeDataWhitespace(code) {
-        if (code === null) {
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            effects.enter('magicBlockLineEnding');
-            effects.consume(code);
-            effects.exit('magicBlockLineEnding');
-            return beforeData;
-        }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.enter('magicBlockData');
-            effects.consume(code);
-            return beforeDataWhitespaceContinue;
-        }
-        if (code === codes_codes.leftCurlyBrace) {
-            seenOpenBrace = true;
-            effects.enter('magicBlockData');
-            return captureData(code);
-        }
-        return nok(code);
-    }
-    /**
-     * Continue consuming whitespace or validate the opening brace.
-     */
-    function beforeDataWhitespaceContinue(code) {
-        if (code === null) {
-            effects.exit('magicBlockData');
-            return nok(code);
-        }
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockData');
-            effects.enter('magicBlockLineEnding');
-            effects.consume(code);
-            effects.exit('magicBlockLineEnding');
-            return beforeData;
-        }
-        if (code === codes_codes.space || code === codes_codes.horizontalTab) {
-            effects.consume(code);
-            return beforeDataWhitespaceContinue;
-        }
-        if (code === codes_codes.leftCurlyBrace) {
-            seenOpenBrace = true;
-            return captureData(code);
-        }
-        effects.exit('magicBlockData');
-        return nok(code);
-    }
-    function captureData(code) {
-        // Fail on EOF - magic block must be closed
-        if (code === null) {
-            effects.exit('magicBlockData');
-            return nok(code);
-        }
-        // Handle multiline magic blocks within text/paragraphs
-        // Exit data, consume line ending with proper token, then re-enter data
-        if (markdownLineEnding(code)) {
-            effects.exit('magicBlockData');
-            effects.enter('magicBlockLineEnding');
-            effects.consume(code);
-            effects.exit('magicBlockLineEnding');
-            return beforeData; // Go back to beforeData to handle potential empty lines
-        }
-        if (jsonState.escapeNext) {
-            jsonState.escapeNext = false;
-            effects.consume(code);
-            return captureData;
-        }
-        if (jsonState.inString) {
-            if (code === codes_codes.backslash) {
-                jsonState.escapeNext = true;
-                effects.consume(code);
-                return captureData;
-            }
-            if (code === codes_codes.quotationMark) {
-                jsonState.inString = false;
-            }
-            effects.consume(code);
-            return captureData;
-        }
-        if (code === codes_codes.quotationMark) {
-            jsonState.inString = true;
-            effects.consume(code);
-            return captureData;
-        }
-        if (code === codes_codes.leftSquareBracket) {
-            effects.exit('magicBlockData');
-            effects.enter('magicBlockMarkerEnd');
-            effects.consume(code);
-            return closingFromData.expectSlash;
-        }
-        effects.consume(code);
-        return captureData;
-    }
-}
-/* harmony default export */ const syntax = ((/* unused pure expression or super */ null && (syntax_magicBlock)));
-
-;// ./lib/micromark/magic-block/index.ts
-/**
- * Micromark extension for magic block syntax.
- *
- * Usage:
- * ```ts
- * import { magicBlock } from './lib/micromark/magic-block';
- *
- * const processor = unified()
- *   .data('micromarkExtensions', [magicBlock()])
- * ```
- */
-
-
-;// ./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.
+ * 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`
@@ -119883,36 +119116,18 @@ const types_types = /** @type {const} */ ({
   chunkString: 'chunkString'
 })
 
-;// ./lib/micromark/mdx-component/syntax.ts
-
-
-
+;// ./lib/micromark/jsx-table/syntax.ts
 
 
-// Raw tags (type-1: pre/script/style/textarea) and block tags (type-6: div,
-// section, …) always start a block, so they stay flow even with trailing
-// content. Other lowercase tags (i, span, …) follow the type-7 rule and only
-// stay flow when nothing trails the close tag.
-const htmlFlowTagNames = new Set([...htmlRawNames, ...htmlBlockNames]);
-// Lowercase type-6 block tags claimable in flow even without a `{…}` attribute, so
-// 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,
     partial: true,
 };
-// Lookahead for `plainClaimLineStart`: is this line markup-only, or a paragraph
-// that merely starts with a tag? Run via `effects.check` so it never consumes.
-const markupOnlyContinuation = {
-    tokenize: tokenizeMarkupOnlyContinuation,
-    partial: true,
-};
-function resolveToMdxComponent(events) {
+function resolveToJsxTable(events) {
     let index = events.length;
     while (index > 0) {
         index -= 1;
-        if (events[index][0] === 'enter' && events[index][1].type === 'mdxComponent') {
+        if (events[index][0] === 'enter' && events[index][1].type === 'jsxTable') {
             break;
         }
     }
@@ -119923,123 +119138,1229 @@ function resolveToMdxComponent(events) {
     }
     return events;
 }
-const mdxComponentFlowConstruct = {
-    name: 'mdxComponent',
-    tokenize: createTokenize('flow'),
-    resolveTo: resolveToMdxComponent,
+const jsxTableConstruct = {
+    name: 'jsxTable',
+    tokenize: tokenizeJsxTable,
+    resolveTo: resolveToJsxTable,
     concrete: true,
 };
-const mdxComponentTextConstruct = {
-    name: 'mdxComponentText',
-    tokenize: createTokenize('text'),
-};
-/**
- * Factory for both flow (block) and text (inline) variants.
- *
- * **Flow** — the original behavior: claims PascalCase components (always) and
- * lowercase HTML tags that carry at least one `{…}` attribute expression.
- * Multi-line, concrete, `afterClose` consumes the rest of the line.
- *
- * **Text** — runs inside paragraphs / inline context. Claims lowercase tags and
- * inline PascalCase components (`INLINE_COMPONENT_TAGS` — Anchor, Glossary), both
- * gated on at least one `{…}` brace attribute. All other PascalCase stays
- * flow-only, matching how ReadMe's custom components are authored. Aborts on line
- * endings (inline constructs don't span lines) and exits immediately after
- * `</tag>` so the paragraph's inline parser picks up the trailing text.
- */
-function createTokenize(mode) {
-    const isFlow = mode === 'flow';
-    return function tokenize(effects, ok, nok) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        let tagName = '';
-        let depth = 0;
-        let closingTagName = '';
-        // For lowercase tags we only want to claim the block if it uses JSX
-        // attribute expression syntax (`attr={...}`). Plain HTML should fall
-        // through to CommonMark html-flow. Flow mode claims any PascalCase block
-        // component; text mode claims only inline PascalCase components
-        // (INLINE_COMPONENT_TAGS — Anchor, Glossary), also brace-gated.
-        let isLowercaseTag = false;
-        let sawBraceAttr = false;
-        // A plain lowercase block tag claimed without a `{…}` attribute, gated by
-        // `plainClaimLineStart`: after a blank line it may only continue on a tag line.
-        let isPlainBlockClaim = false;
-        let pendingBlankLine = false;
-        // Code span tracking
-        let codeSpanOpenSize = 0;
-        let codeSpanCloseSize = 0;
-        // Fenced code block tracking
-        let fenceChar = null;
-        let fenceLength = 0;
-        let fenceCloseLength = 0;
-        let atLineStart = false;
-        // True once this construct consumes any line ending; lets `afterClose`
-        // treat only single-line lowercase tags as inline candidates.
-        let sawLineEnding = false;
-        // Bail when the opener line has unmatched tag-like tokens in its body.
-        // `<Foo>_<Bar>.csv` leaves opens > closes; matched shapes like
-        // `<Callout>x <strong>y</strong>` balance to 0. Without this,
-        // `concrete: true` causes orphan openers to eat sibling blockquotes.
-        let onOpenerLine = false;
-        let openerLineHasContent = false;
-        let openerLineOpens = 0;
-        let openerLineCloses = 0;
-        // Attribute parsing state
-        let quoteChar = null;
-        let braceDepth = 0;
-        let inTemplateLit = false; // true when inside a template literal (for line continuation)
-        // Stack of braceDepth values at each ${...} interpolation entry point.
-        // 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 isSameCaseAsTag = (code) => isLowercaseTag
-            ? code >= codes_codes.lowercaseA && code <= codes_codes.lowercaseZ
-            : code >= codes_codes.uppercaseA && code <= codes_codes.uppercaseZ;
-        // Shared brace-expression state machine. The two call sites differ only in where
-        // to continue after a line ending and where to return when braceDepth reaches zero.
-        function createBraceExprStates(continuationStart, afterBraceClose) {
-            function braceExpr(code) {
-                if (code === null)
-                    return nok(code);
-                if (markdownLineEnding(code)) {
-                    if (!isFlow)
-                        return nok(code);
-                    effects.exit('mdxComponentData');
-                    return continuationStart(code);
-                }
-                if (code === codes_codes.quotationMark || code === codes_codes.apostrophe) {
-                    quoteChar = code;
-                    effects.consume(code);
-                    return braceString;
-                }
-                if (code === codes_codes.graveAccent) {
-                    inTemplateLit = true;
-                    effects.consume(code);
-                    return braceTemplateLiteral;
-                }
-                if (code === codes_codes.leftCurlyBrace) {
-                    braceDepth += 1;
-                    effects.consume(code);
-                    return braceExpr;
-                }
-                if (code === codes_codes.rightCurlyBrace) {
-                    braceDepth -= 1;
-                    effects.consume(code);
-                    if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
-                        templateStack.pop();
-                        inTemplateLit = true;
-                        return braceTemplateLiteral;
-                    }
-                    if (braceDepth === 0) {
-                        return afterBraceClose;
-                    }
-                    return braceExpr;
-                }
+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 braceExpr;
+                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
+
+
+/**
+ * Known magic block types that the tokenizer will recognize.
+ * Unknown types will not be tokenized as magic blocks.
+ */
+const KNOWN_BLOCK_TYPES = new Set([
+    'code',
+    'api-header',
+    'image',
+    'callout',
+    'parameters',
+    'table',
+    'embed',
+    'html',
+    'recipe',
+    'tutorial-tile',
+]);
+/**
+ * Check if a character is valid for a magic block type identifier.
+ * Types can contain alphanumeric characters and hyphens (e.g., "api-header", "tutorial-tile")
+ */
+function isTypeChar(code) {
+    return asciiAlphanumeric(code) || code === codes.dash;
+}
+/**
+ * Creates the opening marker state machine: [block:
+ * Returns the first state function to start parsing.
+ */
+function createOpeningMarkerParser(effects, nok, onComplete) {
+    const expectB = (code) => {
+        if (code !== codes.lowercaseB)
+            return nok(code);
+        effects.consume(code);
+        return expectL;
+    };
+    const expectL = (code) => {
+        if (code !== codes.lowercaseL)
+            return nok(code);
+        effects.consume(code);
+        return expectO;
+    };
+    const expectO = (code) => {
+        if (code !== codes.lowercaseO)
+            return nok(code);
+        effects.consume(code);
+        return expectC;
+    };
+    const expectC = (code) => {
+        if (code !== codes.lowercaseC)
+            return nok(code);
+        effects.consume(code);
+        return expectK;
+    };
+    const expectK = (code) => {
+        if (code !== codes.lowercaseK)
+            return nok(code);
+        effects.consume(code);
+        return expectColon;
+    };
+    const expectColon = (code) => {
+        if (code !== codes.colon)
+            return nok(code);
+        effects.consume(code);
+        effects.exit('magicBlockMarkerStart');
+        effects.enter('magicBlockType');
+        return onComplete;
+    };
+    return expectB;
+}
+/**
+ * Creates the type capture state machine.
+ * Captures type characters until ] and validates against known types.
+ */
+function createTypeCaptureParser(effects, nok, onComplete, blockTypeRef) {
+    const captureTypeFirst = (code) => {
+        // Reject empty type name [block:]
+        if (code === codes.rightSquareBracket) {
+            return nok(code);
+        }
+        if (isTypeChar(code)) {
+            blockTypeRef.value += String.fromCharCode(code);
+            effects.consume(code);
+            return captureType;
+        }
+        return nok(code);
+    };
+    const captureType = (code) => {
+        if (code === codes.rightSquareBracket) {
+            if (!KNOWN_BLOCK_TYPES.has(blockTypeRef.value)) {
+                return nok(code);
+            }
+            effects.exit('magicBlockType');
+            effects.enter('magicBlockMarkerTypeEnd');
+            effects.consume(code);
+            effects.exit('magicBlockMarkerTypeEnd');
+            return onComplete;
+        }
+        if (isTypeChar(code)) {
+            blockTypeRef.value += String.fromCharCode(code);
+            effects.consume(code);
+            return captureType;
+        }
+        return nok(code);
+    };
+    return { first: captureTypeFirst, remaining: captureType };
+}
+/**
+ * Creates the closing marker state machine: /block]
+ * Handles partial matches by calling onMismatch to fall back to data capture.
+ */
+function createClosingMarkerParser(effects, onSuccess, onMismatch, onEof, jsonState) {
+    const handleMismatch = (code) => {
+        if (jsonState && code === codes.quotationMark) {
+            jsonState.inString = true;
+        }
+        return onMismatch(code);
+    };
+    const expectSlash = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.slash)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectB;
+    };
+    const expectB = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseB)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectL;
+    };
+    const expectL = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseL)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectO;
+    };
+    const expectO = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseO)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectC;
+    };
+    const expectC = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseC)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectK;
+    };
+    const expectK = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.lowercaseK)
+            return handleMismatch(code);
+        effects.consume(code);
+        return expectBracket;
+    };
+    const expectBracket = (code) => {
+        if (code === null)
+            return onEof(code);
+        if (code !== codes.rightSquareBracket)
+            return handleMismatch(code);
+        effects.consume(code);
+        return onSuccess;
+    };
+    return { expectSlash };
+}
+/**
+ * Partial construct for checking non-lazy continuation.
+ * This is used by the flow tokenizer to check if we can continue
+ * parsing on the next line.
+ */
+const syntax_nonLazyContinuation = {
+    partial: true,
+    tokenize: syntax_tokenizeNonLazyContinuation,
+};
+/**
+ * Tokenizer for non-lazy continuation checking.
+ * Returns ok if the next line is non-lazy (can continue), nok if lazy.
+ */
+function syntax_tokenizeNonLazyContinuation(effects, ok, nok) {
+    const lineStart = (code) => {
+        // `this` here refers to the micromark parser
+        // since we are just passing functions as references and not actually calling them
+        // micromarks's internal parser will call this automatically with appropriate arguments
+        return this.parser.lazy[this.now().line] ? nok(code) : ok(code);
+    };
+    const start = (code) => {
+        if (code === null) {
+            return nok(code);
+        }
+        if (!markdownLineEnding(code)) {
+            return nok(code);
+        }
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return lineStart;
+    };
+    return start;
+}
+/**
+ * Create a micromark extension for magic block syntax.
+ *
+ * This extension handles both single-line and multiline magic blocks:
+ * - Flow construct (concrete): Handles block-level multiline magic blocks at document level
+ * - Text construct: Handles inline magic blocks in lists, paragraphs, etc.
+ *
+ * The flow construct is marked as "concrete" which prevents it from being
+ * interrupted by container markers (like `>` for blockquotes or `-` for lists).
+ */
+function syntax_magicBlock() {
+    return {
+        // Flow construct - handles block-level magic blocks at document root
+        // Marked as concrete to prevent interruption by containers
+        flow: {
+            [codes.leftSquareBracket]: {
+                name: 'magicBlock',
+                concrete: true,
+                tokenize: tokenizeMagicBlockFlow,
+            },
+        },
+        // Text construct - handles magic blocks in inline contexts (lists, paragraphs)
+        text: {
+            [codes.leftSquareBracket]: {
+                name: 'magicBlock',
+                tokenize: tokenizeMagicBlockText,
+            },
+        },
+    };
+}
+/**
+ * Flow tokenizer for block-level magic blocks (multiline).
+ * Uses the continuation checking pattern from code fences.
+ */
+function tokenizeMagicBlockFlow(effects, ok, nok) {
+    // State for tracking JSON content
+    const jsonState = { escapeNext: false, inString: false };
+    const blockTypeRef = { value: '' };
+    let seenOpenBrace = false;
+    // Create shared parsers for opening marker and type capture
+    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
+    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
+    return start;
+    function start(code) {
+        if (code !== codes.leftSquareBracket)
+            return nok(code);
+        effects.enter('magicBlock');
+        effects.enter('magicBlockMarkerStart');
+        effects.consume(code);
+        return openingMarkerParser;
+    }
+    /**
+     * State before data content - handles line endings or starts data capture.
+     */
+    function beforeData(code) {
+        // EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // Line ending before any data - check continuation
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        // Check for closing marker directly (without entering data)
+        // This handles cases like [block:type]\n{}\n\n[/block] where there are
+        // newlines after the data object
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlashFromContinuation;
+        }
+        // If we've already seen the opening brace, just continue capturing data
+        if (seenOpenBrace) {
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        // Skip whitespace (spaces/tabs) before the data - stay in beforeData
+        // Don't enter magicBlockData token yet until we confirm there's a '{'
+        if (code === codes.space || code === codes.horizontalTab) {
+            return beforeDataWhitespace(code);
+        }
+        // Data must start with '{' for valid JSON
+        if (code !== codes.leftCurlyBrace) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // We have '{' - enter data token and start capturing
+        seenOpenBrace = true;
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Consume whitespace before the data without creating a token.
+     * Uses a temporary token to satisfy micromark's requirement.
+     */
+    function beforeDataWhitespace(code) {
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        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.leftCurlyBrace) {
+            seenOpenBrace = true;
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continue consuming whitespace or validate the opening brace.
+     */
+    function beforeDataWhitespaceContinue(code) {
+        if (code === null) {
+            effects.exit('magicBlockData');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            return captureData(code);
+        }
+        effects.exit('magicBlockData');
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continuation OK before we've entered data token.
+     */
+    function continuationOkBeforeData(code) {
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return beforeData; // Stay in beforeData state - don't enter magicBlockData yet
+    }
+    function captureData(code) {
+        // EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlockData');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // At line ending, check if we can continue on the next line
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (jsonState.escapeNext) {
+            jsonState.escapeNext = false;
+            effects.consume(code);
+            return captureData;
+        }
+        if (jsonState.inString) {
+            if (code === codes.backslash) {
+                jsonState.escapeNext = true;
+                effects.consume(code);
+                return captureData;
+            }
+            if (code === codes.quotationMark) {
+                jsonState.inString = false;
+            }
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.quotationMark) {
+            jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.leftSquareBracket) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlash;
+        }
+        effects.consume(code);
+        return captureData;
+    }
+    /**
+     * Called when non-lazy continuation check passes - we can continue parsing.
+     */
+    function continuationOk(code) {
+        // Consume the line ending
+        effects.enter('magicBlockLineEnding');
+        effects.consume(code);
+        effects.exit('magicBlockLineEnding');
+        return continuationStart;
+    }
+    /**
+     * Start of continuation line - check for more line endings, closing marker, or start capturing data.
+     */
+    function continuationStart(code) {
+        // Handle consecutive line endings
+        if (code === null) {
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        // Check if this is the start of the closing marker [/block]
+        // If so, handle it directly without entering magicBlockData
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return expectSlashFromContinuation;
+        }
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Check for closing marker slash when coming from continuation.
+     * If not a closing marker, create an empty data token and continue.
+     */
+    function expectSlashFromContinuation(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockMarkerEnd');
+            return effects.check(syntax_nonLazyContinuation, continuationOkBeforeData, after)(code);
+        }
+        if (code === codes.slash) {
+            effects.consume(code);
+            return expectClosingB;
+        }
+        // Not a closing marker - this is data content
+        // Exit marker and enter data
+        effects.exit('magicBlockMarkerEnd');
+        effects.enter('magicBlockData');
+        // The [ was consumed by the marker, so we need to conceptually "have it" in our data
+        // But since we already consumed it into the marker, we need a different approach
+        // Re-classify: consume this character as data and continue
+        if (code === codes.quotationMark)
+            jsonState.inString = true;
+        effects.consume(code);
+        return captureData;
+    }
+    function expectSlash(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        // At line ending during marker parsing
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockMarkerEnd');
+            return effects.check(syntax_nonLazyContinuation, continuationOk, after)(code);
+        }
+        if (code !== codes.slash) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingB;
+    }
+    function expectClosingB(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseB) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingL;
+    }
+    function expectClosingL(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseL) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingO;
+    }
+    function expectClosingO(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseO) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingC;
+    }
+    function expectClosingC(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseC) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingK;
+    }
+    function expectClosingK(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.lowercaseK) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        return expectClosingBracket;
+    }
+    function expectClosingBracket(code) {
+        if (code === null) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.exit('magicBlock');
+            return nok(code);
+        }
+        if (code !== codes.rightSquareBracket) {
+            effects.exit('magicBlockMarkerEnd');
+            effects.enter('magicBlockData');
+            if (code === codes.quotationMark)
+                jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        effects.consume(code);
+        effects.exit('magicBlockMarkerEnd');
+        // Check for trailing whitespace on the same line
+        return consumeTrailing;
+    }
+    /**
+     * Consume trailing whitespace (spaces/tabs) on the same line after [/block].
+     * For concrete flow constructs, we must end at eol/eof or fail.
+     * Trailing whitespace is consumed; other content causes nok (text tokenizer handles it).
+     */
+    function consumeTrailing(code) {
+        // End of file - done
+        if (code === null) {
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Line ending - done
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Space or tab - consume as trailing whitespace
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.enter('magicBlockTrailing');
+            effects.consume(code);
+            return consumeTrailingContinue;
+        }
+        // Any other character - fail flow tokenizer, let text tokenizer handle it
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Continue consuming trailing whitespace.
+     */
+    function consumeTrailingContinue(code) {
+        // End of file - done
+        if (code === null) {
+            effects.exit('magicBlockTrailing');
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // Line ending - done
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockTrailing');
+            effects.exit('magicBlock');
+            return ok(code);
+        }
+        // More space or tab - keep consuming
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return consumeTrailingContinue;
+        }
+        // Non-whitespace after whitespace - fail flow tokenizer
+        effects.exit('magicBlockTrailing');
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+    /**
+     * Called when we can't continue (lazy line or EOF) - exit the construct.
+     */
+    function after(code) {
+        effects.exit('magicBlock');
+        return nok(code);
+    }
+}
+/**
+ * Text tokenizer for single-line magic blocks only.
+ * Used in inline contexts like list items and paragraphs.
+ * Multiline blocks are handled by the flow tokenizer.
+ */
+function tokenizeMagicBlockText(effects, ok, nok) {
+    // State for tracking JSON content
+    const jsonState = { escapeNext: false, inString: false };
+    const blockTypeRef = { value: '' };
+    let seenOpenBrace = false;
+    // Create shared parsers for opening marker and type capture
+    const typeParser = createTypeCaptureParser(effects, nok, beforeData, blockTypeRef);
+    const openingMarkerParser = createOpeningMarkerParser(effects, nok, typeParser.first);
+    // Success handler for closing marker - exits tokens and returns ok
+    const closingSuccess = (code) => {
+        effects.exit('magicBlockMarkerEnd');
+        effects.exit('magicBlock');
+        return ok(code);
+    };
+    // Mismatch handler - falls back to data capture
+    const closingMismatch = (code) => {
+        effects.exit('magicBlockMarkerEnd');
+        effects.enter('magicBlockData');
+        if (code === codes.quotationMark)
+            jsonState.inString = true;
+        effects.consume(code);
+        return captureData;
+    };
+    // EOF handler
+    const closingEof = (_code) => nok(_code);
+    // Create closing marker parsers
+    const closingFromBeforeData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
+    const closingFromData = createClosingMarkerParser(effects, closingSuccess, closingMismatch, closingEof, jsonState);
+    return start;
+    function start(code) {
+        if (code !== codes.leftSquareBracket)
+            return nok(code);
+        effects.enter('magicBlock');
+        effects.enter('magicBlockMarkerStart');
+        effects.consume(code);
+        return openingMarkerParser;
+    }
+    /**
+     * State before data content - handles line endings before entering data token.
+     * Whitespace before '{' is allowed.
+     */
+    function beforeData(code) {
+        // Fail on EOF - magic block must be closed
+        if (code === null) {
+            return nok(code);
+        }
+        // Handle line endings before any data - consume them without entering data token
+        if (markdownLineEnding(code)) {
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        // Check for closing marker directly (without entering data)
+        if (code === codes.leftSquareBracket) {
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return closingFromBeforeData.expectSlash;
+        }
+        // If we've already seen the opening brace, just continue capturing data
+        if (seenOpenBrace) {
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        // Skip whitespace (spaces/tabs) before the data
+        if (code === codes.space || code === codes.horizontalTab) {
+            return beforeDataWhitespace(code);
+        }
+        // Data must start with '{' for valid JSON
+        if (code !== codes.leftCurlyBrace) {
+            return nok(code);
+        }
+        // We have '{' - enter data token and start capturing
+        seenOpenBrace = true;
+        effects.enter('magicBlockData');
+        return captureData(code);
+    }
+    /**
+     * Consume whitespace before the data.
+     */
+    function beforeDataWhitespace(code) {
+        if (code === null) {
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.enter('magicBlockData');
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            effects.enter('magicBlockData');
+            return captureData(code);
+        }
+        return nok(code);
+    }
+    /**
+     * Continue consuming whitespace or validate the opening brace.
+     */
+    function beforeDataWhitespaceContinue(code) {
+        if (code === null) {
+            effects.exit('magicBlockData');
+            return nok(code);
+        }
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData;
+        }
+        if (code === codes.space || code === codes.horizontalTab) {
+            effects.consume(code);
+            return beforeDataWhitespaceContinue;
+        }
+        if (code === codes.leftCurlyBrace) {
+            seenOpenBrace = true;
+            return captureData(code);
+        }
+        effects.exit('magicBlockData');
+        return nok(code);
+    }
+    function captureData(code) {
+        // Fail on EOF - magic block must be closed
+        if (code === null) {
+            effects.exit('magicBlockData');
+            return nok(code);
+        }
+        // Handle multiline magic blocks within text/paragraphs
+        // Exit data, consume line ending with proper token, then re-enter data
+        if (markdownLineEnding(code)) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockLineEnding');
+            effects.consume(code);
+            effects.exit('magicBlockLineEnding');
+            return beforeData; // Go back to beforeData to handle potential empty lines
+        }
+        if (jsonState.escapeNext) {
+            jsonState.escapeNext = false;
+            effects.consume(code);
+            return captureData;
+        }
+        if (jsonState.inString) {
+            if (code === codes.backslash) {
+                jsonState.escapeNext = true;
+                effects.consume(code);
+                return captureData;
+            }
+            if (code === codes.quotationMark) {
+                jsonState.inString = false;
+            }
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.quotationMark) {
+            jsonState.inString = true;
+            effects.consume(code);
+            return captureData;
+        }
+        if (code === codes.leftSquareBracket) {
+            effects.exit('magicBlockData');
+            effects.enter('magicBlockMarkerEnd');
+            effects.consume(code);
+            return closingFromData.expectSlash;
+        }
+        effects.consume(code);
+        return captureData;
+    }
+}
+/* harmony default export */ const syntax = ((/* unused pure expression or super */ null && (syntax_magicBlock)));
+
+;// ./lib/micromark/magic-block/index.ts
+/**
+ * Micromark extension for magic block syntax.
+ *
+ * Usage:
+ * ```ts
+ * import { magicBlock } from './lib/micromark/magic-block';
+ *
+ * const processor = unified()
+ *   .data('micromarkExtensions', [magicBlock()])
+ * ```
+ */
+
+
+;// ./lib/micromark/mdx-component/syntax.ts
+
+
+
+
+
+// Raw tags (type-1: pre/script/style/textarea) and block tags (type-6: div,
+// section, …) always start a block, so they stay flow even with trailing
+// content. Other lowercase tags (i, span, …) follow the type-7 rule and only
+// stay flow when nothing trails the close tag.
+const htmlFlowTagNames = new Set([...htmlRawNames, ...htmlBlockNames]);
+// Lowercase type-6 block tags claimable in flow even without a `{…}` attribute, so
+// 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 mdx_component_syntax_nonLazyContinuationStart = {
+    tokenize: mdx_component_syntax_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+// Lookahead for `plainClaimLineStart`: is this line markup-only, or a paragraph
+// that merely starts with a tag? Run via `effects.check` so it never consumes.
+const markupOnlyContinuation = {
+    tokenize: tokenizeMarkupOnlyContinuation,
+    partial: true,
+};
+function resolveToMdxComponent(events) {
+    let index = events.length;
+    while (index > 0) {
+        index -= 1;
+        if (events[index][0] === 'enter' && events[index][1].type === 'mdxComponent') {
+            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 mdxComponentFlowConstruct = {
+    name: 'mdxComponent',
+    tokenize: createTokenize('flow'),
+    resolveTo: resolveToMdxComponent,
+    concrete: true,
+};
+const mdxComponentTextConstruct = {
+    name: 'mdxComponentText',
+    tokenize: createTokenize('text'),
+};
+/**
+ * Factory for both flow (block) and text (inline) variants.
+ *
+ * **Flow** — the original behavior: claims PascalCase components (always) and
+ * lowercase HTML tags that carry at least one `{…}` attribute expression.
+ * Multi-line, concrete, `afterClose` consumes the rest of the line.
+ *
+ * **Text** — runs inside paragraphs / inline context. Claims lowercase tags and
+ * inline PascalCase components (`INLINE_COMPONENT_TAGS` — Anchor, Glossary), both
+ * gated on at least one `{…}` brace attribute. All other PascalCase stays
+ * flow-only, matching how ReadMe's custom components are authored. Aborts on line
+ * endings (inline constructs don't span lines) and exits immediately after
+ * `</tag>` so the paragraph's inline parser picks up the trailing text.
+ */
+function createTokenize(mode) {
+    const isFlow = mode === 'flow';
+    return function tokenize(effects, ok, nok) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        let tagName = '';
+        let depth = 0;
+        let closingTagName = '';
+        // For lowercase tags we only want to claim the block if it uses JSX
+        // attribute expression syntax (`attr={...}`). Plain HTML should fall
+        // through to CommonMark html-flow. Flow mode claims any PascalCase block
+        // component; text mode claims only inline PascalCase components
+        // (INLINE_COMPONENT_TAGS — Anchor, Glossary), also brace-gated.
+        let isLowercaseTag = false;
+        let sawBraceAttr = false;
+        // A plain lowercase block tag claimed without a `{…}` attribute, gated by
+        // `plainClaimLineStart`: after a blank line it may only continue on a tag line.
+        let isPlainBlockClaim = false;
+        let pendingBlankLine = false;
+        // Code span tracking
+        let codeSpanOpenSize = 0;
+        let codeSpanCloseSize = 0;
+        // Fenced code block tracking
+        let fenceChar = null;
+        let fenceLength = 0;
+        let fenceCloseLength = 0;
+        let atLineStart = false;
+        // True once this construct consumes any line ending; lets `afterClose`
+        // treat only single-line lowercase tags as inline candidates.
+        let sawLineEnding = false;
+        // Bail when the opener line has unmatched tag-like tokens in its body.
+        // `<Foo>_<Bar>.csv` leaves opens > closes; matched shapes like
+        // `<Callout>x <strong>y</strong>` balance to 0. Without this,
+        // `concrete: true` causes orphan openers to eat sibling blockquotes.
+        let onOpenerLine = false;
+        let openerLineHasContent = false;
+        let openerLineOpens = 0;
+        let openerLineCloses = 0;
+        // Attribute parsing state
+        let quoteChar = null;
+        let braceDepth = 0;
+        let inTemplateLit = false; // true when inside a template literal (for line continuation)
+        // Stack of braceDepth values at each ${...} interpolation entry point.
+        // When a } brings braceDepth back to a saved value, we return to the
+        // template literal instead of continuing in the brace expression.
+        const templateStack = [];
+        const isAlpha = (code) => (code >= codes.uppercaseA && code <= codes.uppercaseZ) ||
+            (code >= codes.lowercaseA && code <= codes.lowercaseZ);
+        const isSameCaseAsTag = (code) => isLowercaseTag
+            ? code >= codes.lowercaseA && code <= codes.lowercaseZ
+            : code >= codes.uppercaseA && code <= codes.uppercaseZ;
+        // Shared brace-expression state machine. The two call sites differ only in where
+        // to continue after a line ending and where to return when braceDepth reaches zero.
+        function createBraceExprStates(continuationStart, afterBraceClose) {
+            function braceExpr(code) {
+                if (code === null)
+                    return nok(code);
+                if (markdownLineEnding(code)) {
+                    if (!isFlow)
+                        return nok(code);
+                    effects.exit('mdxComponentData');
+                    return continuationStart(code);
+                }
+                if (code === codes.quotationMark || code === codes.apostrophe) {
+                    quoteChar = code;
+                    effects.consume(code);
+                    return braceString;
+                }
+                if (code === codes.graveAccent) {
+                    inTemplateLit = true;
+                    effects.consume(code);
+                    return braceTemplateLiteral;
+                }
+                if (code === codes.leftCurlyBrace) {
+                    braceDepth += 1;
+                    effects.consume(code);
+                    return braceExpr;
+                }
+                if (code === codes.rightCurlyBrace) {
+                    braceDepth -= 1;
+                    effects.consume(code);
+                    if (templateStack.length > 0 && braceDepth === templateStack[templateStack.length - 1]) {
+                        templateStack.pop();
+                        inTemplateLit = true;
+                        return braceTemplateLiteral;
+                    }
+                    if (braceDepth === 0) {
+                        return afterBraceClose;
+                    }
+                    return braceExpr;
+                }
+                effects.consume(code);
+                return braceExpr;
             }
             function braceString(code) {
                 if (code === null)
@@ -120050,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;
                 }
@@ -120078,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;
                 }
@@ -120102,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;
@@ -120118,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');
@@ -120130,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;
@@ -120140,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);
@@ -120153,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;
@@ -120191,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.
@@ -120211,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);
@@ -120235,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;
             }
@@ -120255,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;
@@ -120265,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;
@@ -120308,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);
@@ -120346,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);
@@ -120363,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);
             }
@@ -120371,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;
@@ -120390,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;
@@ -120405,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;
@@ -120434,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;
             }
@@ -120443,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;
@@ -120452,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);
             }
@@ -120468,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);
@@ -120495,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;
@@ -120506,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;
             }
@@ -120528,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) {
@@ -120588,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;
@@ -120620,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
@@ -120637,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;
             }
@@ -120650,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);
             }
@@ -120670,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;
@@ -120703,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;
         }
@@ -120722,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;
@@ -120755,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] },
     };
 }
 
@@ -120778,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(),
@@ -120840,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
 
@@ -120971,70 +121379,168 @@ const mdxishInlineMdxComponents = () => tree => {
 };
 /* harmony default export */ const inline_mdx_blocks = (mdxishInlineMdxComponents);
 
+;// ./processor/transform/mdxish/terminate-html-flow-blocks.ts
+
+
+
+const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
+const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
+// A line that is exactly one lowercase opening (or self-closing) tag — the shape
+// that opens a CommonMark type-6/7 HTML block and swallows the lines below it.
+const SINGLE_OPENING_TAG_REGEX = /^<[a-z][^<>]*>$/;
+// Tags whose contents must be preserved as is, inserting a blank line after the
+// opener corrupts the payload.
+// htmlRawNames here refer to <pre>, <textarea>, <script>, <style>
+const RAW_CONTENT_TAGS = [...htmlRawNames, ...HTML_TABLE_STRUCTURE_TAGS];
+// The `(?=[\s/>])` lookahead avoids false matches on lookalike names like `<script-foo>`.
+const RAW_CONTENT_TAG_MATCHERS = RAW_CONTENT_TAGS.map(tag => ({
+    open: new RegExp(`<${tag}(?=[\\s/>])[^>]*?(?<!/)>`, 'gi'),
+    close: new RegExp(`</${tag}(?=[\\s>])[^>]*>`, 'gi'),
+}));
+function isLineHtml(line) {
+    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
+}
+// Per-tag {opens, closes} counts of RAW_CONTENT_TAGS on one line — feeds both the
+// per-line net-open check and the cumulative still-open depth tracking.
+function countRawContentTags(line) {
+    return RAW_CONTENT_TAG_MATCHERS.map(({ open, close }) => ({
+        opens: (line.match(open) ?? []).length,
+        closes: (line.match(close) ?? []).length,
+    }));
+}
+// Indentation width in columns, counting a tab as 4 per CommonMark.
+function indentWidth(line) {
+    const leading = line.match(/^[ \t]*/)?.[0] ?? '';
+    return leading.replace(/\t/g, '    ').length;
+}
+/**
+ * Decides whether a blank line belongs between `line` and `next` so the HTML
+ * flow block opened on `line` terminates and `next` parses as markdown.
+ */
+function shouldTerminateBetween(line, next, { insideRawContent, lineLeavesRawOpen }) {
+    if (next.trim().length === 0)
+        return false;
+    const currentIndent = indentWidth(line);
+    const nextIndent = indentWidth(next);
+    // 4+ columns is CommonMark indented-code territory: an inserted blank line
+    // would turn the next line into a code block instead of freeing it (#1344).
+    if (currentIndent > 3 || nextIndent > 3)
+        return false;
+    const currentTrimmed = line.trim();
+    const nextTrimmed = next.trim();
+    if (!isLineHtml(currentTrimmed) || isLineHtml(nextTrimmed) || lineLeavesRawOpen) {
+        return false;
+    }
+    // Column-0 pairs keep the original (pre-relaxation) rule, deliberately ignoring
+    // `insideRawContent`: one unclosed <pre>/<table> typo would otherwise suppress
+    // termination for the whole rest of the document.
+    if (currentIndent === 0 && nextIndent === 0)
+        return true;
+    // Indented shapes (either line at 1–3 columns) are stricter: only a lone opening
+    // tag followed by markdown. A next line opening a tag or expression must stay
+    // glued for the mdxComponent tokenizer; raw-content payloads stay byte-exact.
+    return (!insideRawContent &&
+        SINGLE_OPENING_TAG_REGEX.test(currentTrimmed) &&
+        !nextTrimmed.startsWith('<') &&
+        !nextTrimmed.startsWith('{'));
+}
+/**
+ * CommonMark HTML blocks (types 6/7) end only at a blank line, so markdown on the
+ * next line is swallowed as HTML (`## heading` after `<div>` renders as literal text).
+ * Inserts the missing blank line; the gating rules live in `shouldTerminateBetween`.
+ *
+ * @link https://spec.commonmark.org/0.29/#html-blocks
+ */
+function terminateHtmlFlowBlocks(content) {
+    const { protectedContent, protectedCode } = protectCodeBlocks(content);
+    const lines = protectedContent.split('\n');
+    const result = [];
+    // Per-tag count of still-open raw-content elements at the current boundary.
+    const rawContentDepths = RAW_CONTENT_TAG_MATCHERS.map(() => 0);
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        result.push(line);
+        const tagCounts = countRawContentTags(line);
+        tagCounts.forEach(({ opens, closes }, tagIndex) => {
+            rawContentDepths[tagIndex] = Math.max(0, rawContentDepths[tagIndex] + opens - closes);
+        });
+        const next = lines[i + 1];
+        const rawContentFacts = {
+            insideRawContent: rawContentDepths.some(depth => depth > 0),
+            lineLeavesRawOpen: tagCounts.some(({ opens, closes }) => opens > closes),
+        };
+        if (next !== undefined && shouldTerminateBetween(line, next, rawContentFacts)) {
+            result.push('');
+        }
+    }
+    return restoreCodeBlocks(result.join('\n'), protectedCode);
+}
+
 ;// ./processor/transform/mdxish/components/mdx-blocks.ts
 
 
 
 
 
-/** Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
+
+
+// Matches a JSX attribute expression (e.g. `key={i}`) anywhere in a string. */
 const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
-/**
- * Reduce leading whitespace on all lines just enough to prevent
- * remark from treating indented content as code blocks (4+ spaces).
- * Preserves relative indentation so whitespace text nodes are
- * maintained in the HAST output.
+// Name shape mirrors `componentTagPattern`; the lookbehind skips the inner tag
+// of a legacy `<<VARIABLE>>`.
+const NESTED_COMPONENT_TAG_RE = /(?<!<)<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+// Excludes tags with dedicated transformers (`Table`, `HTMLBlock`, inline
+// components), which expect their wrapper to stay raw.
+const hasNestedGenericComponentTag = (content) => [...content.matchAll(NESTED_COMPONENT_TAG_RE)].some(match => !GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(match[1]));
+/**
+ * Strip the shared leading indentation from a component body so readability indentation
+ * isn't parsed as indented code (4+ spaces), e.g. `  <p>` / `   text` -> `<p>` / ` text`.
+ * Relative indentation is kept, so content genuinely 4+ columns deeper stays code. We
+ * only strip when a line actually reaches 4 columns; otherwise the body is left as-is so
+ * its leading whitespace survives as text nodes (mixed component + HTML content needs it).
  */
 function safeDeindent(text) {
     const lines = text.split('\n');
     const nonEmptyLines = lines.filter(line => line.trim().length > 0);
     if (nonEmptyLines.length === 0)
         return text;
-    const minIndent = Math.min(...nonEmptyLines.map(line => {
-        const match = line.match(/^(\s*)/);
-        return match ? match[1].length : 0;
-    }));
-    // Only strip enough indent to keep all lines below the 4-space code threshold
-    const stripAmount = Math.max(0, minIndent - 3);
+    // Indent counts characters (tab = 1), unlike indentWidth's CommonMark columns
+    // (tab = 4) in terminate-html-flow-blocks.
+    const indents = nonEmptyLines.map(line => line.match(/^(\s*)/)?.[1].length ?? 0);
+    const minIndent = Math.min(...indents);
+    const maxIndent = Math.max(...indents);
+    const stripAmount = maxIndent > 3 ? minIndent : 0;
     if (stripAmount === 0)
         return text;
     return lines.map(line => line.slice(stripAmount)).join('\n');
 }
 /**
- * Parse markdown content into mdast children nodes.
- * Dedents the content first to prevent indented component content
- * (from nested components) from being treated as code blocks.
+ * Parse component-body markdown into mdast children. Dedenting shifts columns and
+ * stales the top-level `terminateHtmlFlowBlocks` decisions, so that one preprocessor
+ * re-runs here; other column-anchored fixups (compact headings, tables) do not.
  */
 const parseMdChildren = (value, safeMode) => {
-    const parsed = getInlineMdProcessor({ safeMode }).parse(safeDeindent(value).trim());
+    const parsed = getInlineMdProcessor({ safeMode }).parse(terminateHtmlFlowBlocks(safeDeindent(value).trim()));
     return parsed.children || [];
 };
-/**
- * Parse substring content of a node and update the parent's children to include the new nodes.
- */
+// Parses trailing content into sibling nodes and re-queues the parent so any
+// components among them get processed.
 const parseSibling = (stack, parent, index, sibling, safeMode) => {
     const siblingNodes = parseMdChildren(sibling, safeMode);
-    // The new sibling nodes might contain new components to be processed
     if (siblingNodes.length > 0) {
         parent.children.splice(index + 1, 0, ...siblingNodes);
         stack.push(parent);
     }
 };
-/**
- * Build a position ending at `consumedLength` into the html node's value, so the
- * component doesn't claim trailing content the tokenizer swallowed into one node.
- */
+// Ends the position at `consumedLength` so the component doesn't claim trailing
+// content the tokenizer swallowed into the same html node.
 const positionEndingAtConsumed = (nodePosition, value, consumedLength) => {
     if (!nodePosition?.start)
         return nodePosition;
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, value.slice(0, consumedLength)) };
 };
-/**
- * Build a position ending right after the last occurrence of `closingTag` within
- * this node's span in the original source. Used in the trailing-content path so
- * the offset is computed against the real source bytes (including blockquote/list
- * prefixes that were stripped from the html node's value).
- */
+// Like `positionEndingAtConsumed`, but measures against the original source so
+// blockquote/list prefixes stripped from the html node's value are counted.
 const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) => {
     if (!nodePosition?.start || !nodePosition.end)
         return nodePosition;
@@ -121045,9 +121551,6 @@ const positionEndingAtClosingTagInSource = (nodePosition, closingTag, source) =>
     const consumed = nodeSource.slice(0, closingTagOffset + closingTag.length);
     return { start: nodePosition.start, end: pointAfter(nodePosition.start, consumed) };
 };
-/**
- * Create an MdxJsxFlowElement node from component data.
- */
 const createComponentNode = ({ tag, attributes, children, startPosition, endPosition }) => ({
     type: 'mdxJsxFlowElement',
     name: tag,
@@ -121069,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:
  *
@@ -121100,8 +121607,7 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if ('children' in node && Array.isArray(node.children)) {
             stack.push(node);
         }
-        // Only visit HTML nodes with an actual html tag,
-        // which means a potential unparsed MDX component
+        // Only html nodes can be an unparsed MDX component.
         const value = node.value;
         if (node.type !== 'html' || typeof value !== 'string')
             return;
@@ -121110,32 +121616,34 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
         if (!parsed)
             return;
         const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
-        // Offset of `trimmed` within the (possibly whitespace-padded) html node value,
-        // so consumed-length math maps back onto the node's real source offsets.
+        // Offsets so consumed-length math maps back onto the node's real source.
         const leadingWhitespace = value.length - value.trimStart().length;
-        // Index right after the opening tag's `>` within `trimmed`.
         const openingTagEnd = trimmed.length - contentAfterTag.length;
-        // Skip tags that have dedicated transformers
         if (GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(tag))
-            return;
+            return; // owned by dedicated transformers
         const isPascal = isPascalCase(tag);
-        // Lowercase inline tags (inside a paragraph) with `{…}` attributes are
-        // promoted to `mdxJsxTextElement` by mdxishInlineComponentBlocks. Skip
-        // them here so they stay as html for that pass; PascalCase components
-        // keep going through this transformer (they stay flow-level even when
-        // inline, which is how ReadMe's custom components are modeled).
+        // ==== 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).
         if (!isPascal && parent.type === 'paragraph')
             return;
-        // Lowercase HTML tags are eligible when they (or a descendant tag in their
-        // content, e.g. a `.map()` body returning JSX with `key={i}`) carry a
-        // JSX-expression attribute. Without this, a wrapper `<div>` with only plain
-        // attributes (or none) swallows its whole nested block — including any
-        // `style={{...}}`/`.map()` JSX inside it — as literal HTML text, which
-        // rehype-raw's parse5 pass then garbles (it has no notion of JS expressions).
-        // Plain HTML with no expressions anywhere stays as an html node so
-        // rehype-raw handles it as normal.
-        const hasNestedExpressionAttr = !selfClosing && NESTED_ATTR_EXPRESSION_RE.test(contentAfterTag);
-        if (!isPascal && !hasExpressionAttr(attributes) && !hasNestedExpressionAttr)
+        // 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 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);
+        // 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
@@ -121149,7 +121657,6 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 endPosition: positionEndingAtConsumed(node.position, value, leadingWhitespace + openingTagEnd),
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // Check and parse if there's relevant content after the current closing tag
             const remainingContent = contentAfterTag.trim();
             if (remainingContent) {
                 parseSibling(stack, parent, index, remainingContent, safeMode);
@@ -121157,18 +121664,27 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
             return;
         }
         // Case 2: Self-contained block (closing tag in content)
-        if (contentAfterTag.includes(closingTagStr)) {
-            // Find the first closing tag
-            const closingTagIndex = contentAfterTag.lastIndexOf(closingTagStr);
-            // Pass raw (untrimmed) content so dedent in parseMdChildren can
-            // normalize indentation before trimming
+        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)
-                : [];
-            // Lowercase HTML tags are usually inline (e.g. <a>, <span>). Remark wraps
-            // bare text in a paragraph; unwrap when there's exactly one paragraph so
+            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') {
                 parsedChildren = parsedChildren[0].children;
@@ -121178,12 +121694,9 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                 attributes,
                 children: parsedChildren,
                 startPosition: node.position,
-                // When trailing content follows the closing tag, compute the end position precisely
-                // within the html node's value so the component doesn't claim that content.
-                // Prefer source-based positioning when the original source is available: the html
-                // node's value has '> '/space prefixes stripped for blockquotes/list items, so
-                // positionEndingAtConsumed would undercount source offsets. When the entire node
-                // is consumed, use the original node position directly.
+                // With trailing content, end precisely at the closing tag. Prefer source
+                // offsets when available (the node's value strips blockquote/list
+                // prefixes); otherwise fall back to the whole node position.
                 endPosition: contentAfterClose
                     ? source
                         ? positionEndingAtClosingTagInSource(node.position, closingTagStr, source)
@@ -121191,17 +121704,16 @@ const mdx_blocks_mdxishMdxComponentBlocks = (opts = {}) => (tree, file) => {
                     : node.position,
             });
             substituteNodeWithMdxNode(parent, index, componentNode);
-            // After the closing tag, there might be more content to be processed
+            // Re-queue whichever side may hold further components.
             if (contentAfterClose) {
                 parseSibling(stack, parent, index, contentAfterClose, safeMode);
             }
             else if (componentNode.children.length > 0) {
-                // The content inside the component block might contain new components to be processed
                 stack.push(componentNode);
             }
         }
     };
-    // Process the nodes with the components depth-first to maintain the correct order of the nodes
+    // Depth-first so nodes keep their source order.
     while (stack.length) {
         const parent = stack.pop();
         if (parent?.children) {
@@ -123372,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;
         }
@@ -123400,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);
@@ -123413,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);
@@ -123426,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);
@@ -123461,7 +123973,7 @@ function exitLooseHtmlEntity(token) {
 }
 function looseHtmlEntity() {
     return {
-        text: { [codes_codes.ampersand]: looseHtmlEntityConstruct },
+        text: { [codes.ampersand]: looseHtmlEntityConstruct },
     };
 }
 function looseHtmlEntityFromMarkdown() {
@@ -124154,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.
  */
@@ -124237,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
@@ -124268,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);
 
@@ -124997,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
 
 /**
@@ -125450,74 +125953,7 @@ function normalizeTableSeparator(content) {
     });
     return normalizedLines.join('\n');
 }
-/* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
-
-;// ./processor/transform/mdxish/terminate-html-flow-blocks.ts
-
-
-
-const STANDALONE_HTML_LINE_REGEX = /^(<[a-z][^<>]*>|<\/[a-z][^<>]*>)+\s*$/;
-const HTML_LINE_WITH_CONTENT_REGEX = /^<[a-z][^<>]*>.*<\/[a-z][^<>]*>(?:[^<]*)$/;
-// Tags whose contents must be preserved as is, inserting a blank line after the
-// opener corrupts the payload.
-// htmlRawNames here refer to <pre>, <textarea>, <script>, <style>
-const RAW_CONTENT_TAGS = [...htmlRawNames, ...HTML_TABLE_STRUCTURE_TAGS];
-// The `(?=[\s/>])` lookahead avoids false matches on lookalike names like `<script-foo>`.
-const RAW_CONTENT_TAG_MATCHERS = RAW_CONTENT_TAGS.map(tag => ({
-    open: new RegExp(`<${tag}(?=[\\s/>])[^>]*?(?<!/)>`, 'gi'),
-    close: new RegExp(`</${tag}(?=[\\s>])[^>]*>`, 'gi'),
-}));
-function isLineHtml(line) {
-    return STANDALONE_HTML_LINE_REGEX.test(line) || HTML_LINE_WITH_CONTENT_REGEX.test(line);
-}
-// True if any RAW_CONTENT_TAGS opener on this line is not closed on the same line.
-function hasUnclosedRawContentOpener(line) {
-    return RAW_CONTENT_TAG_MATCHERS.some(({ open, close }) => {
-        const opens = (line.match(open) ?? []).length;
-        const closes = (line.match(close) ?? []).length;
-        return opens > closes;
-    });
-}
-/**
- * Preprocessor to terminate HTML flow blocks.
- *
- * In CommonMark, HTML blocks (types 6 and 7) only terminate on a blank line.
- * Without one, any content on the next line is consumed as part of the HTML block
- * and never parsed as its own construct. For example, a `[block:callout]` immediately
- * following `<div><p></p></div>` gets swallowed into the HTML flow token.
- *
- * @link https://spec.commonmark.org/0.29/#html-blocks
- *
- * This preprocessor inserts a blank line after standalone HTML lines when the next
- * line is non-blank and not an HTML construct, ensuring micromark's HTML flow
- * tokenizer terminates and subsequent content is parsed independently.
- *
- * Conditions:
- * 1. Only non-indented lines with lowercase tag names are considered. Uppercase tags
- *    (e.g. `<Table>`, `<MyComponent>`) are JSX custom components and don't trigger
- *    CommonMark HTML blocks.
- * 2. Lines inside protected blocks (e.g. fenced code) are left untouched.
- * 3. Lines with an unclosed RAW_CONTENT_TAGS opener are exempted.
- */
-function terminateHtmlFlowBlocks(content) {
-    const { protectedContent, protectedCode } = protectCodeBlocks(content);
-    const lines = protectedContent.split('\n');
-    const result = [];
-    for (let i = 0; i < lines.length; i += 1) {
-        result.push(lines[i]);
-        // Skip blank & indented lines
-        if (i >= lines.length - 1 || lines[i + 1].trim().length === 0 || lines[i + 1].startsWith(' ') || lines[i + 1].startsWith('\t')) {
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        const isCurrentLineHtml = isLineHtml(lines[i]);
-        const isNextLineHtml = isLineHtml(lines[i + 1]);
-        if (isCurrentLineHtml && !isNextLineHtml && !hasUnclosedRawContentOpener(lines[i])) {
-            result.push('');
-        }
-    }
-    return restoreCodeBlocks(result.join('\n'), protectedCode);
-}
+/* harmony default export */ const normalize_table_separator = ((/* unused pure expression or super */ null && (normalizeTableSeparator)));
 
 ;// ./processor/transform/mdxish/variables-code.ts
 
@@ -125675,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) {
@@ -125703,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
 
 
@@ -125745,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');
@@ -125754,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);
         }
@@ -125763,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);
@@ -125790,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;
         }
@@ -125802,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;
         }
@@ -125818,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);
@@ -125826,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;
         }
@@ -125837,7 +126550,7 @@ function tokenizeJsxComment(effects, ok, nok) {
 function jsxComment() {
     return {
         flow: {
-            [codes_codes.leftCurlyBrace]: {
+            [codes.leftCurlyBrace]: {
                 name: 'jsxComment',
                 concrete: true,
                 tokenize: tokenizeJsxComment,
@@ -125846,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
 
 
@@ -126102,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');
@@ -126111,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);
         }
@@ -126121,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;
@@ -126154,7 +126630,7 @@ function tokenizeTextExpression(effects, ok, nok) {
 function mdxExpressionLenient() {
     return {
         text: {
-            [codes_codes.leftCurlyBrace]: {
+            [codes.leftCurlyBrace]: {
                 name: 'mdxTextExpression',
                 tokenize: tokenizeTextExpression,
             },
@@ -126258,6 +126734,9 @@ function loadComponents() {
 
 
 
+
+
+
 
 
 
@@ -126272,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);
@@ -126309,6 +126792,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         syntax_gemoji(),
         legacyVariable(),
         looseHtmlEntity(),
+        syntax_htmlBlockComponent(),
     ];
     const fromMarkdownExts = [
         jsx_table_jsxTableFromMarkdown(),
@@ -126318,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
@@ -126331,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)
@@ -126386,6 +126875,12 @@ function mdxishMdastToMd(mdast) {
         .use(remarkStringify, {
         bullet: '-',
         emphasis: '_',
+        // Escape literal braces in text so they don't parse as (often
+        // unterminated) MDX expressions on the next round trip.
+        unsafe: [
+            { character: '{', inConstruct: 'phrasing' },
+            { character: '}', inConstruct: 'phrasing' },
+        ],
     });
     return processor.stringify(processor.runSync(mdast));
 }
@@ -126868,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