@simon_he/vue-tui 1.0.1 → 1.1.0

package/dist/mermaid.cjs

@@ -0,0 +1,1707 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/mermaid.ts
+var mermaid_exports = {};
+__export(mermaid_exports, {
+  TBeautifulMermaid: () => TBeautifulMermaid,
+  TBeautifulMermaidText: () => TBeautifulMermaidText,
+  TMermaid: () => TMermaid,
+  TMermaidText: () => TMermaidText2,
+  beautifulMermaidRenderer: () => beautifulMermaidRenderer,
+  createBeautifulMermaidRenderer: () => createBeautifulMermaidRenderer,
+  isSimpleMermaidFlowchartSource: () => isSimpleMermaidFlowchartSource,
+  markMermaidRenderErrorFatal: () => markMermaidRenderErrorFatal
+});
+module.exports = __toCommonJS(mermaid_exports);
+
+// src/vue/components/TMermaidText.ts
+var import_vue8 = require("vue");
+
+// src/vue/context.ts
+var import_vue = require("vue");
+
+// src/vue/injection-key.ts
+var VUE_TUI_INJECTION_PROTOCOL = "v1";
+function injectionKey(name) {
+  return Symbol.for(`@simon_he/vue-tui:${VUE_TUI_INJECTION_PROTOCOL}:${name}`);
+}
+
+// src/vue/context.ts
+var TerminalContextKey = injectionKey("TerminalContext"), LayoutContextKey = injectionKey("LayoutContext"), VisibilityContextKey = injectionKey("VisibilityContext"), EventZIndexContextKey = injectionKey("EventZIndex"), RenderPlaneContextKey = injectionKey("RenderPlane"), ImeAnchorContextKey = injectionKey("ImeAnchor"), TInputPluginsContextKey = injectionKey("TInputPlugins"), TPathPickerProviderContextKey = injectionKey("TPathPickerProvider"), TerminalGraphicsActivityKey = injectionKey(
+  "TerminalGraphicsActivity"
+), DialogContextKey = injectionKey("DialogContext");
+
+// src/vue/composables/use-layout.ts
+var import_vue2 = require("vue");
+function useLayout() {
+  let ctx = (0, import_vue2.inject)(LayoutContextKey, null);
+  if (!ctx)
+    throw new Error("LayoutContext is missing (TerminalProvider/TView)");
+  return ctx;
+}
+
+// src/vue/composables/use-render-node.ts
+var import_vue5 = require("vue");
+
+// src/vue/composables/use-render-stack.ts
+var import_vue3 = require("vue");
+
+// src/vue/render/context.ts
+var RenderStackKey = injectionKey("RenderStack");
+
+// src/vue/composables/use-render-stack.ts
+function useRenderStack() {
+  let stack = (0, import_vue3.inject)(RenderStackKey, null);
+  if (!stack)
+    throw new Error("RenderStack is missing");
+  return stack;
+}
+
+// src/vue/composables/use-terminal.ts
+var import_vue4 = require("vue");
+function useTerminal() {
+  let ctx = (0, import_vue4.inject)(TerminalContextKey, null);
+  if (!ctx)
+    throw new Error("TerminalProvider is missing");
+  return ctx;
+}
+
+// src/core/buffer/eaw-ranges-unicode-17.ts
+var fullWidthRanges = [
+  [4352, 4447],
+  [8986, 8987],
+  [9001, 9002],
+  [9193, 9196],
+  [9200, 9200],
+  [9203, 9203],
+  [9725, 9726],
+  [9748, 9749],
+  [9776, 9783],
+  [9800, 9811],
+  [9855, 9855],
+  [9866, 9871],
+  [9875, 9875],
+  [9889, 9889],
+  [9898, 9899],
+  [9917, 9918],
+  [9924, 9925],
+  [9934, 9934],
+  [9940, 9940],
+  [9962, 9962],
+  [9970, 9971],
+  [9973, 9973],
+  [9978, 9978],
+  [9981, 9981],
+  [9989, 9989],
+  [9994, 9995],
+  [10024, 10024],
+  [10060, 10060],
+  [10062, 10062],
+  [10067, 10069],
+  [10071, 10071],
+  [10133, 10135],
+  [10160, 10160],
+  [10175, 10175],
+  [11035, 11036],
+  [11088, 11088],
+  [11093, 11093],
+  [11904, 11929],
+  [11931, 12019],
+  [12032, 12245],
+  [12272, 12350],
+  [12353, 12438],
+  [12441, 12543],
+  [12549, 12591],
+  [12593, 12686],
+  [12688, 12773],
+  [12783, 12830],
+  [12832, 12871],
+  [12880, 42124],
+  [42128, 42182],
+  [43360, 43388],
+  [44032, 55203],
+  [63744, 64255],
+  [65040, 65049],
+  [65072, 65106],
+  [65108, 65126],
+  [65128, 65131],
+  [65281, 65376],
+  [65504, 65510],
+  [94176, 94180],
+  [94192, 94198],
+  [94208, 101589],
+  [101631, 101662],
+  [101760, 101874],
+  [110576, 110579],
+  [110581, 110587],
+  [110589, 110590],
+  [110592, 110882],
+  [110898, 110898],
+  [110928, 110930],
+  [110933, 110933],
+  [110948, 110951],
+  [110960, 111355],
+  [119552, 119638],
+  [119648, 119670],
+  [126980, 126980],
+  [127183, 127183],
+  [127374, 127374],
+  [127377, 127386],
+  [127488, 127490],
+  [127504, 127547],
+  [127552, 127560],
+  [127568, 127569],
+  [127584, 127589],
+  [127744, 127776],
+  [127789, 127797],
+  [127799, 127868],
+  [127870, 127891],
+  [127904, 127946],
+  [127951, 127955],
+  [127968, 127984],
+  [127988, 127988],
+  [127992, 128062],
+  [128064, 128064],
+  [128066, 128252],
+  [128255, 128317],
+  [128331, 128334],
+  [128336, 128359],
+  [128378, 128378],
+  [128405, 128406],
+  [128420, 128420],
+  [128507, 128591],
+  [128640, 128709],
+  [128716, 128716],
+  [128720, 128722],
+  [128725, 128728],
+  [128732, 128735],
+  [128747, 128748],
+  [128756, 128764],
+  [128992, 129003],
+  [129008, 129008],
+  [129292, 129338],
+  [129340, 129349],
+  [129351, 129535],
+  [129648, 129660],
+  [129664, 129674],
+  [129678, 129734],
+  [129736, 129736],
+  [129741, 129756],
+  [129759, 129770],
+  [129775, 129784],
+  [131072, 196605],
+  [196608, 262141]
+], ambiguousWidthRanges = [
+  [161, 161],
+  [164, 164],
+  [167, 168],
+  [170, 170],
+  [173, 174],
+  [176, 180],
+  [182, 186],
+  [188, 191],
+  [198, 198],
+  [208, 208],
+  [215, 216],
+  [222, 225],
+  [230, 230],
+  [232, 234],
+  [236, 237],
+  [240, 240],
+  [242, 243],
+  [247, 250],
+  [252, 252],
+  [254, 254],
+  [257, 257],
+  [273, 273],
+  [275, 275],
+  [283, 283],
+  [294, 295],
+  [299, 299],
+  [305, 307],
+  [312, 312],
+  [319, 322],
+  [324, 324],
+  [328, 331],
+  [333, 333],
+  [338, 339],
+  [358, 359],
+  [363, 363],
+  [462, 462],
+  [464, 464],
+  [466, 466],
+  [468, 468],
+  [470, 470],
+  [472, 472],
+  [474, 474],
+  [476, 476],
+  [593, 593],
+  [609, 609],
+  [708, 708],
+  [711, 711],
+  [713, 715],
+  [717, 717],
+  [720, 720],
+  [728, 731],
+  [733, 733],
+  [735, 735],
+  [768, 879],
+  [913, 929],
+  [931, 937],
+  [945, 961],
+  [963, 969],
+  [1025, 1025],
+  [1040, 1103],
+  [1105, 1105],
+  [8208, 8208],
+  [8211, 8214],
+  [8216, 8217],
+  [8220, 8221],
+  [8224, 8226],
+  [8228, 8231],
+  [8240, 8240],
+  [8242, 8243],
+  [8245, 8245],
+  [8251, 8251],
+  [8254, 8254],
+  [8308, 8308],
+  [8319, 8319],
+  [8321, 8324],
+  [8364, 8364],
+  [8451, 8451],
+  [8453, 8453],
+  [8457, 8457],
+  [8467, 8467],
+  [8470, 8470],
+  [8481, 8482],
+  [8486, 8486],
+  [8491, 8491],
+  [8531, 8532],
+  [8539, 8542],
+  [8544, 8555],
+  [8560, 8569],
+  [8585, 8585],
+  [8592, 8601],
+  [8632, 8633],
+  [8658, 8658],
+  [8660, 8660],
+  [8679, 8679],
+  [8704, 8704],
+  [8706, 8707],
+  [8711, 8712],
+  [8715, 8715],
+  [8719, 8719],
+  [8721, 8721],
+  [8725, 8725],
+  [8730, 8730],
+  [8733, 8736],
+  [8739, 8739],
+  [8741, 8741],
+  [8743, 8748],
+  [8750, 8750],
+  [8756, 8759],
+  [8764, 8765],
+  [8776, 8776],
+  [8780, 8780],
+  [8786, 8786],
+  [8800, 8801],
+  [8804, 8807],
+  [8810, 8811],
+  [8814, 8815],
+  [8834, 8835],
+  [8838, 8839],
+  [8853, 8853],
+  [8857, 8857],
+  [8869, 8869],
+  [8895, 8895],
+  [8978, 8978],
+  [9312, 9449],
+  [9451, 9547],
+  [9552, 9587],
+  [9600, 9615],
+  [9618, 9621],
+  [9632, 9633],
+  [9635, 9641],
+  [9650, 9651],
+  [9654, 9655],
+  [9660, 9661],
+  [9664, 9665],
+  [9670, 9672],
+  [9675, 9675],
+  [9678, 9681],
+  [9698, 9701],
+  [9711, 9711],
+  [9733, 9734],
+  [9737, 9737],
+  [9742, 9743],
+  [9756, 9756],
+  [9758, 9758],
+  [9792, 9792],
+  [9794, 9794],
+  [9824, 9825],
+  [9827, 9829],
+  [9831, 9834],
+  [9836, 9837],
+  [9839, 9839],
+  [9886, 9887],
+  [9919, 9919],
+  [9926, 9933],
+  [9935, 9939],
+  [9941, 9953],
+  [9955, 9955],
+  [9960, 9961],
+  [9963, 9969],
+  [9972, 9972],
+  [9974, 9977],
+  [9979, 9980],
+  [9982, 9983],
+  [10045, 10045],
+  [10102, 10111],
+  [11094, 11097],
+  [12872, 12879],
+  [57344, 63743],
+  [65024, 65039],
+  [65533, 65533],
+  [127232, 127242],
+  [127248, 127277],
+  [127280, 127337],
+  [127344, 127373],
+  [127375, 127376],
+  [127387, 127404],
+  [917760, 917999],
+  [983040, 1048573],
+  [1048576, 1114109]
+];
+
+// src/core/buffer/width.ts
+function isFullWidthCodePoint(codePoint) {
+  if (codePoint < 4352)
+    return !1;
+  for (let [start, end] of fullWidthRanges) {
+    if (codePoint < start)
+      return !1;
+    if (codePoint <= end)
+      return !0;
+  }
+  return !1;
+}
+function isAmbiguousWidthCodePoint(codePoint) {
+  let first = ambiguousWidthRanges[0], last = ambiguousWidthRanges[ambiguousWidthRanges.length - 1];
+  if (!first || !last || codePoint < first[0] || codePoint > last[1])
+    return !1;
+  for (let [start, end] of ambiguousWidthRanges) {
+    if (codePoint < start)
+      return !1;
+    if (codePoint <= end)
+      return !0;
+  }
+  return !1;
+}
+function isVariationSelectorCodePoint(codePoint) {
+  return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isCombiningMarkCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 6832 && codePoint <= 6911 || // Combining Diacritical Marks Extended
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8447 || // Combining Diacritical Marks for Symbols
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 12330 && codePoint <= 12335 || // EAW=W: Ideographic level tone marks
+  codePoint >= 12441 && codePoint <= 12442 || // EAW=W: Combining Katakana-Hiragana marks
+  codePoint === 94180;
+}
+function isEmojiLike(codePoint) {
+  return codePoint >= 127744 && codePoint <= 129791 || codePoint >= 127462 && codePoint <= 127487;
+}
+var extendedPictographicRe = null;
+try {
+  extendedPictographicRe = new RegExp("\\p{Extended_Pictographic}", "u");
+} catch {
+  extendedPictographicRe = null;
+}
+var emojiPresentationRe = null;
+try {
+  emojiPresentationRe = new RegExp("\\p{Emoji_Presentation}", "u");
+} catch {
+  emojiPresentationRe = null;
+}
+var emojiRe = null;
+try {
+  emojiRe = new RegExp("\\p{Emoji}", "u");
+} catch {
+  emojiRe = null;
+}
+function normalizeCustomWidth(width) {
+  return width === 2 ? 2 : 1;
+}
+function charCellWidth(text, provider = "default") {
+  if (!text)
+    return 1;
+  if (typeof provider == "function")
+    return normalizeCustomWidth(provider(text));
+  if (provider !== "cjk" && text.length === 1 && text.charCodeAt(0) < 4352)
+    return 1;
+  let codePoint = text.codePointAt(0);
+  if (codePoint == null)
+    return 1;
+  let hasVs16 = text.includes("\uFE0F");
+  return isVariationSelectorCodePoint(codePoint) || isCombiningMarkCodePoint(codePoint) || codePoint >= 9472 && codePoint <= 9599 ? 1 : isFullWidthCodePoint(codePoint) || provider === "cjk" && isAmbiguousWidthCodePoint(codePoint) || isEmojiLike(codePoint) || emojiPresentationRe?.test(text) || text.includes("\u20E3") || hasVs16 && emojiRe?.test(text) ? 2 : extendedPictographicRe?.test(text) ? codePoint <= 65535 ? hasVs16 ? 2 : 1 : 2 : 1;
+}
+
+// src/utils/grapheme.ts
+var graphemeSegmenter = null;
+try {
+  let Segmenter = typeof Intl < "u" ? Intl.Segmenter : void 0;
+  graphemeSegmenter = Segmenter ? new Segmenter(void 0, { granularity: "grapheme" }) : null;
+} catch {
+  graphemeSegmenter = null;
+}
+var unicodeMarkRe = null;
+try {
+  unicodeMarkRe = new RegExp("\\p{Mark}", "u");
+} catch {
+  unicodeMarkRe = null;
+}
+function needsGraphemeSegmentation(text) {
+  for (let ch of text) {
+    let cp = ch.codePointAt(0);
+    if (cp === 8205 || cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999 || isCombiningMark(cp) || cp >= 127995 && cp <= 127999 || cp >= 127462 && cp <= 127487 || cp >= 917504 && cp <= 917631)
+      return !0;
+  }
+  return !1;
+}
+function isVariationSelector(codePoint) {
+  return codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isCombiningMark(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || isDevanagariMark(codePoint) || unicodeMarkRe?.test(String.fromCodePoint(codePoint)) === !0;
+}
+function isDevanagariMark(codePoint) {
+  return codePoint >= 2304 && codePoint <= 2307 || codePoint >= 2362 && codePoint <= 2364 || codePoint >= 2366 && codePoint <= 2383 || codePoint >= 2385 && codePoint <= 2391 || codePoint >= 2402 && codePoint <= 2403;
+}
+function isVirama(codePoint) {
+  return codePoint === 2381;
+}
+function isEmojiModifier(codePoint) {
+  return codePoint >= 127995 && codePoint <= 127999;
+}
+function isRegionalIndicator(codePoint) {
+  return codePoint >= 127462 && codePoint <= 127487;
+}
+function isEmojiTag(codePoint) {
+  return codePoint >= 917504 && codePoint <= 917631;
+}
+function fallbackGraphemeSegments(text) {
+  let out = [], segment = "", segmentStart = 0, pos = 0, regionalIndicators = 0, joinNext = !1, pushSegment = () => {
+    segment && out.push({ segment, index: segmentStart });
+  };
+  for (let ch of text) {
+    let codePoint = ch.codePointAt(0), chStart = pos;
+    pos += ch.length, segment !== "" && (joinNext || codePoint === 8205 || isVariationSelector(codePoint) || isCombiningMark(codePoint) || isEmojiModifier(codePoint) || isEmojiTag(codePoint) || isRegionalIndicator(codePoint) && regionalIndicators === 1) ? (segment += ch, isRegionalIndicator(codePoint) ? regionalIndicators++ : !isVariationSelector(codePoint) && !isCombiningMark(codePoint) && (regionalIndicators = 0)) : (pushSegment(), segment = ch, segmentStart = chStart, regionalIndicators = isRegionalIndicator(codePoint) ? 1 : 0), codePoint === 8205 || isVirama(codePoint) ? joinNext = !0 : joinNext && !isVariationSelector(codePoint) && !isCombiningMark(codePoint) && (joinNext = !1);
+  }
+  return pushSegment(), out;
+}
+function segmentedGraphemes(text) {
+  return needsGraphemeSegmentation(text) ? graphemeSegmenter ? graphemeSegmenter.segment(text) : fallbackGraphemeSegments(text) : null;
+}
+
+// src/vue/utils/text.ts
+var renderPassDepth = 0, renderPassTextWidthCache = /* @__PURE__ */ new Map(), textWidthProviderStack = [];
+function currentTextWidthProvider() {
+  return textWidthProviderStack[textWidthProviderStack.length - 1] ?? "default";
+}
+function hasAsciiFastPath(provider) {
+  return typeof provider != "function";
+}
+function canUseDefaultTextCache(provider) {
+  return provider === "default" || provider === "narrow-ambiguous";
+}
+function withTextWidthProvider(provider, fn) {
+  textWidthProviderStack.push(provider ?? "default");
+  try {
+    return fn();
+  } finally {
+    textWidthProviderStack.pop();
+  }
+}
+function isAscii(text) {
+  for (let i = 0; i < text.length; i++)
+    if (text.charCodeAt(i) > 127)
+      return !1;
+  return !0;
+}
+var UNSAFE_FORMAT_CONTROL_RE = /[\u061C\u00AD\u180E\u200B\u200C\u200E\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/u;
+function isUnsafeFormatControl(codePoint) {
+  return codePoint === 1564 || codePoint === 173 || codePoint === 6158 || codePoint === 8203 || codePoint === 8204 || codePoint === 8206 || codePoint === 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303 || codePoint === 65279;
+}
+function hasInlineAsciiControl(text) {
+  for (let i = 0; i < text.length; i++) {
+    let code = text.charCodeAt(i);
+    if (code === 10 || code === 13 || code === 9)
+      return !0;
+  }
+  return !1;
+}
+function hasTextBlockAsciiControl(text) {
+  for (let i = 0; i < text.length; i++) {
+    let code = text.charCodeAt(i);
+    if (code === 9 || code <= 31 && code !== 10 || code === 127)
+      return !0;
+  }
+  return !1;
+}
+function forEachGrapheme(text, cb) {
+  if (!text)
+    return;
+  let segments = segmentedGraphemes(text);
+  if (!segments) {
+    for (let ch of text)
+      if (cb(ch) === !1)
+        return;
+    return;
+  }
+  for (let part of segments)
+    if (cb(part.segment) === !1)
+      return;
+}
+function sanitizeInlineText(text) {
+  if (!text)
+    return "";
+  if (!UNSAFE_FORMAT_CONTROL_RE.test(text) && !hasInlineAsciiControl(text))
+    return text;
+  let out = [];
+  for (let ch of text) {
+    let cp = ch.codePointAt(0);
+    if (cp === 10 || cp === 13 || cp === 9) {
+      out.push(" ");
+      continue;
+    }
+    isUnsafeFormatControl(cp) || out.push(ch);
+  }
+  return out.join("");
+}
+function sanitizeTextBlock(text) {
+  if (!text)
+    return "";
+  if (!UNSAFE_FORMAT_CONTROL_RE.test(text) && !hasTextBlockAsciiControl(text))
+    return text;
+  let out = [];
+  out.length = 0;
+  for (let ch of text) {
+    let cp = ch.codePointAt(0);
+    if (cp !== 13) {
+      if (cp === 9) {
+        out.push(" ");
+        continue;
+      }
+      cp <= 31 && cp !== 10 || cp === 127 || isUnsafeFormatControl(cp) || out.push(ch);
+    }
+  }
+  return out.join("");
+}
+function textCellWidth(text, provider = currentTextWidthProvider()) {
+  if (!text)
+    return 0;
+  if (hasAsciiFastPath(provider) && isAscii(text))
+    return text.length;
+  let useCache = canUseDefaultTextCache(provider);
+  if (useCache && renderPassDepth > 0) {
+    let cached = renderPassTextWidthCache.get(text);
+    if (cached != null)
+      return cached;
+  }
+  if (useCache) {
+    let cached = textWidthCacheGet(text);
+    if (cached != null)
+      return cached;
+  }
+  let cells = 0;
+  return forEachGrapheme(text, (g) => {
+    cells += charCellWidth(g, provider);
+  }), useCache && renderPassDepth > 0 && renderPassTextWidthCache.set(text, cells), useCache && textWidthCacheSet(text, cells), cells;
+}
+var spaceCache = /* @__PURE__ */ new Map(), MAX_CACHED_SPACES = 256;
+function spaces(count) {
+  if (count = Math.max(0, Math.floor(count)), count === 0)
+    return "";
+  let cached = spaceCache.get(count);
+  if (cached)
+    return cached;
+  let v = " ".repeat(count);
+  return spaceCache.size >= MAX_CACHED_SPACES && spaceCache.clear(), spaceCache.set(count, v), v;
+}
+var repeatCharCache = /* @__PURE__ */ new Map(), MAX_REPEAT_CHAR_KEYS = 8, MAX_CACHED_REPEAT_CHAR = 256;
+function repeatChar(ch, count) {
+  if (count = Math.max(0, Math.floor(count)), count === 0 || !ch)
+    return "";
+  let bucket = repeatCharCache.get(ch);
+  bucket || (repeatCharCache.size >= MAX_REPEAT_CHAR_KEYS && repeatCharCache.clear(), bucket = /* @__PURE__ */ new Map(), repeatCharCache.set(ch, bucket));
+  let cached = bucket.get(count);
+  if (cached)
+    return cached;
+  let v = ch.repeat(count);
+  return bucket.size >= MAX_CACHED_REPEAT_CHAR && bucket.clear(), bucket.set(count, v), v;
+}
+function sliceByCells(text, maxCells, provider = currentTextWidthProvider()) {
+  if (maxCells = Math.max(0, Math.floor(maxCells)), maxCells <= 0)
+    return "";
+  if (text && hasAsciiFastPath(provider) && isAscii(text))
+    return text.slice(0, maxCells);
+  let out = [], cells = 0;
+  return forEachGrapheme(text, (g) => {
+    let w = charCellWidth(g, provider);
+    if (cells + w > maxCells)
+      return !1;
+    out.push(g), cells += w;
+  }), out.length ? out.join("") : "";
+}
+function sliceByCellsRange(text, startCells, endCells, provider = currentTextWidthProvider()) {
+  if (startCells = Math.max(0, Math.floor(startCells)), endCells = Math.max(0, Math.floor(endCells)), endCells <= startCells || !text)
+    return "";
+  if (hasAsciiFastPath(provider) && isAscii(text))
+    return text.slice(startCells, endCells);
+  let out = [], cells = 0;
+  return forEachGrapheme(text, (g) => {
+    let w = charCellWidth(g, provider), next = cells + w;
+    if (cells >= endCells)
+      return !1;
+    if (next <= startCells) {
+      cells = next;
+      return;
+    }
+    if (cells < startCells && next > startCells) {
+      out.push(spaces(Math.min(next, endCells) - startCells)), cells = next;
+      return;
+    }
+    if (next > endCells)
+      return out.push(spaces(endCells - cells)), !1;
+    out.push(g), cells = next;
+  }), out.length ? out.join("") : "";
+}
+function padEndByCells(text, width, provider = currentTextWidthProvider()) {
+  width = Math.max(0, Math.floor(width));
+  let cells = text && hasAsciiFastPath(provider) && isAscii(text) ? text.length : textCellWidth(text, provider);
+  return cells >= width ? text : `${text}${spaces(width - cells)}`;
+}
+var textWidthCache = /* @__PURE__ */ new Map(), MAX_TEXT_WIDTH_CACHE = 1024;
+function textWidthCacheGet(text) {
+  let cached = textWidthCache.get(text);
+  return cached == null ? null : (textWidthCache.delete(text), textWidthCache.set(text, cached), cached);
+}
+function textWidthCacheSet(text, cells) {
+  if (textWidthCache.set(text, cells), textWidthCache.size > MAX_TEXT_WIDTH_CACHE) {
+    let firstKey = textWidthCache.keys().next().value;
+    firstKey != null && textWidthCache.delete(firstKey);
+  }
+}
+
+// src/vue/composables/use-render-node.ts
+var pendingInvalidateByScheduler = /* @__PURE__ */ new WeakMap();
+function mergePriority(prev, next) {
+  return prev === "high" || next === "high" ? "high" : prev === "normal" || next === "normal" ? "normal" : "low";
+}
+function requestBatchedInvalidate(scheduler, plane, priority) {
+  let state = pendingInvalidateByScheduler.get(scheduler);
+  if (state || (state = { queued: !1, plane: null, priority: "low" }, pendingInvalidateByScheduler.set(scheduler, state)), state.queued) {
+    state.plane !== null && state.plane !== plane && (state.plane = null), state.priority = mergePriority(state.priority, priority);
+    return;
+  }
+  state.plane = plane, state.priority = priority, state.queued = !0, queueMicrotask(() => {
+    state.queued = !1;
+    let queuedPlane = state.plane, queuedPriority = state.priority;
+    state.plane = null, state.priority = "low", scheduler.invalidate({
+      plane: queuedPlane ?? void 0,
+      priority: queuedPriority
+    });
+  });
+}
+function sameRenderRect(a, b) {
+  return a === b ? !0 : !a || !b ? !1 : a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function sameDeps(a, b) {
+  if (Object.is(a, b))
+    return !0;
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+    return !1;
+  for (let i = 0; i < a.length; i++)
+    if (!Object.is(a[i], b[i]))
+      return !1;
+  return !0;
+}
+function useRenderNode(getOptions) {
+  let { scheduler, render, widthProvider } = useTerminal(), parentStack = useRenderStack(), plane = (0, import_vue5.inject)(RenderPlaneContextKey, (0, import_vue5.ref)("default")), id = (0, import_vue5.ref)(null), lastPlane = (0, import_vue5.ref)(plane.value), lastStack = null, lastZIndex = 0, lastHasRect = !1, lastRect = null, lastDeps, lastHasDeps = !1, options = (0, import_vue5.computed)(() => withTextWidthProvider(widthProvider, getOptions)), stop = (0, import_vue5.watchEffect)(
+    () => {
+      let opt = options.value;
+      opt.deps;
+      let stack = opt.stack ?? parentStack.value, nextPlane = plane.value, hasRect = Object.prototype.hasOwnProperty.call(opt, "rect"), nextRect = hasRect ? opt.rect ?? null : null, nextZIndex = opt.zIndex ?? 0, hasDeps = Object.prototype.hasOwnProperty.call(opt, "deps");
+      if (!stack)
+        return;
+      if (!id.value) {
+        let node = render.register({
+          stack,
+          zIndex: nextZIndex,
+          rect: hasRect ? nextRect : void 0,
+          plane: nextPlane,
+          paint: opt.paint
+        });
+        id.value = node.id, lastPlane.value = nextPlane, lastStack = stack, lastZIndex = nextZIndex, lastHasRect = hasRect, lastRect = nextRect, lastHasDeps = hasDeps, lastDeps = opt.deps, requestBatchedInvalidate(scheduler, nextPlane, opt.priority ?? "normal");
+        return;
+      }
+      let prevPlane = lastPlane.value;
+      if (hasDeps && lastHasDeps && !opt.dirtyRowsHint?.length && lastStack === stack && lastZIndex === nextZIndex && prevPlane === nextPlane && lastHasRect === hasRect && (!hasRect || sameRenderRect(lastRect, nextRect)) && sameDeps(lastDeps, opt.deps))
+        return;
+      let updatePayload = {
+        stack,
+        zIndex: nextZIndex,
+        dirtyRowsHint: opt.dirtyRowsHint,
+        plane: nextPlane,
+        paint: opt.paint
+      };
+      hasRect && (updatePayload.rect = nextRect), render.update(id.value, updatePayload), lastPlane.value = nextPlane, lastStack = stack, lastZIndex = nextZIndex, lastHasRect = hasRect, lastRect = nextRect, lastHasDeps = hasDeps, lastDeps = opt.deps;
+      let priority = opt.priority ?? "normal";
+      requestBatchedInvalidate(scheduler, prevPlane, priority), prevPlane !== nextPlane && requestBatchedInvalidate(scheduler, nextPlane, priority);
+    },
+    { flush: "sync" }
+  );
+  return (0, import_vue5.onBeforeUnmount)(() => {
+    stop(), id.value && (render.unregister(id.value), requestBatchedInvalidate(scheduler, lastPlane.value, "normal"));
+  }), { id };
+}
+
+// src/vue/composables/use-terminal-node.ts
+var import_vue6 = require("vue");
+function wrapHandlers(handlers, widthProvider) {
+  if (!handlers)
+    return {};
+  let out = {};
+  for (let key of Object.keys(handlers)) {
+    let handler = handlers[key];
+    handler && (out[key] = (event) => withTextWidthProvider(widthProvider, () => handler(event)));
+  }
+  return out;
+}
+function useTerminalNode(getOptions) {
+  let { events, widthProvider } = useTerminal(), id = (0, import_vue6.ref)(null), options = (0, import_vue6.computed)(() => withTextWidthProvider(widthProvider, getOptions)), stop = (0, import_vue6.watchEffect)(() => {
+    let manager = events.value;
+    if (!manager)
+      return;
+    let opt = options.value;
+    if (!id.value) {
+      let node = manager.register({
+        rect: opt.rect,
+        zIndex: opt.zIndex ?? 0,
+        visible: opt.visible,
+        focusable: opt.focusable,
+        selectable: opt.selectable,
+        selectionScrollBy: opt.selectionScrollBy,
+        handlers: wrapHandlers(opt.handlers, widthProvider)
+      });
+      id.value = node.id;
+      return;
+    }
+    manager.update(id.value, {
+      rect: opt.rect,
+      zIndex: opt.zIndex ?? 0,
+      visible: opt.visible,
+      focusable: opt.focusable,
+      selectable: opt.selectable,
+      selectionScrollBy: opt.selectionScrollBy,
+      handlers: wrapHandlers(opt.handlers, widthProvider)
+    });
+  });
+  return (0, import_vue6.onBeforeUnmount)(() => {
+    stop();
+    let manager = events.value;
+    manager && id.value && manager.unregister(id.value);
+  }), { id };
+}
+
+// src/vue/composables/use-visibility.ts
+var import_vue7 = require("vue");
+var VUE_TERMINAL_SHOW_CB = "__vueTerminalOnShow", vShowPatched = !1;
+function patchVShow() {
+  if (vShowPatched)
+    return;
+  vShowPatched = !0;
+  let dir = import_vue7.vShow, origBeforeMount = dir.beforeMount, origUpdated = dir.updated, origBeforeUnmount = dir.beforeUnmount, notify = (el, value) => {
+    if (!el || typeof el != "object")
+      return;
+    let cb = el[VUE_TERMINAL_SHOW_CB];
+    cb?.(!!value);
+  };
+  typeof origBeforeMount == "function" && (dir.beforeMount = (el, binding, vnode) => {
+    origBeforeMount(el, binding, vnode), notify(el, binding?.value);
+  }), typeof origUpdated == "function" && (dir.updated = (el, binding, vnode) => {
+    origUpdated(el, binding, vnode), notify(el, binding?.value);
+  }), typeof origBeforeUnmount == "function" && (dir.beforeUnmount = (el, binding, vnode) => {
+    origBeforeUnmount(el, binding, vnode), notify(el, binding?.value);
+  });
+}
+var PLACEHOLDER_STYLE = Object.freeze({
+  position: "absolute",
+  left: "-9999px",
+  top: "0",
+  width: "0",
+  height: "0",
+  overflow: "hidden"
+});
+function useVisibility(options) {
+  patchVShow();
+  let { scheduler } = useTerminal(), parentVisible = (0, import_vue7.inject)(VisibilityContextKey, (0, import_vue7.ref)(!0)), localVisible = (0, import_vue7.ref)(!0), visible = (0, import_vue7.computed)(() => parentVisible.value && localVisible.value);
+  options?.provide && (0, import_vue7.provide)(VisibilityContextKey, visible);
+  let onShow = (value) => {
+    localVisible.value = value, scheduler.invalidate();
+  };
+  return { visible, rootProps: {
+    style: PLACEHOLDER_STYLE,
+    onVnodeBeforeMount: (vnode) => {
+      let el = vnode.el;
+      el && typeof el == "object" && (el[VUE_TERMINAL_SHOW_CB] = onShow);
+    },
+    onVnodeBeforeUnmount: (vnode) => {
+      let el = vnode.el;
+      el && typeof el == "object" && el[VUE_TERMINAL_SHOW_CB] === onShow && delete el[VUE_TERMINAL_SHOW_CB];
+    }
+  } };
+}
+
+// src/vue/utils/rect.ts
+function intersectRect(a, b) {
+  let x0 = Math.max(a.x, b.x), y0 = Math.max(a.y, b.y), x1 = Math.min(a.x + a.w, b.x + b.w), y1 = Math.min(a.y + a.h, b.y + b.h);
+  return x1 <= x0 || y1 <= y0 ? null : { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function translateRect(rect, dx, dy) {
+  return { x: rect.x + dx, y: rect.y + dy, w: rect.w, h: rect.h };
+}
+
+// src/vue/components/TMermaidText.ts
+var TUI_MERMAID_FATAL_RENDER_ERROR = "__vueTuiMermaidFatalRenderError", fatalMermaidRenderErrors = /* @__PURE__ */ new WeakSet(), DEFAULT_MERMAID_RENDER_TIMEOUT_MS = 2500, DEFAULT_MERMAID_MAX_RENDER_SOURCE_CHARS = 2e4, DEFAULT_MERMAID_MAX_RENDER_SOURCE_LINES = 400, DEFAULT_MERMAID_COPIED_DURATION_MS = 1200, UNICODE_MERMAID_BOX_CHARS = Object.freeze({
+  tl: "\u250C",
+  tr: "\u2510",
+  bl: "\u2514",
+  br: "\u2518",
+  h: "\u2500",
+  v: "\u2502"
+}), ASCII_MERMAID_BOX_CHARS = Object.freeze({
+  tl: "+",
+  tr: "+",
+  bl: "+",
+  br: "+",
+  h: "-",
+  v: "|"
+}), DEFAULT_MERMAID_MAX_RENDER_FLOW_STATEMENTS = 120, SIMPLE_MERMAID_DIRECTIVE_RE = /^(?:graph|flowchart)\s+(?:TB|TD|BT|LR|RL)\s*$/i, MERMAID_INIT_DIRECTIVE_RE = /^%%\{/, MERMAID_COMMENT_RE = /^%%/, MERMAID_FRONTMATTER_DELIMITER_RE = /^---\s*$/, SIMPLE_MERMAID_FLOW_STATEMENT_START_RE = /^(?:"[^"]+"|'[^']+'|`[^`]+`|[A-Za-z0-9_][A-Za-z0-9_-]*)/, COMPLEX_MERMAID_FLOW_FEATURE_RE = /^(?:subgraph|end|classDef|class|click|style|linkStyle|accTitle|accDescr|direction)\b/i, ESC = "\x1B", BEL = "\x07", TERMINAL_ESCAPE_RE = new RegExp(
+  [
+    `${ESC}\\][\\s\\S]*?(?:${BEL}|${ESC}\\\\)`,
+    `${ESC}[PX^_][\\s\\S]*?${ESC}\\\\`,
+    `${ESC}\\[[0-?]*[ -/]*[@-~]`,
+    `${ESC}[@-Z\\\\-_]`
+  ].join("|"),
+  "g"
+);
+function stripTerminalEscapes(value) {
+  return value.replace(TERMINAL_ESCAPE_RE, "");
+}
+function normalizeNonNegativeInt(value, fallback) {
+  let n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : fallback;
+}
+function countLinesUpTo(value, max) {
+  if (max <= 0)
+    return 0;
+  let lines = 1;
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    if (!(code !== 10 && code !== 13) && (lines++, code === 13 && value.charCodeAt(index + 1) === 10 && index++, lines > max))
+      return lines;
+  }
+  return lines;
+}
+function createMermaidScannerState() {
+  return {
+    quote: "",
+    escaped: !1,
+    squareDepth: 0,
+    parenDepth: 0,
+    braceDepth: 0,
+    pipeLabel: !1
+  };
+}
+function scannerAtTopLevel(state) {
+  return !state.quote && !state.pipeLabel && state.squareDepth === 0 && state.parenDepth === 0 && state.braceDepth === 0;
+}
+function advanceMermaidScannerState(state, ch) {
+  if (state.pipeLabel) {
+    if (state.escaped) {
+      state.escaped = !1;
+      return;
+    }
+    if (ch === "\\") {
+      state.escaped = !0;
+      return;
+    }
+    ch === "|" && (state.pipeLabel = !1);
+    return;
+  }
+  if (state.quote) {
+    if (state.escaped) {
+      state.escaped = !1;
+      return;
+    }
+    if (ch === "\\") {
+      state.escaped = !0;
+      return;
+    }
+    ch === state.quote && (state.quote = "");
+    return;
+  }
+  if (ch === '"' || ch === "'" || ch === "`") {
+    state.quote = ch, state.escaped = !1;
+    return;
+  }
+  if (ch === "|" && scannerAtTopLevel(state)) {
+    state.pipeLabel = !0, state.escaped = !1;
+    return;
+  }
+  if (ch === "[") {
+    state.squareDepth++;
+    return;
+  }
+  if (ch === "]") {
+    state.squareDepth = Math.max(0, state.squareDepth - 1);
+    return;
+  }
+  if (ch === "(") {
+    state.parenDepth++;
+    return;
+  }
+  if (ch === ")") {
+    state.parenDepth = Math.max(0, state.parenDepth - 1);
+    return;
+  }
+  if (ch === "{") {
+    state.braceDepth++;
+    return;
+  }
+  ch === "}" && (state.braceDepth = Math.max(0, state.braceDepth - 1));
+}
+function splitMermaidLineStatements(line) {
+  let out = [], state = createMermaidScannerState(), start = 0;
+  for (let index = 0; index < line.length; index++) {
+    let ch = line[index] ?? "";
+    if (ch === ";" && scannerAtTopLevel(state)) {
+      let statement = line.slice(start, index).trim();
+      statement && out.push(statement), start = index + 1;
+      continue;
+    }
+    advanceMermaidScannerState(state, ch);
+  }
+  let tail = line.slice(start).trim();
+  return tail && out.push(tail), out;
+}
+function stripTopLevelMermaidComment(statement) {
+  let state = createMermaidScannerState();
+  for (let index = 0; index < statement.length; index++) {
+    let ch = statement[index] ?? "";
+    if (ch === "%" && statement[index + 1] === "%" && scannerAtTopLevel(state))
+      return statement.slice(0, index).trim();
+    advanceMermaidScannerState(state, ch);
+  }
+  return statement.trim();
+}
+function mermaidSourceLines(code) {
+  return String(code ?? "").replace(/\r\n?/g, `
+`).split(`
+`);
+}
+function mermaidSourceStatements(code) {
+  let statements = [];
+  for (let rawLine of mermaidSourceLines(code)) {
+    let line = rawLine.trim();
+    if (line) {
+      if (MERMAID_INIT_DIRECTIVE_RE.test(line) || MERMAID_FRONTMATTER_DELIMITER_RE.test(line)) {
+        statements.push(line);
+        continue;
+      }
+      if (!MERMAID_COMMENT_RE.test(line))
+        for (let rawStatement of splitMermaidLineStatements(line)) {
+          let statement = stripTopLevelMermaidComment(rawStatement);
+          !statement || MERMAID_COMMENT_RE.test(statement) || statements.push(statement);
+        }
+    }
+  }
+  return statements;
+}
+function isForbiddenMermaidFlowStatement(statement) {
+  return MERMAID_INIT_DIRECTIVE_RE.test(statement) || MERMAID_FRONTMATTER_DELIMITER_RE.test(statement) || COMPLEX_MERMAID_FLOW_FEATURE_RE.test(statement);
+}
+function hasTopLevelMermaidComplexToken(statement) {
+  let state = createMermaidScannerState();
+  for (let index = 0; index < statement.length; index++) {
+    let ch = statement[index] ?? "";
+    if (scannerAtTopLevel(state) && (ch === "@" || statement.startsWith(":::", index) && /[A-Za-z_]/.test(statement[index + 3] ?? "")))
+      return !0;
+    advanceMermaidScannerState(state, ch);
+  }
+  return !1;
+}
+function isSimpleMermaidFlowStatement(statement) {
+  return SIMPLE_MERMAID_DIRECTIVE_RE.test(statement) || isForbiddenMermaidFlowStatement(statement) || hasTopLevelMermaidComplexToken(statement) ? !1 : SIMPLE_MERMAID_FLOW_STATEMENT_START_RE.test(statement);
+}
+function isSimpleMermaidFlowchartSource(code) {
+  let statements = mermaidSourceStatements(code), sawDirective = !1, renderableStatements = 0;
+  for (let statement of statements) {
+    if (!sawDirective) {
+      if (!SIMPLE_MERMAID_DIRECTIVE_RE.test(statement))
+        return !1;
+      sawDirective = !0;
+      continue;
+    }
+    if (!isSimpleMermaidFlowStatement(statement) || (renderableStatements++, renderableStatements > DEFAULT_MERMAID_MAX_RENDER_FLOW_STATEMENTS))
+      return !1;
+  }
+  return sawDirective && renderableStatements > 0;
+}
+function clipboardCanWrite(api) {
+  return api.canWrite ?? api.supported;
+}
+var MERMAID_RENDER_TIMEOUT = Symbol("MERMAID_RENDER_TIMEOUT");
+function markMermaidRenderErrorFatal(error) {
+  let normalized = error instanceof Error ? error : new Error(String(error));
+  fatalMermaidRenderErrors.add(normalized);
+  try {
+    Object.defineProperty(normalized, TUI_MERMAID_FATAL_RENDER_ERROR, {
+      value: !0,
+      configurable: !0
+    });
+  } catch {
+    try {
+      normalized[TUI_MERMAID_FATAL_RENDER_ERROR] = !0;
+    } catch {
+    }
+  }
+  return normalized;
+}
+function splitRenderedOutput(value) {
+  let lines = sanitizeTextBlock(
+    stripTerminalEscapes(String(value ?? "")).replace(/\r\n?/g, `
+`)
+  ).split(`
+`);
+  return lines.length ? lines : [""];
+}
+function hasVisibleRenderedOutput(value) {
+  return value.some((line) => line.trim().length > 0);
+}
+var tMermaidTextProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, default: void 0 },
+  zIndex: { type: Number, default: 0 },
+  content: { type: String, default: "" },
+  code: { type: String, default: void 0 },
+  style: { type: Object, default: void 0 },
+  loadingStyle: { type: Object, default: void 0 },
+  errorStyle: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 },
+  final: { type: Boolean, default: !0 },
+  streaming: { type: Boolean, default: !1 },
+  ascii: { type: Boolean, default: !1 },
+  paddingX: { type: Number, default: void 0 },
+  paddingY: { type: Number, default: void 0 },
+  boxBorderPadding: { type: Number, default: void 0 },
+  options: {
+    type: Object,
+    default: void 0
+  },
+  renderer: {
+    type: Function,
+    default: void 0
+  },
+  // Deprecated source-first compatibility props.
+  // Source-first Mermaid never paints loading/incomplete/error placeholders;
+  // renderer failure keeps source visible. These props remain for source compatibility.
+  isTransientError: {
+    type: Function,
+    default: void 0
+  },
+  shouldRenderSource: {
+    type: Function,
+    default: void 0
+  },
+  // Deprecated source-first compatibility text props.
+  // Kept so existing callers do not break, but not used by the source-first renderer.
+  loadingText: {
+    type: String,
+    default: "Rendering Mermaid diagram..."
+  },
+  incompleteText: {
+    type: String,
+    default: "Waiting for complete Mermaid diagram..."
+  },
+  missingDependencyText: {
+    type: String,
+    default: "Install the Mermaid renderer package and use TMermaidText from @simon_he/vue-tui/mermaid or @simon_he/vue-tui/agent/mermaid, or pass a renderer prop."
+  },
+  errorText: {
+    type: String,
+    default: "Mermaid render failed"
+  },
+  showErrorDetails: {
+    type: Boolean,
+    default: !0
+  },
+  box: { type: Boolean, default: !0 },
+  title: { type: String, default: "mermaid" },
+  copyButton: { type: Boolean, default: !0 },
+  copyText: { type: String, default: "copy" },
+  copiedText: { type: String, default: "copied" },
+  renderTimeoutMs: { type: Number, default: DEFAULT_MERMAID_RENDER_TIMEOUT_MS },
+  maxRenderSourceChars: { type: Number, default: DEFAULT_MERMAID_MAX_RENDER_SOURCE_CHARS },
+  maxRenderSourceLines: { type: Number, default: DEFAULT_MERMAID_MAX_RENDER_SOURCE_LINES },
+  copiedDurationMs: { type: Number, default: DEFAULT_MERMAID_COPIED_DURATION_MS }
+}, TMermaidText = (0, import_vue8.defineComponent)({
+  name: "TMermaidText",
+  props: tMermaidTextProps,
+  emits: {
+    copy: (_payload) => !0
+  },
+  setup(props, { emit }) {
+    let instance = (0, import_vue8.getCurrentInstance)(), terminalContext = useTerminal(), { terminal, defaultStyle, scheduler, widthProvider } = terminalContext, layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue8.inject)(EventZIndexContextKey, (0, import_vue8.computed)(() => 0)), renderedSnapshot = (0, import_vue8.shallowRef)(null), documentVersion = (0, import_vue8.shallowRef)(0), copied = (0, import_vue8.shallowRef)(!1), builtOnce = !1, renderVersion = 0, alive = !0, frameTaskId = `TMermaidText:${instance?.uid ?? "unknown"}:mermaid`, copiedTimer = null, copyRequestVersion = 0, source = (0, import_vue8.computed)(() => props.code ?? props.content ?? ""), waitingForStreamingSourceToFinish = (0, import_vue8.computed)(() => props.streaming && !props.final);
+    function bump() {
+      documentVersion.value++;
+    }
+    function resolveAsciiOptions() {
+      let base = props.options ?? {};
+      return {
+        ...base,
+        useAscii: props.ascii,
+        paddingX: props.paddingX ?? base.paddingX,
+        paddingY: props.paddingY ?? base.paddingY,
+        boxBorderPadding: props.boxBorderPadding ?? base.boxBorderPadding,
+        colorMode: "none"
+      };
+    }
+    function clearCopiedTimer() {
+      copiedTimer != null && (clearTimeout(copiedTimer), copiedTimer = null);
+    }
+    function setCopied(next, repaint = !0) {
+      next || clearCopiedTimer(), copied.value !== next && (copied.value = next, repaint && bump());
+    }
+    function resetCopyFeedback(repaint = !0) {
+      copyRequestVersion++, setCopied(!1, repaint);
+    }
+    function clearRenderedSnapshot() {
+      return renderedSnapshot.value == null ? !1 : (renderedSnapshot.value = null, !0);
+    }
+    function showCopiedFeedback() {
+      clearCopiedTimer();
+      let duration = normalizeNonNegativeInt(
+        props.copiedDurationMs,
+        DEFAULT_MERMAID_COPIED_DURATION_MS
+      );
+      if (duration <= 0) {
+        setCopied(!1);
+        return;
+      }
+      setCopied(!0), copiedTimer = setTimeout(() => {
+        copiedTimer = null, alive && setCopied(!1);
+      }, duration);
+    }
+    function shouldSkipRenderForSize(code) {
+      let maxChars = normalizeNonNegativeInt(
+        props.maxRenderSourceChars,
+        DEFAULT_MERMAID_MAX_RENDER_SOURCE_CHARS
+      );
+      if (maxChars > 0 && code.length > maxChars)
+        return !0;
+      let maxLines = normalizeNonNegativeInt(
+        props.maxRenderSourceLines,
+        DEFAULT_MERMAID_MAX_RENDER_SOURCE_LINES
+      );
+      return maxLines > 0 && countLinesUpTo(code, maxLines) > maxLines;
+    }
+    function shouldSkipRender(code) {
+      if (shouldSkipRenderForSize(code))
+        return !0;
+      let shouldRenderSource = props.shouldRenderSource;
+      if (!shouldRenderSource)
+        return !1;
+      try {
+        return !shouldRenderSource(code, {
+          final: props.final,
+          streaming: props.streaming
+        });
+      } catch {
+        return !0;
+      }
+    }
+    async function renderWithTimeout(renderer, code, options) {
+      let timeoutMs = normalizeNonNegativeInt(
+        props.renderTimeoutMs,
+        DEFAULT_MERMAID_RENDER_TIMEOUT_MS
+      );
+      if (timeoutMs <= 0)
+        return await renderer(code, options);
+      let timer = null;
+      try {
+        return await Promise.race([
+          Promise.resolve().then(() => renderer(code, options)),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(MERMAID_RENDER_TIMEOUT), timeoutMs);
+          })
+        ]);
+      } finally {
+        timer != null && clearTimeout(timer);
+      }
+    }
+    function clearRenderState() {
+      renderedSnapshot.value = null;
+    }
+    function acceptRenderedSnapshot(code, rendered) {
+      let renderedLines = splitRenderedOutput(rendered);
+      if (!hasVisibleRenderedOutput(renderedLines)) {
+        renderedSnapshot.value = null;
+        return;
+      }
+      renderedSnapshot.value = (0, import_vue8.markRaw)({
+        source: code,
+        lines: (0, import_vue8.markRaw)(renderedLines)
+      });
+    }
+    async function renderNow(version) {
+      let code = source.value;
+      if (!code.trim()) {
+        if (!alive || version !== renderVersion)
+          return;
+        clearRenderState(), bump();
+        return;
+      }
+      if (waitingForStreamingSourceToFinish.value) {
+        if (!alive || version !== renderVersion)
+          return;
+        clearRenderState(), bump();
+        return;
+      }
+      if (shouldSkipRender(code)) {
+        if (!alive || version !== renderVersion)
+          return;
+        clearRenderState(), bump();
+        return;
+      }
+      renderedSnapshot.value = null, bump();
+      try {
+        let renderer = props.renderer;
+        if (!renderer) {
+          if (!alive || version !== renderVersion)
+            return;
+          clearRenderState(), bump();
+          return;
+        }
+        let rendered = await renderWithTimeout(renderer, code, resolveAsciiOptions());
+        if (!alive || version !== renderVersion)
+          return;
+        acceptRenderedSnapshot(code, rendered), bump();
+      } catch {
+        if (!alive || version !== renderVersion)
+          return;
+        clearRenderState(), bump();
+      }
+    }
+    function scheduleRender() {
+      let version = ++renderVersion, copiedWasVisible = copied.value;
+      resetCopyFeedback(!1);
+      let snapshotCleared = clearRenderedSnapshot();
+      if (waitingForStreamingSourceToFinish.value) {
+        builtOnce = !0, scheduler.cancelFrameTask?.(frameTaskId), (copiedWasVisible || snapshotCleared) && bump();
+        return;
+      }
+      if (!builtOnce || !props.streaming) {
+        builtOnce = !0, renderNow(version);
+        return;
+      }
+      (copiedWasVisible || snapshotCleared) && bump(), scheduler.queueFrameTask({
+        id: frameTaskId,
+        reason: "stream",
+        priority: "low",
+        sync: !1,
+        run: () => {
+          alive && version === renderVersion && renderNow(version);
+        }
+      }) === !1 && renderNow(version);
+    }
+    (0, import_vue8.watch)(
+      [
+        source,
+        () => props.renderer,
+        () => props.ascii,
+        () => props.paddingX,
+        () => props.paddingY,
+        () => props.boxBorderPadding,
+        () => props.options,
+        () => props.streaming,
+        () => props.final,
+        () => props.renderTimeoutMs,
+        () => props.maxRenderSourceChars,
+        () => props.maxRenderSourceLines,
+        () => props.shouldRenderSource
+      ],
+      () => {
+        scheduleRender();
+      },
+      { immediate: !0, deep: !0 }
+    ), (0, import_vue8.onBeforeUnmount)(() => {
+      alive = !1, renderVersion++, clearCopiedTimer(), scheduler.cancelFrameTask?.(frameTaskId);
+    });
+    let hasBox = (0, import_vue8.computed)(() => props.box !== !1), normalizedWidth = (0, import_vue8.computed)(() => {
+      let width = Math.floor(Number(props.w));
+      return Number.isFinite(width) ? Math.max(0, width) : 0;
+    }), reservesBoxRows = (0, import_vue8.computed)(() => hasBox.value && normalizedWidth.value >= 2), boxChars = (0, import_vue8.computed)(
+      () => props.ascii ? ASCII_MERMAID_BOX_CHARS : UNICODE_MERMAID_BOX_CHARS
+    ), sourceLines = (0, import_vue8.computed)(() => splitRenderedOutput(source.value)), displayLines = (0, import_vue8.computed)(() => {
+      let snapshot = renderedSnapshot.value;
+      return snapshot && snapshot.source === source.value && hasVisibleRenderedOutput(snapshot.lines) ? snapshot.lines : sourceLines.value;
+    }), currentStyle = (0, import_vue8.computed)(() => props.style ?? defaultStyle.value), fullHeight = (0, import_vue8.computed)(() => {
+      if (props.h != null) {
+        let h3 = Math.floor(Number(props.h));
+        return Number.isFinite(h3) ? Math.max(0, h3) : 0;
+      }
+      let autoContentHeight = Math.max(1, displayLines.value.length);
+      return reservesBoxRows.value ? autoContentHeight + 2 : autoContentHeight;
+    }), fullRect = (0, import_vue8.computed)(() => translateRect(
+      { x: props.x, y: props.y, w: props.w, h: fullHeight.value },
+      layout.originX,
+      layout.originY
+    )), absRect = (0, import_vue8.computed)(() => {
+      let translated = fullRect.value;
+      return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
+    }), copyLabel = (0, import_vue8.computed)(() => copied.value ? props.copiedText : props.copyText);
+    function cellWidth(value) {
+      return withTextWidthProvider(widthProvider, () => textCellWidth(value));
+    }
+    function sliceCells(text, maxCells) {
+      return withTextWidthProvider(widthProvider, () => sliceByCells(text, maxCells));
+    }
+    function sliceCellsRange(text, startCells, endCells) {
+      return withTextWidthProvider(
+        widthProvider,
+        () => sliceByCellsRange(text, startCells, endCells)
+      );
+    }
+    function padCells(text, width) {
+      return withTextWidthProvider(widthProvider, () => padEndByCells(text, width));
+    }
+    function canDrawBox(width, height) {
+      return hasBox.value && Math.floor(width) >= 2 && Math.floor(height) >= 2;
+    }
+    function segmentCells(text) {
+      return cellWidth(text);
+    }
+    function headerCopySegment(width) {
+      if (!hasBox.value || !props.copyButton)
+        return null;
+      let rowWidth = Math.max(0, Math.floor(width));
+      if (rowWidth < 4)
+        return null;
+      let label = sanitizeInlineText(copyLabel.value);
+      if (!label)
+        return null;
+      let maxCells = Math.max(0, rowWidth - 2), text = sliceCells(` ${label} `, maxCells), cells = segmentCells(text);
+      return !text || cells <= 0 ? null : {
+        text,
+        start: Math.max(1, rowWidth - cells - 1),
+        cells
+      };
+    }
+    function headerTitleSegment(width, copy) {
+      if (!hasBox.value)
+        return null;
+      let rowWidth = Math.max(0, Math.floor(width));
+      if (rowWidth < 4)
+        return null;
+      let title = sanitizeInlineText(props.title);
+      if (!title)
+        return null;
+      let titleStart = 1, titleEnd = copy ? Math.max(titleStart, copy.start - 1) : rowWidth - 1, maxCells = Math.max(0, titleEnd - titleStart);
+      if (maxCells <= 0)
+        return null;
+      let text = sliceCells(` ${title} `, maxCells), cells = segmentCells(text);
+      return !text || cells <= 0 ? null : {
+        text,
+        start: titleStart,
+        cells
+      };
+    }
+    let copyHitRect = (0, import_vue8.computed)(() => {
+      let full = fullRect.value;
+      if (!visible.value || !props.copyButton || !canDrawBox(full.w, full.h))
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let copy = headerCopySegment(Math.max(0, Math.floor(full.w)));
+      if (!copy)
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let raw = {
+        x: Math.floor(full.x) + copy.start,
+        y: Math.floor(full.y),
+        w: copy.cells,
+        h: 1
+      };
+      return layout.clipRect ? intersectRect(raw, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : raw;
+    });
+    async function writeClipboardText(text) {
+      let contextClipboard = terminalContext.clipboard;
+      if (contextClipboard) {
+        if (!clipboardCanWrite(contextClipboard))
+          throw new Error("Clipboard write not available in this runtime");
+        await contextClipboard.writeText(text);
+        return;
+      }
+      let navClipboard = globalThis.navigator?.clipboard;
+      if (navClipboard && typeof navClipboard.writeText == "function") {
+        await navClipboard.writeText(text);
+        return;
+      }
+      throw new Error("Clipboard write not available in this runtime");
+    }
+    async function copySource() {
+      let text = source.value, requestVersion = ++copyRequestVersion, ok = !1, copyError;
+      try {
+        await writeClipboardText(text), ok = !0;
+      } catch (err) {
+        copyError = err;
+      }
+      if (!alive)
+        return;
+      requestVersion === copyRequestVersion && source.value === text && (ok ? showCopiedFeedback() : setCopied(!1)), emit("copy", ok ? { text, ok } : { text, ok, error: copyError });
+    }
+    function onCopyClick(event) {
+      event.preventDefault(), event.stopPropagation(), copySource();
+    }
+    function onCopyKeydown(event) {
+      event.key !== "Enter" && event.key !== " " || (event.preventDefault(), event.stopPropagation(), copySource());
+    }
+    let copyNodeActive = (0, import_vue8.computed)(
+      () => visible.value && props.copyButton && copyHitRect.value.w > 0 && copyHitRect.value.h > 0
+    );
+    useTerminalNode(() => ({
+      rect: copyHitRect.value,
+      zIndex: (parentEventZ.value ?? 0) + props.zIndex + 1,
+      visible: copyNodeActive.value,
+      focusable: copyNodeActive.value,
+      selectable: !1,
+      handlers: copyNodeActive.value ? {
+        click: onCopyClick,
+        keydown: onCopyKeydown
+      } : {}
+    }));
+    function overlayCells(row, segment, width) {
+      let rowWidth = Math.max(0, Math.floor(width)), start = Math.max(0, Math.floor(segment.start));
+      if (rowWidth <= 1 || start >= rowWidth - 1 || segment.cells <= 0)
+        return row;
+      let maxCells = Math.max(0, rowWidth - 1 - start), text = sliceCells(segment.text, maxCells), cells = segmentCells(text);
+      return !text || cells <= 0 ? row : `${sliceCells(row, start)}${text}${sliceCellsRange(row, start + cells, rowWidth)}`;
+    }
+    function contentLine(rowIndex, width, pad) {
+      let src = displayLines.value[rowIndex] ?? "", clipped = sliceCells(src, width);
+      return pad ? padCells(clipped, width) : clipped;
+    }
+    function boxRow(rowIndex, width, height) {
+      let rowWidth = Math.max(0, Math.floor(width)), rowHeight = Math.max(0, Math.floor(height));
+      if (!canDrawBox(rowWidth, rowHeight))
+        return contentLine(rowIndex, rowWidth, props.clear);
+      let chars = boxChars.value, innerW = Math.max(0, rowWidth - 2);
+      if (rowIndex === 0) {
+        let row = `${chars.tl}${repeatChar(chars.h, innerW)}${chars.tr}`, copy = headerCopySegment(rowWidth), title = headerTitleSegment(rowWidth, copy);
+        return title && (row = overlayCells(row, title, rowWidth)), copy && (row = overlayCells(row, copy, rowWidth)), row;
+      }
+      return rowIndex === rowHeight - 1 ? `${chars.bl}${repeatChar(chars.h, innerW)}${chars.br}` : `${chars.v}${contentLine(rowIndex - 1, innerW, !0)}${chars.v}`;
+    }
+    return useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? absRect.value : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        absRect.value,
+        fullRect.value,
+        displayLines.value,
+        currentStyle.value,
+        props.clear,
+        renderedSnapshot.value,
+        hasBox.value,
+        boxChars.value,
+        props.title,
+        props.copyButton,
+        copyLabel.value,
+        documentVersion.value
+      ],
+      paint: (dirtyRows) => {
+        withTextWidthProvider(widthProvider, () => {
+          if (!visible.value)
+            return;
+          let r = absRect.value, full = fullRect.value;
+          if (r.w <= 0 || r.h <= 0)
+            return;
+          let style = currentStyle.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), fullW = Math.max(0, Math.floor(full.w)), fullH = Math.max(0, Math.floor(full.h)), blank = props.clear ? spaces(r.w) : "", paintRow = (y) => {
+            if (y < r.y || y >= r.y + r.h)
+              return;
+            let rowIndex = y - fullY;
+            if (rowIndex < 0 || rowIndex >= fullH) {
+              props.clear && terminal.write(blank, { x: r.x, y, style });
+              return;
+            }
+            let src = boxRow(rowIndex, fullW, fullH), clipped = dx > 0 ? sliceCellsRange(src, dx, dx + r.w) : sliceCells(src, r.w), value = props.clear ? padCells(clipped, r.w) : clipped;
+            (value || props.clear) && terminal.write(value, { x: r.x, y, style });
+          };
+          if (dirtyRows?.length) {
+            for (let y of dirtyRows)
+              paintRow(y);
+            return;
+          }
+          for (let y = r.y; y < r.y + r.h; y++)
+            paintRow(y);
+        });
+      }
+    })), () => (0, import_vue8.h)("span", rootProps);
+  }
+});
+
+// src/vue/mermaid/beautiful-mermaid.ts
+var import_vue9 = require("vue");
+var BEAUTIFUL_MERMAID_INSTALL_HINT = "Install beautiful-mermaid and use TMermaidText from @simon_he/vue-tui/mermaid or @simon_he/vue-tui/agent/mermaid, or pass a custom renderer prop.", MISSING_BEAUTIFUL_MERMAID_ERROR_CODE = "VUE_TUI_MISSING_BEAUTIFUL_MERMAID", INVALID_BEAUTIFUL_MERMAID_EXPORT_ERROR_CODE = "VUE_TUI_INVALID_BEAUTIFUL_MERMAID_EXPORT", cachedBeautifulMermaid = null;
+function functionValue(value) {
+  return typeof value == "function" ? value : null;
+}
+function functionProp(target, key) {
+  if (!target || typeof target != "object" || !(key in target))
+    return null;
+  let value = target[key];
+  return typeof value == "function" ? value : null;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function codedError(message, code) {
+  let error = new Error(message);
+  return error.code = code, error;
+}
+function missingBeautifulMermaidError(error) {
+  if (error && typeof error == "object" && errorCode(error) === MISSING_BEAUTIFUL_MERMAID_ERROR_CODE)
+    return markMermaidRenderErrorFatal(error);
+  let detail = errorMessage(error);
+  return markMermaidRenderErrorFatal(
+    codedError(
+      `${BEAUTIFUL_MERMAID_INSTALL_HINT} (${detail})`,
+      MISSING_BEAUTIFUL_MERMAID_ERROR_CODE
+    )
+  );
+}
+function errorCode(error) {
+  if (!error || typeof error != "object")
+    return "";
+  let value = error.code;
+  return typeof value == "string" ? value : "";
+}
+function errorCause(error) {
+  if (!(!error || typeof error != "object"))
+    return error.cause;
+}
+function isMissingBeautifulMermaid(error) {
+  return isMissingBeautifulMermaidWithSeen(error, /* @__PURE__ */ new WeakSet());
+}
+function isMissingBeautifulMermaidWithSeen(error, seen) {
+  if (error && typeof error == "object") {
+    if (seen.has(error))
+      return !1;
+    seen.add(error);
+  }
+  let message = errorMessage(error), code = errorCode(error);
+  if (code === MISSING_BEAUTIFUL_MERMAID_ERROR_CODE || (/Cannot find package ['"]beautiful-mermaid['"]/.test(message) || /Cannot find module ['"]beautiful-mermaid['"]/.test(message) || /Cannot resolve module ['"]beautiful-mermaid['"]/.test(message) || /Can't resolve ['"]beautiful-mermaid['"]/.test(message) || /Failed to resolve module specifier ['"]beautiful-mermaid['"]/.test(message) || /Failed to resolve import ['"]beautiful-mermaid['"]/.test(message) || /Could not resolve ['"]beautiful-mermaid['"]/.test(message)) && (code === "" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || code === "UNRESOLVED_IMPORT"))
+    return !0;
+  let cause = errorCause(error);
+  return cause !== void 0 && isMissingBeautifulMermaidWithSeen(cause, seen);
+}
+function resolveBeautifulMermaidRenderer(mod) {
+  let renderer = functionProp(mod, "renderMermaidASCII") ?? functionProp(mod, "renderMermaidAscii") ?? functionValue(mod.default) ?? functionProp(mod.default, "renderMermaidASCII") ?? functionProp(mod.default, "renderMermaidAscii");
+  if (!renderer)
+    throw markMermaidRenderErrorFatal(
+      codedError(
+        "beautiful-mermaid is installed but does not export renderMermaidASCII.",
+        INVALID_BEAUTIFUL_MERMAID_EXPORT_ERROR_CODE
+      )
+    );
+  return renderer;
+}
+function hasErrorCode(error, code, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!error || typeof error != "object" || seen.has(error))
+    return !1;
+  if (seen.add(error), errorCode(error) === code)
+    return !0;
+  let cause = errorCause(error);
+  return cause !== void 0 && hasErrorCode(cause, code, seen);
+}
+function isBeautifulMermaidExportError(error) {
+  return hasErrorCode(error, INVALID_BEAUTIFUL_MERMAID_EXPORT_ERROR_CODE);
+}
+var isTransientBeautifulMermaidRenderError = (error) => !(isMissingBeautifulMermaid(error) || isBeautifulMermaidExportError(error));
+async function loadBeautifulMermaid() {
+  return cachedBeautifulMermaid || (cachedBeautifulMermaid = import("beautiful-mermaid").then((mod) => mod).catch((error) => {
+    throw cachedBeautifulMermaid = null, isMissingBeautifulMermaid(error) ? missingBeautifulMermaidError(error) : markMermaidRenderErrorFatal(error);
+  })), cachedBeautifulMermaid;
+}
+var beautifulMermaidRenderer = async (code, options) => {
+  try {
+    let mod = await loadBeautifulMermaid();
+    return await resolveBeautifulMermaidRenderer(mod)(code, options);
+  } catch (error) {
+    throw isMissingBeautifulMermaid(error) ? missingBeautifulMermaidError(error) : error;
+  }
+};
+function createBeautifulMermaidRenderer() {
+  return beautifulMermaidRenderer;
+}
+var TMermaidText2 = (0, import_vue9.defineComponent)({
+  name: "TMermaidText",
+  inheritAttrs: !1,
+  props: tMermaidTextProps,
+  emits: {
+    copy: (_payload) => !0
+  },
+  setup(props, { attrs, emit, slots }) {
+    return () => {
+      let renderer = props.renderer ?? beautifulMermaidRenderer, shouldRenderSource = props.shouldRenderSource ?? isSimpleMermaidFlowchartSource;
+      return (0, import_vue9.h)(
+        TMermaidText,
+        {
+          ...attrs,
+          ...props,
+          renderer,
+          shouldRenderSource,
+          isTransientError: props.isTransientError ?? isTransientBeautifulMermaidRenderError,
+          onCopy: (payload) => emit("copy", payload)
+        },
+        slots
+      );
+    };
+  }
+}), TMermaid = TMermaidText2, TBeautifulMermaidText = TMermaidText2, TBeautifulMermaid = TMermaidText2;