@simon_he/vue-tui 1.1.5 → 1.1.6

package/dist/markdown.cjs

@@ -1279,7 +1279,7 @@ function loadBuiltinMathRasterizer() {
   })()), builtinRasterizerLoad;
 }
 
-// node_modules/.pnpm/stream-markdown-parser@1.1.9/node_modules/stream-markdown-parser/dist/index.js
+// node_modules/.pnpm/stream-markdown-parser@1.2.3/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) => {
@@ -11183,7 +11183,23 @@ function shouldDemoteFilenameLikeLinkify(linkText, context = {}) {
   let extension = String(extensionMatch[1] ?? "").toLowerCase();
   return isMarketTickerLikeText(linkText, extension, context.marketTicker === !0) ? !0 : FILENAMEISH_LINK_EXTENSIONS.has(extension) ? !AMBIGUOUS_BARE_DOMAIN_EXTENSIONS.has(extension) || context.filename ? !0 : hasStrongFilenameSignals(linkText) : !!(context.explicitFilename && EXPLICIT_FILENAME_CONTEXT_ONLY_EXTENSIONS.has(extension) || context.filename && FILENAME_CONTEXT_ONLY_EXTENSIONS.has(extension));
 }
+var syntheticLinkOrigins = /* @__PURE__ */ new WeakMap(), cacheStableLinkValidators = /* @__PURE__ */ new WeakSet();
+function setSyntheticLinkOrigin(token, origin) {
+  return syntheticLinkOrigins.set(token, origin), token;
+}
+function readSyntheticLinkOrigin(token) {
+  return syntheticLinkOrigins.get(token);
+}
+function registerCacheStableLinkValidator(validateLink$1) {
+  cacheStableLinkValidators.add(validateLink$1);
+}
+function isCacheStableLinkValidator(validateLink$1) {
+  return validateLink$1 === void 0 || cacheStableLinkValidators.has(validateLink$1);
+}
 var LINKIFY_HARD_STOP_CHARS = ["\uFF01"];
+function getSyntheticLinkOrigin(markup) {
+  return markup === "linkify" || markup === "autolink" ? markup : "recovery";
+}
 function textToken(content) {
   return {
     type: "text",
@@ -11229,13 +11245,13 @@ function pushEmClose(arr, type) {
     nesting: -1
   }));
 }
-function createLinkToken(text$1, href, loading) {
+function createLinkToken(text$1, href, loading, origin = "recovery") {
   let title = "";
   if (href.includes('"')) {
     let temps = href.split('"');
     href = temps[0].trim(), title = temps[1].trim();
   }
-  return {
+  return setSyntheticLinkOrigin({
     type: "link",
     loading,
     href,
@@ -11247,7 +11263,7 @@ function createLinkToken(text$1, href, loading) {
       raw: text$1
     }],
     raw: `[${text$1}](${href})`
-  };
+  }, origin);
 }
 function appendToLinkToken(link$1, suffix) {
   if (!(!link$1 || !suffix) && (link$1.href = String(link$1.href ?? "") + suffix, link$1.text = String(link$1.text ?? "") + suffix, link$1.raw = `[${link$1.text}](${link$1.href})`, Array.isArray(link$1.children) && link$1.children.length)) {
@@ -11411,13 +11427,13 @@ function fixLinkToken(tokens, raw) {
       } else if (curToken?.type === "text" && curToken.content?.endsWith("(") && tokens[i + 1]?.type === "link_open") {
         let match = curToken.content.match(/\[([^\]]+)\]/);
         if (match) {
-          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), replacerTokens = [];
+          let beforeText = curToken.content.slice(0, match.index), emphasisMatch = beforeText.match(/(\*+)$/), origin = getSyntheticLinkOrigin(tokens[i + 1]?.markup), replacerTokens = [];
           if (emphasisMatch) {
             beforeText = beforeText.slice(0, emphasisMatch.index), beforeText && replacerTokens.push(textToken(beforeText));
             let text$1 = match[1], type = emphasisMatch[1].length;
             pushEmOpen(replacerTokens, type);
             let href = tokens[i + 2]?.content || "";
-            if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), replacerTokens.push(createLinkToken(text$1, href, !tokens[i + 4]?.content?.startsWith(")"))), pushEmClose(replacerTokens, type), tokens[i + 4]?.type === "text") {
+            if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), replacerTokens.push(createLinkToken(text$1, href, !tokens[i + 4]?.content?.startsWith(")"), origin)), pushEmClose(replacerTokens, type), tokens[i + 4]?.type === "text") {
               let afterText = tokens[i + 4].content?.replace(/^\)\**/, "");
               afterText && replacerTokens.push(textToken(afterText)), tokens.splice(i, 5, ...replacerTokens);
             } else
@@ -11429,7 +11445,7 @@ function fixLinkToken(tokens, raw) {
               let type = emphasisMatch$1[0].length;
               text$1 = text$1.replace(/^\*+/, "").replace(/\*+$/, "");
               let href$1 = tokens[i + 2]?.content || "";
-              if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href$1 += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), pushEmOpen(replacerTokens, type), replacerTokens.push(createLinkToken(text$1, href$1, !tokens[i + 4]?.content?.startsWith(")"))), pushEmClose(replacerTokens, type), tokens[i + 4]?.type === "text") {
+              if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href$1 += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), pushEmOpen(replacerTokens, type), replacerTokens.push(createLinkToken(text$1, href$1, !tokens[i + 4]?.content?.startsWith(")"), origin)), pushEmClose(replacerTokens, type), tokens[i + 4]?.type === "text") {
                 let afterText = tokens[i + 4].content?.replace(/^\)/, "");
                 afterText && replacerTokens.push(textToken(afterText)), tokens.splice(i, 5, ...replacerTokens);
               } else
@@ -11438,7 +11454,7 @@ function fixLinkToken(tokens, raw) {
               continue;
             }
             let href = tokens[i + 2]?.content || "";
-            if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), replacerTokens.push(createLinkToken(text$1, href, !tokens[i + 4]?.content?.startsWith(")"))), tokens[i + 4]?.type === "text") {
+            if (tokens[i + 4]?.type === "text" && !tokens[i + 4].content?.startsWith(")") && (href += tokens[i + 4]?.content || "", tokens[i + 4].content = ""), replacerTokens.push(createLinkToken(text$1, href, !tokens[i + 4]?.content?.startsWith(")"), origin)), tokens[i + 4]?.type === "text") {
               let afterText = tokens[i + 4].content?.replace(/^\)/, "");
               afterText && replacerTokens.push(textToken(afterText)), tokens.splice(i, 5, ...replacerTokens);
             } else
@@ -11452,11 +11468,11 @@ function fixLinkToken(tokens, raw) {
           let replacerTokens = [], text$1 = tokens[i - 3].content || "", href = curToken.attrs?.find((attr) => attr[0] === "href")?.[1] || "";
           if (tokens[i + 3]?.type === "text") {
             let m = (tokens[i + 3]?.content ?? "").indexOf(")"), loading = m === -1;
-            m === -1 && (href += tokens[i + 3]?.content?.slice(0, m) || "", tokens[i + 3].content = ""), replacerTokens.push(createLinkToken(text$1, href, loading));
+            m === -1 && (href += tokens[i + 3]?.content?.slice(0, m) || "", tokens[i + 3].content = ""), replacerTokens.push(createLinkToken(text$1, href, loading, "linkify"));
             let afterText = tokens[i + 3].content?.replace(/^\)\**/, "");
             afterText && replacerTokens.push(textToken(afterText)), tokens.splice(i - 4, 8, ...replacerTokens);
           } else
-            replacerTokens.push({
+            replacerTokens.push(setSyntheticLinkOrigin({
               type: "link",
               loading: !0,
               href,
@@ -11468,7 +11484,7 @@ function fixLinkToken(tokens, raw) {
                 raw: href
               }],
               raw: `[${text$1}](${href})`
-            }), tokens.splice(i - 4, 7, ...replacerTokens);
+            }, "linkify")), tokens.splice(i - 4, 7, ...replacerTokens);
           continue;
         } else if (tokens[i - 1].content === "](" && tokens[i - 3]?.type === "text" && tokens[i - 3].content?.endsWith(")"))
           if (tokens[i - 2]?.type === "strong_open") {
@@ -11502,7 +11518,7 @@ function fixLinkToken(tokens, raw) {
             count += 1;
           }
         }
