@simon_he/vue-tui 1.1.12 → 1.1.13

package/dist/markdown.cjs

@@ -853,6 +853,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("");
+}
 var textWidthCache = /* @__PURE__ */ new Map(), MAX_TEXT_WIDTH_CACHE = 1024;
 function textWidthCacheGet(text2) {
   let cached = textWidthCache.get(text2);
@@ -1279,7 +1292,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.19/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) => {
@@ -4606,6 +4619,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);
 }
@@ -4631,55 +4668,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--;
-          continue;
-        }
-        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)
+      }
+      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 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;
+        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 (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) {
@@ -4855,7 +4894,7 @@ function process_inlines(tokens, state) {
               nextChar = tokens[j].content.charCodeAt(0);
               break;
             }
-        let isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar)), isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar)), isLastWhiteSpace = isWhiteSpace(lastChar), isNextWhiteSpace = isWhiteSpace(nextChar);
+        let isLastPunctChar = isPunctCode(lastChar), isNextPunctChar = isPunctCode(nextChar), isLastWhiteSpace = isWhiteSpace(lastChar), isNextWhiteSpace = isWhiteSpace(nextChar);
         if (isNextWhiteSpace ? canOpen = !1 : isNextPunctChar && (isLastWhiteSpace || isLastPunctChar || (canOpen = !1)), isLastWhiteSpace ? canClose = !1 : isLastPunctChar && (isNextWhiteSpace || isNextPunctChar || (canClose = !1)), nextChar === 34 && t[0] === '"' && lastChar >= 48 && lastChar <= 57 && (canClose = canOpen = !1), canOpen && canClose && (canOpen = isLastPunctChar, canClose = isNextPunctChar), !canOpen && !canClose) {
           isSingle && (token.content = replaceAt(token.content, t.index, APOSTROPHE));
           continue;
@@ -4910,28 +4949,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) {
@@ -8330,6 +8371,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; ) {
@@ -8472,9 +8544,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);
@@ -8497,19 +8569,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",
@@ -8525,26 +8624,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",
@@ -8557,21 +8658,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}`,
@@ -8579,23 +8680,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);
@@ -8670,11 +8771,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",
@@ -8682,7 +8788,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",
@@ -8699,26 +8805,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",
@@ -8744,11 +8852,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",
@@ -8756,12 +8863,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",
@@ -8769,12 +8877,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) {
@@ -8782,8 +8894,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)
@@ -8800,47 +8912,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;
     }
-    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;
+    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;
+    }
+    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")
@@ -8871,6 +9005,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;
@@ -8897,6 +9032,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;
   }
@@ -8906,16 +9045,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;
   }
@@ -9002,15 +9137,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)
@@ -9018,10 +9164,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;
@@ -9039,7 +9185,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;
@@ -9051,12 +9197,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);
   }
@@ -9083,7 +9255,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)
@@ -9116,8 +9288,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;
@@ -9135,10 +9308,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,
@@ -9148,8 +9321,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;
@@ -9173,10 +9347,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);
@@ -9283,7 +9457,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;
     }
@@ -9303,9 +9477,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;
@@ -9692,9 +9898,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() : [];
     },
@@ -10247,9 +10469,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++;
@@ -11120,7 +11342,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",
@@ -11240,15 +11462,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;
 }
@@ -11296,7 +11518,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)));
@@ -11307,6 +11529,9 @@ function createLinkifyDemotionContextTracker(options, sticky = !1) {
     },
     reset() {
       context = void 0;
+    },
+    snapshot() {
+      return context;
     }
   };
 }
@@ -11343,11 +11568,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] ?? "");
@@ -11852,7 +12077,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") {
@@ -11864,7 +12089,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));
   }
@@ -12173,36 +12398,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;
@@ -12693,27 +12917,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 = [["$$", "$$"], ["\\[", "\\]"]];
@@ -12727,11 +12960,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 = [["$$", "$$"], ["\\[", "\\]"]];
@@ -13225,7 +13458,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;
@@ -13251,13 +13484,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 }));
   });
@@ -13314,7 +13567,17 @@ function factory(opts = {}) {
     ...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)
@@ -13322,7 +13585,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",
@@ -13342,7 +13605,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",
@@ -13373,11 +13636,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,
@@ -13386,11 +13649,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,
@@ -13399,7 +13662,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)
@@ -13430,7 +13693,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,
@@ -13534,13 +13797,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)
@@ -13560,7 +13824,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;
@@ -13569,7 +13833,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,
@@ -13577,7 +13841,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",
@@ -13586,10 +13850,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,
@@ -13943,12 +14207,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) {
@@ -14197,7 +14465,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
@@ -14257,13 +14525,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;
@@ -14431,6 +14702,7 @@ var REUSABLE_INLINE_TOKEN_TYPES = /* @__PURE__ */ new Set([
   "code_block",
   "fence",
   "hr",
+  "html_block",
   "inline",
   "math_block"
 ]);
@@ -14533,7 +14805,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;
@@ -14546,7 +14818,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,
@@ -14555,7 +14827,7 @@ function updateStructuredStreamCache(runtime, source, tokens, groups, nodes, opt
     mixed: groups.mixed,
     source,
     nodes,
-    seed,
+    linkifyDemotionContext,
     stableGroupCount,
     requireClosingStrong: options.requireClosingStrong,
     validateLink: options.validateLink
@@ -14592,18 +14864,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")
@@ -14688,7 +14960,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;
@@ -14705,12 +14977,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++)
@@ -14821,12 +15090,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;
@@ -14934,7 +15209,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 ",
@@ -16473,7 +16748,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;
   }
@@ -16673,9 +16948,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,
@@ -17463,7 +17749,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));
@@ -17643,15 +17929,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];
@@ -17741,42 +18023,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();
@@ -17811,7 +18103,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) {
@@ -17950,6 +18242,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) => {
@@ -18010,8 +18307,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 === `
@@ -18021,7 +18318,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)
@@ -18567,10 +18864,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;
 }
@@ -18597,7 +18892,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
@@ -18668,7 +18963,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),
@@ -18690,9 +18985,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 = {}) {
@@ -18830,11 +19134,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;
@@ -21777,7 +22083,11 @@ var TVirtualMarkdown = (0, import_vue10.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(`
 `)