@readme/markdown 15.9.3 → 15.9.4

package/dist/render-fixture.node.js

@@ -19111,7 +19111,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 1186
+/***/ 7905
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -93266,6 +93266,26 @@ const mdxToHast = () => tree => {
 };
 /* harmony default export */ const mdx_to_hast = ((/* unused pure expression or super */ null && (mdxToHast)));
 
+;// ./lib/mdast-util/mdx-expression/index.ts
+
+const upstream = mdxExpressionFromMarkdown();
+/**
+ * An image's alt is its label flattened to text, which drops an expression's braces. Keep the
+ * `{...}` source there so `{user.*}` still resolves in alt at render time (RM-10865).
+ */
+function exitTextExpression(token) {
+    upstream.exit.mdxTextExpression.call(this, token);
+    if (!this.stack.some(node => node.type === 'image'))
+        return;
+    const { children } = this.stack[this.stack.length - 1];
+    const { position } = children[children.length - 1];
+    children[children.length - 1] = { type: 'text', value: this.sliceSerialize(token), position };
+}
+/** Upstream `mdxExpressionFromMarkdown`, overriding only the text-expression exit to keep `{...}` source in image alt. */
+function mdxishExpressionFromMarkdown() {
+    return { ...upstream, exit: { ...upstream.exit, mdxTextExpression: exitTextExpression } };
+}
+
 ;// ./lib/mdast-util/empty-task-list-item/index.ts
 /**
  * Normalizes list items that are written as only `[ ]` or `[x]` into GFM task
@@ -93498,6 +93518,16 @@ function exitlegacyVariableValue(token) {
 function exitlegacyVariable(token) {
     const ctx = legacy_variable_contextMap.get(token);
     const serialized = this.sliceSerialize(token);
+    // An escaped `\<<name>>` (or `\<<name\>>`) is literal text, as in the legacy parser.
+    if (serialized.startsWith('\\')) {
+        const literal = serialized.slice(1).replace('\\>>', '>>');
+        // An image's alt is flattened to a string, so keep the escape for render-time resolution to honor.
+        const inImageAlt = this.stack.some(node => node.type === 'image');
+        this.enter({ type: 'text', value: inImageAlt ? `\\${literal}` : literal }, token);
+        this.exit(token);
+        legacy_variable_contextMap.delete(token);
+        return;
+    }
     const variableName = serialized.startsWith('<<') && serialized.endsWith('>>')
         ? serialized.slice(2, -2)
         : ctx?.value ?? '';
@@ -95091,9 +95121,16 @@ const legacyVariableConstruct = {
 function syntax_tokenize(effects, ok, nok) {
     let hasValue = false;
     const start = (code) => {
+        effects.enter('legacyVariable');
+        // Claim `\<<name>>` before CommonMark's character escape drops the backslash, as the legacy parser did.
+        if (code !== codes.backslash)
+            return open(code);
+        effects.consume(code); // \
+        return open;
+    };
+    const open = (code) => {
         if (code !== codes.lessThan)
             return nok(code);
-        effects.enter('legacyVariable');
         effects.enter('legacyVariableMarkerStart');
         effects.consume(code); // <
         return open2;
@@ -95133,7 +95170,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes.backslash]: legacyVariableConstruct, [codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -97457,12 +97494,12 @@ const REGISTRY = {
     magicBlock: { syntax: magicBlock, fromMarkdown: magicBlockFromMarkdown },
     // Two `{` tokenizers, never registered together: the document parser takes text
     // only, the component-body re-parser needs flow too for multi-line expressions.
-    mdxExpressionLenient: { syntax: mdxExpressionLenient, fromMarkdown: mdxExpressionFromMarkdown, expression: true },
+    mdxExpressionLenient: { syntax: mdxExpressionLenient, fromMarkdown: mdxishExpressionFromMarkdown, expression: true },
     // `allowEmpty` is the package default; passed explicitly because `mdx-jsx`
     // registers the same tokenizer with it off for attribute expressions.
     mdxExpression: {
         syntax: () => mdxExpression({ allowEmpty: true }),
-        fromMarkdown: mdxExpressionFromMarkdown,
+        fromMarkdown: mdxishExpressionFromMarkdown,
         expression: true,
     },
     mdxComponent: { syntax: mdxComponent, fromMarkdown: mdxComponentFromMarkdown },
@@ -101062,6 +101099,7 @@ const splitHtmlWithNestedTables = (node, source) => {
 
 
 
+
 
 
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -101082,9 +101120,13 @@ const buildTableNodeProcessor = (withMdx) => {
     const { micromarkExtensions, fromMarkdownExtensions } = mdxishExtensions(FEATURES.tableCell);
     // `mdxjs` goes first (= lowest priority): its `mdxJsx` also claims `text` + `<`,
     // and `legacyVariable` has to keep winning that race so `<<var>>` still parses.
+    // `mdxishExpressionFromMarkdown` follows `mdxFromMarkdown` to override its expression exit.
     return unified()
         .data('micromarkExtensions', [...(withMdx ? [mdxjs()] : []), ...micromarkExtensions])
-        .data('fromMarkdownExtensions', [...(withMdx ? [mdxFromMarkdown()] : []), ...fromMarkdownExtensions])
+        .data('fromMarkdownExtensions', [
+        ...(withMdx ? [mdxFromMarkdown(), mdxishExpressionFromMarkdown()] : []),
+        ...fromMarkdownExtensions,
+    ])
         .use(remarkParse)
         .use(normalize_malformed_md_syntax)
         .use([[callouts, { isMdxish: true }], code_tabs])
@@ -127807,22 +127849,28 @@ const BARE_VARIABLE_REGEX = new RegExp(`^${variable_dist.MDX_VARIABLE_REGEXP}$`,
 // Escaped and `$`-prefixed forms are left alone so a reference that stays literal keeps its source.
 // A closing escape needs no lookahead: requiring a literal `]}` already rules out `]\}`.
 const BRACKET_NOTATION_REGEX = /(?<![$\\])\{user\[['"](\w+)['"]\]\}/gu;
+const ALT_VARIABLE_REGEX = new RegExp(`${MDX_VARIABLE_REGEX.source}|${variable_dist.VARIABLE_REGEXP}`, 'gu');
 /**
  * Resolve `{user.*}` in a JSX attribute value against the same `user` binding the rmdx engine gets,
  * so both engines agree. Body text differs on empty values: `Variable` falls back to the default.
  *
  * Legacy `<<...>>` is valid inside a quoted attribute but deliberately left literal — attributes are
- * an MDX surface, and `{user.*}` is the syntax authors use there.
+ * an MDX surface, and `{user.*}` is the syntax authors use there. Image alt is the exception, resolved
+ * in the same pass so a substituted value is never rescanned (RM-10865).
  */
