@readme/markdown 13.5.0 → 13.6.1

package/dist/main.js

@@ -11357,6 +11357,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   Components: () => (/* reexport */ components_namespaceObject),
+  FLOW_TYPES: () => (/* reexport */ FLOW_TYPES),
   Owlmoji: () => (/* reexport */ Owlmoji),
   compile: () => (/* reexport */ lib_compile),
   exports: () => (/* reexport */ lib_exports),
@@ -12538,6 +12539,28 @@ var parseOptions = function parseOptions() {
   return opts;
 };
 
+;// ./lib/constants.ts
+/**
+ * Pattern to match component tags (PascalCase or snake_case)
+ */
+const componentTagPattern = /<(\/?[A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>/g;
+/**
+ * MDAST flow (block-level) content types that cannot be represented
+ * inside GFM table cells. Used to decide whether a table should be
+ * serialized as GFM or as JSX `<Table>` syntax.
+ *
+ * @see https://github.com/syntax-tree/mdast#flowcontent
+ */
+const FLOW_TYPES = new Set([
+    'blockquote',
+    'code',
+    'heading',
+    'html',
+    'list',
+    'table',
+    'thematicBreak',
+]);
+
 ;// ./node_modules/github-slugger/regex.js
 // This module is generated by `script/`.
 /* eslint-disable no-control-regex, no-misleading-character-class, no-useless-escape */
@@ -41028,6 +41051,7 @@ function remarkMdx(options) {
 ;// ./enums.ts
 var NodeTypes;
 (function (NodeTypes) {
+    NodeTypes["anchor"] = "readme-anchor";
     NodeTypes["callout"] = "rdme-callout";
     NodeTypes["codeTabs"] = "code-tabs";
     NodeTypes["embedBlock"] = "embed-block";
@@ -53002,6 +53026,10 @@ const plain = (node, opts = {}) => {
 };
 /* harmony default export */ const lib_plain = (plain);
 
+;// ./processor/compile/variable.ts
+const variable = (node) => `{user.${node.data?.hProperties?.name || ''}}`;
+/* harmony default export */ const compile_variable = (variable);
+
 ;// ./processor/transform/extract-text.ts
 /**
  * Extracts text content from a single AST node recursively.
@@ -53013,7 +53041,7 @@ const plain = (node, opts = {}) => {
  * @returns The concatenated text content
  */
 const extractText = (node) => {
-    if (node.type === 'text' && typeof node.value === 'string') {
+    if ((node.type === 'text' || node.type === 'html') && typeof node.value === 'string') {
         return node.value;
     }
     // When a blockquote contains only an image (no text), treat it as having content
@@ -53041,6 +53069,23 @@ const extractText = (node) => {
 
 
 
+
+
+
+
+
+
+
+const titleParser = unified().use(remarkParse).use(remarkGfm);
+// The title paragraph may contain custom AST nodes that `toMarkdown` doesn't
+// natively understand
+const toMarkdownExtensions = [
+    gfmStrikethroughToMarkdown(),
+    // For mdx variable syntaxes (e.g., {user.name})
+    mdxExpressionToMarkdown(),
+    // Important: This is required and would crash the parser if there's no variable node handler
+    { handlers: { [NodeTypes.variable]: compile_variable } },
+];
 const callouts_regex = `^(${emoji_regex().source}|⚠)(\\s+|$)`;
 const findFirst = (node) => {
     if ('children' in node)
@@ -53157,31 +53202,65 @@ const processBlockquote = (node, index, parent) => {
         // Example: "> ⚠️ **Bold heading**\nBody text here"
         const bodyChildren = splitParagraphAtNewline(firstParagraph);
         const didSplit = bodyChildren !== null;
-        // Extract heading text after removing the icon prefix.
-        // Use `plain()` to handle complex markdown structures (bold, inline code, etc.)
-        const headingText = lib_plain(firstParagraph)
-            .toString()
-            .slice(match.length);
-        // Clean up the raw AST by removing the icon prefix from the first text node
         removeIconPrefix(firstParagraph, match.length);
-        const empty = !headingText.length && firstParagraph.children.length === 1;
+        const firstText = findFirst(firstParagraph);
+        const rawValue = firstText?.value ?? '';
+        const hasContent = rawValue.trim().length > 0 || firstParagraph.children.length > 1;
+        const empty = !hasContent;
         const theme = themes[icon] || 'default';
-        // Convert the first paragraph (first children of node) to a heading if it has content or was split
-        if (headingText || didSplit) {
-            node.children[0] = wrapHeading(node);
-            // Adjust position to account for the stripped icon prefix
-            node.children[0].position.start.offset += match.length;
-            node.children[0].position.start.column += match.length;
+        if (hasContent || didSplit) {
+            const headingMatch = rawValue.match(/^(#{1,6})\s*/);
+            // # heading syntax is handled via direct AST manipulation so we can
+            // set the depth while preserving the original inline children (bold, etc.)
+            if (headingMatch) {
+                firstText.value = rawValue.slice(headingMatch[0].length);
+                const heading = wrapHeading(node);
+                heading.depth = headingMatch[1].length;
+                node.children[0] = heading;
+                node.children[0].position.start.offset += match.length;
+                node.children[0].position.start.column += match.length;
+            }
+            else {
+                const headingText = toMarkdown({ type: 'root', children: [firstParagraph] }, {
+                    extensions: toMarkdownExtensions,
+                })
+                    .trim()
+                    .replace(/^\\(?=[>#+\-*])/, '');
+                const parsedTitle = titleParser.parse(headingText);
+                const parsedFirstChild = parsedTitle.children[0];
+                // Block-level syntax ("> quote", "- list") produces non-paragraph nodes;
+                // inline text parses as a paragraph and falls through to wrapHeading().
+                if (parsedFirstChild && parsedFirstChild.type !== 'paragraph') {
+                    // Strip positions from re-parsed nodes since they're relative to the heading text, not the original source
+                    visit(parsedTitle, (n) => {
+                        delete n.position;
+                    });
+                    const heading = wrapHeading(node);
+                    heading.children = parsedTitle.children;
+                    delete heading.position;
+                    node.children[0] = heading;
+                }
+                else {
+                    node.children[0] = wrapHeading(node);
+                    node.children[0].position.start.offset += match.length;
+                    node.children[0].position.start.column += match.length;
+                }
+            }
         }
         // Insert body content as a separate paragraph after the heading
         if (bodyChildren) {
+            const headingPosition = node.children[0].position;
             node.children.splice(1, 0, {
                 type: 'paragraph',
                 children: bodyChildren,
-                position: {
-                    start: node.children[0].position.end,
-                    end: firstParagraphOriginalEnd,
-                },
+                ...(headingPosition && firstParagraphOriginalEnd
+                    ? {
+                        position: {
+                            start: headingPosition.end,
+                            end: firstParagraphOriginalEnd,
+                        },
+                    }
+                    : {}),
             });
         }
         Object.assign(node, {
@@ -53198,11 +53277,24 @@ const processBlockquote = (node, index, parent) => {
     }
 };
 const calloutTransformer = () => {
-    return (tree) => {
-        visit(tree, 'blockquote', (node, index, parent) => {
+    const processNode = (root) => {
+        visit(root, 'blockquote', (node, index, parent) => {
             processBlockquote(node, index, parent);
+            if (node.type === NodeTypes.callout) {
+                // SKIP prevents re-processing synthetic blockquotes in parsed title content
+                // (e.g., blockquotes from "> Quote" titles). Recursively process body children
+                // (index 1+, skipping the heading at 0) to handle nested callouts.
+                for (let i = 1; i < node.children.length; i += 1) {
+                    processNode(node.children[i]);
+                }
+                return SKIP;
+            }
+            return undefined;
         });
     };
+    return (tree) => {
+        processNode(tree);
+    };
 };
 /* harmony default export */ const callouts = (calloutTransformer);
 
@@ -53227,8 +53319,18 @@ const codeTabsTransformer = ({ copyButtons } = {}) => (tree) => {
             const sibling = parent.children[walker];
             if (!isCode(sibling))
                 break;
+            // Check that the two code blocks are truly adjacent (no blank lines or
+            // other content between them). The `gap` is the number of raw characters
+            // between the end of the previous block and the start of this one.
+            // For a LF-separated pair the gap equals `start.column` (the newline
+            // char(s) plus any indentation). CRLF line endings add one extra byte
+            // (\r) without advancing the line count, so we also accept
+            // `start.column + 1` provided the blocks are still on consecutive lines.
             const olderSibling = parent.children[walker - 1];
-            if (olderSibling.position.end.offset + sibling.position.start.column !== sibling.position.start.offset)
+            const gap = sibling.position.start.offset - olderSibling.position.end.offset;
+            const lineDiff = sibling.position.start.line - olderSibling.position.end.line;
+            const isCRLF = gap === sibling.position.start.column + 1 && lineDiff === 1;
+            if (gap !== sibling.position.start.column && !isCRLF)
                 break;
             children.push(sibling);
             // eslint-disable-next-line no-plusplus
@@ -70804,687 +70906,348 @@ const mdxToHast = () => tree => {
 };
 /* harmony default export */ const mdx_to_hast = (mdxToHast);
 
-;// ./lib/mdast-util/empty-task-list-item/index.ts
+;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
+
+// Marker patterns for multi-node emphasis detection
+const MARKER_PATTERNS = [
+    { isBold: true, marker: '**' },
+    { isBold: true, marker: '__' },
+    { isBold: false, marker: '*' },
+    { isBold: false, marker: '_' },
+];
+// Patterns to detect for bold (** and __) and italic (* and _) syntax:
+// Bold: ** text**, **text **, word** text**, ** text **
+// Italic: * text*, *text *, word* text*, * text *
+// Same patterns for underscore variants
+// We use separate patterns for each marker type to allow this flexibility.
+// Pattern for ** bold **
+// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
+// trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
+const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
+// Pattern for __ bold __
+const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n])+?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n])+?)(\s+)\2)(\S|$)?/g;
+// Pattern for * italic *
+const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
+// Pattern for _ italic _
+const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+((?:[^_\n]|_(?! ))+?)(\s*)\2|((?:[^_\n]|_(?! ))+?)(\s+)\2)(\S|$)?/g;
+// CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
+// Pattern for intraword _word_ in words like hello_world_
+const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
+// Pattern for intraword __word__ in words like hello__world__
+const intrawordUnderscoreBoldRegex = /(\w)__([a-zA-Z0-9]+)__(?![\w_])/g;
+// Pattern for intraword *word* in words like hello*world*
+const intrawordAsteriskItalicRegex = /(\w)\*(?!\*)([a-zA-Z0-9]+)\*(?![\w*])/g;
+// Pattern for intraword **word** in words like hello**world**
+const intrawordAsteriskBoldRegex = /(\w)\*\*([a-zA-Z0-9]+)\*\*(?![\w*])/g;
 /**
- * Normalizes list items that are written as only `[ ]` or `[x]` into GFM task
- * list items during parse, but only when at least one whitespace character
- * follows the closing bracket (`]`). This matches legacy behaviour for checkboxes
- *
- * The issue is `remark-gfm` does not actually classify these as task items when they have no content
- * after the checkbox, which leaves them as plain text (`"[ ]"`). So a custom extension is needed to
- * treat these as task items
+ * Finds opening emphasis marker in a text value.
+ * Returns marker info if found, null otherwise.
  */
-function exitListItemWithEmptyTaskListItem(token) {
-    const node = this.stack[this.stack.length - 1];
-    if (node &&
-        node.type === 'listItem' &&
-        typeof node.checked !== 'boolean') {
-        const listItem = node;
-        const head = listItem.children[0];
-        if (head && head.type === 'paragraph' && head.children.length === 1) {
-            const text = head.children[0];
-            if (text.type === 'text') {
-                const hasTrailingWhitespace = typeof head.position?.end.offset === 'number' &&
-                    typeof text.position?.end.offset === 'number' &&
-                    head.position.end.offset > text.position.end.offset;
-                if (!hasTrailingWhitespace) {
-                    this.exit(token);
-                    return;
-                }
-                const value = text.value;
-                if (value === '[ ]') {
-                    listItem.checked = false;
-                    head.children = [];
-                }
-                else if (value === '[x]' || value === '[X]') {
-                    listItem.checked = true;
-                    head.children = [];
-                }
+function findOpeningMarker(text) {
+    const results = MARKER_PATTERNS.map(({ isBold, marker }) => {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        if (text.startsWith(marker) && text.length > marker.length) {
+            return { isBold, marker, textAfter: text.slice(marker.length), textBefore: '' };
+        }
+        const idx = text.indexOf(marker);
+        if (idx > 0 && !/\s/.test(text[idx - 1])) {
+            if (marker === '*' && text.slice(idx).startsWith('**'))
+                return null;
+            if (marker === '_' && text.slice(idx).startsWith('__'))
+                return null;
+            const after = text.slice(idx + marker.length);
+            if (after.length > 0) {
+                return { isBold, marker, textAfter: after, textBefore: text.slice(0, idx) };
             }
         }
-    }
-    this.exit(token);
-}
-function emptyTaskListItemFromMarkdown() {
-    return {
-        exit: {
-            listItem: exitListItemWithEmptyTaskListItem,
-        },
-    };
+        return null;
+    });
+    return results.find(r => r !== null) ?? null;
 }
-
-;// ./lib/mdast-util/legacy-variable/index.ts
-
-const contextMap = new WeakMap();
-function findlegacyVariableToken() {
-    // tokenStack is micromark's current open token ancestry; find the nearest legacyVariable token.
-    const events = this.tokenStack;
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-        const token = events[i][0];
-        if (token.type === 'legacyVariable')
-            return token;
+/**
+ * Finds the end/closing marker in a text node for multi-node emphasis.
+ */
+function findEndMarker(text, marker) {
+    const spacePattern = ` ${marker}`;
+    const spaceIdx = text.indexOf(spacePattern);
+    if (spaceIdx >= 0) {
+        if (marker === '*' && text.slice(spaceIdx + 1).startsWith('**'))
+            return null;
+        if (marker === '_' && text.slice(spaceIdx + 1).startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(spaceIdx + spacePattern.length),
+            textBefore: text.slice(0, spaceIdx),
+        };
     }
-    return undefined;
-}
-function enterlegacyVariable(token) {
-    contextMap.set(token, { value: '' });
-}
-function exitlegacyVariableValue(token) {
-    const variableToken = findlegacyVariableToken.call(this);
-    if (!variableToken)
-        return;
-    const ctx = contextMap.get(variableToken);
-    // Build up the variable characters
-    if (ctx)
-        ctx.value += this.sliceSerialize(token);
-}
-function exitlegacyVariable(token) {
-    const ctx = contextMap.get(token);
-    const serialized = this.sliceSerialize(token);
-    const variableName = serialized.startsWith('<<') && serialized.endsWith('>>')
-        ? serialized.slice(2, -2)
-        : ctx?.value ?? '';
-    const nodePosition = {
-        start: {
-            offset: token.start.offset,
-            line: token.start.line,
-            column: token.start.column,
-        },
-        end: {
-            offset: token.end.offset,
-            line: token.end.line,
-            column: token.end.column,
-        },
-    };
-    if (variableName.startsWith('glossary:')) {
-        const term = variableName.slice('glossary:'.length).trim();
-        this.enter({
-            type: NodeTypes.glossary,
-            data: {
-                hName: 'Glossary',
-                hProperties: { term },
-            },
-            children: [{ type: 'text', value: term }],
-            position: nodePosition,
-        }, token);
-        this.exit(token);
-        contextMap.delete(token);
-        return;
+    if (text.startsWith(marker)) {
+        if (marker === '*' && text.startsWith('**'))
+            return null;
+        if (marker === '_' && text.startsWith('__'))
+            return null;
+        return {
+            textAfter: text.slice(marker.length),
+            textBefore: '',
+        };
     }
-    this.enter({
-        type: NodeTypes.variable,
-        data: {
-            hName: 'Variable',
-            hProperties: { name: variableName.trim(), isLegacy: true },
-        },
-        value: `<<${variableName}>>`,
-    }, token);
-    this.exit(token);
-    contextMap.delete(token);
-}
-function legacyVariableFromMarkdown() {
-    return {
-        enter: {
-            legacyVariable: enterlegacyVariable,
-        },
-        exit: {
-            legacyVariableValue: exitlegacyVariableValue,
-            legacyVariable: exitlegacyVariable,
-        },
-    };
+    return null;
 }
-
-;// ./node_modules/micromark-util-symbol/lib/codes.js
 /**
- * Character codes.
- *
- * This module is compiled away!
- *
- * micromark works based on character codes.
- * This module contains constants for the ASCII block and the replacement
- * character.
- * A couple of them are handled in a special way, such as the line endings
- * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
- * tab) and its expansion based on what column it’s at (virtual space),
- * and the end-of-file (eof) character.
- * As values are preprocessed before handling them, the actual characters LF,
- * CR, HT, and NUL (which is present as the replacement character), are
- * guaranteed to not exist.
- *
- * Unicode basic latin block.
+ * Scan children for an opening emphasis marker in a text node.
  */
-const codes = /** @type {const} */ ({
-  carriageReturn: -5,
-  lineFeed: -4,
-  carriageReturnLineFeed: -3,
-  horizontalTab: -2,
-  virtualSpace: -1,
-  eof: null,
-  nul: 0,
-  soh: 1,
-  stx: 2,
-  etx: 3,
-  eot: 4,
-  enq: 5,
-  ack: 6,
-  bel: 7,
-  bs: 8,
-  ht: 9, // `\t`
-  lf: 10, // `\n`
-  vt: 11, // `\v`
-  ff: 12, // `\f`
-  cr: 13, // `\r`
-  so: 14,
-  si: 15,
-  dle: 16,
-  dc1: 17,
-  dc2: 18,
-  dc3: 19,
-  dc4: 20,
-  nak: 21,
-  syn: 22,
-  etb: 23,
-  can: 24,
-  em: 25,
-  sub: 26,
-  esc: 27,
-  fs: 28,
-  gs: 29,
-  rs: 30,
-  us: 31,
-  space: 32,
-  exclamationMark: 33, // `!`
-  quotationMark: 34, // `"`
-  numberSign: 35, // `#`
-  dollarSign: 36, // `$`
-  percentSign: 37, // `%`
-  ampersand: 38, // `&`
-  apostrophe: 39, // `'`
-  leftParenthesis: 40, // `(`
-  rightParenthesis: 41, // `)`
-  asterisk: 42, // `*`
-  plusSign: 43, // `+`
-  comma: 44, // `,`
-  dash: 45, // `-`
-  dot: 46, // `.`
-  slash: 47, // `/`
-  digit0: 48, // `0`
-  digit1: 49, // `1`
-  digit2: 50, // `2`
-  digit3: 51, // `3`
-  digit4: 52, // `4`
-  digit5: 53, // `5`
-  digit6: 54, // `6`
-  digit7: 55, // `7`
-  digit8: 56, // `8`
-  digit9: 57, // `9`
-  colon: 58, // `:`
-  semicolon: 59, // `;`
-  lessThan: 60, // `<`
-  equalsTo: 61, // `=`
-  greaterThan: 62, // `>`
-  questionMark: 63, // `?`
-  atSign: 64, // `@`
-  uppercaseA: 65, // `A`
-  uppercaseB: 66, // `B`
-  uppercaseC: 67, // `C`
-  uppercaseD: 68, // `D`
-  uppercaseE: 69, // `E`
-  uppercaseF: 70, // `F`
-  uppercaseG: 71, // `G`
-  uppercaseH: 72, // `H`
-  uppercaseI: 73, // `I`
-  uppercaseJ: 74, // `J`
-  uppercaseK: 75, // `K`
-  uppercaseL: 76, // `L`
-  uppercaseM: 77, // `M`
-  uppercaseN: 78, // `N`
-  uppercaseO: 79, // `O`
-  uppercaseP: 80, // `P`
-  uppercaseQ: 81, // `Q`
-  uppercaseR: 82, // `R`
-  uppercaseS: 83, // `S`
-  uppercaseT: 84, // `T`
-  uppercaseU: 85, // `U`
-  uppercaseV: 86, // `V`
-  uppercaseW: 87, // `W`
-  uppercaseX: 88, // `X`
-  uppercaseY: 89, // `Y`
-  uppercaseZ: 90, // `Z`
-  leftSquareBracket: 91, // `[`
-  backslash: 92, // `\`
-  rightSquareBracket: 93, // `]`
-  caret: 94, // `^`
-  underscore: 95, // `_`
-  graveAccent: 96, // `` ` ``
-  lowercaseA: 97, // `a`
-  lowercaseB: 98, // `b`
-  lowercaseC: 99, // `c`
-  lowercaseD: 100, // `d`
-  lowercaseE: 101, // `e`
-  lowercaseF: 102, // `f`
-  lowercaseG: 103, // `g`
-  lowercaseH: 104, // `h`
-  lowercaseI: 105, // `i`
-  lowercaseJ: 106, // `j`
-  lowercaseK: 107, // `k`
-  lowercaseL: 108, // `l`
-  lowercaseM: 109, // `m`
-  lowercaseN: 110, // `n`
-  lowercaseO: 111, // `o`
-  lowercaseP: 112, // `p`
-  lowercaseQ: 113, // `q`
-  lowercaseR: 114, // `r`
-  lowercaseS: 115, // `s`
-  lowercaseT: 116, // `t`
-  lowercaseU: 117, // `u`
-  lowercaseV: 118, // `v`
-  lowercaseW: 119, // `w`
-  lowercaseX: 120, // `x`
-  lowercaseY: 121, // `y`
-  lowercaseZ: 122, // `z`
-  leftCurlyBrace: 123, // `{`
-  verticalBar: 124, // `|`
-  rightCurlyBrace: 125, // `}`
-  tilde: 126, // `~`
-  del: 127,
-  // Unicode Specials block.
-  byteOrderMarker: 65_279,
-  // Unicode Specials block.
-  replacementCharacter: 65_533 // `�`
-})
-
-;// ./lib/micromark/legacy-variable/syntax.ts
-
-
-function isAllowedValueChar(code) {
-    return (code !== null &&
-        code !== codes.lessThan &&
-        code !== codes.greaterThan &&
-        !markdownLineEnding(code));
-}
-const legacyVariableConstruct = {
-    name: 'legacyVariable',
-    tokenize,
-};
-function tokenize(effects, ok, nok) {
-    let hasValue = false;
-    const start = (code) => {
-        if (code !== codes.lessThan)
-            return nok(code);
-        effects.enter('legacyVariable');
-        effects.enter('legacyVariableMarkerStart');
-        effects.consume(code); // <
-        return open2;
-    };
-    const open2 = (code) => {
-        if (code !== codes.lessThan)
-            return nok(code);
-        effects.consume(code); // <<
-        effects.exit('legacyVariableMarkerStart');
-        effects.enter('legacyVariableValue');
-        return value;
-    };
-    const value = (code) => {
-        if (code === codes.greaterThan) {
-            if (!hasValue)
-                return nok(code);
-            effects.exit('legacyVariableValue');
-            effects.enter('legacyVariableMarkerEnd');
-            effects.consume(code); // >
-            return close2;
+function findOpeningInChildren(children) {
+    let result = null;
+    children.some((child, idx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findOpeningMarker(child.value);
+        if (found) {
+            result = { idx, opening: found };
+            return true;
         }
-        if (!isAllowedValueChar(code))
-            return nok(code);
-        hasValue = true;
-        effects.consume(code);
-        return value;
-    };
-    const close2 = (code) => {
-        if (code !== codes.greaterThan)
-            return nok(code);
-        effects.consume(code); // >>
-        effects.exit('legacyVariableMarkerEnd');
-        effects.exit('legacyVariable');
-        return ok;
-    };
-    return start;
-}
-function legacyVariable() {
-    return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
-    };
+        return false;
+    });
+    return result;
 }
-
-;// ./lib/micromark/legacy-variable/index.ts
 /**
- * Micromark extension for <<variable>> / <<glossary:term>> inline syntax.
+ * Scan children (after openingIdx) for a closing emphasis marker.
  */
-
-
-;// ./processor/transform/mdxish/mdxish-component-blocks.ts
-
-
-
-
-
-
-const pascalCaseTagPattern = /^<([A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>([\s\S]*)?$/;
-const tagAttributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>]+))?/g;
+function findClosingInChildren(children, openingIdx, marker) {
+    let result = null;
+    children.slice(openingIdx + 1).some((child, relativeIdx) => {
+        if (child.type !== 'text')
+            return false;
+        const found = findEndMarker(child.value, marker);
+        if (found) {
+            result = { closingIdx: openingIdx + 1 + relativeIdx, closing: found };
+            return true;
+        }
+        return false;
+    });
+    return result;
+}
 /**
- * Maximum number of siblings to scan forward when looking for a closing tag
- * to avoid scanning too far and degrading performance
+ * Build the replacement nodes for a matched emphasis pair.
  */
-const MAX_LOOKAHEAD = 30;
-/**
- * Tags that have dedicated transformers and should NOT be handled by this plugin.
- * These components either have special parsing requirements that the generic component
- * block transformer cannot handle correctly, or are inline components that we don't
- * want to convert to mdxJsxFlowElement which is a block level element.
- *
- * Glossary and Anchor are inline components.
- */
-const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', 'Anchor']);
-const inlineMdProcessor = unified()
-    .data('micromarkExtensions', [legacyVariable()])
-    .data('fromMarkdownExtensions', [legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown()])
-    .use(remarkParse)
-    .use(remarkGfm);
-const isClosingTag = (value, tag) => value.trim() === `</${tag}>`;
-/**
- * Parse markdown content into mdast children nodes.
- */
-const parseMdChildren = (value) => {
-    const parsed = inlineMdProcessor.parse(value);
-    return parsed.children || [];
-};
-/**
- * Convert raw attribute string into mdxJsxAttribute entries.
- * Handles both key-value attributes (theme="info") and boolean attributes (empty).
- */
-const parseAttributes = (raw) => {
-    const attributes = [];
-    const attrString = raw.trim();
-    if (!attrString)
-        return attributes;
-    tagAttributePattern.lastIndex = 0;
-    let match = tagAttributePattern.exec(attrString);
-    while (match !== null) {
-        const [, attrName, attrValue] = match;
-        const value = attrValue ? attrValue.replace(/^['"]|['"]$/g, '') : null;
-        attributes.push({ type: 'mdxJsxAttribute', name: attrName, value });
-        match = tagAttributePattern.exec(attrString);
+function buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx }) {
+    const newNodes = [];
+    if (opening.textBefore) {
+        newNodes.push({ type: 'text', value: `${opening.textBefore} ` });
     }
-    return attributes;
-};
-/**
- * Parse an HTML tag string into structured data.
- */
-const parseTag = (value) => {
-    const match = value.match(pascalCaseTagPattern);
-    if (!match)
-        return null;
-    const [, tag, attrString = '', selfClosing = '', contentAfterTag = ''] = match;
-    return {
-        tag,
-        attributes: parseAttributes(attrString),
-        selfClosing: !!selfClosing,
-        contentAfterTag,
-    };
-};
-/**
- * Parse substring content of a node and update the parent's children to include the new nodes.
- */
-const parseSibling = (stack, parent, index, sibling) => {
-    const siblingNodes = parseMdChildren(sibling);
-    // 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);
+    const emphasisChildren = [];
+    const openingText = opening.textAfter.replace(/^\s+/, '');
+    if (openingText) {
+        emphasisChildren.push({ type: 'text', value: openingText });
     }
-};
-/**
- * Create an MdxJsxFlowElement node from component data.
- */
-const createComponentNode = ({ tag, attributes, children, startPosition, endPosition }) => ({
-    type: 'mdxJsxFlowElement',
-    name: tag,
-    attributes,
-    children,
-    position: {
-        start: startPosition?.start,
-        end: endPosition?.end ?? startPosition?.end,
-    },
-});
+    container.children.slice(openingIdx + 1, closingIdx).forEach(child => {
+        emphasisChildren.push(child);
+    });
+    const closingText = closing.textBefore.replace(/\s+$/, '');
+    if (closingText) {
+        emphasisChildren.push({ type: 'text', value: closingText });
+    }
+    if (emphasisChildren.length > 0) {
+        const emphasisNode = opening.isBold
+            ? { type: 'strong', children: emphasisChildren }
+            : { type: 'emphasis', children: emphasisChildren };
+        newNodes.push(emphasisNode);
+    }
+    if (closing.textAfter) {
+        newNodes.push({ type: 'text', value: closing.textAfter });
+    }
+    return newNodes;
+}
 /**
- * Remove a closing tag from a paragraph's children and return the updated paragraph.
+ * Find and transform one multi-node emphasis pair in the container.
+ * Returns true if a pair was found and transformed, false otherwise.
  */
-const stripClosingTagFromParagraph = (node, tag) => {
-    if (!Array.isArray(node.children))
-        return { paragraph: node, found: false };
-    const children = [...node.children];
-    const closingIndex = children.findIndex(child => child.type === 'html' && isClosingTag(child.value || '', tag));
-    if (closingIndex === -1)
-        return { paragraph: node, found: false };
-    children.splice(closingIndex, 1);
-    return { paragraph: { ...node, children }, found: true };
-};
+function processOneEmphasisPair(container) {
+    const openingResult = findOpeningInChildren(container.children);
+    if (!openingResult)
+        return false;
+    const { idx: openingIdx, opening } = openingResult;
+    const closingResult = findClosingInChildren(container.children, openingIdx, opening.marker);
+    if (!closingResult)
+        return false;
+    const { closingIdx, closing } = closingResult;
+    const newNodes = buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx });
+    const deleteCount = closingIdx - openingIdx + 1;
+    container.children.splice(openingIdx, deleteCount, ...newNodes);
+    return true;
+}
 /**
- * Scan forward through siblings to find a closing tag.
- * Handles:
- * - Exact match HTML siblings (e.g., `</Tag>`)
- * - HTML siblings with embedded closing tag (e.g., `...\n</Tag>`)
- * - Paragraph siblings containing the closing tag as a child
- *
- * Returns null if not found within MAX_LOOKAHEAD siblings
+ * Handle malformed emphasis that spans multiple AST nodes.
+ * E.g., "**bold [link](url)**" where markers are in different text nodes.
  */
-const scanForClosingTag = (parent, startIndex, tag) => {
-    const closingTagStr = `</${tag}>`;
-    const maxIndex = Math.min(startIndex + MAX_LOOKAHEAD, parent.children.length);
-    let i = startIndex + 1;
-    for (; i < maxIndex; i += 1) {
-        const sibling = parent.children[i];
-        // Check HTML siblings
-        if (sibling.type === 'html') {
-            const siblingValue = sibling.value || '';
-            // Exact match (standalone closing tag)
-            if (isClosingTag(siblingValue, tag)) {
-                return { closingIndex: i, extraClosingChildren: [] };
-            }
-            // Embedded closing tag (closing tag within HTML block content)
-            if (siblingValue.includes(closingTagStr)) {
-                const closeTagPos = siblingValue.indexOf(closingTagStr);
-                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
-                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
-                const extraChildren = contentBeforeClose
-                    ? parseMdChildren(contentBeforeClose)
-                    : [];
-                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
-            }
-        }
-        // Check paragraph siblings
-        if (sibling.type === 'paragraph') {
-            const { paragraph, found } = stripClosingTagFromParagraph(sibling, tag);
-            if (found) {
-                return { closingIndex: i, extraClosingChildren: [], strippedParagraph: paragraph };
-            }
+function visitMultiNodeEmphasis(tree) {
+    const containerTypes = ['paragraph', 'heading', 'tableCell', 'listItem', 'blockquote'];
+    visit(tree, node => {
+        if (!containerTypes.includes(node.type))
+            return;
+        if (!('children' in node) || !Array.isArray(node.children))
+            return;
+        const container = node;
+        let foundPair = true;
+        while (foundPair) {
+            foundPair = processOneEmphasisPair(container);
         }
-    }
-    if (i < parent.children.length) {
-        // eslint-disable-next-line no-console
-        console.warn(`Closing tag </${tag}> not found within ${MAX_LOOKAHEAD} siblings, stopping scan`);
-    }
-    return null;
-};
-const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
-    parent.children.splice(index, 1, mdxNode);
-};
+    });
+}
 /**
- * Transform PascalCase HTML nodes into mdxJsxFlowElement nodes.
- *
- * Remark parses unknown/custom component tags as raw HTML nodes.
- * These are the custom readme MDX syntax for components.
- * 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.
- * Though for some tags, we need to handle them specially
- *
- * ## Supported HTML Structures
- *
- * ### 1. Self-closing tags
- * ```
- * <Component />
- * ```
- * Parsed as: `html: "<Component />"`
- *
- * ### 2. Self-contained blocks (entire component in single HTML node)
- * ```
- * <Button>Click me</Button>
- * ```
- * ```
- * <Component>
- *   <h2>Title</h2>
- *   <p>Content</p>
- * </Component>
- * ```
- * Parsed as: `html: "<Component>\n  <h2>Title</h2>\n  <p>Content</p>\n</Component>"`
- * The opening tag, content, and closing tag are all captured in one HTML node.
- *
- * ### 3. Multi-sibling components (closing tag in a following sibling)
- * Handles various structures where the closing tag is in a later sibling, such as:
- *
- * #### 3a. Block components (closing tag in sibling paragraph)
- * ```
- * <Callout>
- * Some **markdown** content
- * </Callout>
- * ```
- *
- * #### 3b. Multi-paragraph components (closing tag several siblings away)
- * ```
- * <Callout>
- *
- * First paragraph
- *
- * Second paragraph
- * </Callout>
- * ```
+ * A remark plugin that normalizes malformed bold and italic markers in text nodes.
+ * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
+ * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
+ * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
  *
- * #### 3c. Nested components split by blank lines (closing tag embedded in HTML sibling)
- * ```
- * <Outer>
- *   <Inner>content</Inner>
+ * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
+ * Also supports snake_case content like `** some_snake_case**`.
  *
- *   <Inner>content</Inner>
- * </Outer>
- * ```
+ * This runs after remark-parse, which (in v11+) is strict and doesn't parse
+ * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
  */
-const mdxishComponentBlocks = () => tree => {
-    const stack = [tree];
-    const processChildNode = (parent, index) => {
-        const node = parent.children[index];
-        if (!node)
-            return;
-        if ('children' in node && Array.isArray(node.children)) {
-            stack.push(node);
+const normalizeEmphasisAST = () => (tree) => {
+    visit(tree, 'text', function visitor(node, index, parent) {
+        if (index === undefined || !parent)
+            return undefined;
+        // Skip if inside code blocks or inline code
+        if (parent.type === 'inlineCode' || parent.type === 'code') {
+            return undefined;
         }
-        // Only visit HTML nodes with an actual html tag,
-        // which means a potential unparsed MDX component
-        const value = node.value;
-        if (node.type !== 'html' || typeof value !== 'string')
-            return;
-        const parsed = parseTag(value.trim());
-        if (!parsed)
-            return;
-        const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
-        // Skip tags that have dedicated transformers
-        if (EXCLUDED_TAGS.has(tag))
-            return;
-        const closingTagStr = `</${tag}>`;
-        // Case 1: Self-closing tag
-        if (selfClosing) {
-            const componentNode = createComponentNode({
-                tag,
-                attributes,
-                children: [],
-                startPosition: node.position,
-            });
-            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);
+        const text = node.value;
+        const allMatches = [];
+        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '**', match });
+        });
+        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, marker: '__', match });
+        });
+        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '*', match });
+        });
+        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '_', match });
+        });
+        [...text.matchAll(intrawordUnderscoreBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '__', match });
+        });
+        [...text.matchAll(intrawordAsteriskItalicRegex)].forEach(match => {
+            allMatches.push({ isBold: false, isIntraword: true, marker: '*', match });
+        });
+        [...text.matchAll(intrawordAsteriskBoldRegex)].forEach(match => {
+            allMatches.push({ isBold: true, isIntraword: true, marker: '**', match });
+        });
+        if (allMatches.length === 0)
+            return undefined;
+        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
+        const filteredMatches = [];
+        let lastEnd = 0;
+        allMatches.forEach(info => {
+            const start = info.match.index ?? 0;
+            const end = start + info.match[0].length;
+            if (start >= lastEnd) {
+                filteredMatches.push(info);
+                lastEnd = end;
             }
-            return;
-        }
-        // Case 2: Self-contained block (closing tag in content)
-        if (contentAfterTag.includes(closingTagStr)) {
-            // Find the first closing tag
-            const closingTagIndex = contentAfterTag.indexOf(closingTagStr);
-            const componentInnerContent = contentAfterTag.substring(0, closingTagIndex).trim();
-            const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
-            const componentNode = createComponentNode({
-                tag,
-                attributes,
-                children: componentInnerContent ? parseMdChildren(componentInnerContent) : [],
-                startPosition: node.position,
-            });
-            substituteNodeWithMdxNode(parent, index, componentNode);
-            // After the closing tag, there might be more content to be processed
-            if (contentAfterClose) {
-                parseSibling(stack, parent, index, contentAfterClose);
+        });
+        if (filteredMatches.length === 0)
+            return undefined;
+        const parts = [];
+        let lastIndex = 0;
+        filteredMatches.forEach(({ isBold, isIntraword, marker, match }) => {
+            const matchIndex = match.index ?? 0;
+            const fullMatch = match[0];
+            if (isIntraword) {
+                // handles cases like hello_world_ where we only want to italicize 'world'
+                const charBefore = match[1] || ''; // e.g., "l" in "hello_world_"
+                const content = match[2]; // e.g., "world"
+                const combinedBefore = text.slice(lastIndex, matchIndex) + charBefore;
+                if (combinedBefore) {
+                    parts.push({ type: 'text', value: combinedBefore });
+                }
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                lastIndex = matchIndex + fullMatch.length;
+                return;
             }
-            else if (componentNode.children.length > 0) {
-                // The content inside the component block might contain new components to be processed
-                stack.push(componentNode);
+            if (matchIndex > lastIndex) {
+                const beforeText = text.slice(lastIndex, matchIndex);
+                if (beforeText) {
+                    parts.push({ type: 'text', value: beforeText });
+                }
             }
-            return;
-        }
-        // Case 3: Multi-sibling component (closing tag in a following sibling)
-        // Scans forward through siblings to find closing tag in HTML or paragraph nodes
-        const scanResult = scanForClosingTag(parent, index, tag);
-        if (!scanResult)
-            return;
-        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
-        const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
-        // Collect all intermediate siblings between opening tag and closing tag
-        const intermediateChildren = parent.children.slice(index + 1, closingIndex);
-        // For paragraph siblings, include the paragraph's children (with closing tag stripped)
-        // For HTML siblings, include any content parsed from before the closing tag
-        const closingChildren = strippedParagraph
-            ? strippedParagraph.children
-            : extraClosingChildren;
-        const componentNode = createComponentNode({
-            tag,
-            attributes,
-            children: [...extraChildren, ...intermediateChildren, ...closingChildren],
-            startPosition: node.position,
-            endPosition: parent.children[closingIndex]?.position,
+            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
+            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
+            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
+            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
+            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
+            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
+            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
+            const afterChar = match[7]; // Character after closing markers (if any)
+            const markerPos = fullMatch.indexOf(marker);
+            const spacesBeforeMarkers = wordBefore
+                ? fullMatch.slice(wordBefore.length, markerPos)
+                : fullMatch.slice(0, markerPos);
+            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
+            if (wordBefore) {
+                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
+                parts.push({ type: 'text', value: wordBefore + spacing });
+            }
+            else if (spacesBeforeMarkers) {
+                parts.push({ type: 'text', value: spacesBeforeMarkers });
+            }
+            if (content) {
+                if (isBold) {
+                    parts.push({
+                        type: 'strong',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+                else {
+                    parts.push({
+                        type: 'emphasis',
+                        children: [{ type: 'text', value: content }],
+                    });
+                }
+            }
+            if (afterChar) {
+                const prefix = trailingSpace ? ' ' : '';
+                parts.push({ type: 'text', value: prefix + afterChar });
+            }
+            lastIndex = matchIndex + fullMatch.length;
         });
-        // Remove all nodes from opening tag to closing tag (inclusive) and replace with component node
-        parent.children.splice(index, closingIndex - index + 1, componentNode);
-        // Since we might be merging sibling nodes together and combining content,
-        // there might be new components to process
-        if (componentNode.children.length > 0) {
-            stack.push(componentNode);
-        }
-        // If the closing tag sibling had content after it (e.g., another component opening tag),
-        // re-insert it as a sibling so it can be processed in subsequent iterations
-        if (remainingAfterClose) {
-            parseSibling(stack, parent, index, remainingAfterClose);
+        if (lastIndex < text.length) {
+            const remainingText = text.slice(lastIndex);
+            if (remainingText) {
+                parts.push({ type: 'text', value: remainingText });
+            }
         }
-    };
-    // Process the nodes with the components depth-first to maintain the correct order of the nodes
-    while (stack.length) {
-        const parent = stack.pop();
-        if (parent?.children) {
-            parent.children.forEach((_child, index) => {
-                processChildNode(parent, index);
-            });
+        if (parts.length > 0) {
+            parent.children.splice(index, 1, ...parts);
+            return [SKIP, index + parts.length];
         }
-    }
+        return undefined;
+    });
+    // Handle malformed emphasis spanning multiple nodes (e.g., **text [link](url) **)
+    visitMultiNodeEmphasis(tree);
     return tree;
 };
-/* harmony default export */ const mdxish_component_blocks = (mdxishComponentBlocks);
+/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
 
 ;// ./processor/transform/mdxish/mdxish-tables.ts
 
@@ -71495,14 +71258,21 @@ const mdxishComponentBlocks = () => tree => {
 
 
 
+
+
+
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
 const tableTypes = {
     tr: 'tableRow',
     th: 'tableCell',
     td: 'tableCell',
 };
-const mdCellProcessor = unified().use(remarkParse).use(remarkGfm);
-const tableNodeProcessor = unified().use(remarkParse).use(remarkMdx).use(mdxish_component_blocks);
+const tableNodeProcessor = unified()
+    .use(remarkParse)
+    .use(remarkMdx)
+    .use(normalize_malformed_md_syntax)
+    .use([callouts, gemoji_])
+    .use(remarkGfm);
 /**
  * Check if children are only text nodes that might contain markdown
  */
@@ -71532,14 +71302,14 @@ const extractTextFromChildren = (children) => {
         .join('');
 };
 /**
- * Parse markdown text into MDAST nodes
+ * Returns true if any node in the array is block-level (non-phrasing) content.
  */
-const parseMarkdown = (text) => {
-    const tree = mdCellProcessor.runSync(mdCellProcessor.parse(text));
-    return (tree.children || []);
+const hasFlowContent = (nodes) => {
+    return nodes.some(node => !phrasing(node) && node.type !== 'paragraph');
 };
 /**
- * Process a Table node (either MDX JSX element or parsed from HTML) and convert to markdown table
+ * Process a Table node: re-parse text-only cell content, then output as
+ * a markdown table (phrasing-only) or keep as JSX <Table> (has flow content).
  */
 const processTableNode = (node, index, parent) => {
     if (node.name !== 'Table')
@@ -71547,54 +71317,88 @@ const processTableNode = (node, index, parent) => {
     const { position } = node;
     const { align: alignAttr } = getAttrs(node);
     const align = Array.isArray(alignAttr) ? alignAttr : null;
-    const children = [];
-    // Process rows from thead and tbody
-    // The structure is: Table -> thead/tbody -> tr -> td/th
-    const processRow = (row) => {
-        const rowChildren = [];
-        visit(row, isTableCell, ({ name, children: cellChildren, position: cellPosition }) => {
-            let parsedChildren = cellChildren;
-            // If cell contains only text nodes, try to re-parse as markdown
-            if (isTextOnly(cellChildren)) {
-                const textContent = extractTextFromChildren(cellChildren);
-                if (textContent.trim()) {
-                    try {
-                        const parsed = parseMarkdown(textContent);
-                        // If parsing produced nodes, use them; otherwise keep original
-                        if (parsed.length > 0) {
-                            // Flatten paragraphs if they contain only phrasing content
-                            parsedChildren = parsed.flatMap(parsedNode => {
-                                if (parsedNode.type === 'paragraph' && 'children' in parsedNode && parsedNode.children) {
-                                    return parsedNode.children;
-                                }
-                                return [parsedNode];
-                            });
-                        }
-                    }
-                    catch {
-                        // If parsing fails, keep original children
-                    }
+    let tableHasFlowContent = false;
+    // Re-parse text-only cells through markdown and detect flow content
+    visit(node, isTableCell, (cell) => {
+        if (!isTextOnly(cell.children))
+            return;
+        const textContent = extractTextFromChildren(cell.children);
+        if (!textContent.trim())
+            return;
+        // Since now we are using remarkMdx, which can fail and error, we need to
+        // gate this behind a try/catch to ensure that malformed syntaxes do not
+        // crash the page
+        try {
+            const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(textContent));
+            if (parsed.children.length > 0) {
+                cell.children = parsed.children;
+                if (hasFlowContent(parsed.children)) {
+                    tableHasFlowContent = true;
                 }
             }
-            rowChildren.push({
-                type: tableTypes[name],
-                children: parsedChildren,
-                position: cellPosition,
-            });
-        });
-        children.push({
-            type: tableTypes[row.name],
-            children: rowChildren,
-            position: row.position,
+        }
+        catch {
+            // If parsing fails, keep original children
+        }
+    });
+    // mdast's table node always treats the first tableRow as <thead>, so we can't
+    // represent a header-less table in mdast without the first body row getting
+    // promoted. Keep as JSX instead so remarkRehype renders it correctly
+    let hasThead = false;
+    visit(node, isMDXElement, (child) => {
+        if (child.name === 'thead')
+            hasThead = true;
+    });
+    if (tableHasFlowContent || !hasThead) {
+        // remarkMdx wraps inline elements in paragraph nodes (e.g. <td> on the
+        // same line as content becomes mdxJsxTextElement inside a paragraph).
+        // Unwrap these so <td>/<th> sit directly under <tr>, and strip
+        // whitespace-only text nodes to avoid rendering empty <p>/<br>.
+        const cleanChildren = (children) => children
+            .flatMap(child => {
+            if (child.type === 'paragraph' && 'children' in child && Array.isArray(child.children)) {
+                return child.children;
+            }
+            return [child];
+        })
+            .filter(child => !(child.type === 'text' && 'value' in child && typeof child.value === 'string' && !child.value.trim()));
+        visit(node, isMDXElement, (el) => {
+            if ('children' in el && Array.isArray(el.children)) {
+                el.children = cleanChildren(el.children);
+            }
         });
-    };
-    // Visit thead and tbody, then find tr elements within them
+        parent.children[index] = {
+            ...node,
+            position,
+        };
+        return;
+    }
+    // All cells are phrasing-only — convert to markdown table
+    const children = [];
     visit(node, isMDXElement, (child) => {
         if (child.name === 'thead' || child.name === 'tbody') {
             visit(child, isMDXElement, (row) => {
-                if (row.name === 'tr' && row.type === 'mdxJsxFlowElement') {
-                    processRow(row);
-                }
+                if (row.name !== 'tr')
+                    return;
+                const rowChildren = [];
+                visit(row, isTableCell, ({ name, children: cellChildren, position: cellPosition }) => {
+                    const parsedChildren = cellChildren.flatMap(parsedNode => {
+                        if (parsedNode.type === 'paragraph' && 'children' in parsedNode && parsedNode.children) {
+                            return parsedNode.children;
+                        }
+                        return [parsedNode];
+                    });
+                    rowChildren.push({
+                        type: tableTypes[name],
+                        children: parsedChildren,
+                        position: cellPosition,
+                    });
+                });
+                children.push({
+                    type: 'tableRow',
+                    children: rowChildren,
+                    position: row.position,
+                });
             });
         }
     });
@@ -71614,54 +71418,35 @@ const processTableNode = (node, index, parent) => {
 /**
  * Converts JSX Table elements to markdown table nodes and re-parses markdown in cells.
  *
- * Since mdxish doesn't use remarkMdx, we manually parse cell contents through
- * remarkParse and remarkGfm to convert markdown to MDAST nodes.
+ * The jsxTable micromark tokenizer captures `<Table>...</Table>` as a single html node,
+ * preventing CommonMark HTML block type 6 from fragmenting it at blank lines. This
+ * transformer then re-parses the html node with remarkMdx to produce proper JSX AST nodes
+ * and converts them to MDAST table/tableRow/tableCell nodes.
+ *
+ * When cell content contains block-level nodes (callouts, code blocks, etc.), the table
+ * is kept as a JSX <Table> element so that remarkRehype can properly handle the flow content.
  */
 const mdxishTables = () => tree => {
-    // First, handle MDX JSX elements (already converted by mdxishComponentBlocks)
-    visit(tree, isMDXElement, (node, index, parent) => {
-        if (node.name === 'Table') {
-            processTableNode(node, index, parent);
-            return SKIP;
-        }
-    });
-    // Also handle HTML and raw nodes that contain Table tags (in case mdxishComponentBlocks didn't convert them)
-    // This happens when the entire <Table>...</Table> block is in a single HTML node, which mdxishComponentBlocks
-    // doesn't handle (it only handles split nodes: opening tag, content paragraph, closing tag)
-    const handleTableInNode = (node, index, parent) => {
+    visit(tree, 'html', (_node, index, parent) => {
+        const node = _node;
         if (typeof index !== 'number' || !parent || !('children' in parent))
             return;
-        if (typeof node.value !== 'string')
-            return;
-        if (!node.value.includes('<Table') || !node.value.includes('</Table>'))
+        if (!node.value.startsWith('<Table'))
             return;
         try {
-            // Parse the HTML content with remarkMdx and mdxishComponentBlocks to convert it to MDX JSX elements
-            // This creates a proper AST that we can then process
             const parsed = tableNodeProcessor.runSync(tableNodeProcessor.parse(node.value));
-            // Find the Table element in the parsed result and process it
             visit(parsed, isMDXElement, (tableNode) => {
                 if (tableNode.name === 'Table') {
-                    // Process the table and replace the HTML node with a markdown table node
                     processTableNode(tableNode, index, parent);
+                    // Stop after the outermost Table so nested Tables don't overwrite parent.children[index]
+                    // we let it get handled naturally
+                    return EXIT;
                 }
             });
         }
         catch {
             // If parsing fails, leave the node as-is
         }
-    };
-    // Handle HTML nodes (created by remark-parse for HTML blocks)
-    visit(tree, 'html', (node, index, parent) => {
-        if (typeof index === 'number' && parent && 'children' in parent) {
-            handleTableInNode(node, index, parent);
-        }
-    });
-    // Handle raw nodes (created by remark-parse for certain HTML structures)
-    visit(tree, 'raw', (node, index, parent) => {
-        if (typeof index === 'number' && parent && 'children' in parent) {
-            handleTableInNode(node, index, parent);
-        }
     });
     return tree;
 };
@@ -92157,10 +91942,6 @@ 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/variable.ts
-const variable = (node) => `{user.${node.data?.hProperties?.name || ''}}`;
-/* harmony default export */ const compile_variable = (variable);
-
 ;// ./processor/compile/index.ts
 
 
@@ -94284,10 +94065,14 @@ function extractBalancedBraces(content, start) {
     return { content: content.slice(start, pos - 1), end: pos };
 }
 /**
- * Escapes unbalanced braces in content to prevent MDX expression parsing errors.
- * Handles: already-escaped braces, string literals inside expressions, nested balanced braces.
+ * Escapes problematic braces in content to prevent MDX expression parsing errors.
+ * Handles three cases:
+ * 1. Unbalanced braces (e.g., `{foo` without closing `}`)
+ * 2. Paragraph-spanning expressions (e.g., `{\n\n}` where blank line splits paragraphs)
+ * 3. Skips HTML elements to prevent backslashes appearing in output
+ *
  */
-function escapeUnbalancedBraces(content) {
+function escapeProblematicBraces(content) {
     // Skip HTML elements — their content should never be escaped because
     // rehypeRaw parses them into hast elements, making `\` literal text in output
     const htmlElements = [];
@@ -94296,16 +94081,19 @@ function escapeUnbalancedBraces(content) {
         htmlElements.push(match);
         return `___HTML_ELEM_${idx}___`;
     });
-    const opens = [];
-    const unbalanced = new Set();
-    let strDelim = null;
-    let strEscaped = false;
+    const toEscape = new Set();
     // Convert to array of Unicode code points to handle emojis and multi-byte characters correctly
     const chars = Array.from(safe);
+    let strDelim = null;
+    let strEscaped = false;
+    // Stack of open braces with their state
+    const openStack = [];
+    // Track position of last newline (outside strings) to detect blank lines
+    let lastNewlinePos = -2; // -2 means no recent newline
     for (let i = 0; i < chars.length; i += 1) {
         const ch = chars[i];
-        // Track strings inside expressions to ignore braces within them
-        if (opens.length > 0) {
+        // Track string delimiters inside expressions to ignore braces within them
+        if (openStack.length > 0) {
             if (strDelim) {
                 if (strEscaped)
                     strEscaped = false;
@@ -94321,6 +94109,20 @@ function escapeUnbalancedBraces(content) {
                 // eslint-disable-next-line no-continue
                 continue;
             }
+            // Track newlines to detect blank lines (paragraph boundaries)
+            if (ch === '\n') {
+                // Check if this newline creates a blank line (only whitespace since last newline)
+                if (lastNewlinePos >= 0) {
+                    const between = chars.slice(lastNewlinePos + 1, i).join('');
+                    if (/^[ \t]*$/.test(between)) {
+                        // This is a blank line - mark all open expressions as paragraph-spanning
+                        openStack.forEach(entry => {
+                            entry.hasBlankLine = true;
+                        });
+                    }
+                }
+                lastNewlinePos = i;
+            }
         }
         // Skip already-escaped braces (count preceding backslashes)
         if (ch === '{' || ch === '}') {
@@ -94332,21 +94134,33 @@ function escapeUnbalancedBraces(content) {
                 continue;
             }
         }
-        if (ch === '{')
-            opens.push(i);
+        if (ch === '{') {
+            openStack.push({ pos: i, hasBlankLine: false });
+            lastNewlinePos = -2; // Reset newline tracking for new expression
+        }
         else if (ch === '}') {
-            if (opens.length > 0)
-                opens.pop();
-            else
-                unbalanced.add(i);
+            if (openStack.length > 0) {
+                const entry = openStack.pop();
+                // If expression spans paragraph boundary, escape both braces
+                if (entry.hasBlankLine) {
+                    toEscape.add(entry.pos);
+                    toEscape.add(i);
+                }
+            }
+            else {
+                // Unbalanced closing brace (no matching open)
+                toEscape.add(i);
+            }
         }
     }
-    opens.forEach(pos => unbalanced.add(pos));
-    // If there are no unbalanced braces, return content as-is;
-    // otherwise, escape each unbalanced `{` or `}` so MDX doesn't treat them as expressions.
-    let result = unbalanced.size === 0
+    // Any remaining open braces are unbalanced
+    openStack.forEach(entry => toEscape.add(entry.pos));
+    // If there are no problematic braces, return safe content as-is;
+    // otherwise, escape each problematic `{` or `}` so MDX doesn't treat them as expressions.
+    let result = toEscape.size === 0
         ? safe
-        : chars.map((ch, i) => (unbalanced.has(i) ? `\\${ch}` : ch)).join('');
+        : chars.map((ch, i) => (toEscape.has(i) ? `\\${ch}` : ch)).join('');
+    // Restore HTML elements
     if (htmlElements.length > 0) {
         result = result.replace(/___HTML_ELEM_(\d+)___/g, (_m, idx) => htmlElements[parseInt(idx, 10)]);
     }
@@ -94444,8 +94258,9 @@ function preprocessJSXExpressions(content, context = {}) {
     // For inline expressions, we use a library to parse the expression & evaluate it later
     // For attribute expressions, it was difficult to use a library to parse them, so do it manually
     processed = evaluateAttributeExpressions(protectedContent, context, protectedCode);
-    // Step 3: Escape unbalanced braces to prevent MDX expression parsing errors
-    processed = escapeUnbalancedBraces(processed);
+    // Step 3: Escape problematic braces to prevent MDX expression parsing errors
+    // This handles both unbalanced braces and paragraph-spanning expressions in one pass
+    processed = escapeProblematicBraces(processed);
     // Step 4: Restore protected code blocks
     processed = restoreCodeBlocks(processed, protectedCode);
     return processed;
@@ -94505,110 +94320,468 @@ const evaluateExpressions = ({ context = {} } = {}) => tree => {
 };
 /* harmony default export */ const evaluate_expressions = (evaluateExpressions);
 
-;// ./processor/transform/mdxish/heading-slugs.ts
+;// ./processor/transform/mdxish/heading-slugs.ts
+
+
+function isHeading(node) {
+    return /^h[1-6]$/.test(node.tagName);
+}
+function textContent(node) {
+    if (node.type === 'text')
+        return node.value;
+    // Process variable nodes by using their variable name for the id generation
+    if (node.type === 'element' && node.tagName === 'variable' && node.properties?.name) {
+        if (node.properties.isLegacy) {
+            return node.properties.name;
+        }
+        return `user.${node.properties.name}`;
+    }
+    if ('children' in node)
+        return node.children.map(textContent).join('');
+    return '';
+}
+/**
+ * Rehype plugin that constructs ids for headings
+ * Id's are used to construct slug anchor links & Table of Contents during rendering
+ * Use the text / nodes that make up the heading to generate the id
+ */
+const generateSlugForHeadings = () => (tree) => {
+    const slugger = new BananaSlug();
+    visit(tree, 'element', (node) => {
+        if (isHeading(node) && !node.properties.id) {
+            const text = node.children.map(textContent).join('');
+            node.properties.id = slugger.slug(text);
+        }
+    });
+    return tree;
+};
+/* harmony default export */ const heading_slugs = (generateSlugForHeadings);
+
+// EXTERNAL MODULE: external "@readme/variable"
+var variable_ = __webpack_require__(8167);
+var variable_default = /*#__PURE__*/__webpack_require__.n(variable_);
+;// ./node_modules/rehype-parse/lib/index.js
+/**
+ * @import {Root} from 'hast'
+ * @import {Options as FromHtmlOptions} from 'hast-util-from-html'
+ * @import {Parser, Processor} from 'unified'
+ */
+
+/**
+ * @typedef {Omit<FromHtmlOptions, 'onerror'> & RehypeParseFields} Options
+ *   Configuration.
+ *
+ * @typedef RehypeParseFields
+ *   Extra fields.
+ * @property {boolean | null | undefined} [emitParseErrors=false]
+ *   Whether to emit parse errors while parsing (default: `false`).
+ *
+ *   > 👉 **Note**: parse errors are currently being added to HTML.
+ *   > Not all errors emitted by parse5 (or us) are specced yet.
+ *   > Some documentation may still be missing.
+ */
+
+
+
+/**
+ * Plugin to add support for parsing from HTML.
+ *
+ * > 👉 **Note**: this is not an XML parser.
+ * > It supports SVG as embedded in HTML.
+ * > It does not support the features available in XML.
+ * > Passing SVG files might break but fragments of modern SVG should be fine.
+ * > Use [`xast-util-from-xml`][xast-util-from-xml] to parse XML.
+ *
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {undefined}
+ *   Nothing.
+ */
+function rehypeParse(options) {
+  /** @type {Processor<Root>} */
+  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
+  const self = this
+  const {emitParseErrors, ...settings} = {...self.data('settings'), ...options}
+
+  self.parser = parser
+
+  /**
+   * @type {Parser<Root>}
+   */
+  function parser(document, file) {
+    return fromHtml(document, {
+      ...settings,
+      onerror: emitParseErrors
+        ? function (message) {
+            if (file.path) {
+              message.name = file.path + ':' + message.name
+              message.file = file.path
+            }
+
+            file.messages.push(message)
+          }
+        : undefined
+    })
+  }
+}
+
+;// ./lib/mdast-util/empty-task-list-item/index.ts
+/**
+ * Normalizes list items that are written as only `[ ]` or `[x]` into GFM task
+ * list items during parse, but only when at least one whitespace character
+ * follows the closing bracket (`]`). This matches legacy behaviour for checkboxes
+ *
+ * The issue is `remark-gfm` does not actually classify these as task items when they have no content
+ * after the checkbox, which leaves them as plain text (`"[ ]"`). So a custom extension is needed to
+ * treat these as task items
+ */
+function exitListItemWithEmptyTaskListItem(token) {
+    const node = this.stack[this.stack.length - 1];
+    if (node &&
+        node.type === 'listItem' &&
+        typeof node.checked !== 'boolean') {
+        const listItem = node;
+        const head = listItem.children[0];
+        if (head && head.type === 'paragraph' && head.children.length === 1) {
+            const text = head.children[0];
+            if (text.type === 'text') {
+                const hasTrailingWhitespace = typeof head.position?.end.offset === 'number' &&
+                    typeof text.position?.end.offset === 'number' &&
+                    head.position.end.offset > text.position.end.offset;
+                if (!hasTrailingWhitespace) {
+                    this.exit(token);
+                    return;
+                }
+                const value = text.value;
+                if (value === '[ ]') {
+                    listItem.checked = false;
+                    head.children = [];
+                }
+                else if (value === '[x]' || value === '[X]') {
+                    listItem.checked = true;
+                    head.children = [];
+                }
+            }
+        }
+    }
+    this.exit(token);
+}
+function emptyTaskListItemFromMarkdown() {
+    return {
+        exit: {
+            listItem: exitListItemWithEmptyTaskListItem,
+        },
+    };
+}
+
+;// ./lib/mdast-util/legacy-variable/index.ts
+
+const contextMap = new WeakMap();
+function findlegacyVariableToken() {
+    // tokenStack is micromark's current open token ancestry; find the nearest legacyVariable token.
+    const events = this.tokenStack;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const token = events[i][0];
+        if (token.type === 'legacyVariable')
+            return token;
+    }
+    return undefined;
+}
+function enterlegacyVariable(token) {
+    contextMap.set(token, { value: '' });
+}
+function exitlegacyVariableValue(token) {
+    const variableToken = findlegacyVariableToken.call(this);
+    if (!variableToken)
+        return;
+    const ctx = contextMap.get(variableToken);
+    // Build up the variable characters
+    if (ctx)
+        ctx.value += this.sliceSerialize(token);
+}
+function exitlegacyVariable(token) {
+    const ctx = contextMap.get(token);
+    const serialized = this.sliceSerialize(token);
+    const variableName = serialized.startsWith('<<') && serialized.endsWith('>>')
+        ? serialized.slice(2, -2)
+        : ctx?.value ?? '';
+    const nodePosition = {
+        start: {
+            offset: token.start.offset,
+            line: token.start.line,
+            column: token.start.column,
+        },
+        end: {
+            offset: token.end.offset,
+            line: token.end.line,
+            column: token.end.column,
+        },
+    };
+    if (variableName.startsWith('glossary:')) {
+        const term = variableName.slice('glossary:'.length).trim();
+        this.enter({
+            type: NodeTypes.glossary,
+            data: {
+                hName: 'Glossary',
+                hProperties: { term },
+            },
+            children: [{ type: 'text', value: term }],
+            position: nodePosition,
+        }, token);
+        this.exit(token);
+        contextMap.delete(token);
+        return;
+    }
+    this.enter({
+        type: NodeTypes.variable,
+        data: {
+            hName: 'Variable',
+            hProperties: { name: variableName.trim(), isLegacy: true },
+        },
+        value: `<<${variableName}>>`,
+    }, token);
+    this.exit(token);
+    contextMap.delete(token);
+}
+function legacyVariableFromMarkdown() {
+    return {
+        enter: {
+            legacyVariable: enterlegacyVariable,
+        },
+        exit: {
+            legacyVariableValue: exitlegacyVariableValue,
+            legacyVariable: exitlegacyVariable,
+        },
+    };
+}
+
+;// ./node_modules/micromark-util-symbol/lib/codes.js
+/**
+ * Character codes.
+ *
+ * This module is compiled away!
+ *
+ * micromark works based on character codes.
+ * This module contains constants for the ASCII block and the replacement
+ * character.
+ * A couple of them are handled in a special way, such as the line endings
+ * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
+ * tab) and its expansion based on what column it’s at (virtual space),
+ * and the end-of-file (eof) character.
+ * As values are preprocessed before handling them, the actual characters LF,
+ * CR, HT, and NUL (which is present as the replacement character), are
+ * guaranteed to not exist.
+ *
+ * Unicode basic latin block.
+ */
+const codes = /** @type {const} */ ({
+  carriageReturn: -5,
+  lineFeed: -4,
+  carriageReturnLineFeed: -3,
+  horizontalTab: -2,
+  virtualSpace: -1,
+  eof: null,
+  nul: 0,
+  soh: 1,
+  stx: 2,
+  etx: 3,
+  eot: 4,
+  enq: 5,
+  ack: 6,
+  bel: 7,
+  bs: 8,
+  ht: 9, // `\t`
+  lf: 10, // `\n`
+  vt: 11, // `\v`
+  ff: 12, // `\f`
+  cr: 13, // `\r`
+  so: 14,
+  si: 15,
+  dle: 16,
+  dc1: 17,
+  dc2: 18,
+  dc3: 19,
+  dc4: 20,
+  nak: 21,
+  syn: 22,
+  etb: 23,
+  can: 24,
+  em: 25,
+  sub: 26,
+  esc: 27,
+  fs: 28,
+  gs: 29,
+  rs: 30,
+  us: 31,
+  space: 32,
+  exclamationMark: 33, // `!`
+  quotationMark: 34, // `"`
+  numberSign: 35, // `#`
+  dollarSign: 36, // `$`
+  percentSign: 37, // `%`
+  ampersand: 38, // `&`
+  apostrophe: 39, // `'`
+  leftParenthesis: 40, // `(`
+  rightParenthesis: 41, // `)`
+  asterisk: 42, // `*`
+  plusSign: 43, // `+`
+  comma: 44, // `,`
+  dash: 45, // `-`
+  dot: 46, // `.`
+  slash: 47, // `/`
+  digit0: 48, // `0`
+  digit1: 49, // `1`
+  digit2: 50, // `2`
+  digit3: 51, // `3`
+  digit4: 52, // `4`
+  digit5: 53, // `5`
+  digit6: 54, // `6`
+  digit7: 55, // `7`
+  digit8: 56, // `8`
+  digit9: 57, // `9`
+  colon: 58, // `:`
+  semicolon: 59, // `;`
+  lessThan: 60, // `<`
+  equalsTo: 61, // `=`
+  greaterThan: 62, // `>`
+  questionMark: 63, // `?`
+  atSign: 64, // `@`
+  uppercaseA: 65, // `A`
+  uppercaseB: 66, // `B`
+  uppercaseC: 67, // `C`
+  uppercaseD: 68, // `D`
+  uppercaseE: 69, // `E`
+  uppercaseF: 70, // `F`
+  uppercaseG: 71, // `G`
+  uppercaseH: 72, // `H`
+  uppercaseI: 73, // `I`
+  uppercaseJ: 74, // `J`
+  uppercaseK: 75, // `K`
+  uppercaseL: 76, // `L`
+  uppercaseM: 77, // `M`
+  uppercaseN: 78, // `N`
+  uppercaseO: 79, // `O`
+  uppercaseP: 80, // `P`
+  uppercaseQ: 81, // `Q`
+  uppercaseR: 82, // `R`
+  uppercaseS: 83, // `S`
+  uppercaseT: 84, // `T`
+  uppercaseU: 85, // `U`
+  uppercaseV: 86, // `V`
+  uppercaseW: 87, // `W`
+  uppercaseX: 88, // `X`
+  uppercaseY: 89, // `Y`
+  uppercaseZ: 90, // `Z`
+  leftSquareBracket: 91, // `[`
+  backslash: 92, // `\`
+  rightSquareBracket: 93, // `]`
+  caret: 94, // `^`
+  underscore: 95, // `_`
+  graveAccent: 96, // `` ` ``
+  lowercaseA: 97, // `a`
+  lowercaseB: 98, // `b`
+  lowercaseC: 99, // `c`
+  lowercaseD: 100, // `d`
+  lowercaseE: 101, // `e`
+  lowercaseF: 102, // `f`
+  lowercaseG: 103, // `g`
+  lowercaseH: 104, // `h`
+  lowercaseI: 105, // `i`
+  lowercaseJ: 106, // `j`
+  lowercaseK: 107, // `k`
+  lowercaseL: 108, // `l`
+  lowercaseM: 109, // `m`
+  lowercaseN: 110, // `n`
+  lowercaseO: 111, // `o`
+  lowercaseP: 112, // `p`
+  lowercaseQ: 113, // `q`
+  lowercaseR: 114, // `r`
+  lowercaseS: 115, // `s`
+  lowercaseT: 116, // `t`
+  lowercaseU: 117, // `u`
+  lowercaseV: 118, // `v`
+  lowercaseW: 119, // `w`
+  lowercaseX: 120, // `x`
+  lowercaseY: 121, // `y`
+  lowercaseZ: 122, // `z`
+  leftCurlyBrace: 123, // `{`
+  verticalBar: 124, // `|`
+  rightCurlyBrace: 125, // `}`
+  tilde: 126, // `~`
+  del: 127,
+  // Unicode Specials block.
+  byteOrderMarker: 65_279,
+  // Unicode Specials block.
+  replacementCharacter: 65_533 // `�`
+})
+
+;// ./lib/micromark/legacy-variable/syntax.ts
 
 
-function isHeading(node) {
-    return /^h[1-6]$/.test(node.tagName);
+function isAllowedValueChar(code) {
+    return (code !== null &&
+        code !== codes.lessThan &&
+        code !== codes.greaterThan &&
+        !markdownLineEnding(code));
 }
-function textContent(node) {
-    if (node.type === 'text')
-        return node.value;
-    // Process variable nodes by using their variable name for the id generation
-    if (node.type === 'element' && node.tagName === 'variable' && node.properties?.name) {
-        if (node.properties.isLegacy) {
-            return node.properties.name;
+const legacyVariableConstruct = {
+    name: 'legacyVariable',
+    tokenize,
+};
+function tokenize(effects, ok, nok) {
+    let hasValue = false;
+    const start = (code) => {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.enter('legacyVariable');
+        effects.enter('legacyVariableMarkerStart');
+        effects.consume(code); // <
+        return open2;
+    };
+    const open2 = (code) => {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.consume(code); // <<
+        effects.exit('legacyVariableMarkerStart');
+        effects.enter('legacyVariableValue');
+        return value;
+    };
+    const value = (code) => {
+        if (code === codes.greaterThan) {
+            if (!hasValue)
+                return nok(code);
+            effects.exit('legacyVariableValue');
+            effects.enter('legacyVariableMarkerEnd');
+            effects.consume(code); // >
+            return close2;
         }
-        return `user.${node.properties.name}`;
-    }
-    if ('children' in node)
-        return node.children.map(textContent).join('');
-    return '';
+        if (!isAllowedValueChar(code))
+            return nok(code);
+        hasValue = true;
+        effects.consume(code);
+        return value;
+    };
+    const close2 = (code) => {
+        if (code !== codes.greaterThan)
+            return nok(code);
+        effects.consume(code); // >>
+        effects.exit('legacyVariableMarkerEnd');
+        effects.exit('legacyVariable');
+        return ok;
+    };
+    return start;
+}
+function legacyVariable() {
+    return {
+        text: { [codes.lessThan]: legacyVariableConstruct },
+    };
 }
-/**
- * Rehype plugin that constructs ids for headings
- * Id's are used to construct slug anchor links & Table of Contents during rendering
- * Use the text / nodes that make up the heading to generate the id
- */
-const generateSlugForHeadings = () => (tree) => {
-    const slugger = new BananaSlug();
-    visit(tree, 'element', (node) => {
-        if (isHeading(node) && !node.properties.id) {
-            const text = node.children.map(textContent).join('');
-            node.properties.id = slugger.slug(text);
-        }
-    });
-    return tree;
-};
-/* harmony default export */ const heading_slugs = (generateSlugForHeadings);
-
-// EXTERNAL MODULE: external "@readme/variable"
-var variable_ = __webpack_require__(8167);
-var variable_default = /*#__PURE__*/__webpack_require__.n(variable_);
-;// ./node_modules/rehype-parse/lib/index.js
-/**
- * @import {Root} from 'hast'
- * @import {Options as FromHtmlOptions} from 'hast-util-from-html'
- * @import {Parser, Processor} from 'unified'
- */
-
-/**
- * @typedef {Omit<FromHtmlOptions, 'onerror'> & RehypeParseFields} Options
- *   Configuration.
- *
- * @typedef RehypeParseFields
- *   Extra fields.
- * @property {boolean | null | undefined} [emitParseErrors=false]
- *   Whether to emit parse errors while parsing (default: `false`).
- *
- *   > 👉 **Note**: parse errors are currently being added to HTML.
- *   > Not all errors emitted by parse5 (or us) are specced yet.
- *   > Some documentation may still be missing.
- */
-
-
 
+;// ./lib/micromark/legacy-variable/index.ts
 /**
- * Plugin to add support for parsing from HTML.
- *
- * > 👉 **Note**: this is not an XML parser.
- * > It supports SVG as embedded in HTML.
- * > It does not support the features available in XML.
- * > Passing SVG files might break but fragments of modern SVG should be fine.
- * > Use [`xast-util-from-xml`][xast-util-from-xml] to parse XML.
- *
- * @param {Options | null | undefined} [options]
- *   Configuration (optional).
- * @returns {undefined}
- *   Nothing.
+ * Micromark extension for <<variable>> / <<glossary:term>> inline syntax.
  */
-function rehypeParse(options) {
-  /** @type {Processor<Root>} */
-  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.
-  const self = this
-  const {emitParseErrors, ...settings} = {...self.data('settings'), ...options}
-
-  self.parser = parser
-
-  /**
-   * @type {Parser<Root>}
-   */
-  function parser(document, file) {
-    return fromHtml(document, {
-      ...settings,
-      onerror: emitParseErrors
-        ? function (message) {
-            if (file.path) {
-              message.name = file.path + ':' + message.name
-              message.file = file.path
-            }
 
-            file.messages.push(message)
-          }
-        : undefined
-    })
-  }
-}
 
 ;// ./node_modules/entities/lib/esm/generated/encode-html.js
 // Generated using scripts/write-encode-map.ts
@@ -94915,349 +95088,6 @@ function looseHtmlEntityFromMarkdown() {
  */
 
 
-;// ./processor/transform/mdxish/normalize-malformed-md-syntax.ts
-
-// Marker patterns for multi-node emphasis detection
-const MARKER_PATTERNS = [
-    { isBold: true, marker: '**' },
-    { isBold: true, marker: '__' },
-    { isBold: false, marker: '*' },
-    { isBold: false, marker: '_' },
-];
-// Patterns to detect for bold (** and __) and italic (* and _) syntax:
-// Bold: ** text**, **text **, word** text**, ** text **
-// Italic: * text*, *text *, word* text*, * text *
-// Same patterns for underscore variants
-// We use separate patterns for each marker type to allow this flexibility.
-// Pattern for ** bold **
-// Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
-// trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
-const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
-// Pattern for __ bold __
-const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n])+?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n])+?)(\s+)\2)(\S|$)?/g;
-// Pattern for * italic *
-const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
-// Pattern for _ italic _
-const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+((?:[^_\n]|_(?! ))+?)(\s*)\2|((?:[^_\n]|_(?! ))+?)(\s+)\2)(\S|$)?/g;
-// CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
-// Pattern for intraword _word_ in words like hello_world_
-const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
-// Pattern for intraword __word__ in words like hello__world__
-const intrawordUnderscoreBoldRegex = /(\w)__([a-zA-Z0-9]+)__(?![\w_])/g;
-// Pattern for intraword *word* in words like hello*world*
-const intrawordAsteriskItalicRegex = /(\w)\*(?!\*)([a-zA-Z0-9]+)\*(?![\w*])/g;
-// Pattern for intraword **word** in words like hello**world**
-const intrawordAsteriskBoldRegex = /(\w)\*\*([a-zA-Z0-9]+)\*\*(?![\w*])/g;
-/**
- * Finds opening emphasis marker in a text value.
- * Returns marker info if found, null otherwise.
- */
-function findOpeningMarker(text) {
-    const results = MARKER_PATTERNS.map(({ isBold, marker }) => {
-        if (marker === '*' && text.startsWith('**'))
-            return null;
-        if (marker === '_' && text.startsWith('__'))
-            return null;
-        if (text.startsWith(marker) && text.length > marker.length) {
-            return { isBold, marker, textAfter: text.slice(marker.length), textBefore: '' };
-        }
-        const idx = text.indexOf(marker);
-        if (idx > 0 && !/\s/.test(text[idx - 1])) {
-            if (marker === '*' && text.slice(idx).startsWith('**'))
-                return null;
-            if (marker === '_' && text.slice(idx).startsWith('__'))
-                return null;
-            const after = text.slice(idx + marker.length);
-            if (after.length > 0) {
-                return { isBold, marker, textAfter: after, textBefore: text.slice(0, idx) };
-            }
-        }
-        return null;
-    });
-    return results.find(r => r !== null) ?? null;
-}
-/**
- * Finds the end/closing marker in a text node for multi-node emphasis.
- */
-function findEndMarker(text, marker) {
-    const spacePattern = ` ${marker}`;
-    const spaceIdx = text.indexOf(spacePattern);
-    if (spaceIdx >= 0) {
-        if (marker === '*' && text.slice(spaceIdx + 1).startsWith('**'))
-            return null;
-        if (marker === '_' && text.slice(spaceIdx + 1).startsWith('__'))
-            return null;
-        return {
-            textAfter: text.slice(spaceIdx + spacePattern.length),
-            textBefore: text.slice(0, spaceIdx),
-        };
-    }
-    if (text.startsWith(marker)) {
-        if (marker === '*' && text.startsWith('**'))
-            return null;
-        if (marker === '_' && text.startsWith('__'))
-            return null;
-        return {
-            textAfter: text.slice(marker.length),
-            textBefore: '',
-        };
-    }
-    return null;
-}
-/**
- * Scan children for an opening emphasis marker in a text node.
- */
-function findOpeningInChildren(children) {
-    let result = null;
-    children.some((child, idx) => {
-        if (child.type !== 'text')
-            return false;
-        const found = findOpeningMarker(child.value);
-        if (found) {
-            result = { idx, opening: found };
-            return true;
-        }
-        return false;
-    });
-    return result;
-}
-/**
- * Scan children (after openingIdx) for a closing emphasis marker.
- */
-function findClosingInChildren(children, openingIdx, marker) {
-    let result = null;
-    children.slice(openingIdx + 1).some((child, relativeIdx) => {
-        if (child.type !== 'text')
-            return false;
-        const found = findEndMarker(child.value, marker);
-        if (found) {
-            result = { closingIdx: openingIdx + 1 + relativeIdx, closing: found };
-            return true;
-        }
-        return false;
-    });
-    return result;
-}
-/**
- * Build the replacement nodes for a matched emphasis pair.
- */
-function buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx }) {
-    const newNodes = [];
-    if (opening.textBefore) {
-        newNodes.push({ type: 'text', value: `${opening.textBefore} ` });
-    }
-    const emphasisChildren = [];
-    const openingText = opening.textAfter.replace(/^\s+/, '');
-    if (openingText) {
-        emphasisChildren.push({ type: 'text', value: openingText });
-    }
-    container.children.slice(openingIdx + 1, closingIdx).forEach(child => {
-        emphasisChildren.push(child);
-    });
-    const closingText = closing.textBefore.replace(/\s+$/, '');
-    if (closingText) {
-        emphasisChildren.push({ type: 'text', value: closingText });
-    }
-    if (emphasisChildren.length > 0) {
-        const emphasisNode = opening.isBold
-            ? { type: 'strong', children: emphasisChildren }
-            : { type: 'emphasis', children: emphasisChildren };
-        newNodes.push(emphasisNode);
-    }
-    if (closing.textAfter) {
-        newNodes.push({ type: 'text', value: closing.textAfter });
-    }
-    return newNodes;
-}
-/**
- * Find and transform one multi-node emphasis pair in the container.
- * Returns true if a pair was found and transformed, false otherwise.
- */
-function processOneEmphasisPair(container) {
-    const openingResult = findOpeningInChildren(container.children);
-    if (!openingResult)
-        return false;
-    const { idx: openingIdx, opening } = openingResult;
-    const closingResult = findClosingInChildren(container.children, openingIdx, opening.marker);
-    if (!closingResult)
-        return false;
-    const { closingIdx, closing } = closingResult;
-    const newNodes = buildReplacementNodes(container, { opening, openingIdx, closing, closingIdx });
-    const deleteCount = closingIdx - openingIdx + 1;
-    container.children.splice(openingIdx, deleteCount, ...newNodes);
-    return true;
-}
-/**
- * Handle malformed emphasis that spans multiple AST nodes.
- * E.g., "**bold [link](url)**" where markers are in different text nodes.
- */
-function visitMultiNodeEmphasis(tree) {
-    const containerTypes = ['paragraph', 'heading', 'tableCell', 'listItem', 'blockquote'];
-    visit(tree, node => {
-        if (!containerTypes.includes(node.type))
-            return;
-        if (!('children' in node) || !Array.isArray(node.children))
-            return;
-        const container = node;
-        let foundPair = true;
-        while (foundPair) {
-            foundPair = processOneEmphasisPair(container);
-        }
-    });
-}
-/**
- * A remark plugin that normalizes malformed bold and italic markers in text nodes.
- * Detects patterns like `** bold**`, `Hello** Wrong Bold**`, `__ bold__`, `Hello__ Wrong Bold__`,
- * `* italic*`, `Hello* Wrong Italic*`, `_ italic_`, or `Hello_ Wrong Italic_`
- * and converts them to proper strong/emphasis nodes, matching the behavior of the legacy rdmd engine.
- *
- * Supports both asterisk (`**bold**`, `*italic*`) and underscore (`__bold__`, `_italic_`) syntax.
- * Also supports snake_case content like `** some_snake_case**`.
- *
- * This runs after remark-parse, which (in v11+) is strict and doesn't parse
- * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
- */
-const normalizeEmphasisAST = () => (tree) => {
-    visit(tree, 'text', function visitor(node, index, parent) {
-        if (index === undefined || !parent)
-            return undefined;
-        // Skip if inside code blocks or inline code
-        if (parent.type === 'inlineCode' || parent.type === 'code') {
-            return undefined;
-        }
-        const text = node.value;
-        const allMatches = [];
-        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '**', match });
-        });
-        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '__', match });
-        });
-        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '*', match });
-        });
-        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '_', match });
-        });
-        [...text.matchAll(intrawordUnderscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, isIntraword: true, marker: '_', match });
-        });
-        [...text.matchAll(intrawordUnderscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, isIntraword: true, marker: '__', match });
-        });
-        [...text.matchAll(intrawordAsteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, isIntraword: true, marker: '*', match });
-        });
-        [...text.matchAll(intrawordAsteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, isIntraword: true, marker: '**', match });
-        });
-        if (allMatches.length === 0)
-            return undefined;
-        allMatches.sort((a, b) => (a.match.index ?? 0) - (b.match.index ?? 0));
-        const filteredMatches = [];
-        let lastEnd = 0;
-        allMatches.forEach(info => {
-            const start = info.match.index ?? 0;
-            const end = start + info.match[0].length;
-            if (start >= lastEnd) {
-                filteredMatches.push(info);
-                lastEnd = end;
-            }
-        });
-        if (filteredMatches.length === 0)
-            return undefined;
-        const parts = [];
-        let lastIndex = 0;
-        filteredMatches.forEach(({ isBold, isIntraword, marker, match }) => {
-            const matchIndex = match.index ?? 0;
-            const fullMatch = match[0];
-            if (isIntraword) {
-                // handles cases like hello_world_ where we only want to italicize 'world'
-                const charBefore = match[1] || ''; // e.g., "l" in "hello_world_"
-                const content = match[2]; // e.g., "world"
-                const combinedBefore = text.slice(lastIndex, matchIndex) + charBefore;
-                if (combinedBefore) {
-                    parts.push({ type: 'text', value: combinedBefore });
-                }
-                if (isBold) {
-                    parts.push({
-                        type: 'strong',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-                else {
-                    parts.push({
-                        type: 'emphasis',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-                lastIndex = matchIndex + fullMatch.length;
-                return;
-            }
-            if (matchIndex > lastIndex) {
-                const beforeText = text.slice(lastIndex, matchIndex);
-                if (beforeText) {
-                    parts.push({ type: 'text', value: beforeText });
-                }
-            }
-            const wordBefore = match[1]; // e.g., "Hello" in "Hello** Wrong Bold**"
-            const contentWithSpaceAfter = match[3]; // Content when there's a space after opening markers
-            const trailingSpace1 = match[4] || ''; // Space before closing markers (for "** text **" pattern)
-            const contentWithSpaceBefore = match[5]; // Content when there's only a space before closing markers
-            const trailingSpace2 = match[6] || ''; // Space before closing markers (for "**text **" pattern)
-            const trailingSpace = trailingSpace1 || trailingSpace2; // Combined trailing space
-            const content = (contentWithSpaceAfter || contentWithSpaceBefore || '').trim();
-            const afterChar = match[7]; // Character after closing markers (if any)
-            const markerPos = fullMatch.indexOf(marker);
-            const spacesBeforeMarkers = wordBefore
-                ? fullMatch.slice(wordBefore.length, markerPos)
-                : fullMatch.slice(0, markerPos);
-            const shouldAddSpace = !!contentWithSpaceAfter && !!wordBefore && !spacesBeforeMarkers;
-            if (wordBefore) {
-                const spacing = spacesBeforeMarkers + (shouldAddSpace ? ' ' : '');
-                parts.push({ type: 'text', value: wordBefore + spacing });
-            }
-            else if (spacesBeforeMarkers) {
-                parts.push({ type: 'text', value: spacesBeforeMarkers });
-            }
-            if (content) {
-                if (isBold) {
-                    parts.push({
-                        type: 'strong',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-                else {
-                    parts.push({
-                        type: 'emphasis',
-                        children: [{ type: 'text', value: content }],
-                    });
-                }
-            }
-            if (afterChar) {
-                const prefix = trailingSpace ? ' ' : '';
-                parts.push({ type: 'text', value: prefix + afterChar });
-            }
-            lastIndex = matchIndex + fullMatch.length;
-        });
-        if (lastIndex < text.length) {
-            const remainingText = text.slice(lastIndex);
-            if (remainingText) {
-                parts.push({ type: 'text', value: remainingText });
-            }
-        }
-        if (parts.length > 0) {
-            parent.children.splice(index, 1, ...parts);
-            return [SKIP, index + parts.length];
-        }
-        return undefined;
-    });
-    // Handle malformed emphasis spanning multiple nodes (e.g., **text [link](url) **)
-    visitMultiNodeEmphasis(tree);
-    return tree;
-};
-/* harmony default export */ const normalize_malformed_md_syntax = (normalizeEmphasisAST);
-
 ;// ./processor/transform/mdxish/magic-blocks/patterns.ts
 /** Matches HTML tags (open, close, self-closing) with optional attributes. */
 const HTML_TAG_RE = /<\/?([a-zA-Z][a-zA-Z0-9-]*)((?:[^>"']*(?:"[^"]*"|'[^']*'))*[^>"']*)>/g;
@@ -95875,6 +95705,336 @@ const magicBlockTransformer = (options = {}) => tree => {
 };
 /* harmony default export */ const magic_block_transformer = (magicBlockTransformer);
 
+;// ./processor/transform/mdxish/constants.ts
+/**
+ * Inline component tags handled by mdxish-inline-components.ts.
+ * Also excluded from block-level handling in mdxish-component-blocks.ts.
+ */
+const constants_INLINE_COMPONENT_TAGS = new Set(['Anchor']);
+
+;// ./processor/transform/mdxish/mdxish-component-blocks.ts
+
+
+
+
+
+
+
+const pascalCaseTagPattern = /^<([A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>([\s\S]*)?$/;
+const tagAttributePattern = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>]+))?/g;
+/**
+ * Maximum number of siblings to scan forward when looking for a closing tag
+ * to avoid scanning too far and degrading performance
+ */
+const MAX_LOOKAHEAD = 30;
+/**
+ * Tags that have dedicated transformers and should NOT be handled by this plugin.
+ * These components either have special parsing requirements that the generic component
+ * block transformer cannot handle correctly, or are inline components that we don't
+ * want to convert to mdxJsxFlowElement which is a block level element.
+ */
+const EXCLUDED_TAGS = new Set(['HTMLBlock', 'Table', 'Glossary', ...constants_INLINE_COMPONENT_TAGS]);
+const inlineMdProcessor = unified()
+    .data('micromarkExtensions', [legacyVariable()])
+    .data('fromMarkdownExtensions', [legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown()])
+    .use(remarkParse)
+    .use(remarkGfm);
+const isClosingTag = (value, tag) => value.trim() === `</${tag}>`;
+/**
+ * Parse markdown content into mdast children nodes.
+ */
+const parseMdChildren = (value) => {
+    const parsed = inlineMdProcessor.parse(value);
+    return parsed.children || [];
+};
+/**
+ * Convert raw attribute string into mdxJsxAttribute entries.
+ * Handles both key-value attributes (theme="info") and boolean attributes (empty).
+ */
+const parseAttributes = (raw) => {
+    const attributes = [];
+    const attrString = raw.trim();
+    if (!attrString)
+        return attributes;
+    tagAttributePattern.lastIndex = 0;
+    let match = tagAttributePattern.exec(attrString);
+    while (match !== null) {
+        const [, attrName, attrValue] = match;
+        const value = attrValue ? attrValue.replace(/^['"]|['"]$/g, '') : null;
+        attributes.push({ type: 'mdxJsxAttribute', name: attrName, value });
+        match = tagAttributePattern.exec(attrString);
+    }
+    return attributes;
+};
+/**
+ * Parse an HTML tag string into structured data.
+ */
+const parseTag = (value) => {
+    const match = value.match(pascalCaseTagPattern);
+    if (!match)
+        return null;
+    const [, tag, attrString = '', selfClosing = '', contentAfterTag = ''] = match;
+    return {
+        tag,
+        attributes: parseAttributes(attrString),
+        selfClosing: !!selfClosing,
+        contentAfterTag,
+    };
+};
+/**
+ * Parse substring content of a node and update the parent's children to include the new nodes.
+ */
+const parseSibling = (stack, parent, index, sibling) => {
+    const siblingNodes = parseMdChildren(sibling);
+    // 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);
+    }
+};
+/**
+ * Create an MdxJsxFlowElement node from component data.
+ */
+const createComponentNode = ({ tag, attributes, children, startPosition, endPosition }) => ({
+    type: 'mdxJsxFlowElement',
+    name: tag,
+    attributes,
+    children,
+    position: {
+        start: startPosition?.start,
+        end: endPosition?.end ?? startPosition?.end,
+    },
+});
+/**
+ * Remove a closing tag from a paragraph's children and return the updated paragraph.
+ */
+const stripClosingTagFromParagraph = (node, tag) => {
+    if (!Array.isArray(node.children))
+        return { paragraph: node, found: false };
+    const children = [...node.children];
+    const closingIndex = children.findIndex(child => child.type === 'html' && isClosingTag(child.value || '', tag));
+    if (closingIndex === -1)
+        return { paragraph: node, found: false };
+    children.splice(closingIndex, 1);
+    return { paragraph: { ...node, children }, found: true };
+};
+/**
+ * Scan forward through siblings to find a closing tag.
+ * Handles:
+ * - Exact match HTML siblings (e.g., `</Tag>`)
+ * - HTML siblings with embedded closing tag (e.g., `...\n</Tag>`)
+ * - Paragraph siblings containing the closing tag as a child
+ *
+ * Returns null if not found within MAX_LOOKAHEAD siblings
+ */
+const scanForClosingTag = (parent, startIndex, tag) => {
+    const closingTagStr = `</${tag}>`;
+    const maxIndex = Math.min(startIndex + MAX_LOOKAHEAD, parent.children.length);
+    let i = startIndex + 1;
+    for (; i < maxIndex; i += 1) {
+        const sibling = parent.children[i];
+        // Check HTML siblings
+        if (sibling.type === 'html') {
+            const siblingValue = sibling.value || '';
+            // Exact match (standalone closing tag)
+            if (isClosingTag(siblingValue, tag)) {
+                return { closingIndex: i, extraClosingChildren: [] };
+            }
+            // Embedded closing tag (closing tag within HTML block content)
+            if (siblingValue.includes(closingTagStr)) {
+                const closeTagPos = siblingValue.indexOf(closingTagStr);
+                const contentBeforeClose = siblingValue.substring(0, closeTagPos).trim();
+                const contentAfterClose = siblingValue.substring(closeTagPos + closingTagStr.length).trim();
+                const extraChildren = contentBeforeClose
+                    ? parseMdChildren(contentBeforeClose)
+                    : [];
+                return { closingIndex: i, extraClosingChildren: extraChildren, contentAfterClose: contentAfterClose || undefined };
+            }
+        }
+        // Check paragraph siblings
+        if (sibling.type === 'paragraph') {
+            const { paragraph, found } = stripClosingTagFromParagraph(sibling, tag);
+            if (found) {
+                return { closingIndex: i, extraClosingChildren: [], strippedParagraph: paragraph };
+            }
+        }
+    }
+    if (i < parent.children.length) {
+        // eslint-disable-next-line no-console
+        console.warn(`Closing tag </${tag}> not found within ${MAX_LOOKAHEAD} siblings, stopping scan`);
+    }
+    return null;
+};
+const substituteNodeWithMdxNode = (parent, index, mdxNode) => {
+    parent.children.splice(index, 1, mdxNode);
+};
+/**
+ * Transform PascalCase HTML nodes into mdxJsxFlowElement nodes.
+ *
+ * Remark parses unknown/custom component tags as raw HTML nodes.
+ * These are the custom readme MDX syntax for components.
+ * 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.
+ * Though for some tags, we need to handle them specially
+ *
+ * ## Supported HTML Structures
+ *
+ * ### 1. Self-closing tags
+ * ```
+ * <Component />
+ * ```
+ * Parsed as: `html: "<Component />"`
+ *
+ * ### 2. Self-contained blocks (entire component in single HTML node)
+ * ```
+ * <Button>Click me</Button>
+ * ```
+ * ```
+ * <Component>
+ *   <h2>Title</h2>
+ *   <p>Content</p>
+ * </Component>
+ * ```
+ * Parsed as: `html: "<Component>\n  <h2>Title</h2>\n  <p>Content</p>\n</Component>"`
+ * The opening tag, content, and closing tag are all captured in one HTML node.
+ *
+ * ### 3. Multi-sibling components (closing tag in a following sibling)
+ * Handles various structures where the closing tag is in a later sibling, such as:
+ *
+ * #### 3a. Block components (closing tag in sibling paragraph)
+ * ```
+ * <Callout>
+ * Some **markdown** content
+ * </Callout>
+ * ```
+ *
+ * #### 3b. Multi-paragraph components (closing tag several siblings away)
+ * ```
+ * <Callout>
+ *
+ * First paragraph
+ *
+ * Second paragraph
+ * </Callout>
+ * ```
+ *
+ * #### 3c. Nested components split by blank lines (closing tag embedded in HTML sibling)
+ * ```
+ * <Outer>
+ *   <Inner>content</Inner>
+ *
+ *   <Inner>content</Inner>
+ * </Outer>
+ * ```
+ */
+const mdxishComponentBlocks = () => tree => {
+    const stack = [tree];
+    const processChildNode = (parent, index) => {
+        const node = parent.children[index];
+        if (!node)
+            return;
+        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
+        const value = node.value;
+        if (node.type !== 'html' || typeof value !== 'string')
+            return;
+        const parsed = parseTag(value.trim());
+        if (!parsed)
+            return;
+        const { tag, attributes, selfClosing, contentAfterTag = '' } = parsed;
+        // Skip tags that have dedicated transformers
+        if (EXCLUDED_TAGS.has(tag))
+            return;
+        const closingTagStr = `</${tag}>`;
+        // Case 1: Self-closing tag
+        if (selfClosing) {
+            const componentNode = createComponentNode({
+                tag,
+                attributes,
+                children: [],
+                startPosition: node.position,
+            });
+            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);
+            }
+            return;
+        }
+        // Case 2: Self-contained block (closing tag in content)
+        if (contentAfterTag.includes(closingTagStr)) {
+            // Find the first closing tag
+            const closingTagIndex = contentAfterTag.indexOf(closingTagStr);
+            const componentInnerContent = contentAfterTag.substring(0, closingTagIndex).trim();
+            const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
+            const componentNode = createComponentNode({
+                tag,
+                attributes,
+                children: componentInnerContent ? parseMdChildren(componentInnerContent) : [],
+                startPosition: node.position,
+            });
+            substituteNodeWithMdxNode(parent, index, componentNode);
+            // After the closing tag, there might be more content to be processed
+            if (contentAfterClose) {
+                parseSibling(stack, parent, index, contentAfterClose);
+            }
+            else if (componentNode.children.length > 0) {
+                // The content inside the component block might contain new components to be processed
+                stack.push(componentNode);
+            }
+            return;
+        }
+        // Case 3: Multi-sibling component (closing tag in a following sibling)
+        // Scans forward through siblings to find closing tag in HTML or paragraph nodes
+        const scanResult = scanForClosingTag(parent, index, tag);
+        if (!scanResult)
+            return;
+        const { closingIndex, extraClosingChildren, strippedParagraph, contentAfterClose: remainingAfterClose } = scanResult;
+        const extraChildren = contentAfterTag ? parseMdChildren(contentAfterTag.trimStart()) : [];
+        // Collect all intermediate siblings between opening tag and closing tag
+        const intermediateChildren = parent.children.slice(index + 1, closingIndex);
+        // For paragraph siblings, include the full paragraph (with closing tag stripped)
+        // For HTML siblings, include any content parsed from before the closing tag
+        const closingChildren = strippedParagraph
+            ? (strippedParagraph.children.length > 0 ? [strippedParagraph] : [])
+            : extraClosingChildren;
+        const componentNode = createComponentNode({
+            tag,
+            attributes,
+            children: [...extraChildren, ...intermediateChildren, ...closingChildren],
+            startPosition: node.position,
+            endPosition: parent.children[closingIndex]?.position,
+        });
+        // Remove all nodes from opening tag to closing tag (inclusive) and replace with component node
+        parent.children.splice(index, closingIndex - index + 1, componentNode);
+        // Since we might be merging sibling nodes together and combining content,
+        // there might be new components to process
+        if (componentNode.children.length > 0) {
+            stack.push(componentNode);
+        }
+        // If the closing tag sibling had content after it (e.g., another component opening tag),
+        // re-insert it as a sibling so it can be processed in subsequent iterations
+        if (remainingAfterClose) {
+            parseSibling(stack, parent, index, remainingAfterClose);
+        }
+    };
+    // Process the nodes with the components depth-first to maintain the correct order of the nodes
+    while (stack.length) {
+        const parent = stack.pop();
+        if (parent?.children) {
+            parent.children.forEach((_child, index) => {
+                processChildNode(parent, index);
+            });
+        }
+    }
+    return tree;
+};
+/* harmony default export */ const mdxish_component_blocks = (mdxishComponentBlocks);
+
 ;// ./processor/transform/mdxish/mdxish-html-blocks.ts
 
 
@@ -96210,10 +96370,82 @@ const mdxishHtmlBlocks = () => tree => {
 };
 /* harmony default export */ const mdxish_html_blocks = (mdxishHtmlBlocks);
 
+;// ./processor/transform/mdxish/mdxish-inline-components.ts
+
+
+
+// Matches any PascalCase inline component opening tag. Groups: (name, attrs).
+// Uses [A-Za-z0-9_]* to match block version in mdxish-component-blocks.ts
+const INLINE_COMPONENT_OPEN_RE = /^<([A-Z][A-Za-z0-9_]*)(\s[^>]*)?>$/;
+function toMdxJsxTextElement(name, attributes, children) {
+    return {
+        type: 'mdxJsxTextElement',
+        name,
+        attributes,
+        children,
+    };
+}
+/**
+ * Transforms inline html component nodes (e.g. <Anchor>) into proper MDAST phrasing content.
+ *
+ * Inline components are excluded from mdxishComponentBlocks (which only handles block-level
+ * elements), so they remain as scattered html/text/html sibling nodes inside a paragraph.
+ * This plugin merges them into a single typed MDAST node.
+ */
+const mdxishInlineComponents = () => tree => {
+    visit(tree, 'html', (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        const match = node.value?.match(INLINE_COMPONENT_OPEN_RE);
+        if (!match)
+            return;
+        const [, name, attrStr] = match;
+        if (!constants_INLINE_COMPONENT_TAGS.has(name))
+            return;
+        // Parse attributes directly - preserves all attribute types (strings, booleans, objects, arrays)
+        const attributes = parseAttributes(attrStr ?? '');
+        // Find closing tag with whitespace-tolerant matching
+        let closeIdx = index + 1;
+        while (closeIdx < parent.children.length) {
+            const sib = parent.children[closeIdx];
+            if (sib.type === 'html' && sib.value?.trim() === `</${name}>`)
+                break;
+            closeIdx += 1;
+        }
+        if (closeIdx >= parent.children.length)
+            return;
+        // Extract all nodes between opening tag (index) and closing tag (closeIdx).
+        // These are the inline component's children (e.g., text, emphasis, links).
+        // Example: "<Anchor>click **here**</Anchor>" → children = [text, strong]
+        const children = parent.children.slice(index + 1, closeIdx);
+        const newNode = toMdxJsxTextElement(name, attributes, children);
+        parent.children.splice(index, closeIdx - index + 1, newNode);
+    });
+};
+/* harmony default export */ const mdxish_inline_components = (mdxishInlineComponents);
+
 ;// ./processor/transform/mdxish/mdxish-jsx-to-mdast.ts
 
 
 
+const transformAnchor = (jsx) => {
+    const attrs = getAttrs(jsx);
+    const { href = '', label, target, title } = attrs;
+    return {
+        type: NodeTypes.anchor,
+        children: jsx.children,
+        data: {
+            hName: 'Anchor',
+            hProperties: {
+                href,
+                ...(label && { label }),
+                ...(target && { target }),
+                ...(title && { title }),
+            },
+        },
+        position: jsx.position,
+    };
+};
 const transformImage = (jsx) => {
     const attrs = getAttrs(jsx);
     const { align, alt = '', border, caption, className, height, lazy, src = '', title = '', width } = attrs;
@@ -96267,7 +96499,7 @@ const transformCallout = (jsx) => {
 };
 const transformEmbed = (jsx) => {
     const attrs = getAttrs(jsx);
-    const { favicon, html, iframe, image, providerName, providerUrl, title = '', url = '' } = attrs;
+    const { favicon, height, html, iframe, image, providerName, providerUrl, title = '', typeOfEmbed, url = '', width } = attrs;
     return {
         type: NodeTypes.embedBlock,
         title,
@@ -96278,11 +96510,14 @@ const transformEmbed = (jsx) => {
                 title,
                 url,
                 ...(favicon && { favicon }),
+                ...(height && { height }),
                 ...(html && { html }),
                 ...(iframe !== undefined && { iframe }),
                 ...(image && { image }),
                 ...(providerName && { providerName }),
                 ...(providerUrl && { providerUrl }),
+                ...(typeOfEmbed && { typeOfEmbed }),
+                ...(width && { width }),
             },
         },
         position: jsx.position,
@@ -96378,7 +96613,7 @@ const COMPONENT_MAP = {
  * This is controlled by the `newEditorTypes` flag to maintain backwards compatibility.
  */
 const mdxishJsxToMdast = () => tree => {
-    // Transform JSX components (Image, Callout, Embed, Recipe)
+    // Block JSX components (Image, Callout, Embed, Recipe)
     visit(tree, 'mdxJsxFlowElement', (node, index, parent) => {
         if (!parent || index === undefined || !node.name)
             return;
@@ -96389,6 +96624,15 @@ const mdxishJsxToMdast = () => tree => {
         // Replace the JSX node with the MDAST node
         parent.children[index] = newNode;
     });
+    // Inline JSX components (Anchor)
+    visit(tree, 'mdxJsxTextElement', (node, index, parent) => {
+        if (!parent || index === undefined || !node.name)
+            return;
+        if (node.name === 'Anchor') {
+            const newNode = transformAnchor(node);
+            parent.children[index] = newNode;
+        }
+    });
     // Transform magic block images (type: 'image') to image-block
     // Note: Standard markdown images are wrapped in paragraphs and handled by imageTransformer
     // Magic block images are direct children of root, so we handle them here
@@ -96457,12 +96701,6 @@ const mdxishMermaidTransformer = () => (tree) => {
 };
 /* harmony default export */ const mdxish_mermaid = (mdxishMermaidTransformer);
 
-;// ./lib/constants.ts
-/**
- * Pattern to match component tags (PascalCase or snake_case)
- */
-const componentTagPattern = /<(\/?[A-Z][A-Za-z0-9_]*)([^>]*?)(\/?)>/g;
-
 ;// ./processor/transform/mdxish/mdxish-snake-case-components.ts
 
 
@@ -96898,6 +97136,49 @@ 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() {
+    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: [] });
+    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)
+        ctx.chunks.push(this.sliceSerialize(token));
+}
+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('\n');
+        jsx_table_contextMap.delete(token);
+    }
+    this.exit(token);
+}
+function jsxTableFromMarkdown() {
+    return {
+        enter: {
+            jsxTable: enterJsxTable,
+        },
+        exit: {
+            jsxTableData: exitJsxTableData,
+            jsxTable: exitJsxTable,
+        },
+    };
+}
+
 ;// ./lib/mdast-util/magic-block/index.ts
 const magic_block_contextMap = new WeakMap();
 /**
@@ -97054,6 +97335,685 @@ function magicBlockToMarkdown() {
     };
 }
 
+;// ./node_modules/micromark-util-symbol/lib/types.js
+/**
+ * This module is compiled away!
+ *
+ * Here is the list of all types of tokens exposed by micromark, with a short
+ * explanation of what they include and where they are found.
+ * In picking names, generally, the rule is to be as explicit as possible
+ * instead of reusing names.
+ * For example, there is a `definitionDestination` and a `resourceDestination`,
+ * instead of one shared name.
+ */
+
+// Note: when changing the next record, you must also change `TokenTypeMap`
+// in `micromark-util-types/index.d.ts`.
+const types_types = /** @type {const} */ ({
+  // Generic type for data, such as in a title, a destination, etc.
+  data: 'data',
+
+  // Generic type for syntactic whitespace (tabs, virtual spaces, spaces).
+  // Such as, between a fenced code fence and an info string.
+  whitespace: 'whitespace',
+
+  // Generic type for line endings (line feed, carriage return, carriage return +
+  // line feed).
+  lineEnding: 'lineEnding',
+
+  // A line ending, but ending a blank line.
+  lineEndingBlank: 'lineEndingBlank',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the start of a
+  // line.
+  linePrefix: 'linePrefix',
+
+  // Generic type for whitespace (tabs, virtual spaces, spaces) at the end of a
+  // line.
+  lineSuffix: 'lineSuffix',
+
+  // Whole ATX heading:
+  //
+  // ```markdown
+  // #
+  // ## Alpha
+  // ### Bravo ###
+  // ```
+  //
+  // Includes `atxHeadingSequence`, `whitespace`, `atxHeadingText`.
+  atxHeading: 'atxHeading',
+
+  // Sequence of number signs in an ATX heading (`###`).
+  atxHeadingSequence: 'atxHeadingSequence',
+
+  // Content in an ATX heading (`alpha`).
+  // Includes text.
+  atxHeadingText: 'atxHeadingText',
+
+  // Whole autolink (`<https://example.com>` or `<admin@example.com>`)
+  // Includes `autolinkMarker` and `autolinkProtocol` or `autolinkEmail`.
+  autolink: 'autolink',
+
+  // Email autolink w/o markers (`admin@example.com`)
+  autolinkEmail: 'autolinkEmail',
+
+  // Marker around an `autolinkProtocol` or `autolinkEmail` (`<` or `>`).
+  autolinkMarker: 'autolinkMarker',
+
+  // Protocol autolink w/o markers (`https://example.com`)
+  autolinkProtocol: 'autolinkProtocol',
+
+  // A whole character escape (`\-`).
+  // Includes `escapeMarker` and `characterEscapeValue`.
+  characterEscape: 'characterEscape',
+
+  // The escaped character (`-`).
+  characterEscapeValue: 'characterEscapeValue',
+
+  // A whole character reference (`&amp;`, `&#8800;`, or `&#x1D306;`).
+  // Includes `characterReferenceMarker`, an optional
+  // `characterReferenceMarkerNumeric`, in which case an optional
+  // `characterReferenceMarkerHexadecimal`, and a `characterReferenceValue`.
+  characterReference: 'characterReference',
+
+  // The start or end marker (`&` or `;`).
+  characterReferenceMarker: 'characterReferenceMarker',
+
+  // Mark reference as numeric (`#`).
+  characterReferenceMarkerNumeric: 'characterReferenceMarkerNumeric',
+
+  // Mark reference as numeric (`x` or `X`).
+  characterReferenceMarkerHexadecimal: 'characterReferenceMarkerHexadecimal',
+
+  // Value of character reference w/o markers (`amp`, `8800`, or `1D306`).
+  characterReferenceValue: 'characterReferenceValue',
+
+  // Whole fenced code:
+  //
+  // ````markdown
+  // ```js
+  // alert(1)
+  // ```
+  // ````
+  codeFenced: 'codeFenced',
+
+  // A fenced code fence, including whitespace, sequence, info, and meta
+  // (` ```js `).
+  codeFencedFence: 'codeFencedFence',
+
+  // Sequence of grave accent or tilde characters (` ``` `) in a fence.
+  codeFencedFenceSequence: 'codeFencedFenceSequence',
+
+  // Info word (`js`) in a fence.
+  // Includes string.
+  codeFencedFenceInfo: 'codeFencedFenceInfo',
+
+  // Meta words (`highlight="1"`) in a fence.
+  // Includes string.
+  codeFencedFenceMeta: 'codeFencedFenceMeta',
+
+  // A line of code.
+  codeFlowValue: 'codeFlowValue',
+
+  // Whole indented code:
+  //
+  // ```markdown
+  //     alert(1)
+  // ```
+  //
+  // Includes `lineEnding`, `linePrefix`, and `codeFlowValue`.
+  codeIndented: 'codeIndented',
+
+  // A text code (``` `alpha` ```).
+  // Includes `codeTextSequence`, `codeTextData`, `lineEnding`, and can include
+  // `codeTextPadding`.
+  codeText: 'codeText',
+
+  codeTextData: 'codeTextData',
+
+  // A space or line ending right after or before a tick.
+  codeTextPadding: 'codeTextPadding',
+
+  // A text code fence (` `` `).
+  codeTextSequence: 'codeTextSequence',
+
+  // Whole content:
+  //
+  // ```markdown
+  // [a]: b
+  // c
+  // =
+  // d
+  // ```
+  //
+  // Includes `paragraph` and `definition`.
+  content: 'content',
+  // Whole definition:
+  //
+  // ```markdown
+  // [micromark]: https://github.com/micromark/micromark
+  // ```
+  //
+  // Includes `definitionLabel`, `definitionMarker`, `whitespace`,
+  // `definitionDestination`, and optionally `lineEnding` and `definitionTitle`.
+  definition: 'definition',
+
+  // Destination of a definition (`https://github.com/micromark/micromark` or
+  // `<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteral` or `definitionDestinationRaw`.
+  definitionDestination: 'definitionDestination',
+
+  // Enclosed destination of a definition
+  // (`<https://github.com/micromark/micromark>`).
+  // Includes `definitionDestinationLiteralMarker` and optionally
+  // `definitionDestinationString`.
+  definitionDestinationLiteral: 'definitionDestinationLiteral',
+
+  // Markers of an enclosed definition destination (`<` or `>`).
+  definitionDestinationLiteralMarker: 'definitionDestinationLiteralMarker',
+
+  // Unenclosed destination of a definition
+  // (`https://github.com/micromark/micromark`).
+  // Includes `definitionDestinationString`.
+  definitionDestinationRaw: 'definitionDestinationRaw',
+
+  // Text in an destination (`https://github.com/micromark/micromark`).
+  // Includes string.
+  definitionDestinationString: 'definitionDestinationString',
+
+  // Label of a definition (`[micromark]`).
+  // Includes `definitionLabelMarker` and `definitionLabelString`.
+  definitionLabel: 'definitionLabel',
+
+  // Markers of a definition label (`[` or `]`).
+  definitionLabelMarker: 'definitionLabelMarker',
+
+  // Value of a definition label (`micromark`).
+  // Includes string.
+  definitionLabelString: 'definitionLabelString',
+
+  // Marker between a label and a destination (`:`).
+  definitionMarker: 'definitionMarker',
+
+  // Title of a definition (`"x"`, `'y'`, or `(z)`).
+  // Includes `definitionTitleMarker` and optionally `definitionTitleString`.
+  definitionTitle: 'definitionTitle',
+
+  // Marker around a title of a definition (`"`, `'`, `(`, or `)`).
+  definitionTitleMarker: 'definitionTitleMarker',
+
+  // Data without markers in a title (`z`).
+  // Includes string.
+  definitionTitleString: 'definitionTitleString',
+
+  // Emphasis (`*alpha*`).
+  // Includes `emphasisSequence` and `emphasisText`.
+  emphasis: 'emphasis',
+
+  // Sequence of emphasis markers (`*` or `_`).
+  emphasisSequence: 'emphasisSequence',
+
+  // Emphasis text (`alpha`).
+  // Includes text.
+  emphasisText: 'emphasisText',
+
+  // The character escape marker (`\`).
+  escapeMarker: 'escapeMarker',
+
+  // A hard break created with a backslash (`\\n`).
+  // Note: does not include the line ending.
+  hardBreakEscape: 'hardBreakEscape',
+
+  // A hard break created with trailing spaces (`  \n`).
+  // Does not include the line ending.
+  hardBreakTrailing: 'hardBreakTrailing',
+
+  // Flow HTML:
+  //
+  // ```markdown
+  // <div
+  // ```
+  //
+  // Inlcudes `lineEnding`, `htmlFlowData`.
+  htmlFlow: 'htmlFlow',
+
+  htmlFlowData: 'htmlFlowData',
+
+  // HTML in text (the tag in `a <i> b`).
+  // Includes `lineEnding`, `htmlTextData`.
+  htmlText: 'htmlText',
+
+  htmlTextData: 'htmlTextData',
+
+  // Whole image (`![alpha](bravo)`, `![alpha][bravo]`, `![alpha][]`, or
+  // `![alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  image: 'image',
+
+  // Whole link label (`[*alpha*]`).
+  // Includes `labelLink` or `labelImage`, `labelText`, and `labelEnd`.
+  label: 'label',
+
+  // Text in an label (`*alpha*`).
+  // Includes text.
+  labelText: 'labelText',
+
+  // Start a link label (`[`).
+  // Includes a `labelMarker`.
+  labelLink: 'labelLink',
+
+  // Start an image label (`![`).
+  // Includes `labelImageMarker` and `labelMarker`.
+  labelImage: 'labelImage',
+
+  // Marker of a label (`[` or `]`).
+  labelMarker: 'labelMarker',
+
+  // Marker to start an image (`!`).
+  labelImageMarker: 'labelImageMarker',
+
+  // End a label (`]`).
+  // Includes `labelMarker`.
+  labelEnd: 'labelEnd',
+
+  // Whole link (`[alpha](bravo)`, `[alpha][bravo]`, `[alpha][]`, or `[alpha]`).
+  // Includes `label` and an optional `resource` or `reference`.
+  link: 'link',
+
+  // Whole paragraph:
+  //
+  // ```markdown
+  // alpha
+  // bravo.
+  // ```
+  //
+  // Includes text.
+  paragraph: 'paragraph',
+
+  // A reference (`[alpha]` or `[]`).
+  // Includes `referenceMarker` and an optional `referenceString`.
+  reference: 'reference',
+
+  // A reference marker (`[` or `]`).
+  referenceMarker: 'referenceMarker',
+
+  // Reference text (`alpha`).
+  // Includes string.
+  referenceString: 'referenceString',
+
+  // A resource (`(https://example.com "alpha")`).
+  // Includes `resourceMarker`, an optional `resourceDestination` with an optional
+  // `whitespace` and `resourceTitle`.
+  resource: 'resource',
+
+  // A resource destination (`https://example.com`).
+  // Includes `resourceDestinationLiteral` or `resourceDestinationRaw`.
+  resourceDestination: 'resourceDestination',
+
+  // A literal resource destination (`<https://example.com>`).
+  // Includes `resourceDestinationLiteralMarker` and optionally
+  // `resourceDestinationString`.
+  resourceDestinationLiteral: 'resourceDestinationLiteral',
+
+  // A resource destination marker (`<` or `>`).
+  resourceDestinationLiteralMarker: 'resourceDestinationLiteralMarker',
+
+  // A raw resource destination (`https://example.com`).
+  // Includes `resourceDestinationString`.
+  resourceDestinationRaw: 'resourceDestinationRaw',
+
+  // Resource destination text (`https://example.com`).
+  // Includes string.
+  resourceDestinationString: 'resourceDestinationString',
+
+  // A resource marker (`(` or `)`).
+  resourceMarker: 'resourceMarker',
+
+  // A resource title (`"alpha"`, `'alpha'`, or `(alpha)`).
+  // Includes `resourceTitleMarker` and optionally `resourceTitleString`.
+  resourceTitle: 'resourceTitle',
+
+  // A resource title marker (`"`, `'`, `(`, or `)`).
+  resourceTitleMarker: 'resourceTitleMarker',
+
+  // Resource destination title (`alpha`).
+  // Includes string.
+  resourceTitleString: 'resourceTitleString',
+
+  // Whole setext heading:
+  //
+  // ```markdown
+  // alpha
+  // bravo
+  // =====
+  // ```
+  //
+  // Includes `setextHeadingText`, `lineEnding`, `linePrefix`, and
+  // `setextHeadingLine`.
+  setextHeading: 'setextHeading',
+
+  // Content in a setext heading (`alpha\nbravo`).
+  // Includes text.
+  setextHeadingText: 'setextHeadingText',
+
+  // Underline in a setext heading, including whitespace suffix (`==`).
+  // Includes `setextHeadingLineSequence`.
+  setextHeadingLine: 'setextHeadingLine',
+
+  // Sequence of equals or dash characters in underline in a setext heading (`-`).
+  setextHeadingLineSequence: 'setextHeadingLineSequence',
+
+  // Strong (`**alpha**`).
+  // Includes `strongSequence` and `strongText`.
+  strong: 'strong',
+
+  // Sequence of strong markers (`**` or `__`).
+  strongSequence: 'strongSequence',
+
+  // Strong text (`alpha`).
+  // Includes text.
+  strongText: 'strongText',
+
+  // Whole thematic break:
+  //
+  // ```markdown
+  // * * *
+  // ```
+  //
+  // Includes `thematicBreakSequence` and `whitespace`.
+  thematicBreak: 'thematicBreak',
+
+  // A sequence of one or more thematic break markers (`***`).
+  thematicBreakSequence: 'thematicBreakSequence',
+
+  // Whole block quote:
+  //
+  // ```markdown
+  // > a
+  // >
+  // > b
+  // ```
+  //
+  // Includes `blockQuotePrefix` and flow.
+  blockQuote: 'blockQuote',
+  // The `>` or `> ` of a block quote.
+  blockQuotePrefix: 'blockQuotePrefix',
+  // The `>` of a block quote prefix.
+  blockQuoteMarker: 'blockQuoteMarker',
+  // The optional ` ` of a block quote prefix.
+  blockQuotePrefixWhitespace: 'blockQuotePrefixWhitespace',
+
+  // Whole ordered list:
+  //
+  // ```markdown
+  // 1. a
+  //    b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listOrdered: 'listOrdered',
+
+  // Whole unordered list:
+  //
+  // ```markdown
+  // - a
+  //   b
+  // ```
+  //
+  // Includes `listItemPrefix`, flow, and optionally  `listItemIndent` on further
+  // lines.
+  listUnordered: 'listUnordered',
+
+  // The indent of further list item lines.
+  listItemIndent: 'listItemIndent',
+
+  // A marker, as in, `*`, `+`, `-`, `.`, or `)`.
+  listItemMarker: 'listItemMarker',
+
+  // The thing that starts a list item, such as `1. `.
+  // Includes `listItemValue` if ordered, `listItemMarker`, and
+  // `listItemPrefixWhitespace` (unless followed by a line ending).
+  listItemPrefix: 'listItemPrefix',
+
+  // The whitespace after a marker.
+  listItemPrefixWhitespace: 'listItemPrefixWhitespace',
+
+  // The numerical value of an ordered item.
+  listItemValue: 'listItemValue',
+
+  // Internal types used for subtokenizers, compiled away
+  chunkDocument: 'chunkDocument',
+  chunkContent: 'chunkContent',
+  chunkFlow: 'chunkFlow',
+  chunkText: 'chunkText',
+  chunkString: 'chunkString'
+})
+
+;// ./lib/micromark/jsx-table/syntax.ts
+
+
+const syntax_nonLazyContinuationStart = {
+    tokenize: syntax_tokenizeNonLazyContinuationStart,
+    partial: true,
+};
+function resolveToJsxTable(events) {
+    let index = events.length;
+    while (index > 0) {
+        index -= 1;
+        if (events[index][0] === 'enter' && events[index][1].type === 'jsxTable') {
+            break;
+        }
+    }
+    if (index > 1 && events[index - 2][1].type === types_types.linePrefix) {
+        events[index][1].start = events[index - 2][1].start;
+        events[index + 1][1].start = events[index - 2][1].start;
+        events.splice(index - 2, 2);
+    }
+    return events;
+}
+const jsxTableConstruct = {
+    name: 'jsxTable',
+    tokenize: tokenizeJsxTable,
+    resolveTo: resolveToJsxTable,
+    concrete: true,
+};
+function tokenizeJsxTable(effects, ok, nok) {
+    let codeSpanOpenSize = 0;
+    let codeSpanCloseSize = 0;
+    let depth = 1;
+    const TABLE_NAME = [codes.uppercaseT, codes.lowercaseA, codes.lowercaseB, codes.lowercaseL, codes.lowercaseE];
+    const ABLE_SUFFIX = TABLE_NAME.slice(1);
+    /** Build a state chain that matches a sequence of character codes. */
+    function matchChars(chars, onMatch, onFail) {
+        if (chars.length === 0)
+            return onMatch;
+        return ((code) => {
+            if (code === chars[0]) {
+                effects.consume(code);
+                return matchChars(chars.slice(1), onMatch, onFail);
+            }
+            return onFail(code);
+        });
+    }
+    return start;
+    function start(code) {
+        if (code !== codes.lessThan)
+            return nok(code);
+        effects.enter('jsxTable');
+        effects.enter('jsxTableData');
+        effects.consume(code);
+        return matchChars(TABLE_NAME, afterTagName, nok);
+    }
+    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 matchChars(TABLE_NAME, closeGt, body);
+        }
+        if (code === codes.uppercaseT) {
+            effects.consume(code);
+            return matchChars(ABLE_SUFFIX, openAfterTagName, 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>` as a single flow block.
+ *
+ * Prevents CommonMark HTML block type 6 from matching `<Table>` (case-insensitive
+ * match against `table`) and fragmenting it at blank lines.
+ */
+function jsxTable() {
+    return {
+        flow: {
+            [codes.lessThan]: [jsxTableConstruct],
+        },
+    };
+}
+
+;// ./lib/micromark/jsx-table/index.ts
+
+
 ;// ./lib/micromark/magic-block/syntax.ts
 
 
@@ -97980,6 +98940,9 @@ function loadComponents() {
 
 
 
+
+
+
 
 
 
@@ -98028,11 +98991,11 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     };
     const processor = unified()
         .data('micromarkExtensions', safeMode
-        ? [magicBlock(), legacyVariable(), looseHtmlEntity()]
-        : [magicBlock(), mdxExprTextOnly, legacyVariable(), looseHtmlEntity()])
+        ? [jsxTable(), magicBlock(), legacyVariable(), looseHtmlEntity()]
+        : [jsxTable(), magicBlock(), mdxExprTextOnly, legacyVariable(), looseHtmlEntity()])
         .data('fromMarkdownExtensions', safeMode
-        ? [magicBlockFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), looseHtmlEntityFromMarkdown()]
-        : [magicBlockFromMarkdown(), mdxExpressionFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), looseHtmlEntityFromMarkdown()])
+        ? [jsxTableFromMarkdown(), magicBlockFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), looseHtmlEntityFromMarkdown()]
+        : [jsxTableFromMarkdown(), magicBlockFromMarkdown(), mdxExpressionFromMarkdown(), legacyVariableFromMarkdown(), emptyTaskListItemFromMarkdown(), looseHtmlEntityFromMarkdown()])
         .use(remarkParse)
         .use(remarkFrontmatter)
         .use(normalize_malformed_md_syntax)
@@ -98043,7 +99006,9 @@ function mdxishAstProcessor(mdContent, opts = {}) {
         .use(restore_snake_case_component_name, { mapping: snakeCaseMapping })
         .use(mdxish_tables)
         .use(mdxish_html_blocks)
-        .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert JSX elements to MDAST types
+        .use(newEditorTypes ? mdxish_inline_components : undefined) // Merge inline html components (e.g. <Anchor>) into MDAST nodes
+        .use(newEditorTypes ? mdxish_jsx_to_mdast : undefined) // Convert block JSX elements to MDAST types
+        .use(safeMode ? undefined : evaluate_expressions, { context: jsxContext }) // Evaluate MDX expressions using jsxContext
         .use(variables_text) // Parse {user.*} patterns from text nodes
         .use(useTailwind ? transform_tailwind : undefined, { components: tempComponentsMap })
         .use(remarkGfm);
@@ -98650,6 +99615,8 @@ function restoreMagicBlocks(replaced, blocks) {
 
 
 
+
+
 /**
  * Removes Markdown and MDX comments.
  */
@@ -98661,8 +99628,8 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
     // 2. we need to parse JSX comments into mdxTextExpression nodes so that the transformers can pick them up
     if (mdxish) {
         processor
-            .data('micromarkExtensions', [mdxExpression({ allowEmpty: true })])
-            .data('fromMarkdownExtensions', [mdxExpressionFromMarkdown()])
+            .data('micromarkExtensions', [jsxTable(), mdxExpression({ allowEmpty: true })])
+            .data('fromMarkdownExtensions', [jsxTableFromMarkdown(), mdxExpressionFromMarkdown()])
             .data('toMarkdownExtensions', [mdxExpressionToMarkdown()]);
     }
     processor