@readme/markdown 14.13.1 → 14.14.0

package/dist/render-fixture.node.js

@@ -68469,6 +68469,13 @@ const mdast_mdast = (text, opts = {}) => {
  * to parse expressions containing JSX.
  */
 const jsxAcornParser = Parser.extend(acorn_jsx_default()());
+/**
+ * Disables CommonMark's indented-code-block construct (4+ spaces)
+ * The micromark tokenizers use follow the CommonMark specification: https://spec.commonmark.org/0.28/#indented-code-blocks
+ * So any lines indented 4+ spaces are considered as a code block,
+ * which is unexpected from users that used MDX before.
+ */
+const disableIndentedCode = { disable: { null: ['codeIndented'] } };
 /**
  * Evaluate a JavaScript expression source and return its value.
  *
@@ -92197,6 +92204,10 @@ const tailwindPrefix = 'readme-tailwind';
 
 
 const TailwindRoot = ({ children, flow }) => {
+    // `styles/gfm.scss` spaces the wrapped block children through this element and
+    // relies on their margins collapsing through it. Keep it a plain block — no
+    // border, padding, or block formatting context (overflow, display: flow-root/
+    // flex/grid) — or the spacing breaks.
     const Tag = flow ? 'div' : 'span';
     return external_react_default().createElement(Tag, { className: tailwindPrefix }, children);
 };
@@ -112665,185 +112676,70 @@ const hast = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_hast = ((/* unused pure expression or super */ null && (hast)));
 
-;// ./processor/migration/emphasis.ts
-
-const emphasis_strongTest = (node) => ['emphasis', 'strong'].includes(node.type);
-const addSpaceBefore = (index, parent) => {
-    if (!(index > 0 && parent.children[index - 1]))
-        return;
-    const prev = parent.children[index - 1];
-    if (!('value' in prev) || prev.value.endsWith(' ') || prev.type === 'escape')
-        return;
-    parent.children.splice(index, 0, { type: 'text', value: ' ' });
-};
-const addSpaceAfter = (index, parent) => {
-    if (!(index < parent.children.length - 1 && parent.children[index + 1]))
-        return;
-    const nextChild = parent.children[index + 1];
-    if (!('value' in nextChild) || nextChild.value.startsWith(' '))
-        return;
-    parent.children.splice(index + 1, 0, { type: 'text', value: ' ' });
-};
-const trimEmphasis = (node, index, parent) => {
-    let trimmed = false;
-    lib_visit(node, 'text', (child) => {
-        const newValue = child.value.trimStart();
-        if (newValue !== child.value) {
-            trimmed = true;
-            child.value = newValue;
-        }
-        return EXIT;
-    });
-    lib_visit(node, 'text', (child) => {
-        const newValue = child.value.trimEnd();
-        if (newValue !== child.value) {
-            trimmed = true;
-            child.value = newValue;
-        }
-        return EXIT;
-    }, true);
-    if (trimmed) {
-        addSpaceBefore(index, parent);
-        addSpaceAfter(index, parent);
-    }
-};
-const emphasisTransfomer = () => (tree) => {
-    lib_visit(tree, emphasis_strongTest, trimEmphasis);
-    return tree;
-};
-/* harmony default export */ const migration_emphasis = (emphasisTransfomer);
+;// ./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'
+ */
 
-;// ./processor/migration/images.ts
+/**
+ * @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.
+ */
 
-const images_imageTransformer = () => tree => {
-    lib_visit(tree, 'image', (image) => {
-        if (image.data?.hProperties?.className === 'border') {
-            image.data.hProperties.border = true;
-        }
-    });
-};
-/* harmony default export */ const migration_images = (images_imageTransformer);
 
-;// ./processor/migration/linkReference.ts
 
