@readme/markdown 15.9.3 → 15.9.4

package/dist/lib/mdast-util/mdx-expression/index.d.ts

@@ -0,0 +1,3 @@
+import type { Extension as FromMarkdownExtension } from 'mdast-util-from-markdown';
+/** Upstream `mdxExpressionFromMarkdown`, overriding only the text-expression exit to keep `{...}` source in image alt. */
+export declare function mdxishExpressionFromMarkdown(): FromMarkdownExtension;

package/dist/lib/micromark/mdxish-extensions.d.ts

@@ -1,6 +1,5 @@
 import type { Extension as FromMarkdownExtension } from 'mdast-util-from-markdown';
 import type { Extension } from 'micromark-util-types';
-import { mdxExpressionFromMarkdown } from 'mdast-util-mdx-expression';
 import { mdxjsEsmFromMarkdown } from 'mdast-util-mdxjs-esm';
 import { emptyTaskListItemFromMarkdown } from '../mdast-util/empty-task-list-item';
 import { gemojiFromMarkdown } from '../mdast-util/gemoji';
@@ -9,6 +8,7 @@ import { jsxTableFromMarkdown } from '../mdast-util/jsx-table';
 import { legacyVariableFromMarkdown } from '../mdast-util/legacy-variable';
 import { magicBlockFromMarkdown } from '../mdast-util/magic-block';
 import { mdxComponentFromMarkdown } from '../mdast-util/mdx-component';
+import { mdxishExpressionFromMarkdown } from '../mdast-util/mdx-expression';
 import { gemoji } from './gemoji';
 import { htmlBlockComponent } from './html-block-component';
 import { jsxComment } from './jsx-comment';
@@ -50,12 +50,12 @@ declare const REGISTRY: {
     };
     mdxExpressionLenient: {
         syntax: typeof mdxExpressionLenient;
-        fromMarkdown: typeof mdxExpressionFromMarkdown;
+        fromMarkdown: typeof mdxishExpressionFromMarkdown;
         expression: true;
     };
     mdxExpression: {
         syntax: () => Extension;
-        fromMarkdown: typeof mdxExpressionFromMarkdown;
+        fromMarkdown: typeof mdxishExpressionFromMarkdown;
         expression: true;
     };
     mdxComponent: {

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

@@ -3,8 +3,9 @@
  * 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).
  */
-export declare function resolveAttributeVariables(value: string, user: Record<string, unknown>): string;
+export declare function resolveAttributeVariables(value: string, user: Record<string, unknown>, isImageAlt?: boolean): string;
 /** Whether an attribute expression's source is a bare `user.*` reference, left for render-time substitution. */
 export declare const isBareVariableReference: (source: string) => boolean;

package/dist/main.js

@@ -11423,7 +11423,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 8846
+/***/ 714
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -73071,6 +73071,26 @@ const mdxToHast = () => tree => {
 };
 /* harmony default export */ const mdx_to_hast = (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
@@ -73303,6 +73323,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 ?? '';
@@ -74896,9 +74926,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;
@@ -74938,7 +74975,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes.backslash]: legacyVariableConstruct, [codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -77262,12 +77299,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 },
@@ -80867,6 +80904,7 @@ const splitHtmlWithNestedTables = (node, source) => {
 
 
 
+
 
 
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -80887,9 +80925,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])
@@ -107790,22 +107832,28 @@ const BARE_VARIABLE_REGEX = new RegExp(`^${variable_.MDX_VARIABLE_REGEXP}$`, 'u'
 // 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_.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. */
@@ -108758,8 +108806,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.
  */
@@ -108769,7 +108819,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);
 }
@@ -109459,7 +109509,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__(8846);
+/******/ 	let __webpack_exports__ = __webpack_require__(714);
 /******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()

package/dist/main.node.js

@@ -19111,7 +19111,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 6831
+/***/ 3975
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -93320,6 +93320,26 @@ const mdxToHast = () => tree => {
 };
 /* harmony default export */ const mdx_to_hast = (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
@@ -93552,6 +93572,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 ?? '';
@@ -95145,9 +95175,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;
@@ -95187,7 +95224,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes.backslash]: legacyVariableConstruct, [codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -97511,12 +97548,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 },
@@ -101116,6 +101153,7 @@ const splitHtmlWithNestedTables = (node, source) => {
 
 
 
+
 
 
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -101136,9 +101174,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])
@@ -128039,22 +128081,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. */
@@ -129007,8 +129055,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.
  */
@@ -129018,7 +129068,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);
 }
@@ -129767,7 +129817,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__(6831);
+/******/ 	let __webpack_exports__ = __webpack_require__(3975);
 /******/ 	module.exports = __webpack_exports__;
 /******/ 	
 /******/ })()