@mintlify/common 1.0.1122 → 1.0.1124

package/dist/mdx/index.d.ts

@@ -4,6 +4,7 @@ export * from './utils.js';
 export * from './plugins/index.js';
 export * from './lib/index.js';
 export * from './preprocessCustomHeadingIds.js';
+export * from './preprocessMdxFragmentCode.js';
 export * from './getMDXOptions.js';
 export * from './astUtils.js';
 export * from './getS3ImageUri.js';

package/dist/mdx/index.js

@@ -4,6 +4,7 @@ export * from './utils.js';
 export * from './plugins/index.js';
 export * from './lib/index.js';
 export * from './preprocessCustomHeadingIds.js';
+export * from './preprocessMdxFragmentCode.js';
 export * from './getMDXOptions.js';
 export * from './astUtils.js';
 export * from './getS3ImageUri.js';

package/dist/mdx/plugins/remark/remarkMdxExpandExpressions.d.ts

@@ -70,11 +70,14 @@ export declare const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
  * cannot live inside an expression and are dropped. In an inline (`mdxTextExpression`) a lone
  * `<p>` wrapper is unwrapped so it does not nest in the surrounding paragraph.
  *
- * Escaping: the fragment source is JSX text, so a literal brace must be written the JSX way,
- * e.g. `{'{'}` / `{'}'}`; that expression is then evaluated by MDX and renders the brace. A custom
- * heading anchor (`## Title {#id}`) is fine: `preprocessCustomHeadingIds` rewrites it before the
- * expression is parsed, at any indent inside `<MDX>`. Nothing beyond dedenting is done to the
- * recovered text.
+ * Escaping: the fragment source is JSX text, so a literal brace in prose must be written the JSX
+ * way, e.g. `{'{'}` / `{'}'}`; that expression is then evaluated by MDX and renders the brace. A
+ * custom heading anchor (`## Title {#id}`) is fine: `preprocessCustomHeadingIds` rewrites it before
+ * the expression is parsed, at any indent inside `<MDX>`. Code is exempt from all of this:
+ * `preprocessMdxFragmentCode` escapes `<`, `>`, `{`, `}` inside fences and inline code before any
+ * parse, and `decodeFragmentCode` below decodes them (plus `&amp;`) once the fragment's code sits
+ * in `code`/`inlineCode` nodes, so code behaves exactly as it does at the page root. Nothing
+ * beyond dedenting is done to the recovered text.
  *
  * Components defined on the page (`export const Local = () => …`, and named snippet imports,
  * which prebuild rewrites into page exports) are passed into the fragment pipeline as known

package/dist/mdx/plugins/remark/remarkMdxExpandExpressions.js

@@ -16,6 +16,7 @@ import remarkRehype from 'remark-rehype';
 import { unified } from 'unified';
 import { visit } from 'unist-util-visit';
 import { visitParents } from 'unist-util-visit-parents';