-        let linkToken = {
+        let linkToken = setSyntheticLinkOrigin({
           type: "link",
           loading: !1,
           href,
@@ -11514,7 +11530,7 @@ function fixLinkToken(tokens, raw) {
             raw: text$1
           }],
           raw: `[${text$1}](${href})`
-        };
+        }, curToken.markup ? getSyntheticLinkOrigin(curToken.markup) : "explicit");
         if (replacerTokens.push(linkToken), emphasisMatch) {
           let type = emphasisMatch[1].length;
           pushEmClose(replacerTokens, type);
@@ -13044,10 +13060,14 @@ function factory(opts = {}) {
       ...experimental
     }
   });
-  return hasCustomValidateLink || md.set({ validateLink: (url) => !isUnsafeHtmlUrl(url, {
-    tagName: "a",
-    attrName: "href"
-  }) }), applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.enableMath ?? !0) && applyMath(md, {
+  if (!hasCustomValidateLink) {
+    let validateLink$1 = (url) => !isUnsafeHtmlUrl(url, {
+      tagName: "a",
+      attrName: "href"
+    });
+    registerCacheStableLinkValidator(validateLink$1), md.set({ validateLink: validateLink$1 });
+  }
+  return applyInlineUrlValidation(md), applyLinkifyCandidateFilter(md), (opts.enableMath ?? !0) && applyMath(md, {
     ...getDefaultMathOptions() ?? {},
     ...opts.mathOptions ?? {}
   }), (opts.enableContainers ?? !0) && applyContainers(md), opts.enableFixIndentedCodeBlock !== !1 && applyFixIndentedCodeBlock(md), applyFixLinkTokens(md), applyFixStrongTokens(md), applyFixListItem(md), applyFixTableTokens(md), applyRenderRules(md), applyFixHtmlInlineTokens(md, { customHtmlTags: opts.customHtmlTags }), md;
@@ -13096,7 +13116,11 @@ function parseEmphasisToken(tokens, startIndex, options) {
     nextIndex: i < tokens.length ? i + 1 : tokens.length
   };
 }
-var TRAILING_FENCE_LINE_RE = /\r?\n[ \t]*`+\s*$/, DIFF_HEADER_PREFIXES = [
+function TRAILING_OWN_FENCE_LINE_RE(marker, minLen) {
+  return /* @__PURE__ */ new RegExp(`\r?
+[ \\t]*${marker}{${minLen},}[ \\t]*$`);
+}
+var DIFF_HEADER_PREFIXES = [
   "diff ",
   "index ",
   "--- ",
@@ -13149,7 +13173,11 @@ function parseFenceToken(token) {
     let s = info, sp = s.indexOf(" ");
     return sp === -1 ? "" : String(s.slice(sp + 1) ?? "");
   })() : info, content = String(token.content ?? "");
-  if (TRAILING_FENCE_LINE_RE.test(content) && (content = content.replace(TRAILING_FENCE_LINE_RE, "")), diff) {
+  if (!closed && token.markup) {
+    let marker = token.markup[0], minLen = token.markup.length, trailingFenceLineRe = TRAILING_OWN_FENCE_LINE_RE(marker, minLen);
+    trailingFenceLineRe.test(content) && (content = content.replace(trailingFenceLineRe, ""));
+  }
+  if (diff) {
     let { original, updated } = splitUnifiedDiff(content, closed === !0);
     return {
       type: "code_block",
@@ -14442,11 +14470,11 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
       content
     });
     if (currentTextNode) {
-      currentTextNode.content += stripTrailingMidStateMarker(textNode.content, token, markerFlags), currentTextNode.raw += textNode.raw;
+      currentTextNode.content += options?.final ? textNode.content : stripTrailingMidStateMarker(textNode.content, token, markerFlags), currentTextNode.raw += textNode.raw;
       return;
     }
     let maybeMath = preToken?.tag === "br" && tokens[i - 2]?.content === "[";
-    nextToken || (textNode.content = stripTrailingMidStateMarker(textNode.content, token, markerFlags)), currentTextNode = textNode, currentTextNode.center = maybeMath, result.push(currentTextNode);
+    nextToken || (textNode.content = options?.final ? textNode.content : stripTrailingMidStateMarker(textNode.content, token, markerFlags)), currentTextNode = textNode, currentTextNode.center = maybeMath, result.push(currentTextNode);
   }
   function handleTextToken(token) {
     let rawContent = String(token.content ?? ""), rawMarkerFlags = getInlineTextMarkerFlags(rawContent), rawHasBackslash = (rawMarkerFlags & INLINE_TEXT_MARKER_BACKSLASH) !== 0, rawSource = tokens.length === 1 && rawHasBackslash && typeof raw == "string" ? String(raw) : "", content = rawSource ? decodeVisibleTextFromRaw(rawSource) : rawHasBackslash ? rawContent.replace(ESCAPED_PUNCTUATION_RE, "$1") : rawContent, markerFlags = content === rawContent ? rawMarkerFlags : getInlineTextMarkerFlags(content);
@@ -14469,7 +14497,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
       i++;
       return;
     }
-    if (!nextToken && markerFlags & INLINE_TEXT_MARKER_OPEN_PAREN && /[^\]]\s*\(\s*$/.test(content) && (content = content.replace(/\(\s*$/, "")), !content) {
+    if (!nextToken && options?.final !== !0 && markerFlags & INLINE_TEXT_MARKER_OPEN_PAREN && /[^\]]\s*\(\s*$/.test(content) && (content = content.replace(/\(\s*$/, "")), !content) {
       i++;
       return;
     }
@@ -15807,16 +15835,23 @@ function recordInternalNodeSourceRange(node, token, options) {
     end: offsets[Math.max(0, Math.trunc(endLine))] ?? source.length
   });
 }
-var tolerantMathBoundaryStreamCache = /* @__PURE__ */ new WeakMap(), pendingExplicitMathTailCache = /* @__PURE__ */ new WeakMap(), TOLERANT_BOUNDARY_SPLIT_OPENERS = ["$$", "\\["], STREAMING_ADMONITION_OPEN_RE = /(^|\r?\n)[\t ]*:::[\t ]*(?:warning|info|note|tip|danger|caution|error)(?=[\t ]|\r?\n|$)[^\r\n]*(?:\r?\n[\t ]*)*$/, structuredStreamCache = /* @__PURE__ */ new WeakMap(), topLevelStreamParseMode = /* @__PURE__ */ new WeakMap(), REUSABLE_INLINE_TOKEN_TYPES = /* @__PURE__ */ new Set([
+var tolerantMathBoundaryStreamCache = /* @__PURE__ */ new WeakMap(), pendingExplicitMathTailCache = /* @__PURE__ */ new WeakMap(), TOLERANT_BOUNDARY_SPLIT_OPENERS = ["$", "\\["], STREAMING_ADMONITION_OPEN_RE = /(^|\r?\n)[\t ]*:::[\t ]*(?:warning|info|note|tip|danger|caution|error)(?=[\t ]|\r?\n|$)[^\r\n]*(?:\r?\n[\t ]*)*$/, SAFE_MARKDOWN_WINDOW_MARGIN = 1024, SAFE_MARKDOWN_WINDOW_OVERLAP = 16, safeMarkdownCache = /* @__PURE__ */ new WeakMap(), structuredStreamCache = /* @__PURE__ */ new WeakMap(), topLevelStreamParseMode = /* @__PURE__ */ new WeakMap(), REUSABLE_INLINE_TOKEN_TYPES = /* @__PURE__ */ new Set([
   "code_inline",
   "em_close",
   "em_open",
   "emoji",
   "hardbreak",
+  "html_block",
+  "html_inline",
+  "image",
   "ins_close",
   "ins_open",
+  "link",
+  "link_close",
+  "link_open",
   "mark_close",
   "mark_open",
+  "math_inline",
   "s_close",
   "s_open",
   "softbreak",
@@ -15836,6 +15871,7 @@ var tolerantMathBoundaryStreamCache = /* @__PURE__ */ new WeakMap(), pendingExpl
   "code_block",
   "fence",
   "hr",
+  "inline",
   "math_block"
 ]);
 function getParserNow() {
@@ -15867,21 +15903,38 @@ function processTokensWithTiming(tokens, options, timing) {
   let startedAt = getParserNow(), result = processTokens(tokens, options);
   return addTiming(timing, "processTokensMs", getParserNow() - startedAt), result;
 }
-function hasOnlyReusableInlineTokens(tokens) {
+function hasOnlyReusableInlineTokens(tokens, validateLink$1) {
   return tokens.every((token) => {
-    if (!REUSABLE_INLINE_TOKEN_TYPES.has(token.type))
+    if (!REUSABLE_INLINE_TOKEN_TYPES.has(token.type) || (token.type === "link" || token.type === "link_open" || token.type === "link_close") && !isCacheStableLinkValidator(validateLink$1))
       return !1;
+    if (token.type === "link") {
+      let origin = readSyntheticLinkOrigin(token);
+      if (origin !== "explicit" && origin !== "linkify" && origin !== "autolink")
+        return !1;
+    }
+    if (token.type === "link_open" || token.type === "link_close") {
+      let markup = token.markup ?? "";
+      if (markup !== "" && markup !== "linkify" && markup !== "autolink")
+        return !1;
+    }
     let children = token.children;
-    return !Array.isArray(children) || hasOnlyReusableInlineTokens(children);
+    return !Array.isArray(children) || hasOnlyReusableInlineTokens(children, validateLink$1);
   });
 }
-function getReusableTopLevelTokenGroups(tokens) {
+function getReusableTopLevelPairedCloseType(tokenType) {
+  let known = REUSABLE_TOP_LEVEL_PAIRED_TOKEN_TYPES.get(tokenType);
+  if (known)
+    return known;
+  let containerMatch = /^container_(.+)_open$/.exec(tokenType);
+  return containerMatch ? `container_${containerMatch[1]}_close` : void 0;
+}
+function getReusableTopLevelTokenGroups(tokens, validateLink$1) {
   let groupStarts = [], mixed = !1, index = 0;
   for (; index < tokens.length; ) {
     let token = tokens[index];
     if (!token || token.level !== 0)
       return null;
-    let closeType = REUSABLE_TOP_LEVEL_PAIRED_TOKEN_TYPES.get(token.type), groupEnd = index + 1;
+    let closeType = getReusableTopLevelPairedCloseType(token.type), groupEnd = index + 1;
     if (closeType) {
       if (token.nesting !== 1)
         return null;
@@ -15913,7 +15966,7 @@ function getReusableTopLevelTokenGroups(tokens) {
       if (current.type !== "inline")
         continue;
       let children = current.children;
-      if (!Array.isArray(children) || !hasOnlyReusableInlineTokens(children))
+      if (!Array.isArray(children) || !hasOnlyReusableInlineTokens(children, validateLink$1))
         return null;
     }
     groupStarts.push(index), index = groupEnd;
@@ -15948,24 +16001,36 @@ function updateStructuredStreamCache(md, source, tokens, groups, nodes, options)
     source,
     nodes,
     stableGroupCount: groups.mixed ? Math.max(0, groupStarts.length - 1) : sourceEndsWithBlankLine(source) ? groupStarts.length : Math.max(0, groupStarts.length - 1),
-    requireClosingStrong: options.requireClosingStrong
+    requireClosingStrong: options.requireClosingStrong,
+    validateLink: options.validateLink
   });
 }
 function hasStableStructuredStreamGroupBoundaries(previous, tokens, groupStarts, stableGroupCount) {
+  let lastGroupIndex = groupStarts.length - 1;
   for (let index = 0; index < stableGroupCount; index++) {
     let start = groupStarts[index], end = groupStarts[index + 1] ?? tokens.length, boundary = previous.groupBoundaries[index];
-    if (!boundary || boundary.firstToken !== tokens[start] || boundary.lastToken !== tokens[end - 1] || boundary.tokenCount !== end - start)
+    if (!boundary || boundary.tokenCount !== end - start)
+      return !1;
+    if (!(boundary.firstToken === tokens[start] && boundary.lastToken === tokens[end - 1]) && (index >= lastGroupIndex || !isSameTokenShapeForReuse(boundary.firstToken, tokens[start]) || !isSameTokenShapeForReuse(boundary.lastToken, tokens[end - 1])))
       return !1;
   }
   return !0;
 }
 function processTopLevelTokensWithReuse(md, source, tokens, options, timing) {
-  let owner = md, groups = getReusableTopLevelTokenGroups(tokens);
-  if (!(shouldUseTopLevelStreamParse(md, options) && canReuseStructuredStreamNodes(options) && groups !== null))
+  let owner = md, structuredReuseDisabled = options.__disableStructuredReuse === !0;
+  if (!(shouldUseTopLevelStreamParse(md, options) && canReuseStructuredStreamNodes(options)))
+    return structuredReuseDisabled || structuredStreamCache.delete(owner), processTokensWithTiming(tokens, options, timing);
+  if (structuredReuseDisabled)
+    return processTokensWithTiming(tokens, options, timing);
+  let groups = getReusableTopLevelTokenGroups(tokens, options.validateLink);
+  if (!groups)
     return structuredStreamCache.delete(owner), processTokensWithTiming(tokens, options, timing);
   let groupStarts = groups.starts, previous = structuredStreamCache.get(owner), mode = topLevelStreamParseMode.get(owner), 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 && source.startsWith(previous.source) && groupStarts.length >= stableGroupCount && (mode === "append" || mode === "tail") && hasStableStructuredStreamGroupBoundaries(previous, tokens, groupStarts, stableGroupCount)) {
-    let tailStart = groupStarts[stableGroupCount] ?? tokens.length, tailNodes = processTokensWithTiming(tokens.slice(tailStart), options, timing), expectedTailNodes = groupStarts.length - stableGroupCount;
+  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 = processTokensWithTiming(tokens.slice(tailStart), {
+      ...options,
+      __linkifyDemotionSeed: previous.nodes.slice(0, stableGroupCount).map((node) => String(node.raw ?? ""))
+    }, timing), expectedTailNodes = groupStarts.length - stableGroupCount;
     if (tailNodes.length === expectedTailNodes) {
       let result$1 = previous.nodes.slice(0, stableGroupCount).concat(tailNodes);
       return addTiming(timing, "processTokensReusedTopLevelNodes", stableGroupCount), updateStructuredStreamCache(md, source, tokens, groups, result$1, options), result$1;
@@ -16573,6 +16638,22 @@ function sameTokenMap(left, right) {
   let leftMap = left?.map, rightMap = right?.map;
   return leftMap === rightMap ? !0 : !Array.isArray(leftMap) || !Array.isArray(rightMap) ? !1 : leftMap.length === rightMap.length && leftMap.every((value, index) => value === rightMap[index]);
 }
+function sameTokenAttrs(left, right) {
+  let leftAttrs = left?.attrs, rightAttrs = right?.attrs;
+  if (leftAttrs === rightAttrs)
+    return !0;
+  if (!Array.isArray(leftAttrs) || !Array.isArray(rightAttrs) || leftAttrs.length !== rightAttrs.length)
+    return !1;
+  for (let index = 0; index < leftAttrs.length; index++) {
+    let leftAttr = leftAttrs[index], rightAttr = rightAttrs[index];
+    if (leftAttr[0] !== rightAttr[0] || leftAttr[1] !== rightAttr[1])
+      return !1;
+  }
+  return !0;
+}
+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 isSameTokenShape(left, right) {
   return !!left && !!right && left.type === right.type && left.tag === right.tag && left.nesting === right.nesting && left.markup === right.markup && left.content === right.content && sameTokenMap(left, right);
 }
@@ -17000,7 +17081,8 @@ function hasTopLevelHtmlBlock(nodes) {
 function parseDetailsFragmentChildren(fragment, md, options) {
   return fragment.trim() ? parseMarkdownToStructure(fragment, md, {
     ...options,
-    __disableStreamParse: !0
+    __disableStreamParse: !0,
+    __disableStructuredReuse: !0
   }) : [];
 }
 function parseSummaryChildren(fragment, md, options) {
@@ -17196,54 +17278,7 @@ function stripDanglingHtmlLikeTail(markdown) {
       }
     }
     return !0;
-  }, isInsideFencedCodeBlock = (src, pos) => {
-    let inFence = !1, fenceChar = "", fenceLen = 0, isIndentWs = (ch) => ch === " " || ch === "	", parseFenceMarker = (line) => {
-      let i = 0;
-      for (; i < line.length && isIndentWs(line[i]); )
-        i++;
-      let ch = line[i];
-      if (ch !== "`" && ch !== "~")
-        return null;
-      let j = i;
-      for (; j < line.length && line[j] === ch; )
-        j++;
-      let len = j - i;
-      return len < 3 ? null : {
-        markerChar: ch,
-        markerLen: len,
-        rest: line.slice(j)
-      };
-    }, stripBlockquotePrefix = (line) => {
-      let i = 0;
-      for (; i < line.length && isIndentWs(line[i]); )
-        i++;
-      let saw = !1;
-      for (; i < line.length && line[i] === ">"; )
-        for (saw = !0, i++; i < line.length && isIndentWs(line[i]); )
-          i++;
-      return saw ? line.slice(i) : null;
-    }, matchFence = (rawLine) => {
-      let direct = parseFenceMarker(rawLine);
-      if (direct)
-        return direct;
-      let afterQuote = stripBlockquotePrefix(rawLine);
-      return afterQuote == null ? null : parseFenceMarker(afterQuote);
-    }, offset = 0, lines = src.split(/\r?\n/);
-    for (let line of lines) {
-      let lineStart = offset, lineEnd$2 = offset + line.length;
-      if (pos < lineStart)
-        break;
-      let fenceMatch = matchFence(line);
-      if (fenceMatch) {
-        let markerChar = fenceMatch.markerChar, markerLen = fenceMatch.markerLen;
-        inFence ? markerChar === fenceChar && markerLen >= fenceLen && /^\s*$/.test(fenceMatch.rest) && (inFence = !1, fenceChar = "", fenceLen = 0) : (inFence = !0, fenceChar = markerChar, fenceLen = markerLen);
-      }
-      if (pos <= lineEnd$2)
-        break;
-      offset = lineEnd$2 + 1;
-    }
-    return inFence;
-  }, s = String(markdown ?? ""), lastLt = s.lastIndexOf("<");
+  }, isInsideFencedCodeBlock = (src, pos) => isInsideOpenMarkdownFenceBeforeOffset(src, pos), s = String(markdown ?? ""), lastLt = s.lastIndexOf("<");
   if (lastLt === -1 || isInsideFencedCodeBlock(s, lastLt))
     return s;
   if (lastLt > 0) {
@@ -17889,9 +17924,76 @@ function ensureBlankLineBeforeCustomHtmlBlocks(markdown, tags) {
   }
   return out;
 }
