@simon_he/vue-tui 1.1.12 → 1.1.14

package/dist/agent.cjs

@@ -1009,6 +1009,19 @@ function sliceByCellsRange(text2, startCells, endCells, provider = currentTextWi
     out.push(g), cells = next;
   }), out.length ? out.join("") : "";
 }
+function sliceByCellsRangeForSelection(text2, startCells, endCells, provider = currentTextWidthProvider()) {
+  if (startCells = Math.max(0, Math.floor(startCells)), endCells = Math.max(0, Math.floor(endCells)), endCells <= startCells || !text2)
+    return "";
+  if (hasAsciiFastPath(provider) && isAscii(text2))
+    return text2.slice(startCells, endCells);
+  let out = [], cells = 0;
+  return forEachGrapheme(text2, (g) => {
+    let leadingCell = cells;
+    if (cells += charCellWidth(g, provider), leadingCell >= endCells)
+      return !1;
+    leadingCell >= startCells && out.push(g);
+  }), out.join("");
+}
 function padEndByCells(text2, width, provider = currentTextWidthProvider()) {
   width = Math.max(0, Math.floor(width));
   let cells = text2 && hasAsciiFastPath(provider) && isAscii(text2) ? text2.length : textCellWidth(text2, provider);
@@ -8900,7 +8913,7 @@ var virtualListInstanceSeq = 0, TVirtualList = (0, import_vue21.defineComponent)
     function textForSelectionRange(range) {
       let cols = Math.max(1, Math.floor(props.w));
       return terminalSelectionRowSpans(range, cols, itemCount.value).map((span) => {
-        let text2 = sliceByCellsRange(itemText(span.y), span.x0, span.x1);
+        let text2 = sliceByCellsRangeForSelection(itemText(span.y), span.x0, span.x1);
         return span.x1 >= cols ? text2.trimEnd() : text2;
       }).join(`
 `);
@@ -9587,7 +9600,7 @@ var virtualRowsInstanceSeq = 0, EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0,
             x1: span.x1,
             cols
           }) ?? ""
-        ) : sliceByCellsRange(itemText(span.y), span.x0, span.x1);
+        ) : sliceByCellsRangeForSelection(itemText(span.y), span.x0, span.x1);
         return span.x1 >= cols ? text2.trimEnd() : text2;
       }).join(`
 `);