+import { decodeMdxFragmentCode } from '../../preprocessMdxFragmentCode.js';
 import { getAST } from '../../remark.js';
 import { getExportedFunctionNames } from './remarkMdxClientComponentBoundaries.js';
 const REMARK_REHYPE_OPTIONS = {
@@ -60,11 +61,14 @@ export const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
  * cannot live inside an expression and are dropped. In an inline (`mdxTextExpression`) a lone
  * `<p>` wrapper is unwrapped so it does not nest in the surrounding paragraph.
  *
- * Escaping: the fragment source is JSX text, so a literal brace must be written the JSX way,
- * e.g. `{'{'}` / `{'}'}`; that expression is then evaluated by MDX and renders the brace. A custom
- * heading anchor (`## Title {#id}`) is fine: `preprocessCustomHeadingIds` rewrites it before the
- * expression is parsed, at any indent inside `<MDX>`. Nothing beyond dedenting is done to the
- * recovered text.
+ * Escaping: the fragment source is JSX text, so a literal brace in prose must be written the JSX
+ * way, e.g. `{'{'}` / `{'}'}`; that expression is then evaluated by MDX and renders the brace. A
+ * custom heading anchor (`## Title {#id}`) is fine: `preprocessCustomHeadingIds` rewrites it before
+ * the expression is parsed, at any indent inside `<MDX>`. Code is exempt from all of this:
+ * `preprocessMdxFragmentCode` escapes `<`, `>`, `{`, `}` inside fences and inline code before any
+ * parse, and `decodeFragmentCode` below decodes them (plus `&amp;`) once the fragment's code sits
+ * in `code`/`inlineCode` nodes, so code behaves exactly as it does at the page root. Nothing
+ * beyond dedenting is done to the recovered text.
  *
  * Components defined on the page (`export const Local = () => …`, and named snippet imports,
  * which prebuild rewrites into page exports) are passed into the fragment pipeline as known
@@ -86,6 +90,7 @@ export const MAX_MDX_FRAGMENTS_PER_PAGE = 500;
 export const remarkMdxExpandExpressions = (options) => (tree) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
     const depth = (_a = options.depth) !== null && _a !== void 0 ? _a : 0;
+    decodeFragmentCode(tree, depth > 0);
     const expressions = [];
     visitParents(tree, (node, ancestors) => {
         if (node.type !== 'mdxFlowExpression' && node.type !== 'mdxTextExpression')
@@ -194,6 +199,26 @@ const expandExpression = (node_1, options_1, _a) => __awaiter(void 0, [node_1, o
         node.data.tableOfContents = headings;
     }
 });
+/**
+ * Undoes `preprocessMdxFragmentCode`'s escaping now that the code content sits safely inside
+ * `code`/`inlineCode` nodes. On the page tree (`insideFragment` false) only code inside a
+ * block-level `<MDX>` element was escaped; on a fragment tree everything came from inside the
+ * `<MDX>` tags, so every code node is decoded. Each tree passes through this exactly once —
+ * a nested block-level `<MDX>` is part of the enclosing tree, and a nested expression `<MDX>`
+ * is parsed into a fresh tree the fragment pipeline's own instance of this plugin decodes.
+ */
+const decodeFragmentCode = (tree, insideFragment) => {
+    visitParents(tree, (node, ancestors) => {
+        if (node.type !== 'code' && node.type !== 'inlineCode')
+            return;
+        const insideMdxElement = ancestors.some((ancestor) => (ancestor.type === 'mdxJsxFlowElement' || ancestor.type === 'mdxJsxTextElement') &&
+            'name' in ancestor &&
+            ancestor.name === 'MDX');
+        if (insideFragment || insideMdxElement) {
+            node.value = decodeMdxFragmentCode(node.value);
+        }
+    });
+};
 const collectMdxElements = (expression) => {
     const elements = [];
     walk(expression, {

package/dist/mdx/preprocessCustomHeadingIds.d.ts

@@ -23,6 +23,11 @@ export interface PreprocessCustomHeadingIdsOptions {
  * Without this the `{#id}` would reach the expression parser as a JSX expression and fail.
  */
 export declare function preprocessCustomHeadingIds(content: string, options?: PreprocessCustomHeadingIdsOptions): string;
+export declare function parseOpeningFence(stripped: string): {
+    char: string;
+    count: number;
+} | undefined;
+export declare function isClosingFence(stripped: string, fenceChar: string, fenceCount: number): boolean;
 export interface JsxHeadingElement extends MdxJsxFlowElement {
     readonly __jsxHeading: true;
 }

package/dist/mdx/preprocessCustomHeadingIds.js

@@ -75,7 +75,7 @@ export function preprocessCustomHeadingIds(content, options) {
     }
     return result.join('\n');
 }
-function parseOpeningFence(stripped) {
+export function parseOpeningFence(stripped) {
     const char = stripped[0];
     if (char !== '`' && char !== '~')
         return undefined;
@@ -86,7 +86,7 @@ function parseOpeningFence(stripped) {
         return undefined;
     return { char, count };
 }
-function isClosingFence(stripped, fenceChar, fenceCount) {
+export function isClosingFence(stripped, fenceChar, fenceCount) {
     let i = 0;
     while (i < stripped.length && stripped[i] === fenceChar)
         i++;

package/dist/mdx/preprocessMdxFragmentCode.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Escapes `<`, `>`, `{` and `}` inside code fences and inline code within an `<MDX>` body, so code
+ * there needs no hand-escaping and parses exactly like code at the page root.
+ *
+ * The body of an `<MDX>` inside a `{…}` expression is JSX text to the MDX parser: a raw `<` starts
+ * a tag and a raw `{` starts an expression, so ``​`mint <cmd>`​`` or a fence containing
+ * `<project-root>` fails the whole page with "Could not parse expression with acorn" — a code
+ * fence gives no protection because it only becomes code later, when `remarkMdxExpandExpressions`
+ * re-parses the body as markdown. This pass rewrites those characters to character references
+ * (valid JSX text) before any MDX parse; `remarkMdxExpandExpressions` decodes them
+ * (`decodeMdxFragmentCode`) once the body has been parsed and the code content is safely inside
+ * `code`/`inlineCode` nodes.
+ *
+ * Runs as a string pass alongside `preprocessCustomHeadingIds`, with the same line scan and fence
+ * tracking: content inside a page-level fence is never touched (an `<MDX>` there is example code),
+ * and prose/JSX inside an `<MDX>` body is left alone — only fence content and inline code spans
+ * are rewritten, including spans on the same line as the `<MDX>` tags. Block-level `<MDX>` bodies
+ * get the same treatment so both forms behave identically; their code nodes are decoded by the
+ * same plugin. Constructs the line scan cannot see — an inline code span or an opening tag
+ * spanning lines, a span whose content contains backticks — are left alone and fail open: the
+ * page parses (or fails) exactly as it did before this pass existed, and nothing is corrupted.
+ *
+ * The pass is idempotent (nothing it emits is rewritten again), so stacked parse entries — e.g.
+ * prebuild normalizing a page that `getMdx` later compiles, or a fragment re-parse hitting
+ * `getAST` — are safe by construction, and a fragment sliced out of its `<MDX>` tags no longer
+ * matches the scanner at all.
+ */
+export declare function preprocessMdxFragmentCode(content: string): string;
+/**
+ * Inverse of the escape above, applied by `remarkMdxExpandExpressions` to `code`/`inlineCode`
+ * node values inside `<MDX>`. Decodes exactly the references the escape emits plus `&amp;`, which
+ * makes hand-written references work the way JSX text says they should (`&lt;` is `<`) and keeps
+ * every literal spellable (`&amp;lt;` is a literal `&lt;`). Single-pass, so decoded output is
+ * never re-decoded.
+ */
+export declare const decodeMdxFragmentCode: (value: string) => string;

package/dist/mdx/preprocessMdxFragmentCode.js

@@ -0,0 +1,161 @@
+import { isClosingFence, parseOpeningFence } from './preprocessCustomHeadingIds.js';
+// `<MDX>` or `<MDX className="x">`; not `<MDX />` (no body) and not `<MDXProvider>`
+const MDX_OPEN_RE = /<MDX(?:\s[^>]*[^/>\s])?\s*>/g;
+const MDX_CLOSE_RE = /<\/MDX\s*>/g;
+/**
+ * Characters that end or break the JSX parse of an `<MDX>` body, mapped to the character
+ * references acorn treats as plain JSX text. `&` is deliberately absent: leaving it alone makes
+ * the escape idempotent, so the preprocessor can run at every parse entry (getMdx, getAST,
+ * prebuild, editor validation) without the passes having to know about each other.
+ */
+const CODE_ESCAPES = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '{': '&#123;',
+    '}': '&#125;',
+};
+const CODE_ESCAPE_RE = /[<>{}]/g;
+const CODE_UNESCAPES = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&#123;': '{',
+    '&#125;': '}',
+};
+const CODE_UNESCAPE_RE = /&(?:amp|lt|gt|#123|#125);/g;
+// backtick-delimited code span on a single line; spans whose content itself contains backticks
+// (``a`b``) or crosses lines are left alone and behave as before (the page fails to parse the
+// way it always did — fail open, never corrupt)
+const INLINE_CODE_RE = /(`+)([^`]+)\1(?!`)/g;
+// single-line quoted run: a string literal in an expression ({t("<MDX>")}) or an attribute value
+// (title="<MDX>"). An <MDX> inside one is a mention, not a tag.
+const QUOTED_RE = /"[^"\n]*"|'[^'\n]*'/g;
+const escapeCode = (text) => text.replace(CODE_ESCAPE_RE, (char) => { var _a; return (_a = CODE_ESCAPES[char]) !== null && _a !== void 0 ? _a : char; });
+/**
+ * Escapes the inline code spans of one non-fence line that sit inside an `<MDX>` body, and
+ * returns the `<MDX>` nesting depth after the line. Position-aware so a line may enter or leave
+ * `<MDX>` mid-way: only spans between the tags are escaped, an `<MDX>` mention inside an inline
+ * code span or a quoted string never counts as a tag, and tags inside root-level inline code or
+ * string literals cannot poison the depth for the rest of the document.
+ */
+const processProseLine = (line, depth) => {
+    const spans = [...line.matchAll(INLINE_CODE_RE)].map((match) => ({
+        start: match.index,
+        end: match.index + match[0].length,
+        ticks: match[1],
+        code: match[2],
+    }));
+    const inSpan = (index) => spans.some((span) => index >= span.start && index < span.end);
+    // Quoted runs are found with inline-code content masked out, so a quote inside a code span
+    // (`don't`) cannot open one.
+    const masked = spans.reduce((acc, span) => acc.slice(0, span.start) + ' '.repeat(span.end - span.start) + acc.slice(span.end), line);
+    const quoted = [...masked.matchAll(QUOTED_RE)].map((match) => ({
+        start: match.index,
+        end: match.index + match[0].length,
+    }));
+    const inQuoted = (index) => quoted.some((run) => index > run.start && index < run.end - 1);
+    const tags = [
+        ...[...line.matchAll(MDX_OPEN_RE)].map((match) => ({ index: match.index, open: true })),
+        ...[...line.matchAll(MDX_CLOSE_RE)].map((match) => ({ index: match.index, open: false })),
+    ]
+        .filter((tag) => !inSpan(tag.index) && !inQuoted(tag.index))
+        .sort((a, b) => a.index - b.index);
+    const depthAt = (position) => {
+        let current = depth;
+        for (const tag of tags) {
+            if (tag.index >= position)
+                break;
+            current = Math.max(0, current + (tag.open ? 1 : -1));
+        }
+        return current;
+    };
+    let out = '';
+    let cursor = 0;
+    for (const span of spans) {
+        out += line.slice(cursor, span.start);
+        out +=
+            depthAt(span.start) > 0
+                ? `${span.ticks}${escapeCode(span.code)}${span.ticks}`
+                : line.slice(span.start, span.end);
+        cursor = span.end;
+    }
+    out += line.slice(cursor);
+    return { line: out, depth: depthAt(line.length) };
+};
+/**
+ * Escapes `<`, `>`, `{` and `}` inside code fences and inline code within an `<MDX>` body, so code
+ * there needs no hand-escaping and parses exactly like code at the page root.
+ *
+ * The body of an `<MDX>` inside a `{…}` expression is JSX text to the MDX parser: a raw `<` starts
+ * a tag and a raw `{` starts an expression, so ``​`mint <cmd>`​`` or a fence containing
+ * `<project-root>` fails the whole page with "Could not parse expression with acorn" — a code
+ * fence gives no protection because it only becomes code later, when `remarkMdxExpandExpressions`
+ * re-parses the body as markdown. This pass rewrites those characters to character references
+ * (valid JSX text) before any MDX parse; `remarkMdxExpandExpressions` decodes them
+ * (`decodeMdxFragmentCode`) once the body has been parsed and the code content is safely inside
+ * `code`/`inlineCode` nodes.
+ *
+ * Runs as a string pass alongside `preprocessCustomHeadingIds`, with the same line scan and fence
+ * tracking: content inside a page-level fence is never touched (an `<MDX>` there is example code),
+ * and prose/JSX inside an `<MDX>` body is left alone — only fence content and inline code spans
+ * are rewritten, including spans on the same line as the `<MDX>` tags. Block-level `<MDX>` bodies
+ * get the same treatment so both forms behave identically; their code nodes are decoded by the
+ * same plugin. Constructs the line scan cannot see — an inline code span or an opening tag
+ * spanning lines, a span whose content contains backticks — are left alone and fail open: the
+ * page parses (or fails) exactly as it did before this pass existed, and nothing is corrupted.
+ *
+ * The pass is idempotent (nothing it emits is rewritten again), so stacked parse entries — e.g.
+ * prebuild normalizing a page that `getMdx` later compiles, or a fragment re-parse hitting
+ * `getAST` — are safe by construction, and a fragment sliced out of its `<MDX>` tags no longer
+ * matches the scanner at all.
+ */
+export function preprocessMdxFragmentCode(content) {
+    if (!content.includes('<MDX'))
+        return content;
+    const lines = content.split('\n');
+    const result = [];
+    let fenceChar;
+    let fenceCount = 0;
+    let mdxDepth = 0;
+    let changed = false;
+    for (const line of lines) {
+        const stripped = line.trimStart();
+        if (fenceChar !== undefined) {
+            if (isClosingFence(stripped, fenceChar, fenceCount)) {
+                fenceChar = undefined;
+                result.push(line);
+            }
+            else if (mdxDepth > 0) {
+                const escaped = escapeCode(line);
+                if (escaped !== line)
+                    changed = true;
+                result.push(escaped);
+            }
+            else {
+                result.push(line);
+            }
+            continue;
+        }
+        const fence = parseOpeningFence(stripped);
+        if (fence) {
+            fenceChar = fence.char;
+            fenceCount = fence.count;
+            result.push(line);
+            continue;
+        }
+        const processed = processProseLine(line, mdxDepth);
+        if (processed.line !== line)
+            changed = true;
+        mdxDepth = processed.depth;
+        result.push(processed.line);
+    }
+    return changed ? result.join('\n') : content;
+}
+/**
+ * Inverse of the escape above, applied by `remarkMdxExpandExpressions` to `code`/`inlineCode`
+ * node values inside `<MDX>`. Decodes exactly the references the escape emits plus `&amp;`, which
+ * makes hand-written references work the way JSX text says they should (`&lt;` is `<`) and keeps
+ * every literal spellable (`&amp;lt;` is a literal `&lt;`). Single-pass, so decoded output is
+ * never re-decoded.
+ */
+export const decodeMdxFragmentCode = (value) => value.replace(CODE_UNESCAPE_RE, (entity) => { var _a; return (_a = CODE_UNESCAPES[entity]) !== null && _a !== void 0 ? _a : entity; });

package/dist/mdx/preprocessMdxFragmentCode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mdx/preprocessMdxFragmentCode.test.js

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { preprocessMdxFragmentCode } from './preprocessMdxFragmentCode.js';
+const wrap = (body) => `{true ? <MDX>\n${body}\n</MDX> : null}`;
+describe('preprocessMdxFragmentCode', () => {
+    it('escapes < > { } inside a fence inside <MDX>', () => {
+        const out = preprocessMdxFragmentCode(wrap('```bash\n<root>/{arch}/app.vpkg\n```'));
+        expect(out).toBe(wrap('```bash\n&lt;root&gt;/&#123;arch&#125;/app.vpkg\n```'));
+    });
+    it('escapes inline code inside <MDX>', () => {
+        const out = preprocessMdxFragmentCode(wrap('run `mint <cmd>` and `a{b}` now'));
+        expect(out).toBe(wrap('run `mint &lt;cmd&gt;` and `a&#123;b&#125;` now'));
+    });
+    it('leaves prose and JSX inside <MDX> alone', () => {
+        const src = wrap('a <b>bold</b> word and a {expr} stay');
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('leaves fences and inline code outside <MDX> alone', () => {
+        const src = 'x\n\n```bash\n<root>/{arch}\n```\n\nrun `a <b>` now';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('does not treat <MDX> inside a page-level fence as an opener', () => {
+        const src = '```mdx\n<MDX>\n\n# example\n</MDX>\n```\n\n`<x>` after';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('is idempotent and never escapes &', () => {
+        const src = wrap('```bash\n<a> and &lt;b&gt; and &amp;\n```');
+        const once = preprocessMdxFragmentCode(src);
+        expect(once).toBe(wrap('```bash\n&lt;a&gt; and &lt;b&gt; and &amp;\n```'));
+        expect(preprocessMdxFragmentCode(once)).toBe(once);
+    });
+    it('a </MDX> inside a fence is escaped and does not close the block', () => {
+        const out = preprocessMdxFragmentCode(wrap('```\n</MDX>\n```\n\n`<after>`'));
+        expect(out).toBe(wrap('```\n&lt;/MDX&gt;\n```\n\n`&lt;after&gt;`'));
+    });
+    it('handles block-level <MDX> and nested <MDX> bodies', () => {
+        const src = '<MDX>\n\n```txt\n<x>\n```\n\n<MDX>\n\n`{y}`\n</MDX>\n</MDX>';
+        expect(preprocessMdxFragmentCode(src)).toBe('<MDX>\n\n```txt\n&lt;x&gt;\n```\n\n<MDX>\n\n`&#123;y&#125;`\n</MDX>\n</MDX>');
+    });
+    it('keeps fence markers, info strings, and indentation untouched', () => {
+        const src = wrap('  ```bash filename="a.sh"\n  <x>\n  ```');
+        expect(preprocessMdxFragmentCode(src)).toBe(wrap('  ```bash filename="a.sh"\n  &lt;x&gt;\n  ```'));
+    });
+    it('an `<MDX>` mention in root inline code does not poison later root code', () => {
+        const src = 'Use `<MDX>` to branch.\n\n```bash\n<root>/{arch}\n```\n\nrun `a <b>` now';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('escapes inline code on the same line as the <MDX> tags', () => {
+        const out = preprocessMdxFragmentCode('{true ? <MDX>run `mint <cmd>` now</MDX> : null}');
+        expect(out).toBe('{true ? <MDX>run `mint &lt;cmd&gt;` now</MDX> : null}');
+    });
+    it('only spans between the tags are escaped on a shared line', () => {
+        const out = preprocessMdxFragmentCode('`a<b` <MDX>`c<d`</MDX> `e<f`');
+        expect(out).toBe('`a<b` <MDX>`c&lt;d`</MDX> `e<f`');
+    });
+    it('a tag inside an inline code span within a fragment is not counted', () => {
+        const out = preprocessMdxFragmentCode(wrap('mention `</MDX>` here\n\n`x<y`'));
+        expect(out).toBe(wrap('mention `&lt;/MDX&gt;` here\n\n`x&lt;y`'));
+    });
+    it('a complete <MDX> example inside a fragment fence is escaped, not parsed', () => {
+        const out = preprocessMdxFragmentCode(wrap('```mdx\n<MDX>\n# hi\n</MDX>\n```\n\n`x<y`'));
+        expect(out).toBe(wrap('```mdx\n&lt;MDX&gt;\n# hi\n&lt;/MDX&gt;\n```\n\n`x&lt;y`'));
+    });
+    it('a tag inside a string literal does not poison later root code', () => {
+        // A lone opener in a string used to leave the scanner "inside" a fragment for the rest of
+        // the document, escaping root-level code that nothing would ever decode.
+        const src = '{label("<MDX>")} intro\n\n```bash\n<root>/{arch}\n```\n\nrun `a <b>` now';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('a balanced pair inside a string literal escapes nothing on the line', () => {
+        const src = '{t("<MDX> `a<b` </MDX>")} and `x<y` after';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('a tag inside an attribute value is not counted', () => {
+        const src = '<Card title="<MDX>">x</Card>\n\n`code <a>` span';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+    it('returns input unchanged when there is no <MDX>', () => {
+        const src = '# Title\n\n```bash\n<root>\n```';
+        expect(preprocessMdxFragmentCode(src)).toBe(src);
+    });
+});

package/dist/mdx/remark.js

@@ -6,6 +6,7 @@ import remarkMdx from 'remark-mdx';
 import remarkStringify from 'remark-stringify';
 import { remarkVisibilityForMarkdown } from './plugins/remark/remarkVisibilityForMarkdown.js';
 import { preprocessCustomHeadingIds } from './preprocessCustomHeadingIds.js';
+import { preprocessMdxFragmentCode } from './preprocessMdxFragmentCode.js';
 import { getJsxEsmTree } from './snippets/getJsxEsmTree.js';
 import { isJsxOrTsx } from './snippets/isJsxOrTsx.js';
 export const coreRemarkMdxPlugins = [
@@ -19,7 +20,7 @@ export const getAST = (str, filePath) => {
     if (isJsxOrTsx(filePath)) {
         return getJsxEsmTree(str, filePath);
     }
-    return coreRemark().parse(preprocessCustomHeadingIds(str));
+    return coreRemark().parse(preprocessCustomHeadingIds(preprocessMdxFragmentCode(str)));
 };
 export const stringifyTree = (tree) => coreRemark().use(remarkStringify).stringify(tree);
 export function stripVisibilityForMarkdown(mdx) {

package/dist/mdx/server-only/getMdx.js

@@ -12,14 +12,15 @@ import { getTailwindSelectors } from '../../css/tailwind.js';
 import { getMDXOptions, remarkMdxRemoveJs, remarkExpandContent, remarkSplitCodeGroup, remarkSplitTabs, remarkValidateAccordions, remarkValidateSteps, remarkValidateVisibility, remarkValidateTabs, remarkValidateApiExamples, } from '../../index.js';
 import { codeStylingToThemeOrThemes } from '../getCodeStyling.js';
 import { preprocessCustomHeadingIds } from '../preprocessCustomHeadingIds.js';
+import { preprocessMdxFragmentCode } from '../preprocessMdxFragmentCode.js';
 import { replaceVariables } from '../replaceVariables.js';
 import { createSnippetTreeMap } from './getMdx/snippets.js';
 import { getSerializeExtras } from './getSerializeExtras.js';
 export function getMdx(_a) {
     return __awaiter(this, arguments, void 0, function* ({ path, content, metadata, snippets, subdomain, codeStyling, config, tailwindSelectors = undefined, pageType = 'default', trace = undefined, customLanguages = [], variables = undefined, rehypePlugins = [], remarkPlugins = [], allowedComponents = [], }) {
         const traceFn = trace !== null && trace !== void 0 ? trace : ((_name, fn) => fn());
-        const processedContent = preprocessCustomHeadingIds(replaceVariables(content, variables));
-        const processedSnippets = snippets.map((snippet) => (Object.assign(Object.assign({}, snippet), { content: preprocessCustomHeadingIds(replaceVariables(snippet.content, variables)) })));
+        const processedContent = preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(content, variables)));
+        const processedSnippets = snippets.map((snippet) => (Object.assign(Object.assign({}, snippet), { content: preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(snippet.content, variables))) })));
         if (!tailwindSelectors)
             tailwindSelectors = yield traceFn('getMdx.getTailwindSelectors', () => __awaiter(this, void 0, void 0, function* () { return getTailwindSelectors({ content: processedContent }); }));
         const snippetTreeMap = yield traceFn('getMdx.createSnippetTreeMap', () => __awaiter(this, void 0, void 0, function* () { return createSnippetTreeMap(processedSnippets); }));

package/dist/mdx/utils.js

@@ -107,6 +107,8 @@ export const allowedComponents = [
     'br',
     'button',
     'clipPath',
+    'col',
+    'colgroup',
     'defs',
     'div',
     'form',