@readme/markdown 14.8.0 → 14.9.0

package/components/TableOfContents/index.tsx

@@ -99,6 +99,8 @@ function useScrollHighlight(navRef: React.RefObject<HTMLElement | null>) {
           const linkRect = link.getBoundingClientRect();
           nav.style.setProperty('--ToC-border-active-height', `${linkRect.height}px`);
           nav.style.setProperty('--ToC-border-active-top', `${linkRect.top - navRect.top}px`);
+
+          link.scrollIntoView?.({ block: 'nearest', behavior: 'smooth' });
         }
       }
     };

package/dist/index.d.ts

@@ -6,7 +6,7 @@ declare const utils: {
     getHref: typeof getHref;
     calloutIcons: {};
 };
-export { compile, exports, FLOW_TYPES, hast, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
+export { compile, exports, FLOW_TYPES, hast, INLINE_ONLY_PARENT_TYPES, run, mdast, mdastV6, mdx, mdxish, mdxishAstProcessor, mdxishMdastToMd, mdxishTags, extractToc, migrate, mix, plain, renderMdxish, remarkPlugins, stripComments, tags, } from './lib';
 export { default as Owlmoji } from './lib/owlmoji';
 export { Components, utils };
 export { tailwindCompiler } from './utils/tailwind-compiler';

package/dist/lib/extractToc.d.ts

@@ -0,0 +1,2 @@
+import { extractToc } from '../processor/plugin/toc';
+export default extractToc;

package/dist/lib/index.d.ts

@@ -10,6 +10,7 @@ export { default as mdx } from './mdx';
 export { default as mix } from './mix';
 export { default as mdxish, mdxishAstProcessor, mdxishMdastToMd } from './mdxish';
 export type { MdxishOpts } from './mdxish';
+export { default as extractToc } from './extractToc';
 export { default as migrate } from './migrate';
 export { default as plain } from './plain';
 export { default as renderMdxish } from './renderMdxish';

package/dist/lib/utils/mdxish/mdxish-expression.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Evaluate an expression body, transforming JSX to `React.createElement` only when the
+ * parsed estree actually contains a JSX node. The raw `Function()` evaluator can't parse
+ * JSX, so JSX-bearing expressions take the build-and-serialize path while everything else
+ * evaluates directly. Input acorn can't parse falls back to the plain evaluator unchanged.
+ */
+export declare const evalExpression: (expression: string, scope: Record<string, unknown>) => any;

package/dist/main.js

@@ -11599,6 +11599,7 @@ __webpack_require__.d(__webpack_exports__, {
   Owlmoji: () => (/* reexport */ Owlmoji),
   compile: () => (/* reexport */ lib_compile),
   exports: () => (/* reexport */ lib_exports),
+  extractToc: () => (/* reexport */ lib_extractToc),
   gemojiRegex: () => (/* reexport */ gemoji_regex),
   hast: () => (/* reexport */ lib_hast),
   mdast: () => (/* reexport */ lib_mdast),
@@ -12458,6 +12459,7 @@ function useScrollHighlight(navRef) {
                     const linkRect = link.getBoundingClientRect();
                     nav.style.setProperty('--ToC-border-active-height', `${linkRect.height}px`);
                     nav.style.setProperty('--ToC-border-active-top', `${linkRect.top - navRect.top}px`);
+                    link.scrollIntoView?.({ block: 'nearest', behavior: 'smooth' });
                 }
             }
         };
@@ -98755,26 +98757,17 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
 ;// ./processor/plugin/mdxish-handlers.ts
 
 
-
 // Convert MDX expressions to text nodes (evaluation happens earlier in pipeline)
 const mdxExpressionHandler = (_state, node) => ({
     type: 'text',
     value: node.value || '',
 });
-function isStructuredCloneable(value) {
-    try {
-        structuredClone(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 // Convert MDX JSX elements to a custom mdx-jsx hast node that bypasses rehypeRaw's
 // HTML serialization round-trip; downstream normalization rewrites it to `element`.
 const mdxJsxElementHandler = (state, node) => {
     const { attributes = [], name } = node;
     const properties = {};
+    const deferredExpressions = {};
     attributes.forEach(attribute => {
         if (attribute.type !== 'mdxJsxAttribute' || !attribute.name)
             return;
@@ -98785,30 +98778,20 @@ const mdxJsxElementHandler = (state, node) => {
             properties[attribute.name] = decode_decodeHTMLStrict(attribute.value);
         }
         else {
-            const expressionSource = attribute.value.value;
-            let evaluated;
-            try {
-                evaluated = evaluate(expressionSource);
-            }
-            catch {
-                evaluated = expressionSource;
-            }
-            // rehypeRaw's passThrough clones our mdx-jsx node with structuredClone, which
-            // rejects functions and other non-serializable values. Attribute expressions
-            // that evaluate to such values (`onClick={() => ...}`) would crash the pipeline,
-            // so if we have a non-serializable value, we fall back to the raw expression source
-            // and not support it for now.
-            if (!isStructuredCloneable(evaluated)) {
-                evaluated = expressionSource;
-            }
-            properties[attribute.name] = evaluated;
+            // Defer every attribute-expression evaluation past rehypeRaw's `structuredClone`
+            // passthrough: evaluating here can yield React elements or functions that the clone
+            // rejects. The source is stashed in `node.data` (clone-safe) and
+            // `resolveDeferredAttributeExpressionProps` evaluates it once past the clone.
+            deferredExpressions[attribute.name] = attribute.value.value;
         }
     });
+    const hasDeferredExpressions = Object.keys(deferredExpressions).length > 0;
     const jsxNode = {
         type: 'mdx-jsx',
         tagName: name || '',
-        properties,
+        properties: properties,
         children: state.all(node),
+        ...(hasDeferredExpressions && { data: { deferredExpressions } }),
     };
     return jsxNode;
 };
@@ -102090,27 +102073,56 @@ const evaluateExports = () => (tree, file) => {
 
 // EXTERNAL MODULE: ./node_modules/react-dom/server.browser.js
 var server_browser = __webpack_require__(5848);
-;// ./processor/transform/mdxish/evaluate-expressions.ts
-
+;// ./lib/utils/mdxish/mdxish-expression.ts
 
 
 
-
-
-const HAS_JSX = /<[A-Za-z]|<>/;
-/** The raw Function() can't parse JSX, so parse & convert it to a React element first so later we can get its HTML representation */
-const evalJsxExpression = (expression, scope) => {
-    const program = jsxAcornParser.parse(expression, { ecmaVersion: 'latest', sourceType: 'module' });
+const parseExpression = (expression) => jsxAcornParser.parse(expression, { ecmaVersion: 'latest', sourceType: 'module' });
+/**
+ * Recursively report whether an estree value contains any JSX element or fragment node.
+ * estree stores children across named fields (not a `children` array), so this descends
+ * through every nested object/array rather than using a unist-shaped walker.
+ */
+const containsJsxNode = (value) => {
+    if (Array.isArray(value))
+        return value.some(containsJsxNode);
+    if (value === null || typeof value !== 'object')
+        return false;
+    const { type } = value;
+    if (type === 'JSXElement' || type === 'JSXFragment')
+        return true;
+    return Object.values(value).some(containsJsxNode);
+};
+/** Convert a program's JSX into `React.createElement` calls and evaluate it. `scope` must provide `React`. */
+const evalJsxProgram = (program, scope) => {
     buildJsx(program, { runtime: 'classic', pragma: 'React.createElement', pragmaFrag: 'React.Fragment' });
     const { value: source } = toJs(program);
     return evaluate(`(() => { return ${source.trim().replace(/;$/, '')}; })()`, scope);
 };
-/** Evaluate an expression body, transforming JSX to `React.createElement` only when needed. */
+/**
+ * Evaluate an expression body, transforming JSX to `React.createElement` only when the
+ * parsed estree actually contains a JSX node. The raw `Function()` evaluator can't parse
+ * JSX, so JSX-bearing expressions take the build-and-serialize path while everything else
+ * evaluates directly. Input acorn can't parse falls back to the plain evaluator unchanged.
+ */
 const evalExpression = (expression, scope) => {
-    if (HAS_JSX.test(expression))
-        return evalJsxExpression(expression, scope);
-    return evaluate(expression, scope);
+    let program;
+    try {
+        program = parseExpression(expression);
+    }
+    catch {
+        return evaluate(expression, scope);
+    }
+    if (!containsJsxNode(program))
+        return evaluate(expression, scope);
+    return evalJsxProgram(program, scope);
 };
+
+;// ./processor/transform/mdxish/evaluate-expressions.ts
+
+
+
+
 /** Given the type of the expression result, create the corresponding mdast node. */
 const createEvaluatedNode = (result, position) => {
     if (result === null || result === undefined) {
@@ -102624,6 +102636,8 @@ const separateBlockTagFromContent = (match, tag, inlineChar, nextLineChar) => {
     const breaks = '<br>'.repeat(newlineCount);
     return `</${tag}>${breaks}\n\n${inlineChar || nextLineChar}`;
 };
+/** Escape leading `-`/`*`/`+` (followed by space/EOL) so cells don't become bullet lists. */
+const escapeLeadingListMarkers = (text) => text.replace(/^([-*+])(?=[ \t]|$)/gm, '\\$1');
 /**
  * CommonMark doesn't process markdown inside HTML blocks -
  * so `<ul><li>_text_</li></ul>` won't convert underscores to emphasis.
@@ -102640,7 +102654,7 @@ const parseTableCell = (text) => {
         .replace(HTML_ELEMENT_BLOCK_RE, match => match.replace(NEWLINE_WITH_WHITESPACE_RE, '<br>'))
         .replace(CLOSE_BLOCK_TAG_BOUNDARY_RE, separateBlockTagFromContent);
     const trimmedLines = normalized.split('\n').map(line => line.trimStart());
-    const processed = trimmedLines.join('\n');
+    const processed = escapeLeadingListMarkers(trimmedLines.join('\n'));
     const tree = contentParser.runSync(contentParser.parse(processed));
     // Process markdown inside HTML blocks that have non-tag inner text (e.g. `<div>**x**`
     // or `<ul><li>_x_</li></ul>`). Pure bare tags like "<i>" or "<br>" are left for rehypeRaw
@@ -104168,6 +104182,45 @@ function preprocessJSXExpressions(content) {
     return processed;
 }
 
+;// ./processor/transform/mdxish/resolve-deferred-attribute-expression-props.ts
+
+
+
+/**
+ * Resolve attribute expressions that `mdxJsxElementHandler` deferred.
+ *
+ * The handler stashed each attribute expression's source in `node.data.deferredExpressions`
+ * (keyed by prop name) instead of evaluating eagerly, because an eager result can be a React
+ * element or function that rehypeRaw's `structuredClone` passthrough rejects. Now that we're
+ * past the clone, evaluate each source with a scope of `{ React, ...mdxishScope }` and write
+ * the real value into `properties` (e.g. an array of objects whose fields are React elements).
+ *
+ * Must run after `rehypeRaw` (past the clone) but before `normalizeMdxJsxNodes` rewrites these
+ * `mdx-jsx` nodes into plain elements. Skipped in safeMode, which keeps expressions literal.
+ */
+const resolveDeferredAttributeExpressionProps = () => (tree, file) => {
+    const scope = { ...file.data.mdxishScope, React: (external_amd_react_commonjs_react_commonjs2_react_root_React_umd_react_default()) };
+    visit(tree, 'mdx-jsx', (node) => {
+        const deferredExpressions = node.data?.deferredExpressions;
+        if (!deferredExpressions)
+            return;
+        const properties = node.properties;
+        Object.entries(deferredExpressions).forEach(([name, source]) => {
+            try {
+                properties[name] = evalExpression(source, scope);
+            }
+            catch {
+                // Evaluation failed — fall back to the raw expression source so the attribute
+                // renders as readable text rather than disappearing.
+                properties[name] = source;
+            }
+        });
+        delete node.data.deferredExpressions;
+    });
+    return tree;
+};
+/* harmony default export */ const resolve_deferred_attribute_expression_props = (resolveDeferredAttributeExpressionProps);
+
 ;// ./processor/transform/mdxish/restore-snake-case-component-name.ts
 
 
@@ -105197,6 +105250,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -105356,6 +105410,7 @@ function mdxish(mdContent, opts = {}) {
         .use(preserveBooleanProperties) // RehypeRaw converts boolean properties to empty strings
         .use(rehypeRaw, { passThrough: ['html-block', 'mdx-jsx'] }) // MDX JSX nodes bypass parse5's string-only HTML round-trip
         .use(restoreBooleanProperties)
+        .use(safeMode ? undefined : resolve_deferred_attribute_expression_props) // Evaluate deferred attribute expressions on mdx-jsx nodes (now past rehypeRaw's clone)
         .use(normalize_mdx_jsx_nodes) // Rewrite `mdx-jsx` back to standard `element` nodes for downstream plugins
         .use(rehypeFlattenTableCellParagraphs) // Remove <p> wrappers inside table cells to prevent margin issues
         .use(mdxish_mermaid) // Add mermaid-render className to pre wrappers
@@ -105391,6 +105446,10 @@ const mix = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_mix = (mix);
 
+;// ./lib/extractToc.ts
+
+/* harmony default export */ const lib_extractToc = (extractToc);
+
 ;// ./processor/transform/migrate-callouts.ts
 
 
@@ -105832,12 +105891,16 @@ const tags = (doc) => {
 
 
 
+
+
+
 const mdxishTags_tags = (doc) => {
     const set = new Set();
     const processor = remark()
-        .data('micromarkExtensions', [magicBlock(), mdxComponent()])
-        .data('fromMarkdownExtensions', [magicBlockFromMarkdown(), mdxComponentFromMarkdown()])
-        .use(mdx_blocks);
+        .data('micromarkExtensions', [jsxTable(), magicBlock(), mdxComponent()])
+        .data('fromMarkdownExtensions', [jsxTableFromMarkdown(), magicBlockFromMarkdown(), mdxComponentFromMarkdown()])
+        .use(mdx_blocks)
+        .use(mdxish_tables);
     const tree = processor.parse(doc);
     visit(processor.runSync(tree), isMDXElement, (node) => {
         if (node.name?.match(/^[A-Z]/)) {
@@ -105987,6 +106050,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 ;// ./index.tsx
 
 

package/dist/main.node.js

@@ -19283,6 +19283,7 @@ __webpack_require__.d(__webpack_exports__, {
   Owlmoji: () => (/* reexport */ Owlmoji),
   compile: () => (/* reexport */ lib_compile),
   exports: () => (/* reexport */ lib_exports),
+  extractToc: () => (/* reexport */ lib_extractToc),
   gemojiRegex: () => (/* reexport */ gemoji_regex),
   hast: () => (/* reexport */ lib_hast),
   mdast: () => (/* reexport */ lib_mdast),
@@ -25084,6 +25085,7 @@ function useScrollHighlight(navRef) {
                     const linkRect = link.getBoundingClientRect();
                     nav.style.setProperty('--ToC-border-active-height', `${linkRect.height}px`);
                     nav.style.setProperty('--ToC-border-active-top', `${linkRect.top - navRect.top}px`);
+                    link.scrollIntoView?.({ block: 'nearest', behavior: 'smooth' });
                 }
             }
         };
@@ -118979,26 +118981,17 @@ const rehypeMdxishComponents = ({ components, processMarkdown }) => {
 ;// ./processor/plugin/mdxish-handlers.ts
 
 
-
 // Convert MDX expressions to text nodes (evaluation happens earlier in pipeline)
 const mdxExpressionHandler = (_state, node) => ({
     type: 'text',
     value: node.value || '',
 });
-function isStructuredCloneable(value) {
-    try {
-        structuredClone(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 // Convert MDX JSX elements to a custom mdx-jsx hast node that bypasses rehypeRaw's
 // HTML serialization round-trip; downstream normalization rewrites it to `element`.
 const mdxJsxElementHandler = (state, node) => {
     const { attributes = [], name } = node;
     const properties = {};
+    const deferredExpressions = {};
     attributes.forEach(attribute => {
         if (attribute.type !== 'mdxJsxAttribute' || !attribute.name)
             return;
@@ -119009,30 +119002,20 @@ const mdxJsxElementHandler = (state, node) => {
             properties[attribute.name] = decode_decodeHTMLStrict(attribute.value);
         }
         else {
-            const expressionSource = attribute.value.value;
-            let evaluated;
-            try {
-                evaluated = evaluate(expressionSource);
-            }
-            catch {
-                evaluated = expressionSource;
-            }
-            // rehypeRaw's passThrough clones our mdx-jsx node with structuredClone, which
-            // rejects functions and other non-serializable values. Attribute expressions
-            // that evaluate to such values (`onClick={() => ...}`) would crash the pipeline,
-            // so if we have a non-serializable value, we fall back to the raw expression source
-            // and not support it for now.
-            if (!isStructuredCloneable(evaluated)) {
-                evaluated = expressionSource;
-            }
-            properties[attribute.name] = evaluated;
+            // Defer every attribute-expression evaluation past rehypeRaw's `structuredClone`
+            // passthrough: evaluating here can yield React elements or functions that the clone
+            // rejects. The source is stashed in `node.data` (clone-safe) and
+            // `resolveDeferredAttributeExpressionProps` evaluates it once past the clone.
+            deferredExpressions[attribute.name] = attribute.value.value;
         }
     });
+    const hasDeferredExpressions = Object.keys(deferredExpressions).length > 0;
     const jsxNode = {
         type: 'mdx-jsx',
         tagName: name || '',
-        properties,
+        properties: properties,
         children: state.all(node),
+        ...(hasDeferredExpressions && { data: { deferredExpressions } }),
     };
     return jsxNode;
 };
@@ -122314,27 +122297,56 @@ const evaluateExports = () => (tree, file) => {
 
 // EXTERNAL MODULE: ./node_modules/react-dom/server.node.js
 var server_node = __webpack_require__(4362);
-;// ./processor/transform/mdxish/evaluate-expressions.ts
-
+;// ./lib/utils/mdxish/mdxish-expression.ts
 
 
 
-
-
-const HAS_JSX = /<[A-Za-z]|<>/;
-/** The raw Function() can't parse JSX, so parse & convert it to a React element first so later we can get its HTML representation */
-const evalJsxExpression = (expression, scope) => {
-    const program = jsxAcornParser.parse(expression, { ecmaVersion: 'latest', sourceType: 'module' });
+const parseExpression = (expression) => jsxAcornParser.parse(expression, { ecmaVersion: 'latest', sourceType: 'module' });
+/**
+ * Recursively report whether an estree value contains any JSX element or fragment node.
+ * estree stores children across named fields (not a `children` array), so this descends
+ * through every nested object/array rather than using a unist-shaped walker.
+ */
+const containsJsxNode = (value) => {
+    if (Array.isArray(value))
+        return value.some(containsJsxNode);
+    if (value === null || typeof value !== 'object')
+        return false;
+    const { type } = value;
+    if (type === 'JSXElement' || type === 'JSXFragment')
+        return true;
+    return Object.values(value).some(containsJsxNode);
+};
+/** Convert a program's JSX into `React.createElement` calls and evaluate it. `scope` must provide `React`. */
+const evalJsxProgram = (program, scope) => {
     buildJsx(program, { runtime: 'classic', pragma: 'React.createElement', pragmaFrag: 'React.Fragment' });
     const { value: source } = toJs(program);
     return evaluate(`(() => { return ${source.trim().replace(/;$/, '')}; })()`, scope);
 };
-/** Evaluate an expression body, transforming JSX to `React.createElement` only when needed. */
+/**
+ * Evaluate an expression body, transforming JSX to `React.createElement` only when the
+ * parsed estree actually contains a JSX node. The raw `Function()` evaluator can't parse
+ * JSX, so JSX-bearing expressions take the build-and-serialize path while everything else
+ * evaluates directly. Input acorn can't parse falls back to the plain evaluator unchanged.
+ */
 const evalExpression = (expression, scope) => {
-    if (HAS_JSX.test(expression))
-        return evalJsxExpression(expression, scope);
-    return evaluate(expression, scope);
+    let program;
+    try {
+        program = parseExpression(expression);
+    }
+    catch {
+        return evaluate(expression, scope);
+    }
+    if (!containsJsxNode(program))
+        return evaluate(expression, scope);
+    return evalJsxProgram(program, scope);
 };
+
+;// ./processor/transform/mdxish/evaluate-expressions.ts
+
+
+
+
 /** Given the type of the expression result, create the corresponding mdast node. */
 const createEvaluatedNode = (result, position) => {
     if (result === null || result === undefined) {
@@ -122848,6 +122860,8 @@ const separateBlockTagFromContent = (match, tag, inlineChar, nextLineChar) => {
     const breaks = '<br>'.repeat(newlineCount);
     return `</${tag}>${breaks}\n\n${inlineChar || nextLineChar}`;
 };
+/** Escape leading `-`/`*`/`+` (followed by space/EOL) so cells don't become bullet lists. */
+const escapeLeadingListMarkers = (text) => text.replace(/^([-*+])(?=[ \t]|$)/gm, '\\$1');
 /**
  * CommonMark doesn't process markdown inside HTML blocks -
  * so `<ul><li>_text_</li></ul>` won't convert underscores to emphasis.
@@ -122864,7 +122878,7 @@ const parseTableCell = (text) => {
         .replace(HTML_ELEMENT_BLOCK_RE, match => match.replace(NEWLINE_WITH_WHITESPACE_RE, '<br>'))
         .replace(CLOSE_BLOCK_TAG_BOUNDARY_RE, separateBlockTagFromContent);
     const trimmedLines = normalized.split('\n').map(line => line.trimStart());
-    const processed = trimmedLines.join('\n');
+    const processed = escapeLeadingListMarkers(trimmedLines.join('\n'));
     const tree = contentParser.runSync(contentParser.parse(processed));
     // Process markdown inside HTML blocks that have non-tag inner text (e.g. `<div>**x**`
     // or `<ul><li>_x_</li></ul>`). Pure bare tags like "<i>" or "<br>" are left for rehypeRaw
@@ -124392,6 +124406,45 @@ function preprocessJSXExpressions(content) {
     return processed;
 }
 
+;// ./processor/transform/mdxish/resolve-deferred-attribute-expression-props.ts
+
+
+
+/**
+ * Resolve attribute expressions that `mdxJsxElementHandler` deferred.
+ *
+ * The handler stashed each attribute expression's source in `node.data.deferredExpressions`
+ * (keyed by prop name) instead of evaluating eagerly, because an eager result can be a React
+ * element or function that rehypeRaw's `structuredClone` passthrough rejects. Now that we're
+ * past the clone, evaluate each source with a scope of `{ React, ...mdxishScope }` and write
+ * the real value into `properties` (e.g. an array of objects whose fields are React elements).
+ *
+ * Must run after `rehypeRaw` (past the clone) but before `normalizeMdxJsxNodes` rewrites these
+ * `mdx-jsx` nodes into plain elements. Skipped in safeMode, which keeps expressions literal.
+ */
+const resolveDeferredAttributeExpressionProps = () => (tree, file) => {
+    const scope = { ...file.data.mdxishScope, React: (external_react_default()) };
+    visit(tree, 'mdx-jsx', (node) => {
+        const deferredExpressions = node.data?.deferredExpressions;
+        if (!deferredExpressions)
+            return;
+        const properties = node.properties;
+        Object.entries(deferredExpressions).forEach(([name, source]) => {
+            try {
+                properties[name] = evalExpression(source, scope);
+            }
+            catch {
+                // Evaluation failed — fall back to the raw expression source so the attribute
+                // renders as readable text rather than disappearing.
+                properties[name] = source;
+            }
+        });
+        delete node.data.deferredExpressions;
+    });
+    return tree;
+};
+/* harmony default export */ const resolve_deferred_attribute_expression_props = (resolveDeferredAttributeExpressionProps);
+
 ;// ./processor/transform/mdxish/restore-snake-case-component-name.ts
 
 
@@ -125421,6 +125474,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -125580,6 +125634,7 @@ function mdxish(mdContent, opts = {}) {
         .use(preserveBooleanProperties) // RehypeRaw converts boolean properties to empty strings
         .use(rehypeRaw, { passThrough: ['html-block', 'mdx-jsx'] }) // MDX JSX nodes bypass parse5's string-only HTML round-trip
         .use(restoreBooleanProperties)
+        .use(safeMode ? undefined : resolve_deferred_attribute_expression_props) // Evaluate deferred attribute expressions on mdx-jsx nodes (now past rehypeRaw's clone)
         .use(normalize_mdx_jsx_nodes) // Rewrite `mdx-jsx` back to standard `element` nodes for downstream plugins
         .use(rehypeFlattenTableCellParagraphs) // Remove <p> wrappers inside table cells to prevent margin issues
         .use(mdxish_mermaid) // Add mermaid-render className to pre wrappers
@@ -125615,6 +125670,10 @@ const mix = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_mix = (mix);
 
+;// ./lib/extractToc.ts
+
+/* harmony default export */ const lib_extractToc = (extractToc);
+
 ;// ./processor/transform/migrate-callouts.ts
 
 
@@ -126056,12 +126115,16 @@ const tags = (doc) => {
 
 
 
+
+
+
 const mdxishTags_tags = (doc) => {
     const set = new Set();
     const processor = remark()
-        .data('micromarkExtensions', [magicBlock(), mdxComponent()])
-        .data('fromMarkdownExtensions', [magicBlockFromMarkdown(), mdxComponentFromMarkdown()])
-        .use(mdx_blocks);
+        .data('micromarkExtensions', [jsxTable(), magicBlock(), mdxComponent()])
+        .data('fromMarkdownExtensions', [jsxTableFromMarkdown(), magicBlockFromMarkdown(), mdxComponentFromMarkdown()])
+        .use(mdx_blocks)
+        .use(mdxish_tables);
     const tree = processor.parse(doc);
     visit(processor.runSync(tree), isMDXElement, (node) => {
         if (node.name?.match(/^[A-Z]/)) {
@@ -126211,6 +126274,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 ;// ./index.tsx