-const linkReferenceTransformer = () => (tree) => {
-    lib_visit(tree, 'linkReference', (node, index, parent) => {
-        const definitions = {};
-        lib_visit(tree, 'definition', (def) => {
-            definitions[def.identifier] = def;
-        });
-        if (node.label === node.identifier && parent) {
-            if (!(node.identifier in definitions)) {
-                parent.children[index] = {
-                    type: 'text',
-                    value: `[${node.label}]`,
-                    position: node.position,
-                };
-            }
-        }
-    });
-    return tree;
-};
-/* harmony default export */ const migration_linkReference = (linkReferenceTransformer);
+/**
+ * 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}
 
-;// ./processor/migration/table-cell.ts
+  self.parser = parser
 
-const magicIndex = (i, j) => `${i === 0 ? 'h' : `${i - 1}`}-${j}`;
-const isInlineHtml = node => node.type === 'html' && !node.block;
-// @note: This regex is detect malformed lists that were created by the
-// markdown editor. Consider the following markdown:
-//
-// ```
-// * item 1
-// * item 2
-// * item 3
-// ```
-//
-// This is a perfectly valid list. But when you put that text into a table
-// cell, the editor does **bad** things. After a save and load cycle, it gets
-// converted to this:
-//
-// ```
-// \_ item 1
-// \_ item 2
-// \* item 3
-// ```
-//
-// The following regex attempts to detect this pattern, and we'll convert it to
-// something more standard.
-const psuedoListRegex = /^(?![ \t]*([*_]+).*\1[ \t]*$)(?<ws>[ \t]*)\\?([*_])\s*(?<item>.*)$/gm;
-const migrateTableCells = (vfile, rdmd) => (table) => {
-    let json;
-    try {
-        const { position } = table;
-        if (position) {
-            json = JSON.parse(vfile
-                .toString()
-                .slice(position.start.offset, position.end.offset)
-                .replace(/.*\[block:parameters\](.*)\[\/block\].*/s, '$1'));
-        }
-    }
-    catch (err) {
-        /**
-         * This failure case is already handled by the following logic. Plus,
-         * because it's being handled internally, there's no way for our
-         * migration script to catch the error or keep track of it, and it just
-         * ends up blowing up the output logs.
-         */
-        // console.error(err);
-    }
-    lib_visit(table, 'tableRow', (row, i) => {
-        lib_visit(row, 'tableCell', (cell, j) => {
-            let children = cell.children;
-            if (json && json.data[magicIndex(i, j)]) {
-                const string = json.data[magicIndex(i, j)].replace(psuedoListRegex, '$<ws>- $<item>');
-                children = rdmd.mdast(string).children;
+  /**
+   * @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
             }
-            cell.children =
-                children.length > 1 && !children.some(isInlineHtml)
-                    ? children
-                    : [{ type: 'paragraph', children }];
-            return lib_SKIP;
-        });
-        return lib_SKIP;
-    });
-    lib_visit(table, 'inlineCode', (code) => {
-        if (code.value.includes('\n')) {
-            code.type = 'code';
-        }
-    });
-};
-function tableCellTransformer() {
-    const rdmd = this.data('rdmd');
-    return (tree, vfile) => {
-        lib_visit(tree, 'table', migrateTableCells(vfile, rdmd));
-        return tree;
-    };
-}
-/* harmony default export */ const table_cell = (tableCellTransformer);
-
-;// ./processor/migration/index.ts
-
-
-
-
-const transformers = [migration_emphasis, migration_images, migration_linkReference, table_cell];
-/* harmony default export */ const migration = ((/* unused pure expression or super */ null && (transformers)));
 
-;// ./lib/mdastV6.ts
-
-const migrationNormalize = (doc) => {
-    return doc.replaceAll(/^(<!--.*?)\\-->$/gms, '$1-->');
-};
-const mdastV6_mdastV6 = (doc, { rdmd }) => {
-    const [_normalizedDoc] = rdmd.setup(doc);
-    const normalizedDoc = migrationNormalize(_normalizedDoc);
-    const proc = rdmd.processor().use(migrationTransformers).data('rdmd', rdmd);
-    const tree = proc.parse(normalizedDoc);
-    proc.runSync(tree, normalizedDoc);
-    return tree;
-};
-/* harmony default export */ const lib_mdastV6 = ((/* unused pure expression or super */ null && (mdastV6_mdastV6)));
+            file.messages.push(message)
+          }
+        : undefined
+    })
+  }
+}
 
 ;// ./node_modules/hast-util-is-element/lib/index.js
 /**
@@ -117370,6 +117266,227 @@ function rehypeRemark(destination, options) {
   }
 }
 
+;// ./lib/htmlToMarkdown.ts
+
+
+
+
+
+/**
+ * Converts an HTML fragment to GitHub-flavored Markdown.
+ *
+ * `remark-gfm` is load-bearing: without it, `<table>` and `<del>` input throws
+ * at serialization. `iframe` (default: becomes a link) and `noscript` (default:
+ * keeps its text) are dropped by the handlers so raw markup never leaks;
+ * `script`, `style`, and `template` already drop by default and are overridden
+ * defensively. HTML comments are dropped via `nodeHandlers`.
+ */
+const processor = lib_unified()
+    .use(rehypeParse, { fragment: true })
+    .use(rehypeRemark, {
+    // A comment is a `comment` node, not an element, so it goes in
+    // `nodeHandlers` rather than `handlers`.
+    handlers: {
+        iframe: () => undefined,
+        noscript: () => undefined,
+        script: () => undefined,
+        style: () => undefined,
+        template: () => undefined,
+    },
+    nodeHandlers: { comment: () => undefined },
+})
+    .use(lib_remarkGfm)
+    .use(lib_remarkStringify, { bullet: '-', emphasis: '_', fences: true });
+/**
+ * Returns the Markdown form of `html`, or an empty string when there is no
+ * usable input. Synchronous, so it can run inside non-async serializers.
+ */
+function htmlToMarkdown(html) {
+    if (typeof html !== 'string' || !html.trim())
+        return '';
+    return processor.processSync(html).toString().trim();
+}
+
+;// ./processor/migration/emphasis.ts
+
+const emphasis_strongTest = (node) => ['emphasis', 'strong'].includes(node.type);
+const addSpaceBefore = (index, parent) => {
+    if (!(index > 0 && parent.children[index - 1]))
+        return;
+    const prev = parent.children[index - 1];
+    if (!('value' in prev) || prev.value.endsWith(' ') || prev.type === 'escape')
+        return;
+    parent.children.splice(index, 0, { type: 'text', value: ' ' });
+};
+const addSpaceAfter = (index, parent) => {
+    if (!(index < parent.children.length - 1 && parent.children[index + 1]))
+        return;
+    const nextChild = parent.children[index + 1];
+    if (!('value' in nextChild) || nextChild.value.startsWith(' '))
+        return;
+    parent.children.splice(index + 1, 0, { type: 'text', value: ' ' });
+};
+const trimEmphasis = (node, index, parent) => {
+    let trimmed = false;
+    lib_visit(node, 'text', (child) => {
+        const newValue = child.value.trimStart();
+        if (newValue !== child.value) {
+            trimmed = true;
+            child.value = newValue;
+        }
+        return EXIT;
+    });
+    lib_visit(node, 'text', (child) => {
+        const newValue = child.value.trimEnd();
+        if (newValue !== child.value) {
+            trimmed = true;
+            child.value = newValue;
+        }
+        return EXIT;
+    }, true);
+    if (trimmed) {
+        addSpaceBefore(index, parent);
+        addSpaceAfter(index, parent);
+    }
+};
+const emphasisTransfomer = () => (tree) => {
+    lib_visit(tree, emphasis_strongTest, trimEmphasis);
+    return tree;
+};
+/* harmony default export */ const migration_emphasis = (emphasisTransfomer);
+
+;// ./processor/migration/images.ts
+
+const images_imageTransformer = () => tree => {
+    lib_visit(tree, 'image', (image) => {
+        if (image.data?.hProperties?.className === 'border') {
+            image.data.hProperties.border = true;
+        }
+    });
+};
+/* harmony default export */ const migration_images = (images_imageTransformer);
+
+;// ./processor/migration/linkReference.ts
+
+const linkReferenceTransformer = () => (tree) => {
+    lib_visit(tree, 'linkReference', (node, index, parent) => {
+        const definitions = {};
+        lib_visit(tree, 'definition', (def) => {
+            definitions[def.identifier] = def;
+        });
+        if (node.label === node.identifier && parent) {
+            if (!(node.identifier in definitions)) {
+                parent.children[index] = {
+                    type: 'text',
+                    value: `[${node.label}]`,
+                    position: node.position,
+                };
+            }
+        }
+    });
+    return tree;
+};
+/* harmony default export */ const migration_linkReference = (linkReferenceTransformer);
+
+;// ./processor/migration/table-cell.ts
+
+const magicIndex = (i, j) => `${i === 0 ? 'h' : `${i - 1}`}-${j}`;
+const isInlineHtml = node => node.type === 'html' && !node.block;
+// @note: This regex is detect malformed lists that were created by the
+// markdown editor. Consider the following markdown:
+//
+// ```
+// * item 1
+// * item 2
+// * item 3
+// ```
+//
+// This is a perfectly valid list. But when you put that text into a table
+// cell, the editor does **bad** things. After a save and load cycle, it gets
+// converted to this:
+//
+// ```
+// \_ item 1
+// \_ item 2
+// \* item 3
+// ```
+//
+// The following regex attempts to detect this pattern, and we'll convert it to
+// something more standard.
+const psuedoListRegex = /^(?![ \t]*([*_]+).*\1[ \t]*$)(?<ws>[ \t]*)\\?([*_])\s*(?<item>.*)$/gm;
+const migrateTableCells = (vfile, rdmd) => (table) => {
+    let json;
+    try {
+        const { position } = table;
+        if (position) {
+            json = JSON.parse(vfile
+                .toString()
+                .slice(position.start.offset, position.end.offset)
+                .replace(/.*\[block:parameters\](.*)\[\/block\].*/s, '$1'));
+        }
+    }
+    catch (err) {
+        /**
+         * This failure case is already handled by the following logic. Plus,
+         * because it's being handled internally, there's no way for our
+         * migration script to catch the error or keep track of it, and it just
+         * ends up blowing up the output logs.
+         */
+        // console.error(err);
+    }
+    lib_visit(table, 'tableRow', (row, i) => {
+        lib_visit(row, 'tableCell', (cell, j) => {
+            let children = cell.children;
+            if (json && json.data[magicIndex(i, j)]) {
+                const string = json.data[magicIndex(i, j)].replace(psuedoListRegex, '$<ws>- $<item>');
+                children = rdmd.mdast(string).children;
+            }
+            cell.children =
+                children.length > 1 && !children.some(isInlineHtml)
+                    ? children
+                    : [{ type: 'paragraph', children }];
+            return lib_SKIP;
+        });
+        return lib_SKIP;
+    });
+    lib_visit(table, 'inlineCode', (code) => {
+        if (code.value.includes('\n')) {
+            code.type = 'code';
+        }
+    });
+};
+function tableCellTransformer() {
+    const rdmd = this.data('rdmd');
+    return (tree, vfile) => {
+        lib_visit(tree, 'table', migrateTableCells(vfile, rdmd));
+        return tree;
+    };
+}
+/* harmony default export */ const table_cell = (tableCellTransformer);
+
+;// ./processor/migration/index.ts
+
+
+
+
+const transformers = [migration_emphasis, migration_images, migration_linkReference, table_cell];
+/* harmony default export */ const migration = ((/* unused pure expression or super */ null && (transformers)));
+
+;// ./lib/mdastV6.ts
+
+const migrationNormalize = (doc) => {
+    return doc.replaceAll(/^(<!--.*?)\\-->$/gms, '$1-->');
+};
+const mdastV6_mdastV6 = (doc, { rdmd }) => {
+    const [_normalizedDoc] = rdmd.setup(doc);
+    const normalizedDoc = migrationNormalize(_normalizedDoc);
+    const proc = rdmd.processor().use(migrationTransformers).data('rdmd', rdmd);
+    const tree = proc.parse(normalizedDoc);
+    proc.runSync(tree, normalizedDoc);
+    return tree;
+};
+/* harmony default export */ const lib_mdastV6 = ((/* unused pure expression or super */ null && (mdastV6_mdastV6)));
+
 ;// ./processor/compile/anchor.ts
 
 