-function parseMarkdownToStructure(markdown, md, options = {}) {
-  let timing = getParseTiming(options), parseStartedAt = timing ? getParserNow() : 0, isFinal = !!options.final, sourceMarkdown = (markdown ?? "").toString(), safeMarkdown = sourceMarkdown.replace(/([^\\])\r(ight|ho)/g, "$1\\r$2").replace(/([^\\])\r?\n(abla|eq|ot|exists)/g, "$1\\n$2");
-  if (shouldResetTopLevelStreamCacheForFinalAutoParse(md, options) && (md.stream.reset(), clearTolerantMathBoundaryStreamCache(md)), isFinal || (safeMarkdown.endsWith("- *") && (safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*")), /(?:^|\n)\s*-\s*$/.test(safeMarkdown) ? safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*-\s*$/, (m) => m.startsWith(`
+function createLatexSplitMathScanner(source) {
+  let inFence = !1, fenceMarker = "", fenceLen = 0, inDollarBlock = !1, inBracketMath = !1, singleDollarOpen = !1, scanned = 0, processLine = (line, _lineStartOffset) => {
+    let fenceMatch = matchMarkdownFenceMarker(line);
+    if (fenceMatch) {
+      inFence ? fenceMatch.markerChar === fenceMarker && fenceMatch.markerLen >= fenceLen && /^\s*$/.test(fenceMatch.rest) && (inFence = !1, fenceMarker = "", fenceLen = 0) : (inFence = !0, fenceMarker = fenceMatch.markerChar, fenceLen = fenceMatch.markerLen);
+      return;
+    }
+    if (inFence)
+      return;
+    let i = 0;
+    for (; i < line.length; ) {
+      if (inDollarBlock) {
+        line.startsWith("$$", i) && !isEscapedDelimiterAt(line, i) ? (inDollarBlock = !1, i += 2) : i++;
+        continue;
+      }
+      if (inBracketMath) {
+        line.startsWith("\\]", i) && !isEscapedDelimiterAt(line, i) ? (inBracketMath = !1, i += 2) : i++;
+        continue;
+      }
+      let ch = line[i];
+      if (ch === "`") {
+        let runLen = countRepeatedChar(line, i, "`"), closeIndex = findCodeSpanCloseIndex(line, i + runLen, runLen);
+        if (closeIndex === -1)
+          break;
+        i = closeIndex + runLen;
+        continue;
+      }
+      if (ch === "\\") {
+        let next = line[i + 1];
+        next === "[" && !isEscapedDelimiterAt(line, i) ? (inBracketMath = !0, i += 2) : (next === "]" && isEscapedDelimiterAt(line, i), i += 2);
+        continue;
+      }
+      if (ch === "$") {
+        if (line[i + 1] === "$" && !isEscapedDelimiterAt(line, i)) {
+          inDollarBlock = !0, singleDollarOpen = !1, i += 2;
+          continue;
+        }
+        if (singleDollarOpen) {
+          singleDollarOpen = !1, i++;
+          continue;
+        }
+        let after = line[i + 1];
+        (after === void 0 || after !== " " && after !== "	" && !/\d/.test(after)) && (singleDollarOpen = !0), i++;
+        continue;
+      }
+      i++;
+    }
+  };
+  return {
+    scanTo: (target) => {
+      for (; scanned < target; ) {
+        let newlineIndex = source.indexOf(`
+`, scanned), lineEndRaw = newlineIndex === -1 || newlineIndex >= target ? target : newlineIndex, lineEnd$2 = lineEndRaw > scanned && source[lineEndRaw - 1] === "\r" ? lineEndRaw - 1 : lineEndRaw;
+        if (processLine(source.slice(scanned, lineEnd$2), scanned), newlineIndex === -1 || newlineIndex >= target) {
+          scanned = target;
+          break;
+        }
+        singleDollarOpen = !1, scanned = newlineIndex + 1;
+      }
+    },
+    inMath: () => inDollarBlock || inBracketMath || singleDollarOpen
+  };
+}
+function transformStreamingSafeMarkdown(source, isFinal, md, options) {
+  let safeMarkdown = source.replace(/([^\\])\r(ight|ho)/g, "$1\\r$2"), latexSplitMathScanner = createLatexSplitMathScanner(safeMarkdown);
+  if (safeMarkdown = safeMarkdown.replace(/([^\\])\r?\n(abla|eq|ot|exists)/g, (full, before, cmd, offset) => {
+    latexSplitMathScanner.scanTo(offset + 1);
+    let shouldReconstruct = latexSplitMathScanner.inMath();
+    return latexSplitMathScanner.scanTo(offset + full.length), shouldReconstruct ? `${before}\\n${cmd}` : full;
+  }), isFinal || (safeMarkdown.endsWith("- *") && (safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*")), /(?:^|\n)\s*-\s*$/.test(safeMarkdown) ? safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*-\s*$/, (m) => m.startsWith(`
 `) ? `
 ` : "") : /(?:^|\n)\s*--\s*$/.test(safeMarkdown) ? safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*--\s*$/, (m) => m.startsWith(`
 `) ? `
@@ -17903,7 +18005,7 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 ` : "")) : /(?:^|\n)\s*\d+[.)]\s+\*{1,3}\s*$/.test(safeMarkdown) ? safeMarkdown = safeMarkdown.replace(/((?:^|\n)\s*\d+[.)]\s+)(\*{1,3})\s*$/, (_, prefix, stars) => `${prefix}${stars.split("").map(() => "\\*").join("")}`) : /(?:^|\n)\s*\d+[.)]\s*$/.test(safeMarkdown) ? safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*\d+[.)]\s*$/, (m) => m.startsWith(`
 `) ? `
 ` : "") : /\n[[(]\n*$/.test(safeMarkdown) && (safeMarkdown = safeMarkdown.replace(/(\n\[|\n\()+\n*$/g, `
-`)), safeMarkdown = stripPendingExplicitMathTail(safeMarkdown, md), safeMarkdown = getStreamingAdmonitionOpenTailReplacement(safeMarkdown, options.customHtmlTags) ?? safeMarkdown), options.customHtmlTags?.length && safeMarkdown.includes("<")) {
+`)), safeMarkdown = getStreamingAdmonitionOpenTailReplacement(safeMarkdown, options.customHtmlTags) ?? safeMarkdown), options.customHtmlTags?.length && safeMarkdown.includes("<")) {
     let tags = normalizeCustomHtmlTags(options.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) {
@@ -17911,7 +18013,26 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
         safeMarkdown = safeMarkdown.replace(re, "$1$2$2");
       }
   }
-  isFinal || (safeMarkdown = stripDanglingHtmlLikeTail(safeMarkdown));
+  return isFinal || (safeMarkdown = stripDanglingHtmlLikeTail(safeMarkdown)), safeMarkdown;
+}
+function getSafeMarkdown(md, sourceMarkdown, isFinal, options) {
+  let owner = md, mode = `${isFinal ? "final" : "stream"}:${(options.customHtmlTags ?? []).join(",")}`, previous = safeMarkdownCache.get(owner), safeMarkdown;
+  if (!isFinal && !options.customHtmlTags?.length && previous && previous.mode === mode && sourceMarkdown.length >= previous.source.length && sourceMarkdown.startsWith(previous.source)) {
+    let windowStart = Math.max(0, previous.source.length - SAFE_MARKDOWN_WINDOW_MARGIN - SAFE_MARKDOWN_WINDOW_OVERLAP), transformed = transformStreamingSafeMarkdown(sourceMarkdown.slice(windowStart), isFinal, md, 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, md, options);
+  } else
+    safeMarkdown = transformStreamingSafeMarkdown(sourceMarkdown, isFinal, md, options);
+  return isFinal || (safeMarkdown = stripPendingExplicitMathTail(safeMarkdown, md)), safeMarkdownCache.set(owner, {
+    source: sourceMarkdown,
+    safeMarkdown,
+    mode
+  }), safeMarkdown;
+}
+function parseMarkdownToStructure(markdown, md, options = {}) {
+  let timing = getParseTiming(options), parseStartedAt = timing ? getParserNow() : 0, isFinal = !!options.final, sourceMarkdown = (markdown ?? "").toString();
+  shouldResetTopLevelStreamCacheForFinalAutoParse(md, options) && (md.stream.reset(), clearTolerantMathBoundaryStreamCache(md), safeMarkdownCache.delete(md));
+  let safeMarkdown = getSafeMarkdown(md, sourceMarkdown, isFinal, options);
+  timing && addTiming(timing, "safeMarkdownMs", getParserNow() - parseStartedAt);
   let standaloneHtmlDocument = parseStandaloneHtmlDocument(safeMarkdown);
   if (standaloneHtmlDocument) {
     if (options.includeSourceMap) {
@@ -17928,8 +18049,8 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
     }
     return finishParsedNodes(standaloneHtmlDocument, options, timing, parseStartedAt);
   }
-  let tokens = parseTopLevelTokens(md, safeMarkdown, { __markstreamFinal: isFinal }, options);
-  if (!tokens || !Array.isArray(tokens))
+  let tokenizeStartedAt = timing ? getParserNow() : 0, tokens = parseTopLevelTokens(md, safeMarkdown, { __markstreamFinal: isFinal }, options);
+  if (timing && addTiming(timing, "tokenizeMs", getParserNow() - tokenizeStartedAt), !tokens || !Array.isArray(tokens))
     return finishParsedNodes([], options, timing, parseStartedAt);
   let pre = options.preTransformTokens, post = options.postTransformTokens, transformedTokens = tokens;
   pre && typeof pre == "function" && (transformedTokens = pre(transformedTokens) || transformedTokens);
@@ -17951,7 +18072,11 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
       }, timing) : result = postResult;
     }
   }
