@readme/markdown 14.7.2 → 14.8.1

package/dist/main.node.js

@@ -19377,15 +19377,34 @@ __webpack_require__.d(util_types_namespaceObject, {
 // EXTERNAL MODULE: external "react"
 var external_react_ = __webpack_require__(4953);
 var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_);
+;// ./components/Icon/index.tsx
+
+/** @see https://docs-v5.fontawesome.com/web/reference-icons */
+const FA_PREFIXES = new Set(['fa', 'fab', 'fad', 'fal', 'far', 'fas', 'fast', 'fasl', 'fasr', 'fass', 'fat']);
+/**
+ * Renders an icon element, either as a Font Awesome icon or an emoji.
+ */
+const Icon = ({ className, icon, iconColor }) => {
+    const hasFontAwesomePrefix = FA_PREFIXES.has(icon.split(' ')[0]);
+    const isFontAwesome = hasFontAwesomePrefix || icon.startsWith('fa-');
+    if (!isFontAwesome) {
+        return external_react_default().createElement("span", { className: className }, icon);
+    }
+    const faClasses = hasFontAwesomePrefix ? icon : `fa-duotone fa-solid ${icon}`;
+    return external_react_default().createElement("i", { className: `${className} ${faClasses}`, style: iconColor ? { color: iconColor } : undefined });
+};
+/* harmony default export */ const components_Icon = (Icon);
+
 ;// ./components/Accordion/index.tsx
 
 
+
 const Accordion = ({ children, icon, iconColor, title }) => {
     const [isOpen, setIsOpen] = (0,external_react_.useState)(false);
     return (external_react_default().createElement("details", { className: "Accordion", onToggle: () => setIsOpen(!isOpen) },
         external_react_default().createElement("summary", { className: "Accordion-title" },
             external_react_default().createElement("i", { className: `Accordion-toggleIcon${isOpen ? '_opened' : ''} fa fa-regular fa-chevron-right` }),
-            icon && external_react_default().createElement("i", { className: `Accordion-icon fa-duotone fa-solid ${icon}`, style: { color: `${iconColor}` } }),
+            icon && external_react_default().createElement(components_Icon, { className: "Accordion-icon", icon: icon, iconColor: iconColor }),
             title),
         external_react_default().createElement("div", { className: "Accordion-content" }, children)));
 };
@@ -19507,10 +19526,11 @@ const Callout = (props) => {
 ;// ./components/Cards/index.tsx
 
 
+
 const Card = ({ badge, children, href, kind = 'card', icon, iconColor, target, title }) => {
     const Tag = href ? 'a' : 'div';
     return (external_react_default().createElement(Tag, { className: `Card Card_${kind}`, href: href, target: target },
-        icon && external_react_default().createElement("i", { className: `Card-icon fa-duotone fa-solid ${icon}`, style: { '--Card-icon-color': iconColor } }),
+        icon && external_react_default().createElement(components_Icon, { className: "Card-icon", icon: icon, iconColor: iconColor }),
         external_react_default().createElement("div", { className: "Card-content" },
             title && (external_react_default().createElement("div", { className: "Card-title" },
                 title,
@@ -25129,10 +25149,18 @@ function useScrollHighlight(navRef) {
             return rect.top >= 0 && rect.top < window.innerHeight * VISIBLE_RATIO;
         }) || headings[0];
         activate(initialHeading.id);
+        // Snap the active indicator to its initial position without animating, then
+        // enable transitions so only subsequent scroll updates animate. The forced
+        // reflow (reading layout) commits the snapped position as the transition
+        // baseline — otherwise enabling the transition in the same style recalc would
+        // animate it in from height 0 every time the TOC (re)mounts.
+        nav.getBoundingClientRect();
+        nav.dataset.tocReady = 'true';
         return () => {
             observer.disconnect();
             scrollTarget.removeEventListener('scroll', onScroll);
             nav.removeEventListener('click', onClick);
+            delete nav.dataset.tocReady;
         };
     }, [navRef, tocKey]);
 }
@@ -25148,6 +25176,7 @@ function TableOfContents({ children }) {
 ;// ./components/Tabs/index.tsx
 
 
+
 const Tab = ({ children }) => {
     return external_react_default().createElement("div", { className: "TabContent" }, children);
 };
@@ -25158,7 +25187,7 @@ const Tabs = ({ children }) => {
     return (external_react_default().createElement("div", { className: "TabGroup" },
         external_react_default().createElement("header", null,
             external_react_default().createElement("nav", { className: "TabGroup-nav" }, tabs.map((tab, index) => (external_react_default().createElement("button", { key: tab.props.title, className: `TabGroup-tab${activeTab === index ? '_active' : ''}`, onClick: () => setActiveTab(index) },
-                tab.props.icon && (external_react_default().createElement("i", { className: `TabGroup-icon fa-duotone fa-solid ${tab.props.icon}`, style: { color: `${tab.props.iconColor}` } })),
+                tab.props.icon && (external_react_default().createElement(components_Icon, { className: "TabGroup-icon", icon: tab.props.icon, iconColor: tab.props.iconColor })),
                 tab.props.title))))),
         external_react_default().createElement("section", null, tabs[activeTab])));
 };
@@ -118950,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;
@@ -118980,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;
 };
@@ -122285,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) {
@@ -124363,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
 
 
@@ -125392,6 +125470,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -125551,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