@readme/markdown 14.8.0 → 14.8.1

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

@@ -98755,26 +98755,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 +98776,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 +102071,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) {
@@ -104168,6 +104178,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 +105246,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -105356,6 +105406,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

package/dist/main.node.js

@@ -118979,26 +118979,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 +119000,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 +122295,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) {
@@ -124392,6 +124402,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 +125470,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -125580,6 +125630,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