@readme/markdown 14.14.2 → 15.0.1

package/dist/main.node.js

@@ -275,7 +275,7 @@ function visit(tree, test, visitor, reverse) {
 
 /***/ }),
 
-/***/ 9762:
+/***/ 7644:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -349,7 +349,7 @@ exports["default"] = canonical;
 
 /***/ }),
 
-/***/ 7900:
+/***/ 4350:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
@@ -358,15 +358,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-const canonical_1 = __importDefault(__webpack_require__(9762));
-const modes_1 = __webpack_require__(1412);
-const uppercase_1 = __importDefault(__webpack_require__(8892));
+const canonical_1 = __importDefault(__webpack_require__(7644));
+const modes_1 = __webpack_require__(1130);
+const uppercase_1 = __importDefault(__webpack_require__(3622));
 exports["default"] = { uppercase: uppercase_1.default, canonical: canonical_1.default, modes: modes_1.modes, getMode: modes_1.getMode };
 
 
 /***/ }),
 
-/***/ 1412:
+/***/ 1130:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -425,6 +425,7 @@ exports.modes = {
     node: 'javascript',
     macruby: 'ruby',
     markdown: 'gfm',
+    md: 'gfm',
     ml: ['mllike', 'text/x-ocaml'],
     mssql: ['sql', 'text/x-mssql'],
     mysql: ['sql', 'text/x-mysql'],
@@ -479,7 +480,7 @@ function getMode(lang) {
 
 /***/ }),
 