@@ -117862,7 +117979,7 @@ function normalizeProperties(node) {
  * Identifies custom MDX components and recursively parses markdown children.
  * Replaces tagName with PascalCase component name for React component resolution.
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  * @param {Options} options - Configuration options
  * @param {CustomComponents} options.components - Available custom components
  * @param {Function} options.processMarkdown - Function to process markdown content
@@ -120360,6 +120477,13 @@ const htmlFlowTagNames = new Set([...htmlRawNames, ...htmlBlockNames]);
 // blank lines between nested JSX siblings don't fragment the block. Excludes table
 // tags (mdxishTables owns their blank lines) and voids (never close).
 const plainBlockClaimTagNames = new Set([...htmlBlockNames].filter(tag => !HTML_TABLE_STRUCTURE_TAGS.has(tag) && !HTML_VOID_ELEMENTS.has(tag)));
+const foreignContentTags = new Set(FOREIGN_CONTENT_TAGS);
+// Type-7 lowercase tags (a, span, button, and unknown names): CommonMark ends their
+// block at a blank line, fragmenting 4+ column children into indented code. Claimable
+// only in block-wrapper shape (see `blockWrapperOpenerRest`); lookalike openers
+// (`<https://…>`) never find a closer, so their claim retreats cleanly to CommonMark.
+// Voids never close and raw/foreign-content bodies have dedicated owners.
+const isBlockWrapperClaimTagName = (tag) => !htmlFlowTagNames.has(tag) && !HTML_VOID_ELEMENTS.has(tag) && !foreignContentTags.has(tag);
 // Both are 4 columns per CommonMark, but they mean different things: a tab advances
 // to the next multiple of TAB_STOP_WIDTH, and INDENTED_CODE_MIN_COLUMNS is the depth
 // at which a line would fragment into indented code. Named separately so the two
@@ -120424,6 +120548,11 @@ function createTokenize(mode) {
         // `plainClaimLineStart`: after a blank line it may only continue on a tag line.
         let isPlainBlockClaim = false;
         let pendingBlankLine = false;
+        // Type-7 tag claimed pending the block-wrapper (opener alone on its line) check.
+        let pendingBlockWrapperClaim = false;
+        // True once a block-wrapper claim is confirmed; relaxes the top-of-body island gate
+        // below (type-7 fallback is the fragmentation bug, not intentional indented code).
+        let isBlockWrapperClaim = false;
         // Leading indent columns of the current plain-claim line, reset per line; ≥4 is
         // where CommonMark would fragment the island as indented code. Tabs advance to the
         // next 4-column stop — the same rule `expandIndentToColumns`
@@ -120669,16 +120798,11 @@ function createTokenize(mode) {
             }
             // End of opening tag
             if (code === codes.greaterThan) {
-                if (requiresBraceAttr && !sawBraceAttr) {
-                    // Plain lowercase block tags stay claimable in flow, gated per line by
-                    // `plainClaimLineStart`; everything else falls through to CommonMark.
-                    if (!isFlow || !plainBlockClaimTagNames.has(tagName))
-                        return nok(code);
-                    isPlainBlockClaim = true;
-                }
+                if (requiresBraceAttr && !sawBraceAttr && !claimBraceLessTag())
+                    return nok(code);
                 effects.consume(code);
                 onOpenerLine = isFlow;
-                return body;
+                return pendingBlockWrapperClaim ? blockWrapperOpenerRest : body;
             }
             // Quoted attribute value
             if (code === codes.quotationMark || code === codes.apostrophe) {
@@ -120733,6 +120857,35 @@ function createTokenize(mode) {
             // `/ ` without `>` is just part of the attribute area
             return afterOpenTagName(code);
         }
+        // Whether a brace-less lowercase flow tag is claimable: type-6 tags immediately,
+        // type-7 tags pending the block-wrapper check; anything else is CommonMark's.
+        function claimBraceLessTag() {
+            if (!isFlow)
+                return false;
+            if (plainBlockClaimTagNames.has(tagName)) {
+                isPlainBlockClaim = true;
+                return true;
+            }
+            if (isBlockWrapperClaimTagName(tagName)) {
+                pendingBlockWrapperClaim = true;
+                return true;
+            }
+            return false;
+        }
+        // A type-7 tag is claimed only as a block wrapper: opener alone on its line
+        // (trailing spaces ok). Inline content after the opener bails to CommonMark.
+        function blockWrapperOpenerRest(code) {
+            if (markdownSpace(code)) {
+                effects.consume(code);
+                return blockWrapperOpenerRest;
+            }
+            if (!markdownLineEnding(code))
+                return nok(code);
+            pendingBlockWrapperClaim = false;
+            isPlainBlockClaim = true;
+            isBlockWrapperClaim = true;
+            return body(code);
+        }
         // Continuation for multi-line opening tags
         function openTagContinuationStart(code) {
             return effects.check(continuation_checks_nonLazyContinuationStart, openTagContinuationNonLazy, continuationAfter)(code);
@@ -121128,10 +121281,16 @@ function createTokenize(mode) {
         // continue on a tag line (`<…`); any markdown island (`**bold**`, `[block:…]`, a
         // fence) refuses so CommonMark html-flow reparses it exactly as it does today.
         function plainClaimLineStart(code) {
-            // Leading whitespace only → treat as a blank line, matching CommonMark.
-            if (code === codes.space || code === codes.horizontalTab) {
-                plainClaimIndentColumns +=
-                    code === codes.horizontalTab ? TAB_STOP_WIDTH - (plainClaimIndentColumns % TAB_STOP_WIDTH) : 1;
+            // Leading whitespace only → treat as a blank line, matching CommonMark. A tab
+            // advances to the next stop; its trailing `virtualSpace` fillers add nothing
+            // but must still be consumed or they'd read as line content below.
+            if (markdownSpace(code)) {
+                if (code === codes.horizontalTab) {
+                    plainClaimIndentColumns += TAB_STOP_WIDTH - (plainClaimIndentColumns % TAB_STOP_WIDTH);
+                }
+                else if (code === codes.space) {
+                    plainClaimIndentColumns += 1;
+                }
                 effects.consume(code);
                 return plainClaimLineStart;
             }
@@ -121143,10 +121302,11 @@ function createTokenize(mode) {
             if (pendingBlankLine) {
                 // A 4+ col island nested under other tags is cosmetic nesting indent, not code:
                 // keep claiming so promotion dedents + re-parses it as markdown (RM-17560).
-                // Tags whose bodies stay raw are excluded — a claimed island there would never
-                // be re-parsed and would leak as literal text.
+                // Block-wrapper claims extend this to top-of-body islands — their CommonMark
+                // fallback is the fragmentation bug, not intentional indented code. Tags whose
+                // bodies stay raw are excluded: a claimed island there would leak as literal text.
                 if (plainClaimIndentColumns >= INDENTED_CODE_MIN_COLUMNS &&
-                    sawPlainBlockBodyContent &&
+                    (sawPlainBlockBodyContent || isBlockWrapperClaim) &&
                     !NON_REPARSED_BODY_TAGS.has(tagName)) {
                     return plainClaimContinue(code);
                 }
@@ -121225,6 +121385,7 @@ function syntax_mdxComponent() {
 
 
 
+
 
 
 const buildInlineMdProcessor = (safeMode) => {
@@ -121232,7 +121393,7 @@ const buildInlineMdProcessor = (safeMode) => {
     // body (e.g. a `<Callout>`) is captured as one html node. Without it, blank
     // lines between rows let CommonMark HTML block type 6 fragment the table and
     // its rows spill out as text / indented code blocks (CX-3705).
-    const micromarkExts = [syntax_jsxTable(), syntax_mdxComponent(), syntax_gemoji(), legacyVariable(), syntax_magicBlock()];
+    const micromarkExts = [disableIndentedCode, syntax_jsxTable(), syntax_mdxComponent(), syntax_gemoji(), legacyVariable(), syntax_magicBlock()];
     const fromMarkdownExts = [
         jsx_table_jsxTableFromMarkdown(),
         mdx_component_mdxComponentFromMarkdown(),
@@ -122541,71 +122702,6 @@ const generateSlugForHeadings = () => (tree) => {
 // EXTERNAL MODULE: ./node_modules/@readme/variable/dist/index.js
 var variable_dist = __webpack_require__(4355);
 var variable_dist_default = /*#__PURE__*/__webpack_require__.n(variable_dist);
-;// ./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
-    })
-  }
-}
-
 ;// ./node_modules/hast-util-to-html/lib/handle/comment.js
 /**
  * @typedef {import('hast').Comment} Comment
@@ -126951,6 +127047,7 @@ function mdxishAstProcessor(mdContent, opts = {}) {
     // Parser extension for MDX expressions {}
     const mdxExprTextOnly = mdxExpressionLenient();
     const micromarkExts = [
+        disableIndentedCode,
         syntax_jsxTable(),
         syntax_magicBlock(),
         syntax_mdxComponent(),
@@ -127053,7 +127150,7 @@ function mdxishMdastToMd(mdast) {
  * Processes markdown content with MDX syntax support and returns a HAST.
  * Detects and renders custom component tags from the components hash.
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  */
 function mdxish_mdxish(mdContent, opts = {}) {
     const { components: userComponents = {}, safeMode = false, variables } = opts;
@@ -127337,7 +127434,7 @@ function buildRMDXModule(content, headings, tocHast, opts) {
  * @param opts - The options for the render
  * @returns The React component
  *
- * @see {@link https://github.com/readmeio/rmdx/blob/main/docs/mdxish-flow.md}
+ * @see .claude/context/MDXish/Processor Overview.md
  */
 const renderMdxish = (tree, opts = {}) => {
     const { components: userComponents = {}, variables, ...contextOpts } = opts;
@@ -127627,6 +127724,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 ;// ./lib/render-fixture/renderFixture.ts