@@ -10325,7 +10338,7 @@ var TTranscriptView = (0, import_vue23.defineComponent)({
       let text2 = "";
       for (let segment of segments) {
         let start = Math.max(x0, segment.x0), end = Math.min(x1, segment.x1);
-        end <= start || !segment.selectable || (text2 += sliceByCellsRange(segment.text, start - segment.x0, end - segment.x0));
+        end <= start || !segment.selectable || (text2 += sliceByCellsRangeForSelection(segment.text, start - segment.x0, end - segment.x0));
       }
       return text2;
     }
@@ -10354,7 +10367,7 @@ var TTranscriptView = (0, import_vue23.defineComponent)({
     }
     function selectionTextForVisualRowSpan(ctx) {
       let visualRow = ctx.item;
-      return visualRow ? visualRow.selectionSegments.length ? textForSelectionSegments(visualRow.selectionSegments, ctx.x0, ctx.x1) : sliceByCellsRange(selectionTextForVisualRow(visualRow), ctx.x0, ctx.x1) : "";
+      return visualRow ? visualRow.selectionSegments.length ? textForSelectionSegments(visualRow.selectionSegments, ctx.x0, ctx.x1) : sliceByCellsRangeForSelection(selectionTextForVisualRow(visualRow), ctx.x0, ctx.x1) : "";
     }
     return () => (0, import_vue23.h)(TVirtualRows, {
       ref: rowsRef,
@@ -12613,7 +12626,7 @@ var TLogView = (0, import_vue24.defineComponent)({
     function textForSelectionRange(range) {
       let cols = currentWrapWidth(), rows = estimatedVisualRowCount();
       return terminalSelectionRowSpans(range, cols, rows).map((span) => {
-        let text2 = sliceByCellsRange(textForVisualRow(span.y), span.x0, span.x1);
+        let text2 = sliceByCellsRangeForSelection(textForVisualRow(span.y), span.x0, span.x1);
         return span.x1 >= cols ? text2.trimEnd() : text2;
       }).join(`
 `);
@@ -15157,7 +15170,7 @@ function loadBuiltinMathRasterizer() {
   })()), builtinRasterizerLoad;
 }
 
-// node_modules/.pnpm/stream-markdown-parser@1.2.12/node_modules/stream-markdown-parser/dist/index.js
+// node_modules/.pnpm/stream-markdown-parser@1.2.20/node_modules/stream-markdown-parser/dist/index.js
 var __create2 = Object.create, __defProp$1 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __getProtoOf2 = Object.getPrototypeOf, __hasOwnProp2 = Object.prototype.hasOwnProperty, __commonJS = (cb, mod) => function() {
   return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 }, __export$1 = (all) => {
@@ -15540,7 +15553,756 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
   function startsWithTodoMarkdown(token) {
     return /^\[[xX \u00A0]\][ \u00A0]/.test(token.content);
   }
-} }), decodeMap = /* @__PURE__ */ new Map([
+} }), import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM2(require_markdown_it_task_checkbox(), 1), ambiguousMinimalCodePoint = 161, ambiguousMaximumCodePoint = 1114109, ambiguousRanges = [
+  161,
+  161,
+  164,
+  164,
+  167,
+  168,
+  170,
+  170,
+  173,
+  174,
+  176,
+  180,
+  182,
+  186,
+  188,
+  191,
+  198,
+  198,
+  208,
+  208,
+  215,
+  216,
+  222,
+  225,
+  230,
+  230,
+  232,
+  234,
+  236,
+  237,
+  240,
+  240,
+  242,
+  243,
+  247,
+  250,
+  252,
+  252,
+  254,
+  254,
+  257,
+  257,
+  273,
+  273,
+  275,
+  275,
+  283,
+  283,
+  294,
+  295,
+  299,
+  299,
+  305,
+  307,
+  312,
+  312,
+  319,
+  322,
+  324,
+  324,
+  328,
+  331,
+  333,
+  333,
+  338,
+  339,
+  358,
+  359,
+  363,
+  363,
+  462,
+  462,
+  464,
+  464,
+  466,
+  466,
+  468,
+  468,
+  470,
+  470,
+  472,
+  472,
+  474,
+  474,
+  476,
+  476,
+  593,
+  593,
+  609,
+  609,
+  708,
+  708,
+  711,
+  711,
+  713,
+  715,
+  717,
+  717,
+  720,
+  720,
+  728,
+  731,
+  733,
+  733,
+  735,
+  735,
+  768,
+  879,
+  913,
+  929,
+  931,
+  937,
+  945,
+  961,
+  963,
+  969,
+  1025,
+  1025,
+  1040,
+  1103,
+  1105,
+  1105,
+  8208,
+  8208,
+  8211,
+  8214,
+  8216,
+  8217,
+  8220,
+  8221,
+  8224,
+  8226,
+  8228,
+  8231,
+  8240,
+  8240,
+  8242,
+  8243,
+  8245,
+  8245,
+  8251,
+  8251,
+  8254,
+  8254,
+  8308,
+  8308,
+  8319,
+  8319,
+  8321,
+  8324,
+  8364,
+  8364,
+  8451,
+  8451,
+  8453,
+  8453,
+  8457,
+  8457,
+  8467,
+  8467,
+  8470,
+  8470,
+  8481,
+  8482,
+  8486,
+  8486,
+  8491,
+  8491,
+  8531,
+  8532,
+  8539,
+  8542,
+  8544,
+  8555,
+  8560,
+  8569,
+  8585,
+  8585,
+  8592,
+  8601,
+  8632,
+  8633,
+  8658,
+  8658,
+  8660,
+  8660,
+  8679,
+  8679,
+  8704,
+  8704,
+  8706,
+  8707,
+  8711,
+  8712,
+  8715,
+  8715,
+  8719,
+  8719,
+  8721,
+  8721,
+  8725,
+  8725,
+  8730,
+  8730,
+  8733,
+  8736,
+  8739,
+  8739,
+  8741,
+  8741,
+  8743,
+  8748,
+  8750,
+  8750,
+  8756,
+  8759,
+  8764,
+  8765,
+  8776,
+  8776,
+  8780,
+  8780,
+  8786,
+  8786,
+  8800,
+  8801,
+  8804,
+  8807,
+  8810,
+  8811,
+  8814,
+  8815,
+  8834,
+  8835,
+  8838,
+  8839,
+  8853,
+  8853,
+  8857,
+  8857,
+  8869,
+  8869,
+  8895,
+  8895,
+  8978,
+  8978,
+  9312,
+  9449,
+  9451,
+  9547,
+  9552,
+  9587,
+  9600,
+  9615,
+  9618,
+  9621,
+  9632,
+  9633,
+  9635,
+  9641,
+  9650,
+  9651,
+  9654,
+  9655,
+  9660,
+  9661,
+  9664,
+  9665,
+  9670,
+  9672,
+  9675,
+  9675,
+  9678,
+  9681,
+  9698,
+  9701,
+  9711,
+  9711,
+  9733,
+  9734,
+  9737,
+  9737,
+  9742,
+  9743,
+  9756,
+  9756,
+  9758,
+  9758,
+  9792,
+  9792,
+  9794,
+  9794,
+  9824,
+  9825,
+  9827,
+  9829,
+  9831,
+  9834,
+  9836,
+  9837,
+  9839,
+  9839,
+  9886,
+  9887,
+  9919,
+  9919,
+  9926,
+  9933,
+  9935,
+  9939,
+  9941,
+  9953,
+  9955,
+  9955,
+  9960,
+  9961,
+  9963,
+  9969,
+  9972,
+  9972,
+  9974,
+  9977,
+  9979,
+  9980,
+  9982,
+  9983,
+  10045,
+  10045,
+  10102,
+  10111,
+  11094,
+  11097,
+  12872,
+  12879,
+  57344,
+  63743,
+  65024,
+  65039,
+  65533,
+  65533,
+  127232,
+  127242,
+  127248,
+  127277,
+  127280,
+  127337,
+  127344,
+  127373,
+  127375,
+  127376,
+  127387,
+  127404,
+  917760,
+  917999,
+  983040,
+  1048573,
+  1048576,
+  1114109
+], fullwidthMinimalCodePoint = 12288, fullwidthMaximumCodePoint = 65510, fullwidthRanges = [
+  12288,
+  12288,
+  65281,
+  65376,
+  65504,
+  65510
+], halfwidthMinimalCodePoint = 8361, halfwidthMaximumCodePoint = 65518, halfwidthRanges = [
+  8361,
+  8361,
+  65377,
+  65470,
+  65474,
+  65479,
+  65482,
+  65487,
+  65490,
+  65495,
+  65498,
+  65500,
+  65512,
+  65518
+], narrowMinimalCodePoint = 32, narrowMaximumCodePoint = 10630, narrowRanges = [
+  32,
+  126,
+  162,
+  163,
+  165,
+  166,
+  172,
+  172,
+  175,
+  175,
+  10214,
+  10221,
+  10629,
+  10630
+], wideMinimalCodePoint = 4352, wideMaximumCodePoint = 262141, wideRanges = [
+  4352,
+  4447,
+  8986,
+  8987,
+  9001,
+  9002,
+  9193,
+  9196,
+  9200,
+  9200,
+  9203,
+  9203,
+  9725,
+  9726,
+  9748,
+  9749,
+  9776,
+  9783,
+  9800,
+  9811,
+  9855,
+  9855,
+  9866,
+  9871,
+  9875,
+  9875,
+  9889,
+  9889,
+  9898,
+  9899,
+  9917,
+  9918,
+  9924,
+  9925,
+  9934,
+  9934,
+  9940,
+  9940,
+  9962,
+  9962,
+  9970,
+  9971,
+  9973,
+  9973,
+  9978,
+  9978,
+  9981,
+  9981,
+  9989,
+  9989,
+  9994,
+  9995,
+  10024,
+  10024,
+  10060,
+  10060,
+  10062,
+  10062,
+  10067,
+  10069,
+  10071,
+  10071,
+  10133,
+  10135,
+  10160,
+  10160,
+  10175,
+  10175,
+  11035,
+  11036,
+  11088,
+  11088,
+  11093,
+  11093,
+  11904,
+  11929,
+  11931,
+  12019,
+  12032,
+  12245,
+  12272,
+  12287,
+  12289,
+  12350,
+  12353,
+  12438,
+  12441,
+  12543,
+  12549,
+  12591,
+  12593,
+  12686,
+  12688,
+  12773,
+  12783,
+  12830,
+  12832,
+  12871,
+  12880,
+  42124,
+  42128,
+  42182,
+  43360,
+  43388,
+  44032,
+  55203,
+  63744,
+  64255,
+  65040,
+  65049,
+  65072,
+  65106,
+  65108,
+  65126,
+  65128,
+  65131,
+  94176,
+  94180,
+  94192,
+  94198,
+  94208,
+  101589,
+  101631,
+  101662,
+  101760,
+  101874,
+  110576,
+  110579,
+  110581,
+  110587,
+  110589,
+  110590,
+  110592,
+  110882,
+  110898,
+  110898,
+  110928,
+  110930,
+  110933,
+  110933,
+  110948,
+  110951,
+  110960,
+  111355,
+  119552,
+  119638,
+  119648,
+  119670,
+  126980,
+  126980,
+  127183,
+  127183,
+  127374,
+  127374,
+  127377,
+  127386,
+  127488,
+  127490,
+  127504,
+  127547,
+  127552,
+  127560,
+  127568,
+  127569,
+  127584,
+  127589,
+  127744,
+  127776,
+  127789,
+  127797,
+  127799,
+  127868,
+  127870,
+  127891,
+  127904,
+  127946,
+  127951,
+  127955,
+  127968,
+  127984,
+  127988,
+  127988,
+  127992,
+  128062,
+  128064,
+  128064,
+  128066,
+  128252,
+  128255,
+  128317,
+  128331,
+  128334,
+  128336,
+  128359,
+  128378,
+  128378,
+  128405,
+  128406,
+  128420,
+  128420,
+  128507,
+  128591,
+  128640,
+  128709,
+  128716,
+  128716,
+  128720,
+  128722,
+  128725,
+  128728,
+  128732,
+  128735,
+  128747,
+  128748,
+  128756,
+  128764,
+  128992,
+  129003,
+  129008,
+  129008,
+  129292,
+  129338,
+  129340,
+  129349,
+  129351,
+  129535,
+  129648,
+  129660,
+  129664,
+  129674,
+  129678,
+  129734,
+  129736,
+  129736,
+  129741,
+  129756,
+  129759,
+  129770,
+  129775,
+  129784,
+  131072,
+  196605,
+  196608,
+  262141
+], isInRange = (ranges, codePoint) => {
+  let low = 0, high = Math.floor(ranges.length / 2) - 1;
+  for (; low <= high; ) {
+    let mid = Math.floor((low + high) / 2), i = mid * 2;
+    if (codePoint < ranges[i])
+      high = mid - 1;
+    else if (codePoint > ranges[i + 1])
+      low = mid + 1;
+    else
+      return !0;
+  }
+  return !1;
+}, commonCjkCodePoint = 19968, [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0], fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    let start = ranges[index], end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end)
+      return [start, end];
+    end - start > fastPathEnd - fastPathStart && (fastPathStart = start, fastPathEnd = end);
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var isAmbiguous = (codePoint) => codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint ? !1 : isInRange(ambiguousRanges, codePoint), isFullWidth = (codePoint) => codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint ? !1 : isInRange(fullwidthRanges, codePoint), isHalfWidth = (codePoint) => codePoint < halfwidthMinimalCodePoint || codePoint > halfwidthMaximumCodePoint ? !1 : isInRange(halfwidthRanges, codePoint), isNarrow = (codePoint) => codePoint < narrowMinimalCodePoint || codePoint > narrowMaximumCodePoint ? !1 : isInRange(narrowRanges, codePoint), isWide = (codePoint) => codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd ? !0 : codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint ? !1 : isInRange(wideRanges, codePoint);
+function getCategory(codePoint) {
+  return isAmbiguous(codePoint) ? "ambiguous" : isFullWidth(codePoint) ? "fullwidth" : isHalfWidth(codePoint) ? "halfwidth" : isNarrow(codePoint) ? "narrow" : isWide(codePoint) ? "wide" : "neutral";
+}
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint))
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+}
+function eastAsianWidthType(codePoint) {
+  return validate(codePoint), getCategory(codePoint);
+}
+function isEmoji(uc) {
+  return /^\p{Emoji_Presentation}/u.test(String.fromCodePoint(uc));
+}
+function isCjkBase(uc) {
+  if (uc < 4352)
+    return !1;
+  switch (eastAsianWidthType(uc)) {
+    case "fullwidth":
+    case "halfwidth":
+      return !0;
+    case "wide":
+      return !isEmoji(uc);
+    case "narrow":
+      return !1;
+    case "ambiguous":
+      return null;
+    case "neutral":
+      return /^\p{sc=Hangul}/u.test(String.fromCodePoint(uc));
+  }
+}
+function is2PreviousCjk(uc, prev) {
+  return isCjkBase(uc) ?? (prev === 65025 && isQuotationMark(uc));
+  function isQuotationMark(uc$1) {
+    return uc$1 === 8216 || uc$1 === 8217 || uc$1 === 8220 || uc$1 === 8221;
+  }
+}
+function isPreviousCjk(uc) {
+  return isCjkBase(uc) ?? (917760 <= uc && uc <= 917999);
+}
+function isNextCjk(uc) {
+  return isCjkBase(uc) ?? !1;
+}
+function nonEmojiGeneralUseVS(uc) {
+  return uc >= 65024 && uc <= 65038;
+}
+function markdownItCjkFriendlyPlugin(md) {
+  let PreviousState = md.inline.State;
+  class CjkFriendlyState extends PreviousState {
+    scanDelims(start, canSplitWord) {
+      let max = this.posMax, marker = this.src.charCodeAt(start), [lastChar2, lastCharPos] = getLastCharCode(this.src, start), lastMainChar = lastChar2, twoPrevChar = null;
+      nonEmojiGeneralUseVS(lastChar2) && (twoPrevChar = getLastCharCode(this.src, lastCharPos)[0], /^\p{Zs}/u.test(String.fromCodePoint(twoPrevChar)) || (lastMainChar = twoPrevChar));
+      let pos = start;
+      for (; pos < max && this.src.charCodeAt(pos) === marker; )
+        pos++;
+      let count = pos - start, nextChar = pos < max ? this.src.codePointAt(pos) : 32, isLastWhiteSpace = md.utils.isWhiteSpace(lastMainChar), isNextWhiteSpace = md.utils.isWhiteSpace(nextChar);
+      if (isLastWhiteSpace || isNextWhiteSpace)
+        return {
+          can_open: !isNextWhiteSpace,
+          can_close: !isLastWhiteSpace,
+          length: count
+        };
+      let isLastPunctChar = md.utils.isMdAsciiPunct(lastMainChar) || md.utils.isPunctChar(String.fromCodePoint(lastMainChar)), isNextPunctChar = md.utils.isMdAsciiPunct(nextChar) || md.utils.isPunctChar(String.fromCodePoint(nextChar)), left_flanking = isLastPunctChar, right_flanking = isNextPunctChar;
+      if (canSplitWord) {
+        let isEitherCJKChar = isNextCjk(nextChar) || (twoPrevChar !== null ? is2PreviousCjk(twoPrevChar, lastChar2) : isPreviousCjk(lastChar2));
+        left_flanking || (left_flanking = isEitherCJKChar || !isNextPunctChar), right_flanking || (right_flanking = isEitherCJKChar || !isLastPunctChar);
+      }
+      return {
+        can_open: left_flanking,
+        can_close: right_flanking,
+        length: count
+      };
+      function getLastCharCode(str, pos$1) {
+        if (pos$1 <= 0)
+          return [32, -1];
+        let charCode = str.charCodeAt(pos$1 - 1);
+        if ((charCode & 64512) !== 56320)
+          return [charCode, pos$1 - 1];
+        let codePoint = str.codePointAt(pos$1 - 2);
+        return codePoint > 65535 ? [codePoint, pos$1 - 2] : [charCode, pos$1 - 1];
+      }
+    }
+  }
+  md.inline.State = CjkFriendlyState;
+}
+var decodeMap = /* @__PURE__ */ new Map([
   [0, 65533],
   [128, 8364],
   [130, 8218],
@@ -15862,7 +16624,7 @@ var htmlDecoder = /* @__PURE__ */ getDecoder(htmlDecodeTree);
 function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
   return htmlDecoder(htmlString, mode);
 }
-var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM2(require_markdown_it_task_checkbox(), 1), decodeCache = {};
+var decodeCache = {};
 function getDecodeCache(exclude) {
   let cache = decodeCache[exclude];
   if (cache)
@@ -18331,6 +19093,13 @@ var ParserInline = class {
   constructor() {
     __publicField(this, "ruler");
     __publicField(this, "ruler2");
+    /**
+    * State class used for inline parsing, mirroring `ParserInline.prototype.State` in
+    * markdown-it. Plugins subclass it (`scanDelims`, `push`, `pushPending`, ...) and assign
+    * the subclass back to `md.inline.State`; the parser then constructs it with
+    * `new this.State(...)`.
+    */
+    __publicField(this, "State", StateInline);
     __publicField(this, "cachedRulesVersion", -1);
     __publicField(this, "cachedRules", []);
     __publicField(this, "cachedRules2Version", -1);
@@ -18437,13 +19206,20 @@ var ParserInline = class {
   isDefaultRuleset() {
     return this.ruler.version === this.defaultRulerVersion && this.ruler2.version === this.defaultRuler2Version;
   }
+  /**
+  * Whether inline parsing still uses the stock `StateInline`. The plain-text fast paths
+  * construct no state at all, so they must stand down once a plugin replaces `State`.
+  */
+  usesDefaultState() {
+    return this.State === StateInline;
+  }
   parseSource(src, md, env, outTokens) {
-    if (typeof src == "string" && src.length > 0 && this.isDefaultRuleset() && isPlainInlineText$1(src)) {
+    if (typeof src == "string" && src.length > 0 && this.isDefaultRuleset() && this.usesDefaultState() && isPlainInlineText$1(src)) {
       let token = new Token("text", "", 0);
       token.content = src, outTokens.push(token);
       return;
     }
-    let state = new StateInline(src, md, env, outTokens);
+    let state = new this.State(src, md, env, outTokens);
     this.tokenize(state);
     let rules2 = this.getRules2(), len = rules2.length;
     if (!(state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules")))) {
@@ -18470,7 +19246,7 @@ var ParserInline = class {
   }
 };
 function inline(state) {
-  let tokens = state.tokens, canUsePlainTextFastPath = !!state.md?.inline?.isDefaultRuleset?.();
+  let tokens = state.tokens, inlineParser = state.md?.inline, canUsePlainTextFastPath = !!inlineParser?.isDefaultRuleset?.() && inlineParser?.usesDefaultState?.() !== !1;
   for (let i = 0, l = tokens.length; i < l; i++) {
     let tok = tokens[i];
     if (tok.type === "inline" && state.md) {
@@ -18484,6 +19260,30 @@ function inline(state) {
   }
 }
 var CJK_CHAR_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u, ASCII_DOMAIN_START_RE = /[0-9a-z]/i;
+function hasLinkifySeed(text$1) {
+  return text$1.includes(".") || text$1.includes("@") || text$1.includes(":");
+}
+var linkifySeedSafety = /* @__PURE__ */ new WeakMap();
+function isLinkifySeedSafe(linkify$2) {
+  let schemaSearch = linkify$2.re?.get_schema_search?.();
+  if (!schemaSearch)
+    return !1;
+  let cached = linkifySeedSafety.get(linkify$2);
+  if (cached && cached.schemaSearch === schemaSearch)
+    return cached.safe;
+  let schemas = linkify$2.__schemas__, safe = !0;
+  if (schemas) {
+    for (let name in schemas)
+      if (name.charCodeAt(name.length - 1) !== 58) {
+        safe = !1;
+        break;
+      }
+  }
+  return linkifySeedSafety.set(linkify$2, {
+    schemaSearch,
+    safe
+  }), safe;
+}
 function isLinkOpen(str) {
   return /^<a[>\s]/i.test(str);
 }
@@ -18509,55 +19309,57 @@ function trimCjkPrefixFromFuzzyLink(linkify$2, link$1) {
 }
 function linkify(state) {
   let blockTokens = state.tokens;
-  if (state.md?.options?.linkify)
-    for (let j = 0; j < blockTokens.length; j++) {
-      let blockToken$1 = blockTokens[j];
-      if (blockToken$1.type !== "inline" || !state.md.linkify.test(blockToken$1.content))
+  if (!state.md?.options?.linkify)
+    return;
+  let seedSafe = isLinkifySeedSafe(state.md.linkify), mayMatch = (text$1) => seedSafe ? hasLinkifySeed(text$1) : !0;
+  for (let j = 0; j < blockTokens.length; j++) {
+    let blockToken$1 = blockTokens[j];
+    if (blockToken$1.type !== "inline" || !mayMatch(blockToken$1.content))
+      continue;
+    let tokens = blockToken$1.children;
+    tokens || (tokens = [], blockToken$1.children = tokens);
+    let htmlLinkLevel = 0;
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      let currentToken = tokens[i];
+      if (currentToken.type === "link_close") {
+        for (i--; i >= 0 && tokens[i].level !== currentToken.level && tokens[i].type !== "link_open"; )
+          i--;
         continue;
-      let tokens = blockToken$1.children;
-      tokens || (tokens = [], blockToken$1.children = tokens);
-      let htmlLinkLevel = 0;
-      for (let i = tokens.length - 1; i >= 0; i--) {
-        let currentToken = tokens[i];
-        if (currentToken.type === "link_close") {
-          for (i--; i >= 0 && tokens[i].level !== currentToken.level && tokens[i].type !== "link_open"; )
-            i--;
+      }
+      if (currentToken.type === "html_inline" && (isLinkOpen(currentToken.content) && htmlLinkLevel > 0 && htmlLinkLevel--, isLinkClose(currentToken.content) && htmlLinkLevel++), htmlLinkLevel > 0 || currentToken.type !== "text" || !mayMatch(currentToken.content))
+        continue;
+      let text$1 = currentToken.content, links = (state.md.linkify.match(text$1) || []).map((link$1) => trimCjkPrefixFromFuzzyLink(state.md.linkify, link$1));
+      if (links.length === 0)
+        continue;
+      let nodes = [], level = currentToken.level, lastPos = 0;
+      links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special" && (links = links.slice(1));
+      for (let ln = 0; ln < links.length; ln++) {
+        let link$1 = links[ln], fullUrl = state.md.normalizeLink(link$1.url);
+        if (!state.md.validateLink(fullUrl))
           continue;
+        let urlText = link$1.text;
+        link$1.schema ? link$1.schema === "mailto:" && !/^mailto:/i.test(urlText) ? urlText = state.md.normalizeLinkText(`mailto:${urlText}`).replace(/^mailto:/, "") : urlText = state.md.normalizeLinkText(urlText) : urlText = state.md.normalizeLinkText(`http://${urlText}`).replace(/^http:\/\//, "");
+        let pos = link$1.index;
+        if (pos > lastPos) {
+          let textToken$1 = new Token("text", "", 0);
+          textToken$1.content = text$1.slice(lastPos, pos), textToken$1.level = level, nodes.push(textToken$1);
         }
-        if (currentToken.type === "html_inline" && (isLinkOpen(currentToken.content) && htmlLinkLevel > 0 && htmlLinkLevel--, isLinkClose(currentToken.content) && htmlLinkLevel++), htmlLinkLevel > 0 || currentToken.type !== "text" || !state.md.linkify.test(currentToken.content))
-          continue;
-        let text$1 = currentToken.content, links = (state.md.linkify.match(text$1) || []).map((link$1) => trimCjkPrefixFromFuzzyLink(state.md.linkify, link$1));
-        if (links.length === 0)
-          continue;
-        let nodes = [], level = currentToken.level, lastPos = 0;
-        links.length > 0 && links[0].index === 0 && i > 0 && tokens[i - 1].type === "text_special" && (links = links.slice(1));
-        for (let ln = 0; ln < links.length; ln++) {
-          let link$1 = links[ln], fullUrl = state.md.normalizeLink(link$1.url);
-          if (!state.md.validateLink(fullUrl))
-            continue;
-          let urlText = link$1.text;
-          link$1.schema ? link$1.schema === "mailto:" && !/^mailto:/i.test(urlText) ? urlText = state.md.normalizeLinkText(`mailto:${urlText}`).replace(/^mailto:/, "") : urlText = state.md.normalizeLinkText(urlText) : urlText = state.md.normalizeLinkText(`http://${urlText}`).replace(/^http:\/\//, "");
-          let pos = link$1.index;
-          if (pos > lastPos) {
-            let textToken$1 = new Token("text", "", 0);
-            textToken$1.content = text$1.slice(lastPos, pos), textToken$1.level = level, nodes.push(textToken$1);
-          }
-          let tokenOpen = new Token("link_open", "a", 1);
-          tokenOpen.attrs = [["href", fullUrl]], tokenOpen.level = level++, tokenOpen.markup = "linkify", tokenOpen.info = "auto", nodes.push(tokenOpen);
-          let tokenText = new Token("text", "", 0);
-          tokenText.content = urlText, tokenText.level = level, nodes.push(tokenText);
-          let tokenClose = new Token("link_close", "a", -1);
-          tokenClose.level = --level, tokenClose.markup = "linkify", tokenClose.info = "auto", nodes.push(tokenClose), lastPos = link$1.lastIndex;
-        }
-        if (lastPos !== 0) {
-          if (lastPos < text$1.length) {
-            let textToken$1 = new Token("text", "", 0);
-            textToken$1.content = text$1.slice(lastPos), textToken$1.level = level, nodes.push(textToken$1);
-          }
-          tokens.splice(i, 1, ...nodes);
+        let tokenOpen = new Token("link_open", "a", 1);
+        tokenOpen.attrs = [["href", fullUrl]], tokenOpen.level = level++, tokenOpen.markup = "linkify", tokenOpen.info = "auto", nodes.push(tokenOpen);
+        let tokenText = new Token("text", "", 0);
+        tokenText.content = urlText, tokenText.level = level, nodes.push(tokenText);
+        let tokenClose = new Token("link_close", "a", -1);
+        tokenClose.level = --level, tokenClose.markup = "linkify", tokenClose.info = "auto", nodes.push(tokenClose), lastPos = link$1.lastIndex;
+      }
+      if (lastPos !== 0) {
+        if (lastPos < text$1.length) {
+          let textToken$1 = new Token("text", "", 0);
+          textToken$1.content = text$1.slice(lastPos), textToken$1.level = level, nodes.push(textToken$1);
         }
+        tokens.splice(i, 1, ...nodes);
       }
     }
+  }
 }
 var NEWLINES_RE = /\r\n?|\n/g, NULL_RE = /\0/g;
 function normalize(state) {
@@ -18733,7 +19535,7 @@ function process_inlines(tokens, state) {
               nextChar = tokens[j].content.charCodeAt(0);
               break;
             }
-        let isLastPunctChar = isMdAsciiPunct(lastChar2) || isPunctChar(String.fromCharCode(lastChar2)), isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar)), isLastWhiteSpace = isWhiteSpace(lastChar2), isNextWhiteSpace = isWhiteSpace(nextChar);
+        let isLastPunctChar = isPunctCode(lastChar2), isNextPunctChar = isPunctCode(nextChar), isLastWhiteSpace = isWhiteSpace(lastChar2), isNextWhiteSpace = isWhiteSpace(nextChar);
         if (isNextWhiteSpace ? canOpen = !1 : isNextPunctChar && (isLastWhiteSpace || isLastPunctChar || (canOpen = !1)), isLastWhiteSpace ? canClose = !1 : isLastPunctChar && (isNextWhiteSpace || isNextPunctChar || (canClose = !1)), nextChar === 34 && t[0] === '"' && lastChar2 >= 48 && lastChar2 <= 57 && (canClose = canOpen = !1), canOpen && canClose && (canOpen = isLastPunctChar, canClose = isNextPunctChar), !canOpen && !canClose) {
           isSingle && (token.content = replaceAt(token.content, t.index, APOSTROPHE));
           continue;
@@ -18788,28 +19590,30 @@ var BAD_PROTO_RE = /^(?:vbscript|javascript|file|data):/, GOOD_DATA_RE = /^data:
   "http:",
   "https:",
   "mailto:"
-];
+], NON_ASCII_RE = /[^\0-\x7F]/, PUNYCODE_LABEL_RE = /xn--/, ENCODE_IDENTITY_RE = /%(?![0-9a-f]{2})|[^\w;/?:@&=+$,\-.!~*'()#%]/i, DECODE_SCAN_RE = /%[0-9a-f]{2}/i;
 function validateLink(url) {
   let str = url.trim().toLowerCase();
   return BAD_PROTO_RE.test(str) ? GOOD_DATA_RE.test(str) : !0;
 }
 function normalizeLink(url) {
   let parsed = parse_default(url, !0);
-  if (parsed.hostname && (!parsed.protocol || RECODE_HOSTNAME_FOR.includes(parsed.protocol)))
+  if (parsed.hostname && (!parsed.protocol || RECODE_HOSTNAME_FOR.includes(parsed.protocol)) && NON_ASCII_RE.test(parsed.hostname))
     try {
       parsed.hostname = import_punycode.default.toASCII(parsed.hostname);
     } catch {
     }
-  return encode_default(format(parsed));
+  let formatted = format(parsed);
+  return ENCODE_IDENTITY_RE.test(formatted) ? encode_default(formatted) : formatted;
 }
 function normalizeLinkText(url) {
   let parsed = parse_default(url, !0);
-  if (parsed.hostname && (!parsed.protocol || RECODE_HOSTNAME_FOR.includes(parsed.protocol)))
+  if (parsed.hostname && (!parsed.protocol || RECODE_HOSTNAME_FOR.includes(parsed.protocol)) && (NON_ASCII_RE.test(parsed.hostname) || PUNYCODE_LABEL_RE.test(parsed.hostname)))
     try {
       parsed.hostname = import_punycode.default.toUnicode(parsed.hostname);
     } catch {
     }
-  return decode_default(format(parsed), `${decode_default.defaultChars}%`);
+  let formatted = format(parsed);
+  return DECODE_SCAN_RE.test(formatted) ? decode_default(formatted, `${decode_default.defaultChars}%`) : formatted;
 }
 function isSpace$7(code$1) {
   switch (code$1) {
@@ -22208,6 +23012,37 @@ var Renderer = class {
     return output;
   }
 }, renderer_default = Renderer, EMPTY_TOKENS = [], GLOBAL_STATE_APPEND_SCAN_WINDOW = 4096;
+function copyOptions(options) {
+  let copy = { ...options };
+  return Array.isArray(options.quotes) && (copy.quotes = [...options.quotes]), options.experimental && (copy.experimental = { ...options.experimental }), copy;
+}
+function optionsEqual(left, right) {
+  let keys = Object.keys(right);
+  return Object.keys(left).length !== keys.length ? !1 : keys.every((key) => {
+    if (!Object.hasOwn(left, key))
+      return !1;
+    let leftValue = left[key], rightValue = right[key];
+    if (Array.isArray(leftValue) && Array.isArray(rightValue))
+      return leftValue.length === rightValue.length && leftValue.every((value, index) => Object.is(value, rightValue[index]));
+    if (key === "experimental" && leftValue && rightValue) {
+      let leftExperimental = leftValue, rightExperimental = rightValue, experimentalKeys = Object.keys(rightExperimental);
+      return Object.keys(leftExperimental).length === experimentalKeys.length && experimentalKeys.every((option) => Object.hasOwn(leftExperimental, option) && Object.is(leftExperimental[option], rightExperimental[option]));
+    }
+    return Object.is(leftValue, rightValue);
+  });
+}
+function copyParserConfig(md) {
+  return {
+    options: copyOptions(md.options),
+    coreVersion: md.core.ruler.version,
+    blockVersion: md.block.ruler.version,
+    inlineVersion: md.inline.ruler.version,
+    inline2Version: md.inline.ruler2.version
+  };
+}
+function parserConfigEqual(config$1, md) {
+  return optionsEqual(config$1.options, md.options) && config$1.coreVersion === md.core.ruler.version && config$1.blockVersion === md.block.ruler.version && config$1.inlineVersion === md.inline.ruler.version && config$1.inline2Version === md.inline.ruler2.version;
+}
 function appendedHasBlockConstructs(s) {
   let len = s.length, lineStart = 0;
   for (; lineStart <= len; ) {
@@ -22350,9 +23185,9 @@ var StreamParser = class {
     __publicField(this, "core");
     __publicField(this, "anchorBlock", new ParserBlock());
     __publicField(this, "cache", null);
+    __publicField(this, "snapshots", /* @__PURE__ */ new WeakSet());
     __publicField(this, "stats", makeEmptyStats());
     __publicField(this, "normalizeLineEndings", !0);
-    __publicField(this, "coreRulerVersion", -1);
     __publicField(this, "tokenMapsTrusted", !0);
     __publicField(this, "allowUntrustedTailReuse", !1);
     __publicField(this, "MIN_SIZE_FOR_OPTIMIZATION", 1e3);
@@ -22375,19 +23210,46 @@ var StreamParser = class {
     let { resets } = this.stats;
     this.stats = makeEmptyStats(), this.stats.resets = resets;
   }
-  parse(src, env, md) {
-    let priorEnv = this.cache?.env;
-    this.coreRulerVersion >= 0 && this.coreRulerVersion !== md.core.ruler.version && (this.cache = null), this.coreRulerVersion = md.core.ruler.version;
-    let coreRules = md.core.ruler.getNamedRules(""), lineNormalizerIndex = coreRules.findIndex((rule) => rule.fn === normalize), blockRuleIndex = coreRules.findIndex((rule) => rule.fn === block), namedNormalizeRule = coreRules.find((rule) => rule.name === "normalize");
+  snapshot() {
+    let cache = this.cache;
+    if (!cache)
+      return null;
+    let state = cache.snapshotState ?? { cache };
+    cache.snapshotState = state;
+    let snapshot = {
+      state,
+      get sourceLength() {
+        return this.state.cache.src.length;
+      },
+      get tokenCount() {
+        return this.state.cache.tokens.length;
+      }
+    };
+    return this.snapshots.add(snapshot), snapshot;
+  }
+  restore(snapshot, md) {
+    if (!this.snapshots.has(snapshot))
+      throw new TypeError("Invalid stream snapshot");
+    let cache = snapshot.state.cache;
+    return this.cache = cache, parserConfigEqual(cache.config, md) ? cache.tokens : this.parse(cache.src, cache.env, md);
+  }
+  append(segment, env, md) {
+    let cached = this.cache;
+    if (!cached)
+      throw new Error("Stream append requires cached history; call stream.parse(fullSource) first");
+    return this.ensureBoundaryState(cached), this.parse(cached.src + segment, env, md, segment);
+  }
+  parse(src, env, md, knownAppend) {
+    let previousCache = this.cache, priorEnv = previousCache?.env, coreRules = md.core.ruler.getNamedRules(""), lineNormalizerIndex = coreRules.findIndex((rule) => rule.fn === normalize), blockRuleIndex = coreRules.findIndex((rule) => rule.fn === block), namedNormalizeRule = coreRules.find((rule) => rule.name === "normalize");
     this.normalizeLineEndings = lineNormalizerIndex >= 0 && blockRuleIndex >= 0 && lineNormalizerIndex < blockRuleIndex;
-    let envProvided = env, previousCache = this.cache, customNormalize = namedNormalizeRule && namedNormalizeRule.fn !== normalize, nonstandardBuiltinNormalize = namedNormalizeRule && !this.normalizeLineEndings && src.includes("\r"), unknownPreBlockRule = blockRuleIndex < 0 || coreRules.slice(0, blockRuleIndex).some((rule) => rule.fn !== normalize);
+    let envProvided = env, configChanged = !!previousCache && !parserConfigEqual(previousCache.config, md), customNormalize = namedNormalizeRule && namedNormalizeRule.fn !== normalize, nonstandardBuiltinNormalize = namedNormalizeRule && !this.normalizeLineEndings && src.includes("\r"), unknownPreBlockRule = blockRuleIndex < 0 || coreRules.slice(0, blockRuleIndex).some((rule) => rule.fn !== normalize);
     this.tokenMapsTrusted = !(blockRuleIndex < 0 || coreRules.slice(blockRuleIndex + 1).some((rule) => rule.fn !== inline && rule.fn !== linkify && rule.fn !== replacements && rule.fn !== smartquotes && rule.fn !== text_join)), this.allowUntrustedTailReuse = this.tokenMapsTrusted || md.options?.streamTailLocalPostBlockRules === !0;
-    let cached = customNormalize || nonstandardBuiltinNormalize || unknownPreBlockRule ? null : previousCache;
+    let cached = configChanged || customNormalize || nonstandardBuiltinNormalize || unknownPreBlockRule ? null : previousCache;
     if (beginParseDiagnostics(envProvided ?? previousCache?.env ?? priorEnv), !cached || envProvided && envProvided !== cached.env) {
       let workingEnv = envProvided ?? previousCache?.env ?? priorEnv ?? {}, explicitChunkFallbackSetting$1 = !!md.__explicitStreamChunkFallbackSetting, canImplicitLargeInput$1 = typeof md.__canUseImplicitLargeInputStrategy == "function" ? md.__canUseImplicitLargeInputStrategy() : !0, wantsChunking$1 = !!md.options?.streamChunkedFallback, allowImplicitChunk$1 = !explicitChunkFallbackSetting$1 && canImplicitLargeInput$1, chunkedEnabled$1 = wantsChunking$1 || allowImplicitChunk$1, chunkAdaptive$1 = md.options?.streamChunkAdaptive !== !1, targetChunks$1 = md.options?.streamChunkTargetChunks ?? 8, chunkSizeCharsCfg$1 = md.options?.streamChunkSizeChars, chunkSizeLinesCfg$1 = md.options?.streamChunkSizeLines, chunkMaxChunksCfg$1 = md.options?.streamChunkMaxChunks, explicitChunkConfig$1 = !!md.__explicitStreamChunkConfig, auto$1 = md.options?.autoTuneChunks !== !1, chunkFenceAware$1 = md.options?.streamChunkFenceAware ?? !0, largeCachePolicy = md.options?.streamLargeCachePolicy ?? "retain", skipCacheChars = md.options?.streamSkipCacheAboveChars ?? this.DEFAULT_SKIP_CACHE_CHARS, skipCacheLines = md.options?.streamSkipCacheAboveLines ?? this.DEFAULT_SKIP_CACHE_LINES, srcLineCount, shouldSkipLargeCache = !1;
-      if (largeCachePolicy === "skip" && (shouldSkipLargeCache = src.length >= skipCacheChars, !shouldSkipLargeCache && skipCacheLines !== void 0 && (srcLineCount = countLines(src), shouldSkipLargeCache = srcLineCount >= skipCacheLines)), shouldSkipLargeCache) {
+      if (largeCachePolicy === "skip" && (shouldSkipLargeCache = src.length >= skipCacheChars, !shouldSkipLargeCache && skipCacheLines !== void 0 && (srcLineCount = countLines(src), shouldSkipLargeCache = srcLineCount >= skipCacheLines)), shouldSkipLargeCache && knownAppend === void 0 && !previousCache?.snapshotState) {
         let parsed$2 = this.parseFullDocument(src, workingEnv, md, srcLineCount, !1);
-        return this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(workingEnv, {
+        return this.cache = null, this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(workingEnv, {
           area: "stream",
           path: "stream-full",
           reason: "skip-cache-large-one-shot",
@@ -22403,26 +23265,28 @@ var StreamParser = class {
             maxChunkLines: useLines,
             fenceAware: recommendation?.fenceAware ?? chunkFenceAware$1,
             maxChunks: useMaxChunks
-          });
-          return this.cache = {
+          }), globalStateReason = getParseDiagnostics(workingEnv)?.chunk?.globalStateDetected ?? null, cache$2 = this.setCache({
             src,
             tokens,
             env: workingEnv,
             lineCount: srcLineCount,
             lastSegment: void 0,
-            globalStateReason: detectGlobalMarkdownState(src)
-          }, this.updateCacheLineCount(this.cache, srcLineCount), this.recordChunkedParseResult(workingEnv, wantsChunking$1 ? "explicit-initial-large-doc" : "default-initial-large-doc"), tokens;
+            globalStateReason
+          }, md);
+          return this.updateCacheLineCount(cache$2, srcLineCount), this.recordChunkedParseResult(workingEnv, wantsChunking$1 ? "explicit-initial-large-doc" : "default-initial-large-doc"), tokens;
         }
       }
       let parsed$1 = this.parseFullDocument(src, workingEnv, md, srcLineCount);
-      return srcLineCount = parsed$1.lineCount, this.cache = {
+      srcLineCount = parsed$1.lineCount;
+      let cache$1 = this.setCache({
         src,
         tokens: parsed$1.tokens,
         env: workingEnv,
         lineCount: srcLineCount,
         lastSegment: void 0,
-        globalStateReason: detectGlobalMarkdownState(src)
-      }, this.updateCacheLineCount(this.cache, srcLineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(workingEnv, {
+        globalStateReason: parsed$1.globalStateReason
+      }, md);
+      return this.updateCacheLineCount(cache$1, srcLineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(workingEnv, {
         area: "stream",
         path: "stream-full",
         reason: "initial-parse",
@@ -22435,21 +23299,21 @@ var StreamParser = class {
         path: "stream-cache",
         reason: "same-source"
       }), cached.tokens;
-    let appendDelta = src.startsWith(cached.src) ? src.slice(cached.src.length) : null, cachedGlobalStateReason = cached.globalStateReason;
+    let appendDelta = knownAppend !== void 0 ? knownAppend : src.startsWith(cached.src) ? src.slice(cached.src.length) : null, cachedGlobalStateReason = cached.globalStateReason;
     cachedGlobalStateReason === void 0 && (cachedGlobalStateReason = detectGlobalMarkdownState(cached.src), cached.globalStateReason = cachedGlobalStateReason);
     let currentGlobalStateReason = cachedGlobalStateReason ? null : appendDelta !== null ? this.detectGlobalStateForAppend(cached, appendDelta) : detectGlobalMarkdownState(src), nextGlobalStateReason = cachedGlobalStateReason || currentGlobalStateReason;
     if (nextGlobalStateReason) {
       let fallbackEnv$1 = envProvided ?? cached.env;
       resetKnownGlobalMarkdownState(fallbackEnv$1);
-      let fallbackGlobalStateReason = detectGlobalMarkdownState(src), parsed$1 = this.parseFullDocument(src, fallbackEnv$1, md), nextTokens$1 = parsed$1.tokens, lineCount = parsed$1.lineCount;
-      return this.cache = {
+      let parsed$1 = this.parseFullDocument(src, fallbackEnv$1, md), nextTokens$1 = parsed$1.tokens, lineCount = parsed$1.lineCount, cache$1 = this.setCache({
         src,
         tokens: nextTokens$1,
         env: fallbackEnv$1,
         lineCount,
         lastSegment: void 0,
-        globalStateReason: fallbackGlobalStateReason
-      }, this.updateCacheLineCount(this.cache, lineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv$1, {
+        globalStateReason: parsed$1.globalStateReason
+      }, md);
+      return this.updateCacheLineCount(cache$1, lineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv$1, {
         area: "stream",
         path: "stream-full",
         reason: `global-state:${nextGlobalStateReason}`,
@@ -22457,23 +23321,23 @@ var StreamParser = class {
       }), nextTokens$1;
     }
     let threshold = md.options?.streamOptimizationMinSize ?? this.MIN_SIZE_FOR_OPTIMIZATION;
-    if (cached.src.length < threshold && src.length < threshold * 1.5 && !src.startsWith(cached.src)) {
-      let fallbackEnv$1 = envProvided ?? cached.env, parsed$1 = this.parseFullDocument(src, fallbackEnv$1, md), nextTokens$1 = parsed$1.tokens, lineCount = parsed$1.lineCount;
-      return this.cache = {
+    if (cached.src.length < threshold && src.length < threshold * 1.5 && appendDelta === null) {
+      let fallbackEnv$1 = envProvided ?? cached.env, parsed$1 = this.parseFullDocument(src, fallbackEnv$1, md), nextTokens$1 = parsed$1.tokens, lineCount = parsed$1.lineCount, cache$1 = this.setCache({
         src,
         tokens: nextTokens$1,
         env: fallbackEnv$1,
         lineCount,
         lastSegment: void 0,
-        globalStateReason: detectGlobalMarkdownState(src)
-      }, this.updateCacheLineCount(this.cache, lineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv$1, {
+        globalStateReason: parsed$1.globalStateReason
+      }, md);
+      return this.updateCacheLineCount(cache$1, lineCount), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv$1, {
         area: "stream",
         path: "stream-full",
         reason: "small-non-append",
         unbounded: !!getParseDiagnostics(fallbackEnv$1)?.unbounded
       }), nextTokens$1;
     }
-    let cachedLastSegment = this.ensureLastSegment(cached), verifiedUntrustedTail = this.tokenMapsTrusted || this.allowUntrustedTailReuse && (cached.lastSegmentVerified === !0 || !!(cachedLastSegment && this.hasVerifiedSegmentAnchor(cached, cachedLastSegment, md))), appended = appendDelta !== null && this.shouldPreferTailReparseForAppend(cached, verifiedUntrustedTail) || !this.tokenMapsTrusted ? null : this.getAppendedSegment(cached, src, appendDelta);
+    let cachedLastSegment = this.ensureLastSegment(cached, knownAppend !== void 0), verifiedUntrustedTail = this.tokenMapsTrusted || this.allowUntrustedTailReuse && (cached.lastSegmentVerified === !0 || !!(cachedLastSegment && this.hasVerifiedSegmentAnchor(cached, cachedLastSegment, md))), appended = appendDelta !== null && this.shouldPreferTailReparseForAppend(cached, verifiedUntrustedTail) || !this.tokenMapsTrusted ? null : this.getAppendedSegment(cached, src, appendDelta);
     if (appended) {
       let cachedLineCount = cached.lineCount ?? countLines(cached.src), ctxLines = 3;
       appended.length > 5e3 ? ctxLines = 8 : appended.length > 1e3 ? ctxLines = 6 : appended.length > 200 && (ctxLines = 4), ctxLines = Math.min(ctxLines, cachedLineCount);
@@ -22548,11 +23412,16 @@ var StreamParser = class {
         }
         dup > 0 && (appendedTokenStart += dup), a.length > appendedTokenStart && this.appendTokens(cached.tokens, a, appendedTokenStart);
       }
-      if (this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.globalStateReason = null, cached.lineCount = cachedLineCount + (appendedLineCount ?? countAppendedLines()), cached.tokens.length > appendStart) {
+      if (cached.boundary ? this.updateBoundaryStateForAppend(cached, appended) : this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.globalStateReason = null, cached.lineCount = cachedLineCount + (appendedLineCount ?? countAppendedLines()), cached.tokens.length > appendStart) {
         let appendedLastSegment = this.getLastSegment(cached.tokens, src, appendStart, cached.tokens.length, src.length - appended.length, cachedLineCount);
-        appendedLastSegment ? cached.lastSegment = appendedLastSegment : cached.lastSegment = void 0;
+        if (appendedLastSegment) {
+          cached.lastSegment = appendedLastSegment;
+          let appendedOffset = src.length - appended.length;
+          cached.lastSegmentSource = appended.slice(Math.max(0, appendedLastSegment.srcOffset - appendedOffset));
+        } else
+          cached.lastSegment = void 0, cached.lastSegmentSource = void 0;
       } else
-        cached.lastSegment = void 0;
+        cached.lastSegment = void 0, cached.lastSegmentSource = void 0;
       return cached.lastSegmentVerified = void 0, this.stats.total += 1, this.stats.appendHits += 1, useUnboundedAppend && (this.stats.unboundedAppendHits = (this.stats.unboundedAppendHits || 0) + 1), this.stats.lastMode = "append", setStrategyDiagnostics(cached.env, {
         area: "stream",
         path: useUnboundedAppend ? "stream-unbounded-append" : "stream-append",
@@ -22560,7 +23429,7 @@ var StreamParser = class {
         unbounded: useUnboundedAppend
       }), cached.tokens;
     }
-    let fallbackEnv = envProvided ?? cached.env, tailReparsed = verifiedUntrustedTail ? this.tryTailSegmentReparse(src, cached, fallbackEnv, md, cachedLastSegment ?? void 0) : this.allowUntrustedTailReuse ? this.tryUntrustedParagraphTailReparse(src, cached, fallbackEnv, md) : null;
+    let fallbackEnv = envProvided ?? cached.env, tailReparsed = verifiedUntrustedTail ? this.tryTailSegmentReparse(src, cached, fallbackEnv, md, cachedLastSegment ?? void 0, appendDelta ?? void 0) : this.allowUntrustedTailReuse ? this.tryUntrustedParagraphTailReparse(src, cached, fallbackEnv, md) : null;
     if (tailReparsed)
       return this.stats.total += 1, this.stats.tailHits += 1, this.stats.lastMode = "tail", setStrategyDiagnostics(fallbackEnv, {
         area: "stream",
@@ -22577,26 +23446,28 @@ var StreamParser = class {
           maxChunkLines: useLines,
           fenceAware: recommendation?.fenceAware ?? chunkFenceAware,
           maxChunks: useMaxChunks
-        });
-        return this.cache = {
+        }), globalStateReason = getParseDiagnostics(fallbackEnv)?.chunk?.globalStateDetected ?? null, cache$1 = this.setCache({
           src,
           tokens,
           env: fallbackEnv,
           lineCount: srcLineCount2,
           lastSegment: void 0,
-          globalStateReason: detectGlobalMarkdownState(src)
-        }, this.updateCacheLineCount(this.cache, srcLineCount2), this.recordChunkedParseResult(fallbackEnv, wantsChunking ? "explicit-fallback-large-doc" : "default-fallback-large-doc"), tokens;
+          globalStateReason
+        }, md);
+        return this.updateCacheLineCount(cache$1, srcLineCount2), this.recordChunkedParseResult(fallbackEnv, wantsChunking ? "explicit-fallback-large-doc" : "default-fallback-large-doc"), tokens;
       }
     }
     let parsed = this.parseFullDocument(src, fallbackEnv, md, srcLineCount2), nextTokens = parsed.tokens;
-    return srcLineCount2 = parsed.lineCount, this.cache = {
+    srcLineCount2 = parsed.lineCount;
+    let cache = this.setCache({
       src,
       tokens: nextTokens,
       env: fallbackEnv,
       lineCount: srcLineCount2,
       lastSegment: void 0,
-      globalStateReason: detectGlobalMarkdownState(src)
-    }, this.updateCacheLineCount(this.cache, srcLineCount2), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv, {
+      globalStateReason: parsed.globalStateReason
+    }, md);
+    return this.updateCacheLineCount(cache, srcLineCount2), this.stats.total += 1, this.stats.fullParses += 1, this.stats.lastMode = "full", setStrategyDiagnostics(fallbackEnv, {
       area: "stream",
       path: "stream-full",
       reason: "fallback-full",
@@ -22622,11 +23493,10 @@ var StreamParser = class {
     });
   }
   parseFullDocument(src, env, md, knownLineCount, needLineCount = !0) {
-    let currentGlobalStateReason = detectGlobalMarkdownState(src);
     getKnownGlobalMarkdownState(env) && resetKnownGlobalMarkdownState(env);
     let autoUnboundedDecision = typeof md.__canUseImplicitLargeInputStrategy != "function" || md.__canUseImplicitLargeInputStrategy() ? getAutoUnboundedDecision(md, src.length, knownLineCount) : "no";
     if (autoUnboundedDecision === "yes") {
-      let tokens = parseStringUnbounded(md, src, env);
+      let tokens = parseStringUnbounded(md, src, env), globalStateReason = getParseDiagnostics(env)?.unbounded?.globalStateDetected ?? null;
       return setStrategyDiagnostics(env, {
         area: "stream",
         path: "stream-full",
@@ -22634,12 +23504,13 @@ var StreamParser = class {
         unbounded: !0
       }), {
         tokens,
-        lineCount: knownLineCount ?? (needLineCount ? countLines(src) : 0)
+        lineCount: knownLineCount ?? (needLineCount ? countLines(src) : 0),
+        globalStateReason
       };
     }
     let lineCount = knownLineCount;
     if (autoUnboundedDecision === "need-lines" && (lineCount = countLines(src), shouldAutoUseUnbounded(md, src.length, lineCount))) {
-      let tokens = parseStringUnbounded(md, src, env);
+      let tokens = parseStringUnbounded(md, src, env), globalStateReason = getParseDiagnostics(env)?.unbounded?.globalStateDetected ?? null;
       return setStrategyDiagnostics(env, {
         area: "stream",
         path: "stream-full",
@@ -22647,12 +23518,16 @@ var StreamParser = class {
         unbounded: !0
       }), {
         tokens,
-        lineCount
+        lineCount,
+        globalStateReason
       };
     }
-    return lineCount === void 0 && (lineCount = needLineCount ? countLines(src) : 0), {
+    lineCount === void 0 && (lineCount = needLineCount ? countLines(src) : 0);
+    let currentGlobalStateReason = detectGlobalMarkdownState(src);
+    return {
       tokens: runWithKnownGlobalMarkdownState(env, currentGlobalStateReason, () => this.core.parse(src, env, md).tokens),
-      lineCount
+      lineCount,
+      globalStateReason: currentGlobalStateReason
     };
   }
   shouldUseUnboundedAppend(src, _cached, appended) {
@@ -22660,8 +23535,8 @@ var StreamParser = class {
   }
   getAppendedSegment(cache, next, knownAppend) {
     let prev = cache.src;
-    if (knownAppend === null || knownAppend === void 0 && !next.startsWith(prev) || !prev.endsWith(`
-`))
+    if (knownAppend === null || knownAppend === void 0 && !next.startsWith(prev) || (knownAppend !== void 0 ? !this.ensureBoundaryState(cache).endsWithNewline : !prev.endsWith(`
+`)))
       return null;
     let segment = knownAppend ?? next.slice(prev.length);
     if (!segment)
@@ -22678,47 +23553,69 @@ var StreamParser = class {
     if (trimmedFirstLine.length === 0)
       return null;
     if (/^[-=]+$/.test(trimmedFirstLine)) {
-      let prevWithoutTrailingNewline = prev.slice(0, -1), lastBreak = prevWithoutTrailingNewline.lastIndexOf(`
+      let previousLineNonBlank;
+      if (knownAppend !== void 0)
+        previousLineNonBlank = this.ensureBoundaryState(cache).previousLineNonBlank;
+      else {
+        let prevWithoutTrailingNewline = prev.slice(0, -1), lastBreak = prevWithoutTrailingNewline.lastIndexOf(`
 `);
-      if (prevWithoutTrailingNewline.slice(lastBreak + 1).trim().length > 0)
+        previousLineNonBlank = prevWithoutTrailingNewline.slice(lastBreak + 1).trim().length > 0;
+      }
+      if (previousLineNonBlank)
+        return null;
+    }
+    if (knownAppend !== void 0) {
+      let lastSegment = this.ensureLastSegment(cache);
+      if (lastSegment && this.segmentHasFence(cache, lastSegment)) {
+        let scanStart = this.tokenMapsTrusted ? this.ensureSegmentSourceOffset(cache, lastSegment) : 0;
+        if (this.endsInsideOpenFence(prev, scanStart))
+          return null;
+      }
+    } else {
+      let scanStart = this.tokenMapsTrusted ? this.ensureLastSegment(cache)?.srcOffset ?? 0 : 0;
+      if ((this.tokenMapsTrusted || this.cacheHasFenceMarker(cache)) && this.endsInsideOpenFence(prev, scanStart))
         return null;
     }
-    let scanStart = this.tokenMapsTrusted ? this.ensureLastSegment(cache)?.srcOffset ?? 0 : 0;
-    return (this.tokenMapsTrusted || this.cacheHasFenceMarker(cache)) && this.endsInsideOpenFence(prev, scanStart) || this.mayContainReferenceDefinition(segment) ? null : segment;
+    return this.mayContainReferenceDefinition(segment) ? null : segment;
   }
-  tryTailSegmentReparse(src, cached, env, md, segmentOverride) {
+  tryTailSegmentReparse(src, cached, env, md, segmentOverride, knownAppend) {
     let lastSegment = segmentOverride ?? this.ensureLastSegment(cached);
-    if (!lastSegment || lastSegment.srcOffset <= 0 && lastSegment.tokenStart <= 0)
+    if (!lastSegment)
       return null;
-    let stablePrefix = cached.src.slice(0, lastSegment.srcOffset);
-    if (!src.startsWith(stablePrefix))
+    let directAppend = knownAppend !== void 0;
+    if (directAppend && this.ensureSegmentSourceOffset(cached, lastSegment), lastSegment.srcOffset <= 0 && lastSegment.tokenStart <= 0)
       return null;
-    let prevTail = cached.src.slice(lastSegment.srcOffset), nextTail = src.slice(lastSegment.srcOffset);
+    if (!directAppend) {
+      let stablePrefix = cached.src.slice(0, lastSegment.srcOffset);
+      if (!src.startsWith(stablePrefix))
+        return null;
+    }
+    let prevTail = directAppend ? cached.lastSegmentSource ?? cached.src.slice(lastSegment.srcOffset) : cached.src.slice(lastSegment.srcOffset), nextTail = directAppend ? prevTail + knownAppend : src.slice(lastSegment.srcOffset);
     if (nextTail === prevTail)
       return null;
-    let appended = src.startsWith(cached.src) ? src.slice(cached.src.length) : null, postBlockSrc = this.getNormalizedUpdatedSource(cached, src);
+    let appended = directAppend ? knownAppend : src.startsWith(cached.src) ? src.slice(cached.src.length) : null, postBlockSrc = directAppend && this.tokenMapsTrusted ? src : this.getNormalizedUpdatedSource(cached, src, knownAppend);
     if (appended) {
       let merged = this.tryContainerTailAppendMerge(src, cached, env, md, lastSegment, appended, postBlockSrc);
       if (merged)
-        return merged;
+        return cached.lastSegmentSource = directAppend ? nextTail : void 0, merged;
     }
     if (this.mayContainReferenceDefinition(prevTail) || this.mayContainReferenceDefinition(nextTail))
       return null;
     try {
       let parsedTail = this.parseAtLineOffset(nextTail, env, md, lastSegment.lineStart, postBlockSrc), tailState = parsedTail.state, localLastSegment = this.getLastSegment(tailState.tokens, nextTail, 0, tailState.tokens.length, parsedTail.mapsShifted ? 0 : void 0, parsedTail.mapsShifted ? lastSegment.lineStart : void 0);
-      return lastSegment.lineStart > 0 && !parsedTail.mapsShifted && this.shiftTokenLines(tailState.tokens, lastSegment.lineStart), appended ? this.updateFenceMarkerCacheForAppend(cached, appended) : cached.hasFenceMarker = void 0, cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null, cached.globalStateCarry = void 0, cached.tokens.length = lastSegment.tokenStart, this.appendTokens(cached.tokens, tailState.tokens), cached.lineCount = lastSegment.lineStart + countLines(nextTail), localLastSegment ? cached.lastSegment = {
+      return lastSegment.lineStart > 0 && !parsedTail.mapsShifted && this.shiftTokenLines(tailState.tokens, lastSegment.lineStart), appended ? directAppend ? this.updateBoundaryStateForAppend(cached, appended) : this.updateFenceMarkerCacheForAppend(cached, appended) : (cached.boundary = void 0, cached.hasFenceMarker = void 0), cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null, (!directAppend || !appended) && (cached.globalStateCarry = void 0), cached.tokens.length = lastSegment.tokenStart, this.appendTokens(cached.tokens, tailState.tokens), cached.lineCount = lastSegment.lineStart + countLines(nextTail), localLastSegment ? (cached.lastSegment = {
         tokenStart: lastSegment.tokenStart + localLastSegment.tokenStart,
         tokenEnd: lastSegment.tokenStart + localLastSegment.tokenEnd,
         lineStart: parsedTail.mapsShifted ? localLastSegment.lineStart : lastSegment.lineStart + localLastSegment.lineStart,
         lineEnd: parsedTail.mapsShifted ? localLastSegment.lineEnd : lastSegment.lineStart + localLastSegment.lineEnd,
         srcOffset: lastSegment.srcOffset + localLastSegment.srcOffset
-      } : cached.lastSegment = null, cached.lastSegmentVerified = void 0, cached.tokens;
+      }, cached.lastSegmentSource = directAppend ? nextTail.slice(localLastSegment.srcOffset) : void 0) : (cached.lastSegment = null, cached.lastSegmentSource = void 0), cached.lastSegmentVerified = void 0, cached.tokens;
     } catch {
       return null;
     }
   }
   tryUntrustedParagraphTailReparse(src, cached, env, md) {
-    if (this.endsWithBlankLine(cached.src))
+    if (cached.boundary ? cached.boundary.endsWithBlankLine : this.endsWithBlankLine(cached.src))
       return null;
     let lastSegment = this.ensureLastSegment(cached);
     if (!lastSegment || cached.tokens[lastSegment.tokenStart]?.type !== "paragraph_open")
@@ -22749,6 +23646,7 @@ var StreamParser = class {
     return count;
   }
   hasVerifiedSegmentAnchor(cache, segment, md) {
+    segment.srcOffset < 0 && this.ensureSegmentSourceOffset(cache, segment);
     let lineCount = cache.lineCount ?? countLines(cache.src), docLineCount = this.getDocLineCount(cache.src, lineCount);
     if (!(segment.lineStart >= 0 && segment.lineStart <= segment.lineEnd && segment.lineEnd <= docLineCount && segment.srcOffset < cache.src.length))
       return !1;
@@ -22775,6 +23673,10 @@ var StreamParser = class {
       return !1;
     }
   }
+  normalizeSource(src) {
+    return src.replace(/\r\n?/g, `
+`).replace(/\0/g, "\uFFFD");
+  }
   cacheHasFenceMarker(cache) {
     return cache.hasFenceMarker === void 0 && (cache.hasFenceMarker = cache.src.includes("```") || cache.src.includes("~~~")), cache.hasFenceMarker;
   }
@@ -22784,16 +23686,12 @@ var StreamParser = class {
     let boundary = cache.src.slice(-2) + appended;
     cache.hasFenceMarker = boundary.includes("```") || boundary.includes("~~~");
   }
-  normalizeSource(src) {
-    return src.replace(/\r\n?/g, `
-`).replace(/\0/g, "\uFFFD");
-  }
-  getNormalizedUpdatedSource(cache, next) {
+  getNormalizedUpdatedSource(cache, next, knownAppend) {
     if (!this.normalizeLineEndings)
       return next;
-    if (!next.startsWith(cache.src))
+    if (knownAppend === void 0 && !next.startsWith(cache.src))
       return this.normalizeSource(next);
-    let normalizedCached = cache.normalizedSrc ?? this.normalizeSource(cache.src), appended = next.slice(cache.src.length), normalizedAppend = this.normalizeSource(appended);
+    let normalizedCached = cache.normalizedSrc ?? this.normalizeSource(cache.src), appended = knownAppend ?? next.slice(cache.src.length), normalizedAppend = this.normalizeSource(appended);
     return cache.src.endsWith("\r") && appended.startsWith(`
 `) && (normalizedAppend = normalizedAppend.slice(1)), normalizedCached + normalizedAppend;
   }
@@ -22880,15 +23778,26 @@ var StreamParser = class {
   peek() {
     return this.cache?.tokens ?? EMPTY_TOKENS;
   }
+  hasCache() {
+    return this.cache !== null;
+  }
   getStats() {
     return { ...this.stats };
   }
+  setCache(cache, md) {
+    let snapshotState = this.cache?.snapshotState, nextCache = {
+      ...cache,
+      config: copyParserConfig(md),
+      snapshotState
+    };
+    return snapshotState && (snapshotState.cache = nextCache), this.cache = nextCache, nextCache;
+  }
   appendTokens(target, source, start = 0, end = source.length) {
     for (let i = start; i < end; i++)
       target.push(source[i]);
   }
   updateCacheLineCount(cache, lineCount) {
-    cache.lineCount = lineCount ?? countLines(cache.src), cache.lastSegment = void 0, cache.lastSegmentVerified = void 0, cache.normalizedSrc = void 0, cache.globalStateCarry = void 0;
+    cache.lineCount = lineCount ?? countLines(cache.src), cache.lastSegment = void 0, cache.lastSegmentVerified = void 0, cache.normalizedSrc = void 0, cache.globalStateCarry = cache.src.slice(-GLOBAL_STATE_APPEND_SCAN_WINDOW), cache.boundary = void 0, cache.lastSegmentSource = void 0;
   }
   detectGlobalStateForAppend(cache, appended) {
     if (cache.globalStateReason)
@@ -22896,10 +23805,10 @@ var StreamParser = class {
     let text$1 = (cache.globalStateCarry ?? cache.src.slice(-GLOBAL_STATE_APPEND_SCAN_WINDOW)) + appended, reason = detectGlobalMarkdownState(text$1);
     return cache.globalStateCarry = text$1.length > GLOBAL_STATE_APPEND_SCAN_WINDOW ? text$1.slice(text$1.length - GLOBAL_STATE_APPEND_SCAN_WINDOW) : text$1, reason && (cache.globalStateReason = reason), reason;
   }
-  ensureLastSegment(cache) {
-    return cache.lastSegment !== void 0 || (cache.lastSegment = this.getLastSegment(cache.tokens, cache.src)), cache.lastSegment;
+  ensureLastSegment(cache, skipSourceOffset = !1) {
+    return cache.lastSegment !== void 0 || (cache.lastSegment = this.getLastSegment(cache.tokens, cache.src, 0, cache.tokens.length, void 0, void 0, skipSourceOffset)), cache.lastSegment;
   }
-  getLastSegment(tokens, src, tokenStart = 0, tokenEnd = tokens.length, knownSrcOffset, knownLineStart) {
+  getLastSegment(tokens, src, tokenStart = 0, tokenEnd = tokens.length, knownSrcOffset, knownLineStart, skipSourceOffset = !1) {
     if (tokenEnd <= tokenStart)
       return null;
     let lineStart = Number.POSITIVE_INFINITY, lineEnd$2 = -1, depth = 0;
@@ -22917,7 +23826,7 @@ var StreamParser = class {
             tokenEnd,
             lineStart: resolvedStart,
             lineEnd: resolvedEnd,
-            srcOffset: this.getLineStartOffset(src, resolvedStart, knownSrcOffset, knownLineStart)
+            srcOffset: skipSourceOffset ? -1 : this.getLineStartOffset(src, resolvedStart, knownSrcOffset, knownLineStart)
           };
         }
         continue;
@@ -22929,12 +23838,38 @@ var StreamParser = class {
           tokenEnd,
           lineStart: resolvedStart,
           lineEnd: resolvedEnd,
-          srcOffset: this.getLineStartOffset(src, resolvedStart, knownSrcOffset, knownLineStart)
+          srcOffset: skipSourceOffset ? -1 : this.getLineStartOffset(src, resolvedStart, knownSrcOffset, knownLineStart)
         };
       }
     }
     return null;
   }
+  segmentHasFence(cache, segment) {
+    let end = Math.min(segment.tokenEnd, cache.tokens.length);
+    for (let i = segment.tokenStart; i < end; i++)
+      if (cache.tokens[i].type === "fence")
+        return !0;
+    return !1;
+  }
+  ensureSegmentSourceOffset(cache, segment) {
+    if (segment.srcOffset < 0) {
+      let lineCount = cache.lineCount;
+      segment.srcOffset = lineCount !== void 0 && segment.lineStart <= lineCount && segment.lineEnd <= lineCount + 1 ? this.getLineStartOffsetFromEnd(cache.src, segment.lineStart, lineCount) : this.getLineStartOffset(cache.src, segment.lineStart);
+    }
+    return segment.srcOffset;
+  }
+  getLineStartOffsetFromEnd(src, line, lineCount) {
+    if (line <= 0)
+      return 0;
+    let remaining = lineCount - line + 1, pos = src.length;
+    for (; remaining > 0; ) {
+      if (pos = src.lastIndexOf(`
+`, pos - 1), pos < 0)
+        return 0;
+      remaining--;
+    }
+    return pos + 1;
+  }
   getLineStartOffset(src, line, knownSrcOffset, knownLineStart) {
     return knownSrcOffset !== void 0 && knownLineStart !== void 0 && line >= knownLineStart ? this.getLineStartOffsetFrom(src, knownSrcOffset, line - knownLineStart) : this.getLineStartOffsetFrom(src, 0, line);
   }
@@ -22961,7 +23896,7 @@ var StreamParser = class {
     return src.includes("]:") ? /(?:^|\n)[ \t]{0,3}\[[^\]\n]+\]:/.test(src) : !1;
   }
   canDirectlyParseAppend(cache) {
-    if (!this.tokenMapsTrusted || !this.endsWithBlankLine(cache.src))
+    if (!this.tokenMapsTrusted || !(cache.boundary ? cache.boundary.endsWithBlankLine : this.endsWithBlankLine(cache.src)))
       return !1;
     let lastSegment = this.ensureLastSegment(cache);
     if (!lastSegment)
@@ -22994,8 +23929,9 @@ var StreamParser = class {
     }
   }
   tryListTailAppendMerge(src, cached, env, md, lastSegment, appended, listOpen, postBlockSrc) {
-    if (cached.src.length === 0 || cached.src.charCodeAt(cached.src.length - 1) !== 10)
+    if (cached.src.length === 0 || !(cached.boundary ? cached.boundary.endsWithNewline : cached.src.charCodeAt(cached.src.length - 1) === 10))
       return null;
+    this.ensureSegmentSourceOffset(cached, lastSegment);
     let segmentLineSpan = lastSegment.lineEnd - lastSegment.lineStart, segmentChars = cached.src.length - lastSegment.srcOffset;
     if (segmentLineSpan < this.MIN_LIST_LINES_FOR_MERGE && segmentChars < this.MIN_LIST_CHARS_FOR_MERGE)
       return null;
@@ -23013,10 +23949,10 @@ var StreamParser = class {
       return null;
     lineOffset > 0 && !mapsShifted && this.shiftTokenLines(inserted, lineOffset);
     let existingMode = this.getListParagraphMode(cached.tokens, lastSegment.tokenStart, cached.tokens.length, listOpen.level), appendedMode = this.getListParagraphMode(parsed, 0, parsed.length, 0);
-    (existingMode === "loose" || appendedMode === "loose" || this.endsWithBlankLine(cached.src) || (parsed[0]?.map?.[0] ?? 0) - (mapsShifted ? lineOffset : 0) > 0) && (this.setListParagraphVisibility(cached.tokens, lastSegment.tokenStart, cached.tokens.length, listOpen.level, !1), this.setListParagraphVisibility(inserted, 0, inserted.length, listOpen.level, !1)), cached.tokens.splice(cached.tokens.length - 1, 0, ...inserted), this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null;
+    (existingMode === "loose" || appendedMode === "loose" || (cached.boundary ? cached.boundary.endsWithBlankLine : this.endsWithBlankLine(cached.src)) || (parsed[0]?.map?.[0] ?? 0) - (mapsShifted ? lineOffset : 0) > 0) && (this.setListParagraphVisibility(cached.tokens, lastSegment.tokenStart, cached.tokens.length, listOpen.level, !1), this.setListParagraphVisibility(inserted, 0, inserted.length, listOpen.level, !1)), cached.tokens.splice(cached.tokens.length - 1, 0, ...inserted), cached.boundary ? this.updateBoundaryStateForAppend(cached, appended) : this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null;
     let nextLineCount = lineOffset + countLines(appended);
     cached.lineCount = nextLineCount;
-    let nextDocLineCount = this.getDocLineCount(src, nextLineCount);
+    let nextDocLineCount = this.getCachedDocLineCount(cached, nextLineCount);
     return listOpen.map && (listOpen.map[1] = nextDocLineCount), cached.lastSegment = {
       tokenStart: lastSegment.tokenStart,
       tokenEnd: cached.tokens.length,
@@ -23026,8 +23962,9 @@ var StreamParser = class {
     }, cached.lastSegmentVerified = !0, cached.tokens;
   }
   tryTableTailAppendMerge(src, cached, env, md, lastSegment, appended, tableOpen, postBlockSrc) {
-    if (cached.src.length === 0 || cached.src.charCodeAt(cached.src.length - 1) !== 10 || /(?:^|\n)[ \t]*\n/.test(appended))
+    if (cached.src.length === 0 || !(cached.boundary ? cached.boundary.endsWithNewline : cached.src.charCodeAt(cached.src.length - 1) === 10) || /(?:^|\n)[ \t]*\n/.test(appended))
       return null;
+    this.ensureSegmentSourceOffset(cached, lastSegment);
     let segmentLineSpan = lastSegment.lineEnd - lastSegment.lineStart, segmentChars = cached.src.length - lastSegment.srcOffset;
     if (segmentLineSpan < this.MIN_TABLE_LINES_FOR_MERGE && segmentChars < this.MIN_TABLE_CHARS_FOR_MERGE)
       return null;
@@ -23051,10 +23988,10 @@ var StreamParser = class {
       return null;
     lineOffset !== 0 && !mapsShifted && this.shiftTokenLines(inserted, lineOffset);
     let insertAt = cachedSection.tbodyCloseIndex >= 0 ? cachedSection.tbodyCloseIndex : cachedSection.tableCloseIndex, previousLineCount = cached.lineCount ?? countLines(cached.src);
-    cached.tokens.splice(insertAt, 0, ...inserted), this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null;
+    cached.tokens.splice(insertAt, 0, ...inserted), cached.boundary ? this.updateBoundaryStateForAppend(cached, appended) : this.updateFenceMarkerCacheForAppend(cached, appended), cached.src = src, cached.normalizedSrc = postBlockSrc, cached.env = env, cached.globalStateReason = null;
     let nextLineCount = previousLineCount + countLines(appended);
     cached.lineCount = nextLineCount;
-    let nextDocLineCount = this.getDocLineCount(src, nextLineCount);
+    let nextDocLineCount = this.getCachedDocLineCount(cached, nextLineCount);
     if (tableOpen.map && (tableOpen.map[1] = nextDocLineCount), cachedSection.tbodyOpenIndex >= 0) {
       let tbodyOpen = cached.tokens[cachedSection.tbodyOpenIndex];
       tbodyOpen?.map && (tbodyOpen.map[1] = nextDocLineCount);
@@ -23161,7 +24098,7 @@ var StreamParser = class {
       case "paragraph_open":
       case "code_block":
       case "html_block":
-        return !this.endsWithBlankLine(cache.src);
+        return !(cache.boundary ? cache.boundary.endsWithBlankLine : this.endsWithBlankLine(cache.src));
       default:
         return lastToken?.nesting === 1;
     }
@@ -23181,9 +24118,41 @@ var StreamParser = class {
     }
     return !0;
   }
+  ensureBoundaryState(cache) {
+    if (cache.boundary)
+      return cache.boundary;
+    let src = cache.src, len = src.length, endsWithNewline = len > 0 && src.charCodeAt(len - 1) === 10, lineEnd$2 = endsWithNewline ? len - 1 : len, lineStart = lineEnd$2 - 1;
+    for (; lineStart >= 0 && src.charCodeAt(lineStart) !== 10; )
+      lineStart--;
+    let lineNonBlank = !1;
+    for (let i = lineStart + 1; i < lineEnd$2; i++) {
+      let ch = src.charCodeAt(i);
+      if (ch !== 32 && ch !== 9) {
+        lineNonBlank = !0;
+        break;
+      }
+    }
+    return cache.boundary = {
+      currentLineNonBlank: endsWithNewline ? !1 : lineNonBlank,
+      previousLineNonBlank: endsWithNewline ? lineNonBlank : !1,
+      endsWithNewline,
+      endsWithBlankLine: this.endsWithBlankLine(src)
+    }, cache.boundary;
+  }
+  updateBoundaryStateForAppend(cache, appended) {
+    let boundary = this.ensureBoundaryState(cache), currentLineNonBlank = boundary.currentLineNonBlank, previousLineNonBlank = boundary.previousLineNonBlank;
+    for (let i = 0; i < appended.length; i++) {
+      let ch = appended.charCodeAt(i);
+      ch === 10 ? (previousLineNonBlank = currentLineNonBlank, currentLineNonBlank = !1) : ch !== 32 && ch !== 9 && (currentLineNonBlank = !0);
+    }
+    boundary.currentLineNonBlank = currentLineNonBlank, boundary.previousLineNonBlank = previousLineNonBlank, boundary.endsWithNewline = appended.length > 0 ? appended.charCodeAt(appended.length - 1) === 10 : boundary.endsWithNewline, boundary.endsWithBlankLine = cache.src.length + appended.length >= 2 && boundary.endsWithNewline && !previousLineNonBlank;
+  }
   getDocLineCount(src, lineCount = countLines(src)) {
     return src.length === 0 ? 0 : src.charCodeAt(src.length - 1) === 10 ? lineCount : lineCount + 1;
   }
+  getCachedDocLineCount(cache, lineCount) {
+    return cache.src.length === 0 ? 0 : cache.boundary ? cache.boundary.endsWithNewline ? lineCount : lineCount + 1 : this.getDocLineCount(cache.src, lineCount);
+  }
   shiftTokenLines(tokens, offset) {
     if (offset === 0)
       return;
@@ -23213,11 +24182,12 @@ function getParserRuleVersions(md) {
     core: md.core.ruler.version,
     block: md.block.ruler.version,
     inline: md.inline.ruler.version,
-    inline2: md.inline.ruler2.version
+    inline2: md.inline.ruler2.version,
+    inlineState: md.inline.State
   };
 }
 function hasParserRuleChanges(md, initial) {
-  return md.core.ruler.version !== initial.core || md.block.ruler.version !== initial.block || md.inline.ruler.version !== initial.inline || md.inline.ruler2.version !== initial.inline2;
+  return md.core.ruler.version !== initial.core || md.block.ruler.version !== initial.block || md.inline.ruler.version !== initial.inline || md.inline.ruler2.version !== initial.inline2 || md.inline.State !== initial.inlineState;
 }
 function applyExperimentalOptions(options) {
   return options.experimental ? {
@@ -23570,9 +24540,25 @@ function markdownIt(presetName, options) {
     parse(src, env) {
       return md.stream.enabled ? getStreamParser().parse(src, env, md) : md.parse(src, env ?? {});
     },
+    append(segment, env) {
+      if (!md.stream.enabled)
+        throw new Error("Stream append requires stream mode");
+      return getStreamParser().append(segment, env, md);
+    },
+    snapshot() {
+      return streamParser ? streamParser.snapshot() : null;
+    },
+    restore(snapshot) {
+      if (!md.stream.enabled)
+        throw new Error("Stream restore requires stream mode");
+      return getStreamParser().restore(snapshot, md);
+    },
     reset() {
       getStreamParser().reset();
     },
+    hasCache() {
+      return streamParser?.hasCache() ?? !1;
+    },
     peek() {
       return streamParser ? streamParser.peek() : [];
     },
@@ -23890,7 +24876,7 @@ function container_plugin(md, name, options) {
     return tokens[idx].nesting === 1 && tokens[idx].attrJoin("class", name), slf.renderToken(tokens, idx, _options, env, slf);
   }
   options = options || {};
-  let min_markers = 3, marker_str = options.marker || ":", marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length, validate = options.validate || validateDefault, render = options.render || renderDefault;
+  let min_markers = 3, marker_str = options.marker || ":", marker_char = marker_str.charCodeAt(0), marker_len = marker_str.length, validate$1 = options.validate || validateDefault, render = options.render || renderDefault;
   function container(state, startLine, endLine, silent) {
     let pos, auto_closed = !1, start = state.bMarks[startLine] + state.tShift[startLine], max = state.eMarks[startLine];
     if (marker_char !== state.src.charCodeAt(start))
@@ -23902,7 +24888,7 @@ function container_plugin(md, name, options) {
       return !1;
     pos -= (pos - start) % marker_len;
     let markup = state.src.slice(start, pos), params = state.src.slice(pos, max);
-    if (!validate(params, markup))
+    if (!validate$1(params, markup))
       return !1;
     if (silent)
       return !0;
@@ -24125,9 +25111,9 @@ function applyContainers(md) {
 function escapeTagForRegExp(tag) {
   return tag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function findTagCloseIndexOutsideQuotes(input) {
+function findTagCloseIndexOutsideQuotes(input, start = 0) {
   let inSingle = !1, inDouble = !1;
-  for (let i = 0; i < input.length; i++) {
+  for (let i = start; i < input.length; i++) {
     let ch = input[i];
     if (ch === "\\") {
       i++;
@@ -24998,7 +25984,7 @@ function createChildParseContext(parent, options = parent, overrides = {}) {
     ...overrides
   });
 }
-var FILENAMEISH_EXTENSION_RE = /\.([a-z0-9]{1,15})$/i, FILENAMEISH_SEGMENT_RE = /[_()[\]{}<>]/u, URL_PREFIX_HINT_RE = /^(?:https?:\/\/|ftp:\/\/|mailto:|www\.)/i, URL_QUERY_OR_AUTH_HINT_RE = /[?#@]/u, PATH_SEPARATOR_RE = /[\\/]/u, DOMAINISH_TEXT_RE = /^[\p{L}\p{N}./\\-]+$/u, DOMAIN_LABEL_RE = /^[A-Za-z0-9-]{1,63}$/u, PUNYCODE_TLD_RE = /^xn--[a-z0-9-]{2,59}$/i, MARKET_TICKER_SYMBOL_RE = /^(?:[A-Z]{1,6}|\d{1,8})$/u, MARKET_TICKER_CONTEXT_SYMBOL_RE = /^(?=.{1,12}$)[A-Z0-9]+(?:[-.][A-Z0-9]+)*$/iu, EXPLICIT_FILENAME_CONTEXT_RE = /文件名\s*[:：]?|附件\s*[:：]?|路径\s*[:：]?|路徑\s*[:：]?|文件列表\s*[:：]?|文档列表\s*[:：]?|文檔列表\s*[:：]?|\bfile\s*names?\b\s*[:：]?|\battachments?\b\s*[:：]?|\bpaths?\b\s*[:：]?|\bfile\s+lists?\b\s*[:：]?|\bdocument\s+lists?\b\s*[:：]?/iu, FILENAME_CONTEXT_RE = /文件名\s*[:：]?|文件\s*[:：]?|附件\s*[:：]?|档案\s*[:：]?|檔案\s*[:：]?|文档\s*[:：]?|文檔\s*[:：]?|资料\s*[:：]?|資料\s*[:：]?|路径\s*[:：]?|路徑\s*[:：]?|\bfile\s*name\b\s*[:：]?|\battachments?\b\s*[:：]?|\bfiles?\b\s*[:：]?|\bdocuments?\b\s*[:：]?|\bdocs?\b\s*[:：]?|\bpaths?\b\s*[:：]?/iu, MARKET_TICKER_CONTEXT_RE = /股票代码|股票代碼|证券代码|證券代碼|(?:代码|代碼|交易所|后缀|後綴|市场|市場)(?=$|[\s:：/|,，、()（）])|\btickers?\b|\bsymbols?\b|\bexchanges?\b/iu, LINKIFY_DEMOTION_CONTEXT_CACHE_LIMIT = 2e3, LINKIFY_DEMOTION_CONTEXT_CACHE_MAX_TEXT_LENGTH = 512, EMPTY_LINKIFY_DEMOTION_CONTEXT = {}, AMBIGUOUS_BARE_DOMAIN_EXTENSIONS = /* @__PURE__ */ new Set([
+var FILENAMEISH_EXTENSION_RE = /\.([a-z0-9]{1,15})$/i, FILENAMEISH_SEGMENT_RE = /[_()[\]{}<>]/u, URL_PREFIX_HINT_RE = /^(?:https?:\/\/|ftp:\/\/|mailto:|www\.)/i, URL_QUERY_OR_AUTH_HINT_RE = /[?#@]/u, PATH_SEPARATOR_RE = /[\\/]/u, DOMAINISH_TEXT_RE = /^[\p{L}\p{N}./\\-]+$/u, DOMAIN_LABEL_RE = /^[A-Za-z0-9-]{1,63}$/u, PUNYCODE_TLD_RE = /^xn--[a-z0-9-]{2,59}$/i, MARKET_TICKER_SYMBOL_RE = /^(?:[A-Z]{1,6}|\d{1,8})$/u, MARKET_TICKER_CONTEXT_SYMBOL_RE = /^(?=.{1,12}$)[A-Z0-9]+(?:[-.][A-Z0-9]+)*$/iu, EXPLICIT_FILENAME_CONTEXT_RE = /文件名\s*[:：]?|附件\s*[:：]?|路径\s*[:：]?|路徑\s*[:：]?|文件列表\s*[:：]?|文档列表\s*[:：]?|文檔列表\s*[:：]?|\bfile\s*names?\b\s*[:：]?|\battachments?\b\s*[:：]?|\bpaths?\b\s*[:：]?|\bfile\s+lists?\b\s*[:：]?|\bdocument\s+lists?\b\s*[:：]?/iu, FILENAME_CONTEXT_RE = /文件名\s*[:：]?|文件\s*[:：]?|附件\s*[:：]?|档案\s*[:：]?|檔案\s*[:：]?|文档\s*[:：]?|文檔\s*[:：]?|资料\s*[:：]?|資料\s*[:：]?|路径\s*[:：]?|路徑\s*[:：]?|\bfile\s*name\b\s*[:：]?|\battachments?\b\s*[:：]?|\bfiles?\b\s*[:：]?|\bdocuments?\b\s*[:：]?|\bdocs?\b\s*[:：]?|\bpaths?\b\s*[:：]?/iu, MARKET_TICKER_CONTEXT_RE = /股票代码|股票代碼|证券代码|證券代碼|(?:代码|代碼|交易所|后缀|後綴|市场|市場)(?=$|[\s:：/|,，、()（）])|\btickers?\b|\bsymbols?\b|\bexchanges?\b/iu, LINKIFY_DEMOTION_CONTEXT_CACHE_LIMIT = 2e3, LINKIFY_DEMOTION_CONTEXT_CACHE_MAX_TEXT_LENGTH = 16384, LINKIFY_DEMOTION_CONTEXT_CACHE_MAX_TOTAL_TEXT_LENGTH = 512 * LINKIFY_DEMOTION_CONTEXT_CACHE_LIMIT, EMPTY_LINKIFY_DEMOTION_CONTEXT = {}, AMBIGUOUS_BARE_DOMAIN_EXTENSIONS = /* @__PURE__ */ new Set([
   "ai",
   "md",
   "py",
@@ -25118,15 +26104,15 @@ var FILENAMEISH_EXTENSION_RE = /\.([a-z0-9]{1,15})$/i, FILENAMEISH_SEGMENT_RE =
   "yml",
   "zip",
   "zsh"
-]), linkifyDemotionContextCache = /* @__PURE__ */ new Map();
+]), linkifyDemotionContextCache = /* @__PURE__ */ new Map(), linkifyDemotionContextCacheTextLength = 0;
 function rememberLinkifyDemotionContext(text$1, context) {
   if (!text$1 || text$1.length > LINKIFY_DEMOTION_CONTEXT_CACHE_MAX_TEXT_LENGTH)
     return context;
-  for (linkifyDemotionContextCache.set(text$1, context); linkifyDemotionContextCache.size > LINKIFY_DEMOTION_CONTEXT_CACHE_LIMIT; ) {
+  for (linkifyDemotionContextCache.has(text$1) || (linkifyDemotionContextCacheTextLength += text$1.length), linkifyDemotionContextCache.set(text$1, context); linkifyDemotionContextCache.size > LINKIFY_DEMOTION_CONTEXT_CACHE_LIMIT || linkifyDemotionContextCacheTextLength > LINKIFY_DEMOTION_CONTEXT_CACHE_MAX_TOTAL_TEXT_LENGTH; ) {
     let oldestKey = linkifyDemotionContextCache.keys().next().value;
     if (!oldestKey)
       break;
-    linkifyDemotionContextCache.delete(oldestKey);
+    linkifyDemotionContextCache.delete(oldestKey), linkifyDemotionContextCacheTextLength -= oldestKey.length;
   }
   return context;
 }
@@ -25174,7 +26160,7 @@ function inferContinuationLinkifyContext(raw, inherited) {
   })) && (continuation.filename = !0), inherited?.explicitFilename && continuation.filename && (continuation.explicitFilename = !0), inherited?.marketTicker && parts.every((part) => shouldDemoteFilenameLikeLinkify(part, { marketTicker: !0 })) && (continuation.marketTicker = !0), hasLinkifyDemotionContext(continuation) ? continuation : void 0;
 }
 function createLinkifyDemotionContextTracker(options, sticky = !1) {
-  let context;
+  let context = ensureParseContext(options).linkifyDemotionSeedContext;
   return {
     options(raw) {
       return sticky || raw == null ? withLinkifyDemotionContext(options, context) : withLinkifyDemotionContext(options, mergeLinkifyDemotionContext(inferNextBlockLinkifyContext(raw), inferContinuationLinkifyContext(raw, context)));
@@ -25185,6 +26171,9 @@ function createLinkifyDemotionContextTracker(options, sticky = !1) {
     },
     reset() {
       context = void 0;
+    },
+    snapshot() {
+      return context;
     }
   };
 }
@@ -25221,11 +26210,11 @@ function mayContainLinkifyDemotionContext(text$1) {
 }
 function inferLinkifyDemotionContext(contextText) {
   let text$1 = String(contextText ?? ""), cached = linkifyDemotionContextCache.get(text$1);
-  return cached ? (linkifyDemotionContextCache.delete(text$1), linkifyDemotionContextCache.set(text$1, cached), cached) : mayContainLinkifyDemotionContext(text$1) ? rememberLinkifyDemotionContext(text$1, {
+  return cached || (mayContainLinkifyDemotionContext(text$1) ? rememberLinkifyDemotionContext(text$1, {
     explicitFilename: EXPLICIT_FILENAME_CONTEXT_RE.test(text$1),
     filename: FILENAME_CONTEXT_RE.test(text$1),
     marketTicker: MARKET_TICKER_CONTEXT_RE.test(text$1)
-  }) : rememberLinkifyDemotionContext(text$1, EMPTY_LINKIFY_DEMOTION_CONTEXT);
+  }) : rememberLinkifyDemotionContext(text$1, EMPTY_LINKIFY_DEMOTION_CONTEXT));
 }
 function hasDomainAuthorityPrefix(text$1) {
   return isPlausibleBareDomain(text$1.split(/[\\/]/)[0] ?? "");
@@ -25264,6 +26253,21 @@ function setSyntheticLinkOrigin(token, origin) {
 function readSyntheticLinkOrigin(token) {
   return syntheticLinkOrigins.get(token);
 }
+function resolveLinkMarkup(token) {
+  if (!token)
+    return "";
+  let origin = readSyntheticLinkOrigin(token);
+  if (origin === "linkify" || origin === "autolink")
+    return origin;
+  let markup = typeof token.markup == "string" ? token.markup : "";
+  return markup === "linkify" || markup === "autolink" ? markup : "";
+}
+function copySyntheticLinkOrigin(from, to) {
+  if (!from || !to)
+    return;
+  let origin = readSyntheticLinkOrigin(from);
+  origin && syntheticLinkOrigins.set(to, origin);
+}
 function registerCacheStableLinkValidator(validateLink$1) {
   cacheStableLinkValidators.add(validateLink$1);
 }
@@ -25501,7 +26505,7 @@ function fixLinkToken(tokens, raw) {
       } else if (curToken?.type === "text" && curToken.content?.endsWith("(") && tokens[i + 1]?.type === "link_open") {
         let match = curToken.content.match(/\[([^\]]+)\]/);
         if (match) {
-          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), origin = getSyntheticLinkOrigin(tokens[i + 1]?.markup), replacerTokens = [];
+          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), linkOpenMarkup = tokens[i + 1]?.markup, origin = (linkOpenMarkup === "linkify" || linkOpenMarkup === "autolink") && (match.index ?? 0) + match[0].length === curToken.content.length - 1 ? "explicit" : getSyntheticLinkOrigin(linkOpenMarkup), replacerTokens = [];
           if (emphasisMatch) {
             beforeText = beforeText.slice(0, emphasisMatch.index), beforeText && replacerTokens.push(textToken(beforeText));
             let text$1 = match[1], type = emphasisMatch[1].length;
@@ -25730,7 +26734,7 @@ function fixStrongTokens(tokens) {
       for (; k < tokens.length && tokens[k].type === "text" && tokens[k].content === ""; )
         k++;
       let postToken = tokens[k];
-      markup === "__" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_") || postToken?.markup?.includes("_")) && (t.type = "text", t.tag = "", t.content = markup, t.raw = markup, t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null, cleansStrong.add(strongIndex));
+      markup === "__" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_")) && (t.type = "text", t.tag = "", t.content = markup, t.raw = markup, t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null, cleansStrong.add(strongIndex));
     } else if (type === "strong_close")
       cleansStrong.has(strongIndex) && t.markup === "__" && (t.type = "text", t.content = t.markup, t.raw = String(t.markup ?? ""), t.tag = "", t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null), strongIndex--, strongIndex < 0 && (strongIndex = 0);
     else if (type === "em_open") {
@@ -25742,7 +26746,7 @@ function fixStrongTokens(tokens) {
       for (; k < tokens.length && tokens[k].type === "text" && tokens[k].content === ""; )
         k++;
       let postToken = tokens[k];
-      markup === "_" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_") || postToken?.markup?.includes("_")) && (t.type = "text", t.tag = "", t.content = markup, t.raw = markup, t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null, cleansEm.add(emIndex));
+      markup === "_" && (preToken?.content?.endsWith("_") || postToken?.content?.startsWith("_")) && (t.type = "text", t.tag = "", t.content = markup, t.raw = markup, t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null, cleansEm.add(emIndex));
     } else
       type === "em_close" && (cleansEm.has(emIndex) && t.markup === "_" && (t.type = "text", t.content = t.markup, t.raw = String(t.markup ?? ""), t.tag = "", t.markup = "", t.attrs = null, t.map = null, t.info = "", t.meta = null), emIndex--, emIndex < 0 && (emIndex = 0));
   }
@@ -26051,36 +27055,35 @@ function hasTrailingPipeHeaderRowWithoutColon(line) {
   return cells !== null && cells.every((cell) => !cell.includes(":"));
 }
 function fixTableTokens(tokens, final = !1, source = "") {
-  let fixedTokens = [...tokens];
   if (tokens.length < 3)
-    return fixedTokens;
+    return tokens;
   let i = tokens.length - 2, token = tokens[i];
-  if (token.type === "inline") {
-    let sourceMap = tokens[i - 1]?.map, tcontent = String(token.content ?? ""), headerContent = tcontent.split(`
+  if (token.type !== "inline")
+    return tokens;
+  let sourceMap = tokens[i - 1]?.map, tcontent = String(token.content ?? ""), headerContent = tcontent.split(`
 `)[0] ?? "", [headerLine = "", separatorLine = "", ...rest] = tcontent.split(`
 `), hasTrailingNewlineSeparatorStart = !final && !tcontent.includes(`
-`) && /\r?\n$/.test(source) && hasTrailingPipeHeaderRow(tcontent);
-    if (!final && (tcontent.includes(`
+`) && /\r?\n$/.test(source) && hasTrailingPipeHeaderRow(tcontent), fixedTokens = null;
+  if (!final && (tcontent.includes(`
 `) && rest.length === 0 && hasTrailingPipeHeaderRow(headerLine) && isTableSeparatorRowWithPartialTail(separatorLine) || hasTrailingNewlineSeparatorStart)) {
-      let body = headerContent.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1)), insert = [
-        ...createStart(sourceMap),
-        ...body,
-        ...createEnd()
-      ];
-      fixedTokens.splice(i - 1, 3, ...insert);
-    } else if (tcontent.includes(`
+    let body = headerContent.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1)), insert = [
+      ...createStart(sourceMap),
+      ...body,
+      ...createEnd()
+    ];
+    fixedTokens = [...tokens], fixedTokens.splice(i - 1, 3, ...insert);
+  } else if (tcontent.includes(`
 `) && rest.length === 0 && hasTrailingPipeHeaderRow(headerLine) && isTableSeparatorRow(separatorLine)) {
-      let body = headerContent.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1)), insert = [
-        ...createStart(sourceMap),
-        ...body,
-        ...createEnd()
-      ];
-      fixedTokens.splice(i - 1, 3, ...insert);
-    } else
-      tcontent.includes(`
-`) && rest.length === 0 && hasTrailingPipeHeaderRowWithoutColon(headerLine) && isTruncatedSeparatorRow(separatorLine) && (token.content = tcontent.slice(0, -2), token.children.splice(2, 1));
-  }
-  return fixedTokens;
+    let body = headerContent.slice(1, -1).split("|").map((i$1) => i$1.trim()).flatMap((i$1) => createTh(i$1)), insert = [
+      ...createStart(sourceMap),
+      ...body,
+      ...createEnd()
+    ];
+    fixedTokens = [...tokens], fixedTokens.splice(i - 1, 3, ...insert);
+  } else if (tcontent.includes(`
+`) && rest.length === 0 && hasTrailingPipeHeaderRowWithoutColon(headerLine) && isTruncatedSeparatorRow(separatorLine))
+    return token.content = tcontent.slice(0, -2), token.children.splice(2, 1), tokens;
+  return fixedTokens ?? tokens;
 }
 function findMatchingClose(src, startIdx, open, close) {
   let len = src.length;
@@ -26571,27 +27574,36 @@ function hashTolerantBoundaryContent(content) {
     hash = hash * 31 + content.charCodeAt(index) | 0;
   return hash.toString(36);
 }
-function getTolerantBoundaryScanWindow(source) {
+function getTolerantBoundaryScanWindow(source, cache) {
   if (source.length <= TOLERANT_BOUNDARY_SCAN_TAIL_CHARS)
     return {
       source,
       lineOffset: 0
     };
+  if (cache) {
+    let cut = source.length - TOLERANT_BOUNDARY_SCAN_TAIL_CHARS, start$1 = source.indexOf(`
+`, cut);
+    start$1 = start$1 === -1 ? source.length : start$1 + 1;
+    let lineOffset$1 = cache.lineOffset + countLineBreaks(source.slice(cache.windowStart, start$1));
+    return cache.lineOffset = lineOffset$1, cache.windowStart = start$1, {
+      source: source.slice(start$1),
+      lineOffset: lineOffset$1
+    };
+  }
   let start = source.length - TOLERANT_BOUNDARY_SCAN_TAIL_CHARS, nextLineBreak = source.indexOf(`
 `, start);
-  return nextLineBreak === -1 ? {
-    source: "",
-    lineOffset: countLineBreaks(source)
-  } : (start = nextLineBreak + 1, {
+  start = nextLineBreak === -1 ? source.length : nextLineBreak + 1;
+  let lineOffset = countLineBreaks(source.slice(0, start));
+  return {
     source: source.slice(start),
-    lineOffset: countLineBreaks(source.slice(0, start))
-  });
+    lineOffset
+  };
 }
-function mayContainTolerantMathBlockBoundaryOpener(markdown) {
+function mayContainTolerantMathBlockBoundaryOpener(markdown, scanWindowCache) {
   let fullSource = String(markdown ?? "");
   if (!fullSource || !fullSource.includes("$$") && !fullSource.includes("\\["))
     return !1;
-  let { source } = getTolerantBoundaryScanWindow(fullSource);
+  let { source } = getTolerantBoundaryScanWindow(fullSource, scanWindowCache);
   if (!source)
     return !1;
   let lines = source.split(/\r?\n/), startLine = Math.max(0, lines.length - TOLERANT_BOUNDARY_SCAN_MAX_LINES - 2), delimiters = [["$$", "$$"], ["\\[", "\\]"]];
@@ -26605,11 +27617,11 @@ function mayContainTolerantMathBlockBoundaryOpener(markdown) {
   }
   return !1;
 }
-function getTolerantMathBlockBoundaryStreamKey(markdown) {
+function getTolerantMathBlockBoundaryStreamKey(markdown, scanWindowCache) {
   let fullSource = String(markdown ?? "");
   if (!fullSource || !fullSource.includes("$$") && !fullSource.includes("\\["))
     return null;
-  let { source, lineOffset } = getTolerantBoundaryScanWindow(fullSource);
+  let { source, lineOffset } = getTolerantBoundaryScanWindow(fullSource, scanWindowCache);
   if (!source)
     return null;
   let lines = source.split(/\r?\n/), startLine = Math.max(0, lines.length - TOLERANT_BOUNDARY_SCAN_MAX_LINES - 2), delimiters = [["$$", "$$"], ["\\[", "\\]"]];
@@ -27103,7 +28115,7 @@ function applyRenderRules(md) {
     return `<pre class="${info ? `language-${md.utils.escapeHtml(info.split(/\s+/g)[0])}` : ""}"><code>${md.utils.escapeHtml(String(tokenShape.content ?? ""))}</code></pre>`;
   });
 }
-var HTML_LINK_OPEN_RE = /^<a[>\s]/i, HTML_LINK_CLOSE_RE = /^<\/a\s*>/i;
+var HTML_LINK_OPEN_RE = /^<a[>\s]/i, HTML_LINK_CLOSE_RE = /^<\/a\s*>/i, LINKIFY_SEED_RE = /[@:]|\/\/|\.\S/;
 function inlineTokenMayNeedLinkify(token, linkify$2) {
   if (token?.type !== "inline")
     return !1;
@@ -27129,13 +28141,33 @@ function inlineTokenMayNeedLinkify(token, linkify$2) {
 }
 function applyLinkifyCandidateFilter(md) {
   let ruler = md.core?.ruler, original = ruler.getNamedRules?.().find((rule) => rule.name === "linkify")?.fn;
-  typeof original == "function" && ruler.at("linkify", (state) => {
+  if (typeof original != "function")
+    return;
+  let nativeLinkify = md.options.linkify ? md.linkify : void 0, nativeTest = nativeLinkify?.test, nativeMatch = nativeLinkify?.match, nativeBuilderPrototype = nativeLinkify?.re && Object.getPrototypeOf(nativeLinkify.re), screenedCache, seedSafe = !1;
+  ruler.at("linkify", (state) => {
     if (!state.md?.options?.linkify)
       return;
     let tokens = Array.isArray(state.tokens) ? state.tokens : [], linkify$2 = state.md.linkify;
-    if (!linkify$2)
+    if (!linkify$2 || !tokens.some((token) => token?.type === "inline"))
       return;
-    let candidates = tokens.filter((token) => inlineTokenMayNeedLinkify(token, linkify$2));
+    let re = linkify$2.re, nativeBuilder = re && Object.getPrototypeOf(re) === nativeBuilderPrototype && !Object.values(re).some((value) => typeof value == "function"), nativeMethods = linkify$2.test === nativeTest && linkify$2.match === nativeMatch;
+    if (nativeMethods && nativeBuilder && screenedCache !== re.cache) {
+      screenedCache = re.cache;
+      let { schema_names: schemas = [], tlds = [] } = re.opts;
+      seedSafe = schemas.every((name) => name === "//" || name.endsWith(":")) && tlds.every((tld) => /^[\p{L}\p{N}-]+$/u.test(tld));
+    }
+    let canScreen = !!nativeMethods && !!nativeBuilder && seedSafe && (state.env?.__markstreamFinal !== !1 || !!re?.cache.link_fuzzy_search), candidates = tokens.filter((token) => {
+      if (canScreen && token?.type === "inline") {
+        let children = token.children;
+        if (Array.isArray(children) && children.length > 0) {
+          if (!children.some((child) => child?.type === "text" && LINKIFY_SEED_RE.test(String(child.content ?? ""))))
+            return !1;
+        } else if (!LINKIFY_SEED_RE.test(String(token.content ?? "")))
+          return !1;
+        canScreen = !1;
+      }
+      return inlineTokenMayNeedLinkify(token, linkify$2);
+    });
     if (candidates.length)
       return original(Object.assign(Object.create(Object.getPrototypeOf(state)), state, { tokens: candidates }));
   });
@@ -27187,12 +28219,22 @@ function factory(opts = {}) {
     });
     registerCacheStableLinkValidator(validateLink$1), md.set({ validateLink: validateLink$1 });
   }
-  return applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.enableMath ?? !0) && applyMath(md, {
+  return applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.cjkFriendly ?? !0) && md.use(markdownItCjkFriendlyPlugin), (opts.enableMath ?? !0) && applyMath(md, {
     ...getDefaultMathOptions() ?? {},
     ...opts.mathOptions ?? {}
   }), (opts.enableContainers ?? !0) && applyContainers(md), opts.enableFixIndentedCodeBlock !== !1 && applyFixIndentedCodeBlock(md), applyFixLinkTokens(md), applyFixStrongTokens(md), applyFixListItem(md), applyFixTableTokens(md), applyRenderRules(md), applyFixHtmlInlineTokens(md, { customHtmlTags: opts.customHtmlTags }), md;
 }
-var NOT_WHITESPACE = /\S/;
+var regexCache = /* @__PURE__ */ new Map();
+function getCachedRegex(pattern, flags) {
+  let key = flags ? `${pattern}:::${flags}` : pattern, regex = regexCache.get(key);
+  if (!regex && (regex = new RegExp(pattern, flags), regexCache.set(key, regex), regexCache.size > 200)) {
+    let keysToDelete = Array.from(regexCache.keys()).slice(0, 50);
+    for (let keyToDelete of keysToDelete)
+      regexCache.delete(keyToDelete);
+  }
+  return regex.lastIndex = 0, regex;
+}
+var NOT_WHITESPACE = /\S/, STARTS_LIKE_HTML_DOCUMENT_RE = /^(?:<!doctype\s+html[^>]*>\s*)?<html(?:\s[^>]*)?>/i, ENDS_WITH_HTML_CLOSE_RE = /<\/html>\s*$/i, NON_ELEMENT_MARKUP_START_RE = /^<\s*[!?]/, MARKUP_TAG_NAME_RE = /^([A-Z][\w:-]*)/i, SELF_CLOSING_END_RE$1 = /\/\s*>$/;
 function parseStandaloneHtmlDocument(markdown) {
   let firstNonWhitespace = markdown.search(NOT_WHITESPACE);
   if (firstNonWhitespace === -1 || markdown.charCodeAt(firstNonWhitespace) !== 60)
@@ -27200,7 +28242,7 @@ function parseStandaloneHtmlDocument(markdown) {
   let trimmed = markdown.trim();
   if (!trimmed)
     return null;
-  let startsLikeHtmlDocument = /^(?:<!doctype\s+html[^>]*>\s*)?<html(?:\s[^>]*)?>/i.test(trimmed), endsWithHtmlClose = /<\/html>\s*$/i.test(trimmed);
+  let startsLikeHtmlDocument = STARTS_LIKE_HTML_DOCUMENT_RE.test(trimmed), endsWithHtmlClose = ENDS_WITH_HTML_CLOSE_RE.test(trimmed);
   return !startsLikeHtmlDocument || !endsWithHtmlClose ? null : [{
     type: "html_block",
     tag: "html",
@@ -27220,7 +28262,7 @@ function isCloseOnlyHtmlBlockForTag(node, tag) {
   if (node.type !== "html_block" || !tag)
     return !1;
   let raw = String(node.raw ?? node.content ?? "");
-  return new RegExp(String.raw`^\s*<\s*\/\s*${escapeTagForRegExp(tag)}\s*>\s*$`, "i").test(raw);
+  return getCachedRegex(String.raw`^\s*<\s*\/\s*${escapeTagForRegExp(tag)}\s*>\s*$`, "i").test(raw);
 }
 var RAW_TEXT_HTML_TAGS = /* @__PURE__ */ new Set([
   "iframe",
@@ -27251,11 +28293,11 @@ function findNextHtmlBlockFromSource(source, tag, startIndex) {
         tag: ""
       };
     }
-    let endRel = findTagCloseIndexOutsideQuotes(source.slice(start$1));
-    if (endRel === -1)
+    let closeIndex = findTagCloseIndexOutsideQuotes(source, start$1);
+    if (closeIndex === -1)
       return null;
-    let end = start$1 + endRel + 1, raw = source.slice(start$1, end);
-    if (/^<\s*[!?]/.test(raw))
+    let end = closeIndex + 1, raw = source.slice(start$1, end);
+    if (NON_ELEMENT_MARKUP_START_RE.test(raw))
       return {
         closing: !1,
         end,
@@ -27264,11 +28306,11 @@ function findNextHtmlBlockFromSource(source, tag, startIndex) {
       };
     let body = raw.slice(1).trimStart(), closing = body.startsWith("/");
     closing && (body = body.slice(1).trimStart());
-    let tagMatch = body.match(/^([A-Z][\w:-]*)/i);
+    let tagMatch = body.match(MARKUP_TAG_NAME_RE);
     return tagMatch?.[1] ? {
       closing,
       end,
-      selfClosing: /\/\s*>$/.test(raw),
+      selfClosing: SELF_CLOSING_END_RE$1.test(raw),
       tag: tagMatch[1].toLowerCase()
     } : {
       closing: !1,
@@ -27277,7 +28319,7 @@ function findNextHtmlBlockFromSource(source, tag, startIndex) {
       tag: ""
     };
   }, findRawTextClose = (rawTextTag, from) => {
-    let closeRe = new RegExp(String.raw`<\s*\/\s*${escapeTagForRegExp(rawTextTag)}(?=\s|>)`, "gi");
+    let closeRe = getCachedRegex(String.raw`<\s*\/\s*${escapeTagForRegExp(rawTextTag)}(?=\s|>)`, "gi");
     closeRe.lastIndex = from;
     let match = closeRe.exec(source);
     if (!match || match.index == null)
@@ -27308,7 +28350,7 @@ function findNextHtmlBlockFromSource(source, tag, startIndex) {
   if (start === -1 || openEnd === -1)
     return null;
   let openTag = source.slice(start, openEnd + 1);
-  if (VOID_HTML_TAGS.has(lowerTag) || /\/\s*>$/.test(openTag))
+  if (VOID_HTML_TAGS.has(lowerTag) || SELF_CLOSING_END_RE$1.test(openTag))
     return {
       raw: openTag,
       start,
@@ -27412,13 +28454,14 @@ function extendHtmlBlockCloseToLineEnding(source, startIndex) {
 ` ? end + 1 : startIndex;
 }
 function findLastClosingTagStart(raw, tag) {
-  let closeRe = new RegExp(String.raw`<\s*\/\s*${escapeTagForRegExp(tag)}(?=\s|>)`, "gi"), last = -1, match;
+  let closeRe = getCachedRegex(String.raw`<\s*\/\s*${escapeTagForRegExp(tag)}(?=\s|>)`, "gi"), last = -1, match;
   for (; (match = closeRe.exec(raw)) !== null; )
     last = match.index;
   return last;
 }
+var NON_ELEMENT_HTML_BLOCK_START_RE = /^\s*(?:<!--|<!|<\?)/, FIRST_TAG_NAME_RE = /^\s*<([A-Z][\w:-]*)/i, SELF_CLOSING_END_RE = /\/\s*>$/, TRAILING_UNCLOSED_TAG_RE = /<[^>]*$/;
 function findMatchingCloseTagEnd(rawHtml, tag, startIndex) {
-  let lowerTag = tag.toLowerCase(), openTagRe = new RegExp(String.raw`^<\s*${lowerTag}(?=\s|>|/)`, "i"), closeTagRe = new RegExp(String.raw`^<\s*\/\s*${lowerTag}(?=\s|>)`, "i"), depth = 0, index = Math.max(0, startIndex);
+  let lowerTag = tag.toLowerCase(), openTagRe = getCachedRegex(String.raw`^<\s*${lowerTag}(?=\s|>|/)`, "i"), closeTagRe = getCachedRegex(String.raw`^<\s*\/\s*${lowerTag}(?=\s|>)`, "i"), depth = 0, index = Math.max(0, startIndex);
   for (; index < rawHtml.length; ) {
     let lt = rawHtml.indexOf("<", index);
     if (lt === -1)
@@ -27438,7 +28481,7 @@ function findMatchingCloseTagEnd(rawHtml, tag, startIndex) {
       if (endRel === -1)
         return -1;
       let rawTag = slice.slice(0, endRel + 1);
-      /\/\s*>$/.test(rawTag) || depth++, index = lt + endRel + 1;
+      SELF_CLOSING_END_RE.test(rawTag) || depth++, index = lt + endRel + 1;
       continue;
     }
     index = lt + 1;
@@ -27447,7 +28490,7 @@ function findMatchingCloseTagEnd(rawHtml, tag, startIndex) {
 }
 function parseHtmlBlock(token) {
   let raw = String(token.content ?? "");
-  if (/^\s*<!--/.test(raw) || /^\s*<!/.test(raw) || /^\s*<\?/.test(raw))
+  if (NON_ELEMENT_HTML_BLOCK_START_RE.test(raw))
     return {
       type: "html_block",
       content: raw,
@@ -27455,7 +28498,7 @@ function parseHtmlBlock(token) {
       tag: "",
       loading: !1
     };
-  let tag = (raw.match(/^\s*<([A-Z][\w:-]*)/i)?.[1] || "").toLowerCase();
+  let tag = (raw.match(FIRST_TAG_NAME_RE)?.[1] || "").toLowerCase();
   if (!tag)
     return {
       type: "html_block",
@@ -27464,10 +28507,10 @@ function parseHtmlBlock(token) {
       tag: "",
       loading: !1
     };
-  let openEnd = findTagCloseIndexOutsideQuotes(raw), openTag = openEnd === -1 ? raw : raw.slice(0, openEnd + 1), selfClosing = openEnd !== -1 && /\/\s*>$/.test(openTag), isVoid = VOID_HTML_TAGS.has(tag), attrs = parseTagAttrs(openTag), hasClosing = (openEnd === -1 ? -1 : findMatchingCloseTagEnd(raw, tag, openEnd + 1)) !== -1, loading = !(isVoid || selfClosing || hasClosing);
+  let openEnd = findTagCloseIndexOutsideQuotes(raw), openTag = openEnd === -1 ? raw : raw.slice(0, openEnd + 1), selfClosing = openEnd !== -1 && SELF_CLOSING_END_RE.test(openTag), isVoid = VOID_HTML_TAGS.has(tag), attrs = parseTagAttrs(openTag), hasClosing = (openEnd === -1 ? -1 : findMatchingCloseTagEnd(raw, tag, openEnd + 1)) !== -1, loading = !(isVoid || selfClosing || hasClosing);
   return {
     type: "html_block",
-    content: loading ? `${raw.replace(/<[^>]*$/, "")}
+    content: loading ? `${raw.replace(TRAILING_UNCLOSED_TAG_RE, "")}
 </${tag}>` : raw,
     raw,
     tag,
@@ -27537,7 +28580,7 @@ function applyNodeSourceMapRange(node, token, endLine, options) {
 }
 function cloneTokenWithMutableChildren(token) {
   let copy = Object.assign(Object.create(Object.getPrototypeOf(token)), token);
-  return Array.isArray(token.attrs) && (copy.attrs = token.attrs.map((attr) => [...attr])), Array.isArray(token.map) && (copy.map = [...token.map]), Array.isArray(token.children) && (copy.children = token.children.map((child) => cloneTokenWithMutableChildren(child))), copy;
+  return Array.isArray(token.attrs) && (copy.attrs = token.attrs.map((attr) => [...attr])), Array.isArray(token.map) && (copy.map = [...token.map]), Array.isArray(token.children) && (copy.children = token.children.map((child) => cloneTokenWithMutableChildren(child))), copySyntheticLinkOrigin(token, copy), copy;
 }
 function isPlainObject(value) {
   if (!value || typeof value != "object")
@@ -27628,6 +28671,10 @@ function canCloneMarkdownTokenFast(token, enumerableKeys) {
   return !0;
 }
 function cloneMarkdownToken(token, cloneObjectFields = !0) {
+  let cloned = cloneMarkdownTokenValue(token, cloneObjectFields);
+  return copySyntheticLinkOrigin(token, cloned), cloned;
+}
+function cloneMarkdownTokenValue(token, cloneObjectFields = !0) {
   if (!cloneObjectFields)
     return cloneTokenWithMutableChildren(token);
   let allKeys = Reflect.ownKeys(token), enumerableKeys = Object.keys(token);
@@ -27821,12 +28868,16 @@ function createExplicitBracketMathContext() {
 function cloneExplicitBracketMathContext(context) {
   return { ...context };
 }
-function setTolerantMathBoundaryStreamCache(runtime, source, key, explicitBracketMath = scanExplicitBracketMathStreamState(source).state) {
+function setTolerantMathBoundaryStreamCache(runtime, source, key, explicitBracketMath = scanExplicitBracketMathStreamState(source).state, scanWindow = {
+  lineOffset: 0,
+  windowStart: 0
+}) {
   runtime.tolerantMathBoundary = {
     explicitBracketMath,
     source,
     key,
-    pendingCandidate: key === null && mayContainTolerantMathBlockBoundaryOpener(source)
+    pendingCandidate: key === null && mayContainTolerantMathBlockBoundaryOpener(source, scanWindow),
+    scanWindow
   };
 }
 function sourceEndsWithSplitTolerantBoundaryPrefix(source) {
@@ -28075,7 +29126,7 @@ function stripPendingExplicitMathTail(markdown, runtime, useCache = !0) {
   let md = runtime.markdownIt;
   if (!hasMarkstreamMathPlugin(md))
     return markdown;
-  let previous = useCache ? runtime.pendingExplicitMathTail : void 0, state = previous?.source === markdown ? previous.state : previous && markdown.startsWith(previous.source) ? updateExplicitBracketMathStreamState(previous.state, markdown.slice(previous.source.length), previous.source.length - previous.state.lineBuffer.length).state : scanExplicitBracketMathStreamState(markdown).state;
+  let previous = useCache ? runtime.pendingExplicitMathTail : void 0, state = previous?.source === markdown ? previous.state : previous && runtime.sourceExtends(previous.source, markdown) ? updateExplicitBracketMathStreamState(previous.state, markdown.slice(previous.source.length), previous.source.length - previous.state.lineBuffer.length).state : scanExplicitBracketMathStreamState(markdown).state;
   useCache && (runtime.pendingExplicitMathTail = {
     source: markdown,
     state
@@ -28135,13 +29186,16 @@ function syncTolerantMathBoundaryStreamCache(runtime, source) {
   let previous = runtime.tolerantMathBoundary;
   if (previous?.source === source)
     return;
-  let sourceExtendsPrevious = previous ? source.startsWith(previous.source) : !1, appended = sourceExtendsPrevious && previous ? source.slice(previous.source.length) : "", explicitBracketMathUpdate = sourceExtendsPrevious && previous ? updateExplicitBracketMathStreamState(previous.explicitBracketMath, appended, previous.source.length - previous.explicitBracketMath.lineBuffer.length) : scanExplicitBracketMathStreamState(source), nextExplicitBracketMath = explicitBracketMathUpdate.state, completesExplicitBracketMathClose = sourceExtendsPrevious && previous ? explicitBracketMathUpdate.closedOpenMath : !1;
+  let sourceExtendsPrevious = previous ? runtime.sourceExtends(previous.source, source) : !1, appended = sourceExtendsPrevious && previous ? source.slice(previous.source.length) : "", explicitBracketMathUpdate = sourceExtendsPrevious && previous ? updateExplicitBracketMathStreamState(previous.explicitBracketMath, appended, previous.source.length - previous.explicitBracketMath.lineBuffer.length) : scanExplicitBracketMathStreamState(source), nextExplicitBracketMath = explicitBracketMathUpdate.state, completesExplicitBracketMathClose = sourceExtendsPrevious && previous ? explicitBracketMathUpdate.closedOpenMath : !1;
   if (previous && sourceExtendsPrevious && previous.key === null && previous.pendingCandidate === !1 && !completesExplicitBracketMathClose && !appendedChunkMayAffectTolerantMathBoundary(previous.source, appended) && !sourceEndsWithSplitTolerantBoundaryPrefix(source)) {
     previous.source = source, previous.explicitBracketMath = nextExplicitBracketMath;
     return;
   }
-  let nextKey = getTolerantMathBlockBoundaryStreamKey(source);
-  (previous && (previous && !sourceExtendsPrevious || previous.key !== nextKey || completesExplicitBracketMathClose) || !previous && nextKey) && runtime.resetStreamOnly(), setTolerantMathBoundaryStreamCache(runtime, source, nextKey, nextExplicitBracketMath);
+  let scanWindow = sourceExtendsPrevious && previous ? previous.scanWindow : {
+    lineOffset: 0,
+    windowStart: 0
+  }, nextKey = getTolerantMathBlockBoundaryStreamKey(source, scanWindow);
+  (previous && (previous && !sourceExtendsPrevious || previous.key !== nextKey || completesExplicitBracketMathClose) || !previous && nextKey) && runtime.resetStreamOnly(), setTolerantMathBoundaryStreamCache(runtime, source, nextKey, nextExplicitBracketMath, scanWindow);
 }
 function shouldUseSyncParseForPendingTolerantMathBoundary(runtime) {
   let cache = runtime.tolerantMathBoundary;
@@ -28309,6 +29363,7 @@ var REUSABLE_INLINE_TOKEN_TYPES = /* @__PURE__ */ new Set([
   "code_block",
   "fence",
   "hr",
+  "html_block",
   "inline",
   "math_block"
 ]);
@@ -28411,7 +29466,7 @@ function sameTokenAttrs(left, right) {
 function isSameTokenShapeForReuse(left, right) {
   return !!left && !!right && left.type === right.type && left.tag === right.tag && left.nesting === right.nesting && left.level === right.level && left.markup === right.markup && left.content === right.content && left.info === right.info && sameTokenMap(left, right) && sameTokenAttrs(left, right);
 }
-function updateStructuredStreamCache(runtime, source, tokens, groups, nodes, options, previousSeed) {
+function updateStructuredStreamCache(runtime, source, tokens, groups, nodes, options, linkifyDemotionContexts, linkifyDemotionContextOffset = 0, fallbackLinkifyDemotionContext) {
   let groupStarts = groups.starts;
   if (groupStarts.length === 0 || nodes.length !== groupStarts.length) {
     runtime.structuredStream = void 0;
@@ -28424,7 +29479,7 @@ function updateStructuredStreamCache(runtime, source, tokens, groups, nodes, opt
       lastToken: tokens[end - 1],
       tokenCount: end - start
     };
-  }), stableGroupCount = groups.mixed ? Math.max(0, groupStarts.length - 1) : sourceEndsWithBlankLine(source) ? groupStarts.length : Math.max(0, groupStarts.length - 1), seed = previousSeed && previousSeed.length >= stableGroupCount ? previousSeed.slice(0, stableGroupCount).concat(nodes.slice(stableGroupCount).map((node) => String(node.raw ?? ""))) : nodes.map((node) => String(node.raw ?? ""));
+  }), stableGroupCount = groups.mixed ? Math.max(0, groupStarts.length - 1) : sourceEndsWithBlankLine(source) ? groupStarts.length : Math.max(0, groupStarts.length - 1), linkifyContextIndex = stableGroupCount - linkifyDemotionContextOffset - 1, linkifyDemotionContext = linkifyContextIndex >= 0 ? linkifyDemotionContexts?.[linkifyContextIndex] : fallbackLinkifyDemotionContext;
   runtime.structuredStream = {
     groupBoundaries,
     groupStarts,
@@ -28433,7 +29488,7 @@ function updateStructuredStreamCache(runtime, source, tokens, groups, nodes, opt
     mixed: groups.mixed,
     source,
     nodes,
-    seed,
+    linkifyDemotionContext,
     stableGroupCount,
     requireClosingStrong: options.requireClosingStrong,
     validateLink: options.validateLink
@@ -28470,18 +29525,18 @@ function processTopLevelTokensWithReuse(runtime, source, tokens, options, callba
   if (!groups)
     return runtime.structuredStream = void 0, callbacks.processTokens(tokens, options);
   let groupStarts = groups.starts, stableGroupCount = previous && groups.mixed ? Math.min(previous.stableGroupCount, Math.max(0, previous.groupBoundaries.length - 1)) : previous?.stableGroupCount ?? 0;
-  if (previous && stableGroupCount > 0 && previous.requireClosingStrong === options.requireClosingStrong && previous.validateLink === options.validateLink && source.startsWith(previous.source) && groupStarts.length >= stableGroupCount && (mode === "append" || mode === "tail") && hasStableStructuredStreamGroupBoundaries(previous, tokens, groupStarts, stableGroupCount)) {
-    let tailStart = groupStarts[stableGroupCount] ?? tokens.length, tailNodes = callbacks.processTokens(tokens.slice(tailStart), {
+  if (previous && stableGroupCount > 0 && previous.requireClosingStrong === options.requireClosingStrong && previous.validateLink === options.validateLink && runtime.sourceExtends(previous.source, source) && groupStarts.length >= stableGroupCount && (mode === "append" || mode === "tail") && hasStableStructuredStreamGroupBoundaries(previous, tokens, groupStarts, stableGroupCount)) {
+    let tailStart = groupStarts[stableGroupCount] ?? tokens.length, tailOptions = {
       ...options,
-      linkifyDemotionSeed: previous.seed.slice(0, stableGroupCount)
-    }), expectedTailNodes = groupStarts.length - stableGroupCount;
+      linkifyDemotionSeedContext: previous.linkifyDemotionContext
+    }, tailNodes = callbacks.processTokens(tokens.slice(tailStart), tailOptions), expectedTailNodes = groupStarts.length - stableGroupCount;
     if (tailNodes.length === expectedTailNodes) {
       let result$1 = previous.nodes.slice(0, stableGroupCount).concat(tailNodes);
-      return runtime.structuredReuseTailStart = stableGroupCount, callbacks.recordReusedTopLevelNodes?.(stableGroupCount), updateStructuredStreamCache(runtime, source, tokens, groups, result$1, options, previous.seed), result$1;
+      return runtime.structuredReuseTailStart = stableGroupCount, callbacks.recordReusedTopLevelNodes?.(stableGroupCount), updateStructuredStreamCache(runtime, source, tokens, groups, result$1, options, tailOptions.linkifyDemotionResultContexts, stableGroupCount, previous.linkifyDemotionContext), result$1;
     }
   }
   let result = callbacks.processTokens(tokens, options);
-  return updateStructuredStreamCache(runtime, source, tokens, groups, result, options), result;
+  return updateStructuredStreamCache(runtime, source, tokens, groups, result, options, options.linkifyDemotionResultContexts), result;
 }
 function isDetailsOpenHtmlBlock(node) {
   if (node.type !== "html_block" || String(node.tag ?? "").toLowerCase() !== "details")
@@ -28566,7 +29621,7 @@ function parseSiblingHtmlBlockChildren(blocks, context, options, final, useCache
     validateLink: options.validateLink
   }), children.flat();
 }
-function structureGenericHtmlBlockChildren(nodes, context, options, final, tailStart = 0) {
+function structureGenericHtmlBlockChildren(nodes, context, options, final) {
   let processNode = (node) => {
     if (node?.type !== "html_block")
       return node;
@@ -28583,12 +29638,9 @@ function structureGenericHtmlBlockChildren(nodes, context, options, final, tailS
     if (!innerRaw.trim() || !hasStructuredHtmlWrapperMarkers(innerRaw))
       return node;
     let childOptions = buildDetailsChildParseOptions(options, final), siblingHtmlBlocks = hasClose ? null : splitSiblingHtmlBlockFragments(innerRaw), useSiblingCache = !options.isFragment && typeof options.preTransformTokens != "function" && typeof options.postTransformTokens != "function" && typeof options.postTransformNodes != "function" && context.markdownIt.__markstreamHasCustomParserExtensions === !1 && isCacheStableLinkValidator(options.validateLink), children = siblingHtmlBlocks ? parseSiblingHtmlBlockChildren(siblingHtmlBlocks, context, childOptions, final, useSiblingCache) : parseDetailsFragmentChildren(innerRaw, context, childOptions);
-    return shouldStructureGenericHtmlBlockChildren(children) ? {
-      ...node,
-      children
-    } : node;
+    return shouldStructureGenericHtmlBlockChildren(children) && (fields.children = children), node;
   };
-  return tailStart <= 0 ? nodes.map(processNode) : nodes.slice(0, tailStart).concat(nodes.slice(tailStart).map(processNode));
+  return nodes.map(processNode);
 }
 function hasTopLevelHtmlBlock(nodes, start = 0) {
   for (let i = start; i < nodes.length; i++)
@@ -28699,12 +29751,18 @@ function combineStructuredDetailsHtmlBlocks(nodes, source, context, options, fin
   }
   return [merged, cursor];
 }
-function mergeSplitTopLevelHtmlBlocks(nodes, final, source, context, options) {
+function findNodeRawPosition(node, nodeRaw, source, cursor, context) {
+  if (!nodeRaw)
+    return -1;
+  let anchor = context.getInternalNodeSourceRange(node)?.start ?? -1, anchored = anchor >= cursor && source.startsWith(nodeRaw, anchor);
+  return node?.type === "html_block" ? anchored && anchor === cursor ? anchor : source.indexOf(nodeRaw, cursor) : anchor < 0 ? source.indexOf(nodeRaw, cursor) : anchored ? anchor : -1;
+}
+function mergeSplitTopLevelHtmlBlocks(nodes, final, source, context, options, initialSourceCursor = 0) {
   if (!source)
     return nodes;
-  let merged = nodes.slice(), sourceHtmlCursor = 0;
+  let merged = nodes.slice(), sourceHtmlCursor = initialSourceCursor;
   for (let i = 0; i < merged.length; i++) {
-    let node = merged[i], nodeRaw = getMergeableNodeRaw(node), nodePos = nodeRaw ? source.indexOf(nodeRaw, sourceHtmlCursor) : -1;
+    let node = merged[i], nodeRaw = getMergeableNodeRaw(node), nodePos = findNodeRawPosition(node, nodeRaw, source, sourceHtmlCursor, context);
     if (node?.type !== "html_block") {
       nodePos !== -1 && (sourceHtmlCursor = nodePos + nodeRaw.length);
       continue;
@@ -28812,7 +29870,7 @@ function parseEmphasisToken(tokens, startIndex, parseInlineTokens$1, options) {
   };
 }
 function TRAILING_OWN_FENCE_CANDIDATE_LINE_RE(marker) {
-  return /* @__PURE__ */ new RegExp(`(?:^|\\r\\n|\\n|\\r) {0,3}${marker}+[ \\t]*$`);
+  return getCachedRegex(`(?:^|\\r\\n|\\n|\\r) {0,3}${marker}+[ \\t]*$`);
 }
 var DIFF_HEADER_PREFIXES = [
   "diff ",
@@ -29094,7 +30152,8 @@ function parseHtmlInlineCodeToken(token, tokens, i, parseInlineTokens$1, raw, pP
       attrs: normalizedAttrs,
       children: normalizedChildren$1,
       loading: !fragment$1.closed,
-      raw: fragment$1.html || code$1
+      raw: fragment$1.html || code$1,
+      markup: "html"
     }, fragment$1.nextIndex];
   }
   if (selfClosing)
@@ -29245,7 +30304,8 @@ function parseLinkToken(tokens, startIndex, parseInlineTokens$1, options) {
       children,
       raw: `[${linkText}](${href}${title ? ` "${title}"` : ""})`,
       loading,
-      attrs: normalizedAttrs
+      attrs: normalizedAttrs,
+      markup: resolveLinkMarkup(openToken)
     },
     nextIndex: i < tokens.length ? i + 1 : tokens.length
   };
@@ -29475,7 +30535,8 @@ function recoverMarkdownLinkFromTrailingText(state, token) {
       content: label,
       raw: label
     }],
-    raw: `[${label}](${href}${linkToken.title ? ` "${linkToken.title}"` : ""})`
+    raw: `[${label}](${href}${linkToken.title ? ` "${linkToken.title}"` : ""})`,
+    markup: resolveLinkMarkup(token)
   }), !0;
 }
 function recoverMarkdownImageFromLoadingImageTail(state, token) {
@@ -29538,7 +30599,8 @@ function buildLoadingOuterImageLinkNode(imageNode, href = "", title = null) {
     text: text$1,
     children: [imageNode],
     raw: `[${text$1}](${href}${title ? ` "${title}"` : ""})`,
-    loading: !0
+    loading: !0,
+    markup: ""
   };
 }
 function buildLoadingImageNodeFromRaw(raw) {
@@ -29662,7 +30724,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading: loading$1
+        loading: loading$1,
+        markup: ""
       }), state.index += index, !0;
     }
     let linkContentEnd = content.indexOf(")", linkEnd), href = linkContentEnd !== -1 ? content.slice(linkEnd + 2, linkContentEnd) : "", loading = linkContentEnd === -1, emphasisMatch = textNodeContent.match(/\*+$/);
@@ -29696,7 +30759,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading
+        loading,
+        markup: ""
       }), type === 1) {
         newTokens.push({
           type: "em_close",
@@ -29740,7 +30804,8 @@ function handleInlineLinkContent(state, content, _token) {
           content: text$1,
           raw: text$1
         }],
-        loading
+        loading,
+        markup: ""
       });
     let afterText = linkContentEnd !== -1 ? content.slice(linkContentEnd + 1) : "";
     return afterText && (state.dispatchToken({
@@ -30351,7 +31416,7 @@ function handleTextToken(state, token) {
   }
   trailingTextStart < state.result.length && (content.startsWith(trailingTextContent) ? (state.currentTextNode = null, state.result.length = trailingTextStart) : state.currentTextNode = state.result[state.result.length - 1]);
   let nextToken = state.tokens[state.index + 1];
-  if ((content === "`" || content === "|" || content === "$") && !hasEscapedMarkup(token, `\\${content}`) || /^\*+$/.test(content) && !hasEscapedMarkup(token, "\\*")) {
+  if (state.options?.final !== !0 && ((content === "`" || content === "|" || content === "$") && !hasEscapedMarkup(token, `\\${content}`) || /^\*+$/.test(content) && !hasEscapedMarkup(token, "\\*"))) {
     state.index++;
     return;
   }
@@ -30551,9 +31616,20 @@ function dispatchInlineToken(state, token) {
 function handleReference(state, token) {
   state.resetCurrentTextNode(), state.pushParsed(parseReferenceToken(token)), state.index++;
 }
+var TEXT_RECOVERY_MARKER_RE = /[!$(*[\\\]_`|~]/;
 function parseInlineTokens(tokens, raw, pPreToken, options) {
   if (!tokens || tokens.length === 0)
     return [];
+  if (tokens.length === 1 && tokens[0].type === "text") {
+    let content = tokens[0].content;
+    if (typeof content == "string" && content && content !== "<" && !content.endsWith("undefined") && !TEXT_RECOVERY_MARKER_RE.test(content))
+      return [{
+        type: "text",
+        content,
+        raw: content,
+        center: !1
+      }];
+  }
   let parseContext = ensureParseContext(options), inheritedContext = parseContext.linkifyDemotionContext, inferredContext = inferLinkifyDemotionContext(raw), linkifyDemotionContext = {
     filename: inheritedContext?.filename || inferredContext.filename,
     explicitFilename: inheritedContext?.explicitFilename || inferredContext.explicitFilename,
@@ -30592,7 +31668,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
   function pushToken(token) {
     resetCurrentTextNode();
     let node = cloneTokenWithMutableChildren(token);
-    state.result.push(node);
+    node.type === "link" && (node.markup = resolveLinkMarkup(token)), state.result.push(node);
   }
   function pushText(content, raw$1) {
     state.currentTextNode ? (state.currentTextNode.content += content, state.currentTextNode.raw += raw$1 ?? content) : (state.currentTextNode = {
@@ -31341,7 +32417,7 @@ function parseBasicBlockToken(tokens, index, options, parseInlineTokens$1) {
         return includeSourceMap && applyNodeSourceMap(paragraphNode, token, options), [paragraphNode, index + 1];
       }
       if (htmlBlockNode.tag && tagSets?.customTagSet?.has(htmlBlockNode.tag)) {
-        let tag = htmlBlockNode.tag, context = isParseContext(options) ? options : void 0, source = String(context?.sourceMarkdown ?? ""), cursor = Number(context?.customHtmlBlockCursor ?? 0), mappedLineStart = Array.isArray(token.map) ? lineToIndex(source, Number(token.map?.[0] ?? 0)) : 0, fromSource = findNextCustomHtmlBlockFromSource(source, tag, Math.max(clampNonNegative(cursor), clampNonNegative(mappedLineStart)));
+        let tag = htmlBlockNode.tag, context = isParseContext(options) ? options : void 0, source = String(context?.sourceMarkdown ?? ""), cursor = Number(context?.customHtmlBlockCursor ?? 0), mappedLine = Number(token.map?.[0] ?? 0), mappedLineStart = Array.isArray(token.map) ? context?.sourceLineOffsets?.[mappedLine] ?? lineToIndex(source, mappedLine) : 0, fromSource = findNextCustomHtmlBlockFromSource(source, tag, Math.max(clampNonNegative(cursor), clampNonNegative(mappedLineStart)));
         fromSource && context && (context.customHtmlBlockCursor = fromSource.end);
         let rawHtml = String(fromSource?.raw ?? htmlBlockNode.raw ?? ""), openEnd = findTagCloseIndexOutsideQuotes(rawHtml), openTag = openEnd !== -1 ? rawHtml.slice(0, openEnd + 1) : rawHtml, selfClosing = openEnd !== -1 && /\/\s*>\s*$/.test(openTag), closeRange = openEnd === -1 ? null : findMatchingCloseTagRange(rawHtml, tag, openEnd + 1), closeIndex = closeRange?.start ?? -1, inner = "";
         openEnd !== -1 && (closeIndex !== -1 && openEnd < closeIndex ? inner = rawHtml.slice(openEnd + 1, closeIndex) : inner = rawHtml.slice(openEnd + 1)), closeIndex === -1 && (inner = stripTrailingPartialClosingTag(inner, tag));
@@ -31521,15 +32597,11 @@ function maybePromoteCustomNodeFromParagraph(node, options) {
 function processTokensWithContext(tokens, options, parseInlineTokens$1) {
   if (!tokens || !Array.isArray(tokens))
     return [];
-  let result = [], linkifyContext = createLinkifyDemotionContextTracker(options), seedRaws = options.linkifyDemotionSeed;
-  if (Array.isArray(seedRaws) && seedRaws.length)
-    for (let raw of seedRaws)
-      linkifyContext.remember(String(raw ?? ""));
-  let includeSourceMap = options?.includeSourceMap === !0, i = 0;
+  let result = [], resultContexts = [], linkifyContext = createLinkifyDemotionContextTracker(options), includeSourceMap = options?.includeSourceMap === !0, i = 0;
   for (; i < tokens.length; ) {
     let handled = parseCommonBlockToken(tokens, i, linkifyContext.options(), containerTokenHandlers, parseInlineTokens$1);
     if (handled) {
-      recordInternalNodeSourceRange(handled[0], tokens[i], options), result.push(handled[0]), linkifyContext.remember(handled[0].raw), i = handled[1];
+      recordInternalNodeSourceRange(handled[0], tokens[i], options), result.push(handled[0]), linkifyContext.remember(handled[0].raw), resultContexts.push(linkifyContext.snapshot()), i = handled[1];
       continue;
     }
     let token = tokens[i];
@@ -31619,42 +32691,52 @@ function processTokensWithContext(tokens, options, parseInlineTokens$1) {
         i += 1;
         break;
     }
+    let context = linkifyContext.snapshot();
+    for (; resultContexts.length < result.length; )
+      resultContexts.push(context);
   }
-  return result;
+  return options.linkifyDemotionResultContexts = resultContexts, result;
 }
 function getCachedSourceLineOffsets(runtime, source) {
   let cached = runtime.sourceLineOffsets;
-  if (cached && cached.source === source)
+  if (cached?.source === source)
     return cached.offsets;
-  if (cached && source.length > cached.source.length && source.startsWith(cached.source)) {
+  if (cached && source.length > cached.source.length && runtime.sourceExtends(cached.source, source)) {
     let offsets$1 = cached.offsets;
     for (let i = cached.source.length; i < source.length; i++)
       source.charCodeAt(i) === 10 && offsets$1.push(i + 1);
     return cached.source = source, offsets$1;
   }
-  let offsets = [0];
-  for (let i = 0; i < source.length; i++)
-    source.charCodeAt(i) === 10 && offsets.push(i + 1);
+  let offsets = computeSourceLineOffsets(source);
   return runtime.sourceLineOffsets = {
     source,
     offsets
   }, offsets;
 }
+function computeSourceLineOffsets(source) {
+  let offsets = [0];
+  for (let i = 0; i < source.length; i++)
+    source.charCodeAt(i) === 10 && offsets.push(i + 1);
+  return offsets;
+}
 var parserRuntimes = /* @__PURE__ */ new WeakMap(), wrappedMarkdownItInstances = /* @__PURE__ */ new WeakSet(), wrappedStreamInstances = /* @__PURE__ */ new WeakSet();
 function sameSemantics(left, right) {
   return left.customHtmlTags === right.customHtmlTags && left.hasCustomParserExtensions === right.hasCustomParserExtensions && left.includeSourceMap === right.includeSourceMap && left.postTransformNodes === right.postTransformNodes && left.postTransformTokens === right.postTransformTokens && left.preTransformTokens === right.preTransformTokens && left.requireClosingStrong === right.requireClosingStrong && left.reuseStableTopLevelNodes === right.reuseStableTopLevelNodes && left.streamParse === right.streamParse && left.validateLink === right.validateLink;
 }
 var ParserRuntime = class {
   constructor(markdownIt$1) {
-    this.streamParseEnvs = /* @__PURE__ */ new Map(), this.detailsStitchCache = /* @__PURE__ */ new WeakMap(), this.nodeSourceRanges = /* @__PURE__ */ new WeakMap(), this.finalized = !1, this.resettingStream = !1, this.streamStateActive = !1, this.streamResetInCurrentRootParse = !1, this.markdownIt = markdownIt$1;
+    this.streamParseEnvs = /* @__PURE__ */ new Map(), this.htmlPassIdentityPreserving = !1, this.detailsStitchCache = /* @__PURE__ */ new WeakMap(), this.nodeSourceRanges = /* @__PURE__ */ new WeakMap(), this.finalized = !1, this.resettingStream = !1, this.streamStateActive = !1, this.streamResetInCurrentRootParse = !1, this.markdownIt = markdownIt$1;
+  }
+  sourceExtends(previousSource, currentSource) {
+    return this.sourceRelationPrevious === previousSource && this.sourceRelationCurrent === currentSource ? !0 : currentSource.startsWith(previousSource) ? (this.sourceRelationPrevious = previousSource, this.sourceRelationCurrent = currentSource, !0) : !1;
   }
   beginRootParse(source, semantics) {
     this.streamResetInCurrentRootParse = !1;
-    let sourceChangedNonAppend = this.documentSource !== void 0 && source !== this.documentSource && !source.startsWith(this.documentSource), semanticsChanged = this.semantics !== void 0 && !sameSemantics(this.semantics, semantics);
+    let sourceChangedNonAppend = this.documentSource !== void 0 && source !== this.documentSource && !this.sourceExtends(this.documentSource, source), semanticsChanged = this.semantics !== void 0 && !sameSemantics(this.semantics, semantics);
     (this.finalized || sourceChangedNonAppend || semanticsChanged) && this.resetDocument(this.streamStateActive), this.finalized = !1, this.documentSource = source, this.semantics = semantics;
   }
   finishRootParse(final) {
-    final && (this.clearDocumentCaches(), this.documentSource = void 0, this.semantics = void 0, this.finalized = !0);
+    this.sourceRelationPrevious = void 0, this.sourceRelationCurrent = void 0, final && (this.clearDocumentCaches(), this.documentSource = void 0, this.semantics = void 0, this.finalized = !0);
   }
   resetForFinalAutoParse() {
     this.streamResetInCurrentRootParse || this.resetStreamOnly(), this.clearDocumentCaches();
@@ -31689,7 +32771,7 @@ var ParserRuntime = class {
     this.resetDocument(!0), parserRuntimes.delete(this.markdownIt);
   }
   clearDocumentCaches() {
-    this.safeMarkdown = void 0, this.tolerantMathBoundary = void 0, this.pendingExplicitMathTail = void 0, this.streamParseEnvs.clear(), this.topLevelStreamParseMode = void 0, this.structuredStream = void 0, this.siblingHtmlChildren = void 0, this.detailsStitchCache = /* @__PURE__ */ new WeakMap(), this.nodeSourceRanges = /* @__PURE__ */ new WeakMap(), this.sourceLineOffsets = void 0;
+    this.safeMarkdown = void 0, this.tolerantMathBoundary = void 0, this.pendingExplicitMathTail = void 0, this.streamParseEnvs.clear(), this.topLevelStreamParseMode = void 0, this.structuredStream = void 0, this.htmlPassIdentityPreserving = !1, this.siblingHtmlChildren = void 0, this.detailsStitchCache = /* @__PURE__ */ new WeakMap(), this.nodeSourceRanges = /* @__PURE__ */ new WeakMap(), this.sourceLineOffsets = void 0, this.sourceRelationPrevious = void 0, this.sourceRelationCurrent = void 0;
   }
 };
 function wrapMarkdownItBoundaries(md) {
@@ -31828,6 +32910,11 @@ function createSourceLineMapper(source, parsedSource) {
     };
   };
 }
+var closingTagBlankLineReCache = /* @__PURE__ */ new Map();
+function getClosingTagBlankLineRe(tag) {
+  let re = closingTagBlankLineReCache.get(tag);
+  return re || (re = new RegExp(String.raw`(^[\t ]*<\s*\/\s*${tag}\s*>[\t ]*)(\r?\n)(?![\t ]*\r?\n|$)`, "gim"), closingTagBlankLineReCache.size >= 64 && closingTagBlankLineReCache.clear(), closingTagBlankLineReCache.set(tag, re)), re;
+}
 function stripDanglingHtmlLikeTail(markdown) {
   let isWs = (ch) => ch === " " || ch === "	" || ch === `
 ` || ch === "\r", isLikelyHtmlTagPrefix = (tail$1) => {
@@ -31888,8 +32975,8 @@ function stripDanglingHtmlLikeTail(markdown) {
       }
     }
     return !0;
-  }, isInsideFencedCodeBlock = (src, pos) => isInsideOpenMarkdownFenceBeforeOffset(src, pos), s = String(markdown ?? ""), lastLt = s.lastIndexOf("<");
-  if (lastLt === -1 || isInsideFencedCodeBlock(s, lastLt))
+  }, s = String(markdown ?? ""), lastLt = s.lastIndexOf("<");
+  if (lastLt === -1)
     return s;
   if (lastLt > 0) {
     let prev = s[lastLt - 1], prevIsWs = prev === " " || prev === "	" || prev === `
@@ -31899,7 +32986,7 @@ function stripDanglingHtmlLikeTail(markdown) {
   }
   let tail = s.slice(lastLt);
   return tail.includes(">") || tail.length > 1 && (tail[1] === " " || tail[1] === "	" || tail[1] === `
-` || tail[1] === "\r") || !isLikelyHtmlTagPrefix(tail) ? s : s.slice(0, lastLt);
+` || tail[1] === "\r") || !isLikelyHtmlTagPrefix(tail) || isInsideOpenMarkdownFenceBeforeOffset(s, lastLt) ? s : s.slice(0, lastLt);
 }
 function ensureBlankLineBeforeInlineMultilineCustomHtmlBlocks(markdown, tags) {
   if (!markdown || !tags.length)
@@ -32445,10 +33532,8 @@ function normalizeStreamingCustomHtmlSource(markdown, customHtmlTags, isFinal) {
   if (customHtmlTags?.length && safeMarkdown.includes("<")) {
     let tags = normalizeCustomHtmlTags(customHtmlTags);
     if (tags.length && (safeMarkdown = ensureBlankLineBeforeInlineMultilineCustomHtmlBlocks(safeMarkdown, tags), safeMarkdown = normalizeCustomHtmlOpeningTagSameLine(safeMarkdown, tags), safeMarkdown = ensureBlankLineBeforeCustomHtmlBlocks(safeMarkdown, tags), safeMarkdown = ensureBlankLineAfterCustomHtmlCloseBeforeBlockMarkerSameLine(safeMarkdown, tags), safeMarkdown.includes("</")))
-      for (let tag of tags) {
-        let re = new RegExp(String.raw`(^[\t ]*<\s*\/\s*${tag}\s*>[\t ]*)(\r?\n)(?![\t ]*\r?\n|$)`, "gim");
-        safeMarkdown = safeMarkdown.replace(re, "$1$2$2");
-      }
+      for (let tag of tags)
+        safeMarkdown = safeMarkdown.replace(getClosingTagBlankLineRe(tag), "$1$2$2");
   }
   return isFinal || (safeMarkdown = stripDanglingHtmlLikeTail(safeMarkdown)), safeMarkdown;
 }
@@ -32475,7 +33560,7 @@ function transformStreamingSafeMarkdown(source, isFinal, options) {
 }
 function getSafeMarkdown(runtime, sourceMarkdown, isFinal, options) {
   let mode = `${isFinal ? "final" : "stream"}:${(options.customHtmlTags ?? []).join(",")}`, previous = options.isFragment ? void 0 : runtime.safeMarkdown, safeMarkdown;
-  if (!isFinal && !options.customHtmlTags?.length && previous && previous.mode === mode && sourceMarkdown.length >= previous.source.length && sourceMarkdown.startsWith(previous.source)) {
+  if (!isFinal && !options.customHtmlTags?.length && previous && previous.mode === mode && sourceMarkdown.length >= previous.source.length && runtime.sourceExtends(previous.source, sourceMarkdown)) {
     let windowStart = Math.max(0, previous.source.length - SAFE_MARKDOWN_WINDOW_MARGIN - SAFE_MARKDOWN_WINDOW_OVERLAP), transformed = transformStreamingSafeMarkdown(sourceMarkdown.slice(windowStart), isFinal, options), overlapLength = previous.source.length - windowStart;
     safeMarkdown = transformed.length >= overlapLength && transformed.slice(0, overlapLength) === previous.safeMarkdown.slice(-overlapLength) ? previous.safeMarkdown.slice(0, previous.safeMarkdown.length - overlapLength) + transformed : transformStreamingSafeMarkdown(sourceMarkdown, isFinal, options);
   } else
@@ -32546,7 +33631,7 @@ function parseMarkdownWithContext(markdown, inputContext) {
     ...options,
     sourceLineMapper: options.includeSourceMap === !0 ? createSourceLineMapper(sourceMarkdown, safeMarkdown) : void 0,
     sourceMarkdown: safeMarkdown,
-    sourceLineOffsets: getCachedSourceLineOffsets(runtime, safeMarkdown),
+    sourceLineOffsets: options.isFragment ? computeSourceLineOffsets(safeMarkdown) : getCachedSourceLineOffsets(runtime, safeMarkdown),
     customHtmlBlockCursor: 0
   }, result = processTopLevelTokensWithReuse(runtime, safeMarkdown, transformedTokens, internalOptions, {
     processTokens: (nextTokens, nextOptions) => processTokensWithTiming(nextTokens, nextOptions, timing),
@@ -32568,9 +33653,18 @@ function parseMarkdownWithContext(markdown, inputContext) {
       getInternalNodeSourceRange: (node) => getInternalNodeSourceRange(node, runtime),
       markdownIt: md,
       parseFragment: (fragment, fragmentOptions) => parseMarkdownWithContext(fragment, fragmentOptions)
-    };
-    result = mergeSplitTopLevelHtmlBlocks(result, isFinal, safeMarkdown, htmlStructureContext, internalOptions), result = combineStructuredDetailsHtmlBlocks(result, safeMarkdown, htmlStructureContext, internalOptions, isFinal)[0], result = structureGenericHtmlBlockChildren(result, htmlStructureContext, internalOptions, isFinal, tailStart), timing && addTiming(timing, "htmlBlockPassesMs", getParserNow() - htmlPassesStartedAt);
-  }
+    }, canReuseHtmlPrefix = tailStart > 0 && runtime.htmlPassIdentityPreserving, tailSourceStart = canReuseHtmlPrefix ? getInternalNodeSourceRange(result[tailStart], runtime)?.start : void 0, hasDetailsInput = !1;
+    for (let i = canReuseHtmlPrefix ? tailStart : 0; i < result.length; i++) {
+      let node = result[i];
+      if (node.type === "html_block" && String(node.tag ?? "").toLowerCase() === "details") {
+        hasDetailsInput = !0;
+        break;
+      }
+    }
+    let useHtmlTail = canReuseHtmlPrefix && !hasDetailsInput && tailSourceStart != null, prefix = useHtmlTail ? result.slice(0, tailStart) : [], htmlInput = useHtmlTail ? result.slice(tailStart) : result, htmlSourceStart = useHtmlTail ? tailSourceStart : 0, htmlResult = mergeSplitTopLevelHtmlBlocks(htmlInput, isFinal, safeMarkdown, htmlStructureContext, internalOptions, htmlSourceStart), mergeIdentityPreserving = htmlResult.length === htmlInput.length && htmlResult.every((node, index) => node === htmlInput[index]);
+    hasDetailsInput && (htmlResult = combineStructuredDetailsHtmlBlocks(htmlResult, safeMarkdown, htmlStructureContext, internalOptions, isFinal, htmlSourceStart)[0]), htmlResult = structureGenericHtmlBlockChildren(htmlResult, htmlStructureContext, internalOptions, isFinal), result = useHtmlTail ? prefix.concat(htmlResult) : htmlResult, runtime.htmlPassIdentityPreserving = !hasDetailsInput && mergeIdentityPreserving, timing && addTiming(timing, "htmlBlockPassesMs", getParserNow() - htmlPassesStartedAt);
+  } else
+    runtime.htmlPassIdentityPreserving = !0;
   return isFinal && finalizeHtmlBlockLoading(result), result = applyPostTransformNodes(result, options), options.debug && console.log("Parsed Markdown Tree Structure:", result), finishTimedParse(result, timing, parseStartedAt);
 }
 function parseMarkdownToStructure(markdown, md, options = {}) {
@@ -32708,11 +33802,13 @@ function getMarkdown(msgId = `editor-${Date.now()}`, options = {}) {
   md.use(applyInlinePairs), md.use(sup_plugin), md.use(ins_plugin$1);
   let checkboxModule = import_markdown_it_task_checkbox, markdownItCheckboxPlugin = checkboxModule.default ?? checkboxModule;
   md.use(markdownItCheckboxPlugin), md.use(ins_plugin), md.use(footnote_plugin), md.core.ruler.after("block", "mark_fence_closed", (state) => {
-    let s = state, src = s.src, envFinal = !!s.env?.__markstreamFinal, lines = src.split(/\r?\n/);
+    let s = state, src = s.src, envFinal = !!s.env?.__markstreamFinal, lines;
     for (let token of s.tokens) {
       if (token.type !== "fence" || !token.map || !token.markup)
         continue;
-      let openLine = token.map[0], endLine = token.map[1], markup = token.markup, marker = markup[0], minLen = markup.length, line = lines[Math.max(0, endLine - 1)] ?? "", i = 0;
+      let openLine = token.map[0], endLine = token.map[1], markup = token.markup, marker = markup[0], minLen = markup.length, lineIdx = Math.max(0, endLine - 1);
+      lines ?? (lines = src.split(/\r?\n/));
+      let line = lines[lineIdx] ?? "", i = 0;
       for (; i < line.length && (line[i] === " " || line[i] === "	"); )
         i++;
       let count = 0;
@@ -34981,7 +36077,11 @@ var TVirtualMarkdown = (0, import_vue33.defineComponent)({
       return withTextWidthProvider(
         widthProvider,
         () => terminalSelectionRowSpans(range, cols, rows.value.length).map((span) => {
-          let text2 = sliceByCellsRange(rows.value[span.y]?.plainText ?? "", span.x0, span.x1);
+          let text2 = sliceByCellsRangeForSelection(
+            rows.value[span.y]?.plainText ?? "",
+            span.x0,
+            span.x1
+          );
           return span.x1 >= cols ? text2.trimEnd() : text2;
         }).join(`
 `)