-/***/ 8892:
+/***/ 3622:
 /***/ ((__unused_webpack_module, exports) => {
 
 "use strict";
@@ -19303,7 +19304,7 @@ __webpack_require__.d(__webpack_exports__, {
   stripComments: () => (/* reexport */ lib_stripComments),
   tags: () => (/* reexport */ lib_tags),
   tailwindCompiler: () => (/* reexport */ tailwindCompiler),
-  utils: () => (/* binding */ utils)
+  utils: () => (/* binding */ index_utils)
 });
 
 // NAMESPACE OBJECT: ./components/index.ts
@@ -19625,16 +19626,16 @@ const Code = (props) => {
 };
 /* harmony default export */ const components_Code = (Code);
 
-// EXTERNAL MODULE: ./node_modules/@readme/syntax-highlighter/dist-utils/index.js
-var dist_utils = __webpack_require__(7900);
-var dist_utils_default = /*#__PURE__*/__webpack_require__.n(dist_utils);
+// EXTERNAL MODULE: ./node_modules/@readme/syntax-highlighter/dist-utils/utils/index.js
+var utils = __webpack_require__(4350);
+var utils_default = /*#__PURE__*/__webpack_require__.n(utils);
 ;// ./components/CodeTabs/index.tsx
 
 
 
 
 let mermaid;
-const { uppercase } = (dist_utils_default());
+const { uppercase } = (utils_default());
 // Module-level queue that batches mermaid nodes across all CodeTabs instances into a
 // single mermaid.run() call. This is necessary because mermaid generates SVG element IDs
 // using Date.now(), which collides when multiple diagrams render in the same millisecond.
@@ -27249,72 +27250,319 @@ function push(list, items) {
   return items
 }
 
+;// ./node_modules/micromark-util-subtokenize/lib/splice-buffer.js
+/**
+ * Some of the internal operations of micromark do lots of editing
+ * operations on very large arrays. This runs into problems with two
+ * properties of most circa-2020 JavaScript interpreters:
+ *
+ *  - Array-length modifications at the high end of an array (push/pop) are
+ *    expected to be common and are implemented in (amortized) time
+ *    proportional to the number of elements added or removed, whereas
+ *    other operations (shift/unshift and splice) are much less efficient.
+ *  - Function arguments are passed on the stack, so adding tens of thousands
+ *    of elements to an array with `arr.push(...newElements)` will frequently
+ *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)
+ *
+ * SpliceBuffers are an implementation of gap buffers, which are a
+ * generalization of the "queue made of two stacks" idea. The splice buffer
+ * maintains a cursor, and moving the cursor has cost proportional to the
+ * distance the cursor moves, but inserting, deleting, or splicing in
+ * new information at the cursor is as efficient as the push/pop operation.
+ * This allows for an efficient sequence of splices (or pushes, pops, shifts,
+ * or unshifts) as long such edits happen at the same part of the array or
+ * generally sweep through the array from the beginning to the end.
+ *
+ * The interface for splice buffers also supports large numbers of inputs by
+ * passing a single array argument rather passing multiple arguments on the
+ * function call stack.
+ *
+ * @template T
+ *   Item type.
+ */
+class SpliceBuffer {
+  /**
+   * @param {ReadonlyArray<T> | null | undefined} [initial]
+   *   Initial items (optional).
+   * @returns
+   *   Splice buffer.
+   */
+  constructor(initial) {
+    /** @type {Array<T>} */
+    this.left = initial ? [...initial] : [];
+    /** @type {Array<T>} */
+    this.right = [];
+  }
+
+  /**
+   * Array access;
+   * does not move the cursor.
+   *
+   * @param {number} index
+   *   Index.
+   * @return {T}
+   *   Item.
+   */
+  get(index) {
+    if (index < 0 || index >= this.left.length + this.right.length) {
+      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');
+    }
+    if (index < this.left.length) return this.left[index];
+    return this.right[this.right.length - index + this.left.length - 1];
+  }
+
+  /**
+   * The length of the splice buffer, one greater than the largest index in the
+   * array.
+   */
+  get length() {
+    return this.left.length + this.right.length;
+  }
+
+  /**
+   * Remove and return `list[0]`;
+   * moves the cursor to `0`.
+   *
+   * @returns {T | undefined}
+   *   Item, optional.
+   */
+  shift() {
+    this.setCursor(0);
+    return this.right.pop();
+  }
+
+  /**
+   * Slice the buffer to get an array;
+   * does not move the cursor.
+   *
+   * @param {number} start
+   *   Start.
+   * @param {number | null | undefined} [end]
+   *   End (optional).
+   * @returns {Array<T>}
+   *   Array of items.
+   */
+  slice(start, end) {
+    /** @type {number} */
+    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;
+    if (stop < this.left.length) {
+      return this.left.slice(start, stop);
+    }
+    if (start > this.left.length) {
+      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();
+    }
+    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());
+  }
+
+  /**
+   * Mimics the behavior of Array.prototype.splice() except for the change of
+   * interface necessary to avoid segfaults when patching in very large arrays.
+   *
+   * This operation moves cursor is moved to `start` and results in the cursor
+   * placed after any inserted items.
+   *
+   * @param {number} start
+   *   Start;
+   *   zero-based index at which to start changing the array;
+   *   negative numbers count backwards from the end of the array and values
+   *   that are out-of bounds are clamped to the appropriate end of the array.
+   * @param {number | null | undefined} [deleteCount=0]
+   *   Delete count (default: `0`);
+   *   maximum number of elements to delete, starting from start.
+   * @param {Array<T> | null | undefined} [items=[]]
+   *   Items to include in place of the deleted items (default: `[]`).
+   * @return {Array<T>}
+   *   Any removed items.
+   */
+  splice(start, deleteCount, items) {
+    /** @type {number} */
+    const count = deleteCount || 0;
+    this.setCursor(Math.trunc(start));
+    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);
+    if (items) chunkedPush(this.left, items);
+    return removed.reverse();
+  }
+
+  /**
+   * Remove and return the highest-numbered item in the array, so
+   * `list[list.length - 1]`;
+   * Moves the cursor to `length`.
+   *
+   * @returns {T | undefined}
+   *   Item, optional.
+   */
+  pop() {
+    this.setCursor(Number.POSITIVE_INFINITY);
+    return this.left.pop();
+  }
+
+  /**
+   * Inserts a single item to the high-numbered side of the array;
+   * moves the cursor to `length`.
+   *
+   * @param {T} item
+   *   Item.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  push(item) {
+    this.setCursor(Number.POSITIVE_INFINITY);
+    this.left.push(item);
+  }
+
+  /**
+   * Inserts many items to the high-numbered side of the array.
+   * Moves the cursor to `length`.
+   *
+   * @param {Array<T>} items
+   *   Items.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  pushMany(items) {
+    this.setCursor(Number.POSITIVE_INFINITY);
+    chunkedPush(this.left, items);
+  }
+
+  /**
+   * Inserts a single item to the low-numbered side of the array;
+   * Moves the cursor to `0`.
+   *
+   * @param {T} item
+   *   Item.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  unshift(item) {
+    this.setCursor(0);
+    this.right.push(item);
+  }
+
+  /**
+   * Inserts many items to the low-numbered side of the array;
+   * moves the cursor to `0`.
+   *
+   * @param {Array<T>} items
+   *   Items.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  unshiftMany(items) {
+    this.setCursor(0);
+    chunkedPush(this.right, items.reverse());
+  }
+
+  /**
+   * Move the cursor to a specific position in the array. Requires
+   * time proportional to the distance moved.
+   *
+   * If `n < 0`, the cursor will end up at the beginning.
+   * If `n > length`, the cursor will end up at the end.
+   *
+   * @param {number} n
+   *   Position.
+   * @return {undefined}
+   *   Nothing.
+   */
+  setCursor(n) {
+    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;
+    if (n < this.left.length) {
+      // Move cursor to the this.left
+      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);
+      chunkedPush(this.right, removed.reverse());
+    } else {
+      // Move cursor to the this.right
+      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);
+      chunkedPush(this.left, removed.reverse());
+    }
+  }
+}
+
+/**
+ * Avoid stack overflow by pushing items onto the stack in segments
+ *
+ * @template T
+ *   Item type.
+ * @param {Array<T>} list
+ *   List to inject into.
+ * @param {ReadonlyArray<T>} right
+ *   Items to inject.
+ * @return {undefined}
+ *   Nothing.
+ */
+function chunkedPush(list, right) {
+  /** @type {number} */
+  let chunkStart = 0;
+  if (right.length < 10000) {
+    list.push(...right);
+  } else {
+    while (chunkStart < right.length) {
+      list.push(...right.slice(chunkStart, chunkStart + 10000));
+      chunkStart += 10000;
+    }
+  }
+}
 ;// ./node_modules/micromark-util-subtokenize/index.js
 /**
- * @typedef {import('micromark-util-types').Chunk} Chunk
- * @typedef {import('micromark-util-types').Event} Event
- * @typedef {import('micromark-util-types').Token} Token
+ * @import {Chunk, Event, Token} from 'micromark-util-types'
  */
 
 