-function resolveAttributeVariables(value, user) {
-    if (!value.includes('{user'))
+function resolveAttributeVariables(value, user, isImageAlt = false) {
+    if (!isImageAlt && !value.includes('{user'))
         return value;
     return value
         .replace(BRACKET_NOTATION_REGEX, '{user.$1}')
-        .replace(MDX_VARIABLE_REGEX, (source, escapePrefix, name, escapeSuffix) => {
-        if (escapePrefix || escapeSuffix)
-            return source;
-        return stringifyVariableValue(user[name]);
+        .replace(isImageAlt ? ALT_VARIABLE_REGEX : MDX_VARIABLE_REGEX, (source, _prefix, name, _suffix, legacyName) => {
+        // Variable names can't contain a backslash, so one marks an escaped reference.
+        if (source.includes('\\'))
+            return isImageAlt ? source.replaceAll('\\', '') : source;
+        const key = (name ?? legacyName).trim();
+        if (key.startsWith('glossary:'))
+            return key.slice('glossary:'.length).trim();
+        return stringifyVariableValue(user[key]);
     });
 }
 /** Whether an attribute expression's source is a bare `user.*` reference, left for render-time substitution. */
@@ -128680,8 +128728,10 @@ function exportComponentsForRehype(components) {
  * deliberately leaves mermaid alone; resolving it again here would override that.
  */
 const CODE_TAG_NAMES = new Set(['code']);
+const isImageAlt = (tagName, key) => tagName === 'img' && key === 'alt';
 /**
- * Resolve `{user.*}` in string-valued props. Body text is handled by the `Variable` component, but
+ * Resolve `{user.*}` in string-valued props, plus legacy `<<...>>` in img alt, where markdown flattens
+ * body variables to text (RM-10865). Body text is handled by the `Variable` component, but
  * attributes are plain strings, so they are substituted here — at render time, so that a
  * server-parsed (user-agnostic) tree resolves against the current reader's variables.
  */
@@ -128691,7 +128741,7 @@ function resolveVariablesInProps(props, user, tagName) {
         const isDocumentContent = RAW_HTML_PROP_NAMES.has(key) || (isCodeTag && key === 'value');
         if (typeof value !== 'string' || isDocumentContent)
             return [key, value];
-        return [key, resolveAttributeVariables(value, user)];
+        return [key, resolveAttributeVariables(value, user, isImageAlt(tagName, key))];
     });
     return Object.fromEntries(resolvedEntries);
 }
@@ -129526,7 +129576,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"*":["about","acceptCharset","accessK
 /******/ 	// startup
 /******/ 	// Load entry module and return exports
 /******/ 	// This entry module used 'module' so it can't be inlined
-/******/ 	let __webpack_exports__ = __webpack_require__(1186);
+/******/ 	let __webpack_exports__ = __webpack_require__(7905);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()