-  if (hasTopLevelHtmlBlock(result) && (result = mergeSplitTopLevelHtmlBlocks(result, isFinal, safeMarkdown, internalOptions), result = combineStructuredDetailsHtmlBlocks(result, safeMarkdown, md, internalOptions, isFinal)[0], result = structureGenericHtmlBlockChildren(result, md, internalOptions, isFinal)), isFinal) {
+  if (hasTopLevelHtmlBlock(result)) {
+    let htmlPassesStartedAt = timing ? getParserNow() : 0;
+    result = mergeSplitTopLevelHtmlBlocks(result, isFinal, safeMarkdown, internalOptions), result = combineStructuredDetailsHtmlBlocks(result, safeMarkdown, md, internalOptions, isFinal)[0], result = structureGenericHtmlBlockChildren(result, md, internalOptions, isFinal), timing && addTiming(timing, "htmlBlockPassesMs", getParserNow() - htmlPassesStartedAt);
+  }
+  if (isFinal) {
     let seen = /* @__PURE__ */ new WeakSet(), finalizeHtmlBlockLoading = (value) => {
       if (!value || typeof value != "object" || seen.has(value))
         return;
@@ -17972,7 +18097,11 @@ function parseMarkdownToStructure(markdown, md, options = {}) {
 function processTokens(tokens, options) {
   if (!tokens || !Array.isArray(tokens))
     return [];
-  let result = [], linkifyContext = createLinkifyDemotionContextTracker(options), includeSourceMap = options?.includeSourceMap === !0, i = 0;
+  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;
   for (; i < tokens.length; ) {
     let handled = parseCommonBlockToken(tokens, i, linkifyContext.options(), containerTokenHandlers);
     if (handled) {
@@ -19730,11 +19859,60 @@ function mergeStyle2(base, overlay) {
   let merged = Object.freeze({ ...base, ...overlay });
   return bucket.set(overlay, merged), merged;
 }
-var activeMarkdownImageGraphics = /* @__PURE__ */ new WeakMap();
+var activeMarkdownImageGraphics = /* @__PURE__ */ new WeakMap(), markdownImageGraphicIdCache = /* @__PURE__ */ new WeakMap(), preparedMarkdownImageGraphicCache = /* @__PURE__ */ new WeakMap();
 function markdownImageGraphicId(segment, identity) {
-  return `md-image:${stableTerminalGraphicNumericId(
+  let cachedIds = markdownImageGraphicIdCache.get(segment);
+  cachedIds || (cachedIds = /* @__PURE__ */ new Map(), markdownImageGraphicIdCache.set(segment, cachedIds));
+  let cached = cachedIds.get(identity);
+  if (cached)
+    return cached;
+  let id = `md-image:${stableTerminalGraphicNumericId(
     `${identity}:${segment.src ?? segment.tex ?? ""}:${segment.displayWidth ?? 0}:${segment.displayHeight ?? 0}:${segment.base64 ?? ""}`
   )}`;
+  return cachedIds.set(identity, id), id;
+}
+function prepareMarkdownImageGraphic(segment, identity, protocol, placement) {
+  if (!segment.base64)
+    return null;
+  let preparedByVariant = preparedMarkdownImageGraphicCache.get(segment);
+  preparedByVariant || (preparedByVariant = /* @__PURE__ */ new Map(), preparedMarkdownImageGraphicCache.set(segment, preparedByVariant));
+  let cacheKey = `${identity}\0${protocol}\0${placement.width}\0${placement.height}\0${placement.sourceX ?? ""}\0${placement.sourceY ?? ""}\0${placement.sourceWidth ?? ""}\0${placement.sourceHeight ?? ""}`, cached = preparedByVariant.get(cacheKey);
+  if (cached)
+    return cached;
+  let id = markdownImageGraphicId(segment, identity), imageId = stableTerminalGraphicNumericId(`image:${id}`), placementId = stableTerminalGraphicNumericId(`placement:${id}`), sequence = protocol === "kitty" ? createKittyGraphicsSequence(segment.base64, {
+    imageId,
+    placementId,
+    columns: placement.width,
+    rows: placement.height,
+    sourceX: placement.sourceX,
+    sourceY: placement.sourceY,
+    sourceWidth: placement.sourceWidth,
+    sourceHeight: placement.sourceHeight,
+    zIndex: -1
+  }) : protocol === "iterm2" ? createIterm2InlineImageSequence(segment.base64, {
+    width: placement.width,
+    height: placement.height,
+    preserveAspectRatio: !0,
+    doNotMoveCursor: !0
+  }) : "";
+  if (!sequence)
+    return null;
+  let prepared = Object.freeze({
+    id,
+    sequence,
+    clearSequence: protocol === "kitty" ? createKittyDeleteGraphicsSequence({ imageId, placementId }) : void 0,
+    resizeSequence: protocol === "kitty" ? createKittyPlacementSequence({
+      imageId,
+      placementId,
+      columns: placement.width,
+      rows: placement.height,
+      sourceX: placement.sourceX,
+      sourceY: placement.sourceY,
+      sourceWidth: placement.sourceWidth,
+      sourceHeight: placement.sourceHeight
+    }) : void 0
+  });
+  return preparedByVariant.set(cacheKey, prepared), prepared;
 }
 function rememberMarkdownImageGraphic(terminal, id, rect) {
   let active = activeMarkdownImageGraphics.get(terminal);
@@ -19765,57 +19943,47 @@ function clearMarkdownImageGraphics(terminal, rect) {
     for (let [id, item] of active)
       rect && (item.x >= rect.x + rect.w || item.x + item.w <= rect.x || item.y >= rect.y + rect.h || item.y + item.h <= rect.y) || clearTrackedMarkdownImageGraphic(terminal, id);
 }
-function queueMarkdownImageGraphic(terminal, segment, identity, rect) {
+function queueMarkdownImageGraphic(terminal, segment, identity, rect, placementOverride) {
   if (!segment.base64)
     return "unavailable";
   let output = getTerminalGraphicsOutput(terminal), protocol = output?.capabilities.preferredProtocol;
   if (!output?.capabilities.supported || !isTerminalGraphicsProtocol(protocol))
     return "unavailable";
-  let width = Math.max(1, Math.floor(segment.displayWidth ?? rect.w)), height = Math.max(1, Math.floor(segment.displayHeight ?? 1)), id = markdownImageGraphicId(segment, identity), imageId = stableTerminalGraphicNumericId(`image:${id}`), placementId = stableTerminalGraphicNumericId(`placement:${id}`), sequence = protocol === "kitty" ? createKittyGraphicsSequence(segment.base64, {
-    imageId,
-    placementId,
-    columns: width,
-    rows: height,
-    zIndex: -1
-  }) : protocol === "iterm2" ? createIterm2InlineImageSequence(segment.base64, {
-    width,
-    height,
-    preserveAspectRatio: !0,
-    doNotMoveCursor: !0
-  }) : "";
-  if (!sequence)
+  let placement = placementOverride ?? {
+    width: Math.max(1, Math.floor(segment.displayWidth ?? rect.w)),
+    height: Math.max(1, Math.floor(segment.displayHeight ?? 1))
+  }, prepared = prepareMarkdownImageGraphic(segment, identity, protocol, placement);
+  if (!prepared)
     return "unavailable";
-  let clearSequence = protocol === "kitty" ? createKittyDeleteGraphicsSequence({
-    imageId,
-    placementId
-  }) : void 0, resizeSequence = protocol === "kitty" ? createKittyPlacementSequence({
-    imageId,
-    placementId,
-    columns: width,
-    rows: height
-  }) : void 0, accepted = output.queue({
-    id,
+  let accepted = output.queue({
+    id: prepared.id,
     x: rect.x,
     y: rect.y,
-    w: width,
-    h: height,
+    w: placement.width,
+    h: placement.height,
     protocol,
-    sequence,
-    resizeSequence,
-    clearSequence,
+    sequence: prepared.sequence,
+    resizeSequence: prepared.resizeSequence,
+    clearSequence: prepared.clearSequence,
+    placementMoveWithoutClear: protocol === "kitty",
     fallbackText: segment.alt ?? (segment.kind === "math" ? segment.raw ?? segment.tex ?? "math" : "image")
   });
   return markdownImageDebug(
-    `queue id=${id}`,
+    `queue id=${prepared.id}`,
     `accepted=${accepted ? "true" : "false"}`,
     `x=${rect.x}`,
     `y=${rect.y}`,
-    `w=${width}`,
-    `h=${height}`,
+    `w=${placement.width}`,
+    `h=${placement.height}`,
     `visibleW=${rect.w}`,
     `displayW=${segment.displayWidth ?? ""}`,
     `displayH=${segment.displayHeight ?? ""}`
-  ), accepted && rememberMarkdownImageGraphic(terminal, id, { x: rect.x, y: rect.y, w: width, h: height }), accepted ? "queued" : "rejected";
+  ), accepted && rememberMarkdownImageGraphic(terminal, prepared.id, {
+    x: rect.x,
+    y: rect.y,
+    w: placement.width,
+    h: placement.height
+  }), accepted ? "queued" : "rejected";
 }
 function collectVisibleMarkdownImageGraphicIds(rows, options) {
   let keepIds = /* @__PURE__ */ new Set();
@@ -19831,7 +19999,7 @@ function collectVisibleMarkdownImageGraphicIds(rows, options) {
     let logicalX = 0;
     for (let [segmentIndex, segment] of row.segments.entries()) {
       let segmentStart = logicalX, segmentEnd = logicalX + segment.cells;
-      if (logicalX = segmentEnd, !segment.graphic || segmentEnd <= clipStart || segmentStart >= clipEnd || Math.max(segmentStart, clipStart) !== segmentStart)
+      if (logicalX = segmentEnd, !segment.graphic || segmentEnd <= clipStart || segmentStart >= clipEnd)
         continue;
       let height = Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1));
       if (rowIndex + height <= firstRow || rowIndex >= lastRow)
@@ -19847,10 +20015,74 @@ function collectVisibleMarkdownImageGraphicIds(rows, options) {
   }
   return keepIds;
 }
+function queueClippedVisibleMarkdownImageGraphics(terminal, rows, options) {
+  let queuedIds = /* @__PURE__ */ new Set(), output = getTerminalGraphicsOutput(terminal);
+  if (options.w <= 0 || options.h <= 0 || !output?.capabilities.supported || output.capabilities.preferredProtocol !== "kitty")
+    return queuedIds;
+  let clipStart = Math.max(0, Math.floor(options.clipStart)), firstRow = Math.min(rows.length, Math.max(0, Math.floor(options.rowOffset))), lastRow = Math.min(rows.length, firstRow + Math.max(0, Math.floor(options.h))), scanStart = firstRow;
+  for (; scanStart > 0 && (rows[scanStart]?.segments.length ?? 0) === 0; )
+    scanStart--;
+  for (let rowIndex = scanStart; rowIndex < lastRow; rowIndex++) {
+    let row = rows[rowIndex];
+    if (!row)
+      continue;
+    let logicalX = 0;
+    for (let [segmentIndex, segment] of row.segments.entries()) {
+      let segmentStart = logicalX;
+      if (logicalX += segment.cells, !segment.graphic?.base64)
+        continue;
+      let fullWidth = Math.max(1, Math.floor(segment.graphic.displayWidth ?? segment.cells)), fullHeight = Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1)), fullRect = {
+        x: options.x + segmentStart - clipStart,
+        y: options.y + rowIndex - firstRow,
+        w: fullWidth,
+        h: fullHeight
+      }, visibleRect = {
+        x: Math.max(options.x, fullRect.x),
+        y: Math.max(options.y, fullRect.y),
+        w: Math.min(options.x + options.w, fullRect.x + fullRect.w) - Math.max(options.x, fullRect.x),
+        h: Math.min(options.y + options.h, fullRect.y + fullRect.h) - Math.max(options.y, fullRect.y)
+      };
+      if (visibleRect.w <= 0 || visibleRect.h <= 0 || visibleRect.x === fullRect.x && visibleRect.y === fullRect.y && visibleRect.w === fullRect.w && visibleRect.h === fullRect.h || options.isGraphicCovered?.(visibleRect))
+        continue;
+      let naturalWidth = Math.floor(segment.graphic.naturalWidth ?? 0), naturalHeight = Math.floor(segment.graphic.naturalHeight ?? 0);
+      if (naturalWidth <= 0 || naturalHeight <= 0)
+        continue;
+      let offsetX = visibleRect.x - fullRect.x, offsetY = visibleRect.y - fullRect.y, sourceX = Math.floor(offsetX * naturalWidth / fullWidth), sourceY = Math.floor(offsetY * naturalHeight / fullHeight), sourceRight = Math.max(
+        sourceX + 1,
+        Math.min(naturalWidth, Math.ceil((offsetX + visibleRect.w) * naturalWidth / fullWidth))
+      ), sourceBottom = Math.max(
+        sourceY + 1,
+        Math.min(
+          naturalHeight,
+          Math.ceil((offsetY + visibleRect.h) * naturalHeight / fullHeight)
+        )
+      ), identity = `${row.key}:${segmentIndex}`;
+      queueMarkdownImageGraphic(
+        terminal,
+        segment.graphic,
+        identity,
+        { x: visibleRect.x, y: visibleRect.y, w: visibleRect.w },
+        {
+          width: visibleRect.w,
+          height: visibleRect.h,
+          sourceX,
+          sourceY,
+          sourceWidth: sourceRight - sourceX,
+          sourceHeight: sourceBottom - sourceY
+        }
+      ) === "queued" && queuedIds.add(markdownImageGraphicId(segment.graphic, identity));
+    }
+  }
+  return queuedIds;
+}
 function paintMarkdownVisualRow(terminal, row, options) {
   let clipStart = Math.max(0, Math.floor(options.clipStart ?? 0)), clipEnd = clipStart + options.w;
   if (!row) {
-    options.clear !== !1 && (terminal.write(spaces(options.w), { x: options.x, y: options.y, style: options.baseStyle }), clearStaleMarkdownImageGraphicsForRow(terminal, options.y, /* @__PURE__ */ new Set(), options.keepGraphicIds));
+    options.clear !== !1 && (terminal.write(spaces(options.w), {
+      x: options.x,
+      y: options.y,
+      style: options.baseStyle
+    }), clearStaleMarkdownImageGraphicsForRow(terminal, options.y, /* @__PURE__ */ new Set(), options.keepGraphicIds));
     return;
   }
   let logicalX = 0, used = 0, queuedGraphics = /* @__PURE__ */ new Set();
@@ -19881,12 +20113,12 @@ function paintMarkdownVisualRow(terminal, row, options) {
         y: options.y,
         w: Math.max(1, Math.floor(segment.graphic.displayWidth ?? visibleCells)),
         h: Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1))
-      }, queueResult = !(options.isGraphicCovered?.(graphicRect) === !0) && visibleStart === segmentStart && visibleCells > 0 && queueMarkdownImageGraphic(terminal, segment.graphic, `${row.key}:${segmentIndex}`, {
+      }, graphicCovered = options.isGraphicCovered?.(graphicRect) === !0, graphicId = markdownImageGraphicId(segment.graphic, `${row.key}:${segmentIndex}`), queueResult = options.prequeuedGraphicIds?.has(graphicId) === !0 ? "queued" : !graphicCovered && visibleStart === segmentStart && visibleCells > 0 && queueMarkdownImageGraphic(terminal, segment.graphic, `${row.key}:${segmentIndex}`, {
         x: cellX,
         y: options.y,
         w: visibleCells
       }), graphicAvailable = queueResult || canAttemptMarkdownImageGraphic(terminal, segment.graphic), queuedGraphic = queueResult === "queued", suppressFallback = queuedGraphic || queueResult === "rejected" || graphicAvailable === !0;
-      queuedGraphic && queuedGraphics.add(markdownImageGraphicId(segment.graphic, `${row.key}:${segmentIndex}`)), terminal.write(
+      queuedGraphic && queuedGraphics.add(graphicId), terminal.write(
         suppressFallback ? spaces(visibleCells) : sliceByCellsRange(
           segment.fallbackText ?? segment.graphic.alt ?? (segment.graphic.kind === "math" ? segment.graphic.raw ?? segment.graphic.tex ?? "math" : "image"),
           0,
@@ -20614,23 +20846,36 @@ function markdownStyleSignature(style) {
     style.href ?? ""
   ].join("
") : "";
 }
+var markdownRowSignatureCache = /* @__PURE__ */ new WeakMap(), markdownRowGraphicSignatureCache = /* @__PURE__ */ new WeakMap();
 function markdownRowSignature(row) {
-  return row ? [
+  if (!row)
+    return "";
+  let cached = markdownRowSignatureCache.get(row);
+  if (cached != null)
+    return cached;
+  let signature = [
     row.key,
     row.plainText,
     row.segments.map(
       (segment) => `${segment.text}
${segment.cells}
${markdownStyleSignature(segment.style)}
${segment.graphic?.src ?? ""}
${segment.graphic?.base64 ?? ""}
${segment.fallbackText ?? ""}`
     ).join("")
-  ].join("") : "";
+  ].join("");
+  return markdownRowSignatureCache.set(row, signature), signature;
 }
 function getWheelScrollInput(e) {
   let deltaY = Number(e.deltaY ?? 0), deltaMode = typeof e.deltaMode == "number" ? e.deltaMode : void 0;
   return Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && deltaMode == null ? { deltaY: deltaY / 100, mode: "line" } : deltaMode === 1 ? { deltaY, mode: "line" } : deltaMode === 0 ? { deltaY, mode: "pixel" } : { deltaY, mode: "auto" };
 }
 function rowGraphicSignature(row) {
-  return row ? row.segments.map(
-    (segment) => segment.graphic ? `${segment.graphic.kind}
${segment.graphic.src}
${segment.graphic.base64 ?? ""}` : ""
-  ).join("") : "";
+  if (!row)
+    return "";
+  let cached = markdownRowGraphicSignatureCache.get(row);
+  if (cached != null)
+    return cached;
+  let signature = row.segments.filter((segment) => segment.graphic).map(
+    (segment) => `${segment.graphic.kind}
${segment.graphic.src}
${segment.graphic.base64 ?? ""}`
+  ).join("");
+  return markdownRowGraphicSignatureCache.set(row, signature), signature;
 }
 var TVirtualMarkdown = (0, import_vue10.defineComponent)({
   name: "TVirtualMarkdown",
@@ -20681,6 +20926,10 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
     imageOcclusionRects: {
       type: Array,
       default: void 0
+    },
+    rowScrollMode: {
+      type: String,
+      default: "off"
     }
   },
   emits: {
@@ -20694,7 +20943,16 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
     linkAction: (_payload) => !0
   },
   setup(props, { emit }) {
-    let instance = (0, import_vue10.getCurrentInstance)(), { terminal, defaultStyle, events, scheduler, selection, widthProvider } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue10.inject)(EventZIndexContextKey, (0, import_vue10.computed)(() => 0)), eventZ = (0, import_vue10.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), internalScrollTop = (0, import_vue10.ref)(0), documentVersion = (0, import_vue10.ref)(0), rows = (0, import_vue10.shallowRef)((0, import_vue10.markRaw)([])), pendingSelectionScrollFocusRemap = !1, wheelState = createWheelScrollState(), builtOnce = !1, rebuildVersion = 0, layoutCache, alive = !0, parser = (0, import_vue10.shallowRef)(
+    let instance = (0, import_vue10.getCurrentInstance)(), {
+      terminal,
+      defaultStyle,
+      events,
+      scheduler,
+      selection,
+      widthProvider,
+      render,
+      rendererCapabilities
+    } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue10.inject)(EventZIndexContextKey, (0, import_vue10.computed)(() => 0)), plane = (0, import_vue10.inject)(RenderPlaneContextKey, (0, import_vue10.ref)("default")), eventZ = (0, import_vue10.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), internalScrollTop = (0, import_vue10.ref)(0), documentVersion = (0, import_vue10.ref)(0), rows = (0, import_vue10.shallowRef)((0, import_vue10.markRaw)([])), pendingSelectionScrollFocusRemap = !1, wheelState = createWheelScrollState(), builtOnce = !1, rebuildVersion = 0, layoutCache, alive = !0, dirtyRowsHint, renderNodeId = null, parser = (0, import_vue10.shallowRef)(
       (0, import_vue10.markRaw)(
         createTuiMarkdownParser({
           streaming: props.streaming,
@@ -20769,7 +21027,16 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
       let nextRows = nextLayout.rows;
       rows.value = (0, import_vue10.markRaw)(nextRows), enqueuePendingMathImages(), reconcileScrollTop();
       let nextScrollTop = internalScrollTop.value, nextVisibleRows = visibleRowSignatures(nextRows, nextScrollTop), nextVisibleGraphics = visibleRowGraphics(nextRows, nextScrollTop), visibleChanged = prevVisibleRows.length !== nextVisibleRows.length || prevVisibleRows.some((row, index) => row !== nextVisibleRows[index]) || prevVisibleGraphics.some((row, index) => row !== nextVisibleGraphics[index]);
-      (!builtOnce || prevScrollTop !== nextScrollTop || visibleChanged) && (documentVersion.value++, selection.refresh());
+      if (!builtOnce || prevScrollTop !== nextScrollTop || visibleChanged) {
+        if (visibleChanged && prevScrollTop === nextScrollTop && prevVisibleGraphics.every((signature) => !signature) && nextVisibleGraphics.every((signature) => !signature)) {
+          let rect = normalizedRect(), changedRows = [], count = Math.max(prevVisibleRows.length, nextVisibleRows.length);
+          for (let index = 0; index < count; index++)
+            prevVisibleRows[index] !== nextVisibleRows[index] && changedRows.push(rect.y + index);
+          markRowsDirty(changedRows);
+        } else
+          markRowsDirty(viewportRows());
+        documentVersion.value++, selection.refresh();
+      }
     }
     function scheduleRebuild() {
       let currentVersion = ++rebuildVersion;
@@ -20826,16 +21093,60 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         out.push(rowGraphicSignature(sourceRows[index]));
       return out;
     }
+    function viewportRows() {
+      let rect = normalizedRect(), result = [];
+      for (let y = rect.y; y < rect.y + rect.h; y++)
+        result.push(y);
+      return result;
+    }
+    function exposedRowsForDelta(y, height, delta) {
+      let result = [];
+      if (delta > 0)
+        for (let offset = height - delta; offset < height; offset++)
+          result.push(y + offset);
+      else
+        for (let offset = 0; offset < -delta; offset++)
+          result.push(y + offset);
+      return result;
+    }
+    function markRowsDirty(nextRows) {
+      let rows2 = new Set(dirtyRowsHint);
+      for (let y of nextRows)
+        rows2.add(y);
+      dirtyRowsHint = Array.from(rows2).sort((a, b) => a - b), renderNodeId && render.markDirtyRows(renderNodeId, dirtyRowsHint);
+    }
+    function visibleGraphicsAt(scrollTop) {
+      let rect = normalizedRect(), { x: clipX, y: clipY } = clipOffsets();
+      return collectVisibleMarkdownImageGraphicIds(rows.value, {
+        x: rect.x,
+        y: rect.y,
+        w: rect.w,
+        h: rect.h,
+        rowOffset: scrollTop + clipY,
+        clipStart: clipX
+      }).size > 0;
+    }
+    function isClipped() {
+      let rect = normalizedRect(), full = normalizedFullRect();
+      return rect.x !== full.x || rect.y !== full.y || rect.w !== full.w || rect.h !== full.h;
+    }
+    function markScrollDamage(prevTop, nextTop) {
+      let rect = normalizedRect(), delta = nextTop - prevTop;
+      if (rect.h <= 0 || !delta)
+        return;
+      let size = terminal.size();
+      props.rowScrollMode === "unsafe-full-row" && rendererCapabilities.value.scrollOperations && rect.x === 0 && rect.w >= size.cols && rect.y >= 0 && rect.y + rect.h <= size.rows && !isClipped() && Math.abs(delta) < rect.h && !dirtyRowsHint?.length && !visibleGraphicsAt(prevTop) ? (render.unsafeScrollPlaneRows(plane.value, rect.y, rect.y + rect.h, delta), markRowsDirty(exposedRowsForDelta(rect.y, rect.h, delta))) : markRowsDirty(viewportRows());
+    }
     function hasControlledScrollTop() {
       return Object.prototype.hasOwnProperty.call(instance?.vnode.props ?? {}, "scrollTop");
     }
     function applyControlledScrollTop(next, remapSelectionFocus = !1) {
       let desired = Math.floor(Number(next) || 0), clamped = clamp3(desired, 0, maxScrollTop()), changed = internalScrollTop.value !== clamped;
-      changed && (internalScrollTop.value = clamped), desired !== clamped && (emit("update:scrollTop", clamped), emit("scroll", clamped)), (changed || remapSelectionFocus) && selection.refresh(remapSelectionFocus ? { remapFocus: !0 } : void 0);
+      changed && (markScrollDamage(internalScrollTop.value, clamped), internalScrollTop.value = clamped), desired !== clamped && (emit("update:scrollTop", clamped), emit("scroll", clamped)), (changed || remapSelectionFocus) && selection.refresh(remapSelectionFocus ? { remapFocus: !0 } : void 0);
     }
     function setScrollTop(next, emitChange = !0, refreshOptions) {
       let desired = Math.floor(Number(next) || 0), clamped = clamp3(desired, 0, maxScrollTop()), changed = internalScrollTop.value !== clamped;
-      changed && (internalScrollTop.value = clamped), emitChange && (changed || refreshOptions?.emitClampEvenIfUnchanged && desired !== clamped) && (emit("update:scrollTop", clamped), emit("scroll", clamped)), (changed || refreshOptions?.remapSelectionFocus) && selection.refresh(refreshOptions?.remapSelectionFocus ? { remapFocus: !0 } : void 0);
+      changed && (markScrollDamage(internalScrollTop.value, clamped), internalScrollTop.value = clamped), emitChange && (changed || refreshOptions?.emitClampEvenIfUnchanged && desired !== clamped) && (emit("update:scrollTop", clamped), emit("scroll", clamped)), (changed || refreshOptions?.remapSelectionFocus) && selection.refresh(refreshOptions?.remapSelectionFocus ? { remapFocus: !0 } : void 0);
     }
     function reconcileScrollTop() {
       let desired = hasControlledScrollTop() ? Math.floor(Number(props.scrollTop) || 0) : internalScrollTop.value, clamped = clamp3(desired, 0, maxScrollTop());
@@ -21046,16 +21357,18 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         keydown: onKeydown
       }
     }));
-    return (0, import_vue10.watchEffect)(() => {
+    (0, import_vue10.watchEffect)(() => {
       if (!props.autoFocus || !visible.value)
         return;
       let manager = events.value, nodeId = eventNode.id.value;
       nodeId && manager && manager.getFocused() !== nodeId && manager.focus(nodeId);
     }), (0, import_vue10.onBeforeUnmount)(() => {
       alive = !1, rebuildVersion++, unsubscribeGraphicsOutput(), unsubscribeMathRenderer(), unsubscribeMathImage(), clearMarkdownImageGraphics(terminal, fullRect.value);
-    }), useRenderNode(() => ({
+    });
+    let renderNode = useRenderNode(() => ({
       zIndex: props.zIndex,
       rect: visible.value ? normalizedRect() : { x: 0, y: 0, w: 0, h: 0 },
+      dirtyRowsHint,
       deps: [
         visible.value,
         absRect.value,
@@ -21068,13 +21381,25 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         props.imageOcclusionRects
       ],
       paint: (dirtyRows) => {
-        withTextWidthProvider(widthProvider, () => {
+        dirtyRowsHint = void 0, withTextWidthProvider(widthProvider, () => {
           if (!visible.value)
             return;
           let r = normalizedRect();
           if (r.w <= 0 || r.h <= 0)
             return;
-          let baseStyle = props.style ?? defaultStyle.value, { x: clipX, y: clipY } = clipOffsets(), isGraphicCovered = (rect) => props.imageOcclusionRects?.some((item) => intersectRect(rect, item)) === !0, keepGraphicIds = collectVisibleMarkdownImageGraphicIds(rows.value, {
+          let baseStyle = props.style ?? defaultStyle.value, { x: clipX, y: clipY } = clipOffsets(), isGraphicCovered = (rect) => props.imageOcclusionRects?.some((item) => intersectRect(rect, item)) === !0, prequeuedGraphicIds = queueClippedVisibleMarkdownImageGraphics(
+            terminal,
+            rows.value,
+            {
+              x: r.x,
+              y: r.y,
+              w: r.w,
+              h: r.h,
+              rowOffset: internalScrollTop.value + clipY,
+              clipStart: clipX,
+              isGraphicCovered
+            }
+          ), keepGraphicIds = collectVisibleMarkdownImageGraphicIds(rows.value, {
             x: r.x,
             y: r.y,
             w: r.w,
@@ -21094,6 +21419,7 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
               baseStyle,
               clear: !0,
               keepGraphicIds,
+              prequeuedGraphicIds,
               isGraphicCovered
             });
           };
@@ -21106,7 +21432,10 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
             paintRow(y);
         });
       }
-    })), () => (0, import_vue10.h)("span", rootProps);
+    }));
+    return (0, import_vue10.watchEffect)(() => {
+      renderNodeId = renderNode.id.value;
+    }), () => (0, import_vue10.h)("span", rootProps);
   }
 });