@readme/markdown 15.0.1 → 15.1.0

package/dist/main.node.js

@@ -24807,6 +24807,9 @@ const GlossaryContext = (0,external_react_.createContext)([]);
 
 
 
+/** Tippy portals to document.body by default, which would break the
+ *  `.rm-ReadMe[data-color-mode] …` descendant selectors in style.scss. */
+const appendToReadMeRoot = (ref) => ref.closest('.rm-ReadMe') ?? document.body;
 const Glossary = ({ children, term: termProp, terms }) => {
     const term = (Array.isArray(children) ? children[0] : children) || termProp;
     if (!term)
@@ -24814,7 +24817,7 @@ const Glossary = ({ children, term: termProp, terms }) => {
     const foundTerm = terms.find(i => term.toLowerCase() === i?.term?.toLowerCase());
     if (!foundTerm)
         return external_react_default().createElement("span", null, term);
-    return (external_react_default().createElement(tippy_react_esm, { content: external_react_default().createElement("div", { className: "GlossaryItem-tooltip-content" },
+    return (external_react_default().createElement(tippy_react_esm, { appendTo: appendToReadMeRoot, content: external_react_default().createElement("div", { className: "GlossaryItem-tooltip-content" },
             external_react_default().createElement("strong", { className: "GlossaryItem-term" }, foundTerm.term),
             " - ",
             foundTerm.definition), offset: [-5, 5], placement: "bottom-start" },
@@ -74989,12 +74992,104 @@ const mdast = (text, opts = {}) => {
  */
 const jsxAcornParser = Parser.extend(acorn_jsx_default()());
 
+;// ./lib/utils/literal-expression.ts
+
+const unsupported = (description) => new Error(`not a literal expression: ${description}`);
+/** Narrows a resolved value for arithmetic, so operands never coerce to `NaN` or `"[object Object]"`. */
+const asNumber = (value) => {
+    if (typeof value !== 'number')
+        throw unsupported('non-numeric operand');
+    return value;
+};
+const asOperand = (value) => {
+    if (typeof value !== 'number' && typeof value !== 'string')
+        throw unsupported('non-primitive operand');
+    return value;
+};
+const ARITHMETIC_OPERATORS = {
+    // `+` doubles as string concatenation, so it accepts a string on either side.
+    '+': (left, right) => (typeof left === 'number' && typeof right === 'number' ? left + right : `${left}${right}`),
+    '-': (left, right) => asNumber(left) - asNumber(right),
+    '*': (left, right) => asNumber(left) * asNumber(right),
+    '/': (left, right) => asNumber(left) / asNumber(right),
+};
+/** Resolve one estree node, recursing into arrays and objects. Throws for anything not on the allowlist. */
+const resolveNode = (node) => {
+    switch (node.type) {
+        case 'Literal':
+            // Regex and bigint `Literal`s hold values a tree consumer can't serialise;
+            // a BigInt throws outright in `JSON.stringify`.
+            if ('regex' in node || 'bigint' in node)
+                throw unsupported('regex or bigint literal');
+            return node.value;
+        case 'Identifier':
+            if (node.name !== 'undefined')
+                throw unsupported(`identifier \`${node.name}\``);
+            return undefined;
+        case 'TemplateLiteral':
+            if (node.expressions.length)
+                throw unsupported('template substitution');
+            return node.quasis.map(quasi => quasi.value.cooked).join('');
+        case 'UnaryExpression':
+            if (node.operator !== '-')
+                throw unsupported(`operator \`${node.operator}\``);
+            return -asNumber(resolveNode(node.argument));
+        case 'BinaryExpression': {
+            const applyOperator = ARITHMETIC_OPERATORS[node.operator];
+            if (!applyOperator)
+                throw unsupported(`operator \`${node.operator}\``);
+            return applyOperator(asOperand(resolveNode(node.left)), asOperand(resolveNode(node.right)));
+        }
+        case 'ArrayExpression':
+            return node.elements.map(element => (element === null ? null : resolveNode(element)));
+        case 'ObjectExpression':
+            return node.properties.reduce((memo, property) => {
+                if (property.type !== 'Property' || property.computed)
+                    throw unsupported('computed or spread property');
+                const { key } = property;
+                if (key.type !== 'Identifier' && key.type !== 'Literal')
+                    throw unsupported('property key');
+                const name = key.type === 'Identifier' ? key.name : String(key.value);
+                // `__proto__` would replace the object's prototype rather than add a property.
+                if (name === '__proto__')
+                    throw unsupported('`__proto__` key');
+                memo[name] = resolveNode(property.value);
+                return memo;
+            }, {});
+        default:
+            throw unsupported(node.type);
+    }
+};
+/**
+ * Resolve a JSX attribute expression's source to its value without executing it.
+ *
+ * Supports the literal syntax attributes actually use — `true`, `"a"`, `` `a` ``,
+ * `undefined`, `{ textAlign: "left" }`, `["left"]`, `1 + 1`, `'https://' + 'x.com'` —
+ * and refuses everything else, so no identifier, member access, call, assignment or
+ * function body can ever run. The trade-off is that expressions needing a scope or a
+ * method call (`{item.url}`, `{"a".toUpperCase()}`) throw, and callers keep the raw
+ * source instead — the same fallback they already used for an expression that threw.
+ * mdxish rendering is unaffected, since it resolves those later with its scoped
+ * evaluator; only consumers reading attributes straight off the tree see the source.
+ *
+ * @param source expression body, without the surrounding braces
+ * @throws if `source` is unparseable or isn't a supported literal expression
+ */
+const evaluateLiteralExpression = (source) => {
+    const expression = jsxAcornParser.parseExpressionAt(source, 0, { ecmaVersion: 'latest' });
+    // acorn stops at the first complete expression, so anything trailing means this isn't one.
+    if (expression.end !== source.trimEnd().length)
+        throw unsupported('trailing content');
+    return resolveNode(expression);
+};
+
 ;// ./processor/utils.ts
 
 
 
 
 
+
 /**
  * Evaluate a JavaScript expression source and return its value.
  *
@@ -75092,8 +75187,10 @@ const getAttrs = (jsx) => jsx.attributes.reduce((memo, attr) => {
             memo[attr.name] = decode_decodeHTMLStrict(attr.value);
         }
         else if (attr.value?.value !== undefined) {
+            // Expression values only survive to here when safeMode is off; `flattenAttributeExpressions`
+            // rewrites them to plain strings at the head of the pipeline otherwise.
             try {
-                memo[attr.name] = evaluate(attr.value.value);
+                memo[attr.name] = evaluateLiteralExpression(attr.value.value);
             }
             catch {
                 memo[attr.name] = attr.value.value;
@@ -75874,6 +75971,31 @@ const embedTransformer = () => {
 };
 /* harmony default export */ const transform_embeds = (embedTransformer);
 
+;// ./processor/transform/flatten-attribute-expressions.ts
+
+
+/**
+ * Rewrites JSX attribute expressions (`icon={String(1 + 3)}`) into plain string attributes
+ * holding their literal source, so nothing downstream can evaluate them.
+ *
+ * This is the RMDX counterpart to mdxish's `preserveExpressionsAsText` parse option: safeMode's
+ * contract is enforced once, at the head of the pipeline, rather than at every `getAttrs()` call
+ * site. Only registered when safeMode is on.
+ */
+const flattenAttributeExpressions = () => tree => {
+    visit(tree, isMDXElement, (node) => {
+        node.attributes.forEach(attr => {
+            if (!('name' in attr))
+                return;
+            if (attr.value === null || typeof attr.value === 'string')
+                return;
+            attr.value = attr.value.value;
+        });
+    });
+    return tree;
+};
+/* harmony default export */ const flatten_attribute_expressions = (flattenAttributeExpressions);
+
 ;// ./node_modules/gemoji/index.js
 /**
  * @typedef Gemoji
@@ -97178,13 +97300,36 @@ const MARKER_PATTERNS = [
 // Pattern for ** bold **
 // Groups: 1=wordBefore, 2=marker, 3=contentWithSpaceAfter, 4=trailingSpace1, 5=contentWithSpaceBefore, 6=trailingSpace2, 7=afterChar
 // trailingSpace1 is for "** text **" pattern, trailingSpace2 is for "**text **" pattern
-const asteriskBoldRegex = /([^*\s]+)?\s*(\*\*)(?:\s+((?:[^*\n]|\*(?!\*))+?)(\s*)\2|((?:[^*\n]|\*(?!\*))+?)(\s+)\2)(\S|$)?/g;
+//
+// The wordBefore and whitespace prefixes are deliberately bounded ({1,64} /
+// {0,8}) rather than unbounded (+ / *). An unbounded prefix makes matchAll
+// re-scan an arbitrarily long run from every character position, which turns
+// the pass O(n²) on text nodes containing huge unbroken tokens (pasted base64
+// payloads, minified code). Bounding the prefix caps the backtracking per
+// position; a prefix longer than the bound just starts the match later, and
+// the cut-off chars flow into the preceding text node instead — adjacent text
+// parts are merged before splicing, so the emitted AST is unchanged.
+//
+// The content quantifiers are bounded too ({1,500}). The underscore content
+// clauses can scan across `_` (needed for snake_case content), so without a
+// bound every `_` in a marker-dense token (base64url, snake_case identifiers)
+// re-scans to end-of-line looking for a closer — O(n²) again. Content already
+// can't cross a newline, and 500 chars covers any sentence-length emphasis
+// phrase; longer spans stay unnormalized rather than costing quadratic scans.
+const asteriskBoldRegex = /([^*\s]{1,64})?\s{0,8}(\*\*)(?:\s+((?:[^*\n]|\*(?!\*)){1,500}?)(\s*)\2|((?:[^*\n]|\*(?!\*)){1,500}?)(\s+)\2)(\S|$)?/g;
 // Pattern for __ bold __
-const underscoreBoldRegex = /([^_\s]+)?\s*(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n])+?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n])+?)(\s+)\2)(\S|$)?/g;
+const underscoreBoldRegex = /([^_\s]{1,64})?\s{0,8}(__)(?:\s+((?:__(?! )|_(?!_)|[^_\n]){1,500}?)(\s*)\2|((?:__(?! )|_(?!_)|[^_\n]){1,500}?)(\s+)\2)(\S|$)?/g;
 // Pattern for * italic *
-const asteriskItalicRegex = /([^*\s]+)?\s*(\*)(?!\*)(?:\s+([^*\n]+?)(\s*)\2|([^*\n]+?)(\s+)\2)(\S|$)?/g;
+const asteriskItalicRegex = /([^*\s]{1,64})?\s{0,8}(\*)(?!\*)(?:\s+([^*\n]{1,500}?)(\s*)\2|([^*\n]{1,500}?)(\s+)\2)(\S|$)?/g;
 // Pattern for _ italic _
-const underscoreItalicRegex = /([^_\s]+)?\s*(_)(?!_)(?:\s+((?:[^_\n]|_(?! ))+?)(\s*)\2|((?:[^_\n]|_(?! ))+?)(\s+)\2)(\S|$)?/g;
+const underscoreItalicRegex = /([^_\s]{1,64})?\s{0,8}(_)(?!_)(?:\s+((?:[^_\n]|_(?! )){1,500}?)(\s*)\2|((?:[^_\n]|_(?! )){1,500}?)(\s+)\2)(\S|$)?/g;
+// Every loose alternation requires whitespace beside a marker — after the
+// opening (`** text**`) or before the closing (`**text **`) — so
+// marker-beside-whitespace is an exact gate for the loose families. A single
+// linear probe skips them entirely on marker-dense tokens whose markers are
+// all intraword (base64url payloads, snake_case identifiers).
+const asteriskBesideWhitespaceRegex = /\*\s|\s\*/;
+const underscoreBesideWhitespaceRegex = /_\s|\s_/;
 // CommonMark ignores intraword underscores or asteriks, but we want to italicize/bold the inner part
 // Pattern for intraword _word_ in words like hello_world_
 const intrawordUnderscoreItalicRegex = /(\w)_(?!_)([a-zA-Z0-9]+)_(?![\w_])/g;
@@ -97194,6 +97339,23 @@ const intrawordUnderscoreBoldRegex = /(\w)__([a-zA-Z0-9]+)__(?![\w_])/g;
 const intrawordAsteriskItalicRegex = /(\w)\*(?!\*)([a-zA-Z0-9]+)\*(?![\w*])/g;
 // Pattern for intraword **word** in words like hello**world**
 const intrawordAsteriskBoldRegex = /(\w)\*\*([a-zA-Z0-9]+)\*\*(?![\w*])/g;
+// All regex families, in match-precedence order: collected matches are
+// stable-sorted by match.index, so at an equal index the earlier row wins the
+// overlap filter — keep this order. `gate` names the per-node precondition
+// (see the gate record in the visitor) checked before the family's regex
+// runs, so a node that can't possibly match never pays for a full scan: the
+// intraword families need their marker character present, and the loose
+// families additionally need that marker beside whitespace.
+const REGEX_FAMILIES = [
+    { regex: asteriskBoldRegex, isBold: true, marker: '**', gate: 'asteriskLoose' },
+    { regex: underscoreBoldRegex, isBold: true, marker: '__', gate: 'underscoreLoose' },
+    { regex: asteriskItalicRegex, isBold: false, marker: '*', gate: 'asteriskLoose' },
+    { regex: underscoreItalicRegex, isBold: false, marker: '_', gate: 'underscoreLoose' },
+    { regex: intrawordUnderscoreItalicRegex, isBold: false, isIntraword: true, marker: '_', gate: 'underscore' },
+    { regex: intrawordUnderscoreBoldRegex, isBold: true, isIntraword: true, marker: '__', gate: 'underscore' },
+    { regex: intrawordAsteriskItalicRegex, isBold: false, isIntraword: true, marker: '*', gate: 'asterisk' },
+    { regex: intrawordAsteriskBoldRegex, isBold: true, isIntraword: true, marker: '**', gate: 'asterisk' },
+];
 /**
  * Finds opening emphasis marker in a text value.
  * Returns marker info if found, null otherwise.
@@ -97385,6 +97547,21 @@ function isInsideInlineHtmlCode(index, parent) {
  * malformed emphasis syntax. This plugin post-processes the AST to handle these cases.
  */
 const normalizeEmphasisAST = () => (tree) => {
+    // Back-scanning siblings for <code>…</code> html pairs costs O(children)
+    // per text node — O(children²) per parent, which bites on marker-dense
+    // paragraphs where micromark emits thousands of inline children. Most
+    // parents have no html children at all, so cache that check per parent and
+    // skip the back-scan entirely. The cached flag survives our splices: they
+    // only ever swap text nodes for text/strong/emphasis, never html.
+    const hasHtmlChild = new WeakMap();
+    const mayBeInsideInlineHtmlCode = (index, parent) => {
+        let flag = hasHtmlChild.get(parent);
+        if (flag === undefined) {
+            flag = parent.children.some(child => child.type === 'html');
+            hasHtmlChild.set(parent, flag);
+        }
+        return flag && isInsideInlineHtmlCode(index, parent);
+    };
     visit(tree, 'text', function visitor(node, index, parent) {
         if (index === undefined || !parent)
             return undefined;
@@ -97396,41 +97573,39 @@ const normalizeEmphasisAST = () => (tree) => {
         // raw HTML <code>...</code> inside table cells, which the table re-parser
         // parses as MDX JSX (not as an mdast `inlineCode` node).
         if ((parent.type === 'mdxJsxTextElement' || parent.type === 'mdxJsxFlowElement') &&
-            'name' in parent && parent.name === 'code') {
+            'name' in parent &&
+            parent.name === 'code') {
             return undefined;
         }
+        const text = node.value;
+        // The regexes below can't match without their marker character, but
+        // running them anyway costs a scan of the whole node — ruinous on huge
+        // pasted payloads (base64 attachments, minified code). Checked before the
+        // html-sibling scan so marker-free text never pays for that either.
+        const hasAsterisk = text.includes('*');
+        const hasUnderscore = text.includes('_');
+        if (!hasAsterisk && !hasUnderscore)
+            return undefined;
         // In GFM tables, inline <code>...</code> is represented as sibling `html`
         // nodes rather than as an mdxJsxTextElement, so the check above doesn't
         // apply. Scan backwards through siblings to see if we are enclosed by a
         // <code>…</code> inline HTML pair.
-        if (isInsideInlineHtmlCode(index, parent)) {
+        if (mayBeInsideInlineHtmlCode(index, parent)) {
             return undefined;
         }
-        const text = node.value;
+        const gates = {
+            asterisk: hasAsterisk,
+            asteriskLoose: hasAsterisk && asteriskBesideWhitespaceRegex.test(text),
+            underscore: hasUnderscore,
+            underscoreLoose: hasUnderscore && underscoreBesideWhitespaceRegex.test(text),
+        };
         const allMatches = [];
-        [...text.matchAll(asteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '**', match });
-        });
-        [...text.matchAll(underscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, marker: '__', match });
-        });
-        [...text.matchAll(asteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '*', match });
-        });
-        [...text.matchAll(underscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, marker: '_', match });
-        });
-        [...text.matchAll(intrawordUnderscoreItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, isIntraword: true, marker: '_', match });
-        });
-        [...text.matchAll(intrawordUnderscoreBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, isIntraword: true, marker: '__', match });
-        });
-        [...text.matchAll(intrawordAsteriskItalicRegex)].forEach(match => {
-            allMatches.push({ isBold: false, isIntraword: true, marker: '*', match });
-        });
-        [...text.matchAll(intrawordAsteriskBoldRegex)].forEach(match => {
-            allMatches.push({ isBold: true, isIntraword: true, marker: '**', match });
+        REGEX_FAMILIES.forEach(({ regex, gate, ...info }) => {
+            if (!gates[gate])
+                return;
+            [...text.matchAll(regex)].forEach(match => {
+                allMatches.push({ ...info, match });
+            });
         });
         if (allMatches.length === 0)
             return undefined;
@@ -97527,9 +97702,22 @@ const normalizeEmphasisAST = () => (tree) => {
                 parts.push({ type: 'text', value: remainingText });
             }
         }
-        if (parts.length > 0) {
-            parent.children.splice(index, 1, ...parts);
-            return [SKIP, index + parts.length];
+        // Merge adjacent text parts so the emitted AST doesn't depend on where a
+        // match happened to start (the bounded prefixes above can shift a match
+        // start rightward, splitting what used to be a single text node).
+        const mergedParts = parts.reduce((acc, part) => {
+            const prev = acc[acc.length - 1];
+            if (part.type === 'text' && prev?.type === 'text') {
+                prev.value += part.value;
+            }
+            else {
+                acc.push(part);
+            }
+            return acc;
+        }, []);
+        if (mergedParts.length > 0) {
+            parent.children.splice(index, 1, ...mergedParts);
+            return [SKIP, index + mergedParts.length];
         }
         return undefined;
     });
@@ -101643,6 +101831,7 @@ const variables = ({ asMdx } = { asMdx: true }) => tree => {
 
 
 
+
 const defaultTransforms = {
     calloutTransformer: callouts,
     codeTabsTransformer: code_tabs,
@@ -101670,6 +101859,9 @@ const astProcessor = (opts = {}) => {
     const components = opts.components || {};
     let processor = remark()
         .use(remarkMdx)
+        // Must precede every other transformer: it strips evaluable attribute expressions so no
+        // downstream `getAttrs()` call can reach `evaluate()`.
+        .use(opts.safeMode ? flatten_attribute_expressions : undefined)
         .use(remarkPlugins)
         .use(opts.remarkPlugins)
         .use(transform_variables, { asMdx: false })
@@ -116249,12 +116441,59 @@ const hastscript_lib_h = create_h_createH(node_modules_property_information_html
 /** @type {ReturnType<createH>} */
 const lib_s = create_h_createH(node_modules_property_information_svg, 'g', svg_case_sensitive_tag_names_svgCaseSensitiveTagNames)
 
+;// ./utils/user.ts
+/**
+ * Coerce a user variable value to a string for substitution into markdown text.
+ * Non-string values (arrays, objects, numbers) are stringified via JSON or `String()`
+ * so that `<<var>>` syntax doesn't produce `[object Object]` for structured data like
+ * JWT `keys`.
+ */
+const stringifyVariableValue = (value) => {
+    if (typeof value === 'string')
+        return value;
+    if (value == null)
+        return '';
+    if (typeof value === 'object') {
+        try {
+            return JSON.stringify(value) ?? '';
+        }
+        catch {
+            console.warn('[WARNING] Could not stringify a structured user variable.');
+            return '';
+        }
+    }
+    return String(value);
+};
+/**
+ * Flatten `variables.user` into a string-keyed string-valued record by coercing
+ * each value. Used by markdown substitution paths that need a plain
+ * `Record<string, string>` lookup.
+ */
+const flattenUserVariables = (user) => Object.fromEntries(Object.entries(user).map(([name, value]) => [name, stringifyVariableValue(value)]));
+const User = (variables) => {
+    const { user = {}, defaults = [] } = variables || {};
+    return new Proxy(user, {
+        get(target, attribute) {
+            if (typeof attribute === 'symbol') {
+                return '';
+            }
+            if (attribute in target) {
+                return target[attribute];
+            }
+            const def = defaults.find((d) => d.name === attribute);
+            return def ? def.default : attribute.toUpperCase();
+        },
+    });
+};
+/* harmony default export */ const user = (User);
+
 ;// ./processor/plugin/toc.ts
 
 
 
 
 
+
 const HEADING_TAGS = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
 const isHeadingTag = (tag) => (tag ? HEADING_TAGS.includes(tag) : false);
 const isStandardHtmlElement = (node) => STANDARD_HTML_TAGS.has(node.tagName.toLowerCase());
@@ -116366,7 +116605,7 @@ const flattenVariables = (variables) => {
     if (!variables)
         return {};
     return {
-        ...variables.user,
+        ...flattenUserVariables(variables.user),
         ...Object.fromEntries((variables.defaults || []).filter(d => !(d.name in variables.user)).map(d => [d.name, d.default])),
     };
 };
@@ -116514,7 +116753,7 @@ const exports_exports = (doc) => {
 
 const hast = (text, opts = {}) => {
     const components = Object.entries(opts.components || {}).reduce((memo, [name, doc]) => {
-        memo[name] = lib_mdast(doc);
+        memo[name] = lib_mdast(doc, { safeMode: opts.safeMode });
         return memo;
     }, {});
     const processor = ast_processor(opts)
@@ -127150,6 +127389,7 @@ function normalizeTableSeparator(content) {
 ;// ./processor/transform/mdxish/variables-code.ts
 
 
+
 // Single combined regex so that resolved values from one pattern are never re-scanned by the other.
 const COMBINED_VARIABLE_REGEX = new RegExp(`${variable_dist.VARIABLE_REGEXP}|${variable_dist.MDX_VARIABLE_REGEXP}`, 'giu');
 // Flatten variables into a single object for easy lookup
@@ -127158,7 +127398,7 @@ function variables_code_flattenVariables(variables) {
         return {};
     return {
         ...Object.fromEntries((variables.defaults || []).map(d => [d.name, d.default])),
-        ...variables.user,
+        ...flattenUserVariables(variables.user),
     };
 }
 function resolveCodeVariables(value, resolvedVariables) {
@@ -127702,24 +127942,6 @@ const Contexts = ({ children, terms = [], variables = { user: {}, defaults: [] }
 };
 /* harmony default export */ const contexts = (Contexts);
 
-;// ./utils/user.ts
-const User = (variables) => {
-    const { user = {}, defaults = [] } = variables || {};
-    return new Proxy(user, {
-        get(target, attribute) {
-            if (typeof attribute === 'symbol') {
-                return '';
-            }
-            if (attribute in target) {
-                return target[attribute];
-            }
-            const def = defaults.find((d) => d.name === attribute);
-            return def ? def.default : attribute.toUpperCase();
-        },
-    });
-};
-/* harmony default export */ const user = (User);
-
 ;// ./lib/utils/makeUseMdxComponents.ts
 
 
@@ -127752,6 +127974,7 @@ const makeUseMDXComponents = (more = {}) => {
 
 ;// ./lib/utils/mdxish/mdxish-variables.ts
 
+
 // The `$` guard skips template-literal interpolation: `${user.name}` embeds `{user.name}`, and
 // substituting it would leave a mangled `` `Hi $Name` `` behind. Those belong to an expression,
 // which either evaluated already or is meant to stay literal.
@@ -127775,7 +127998,7 @@ function resolveAttributeVariables(value, user) {
         .replace(MDX_VARIABLE_REGEX, (source, escapePrefix, name, escapeSuffix) => {
         if (escapePrefix || escapeSuffix)
             return source;
-        return user[name];
+        return stringifyVariableValue(user[name]);
     });
 }
 
@@ -128051,7 +128274,8 @@ const run_run = (string, _opts = {}) => {
 
 const tags = (doc) => {
     const set = new Set();
-    visit(lib_mdast(doc), isMDXElement, (node) => {
+    // Tag names never depend on evaluated attribute values, so always parse in safeMode.
+    visit(lib_mdast(doc, { safeMode: true }), isMDXElement, (node) => {
         if (node.name?.match(/^[A-Z]/)) {
             set.add(node.name);
         }
@@ -128067,13 +128291,14 @@ const tags = (doc) => {
 
 
 
-const { micromarkExtensions, fromMarkdownExtensions } = mdxishExtensions(FEATURES.tags);
+const { micromarkExtensions, fromMarkdownExtensions } = mdxishExtensions(FEATURES.tags, { safeMode: true });
 const mdxishTags_tags = (doc) => {
     const set = new Set();
     const processor = remark()
         .data('micromarkExtensions', micromarkExtensions)
         .data('fromMarkdownExtensions', fromMarkdownExtensions)
-        .use(mdx_blocks)
+        // Tag names never depend on evaluated attribute values, so always parse in safeMode.
+        .use(mdx_blocks, { safeMode: true })
         .use(mdxish_tables);
     const tree = processor.parse(doc);
     visit(processor.runSync(tree), isMDXElement, (node) => {