+
+
+// Hidden API exposed for testing.
+
+
 /**
  * Tokenize subcontent.
  *
- * @param {Array<Event>} events
+ * @param {Array<Event>} eventsArray
  *   List of events.
  * @returns {boolean}
  *   Whether subtokens were found.
- */ // eslint-disable-next-line complexity
-function subtokenize(events) {
+ */
+// eslint-disable-next-line complexity
+function subtokenize(eventsArray) {
   /** @type {Record<string, number>} */
-  const jumps = {}
-  let index = -1
+  const jumps = {};
+  let index = -1;
   /** @type {Event} */
-  let event
+  let event;
   /** @type {number | undefined} */
-  let lineIndex
+  let lineIndex;
   /** @type {number} */
-  let otherIndex
+  let otherIndex;
   /** @type {Event} */
-  let otherEvent
+  let otherEvent;
   /** @type {Array<Event>} */
-  let parameters
+  let parameters;
   /** @type {Array<Event>} */
-  let subevents
+  let subevents;
   /** @type {boolean | undefined} */
-  let more
+  let more;
+  const events = new SpliceBuffer(eventsArray);
   while (++index < events.length) {
     while (index in jumps) {
-      index = jumps[index]
+      index = jumps[index];
     }
-    event = events[index]
+    event = events.get(index);
 
     // Add a hook for the GFM tasklist extension, which needs to know if text
     // is in the first content of a list item.
-    if (
-      index &&
-      event[1].type === 'chunkFlow' &&
-      events[index - 1][1].type === 'listItemPrefix'
-    ) {
-      subevents = event[1]._tokenizer.events
-      otherIndex = 0
-      if (
-        otherIndex < subevents.length &&
-        subevents[otherIndex][1].type === 'lineEndingBlank'
-      ) {
-        otherIndex += 2
+    if (index && event[1].type === "chunkFlow" && events.get(index - 1)[1].type === "listItemPrefix") {
+      subevents = event[1]._tokenizer.events;
+      otherIndex = 0;
+      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") {
+        otherIndex += 2;
       }
-      if (
-        otherIndex < subevents.length &&
-        subevents[otherIndex][1].type === 'content'
-      ) {
+      if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") {
         while (++otherIndex < subevents.length) {
-          if (subevents[otherIndex][1].type === 'content') {
-            break
+          if (subevents[otherIndex][1].type === "content") {
+            break;
           }
-          if (subevents[otherIndex][1].type === 'chunkText') {
-            subevents[otherIndex][1]._isInFirstContentOfListItem = true
-            otherIndex++
+          if (subevents[otherIndex][1].type === "chunkText") {
+            subevents[otherIndex][1]._isInFirstContentOfListItem = true;
+            otherIndex++;
           }
         }
       }
@@ -27323,158 +27571,160 @@ function subtokenize(events) {
     // Enter.
     if (event[0] === 'enter') {
       if (event[1].contentType) {
-        Object.assign(jumps, subcontent(events, index))
-        index = jumps[index]
-        more = true
+        Object.assign(jumps, subcontent(events, index));
+        index = jumps[index];
+        more = true;
       }
     }
     // Exit.
     else if (event[1]._container) {
-      otherIndex = index
-      lineIndex = undefined
+      otherIndex = index;
+      lineIndex = undefined;
       while (otherIndex--) {
-        otherEvent = events[otherIndex]
-        if (
-          otherEvent[1].type === 'lineEnding' ||
-          otherEvent[1].type === 'lineEndingBlank'
-        ) {
+        otherEvent = events.get(otherIndex);
+        if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") {
           if (otherEvent[0] === 'enter') {
             if (lineIndex) {
-              events[lineIndex][1].type = 'lineEndingBlank'
+              events.get(lineIndex)[1].type = "lineEndingBlank";
             }
-            otherEvent[1].type = 'lineEnding'
-            lineIndex = otherIndex
+            otherEvent[1].type = "lineEnding";
+            lineIndex = otherIndex;
           }
+        } else if (otherEvent[1].type === "linePrefix") {
+          // Move past.
         } else {
-          break
+          break;
         }
       }
       if (lineIndex) {
         // Fix position.
-        event[1].end = Object.assign({}, events[lineIndex][1].start)
+        event[1].end = {
+          ...events.get(lineIndex)[1].start
+        };
 
         // Switch container exit w/ line endings.
-        parameters = events.slice(lineIndex, index)
-        parameters.unshift(event)
-        splice(events, lineIndex, index - lineIndex + 1, parameters)
+        parameters = events.slice(lineIndex, index);
+        parameters.unshift(event);
+        events.splice(lineIndex, index - lineIndex + 1, parameters);
       }
     }
   }
-  return !more
+
+  // The changes to the `events` buffer must be copied back into the eventsArray
+  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));
+  return !more;
 }
 
 /**
  * Tokenize embedded tokens.
  *
- * @param {Array<Event>} events
+ * @param {SpliceBuffer<Event>} events
+ *   Events.
  * @param {number} eventIndex
+ *   Index.
  * @returns {Record<string, number>}
+ *   Gaps.
  */
 function subcontent(events, eventIndex) {
-  const token = events[eventIndex][1]
-  const context = events[eventIndex][2]
-  let startPosition = eventIndex - 1
+  const token = events.get(eventIndex)[1];
+  const context = events.get(eventIndex)[2];
+  let startPosition = eventIndex - 1;
   /** @type {Array<number>} */
-  const startPositions = []
-  const tokenizer =
-    token._tokenizer || context.parser[token.contentType](token.start)
-  const childEvents = tokenizer.events
+  const startPositions = [];
+  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);
+  const childEvents = tokenizer.events;
   /** @type {Array<[number, number]>} */
-  const jumps = []
+  const jumps = [];
   /** @type {Record<string, number>} */
-  const gaps = {}
+  const gaps = {};
   /** @type {Array<Chunk>} */
-  let stream
+  let stream;
   /** @type {Token | undefined} */
-  let previous
-  let index = -1
+  let previous;
+  let index = -1;
   /** @type {Token | undefined} */
-  let current = token
-  let adjust = 0
-  let start = 0
-  const breaks = [start]
+  let current = token;
+  let adjust = 0;
+  let start = 0;
+  const breaks = [start];
 
   // Loop forward through the linked tokens to pass them in order to the
   // subtokenizer.
   while (current) {
     // Find the position of the event for this token.
-    while (events[++startPosition][1] !== current) {
+    while (events.get(++startPosition)[1] !== current) {
       // Empty.
     }
-    startPositions.push(startPosition)
+    startPositions.push(startPosition);
     if (!current._tokenizer) {
-      stream = context.sliceStream(current)
+      stream = context.sliceStream(current);
       if (!current.next) {
-        stream.push(null)
+        stream.push(null);
       }
       if (previous) {
-        tokenizer.defineSkip(current.start)
+        tokenizer.defineSkip(current.start);
       }
       if (current._isInFirstContentOfListItem) {
-        tokenizer._gfmTasklistFirstContentOfListItem = true
+        tokenizer._gfmTasklistFirstContentOfListItem = true;
       }
-      tokenizer.write(stream)
+      tokenizer.write(stream);
       if (current._isInFirstContentOfListItem) {
-        tokenizer._gfmTasklistFirstContentOfListItem = undefined
+        tokenizer._gfmTasklistFirstContentOfListItem = undefined;
       }
     }
 
     // Unravel the next token.
-    previous = current
-    current = current.next
+    previous = current;
+    current = current.next;
   }
 
   // Now, loop back through all events (and linked tokens), to figure out which
   // parts belong where.
-  current = token
+  current = token;
   while (++index < childEvents.length) {
     if (
-      // Find a void token that includes a break.
-      childEvents[index][0] === 'exit' &&
-      childEvents[index - 1][0] === 'enter' &&
-      childEvents[index][1].type === childEvents[index - 1][1].type &&
-      childEvents[index][1].start.line !== childEvents[index][1].end.line
-    ) {
-      start = index + 1
-      breaks.push(start)
+    // Find a void token that includes a break.
+    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {
+      start = index + 1;
+      breaks.push(start);
       // Help GC.
-      current._tokenizer = undefined
-      current.previous = undefined
-      current = current.next
+      current._tokenizer = undefined;
+      current.previous = undefined;
+      current = current.next;
     }
   }
 
   // Help GC.
-  tokenizer.events = []
+  tokenizer.events = [];
 
   // If there’s one more token (which is the cases for lines that end in an
   // EOF), that’s perfect: the last point we found starts it.
   // If there isn’t then make sure any remaining content is added to it.
   if (current) {
     // Help GC.
-    current._tokenizer = undefined
-    current.previous = undefined
+    current._tokenizer = undefined;
+    current.previous = undefined;
   } else {
-    breaks.pop()
+    breaks.pop();
   }
 
   // Now splice the events from the subtokenizer into the current events,
   // moving back to front so that splice indices aren’t affected.
-  index = breaks.length
+  index = breaks.length;
   while (index--) {
-    const slice = childEvents.slice(breaks[index], breaks[index + 1])
-    const start = startPositions.pop()
-    jumps.unshift([start, start + slice.length - 1])
-    splice(events, start, 2, slice)
+    const slice = childEvents.slice(breaks[index], breaks[index + 1]);
+    const start = startPositions.pop();
+    jumps.push([start, start + slice.length - 1]);
+    events.splice(start, 2, slice);
   }
-  index = -1
+  jumps.reverse();
+  index = -1;
   while (++index < jumps.length) {
-    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]
-    adjust += jumps[index][1] - jumps[index][0] - 1
+    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
+    adjust += jumps[index][1] - jumps[index][0] - 1;
   }
-  return gaps
+  return gaps;
 }
-
 ;// ./node_modules/micromark/lib/postprocess.js
 /**
  * @typedef {import('micromark-util-types').Event} Event
@@ -94657,11 +94907,6 @@ const looseHtmlEntityConstruct = {
     name: 'looseHtmlEntity',
     tokenize: tokenizeLooseHtmlEntity,
 };
-function resolveEntity(name) {
-    const input = `&${name};`;
-    const decoded = decode_decodeHTMLStrict(input);
-    return decoded !== input ? decoded : undefined;
-}
 function tokenizeLooseHtmlEntity(effects, ok, nok) {
     let length = 0;
     const start = (code) => {
@@ -94728,28 +94973,9 @@ function tokenizeLooseHtmlEntity(effects, ok, nok) {
 }
 function exitLooseHtmlEntity(token) {
     const raw = this.sliceSerialize(token);
-    const entityChars = raw.slice(1);
-    if (entityChars.startsWith('#')) {
-        const decoded = resolveEntity(entityChars);
-        if (decoded) {
-            this.enter({ type: 'text', value: decoded }, token);
-            this.exit(token);
-            return;
-        }
-    }
-    else {
-        for (let len = entityChars.length; len >= 2; len -= 1) {
-            const candidate = entityChars.slice(0, len);
-            const decoded = resolveEntity(candidate);
-            if (decoded) {
-                const remainder = entityChars.slice(len);
-                this.enter({ type: 'text', value: decoded + remainder }, token);
-                this.exit(token);
-                return;
-            }
-        }
-    }
-    this.enter({ type: 'text', value: raw }, token);
+    // `decodeHTML` follows the HTML spec's legacy rules, where only a small
+    // whitelist of names may omit the semicolon, so `&partner_key` stays intact.
+    this.enter({ type: 'text', value: esm_decode_decodeHTML(raw) }, token);
     this.exit(token);
 }
 function looseHtmlEntity() {
@@ -94769,10 +94995,11 @@ function looseHtmlEntityFromMarkdown() {
 /**
  * Micromark extension for HTML entities without semicolons.
  *
- * Handles named entities (e.g. `&nbsp`, `&amp`, `&copy`), decimal numeric
- * references (e.g. `&#160`, `&#169`), and hex numeric references (e.g. `&#xa0`,
- * `&#xA0`). Entities that already include the semicolon are left for the
- * standard parser to handle.
+ * Handles the named entities the HTML spec lets authors write without a
+ * semicolon (e.g. `&nbsp`, `&amp`, `&copy`), decimal numeric references (e.g.
+ * `&#160`, `&#169`), and hex numeric references (e.g. `&#xa0`, `&#xA0`).
+ * Entities that already include the semicolon are left for the standard parser
+ * to handle.
  */
 
 
@@ -113513,7 +113740,9 @@ class MdxSyntaxError extends SyntaxError {
  * as `\r<br>`. Treating both characters as hard breaks doubles the spacing.
  */
 const hardBreaks = () => tree => {
-    findAndReplace(tree, [/\r?\n/g, () => ({ type: 'break' })]);
+    // Skip `html-block`: its opaque payload is rendered verbatim, so turning its newlines
+    // into `break` nodes is unnecessary and costly on large blocks.
+    findAndReplace(tree, [/\r?\n/g, () => ({ type: 'break' })], { ignore: ['html-block'] });
 };
 /* harmony default export */ const hard_breaks = (hardBreaks);
 
@@ -123982,6 +124211,10 @@ const NESTED_ATTR_EXPRESSION_RE = /[\w-]+\s*=\s*\{/;
 // Name shape mirrors `componentTagPattern`; the lookbehind skips the inner tag
 // of a legacy `<<VARIABLE>>`.
 const NESTED_COMPONENT_TAG_RE = /(?<!<)<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+// Whole blank lines at a component body's edges. `\n` sits inside each group so a
+// match can only ever span complete lines, never part of a content line.
+const LEADING_BLANK_LINES_RE = /^(?:[ \t]*\n)+/;
+const TRAILING_BLANK_LINES_RE = /(?:\n[ \t]*)+$/;
 // Excludes tags with dedicated transformers (`Table`, `HTMLBlock`, inline
 // components), which expect their wrapper to stay raw.
 const hasNestedGenericComponentTag = (content) => [...content.matchAll(NESTED_COMPONENT_TAG_RE)].some(match => !GENERIC_MDX_COMPONENT_EXCLUDED_TAGS.has(match[1]));
@@ -124015,13 +124248,21 @@ function safeDeindent(text) {
     })
         .join('\n');
 }
+/**
+ * Drop the blank lines at a component body's edges, keeping the first content line's
+ * indent: `.trim()` stripped that line alone, so a uniformly indented body reparsed
+ * lopsided and every list item after the first nested. The trailing pattern
+ * takes the last content line's newline but leaves its spaces, which are code content
+ * when a fence runs into the end tag.
+ */
+const trimBlankEdges = (text) => text.replace(LEADING_BLANK_LINES_RE, '').replace(TRAILING_BLANK_LINES_RE, '');
 /**
  * Parse component-body markdown into mdast children. Dedenting shifts columns and
  * stales the top-level `terminateHtmlFlowBlocks` decisions, so that one preprocessor
  * re-runs here; other column-anchored fixups (compact headings, tables) do not.
  */
 const parseMdChildren = (value, safeMode) => {
-    const reparseSource = terminateHtmlFlowBlocks(safeDeindent(value).trim());
+    const reparseSource = terminateHtmlFlowBlocks(trimBlankEdges(safeDeindent(value)));
     const parsed = getInlineMdProcessor({ safeMode }).parse(reparseSource);
     // Promote nested wrappers bottom-up so an outer wrapper sees markdown buried in a
     // child claimed whole (e.g. `<li>` in `<ol>`) before its containsMarkdownConstruct check (RM-17560).
@@ -124186,7 +124427,8 @@ function promoteComponentBlocks(tree, safeMode, source) {
         // Case 2: Self-contained block (closing tag in content)
         const closingTagIndex = isPlainLowercaseHtml ? plainClosingTagIndex : contentAfterTag.lastIndexOf(closingTagStr);
         if (closingTagIndex >= 0) {
-            // Untrimmed so parseMdChildren can dedent before trimming.
+            // Left as authored: parseMdChildren needs the original columns to dedent by, and
+            // it clears the blank edges itself.
             const componentInnerContent = contentAfterTag.substring(0, closingTagIndex);
             const contentAfterClose = contentAfterTag.substring(closingTagIndex + closingTagStr.length).trim();
             let parsedChildren = [];
@@ -126552,9 +126794,9 @@ const resolveDeferredAttributeExpressionProps = () => (tree, file) => {
                 properties[name] = name === 'style' && style_object_to_css_isPlainObject(result) ? styleObjectToCssText(result) : result;
             }
             catch {
-                // Evaluation failed — fall back to the raw expression source so the attribute
-                // renders as readable text rather than disappearing.
-                properties[name] = source;
+                // Evaluation failed — keep the literal `{...}`, matching how `evaluateExpressions` falls
+                // back in body text. Variable references like `{user.name}` stay resolvable at render time.
+                properties[name] = `{${source}}`;
             }
         });
         delete node.data.deferredExpressions;
@@ -127460,6 +127702,24 @@ 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
 
 
@@ -127490,6 +127750,35 @@ const makeUseMDXComponents = (more = {}) => {
 };
 /* harmony default export */ const makeUseMdxComponents = (makeUseMDXComponents);
 
+;// ./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.
+const MDX_VARIABLE_REGEX = new RegExp(`(?<!\\$)${variable_dist.MDX_VARIABLE_REGEXP}`, 'gu');
+// Bracket notation names the same variable as dot notation, so normalize it before substituting.
+// 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;
+/**
+ * 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.
+ */
+function resolveAttributeVariables(value, user) {
+    if (!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 user[name];
+    });
+}
+
 ;// ./lib/utils/mdxish/mdxish-render-utils.tsx
 
 
@@ -127498,6 +127787,8 @@ const makeUseMDXComponents = (more = {}) => {
 
 
 
+
+
 /** Flatten CustomComponents into a component map for rehype-react */
 function exportComponentsForRehype(components) {
     const exported = Object.entries(components).reduce((memo, [tag, mod]) => {
@@ -127525,6 +127816,28 @@ function exportComponentsForRehype(components) {
     result.variable = (variable_dist_default());
     return result;
 }
+/**
+ * Code rides on a `value` prop, and `variablesCodeResolver` owns it at parse time where it
+ * deliberately leaves mermaid alone; resolving it again here would override that.
+ */
+const CODE_TAG_NAMES = new Set(['code']);
+/** Raw markup injected with `dangerouslySetInnerHTML` by HTMLBlock and Embed — never interpolate. */
+const RAW_HTML_PROP_NAMES = new Set(['html']);
+/**
+ * Resolve `{user.*}` in string-valued props. 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.
+ */
+function resolveVariablesInProps(props, user, tagName) {
+    const isCodeTag = Boolean(tagName && CODE_TAG_NAMES.has(tagName));
+    const resolvedEntries = Object.entries(props).map(([key, value]) => {
+        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 Object.fromEntries(resolvedEntries);
+}
 /**
  * Custom React.createElement wrapper that recovers real JS prop values for
  * custom components. rehype-react v6 uses hast-to-hyperscript, which stringifies
@@ -127536,7 +127849,7 @@ function exportComponentsForRehype(components) {
  * Only arrays win over `rest`, overwriting other shapes would undo correct
  * React conversions like `style="color:red"` → `{ color: 'red' }`.
  */
-function createElementPreservingHastProps(type, props, ...children) {
+const makeCreateElementPreservingHastProps = (user) => function createElementPreservingHastProps(type, props, ...children) {
     if (props?.node?.properties) {
         const { node, ...rest } = props;
         const mergedProps = { ...rest };
@@ -127546,15 +127859,16 @@ function createElementPreservingHastProps(type, props, ...children) {
         });
         // Strip undefined so positional args don't shadow node.properties.children
         const definedChildren = children.filter(c => c !== undefined);
-        return external_react_default().createElement(type, mergedProps, ...definedChildren);
+        const withVariables = resolveVariablesInProps(mergedProps, user, node.tagName);
+        return external_react_default().createElement(type, withVariables, ...definedChildren);
     }
-    return external_react_default().createElement(type, props, ...children);
-}
+    return external_react_default().createElement(type, props && resolveVariablesInProps(props, user), ...children);
+};
 /** Create a rehype-react processor */
-function createRehypeReactProcessor(components) {
+function createRehypeReactProcessor(components, variables) {
     // @ts-expect-error - rehype-react types are incompatible with React.Fragment return type
     return unified().use((rehype_react_default()), {
-        createElement: createElementPreservingHastProps,
+        createElement: makeCreateElementPreservingHastProps(user(variables)),
         Fragment: (external_react_default()).Fragment,
         components,
         passNode: true,
@@ -127569,7 +127883,7 @@ function createTocComponent(tocHast) {
         components: { p: (external_react_default()).Fragment },
     });
     const tocReactElement = tocProcessor.stringify(tocHast);
-    const TocComponent = () => tocReactElement ? (external_react_default().createElement(components_TableOfContents, null, tocReactElement)) : null;
+    const TocComponent = () => tocReactElement ? external_react_default().createElement(components_TableOfContents, null, tocReactElement) : null;
     TocComponent.displayName = 'Toc';
     return TocComponent;
 }
@@ -127618,7 +127932,7 @@ const renderMdxish = (tree, opts = {}) => {
     Object.entries(localScope).forEach(([name, value]) => {
         componentsForRehype[name] = value;
     });
-    const processor = createRehypeReactProcessor(componentsForRehype);
+    const processor = createRehypeReactProcessor(componentsForRehype, variables);
     const content = processor.stringify(tree);
     const tocHast = headings.length > 0 ? tocToHast(headings, variables) : null;
     return buildRMDXModule(content, headings, tocHast, { ...contextOpts, variables });
@@ -127674,24 +127988,6 @@ function runSync(code, options) {
 // EXTERNAL MODULE: ./node_modules/react/jsx-runtime.js
 var jsx_runtime = __webpack_require__(4848);
 var jsx_runtime_namespaceObject = /*#__PURE__*/__webpack_require__.t(jsx_runtime, 2);
-;// ./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/run.tsx
 
 
@@ -127936,7 +128232,7 @@ async function stripComments(doc, { mdx, mdxish } = {}) {
 
 
 
-const utils = {
+const index_utils = {
     get options() {
         return { ...options };
     },