@readme/markdown 15.9.3 → 15.10.0

package/dist/main.js

@@ -11423,7 +11423,7 @@ module.exports = function () {
 
 /***/ },
 
-/***/ 8846
+/***/ 9477
 (module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -11448,6 +11448,7 @@ __webpack_require__.d(__webpack_exports__, {
   mdx: () => (/* reexport */ lib_mdx),
   mdxish: () => (/* reexport */ lib_mdxish),
   mdxishAstProcessor: () => (/* reexport */ mdxishAstProcessor),
+  mdxishHeadingIds: () => (/* reexport */ mdxishHeadingIds),
   mdxishMdastToMd: () => (/* reexport */ mdxishMdastToMd),
   mdxishTags: () => (/* reexport */ mdxishTags),
   migrate: () => (/* reexport */ lib_migrate),
@@ -54835,6 +54836,209 @@ const mdast = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_mdast = (mdast);
 
+;// ./node_modules/micromark-util-symbol/lib/codes.js
+/**
+ * Character codes.
+ *
+ * This module is compiled away!
+ *
+ * micromark works based on character codes.
+ * This module contains constants for the ASCII block and the replacement
+ * character.
+ * A couple of them are handled in a special way, such as the line endings
+ * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
+ * tab) and its expansion based on what column it’s at (virtual space),
+ * and the end-of-file (eof) character.
+ * As values are preprocessed before handling them, the actual characters LF,
+ * CR, HT, and NUL (which is present as the replacement character), are
+ * guaranteed to not exist.
+ *
+ * Unicode basic latin block.
+ */
+const codes = /** @type {const} */ ({
+  carriageReturn: -5,
+  lineFeed: -4,
+  carriageReturnLineFeed: -3,
+  horizontalTab: -2,
+  virtualSpace: -1,
+  eof: null,
+  nul: 0,
+  soh: 1,
+  stx: 2,
+  etx: 3,
+  eot: 4,
+  enq: 5,
+  ack: 6,
+  bel: 7,
+  bs: 8,
+  ht: 9, // `\t`
+  lf: 10, // `\n`
+  vt: 11, // `\v`
+  ff: 12, // `\f`
+  cr: 13, // `\r`
+  so: 14,
+  si: 15,
+  dle: 16,
+  dc1: 17,
+  dc2: 18,
+  dc3: 19,
+  dc4: 20,
+  nak: 21,
+  syn: 22,
+  etb: 23,
+  can: 24,
+  em: 25,
+  sub: 26,
+  esc: 27,
+  fs: 28,
+  gs: 29,
+  rs: 30,
+  us: 31,
+  space: 32,
+  exclamationMark: 33, // `!`
+  quotationMark: 34, // `"`
+  numberSign: 35, // `#`
+  dollarSign: 36, // `$`
+  percentSign: 37, // `%`
+  ampersand: 38, // `&`
+  apostrophe: 39, // `'`
+  leftParenthesis: 40, // `(`
+  rightParenthesis: 41, // `)`
+  asterisk: 42, // `*`
+  plusSign: 43, // `+`
+  comma: 44, // `,`
+  dash: 45, // `-`
+  dot: 46, // `.`
+  slash: 47, // `/`
+  digit0: 48, // `0`
+  digit1: 49, // `1`
+  digit2: 50, // `2`
+  digit3: 51, // `3`
+  digit4: 52, // `4`
+  digit5: 53, // `5`
+  digit6: 54, // `6`
+  digit7: 55, // `7`
+  digit8: 56, // `8`
+  digit9: 57, // `9`
+  colon: 58, // `:`
+  semicolon: 59, // `;`
+  lessThan: 60, // `<`
+  equalsTo: 61, // `=`
+  greaterThan: 62, // `>`
+  questionMark: 63, // `?`
+  atSign: 64, // `@`
+  uppercaseA: 65, // `A`
+  uppercaseB: 66, // `B`
+  uppercaseC: 67, // `C`
+  uppercaseD: 68, // `D`
+  uppercaseE: 69, // `E`
+  uppercaseF: 70, // `F`
+  uppercaseG: 71, // `G`
+  uppercaseH: 72, // `H`
+  uppercaseI: 73, // `I`
+  uppercaseJ: 74, // `J`
+  uppercaseK: 75, // `K`
+  uppercaseL: 76, // `L`
+  uppercaseM: 77, // `M`
+  uppercaseN: 78, // `N`
+  uppercaseO: 79, // `O`
+  uppercaseP: 80, // `P`
+  uppercaseQ: 81, // `Q`
+  uppercaseR: 82, // `R`
+  uppercaseS: 83, // `S`
+  uppercaseT: 84, // `T`
+  uppercaseU: 85, // `U`
+  uppercaseV: 86, // `V`
+  uppercaseW: 87, // `W`
+  uppercaseX: 88, // `X`
+  uppercaseY: 89, // `Y`
+  uppercaseZ: 90, // `Z`
+  leftSquareBracket: 91, // `[`
+  backslash: 92, // `\`
+  rightSquareBracket: 93, // `]`
+  caret: 94, // `^`
+  underscore: 95, // `_`
+  graveAccent: 96, // `` ` ``
+  lowercaseA: 97, // `a`
+  lowercaseB: 98, // `b`
+  lowercaseC: 99, // `c`
+  lowercaseD: 100, // `d`
+  lowercaseE: 101, // `e`
+  lowercaseF: 102, // `f`
+  lowercaseG: 103, // `g`
+  lowercaseH: 104, // `h`
+  lowercaseI: 105, // `i`
+  lowercaseJ: 106, // `j`
+  lowercaseK: 107, // `k`
+  lowercaseL: 108, // `l`
+  lowercaseM: 109, // `m`
+  lowercaseN: 110, // `n`
+  lowercaseO: 111, // `o`
+  lowercaseP: 112, // `p`
+  lowercaseQ: 113, // `q`
+  lowercaseR: 114, // `r`
+  lowercaseS: 115, // `s`
+  lowercaseT: 116, // `t`
+  lowercaseU: 117, // `u`
+  lowercaseV: 118, // `v`
+  lowercaseW: 119, // `w`
+  lowercaseX: 120, // `x`
+  lowercaseY: 121, // `y`
+  lowercaseZ: 122, // `z`
+  leftCurlyBrace: 123, // `{`
+  verticalBar: 124, // `|`
+  rightCurlyBrace: 125, // `}`
+  tilde: 126, // `~`
+  del: 127,
+  // Unicode Specials block.
+  byteOrderMarker: 65_279,
+  // Unicode Specials block.
+  replacementCharacter: 65_533 // `�`
+})
+
+;// ./lib/micromark/heading-id/syntax.ts
+
+
+/** One character a `{#id}` heading id may use: the ones github-slugger keeps, plus `.` and `:`. */
+const HEADING_ID_CHAR = '[\\p{L}\\p{M}\\p{N}_.:-]';
+const ID_CLOSE_REGEX = new RegExp(`^${HEADING_ID_CHAR}+\\}$`, 'u');
+const typeAt = (events, index) => events[index]?.[1].type;
+function isIdToken(events, index, context, type, value) {
+    return typeAt(events, index) === type && value.test(context.sliceSerialize(events[index][1]));
+}
+/** The exit index of the heading's last content token, past any trailing space and closing `##`. */
+function contentEnd(events) {
+    let end = events.length - 2;
+    if (typeAt(events, end) === 'whitespace')
+        end -= 2;
+    if (typeAt(events, end) === 'atxHeadingSequence' && typeAt(events, end - 2) === 'whitespace')
+        end -= 4;
+    return end;
+}
+const resolveHeadingId = (events, context) => {
+    // Each token is an enter and an exit event; these indexes point at the exits.
+    const close = contentEnd(events);
+    const hash = close - 2;
+    const open = close - 4;
+    const space = close - 6;
+    const endsWithId = isIdToken(events, close, context, 'atxHeadingText', ID_CLOSE_REGEX) &&
+        isIdToken(events, hash, context, 'atxHeadingSequence', /^#$/) &&
+        isIdToken(events, open, context, 'atxHeadingText', /^\{$/) &&
+        typeAt(events, space) === 'whitespace';
+    if (!endsWithId)
+        return headingAtx.resolve?.(events, context) ?? events;
+    const id = { type: 'headingId', start: events[open][1].start, end: events[close][1].end };
+    events.splice(space - 1, close - space + 2);
+    const resolved = headingAtx.resolve?.(events, context) ?? events;
+    resolved.splice(resolved.length - 1, 0, ['enter', id, context], ['exit', id, context]);
+    return resolved;
+};
+const headingIdConstruct = { ...headingAtx, resolve: resolveHeadingId };
+/** The ATX heading construct, with a line-final ` {#id}` split off as a `headingId` token. */
+function headingId() {
+    return { flow: { [codes.numberSign]: headingIdConstruct } };
+}
+
 ;// ./lib/utils/jsx-acorn-parser.ts
 
 
@@ -54946,6 +55150,7 @@ const evaluateLiteralExpression = (source) => {
 
 
 
+
 /**
  * Evaluate a JavaScript expression source and return its value.
  *
@@ -55062,6 +55267,24 @@ const getHPropKeys = (node) => {
     const hProps = getHProps(node);
     return Object.keys(hProps) || [];
 };
+/** Turn a non-renderable evaluation result into a text node. */
+const createTextNode = (result, position) => {
+    if (result === null || result === undefined)
+        return { type: 'text', value: '', position };
+    if (typeof result === 'object')
+        return { type: 'text', value: JSON.stringify(result), position };
+    return { type: 'text', value: String(result), position };
+};
+const HEADING_ID_REGEX = new RegExp(`^${HEADING_ID_CHAR}+$`, 'u');
+/**
+ * The id a heading's trailing `{#id}` set, when it is one the `{#id}` syntax can spell.
+ *
+ * Ids may use letters, numbers, `-`, `_`, `.` and `:`; anything else, like `x y`, is dropped.
+ */
+const explicitHeadingId = (node) => {
+    const id = node.data?.hProperties?.id;
+    return typeof id === 'string' && HEADING_ID_REGEX.test(id) ? id : undefined;
+};
 /**
  * Gets the attributes of an MDX element and returns them as an object of hProperties.
  *
@@ -73071,6 +73294,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
@@ -73177,6 +73420,17 @@ function gemojiFromMarkdown() {
     };
 }
 
+;// ./lib/mdast-util/heading-id/index.ts
+function exitHeadingId(token) {
+    const heading = this.stack[this.stack.length - 1];
+    const id = this.sliceSerialize(token).slice('{#'.length, -'}'.length);
+    heading.data = { ...heading.data, hProperties: { ...heading.data?.hProperties, id } };
+}
+/** Sets a heading's id from its `headingId` token. */
+function headingIdFromMarkdown() {
+    return { exit: { headingId: exitHeadingId } };
+}
+
 ;// ./lib/mdast-util/html-block-component/index.ts
 const contextMap = new WeakMap();
 function findHtmlBlockComponentToken() {
@@ -73303,6 +73557,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 ?? '';
@@ -73545,166 +73809,6 @@ function mdxComponentFromMarkdown() {
     };
 }
 
-;// ./node_modules/micromark-util-symbol/lib/codes.js
-/**
- * Character codes.
- *
- * This module is compiled away!
- *
- * micromark works based on character codes.
- * This module contains constants for the ASCII block and the replacement
- * character.
- * A couple of them are handled in a special way, such as the line endings
- * (CR, LF, and CR+LF, commonly known as end-of-line: EOLs), the tab (horizontal
- * tab) and its expansion based on what column it’s at (virtual space),
- * and the end-of-file (eof) character.
- * As values are preprocessed before handling them, the actual characters LF,
- * CR, HT, and NUL (which is present as the replacement character), are
- * guaranteed to not exist.
- *
- * Unicode basic latin block.
- */
-const codes = /** @type {const} */ ({
-  carriageReturn: -5,
-  lineFeed: -4,
-  carriageReturnLineFeed: -3,
-  horizontalTab: -2,
-  virtualSpace: -1,
-  eof: null,
-  nul: 0,
-  soh: 1,
-  stx: 2,
-  etx: 3,
-  eot: 4,
-  enq: 5,
-  ack: 6,
-  bel: 7,
-  bs: 8,
-  ht: 9, // `\t`
-  lf: 10, // `\n`
-  vt: 11, // `\v`
-  ff: 12, // `\f`
-  cr: 13, // `\r`
-  so: 14,
-  si: 15,
-  dle: 16,
-  dc1: 17,
-  dc2: 18,
-  dc3: 19,
-  dc4: 20,
-  nak: 21,
-  syn: 22,
-  etb: 23,
-  can: 24,
-  em: 25,
-  sub: 26,
-  esc: 27,
-  fs: 28,
-  gs: 29,
-  rs: 30,
-  us: 31,
-  space: 32,
-  exclamationMark: 33, // `!`
-  quotationMark: 34, // `"`
-  numberSign: 35, // `#`
-  dollarSign: 36, // `$`
-  percentSign: 37, // `%`
-  ampersand: 38, // `&`
-  apostrophe: 39, // `'`
-  leftParenthesis: 40, // `(`
-  rightParenthesis: 41, // `)`
-  asterisk: 42, // `*`
-  plusSign: 43, // `+`
-  comma: 44, // `,`
-  dash: 45, // `-`
-  dot: 46, // `.`
-  slash: 47, // `/`
-  digit0: 48, // `0`
-  digit1: 49, // `1`
-  digit2: 50, // `2`
-  digit3: 51, // `3`
-  digit4: 52, // `4`
-  digit5: 53, // `5`
-  digit6: 54, // `6`
-  digit7: 55, // `7`
-  digit8: 56, // `8`
-  digit9: 57, // `9`
-  colon: 58, // `:`
-  semicolon: 59, // `;`
-  lessThan: 60, // `<`
-  equalsTo: 61, // `=`
-  greaterThan: 62, // `>`
-  questionMark: 63, // `?`
-  atSign: 64, // `@`
-  uppercaseA: 65, // `A`
-  uppercaseB: 66, // `B`
-  uppercaseC: 67, // `C`
-  uppercaseD: 68, // `D`
-  uppercaseE: 69, // `E`
-  uppercaseF: 70, // `F`
-  uppercaseG: 71, // `G`
-  uppercaseH: 72, // `H`
-  uppercaseI: 73, // `I`
-  uppercaseJ: 74, // `J`
-  uppercaseK: 75, // `K`
-  uppercaseL: 76, // `L`
-  uppercaseM: 77, // `M`
-  uppercaseN: 78, // `N`
-  uppercaseO: 79, // `O`
-  uppercaseP: 80, // `P`
-  uppercaseQ: 81, // `Q`
-  uppercaseR: 82, // `R`
-  uppercaseS: 83, // `S`
-  uppercaseT: 84, // `T`
-  uppercaseU: 85, // `U`
-  uppercaseV: 86, // `V`
-  uppercaseW: 87, // `W`
-  uppercaseX: 88, // `X`
-  uppercaseY: 89, // `Y`
-  uppercaseZ: 90, // `Z`
-  leftSquareBracket: 91, // `[`
-  backslash: 92, // `\`
-  rightSquareBracket: 93, // `]`
-  caret: 94, // `^`
-  underscore: 95, // `_`
-  graveAccent: 96, // `` ` ``
-  lowercaseA: 97, // `a`
-  lowercaseB: 98, // `b`
-  lowercaseC: 99, // `c`
-  lowercaseD: 100, // `d`
-  lowercaseE: 101, // `e`
-  lowercaseF: 102, // `f`
-  lowercaseG: 103, // `g`
-  lowercaseH: 104, // `h`
-  lowercaseI: 105, // `i`
-  lowercaseJ: 106, // `j`
-  lowercaseK: 107, // `k`
-  lowercaseL: 108, // `l`
-  lowercaseM: 109, // `m`
-  lowercaseN: 110, // `n`
-  lowercaseO: 111, // `o`
-  lowercaseP: 112, // `p`
-  lowercaseQ: 113, // `q`
-  lowercaseR: 114, // `r`
-  lowercaseS: 115, // `s`
-  lowercaseT: 116, // `t`
-  lowercaseU: 117, // `u`
-  lowercaseV: 118, // `v`
-  lowercaseW: 119, // `w`
-  lowercaseX: 120, // `x`
-  lowercaseY: 121, // `y`
-  lowercaseZ: 122, // `z`
-  leftCurlyBrace: 123, // `{`
-  verticalBar: 124, // `|`
-  rightCurlyBrace: 125, // `}`
-  tilde: 126, // `~`
-  del: 127,
-  // Unicode Specials block.
-  byteOrderMarker: 65_279,
-  // Unicode Specials block.
-  replacementCharacter: 65_533 // `�`
-})
-
 ;// ./lib/micromark/gemoji/syntax.ts
 
 // Matches the name pattern from the original regex: \+1 or [-\w]+
@@ -73792,6 +73896,9 @@ function syntax_gemoji() {
     };
 }
 
+;// ./lib/micromark/heading-id/index.ts
+
+
 ;// ./node_modules/micromark-util-symbol/lib/types.js
 /**
  * This module is compiled away!
@@ -74896,9 +75003,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 +75052,7 @@ function syntax_tokenize(effects, ok, nok) {
 }
 function legacyVariable() {
     return {
-        text: { [codes.lessThan]: legacyVariableConstruct },
+        text: { [codes.backslash]: legacyVariableConstruct, [codes.lessThan]: legacyVariableConstruct },
     };
 }
 
@@ -77234,6 +77348,8 @@ function mdxExpressionLenient() {
 
 
 
+
+
 
 
 
@@ -77262,17 +77378,19 @@ 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 },
     gemoji: { syntax: syntax_gemoji, fromMarkdown: gemojiFromMarkdown },
     legacyVariable: { syntax: legacyVariable, fromMarkdown: legacyVariableFromMarkdown },
+    // Replaces the ATX heading construct in `flow`, so it never touches prose outside a heading.
+    headingId: { syntax: headingId, fromMarkdown: headingIdFromMarkdown },
     looseHtmlEntity: { syntax: looseHtmlEntity, fromMarkdown: looseHtmlEntityFromMarkdown },
     htmlBlockComponent: { syntax: htmlBlockComponent, fromMarkdown: htmlBlockComponentFromMarkdown },
     // This is for in-document variable & function definitions
@@ -77303,18 +77421,13 @@ const EXPRESSIONS = ['jsxComment', 'mdxExpressionLenient', 'mdxjsEsm'];
  */
 const FEATURES = {
     /** `lib/mdxish.ts` — the document parser; the only site taking every group */
-    document: [...BLOCK_CLAIMS, ...INLINE, ...EXPRESSIONS, 'emptyTaskListItem'],
+    document: [...BLOCK_CLAIMS, ...INLINE, ...EXPRESSIONS, 'emptyTaskListItem', 'headingId'],
     /**
      * `components/utils.ts` — re-parses a component body, which should tokenize
      * like the document around it: when the two drifted a `<Table>` in a
      * `<Callout>` lost every row (CX-3705).
      */
-    componentBody: [
-        ...BLOCK_CLAIMS,
-        ...INLINE,
-        'mdxExpression',
-        'emptyTaskListItem',
-    ],
+    componentBody: [...BLOCK_CLAIMS, ...INLINE, 'mdxExpression', 'emptyTaskListItem', 'headingId'],
     /**
      * `lib/mdxishTags.ts` — collects component names, so nothing inline is needed.
      * Omits `htmlBlockComponent` deliberately since it's not a custom component,
@@ -80867,6 +80980,7 @@ const splitHtmlWithNestedTables = (node, source) => {
 
 
 
+
 
 
 const isTableCell = (node) => isMDXElement(node) && ['th', 'td'].includes(node.name);
@@ -80887,9 +81001,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])
@@ -101933,6 +102051,18 @@ const embed_embed = (node) => {
 };
 /* harmony default export */ const compile_embed = (embed_embed);
 
+;// ./processor/compile/heading.ts
+
+
+const SETEXT_UNDERLINE_REGEX = /\n(?:=+|-+)$/;
+/** Writes an explicit heading id back as ` {#id}`. A setext heading, written for a line break, can't carry one. */
+const compile_heading_heading = ((node, parent, state, info) => {
+    const markdown = handle.heading(node, parent, state, info);
+    const id = explicitHeadingId(node);
+    return id && !SETEXT_UNDERLINE_REGEX.test(markdown) ? `${markdown} {#${id}}` : markdown;
+});
+/* harmony default export */ const compile_heading = (compile_heading_heading);
+
 ;// ./processor/compile/html-block.ts
 
 const htmlBlock = (node) => {
@@ -102078,6 +102208,7 @@ const mdxishText = (node, parent, state, info) => compile_text_text(node, parent
 
 
 
+
 function compilers(mdxish = false) {
     const data = this.data();
     const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
@@ -102098,6 +102229,7 @@ function compilers(mdxish = false) {
         text: compile_text_text,
         yaml: compile_compatibility,
         // needed only for mdxish
+        ...(mdxish && { heading: compile_heading }),
         ...(mdxish && { list: compile_list }),
         ...(mdxish && { listItem: list_item }),
         ...(mdxish && { text: compile_text }),
@@ -105647,6 +105779,7 @@ function reactElementToHast(node) {
 
 
 
+
 /**
  * Bind the components a given expression actually uses as tags. Scoped per expression on purpose:
  * binding the whole hash would shadow same-named globals (a `math` component would break
@@ -105697,14 +105830,6 @@ const wrapInParagraph = (child) => ({
     position: child.position,
 });
 const placeText = (text, needsBlock) => (needsBlock ? wrapInParagraph(text) : text);
-/** Turn a non-renderable evaluation result into a text node. */
-const createTextNode = (result, position) => {
-    if (result === null || result === undefined)
-        return { type: 'text', value: '', position };
-    if (typeof result === 'object')
-        return { type: 'text', value: JSON.stringify(result), position };
-    return { type: 'text', value: String(result), position };
-};
 /**
  * AST transformer to evaluate MDX expressions.
  * Replaces mdxFlowExpression and mdxTextExpression nodes with their evaluated values.
@@ -105824,6 +105949,26 @@ const evaluateStyleBlockExpressions = () => (tree, file) => {
 };
 /* harmony default export */ const evaluate_style_block_expressions = (evaluateStyleBlockExpressions);
 
+;// ./processor/transform/mdxish/heading-ids.ts
+
+/**
+ * Records every heading id set by `{#id}`, so the slug pass never gives one to another heading.
+ * Warns when two headings share an id, since links can only reach the first.
+ */
+const headingIdsTransformer = () => (tree, file) => {
+    visit(tree, 'heading', (node) => {
+        const id = node.data?.hProperties?.id;
+        if (typeof id !== 'string')
+            return;
+        const ids = file.data.explicitHeadingIds ?? new Set();
+        file.data.explicitHeadingIds = ids;
+        if (ids.has(id))
+            console.warn(`[mdxish] Heading id "${id}" is used more than once; links reach only the first.`);
+        ids.add(id);
+    });
+};
+/* harmony default export */ const heading_ids = (headingIdsTransformer);
+
 ;// ./processor/transform/mdxish/heading-slugs.ts
 
 
@@ -105849,12 +105994,17 @@ function textContent(node) {
  * Id's are used to construct slug anchor links & Table of Contents during rendering
  * Use the text / nodes that make up the heading to generate the id
  */
-const generateSlugForHeadings = () => (tree) => {
+const generateSlugForHeadings = () => (tree, file) => {
     const slugger = new BananaSlug();
+    // The slugger only counts the ids it generates, so `{#id}` ones are skipped past by hand.
+    const explicitIds = file.data.explicitHeadingIds ?? new Set();
     visit(tree, 'element', (node) => {
         if (isHeading(node) && !node.properties.id) {
             const text = node.children.map(textContent).join('');
-            node.properties.id = slugger.slug(text);
+            let id = slugger.slug(text);
+            while (explicitIds.has(id))
+                id = slugger.slug(text);
+            node.properties.id = id;
         }
     });
     return tree;
@@ -107790,22 +107940,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. */
@@ -108363,6 +108519,7 @@ function loadComponents() {
 
 
 
+
 
 
 const defaultTransformers = [
@@ -108482,24 +108639,15 @@ function mdxishMdastToMd(mdast) {
         .use(remarkStringify, stringifyOptions);
     return processor.stringify(processor.runSync(mdast));
 }
-/**
- * Processes markdown content with MDX syntax support and returns a HAST.
- * Detects and renders custom component tags from the components hash.
- *
- * @see .claude/context/MDXish/Processor Overview.md
- */
-function mdxish(mdContent, opts = {}) {
+/** The steps `mdxish()` runs after parsing; run it on the parse's VFile, since steps read `file.data`. */
+function mdxishRenderProcessor(opts = {}) {
     const { components: userComponents = {}, hardBreaks: enableHardBreaks = true, safeMode = false, sanitize = false, variables, } = opts;
     const components = {
         ...loadComponents(),
         ...userComponents,
     };
-    // Remove JSX comments before processing (protect code blocks first)
-    const { protectedCode, protectedContent } = protectCodeBlocks(mdContent);
-    const withoutComments = removeJSXComments(protectedContent);
-    const contentWithoutComments = restoreCodeBlocks(withoutComments, protectedCode);
-    const { processor, parserReadyContent } = mdxishAstProcessor(contentWithoutComments, opts);
-    processor
+    return unified()
+        .use(heading_ids)
         .use(safeMode ? undefined : evaluate_exports, { sanitize }) // Evaluate `export const/function` and stash scope on file.data.mdxishScope
         .use(enableHardBreaks ? hard_breaks : undefined) // Must precede evaluateExpressions to avoid splitting the \n in an evaluated template literal into a <br> node
         .use(safeMode ? undefined : evaluate_expressions, { components, variables }) // Evaluate self-contained MDX expressions (e.g. `{1+1}`)
@@ -108517,11 +108665,25 @@ function mdxish(mdContent, opts = {}) {
         .use(heading_slugs)
         .use(rehypeMdxishComponents, {
         components,
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- component bodies render through mdxish() again
         processMarkdown: (markdown) => mdxish(markdown, opts),
     });
+}
+/**
+ * Processes markdown content with MDX syntax support and returns a HAST.
+ * Detects and renders custom component tags from the components hash.
+ *
+ * @see .claude/context/MDXish/Processor Overview.md
+ */
+function mdxish(mdContent, opts = {}) {
+    // Remove JSX comments before processing (protect code blocks first)
+    const { protectedCode, protectedContent } = protectCodeBlocks(mdContent);
+    const withoutComments = removeJSXComments(protectedContent);
+    const contentWithoutComments = restoreCodeBlocks(withoutComments, protectedCode);
+    const { processor, parserReadyContent } = mdxishAstProcessor(contentWithoutComments, opts);
     const vfile = new VFile({ value: parserReadyContent });
-    const mdast = processor.parse(parserReadyContent);
-    const hast = processor.runSync(mdast, vfile);
+    const mdast = processor.runSync(processor.parse(parserReadyContent), vfile);
+    const hast = mdxishRenderProcessor(opts).runSync(mdast, vfile);
     if (!hast) {
         throw new Error('Markdown pipeline did not produce a HAST tree.');
     }
@@ -108546,6 +108708,134 @@ const mix = (text, opts = {}) => {
 };
 /* harmony default export */ const lib_mix = (mix);
 
+;// ./lib/mdxishHeadingIds.ts
+
+
+
+
+
+
+
+
+const HEADING_INDEX = 'dataMdxishHeadingIndex';
+const HEADING_TAG_REGEX = /^h[1-6]$/;
+const JSX_COMMENT_ONLY_REGEX = new RegExp(`^${JSX_COMMENT_REGEX.source}$`);
+const isExpression = (node) => node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression';
+function collectHeadings(tree) {
+    const headings = [];
+    visit(tree, 'heading', (node) => {
+        headings.push(node);
+    });
+    return headings;
+}
+function literalValue(source) {
+    try {
+        return { value: evaluateLiteralExpression(source) };
+    }
+    catch {
+        return null;
+    }
+}
+function trimHeadingText(heading) {
+    const first = heading.children[0];
+    if (first?.type === 'text')
+        first.value = first.value.trimStart();
+    const last = heading.children.at(-1);
+    if (last?.type === 'text')
+        last.value = last.value.trimEnd();
+}
+const isNamePath = (node) => node.type === 'Identifier' ||
+    (node.type === 'MemberExpression' && !node.computed && !!node.object && isNamePath(node.object));
+// A name like `{price}` or `{plan.name}` can only read a value, never build an element. Code the parser
+// rejects can't run at all, so the hub shows it as text.
+function canBuildElements(source) {
+    try {
+        return !isNamePath(jsxAcornParser.parseExpressionAt(source, 0, { ecmaVersion: 'latest' }));
+    }
+    catch {
+        return false;
+    }
+}
+const isHeadingElement = (node) => isMDXElement(node) && HEADING_TAG_REGEX.test(node.name ?? '');
+// An expression the hub has to run changes a heading from inside one (Markdown or an HTML heading tag), by
+// building an element (a call or JSX), or as a block: alone in its paragraph, its result is lifted out as one.
+function canChangeHeadings(node, ancestors, heading) {
+    if (heading || ancestors.some(isHeadingElement) || node.type === 'mdxFlowExpression' || canBuildElements(node.value))
+        return true;
+    const parent = ancestors[ancestors.length - 1];
+    return parent.children.every(child => child === node || (child.type === 'text' && !child.value.trim()));
+}
+// Safe mode leaves `<h2 id={...}>` without the id the hub evaluates, which shifts the numbering.
+function hasEvaluatedHeadingAttribute(tree) {
+    let found = false;
+    visit(tree, isHeadingElement, (node) => {
+        found = node.attributes.some(attribute => attribute.type === 'mdxJsxExpressionAttribute' || typeof attribute.value === 'object');
+        return found ? (/* inlined export .EXIT */false) : undefined;
+    });
+    return found;
+}
+// Matches what the hub renders without running code: comments are stripped and plain literals become their
+// text. `false` when an expression that needs running could change the headings.
+function settleExpressions(tree) {
+    const edits = [];
+    let settled = true;
+    visitParents(tree, isExpression, (node, ancestors) => {
+        const heading = ancestors.find((ancestor) => ancestor.type === 'heading');
+        const parent = ancestors[ancestors.length - 1];
+        if (JSX_COMMENT_ONLY_REGEX.test(`{${node.value}}`)) {
+            edits.push({ heading, node, parent, replacement: null });
+            return;
+        }
+        const literal = literalValue(node.value);
+        if (literal) {
+            edits.push({ heading, node, parent, replacement: createTextNode(literal.value, node.position) });
+            return;
+        }
+        if (canChangeHeadings(node, ancestors, heading))
+            settled = false;
+    });
+    const apply = ({ node, parent, replacement }) => {
+        parent.children.splice(parent.children.indexOf(node), 1, ...(replacement ? [replacement] : []));
+    };
+    // Comments go first: the hub strips them from the source, so the parser trims only the source
+    // whitespace around them, never the spaces a literal adds.
+    edits
+        .filter(edit => !edit.replacement)
+        .forEach(edit => {
+        apply(edit);
+        if (edit.heading)
+            trimHeadingText(edit.heading);
+    });
+    edits.filter(edit => edit.replacement).forEach(apply);
+    return settled;
+}
+/** Each heading's rendered anchor id, worked out without running code; `null` when code could change them. */
+function mdxishHeadingIds(tree, opts = {}) {
+    const headings = collectHeadings(tree);
+    if (headings.length === 0)
+        return new Map();
+    const copy = structuredClone(tree);
+    let hasExport = false;
+    visit(copy, 'mdxjsEsm', () => {
+        hasExport = true;
+    });
+    // An `export` can define components that render headings.
+    if (hasExport || hasEvaluatedHeadingAttribute(copy) || !settleExpressions(copy))
+        return null;
+    collectHeadings(copy).forEach((heading, index) => {
+        heading.data = { ...heading.data, hProperties: { ...heading.data?.hProperties, [HEADING_INDEX]: index } };
+    });
+    const hast = mdxishRenderProcessor({ ...opts, safeMode: true }).runSync(copy, new VFile());
+    const ids = new Map();
+    visit(hast, 'element', (node) => {
+        const index = node.properties[HEADING_INDEX];
+        if (index === undefined || typeof node.properties.id !== 'string')
+            return;
+        ids.set(headings[Number(index)], node.properties.id);
+    });
+    return ids;
+}
+
 ;// ./lib/extractToc.ts
 
 /* harmony default export */ const lib_extractToc = (extractToc);
@@ -108758,8 +109048,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 +109061,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);
 }
@@ -109163,6 +109455,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
+
 
 ;// ./index.tsx
 
@@ -109459,7 +109752,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__(9477);
 /******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()