@simon_he/vue-tui 1.1.6 → 1.1.9

package/dist/experimental/browser.cjs

@@ -0,0 +1,3705 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/experimental/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  TBrowser: () => TBrowser
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/vue/components/TBrowser.ts
+var import_vue12 = require("vue");
+
+// src/vue/composables/use-layout.ts
+var import_vue2 = require("vue");
+
+// src/vue/context.ts
+var import_vue = require("vue");
+
+// src/renderer/terminal-graphics-trace.ts
+var metrics = {
+  requests: 0,
+  skippedHidden: 0,
+  skippedScrolling: 0,
+  cacheHits: 0,
+  cacheMisses: 0,
+  cacheStores: 0,
+  rendererRuns: 0,
+  rendererAborts: 0,
+  rendererErrors: 0,
+  queued: 0,
+  queueWaits: 0,
+  queueDeduped: 0,
+  cleared: 0,
+  bytesQueued: 0,
+  totalRendererMs: 0,
+  totalValidateMs: 0,
+  totalQueueWaitMs: 0,
+  maxQueueWaitMs: 0,
+  maxActiveRenders: 0,
+  maxWaitingRenders: 0,
+  maxCacheEntries: 0,
+  maxCacheBytes: 0,
+  scrollStarts: 0,
+  scrollMarks: 0,
+  scrollIdles: 0,
+  totalScrollMs: 0,
+  maxScrollMs: 0
+}, subscribers = /* @__PURE__ */ new Set();
+function nowTerminalGraphicTraceTime() {
+  return typeof performance < "u" && typeof performance.now == "function" ? performance.now() : Date.now();
+}
+function recordTerminalGraphicTrace(event) {
+  let normalized = {
+    ...event,
+    timestamp: event.timestamp ?? nowTerminalGraphicTraceTime()
+  };
+  switch (normalized.type) {
+    case "request":
+      metrics.requests++;
+      break;
+    case "skip-hidden":
+      metrics.skippedHidden++;
+      break;
+    case "skip-scrolling":
+      metrics.skippedScrolling++;
+      break;
+    case "cache-hit":
+      metrics.cacheHits++;
+      break;
+    case "cache-miss":
+      metrics.cacheMisses++;
+      break;
+    case "cache-store":
+      metrics.cacheStores++;
+      break;
+    case "renderer-start":
+      metrics.rendererRuns++;
+      break;
+    case "renderer-end":
+      metrics.totalRendererMs += normalized.durationMs ?? 0;
+      break;
+    case "renderer-abort":
+      metrics.rendererAborts++;
+      break;
+    case "renderer-error":
+      metrics.rendererErrors++;
+      break;
+    case "validate-end":
+      metrics.totalValidateMs += normalized.durationMs ?? 0;
+      break;
+    case "queue":
+      metrics.queued++, metrics.bytesQueued += normalized.bytes ?? 0;
+      break;
+    case "queue-wait": {
+      let durationMs = normalized.durationMs ?? 0;
+      metrics.queueWaits++, metrics.totalQueueWaitMs += durationMs, metrics.maxQueueWaitMs = Math.max(metrics.maxQueueWaitMs, durationMs);
+      break;
+    }
+    case "queue-dedupe":
+      metrics.queueDeduped++;
+      break;
+    case "clear":
+      metrics.cleared++;
+      break;
+    case "scroll-start":
+      metrics.scrollStarts++;
+      break;
+    case "scroll-mark":
+      metrics.scrollMarks++;
+      break;
+    case "scroll-idle": {
+      let durationMs = normalized.durationMs ?? 0;
+      metrics.scrollIdles++, metrics.totalScrollMs += durationMs, metrics.maxScrollMs = Math.max(metrics.maxScrollMs, durationMs);
+      break;
+    }
+  }
+  normalized.active != null && Number.isFinite(normalized.active) && (metrics.maxActiveRenders = Math.max(metrics.maxActiveRenders, Math.max(0, normalized.active))), normalized.waiting != null && Number.isFinite(normalized.waiting) && (metrics.maxWaitingRenders = Math.max(
+    metrics.maxWaitingRenders,
+    Math.max(0, normalized.waiting)
+  )), normalized.cacheEntries != null && Number.isFinite(normalized.cacheEntries) && (metrics.maxCacheEntries = Math.max(
+    metrics.maxCacheEntries,
+    Math.max(0, normalized.cacheEntries)
+  )), normalized.cacheBytes != null && Number.isFinite(normalized.cacheBytes) && (metrics.maxCacheBytes = Math.max(metrics.maxCacheBytes, Math.max(0, normalized.cacheBytes)));
+  for (let subscriber of subscribers)
+    try {
+      subscriber(normalized);
+    } catch {
+    }
+}
+
+// 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
+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-terminal-node.ts
+var import_vue4 = require("vue");
+
+// src/vue/composables/use-terminal.ts
+var import_vue3 = require("vue");
+function useTerminal() {
+  let ctx = (0, import_vue3.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;
+}
+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 wrapCacheByWidth = /* @__PURE__ */ new Map(), MAX_WRAP_CACHE_BUCKETS = 32, MAX_WRAP_CACHE_PER_WIDTH = 256;
+function getWrapBucket(width) {
+  let bucket = wrapCacheByWidth.get(width);
+  return bucket || (wrapCacheByWidth.size >= MAX_WRAP_CACHE_BUCKETS && wrapCacheByWidth.clear(), bucket = /* @__PURE__ */ new Map(), wrapCacheByWidth.set(width, bucket), bucket);
+}
+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);
+  }
+}
+function wrapByCells(text, width, provider = currentTextWidthProvider()) {
+  width = Math.max(1, Math.floor(width));
+  let bucket = canUseDefaultTextCache(provider) ? getWrapBucket(width) : null;
+  if (text && hasAsciiFastPath(provider) && isAscii(text)) {
+    if (bucket) {
+      let cached = bucket.get(text);
+      if (cached)
+        return cached;
+    }
+    let out2 = [];
+    for (let rawLine of text.replace(/\r/g, "").split(`
+`)) {
+      if (rawLine.length === 0) {
+        out2.push("");
+        continue;
+      }
+      for (let i = 0; i < rawLine.length; i += width)
+        out2.push(rawLine.slice(i, i + width));
+    }
+    return bucket && (bucket.size >= MAX_WRAP_CACHE_PER_WIDTH && bucket.clear(), bucket.set(text, out2)), out2;
+  }
+  if (bucket) {
+    let cached = bucket.get(text);
+    if (cached)
+      return cached;
+  }
+  let out = [];
+  for (let rawLine of text.replace(/\r/g, "").split(`
+`)) {
+    if (rawLine.length === 0) {
+      out.push("");
+      continue;
+    }
+    let segments = segmentedGraphemes(rawLine);
+    if (segments) {
+      let lineStart = 0, cells = 0;
+      for (let part of segments) {
+        let g = part.segment, gIdx = part.index, w = charCellWidth(g, provider);
+        if (cells > 0 && cells + w > width && (out.push(rawLine.slice(lineStart, gIdx)), lineStart = gIdx, cells = 0), cells += w, cells >= width) {
+          let end = gIdx + g.length;
+          out.push(rawLine.slice(lineStart, end)), lineStart = end, cells = 0;
+        }
+      }
+      lineStart < rawLine.length && out.push(rawLine.slice(lineStart));
+    } else {
+      let lineStart = 0, pos = 0, cells = 0;
+      for (let ch of rawLine) {
+        let w = charCellWidth(ch, provider);
+        cells > 0 && cells + w > width && (out.push(rawLine.slice(lineStart, pos)), lineStart = pos, cells = 0), pos += ch.length, cells += w, cells >= width && (out.push(rawLine.slice(lineStart, pos)), lineStart = pos, cells = 0);
+      }
+      lineStart < rawLine.length && out.push(rawLine.slice(lineStart));
+    }
+  }
+  let res = out.length ? out : [""];
+  return bucket && (bucket.size >= MAX_WRAP_CACHE_PER_WIDTH && bucket.clear(), bucket.set(text, res)), res;
+}
+
+// src/vue/composables/use-terminal-node.ts
+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_vue4.ref)(null), options = (0, import_vue4.computed)(() => withTextWidthProvider(widthProvider, getOptions)), stop = (0, import_vue4.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_vue4.onBeforeUnmount)(() => {
+    stop();
+    let manager = events.value;
+    manager && id.value && manager.unregister(id.value);
+  }), { id };
+}
+
+// src/vue/composables/use-visibility.ts
+var import_vue5 = require("vue");
+var VUE_TERMINAL_SHOW_CB = "__vueTerminalOnShow", vShowPatched = !1;
+function patchVShow() {
+  if (vShowPatched)
+    return;
+  vShowPatched = !0;
+  let dir = import_vue5.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_vue5.inject)(VisibilityContextKey, (0, import_vue5.ref)(!0)), localVisible = (0, import_vue5.ref)(!0), visible = (0, import_vue5.computed)(() => parentVisible.value && localVisible.value);
+  options?.provide && (0, import_vue5.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/TVideo.ts
+var import_vue11 = require("vue");
+
+// src/core/terminal/create-terminal.ts
+var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals"), TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
+function getRootTerminal(terminal) {
+  return terminal[TERMINAL_ROOT] ?? terminal;
+}
+
+// src/renderer/terminal-graphics.ts
+var ESC = "\x1B", BEL = "\x07", ST = `${ESC}\\`, ESC_RE = "\\u001B", BEL_RE = "\\u0007", CSI_RE = new RegExp(`${ESC_RE}\\[[0-?]*[ -/]*[@-~]`, "g"), OSC_RE = new RegExp(`${ESC_RE}\\][\\s\\S]*?(?:${BEL_RE}|${ESC_RE}\\\\)`, "g"), DCS_RE = new RegExp(`${ESC_RE}P[\\s\\S]*?${ESC_RE}\\\\`, "g"), APC_RE = new RegExp(`${ESC_RE}_[\\s\\S]*?${ESC_RE}\\\\`, "g"), C1_CSI_RE = new RegExp("\\u009B[0-?]*[ -/]*[@-~]", "g"), C1_OSC_RE = new RegExp(`\\u009D[\\s\\S]*?(?:${BEL_RE}|\\u009C)`, "g"), C1_DCS_RE = new RegExp("\\u0090[\\s\\S]*?\\u009C", "g"), C1_APC_RE = new RegExp("\\u009F[\\s\\S]*?\\u009C", "g"), MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS = 16 * 1024 * 1024, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS = 16384, MAX_TERMINAL_GRAPHIC_CELLS = 1e5, TERMINAL_GRAPHICS_REGISTRY = Symbol.for("@simon_he/vue-tui:v1:terminal-graphics"), terminalGraphicsGlobal = globalThis, terminalGraphicsRegistry = terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] ?? {
+  outputs: /* @__PURE__ */ new WeakMap(),
+  outputVersions: /* @__PURE__ */ new WeakMap(),
+  outputListeners: /* @__PURE__ */ new WeakMap()
+};
+terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] = terminalGraphicsRegistry;
+var terminalGraphicsOutputs = terminalGraphicsRegistry.outputs, terminalGraphicsOutputVersions = terminalGraphicsRegistry.outputVersions, terminalGraphicsOutputListeners = terminalGraphicsRegistry.outputListeners;
+function getTerminalGraphicsOutput(terminal) {
+  return terminalGraphicsOutputs.get(getRootTerminal(terminal)) ?? null;
+}
+function getTerminalGraphicsOutputVersion(terminal) {
+  return terminalGraphicsOutputVersions.get(getRootTerminal(terminal)) ?? 0;
+}
+function subscribeTerminalGraphicsOutput(terminal, listener) {
+  let rootTerminal = getRootTerminal(terminal), listeners = terminalGraphicsOutputListeners.get(rootTerminal);
+  return listeners || (listeners = /* @__PURE__ */ new Set(), terminalGraphicsOutputListeners.set(rootTerminal, listeners)), listeners.add(listener), () => {
+    listeners.delete(listener), listeners.size === 0 && terminalGraphicsOutputListeners.delete(rootTerminal);
+  };
+}
+function isTerminalGraphicsProtocol(value) {
+  return value === "kitty" || value === "iterm2" || value === "sixel";
+}
+function stableTerminalGraphicNumericId(input, options = {}) {
+  let min = Math.floor(options.min ?? 1), max = Math.floor(options.max ?? 2147483647), span = Math.max(1, max - min + 1), hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1)
+    hash ^= input.charCodeAt(index), hash = Math.imul(hash, 16777619);
+  return min + (hash >>> 0) % span;
+}
+function positiveGraphicInt(value, max) {
+  let n = Math.trunc(Number(value));
+  return !Number.isFinite(n) || n <= 0 ? null : Math.min(max, n);
+}
+function normalizeTerminalGraphicSize(width, height) {
+  let w = positiveGraphicInt(width, MAX_TERMINAL_GRAPHIC_CELLS), h6 = positiveGraphicInt(height, MAX_TERMINAL_GRAPHIC_CELLS);
+  return w == null || h6 == null || w * h6 > MAX_TERMINAL_GRAPHIC_CELLS ? null : { width: w, height: h6 };
+}
+function canDrawTerminalGraphicRect(rect, size) {
+  let x = Math.floor(rect.x), y = Math.floor(rect.y), graphicSize = normalizeTerminalGraphicSize(rect.w, rect.h), cols = Math.max(0, Math.floor(size.cols)), rows = Math.max(0, Math.floor(size.rows));
+  return graphicSize != null && cols > 0 && rows > 0 && Number.isFinite(x) && Number.isFinite(y) && x >= 0 && y >= 0 && x < cols && y < rows;
+}
+function withoutNestedEscapes(body) {
+  return !body.includes(ESC) && !body.includes(BEL);
+}
+function isBase64ish(value) {
+  return /^[A-Za-z0-9+/=]*$/.test(value);
+}
+function parseKittyControls(raw) {
+  let out = /* @__PURE__ */ new Map();
+  if (!/^[A-Za-z0-9_,=+.\-:]*$/.test(raw))
+    return null;
+  for (let part of raw.split(",")) {
+    if (!part)
+      continue;
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return null;
+    let key = part.slice(0, eq), value = part.slice(eq + 1);
+    if (!/^[A-Za-z]$/.test(key) || !/^[A-Za-z0-9+.\-:]*$/.test(value))
+      return null;
+    out.set(key, value);
+  }
+  return out;
+}
+function parseKittyPackets(sequence) {
+  let packets = [], index = 0;
+  for (; index < sequence.length; ) {
+    if (!sequence.startsWith(`${ESC}_G`, index))
+      return null;
+    let end = sequence.indexOf(ST, index + 3);
+    if (end < 0)
+      return null;
+    let body = sequence.slice(index + 3, end);
+    if (!withoutNestedEscapes(body))
+      return null;
+    let semicolon = body.indexOf(";"), rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body, payload = semicolon >= 0 ? body.slice(semicolon + 1) : "", controls = parseKittyControls(rawControls);
+    if (!controls || payload && !isBase64ish(payload))
+      return null;
+    packets.push({ controls, payload }), index = end + ST.length;
+  }
+  return packets.length ? packets : null;
+}
+var KITTY_DRAW_FIRST_CONTROL_KEYS = /* @__PURE__ */ new Set([
+  "a",
+  "f",
+  "q",
+  "C",
+  "i",
+  "I",
+  "p",
+  "c",
+  "r",
+  "x",
+  "y",
+  "w",
+  "h",
+  "z",
+  "m",
+  "t"
+]), KITTY_DRAW_CONTINUATION_CONTROL_KEYS = /* @__PURE__ */ new Set(["a", "q", "m"]), KITTY_CLEAR_CONTROL_KEYS = /* @__PURE__ */ new Set(["a", "d", "i", "I", "p", "q"]);
+function kittyControlsUseOnly(controls, allowed) {
+  for (let key of controls.keys())
+    if (!allowed.has(key))
+      return !1;
+  return !0;
+}
+var KITTY_UINT32_MAX = 4294967295, KITTY_INT32_MIN = -2147483648, KITTY_INT32_MAX = 2147483647;
+function kittyControlIsUint32(controls, key, min = 0) {
+  let value = controls.get(key);
+  if (value == null)
+    return !0;
+  if (!/^\d+$/.test(value))
+    return !1;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX;
+}
+function kittyControlIsInt32(controls, key) {
+  let value = controls.get(key);
+  if (value == null)
+    return !0;
+  if (!/^-?\d+$/.test(value))
+    return !1;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX;
+}
+function kittyControlPositiveInt(controls, key, fallback) {
+  let value = controls.get(key);
+  if (value == null)
+    return fallback;
+  if (!/^\d+$/.test(value))
+    return null;
+  let n = Number(value);
+  return Number.isSafeInteger(n) && n >= 1 ? n : null;
+}
+function kittyControlIsTerminalGraphicCellsBounded(controls) {
+  let columns = kittyControlPositiveInt(controls, "c", 1), rows = kittyControlPositiveInt(controls, "r", 1);
+  return columns != null && rows != null && columns * rows <= MAX_TERMINAL_GRAPHIC_CELLS;
+}
+function validateKittySharedSafeControls(controls) {
+  let q = controls.get("q");
+  if (q != null && !/^[0-2]$/.test(q))
+    return !1;
+  let cursorMove = controls.get("C");
+  if (cursorMove != null && !/^[01]$/.test(cursorMove))
+    return !1;
+  for (let key of ["i", "I", "p"])
+    if (!kittyControlIsUint32(controls, key))
+      return !1;
+  for (let key of ["c", "r"])
+    if (!kittyControlIsUint32(controls, key, 1))
+      return !1;
+  if (!kittyControlIsTerminalGraphicCellsBounded(controls))
+    return !1;
+  for (let key of ["x", "y"])
+    if (!kittyControlIsUint32(controls, key))
+      return !1;
+  for (let key of ["w", "h"])
+    if (!kittyControlIsUint32(controls, key, 1))
+      return !1;
+  if (!kittyControlIsInt32(controls, "z"))
+    return !1;
+  let transmissionMedium = controls.get("t");
+  return !(transmissionMedium != null && transmissionMedium !== "d");
+}
+function validateKittySequence(sequence, op = "draw") {
+  let packets = parseKittyPackets(sequence);
+  if (!packets)
+    return !1;
+  if (op === "clear") {
+    if (packets.length !== 1)
+      return !1;
+    let packet = packets[0];
+    if (!kittyControlsUseOnly(packet.controls, KITTY_CLEAR_CONTROL_KEYS) || !validateKittySharedSafeControls(packet.controls) || packet.payload || packet.controls.get("a") !== "d")
+      return !1;
+    let d = packet.controls.get("d");
+    return d == null || /^[aAcCiI]$/.test(d);
+  }
+  let first = packets[0];
+  if (!kittyControlsUseOnly(first.controls, KITTY_DRAW_FIRST_CONTROL_KEYS) || !validateKittySharedSafeControls(first.controls))
+    return !1;
+  if (first.controls.get("a") === "p")
+    return !(packets.length !== 1 || first.payload || !first.controls.has("i") && !first.controls.has("I"));
+  if (first.controls.get("a") !== "T" || !first.payload)
+    return !1;
+  let f = first.controls.get("f");
+  if (f != null && f !== "24" && f !== "32" && f !== "100")
+    return !1;
+  let firstMore = first.controls.get("m");
+  if (firstMore != null && firstMore !== "0" && firstMore !== "1" || packets.length > 1 && firstMore !== "1")
+    return !1;
+  for (let i = 1; i < packets.length; i++) {
+    let packet = packets[i];
+    if (!kittyControlsUseOnly(packet.controls, KITTY_DRAW_CONTINUATION_CONTROL_KEYS) || !validateKittySharedSafeControls(packet.controls))
+      return !1;
+    let action = packet.controls.get("a");
+    if (action != null && action !== "T")
+      return !1;
+    let m = packet.controls.get("m");
+    if (m !== "0" && m !== "1" || !packet.payload && !(i === packets.length - 1 && m === "0"))
+      return !1;
+  }
+  return !(packets.length > 1 && packets[packets.length - 1].controls.get("m") === "1");
+}
+function validateIterm2Dimension(value) {
+  return /^auto$/i.test(value) || /^(?:[1-9]\d{0,4})(?:px|%)?$/.test(value);
+}
+function validateIterm2Params(params) {
+  let seen = /* @__PURE__ */ new Set(), inline = !1;
+  for (let part of params.split(";").filter(Boolean)) {
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return !1;
+    let key = part.slice(0, eq), value = part.slice(eq + 1);
+    if (seen.has(key))
+      return !1;
+    switch (seen.add(key), key) {
+      case "inline":
+        if (value !== "1")
+          return !1;
+        inline = !0;
+        break;
+      case "width":
+      case "height":
+        if (!validateIterm2Dimension(value))
+          return !1;
+        break;
+      case "preserveAspectRatio":
+      case "doNotMoveCursor":
+        if (!/^[01]$/.test(value))
+          return !1;
+        break;
+      default:
+        return !1;
+    }
+  }
+  return inline;
+}
+function validateIterm2Sequence(sequence, op = "draw") {
+  if (op === "clear")
+    return !1;
+  let index = 0;
+  for (; index < sequence.length; ) {
+    let prefix = `${ESC}]1337;File=`;
+    if (!sequence.startsWith(prefix, index))
+      return !1;
+    let belEnd = sequence.indexOf(BEL, index + prefix.length), stEnd = sequence.indexOf(ST, index + prefix.length), end = belEnd >= 0 && stEnd >= 0 ? Math.min(belEnd, stEnd) : belEnd >= 0 ? belEnd : stEnd;
+    if (end < 0)
+      return !1;
+    let body = sequence.slice(index + `${ESC}]1337;`.length, end);
+    if (!body.startsWith("File=") || !withoutNestedEscapes(body))
+      return !1;
+    let colon = body.indexOf(":");
+    if (colon < 0)
+      return !1;
+    let params = body.slice(5, colon), payload = body.slice(colon + 1);
+    if (!/^[A-Za-z0-9_=;,.%+\-:]*$/.test(params) || !payload || !isBase64ish(payload) || !validateIterm2Params(params))
+      return !1;
+    index = end + (end === stEnd ? ST.length : BEL.length);
+  }
+  return sequence.length > 0;
+}
+function validateSixelSequence(sequence, op = "draw") {
+  if (op === "clear")
+    return !1;
+  let index = 0;
+  for (; index < sequence.length; ) {
+    if (!sequence.startsWith(`${ESC}P`, index))
+      return !1;
+    let end = sequence.indexOf(ST, index + 2);
+    if (end < 0)
+      return !1;
+    let body = sequence.slice(index + 2, end);
+    if (!withoutNestedEscapes(body))
+      return !1;
+    for (let i = 0; i < body.length; i++) {
+      let code = body.charCodeAt(i);
+      if (code < 32 || code > 126)
+        return !1;
+    }
+    let q = body.indexOf("q");
+    if (q < 0 || q > 32)
+      return !1;
+    let introducer = body.slice(0, q);
+    if (!/^[0-9;?]*$/.test(introducer) || !body.slice(q + 1).length)
+      return !1;
+    index = end + ST.length;
+  }
+  return sequence.length > 0;
+}
+function stripTerminalControlChars(value) {
+  let out = "";
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 128 && code <= 159 || (out += value[index]);
+  }
+  return out;
+}
+function sanitizeTerminalFallbackText(text) {
+  return stripTerminalControlChars(
+    String(text ?? "").replace(OSC_RE, "").replace(CSI_RE, "").replace(DCS_RE, "").replace(APC_RE, "").replace(C1_OSC_RE, "").replace(C1_CSI_RE, "").replace(C1_DCS_RE, "").replace(C1_APC_RE, "")
+  ).slice(0, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS);
+}
+function isSafeTerminalGraphicsSequence(sequence, protocol, op = "draw") {
+  return !isTerminalGraphicsProtocol(protocol) || !sequence || sequence.length > MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS ? !1 : protocol === "kitty" ? validateKittySequence(sequence, op) : protocol === "iterm2" ? validateIterm2Sequence(sequence, op) : validateSixelSequence(sequence, op);
+}
+function uint32Control(key, value, min = 0) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX ? `${key}=${n}` : "";
+}
+function int32Control(key, value) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX ? `${key}=${n}` : "";
+}
+function sanitizeBase64(value) {
+  let data = String(value ?? "").replace(/\s+/g, "");
+  return isBase64ish(data) ? data : "";
+}
+function kittyGraphicCellControls(columns, rows) {
+  if (columns == null && rows == null)
+    return [];
+  let size = normalizeTerminalGraphicSize(columns ?? 1, rows ?? 1);
+  return size ? [columns == null ? "" : `c=${size.width}`, rows == null ? "" : `r=${size.height}`] : [];
+}
+function kittyGraphicSourceControls(sourceX, sourceY, sourceWidth, sourceHeight) {
+  return [
+    uint32Control("x", sourceX),
+    uint32Control("y", sourceY),
+    uint32Control("w", sourceWidth, 1),
+    uint32Control("h", sourceHeight, 1)
+  ];
+}
+function chunkBase64(value, chunkSize) {
+  let normalizedSize = Math.max(4, Math.floor(chunkSize / 4) * 4), chunks = [];
+  for (let index = 0; index < value.length; index += normalizedSize)
+    chunks.push(value.slice(index, index + normalizedSize));
+  return chunks.length ? chunks : [""];
+}
+function createKittyPlacementSequence(options) {
+  let imageId = uint32Control("i", options.imageId), imageNumber = uint32Control("I", options.imageNumber);
+  if (!imageId && !imageNumber)
+    return "";
+  let controls = [
+    "a=p",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    imageId,
+    imageNumber,
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return `${ESC}_G${controls.join(",")}${ST}`;
+}
+function createKittyGraphicsSequence(base64Png, options = {}) {
+  let data = sanitizeBase64(base64Png);
+  if (!data)
+    return "";
+  let chunks = chunkBase64(data, options.chunkSize ?? 4096), baseControls = [
+    "a=T",
+    "f=100",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    uint32Control("i", options.imageId),
+    uint32Control("I", options.imageNumber),
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return chunks.map((chunk, index) => {
+    let last = index === chunks.length - 1, controls = index === 0 ? [...baseControls, chunks.length > 1 ? `m=${last ? 0 : 1}` : ""] : [options.quiet === !1 ? "" : "q=2", `m=${last ? 0 : 1}`].filter(Boolean);
+    return `${ESC}_G${controls.filter(Boolean).join(",")};${chunk}${ST}`;
+  }).join("");
+}
+function createKittyDeleteGraphicsSequence(options = {}) {
+  let controls = ["a=d"];
+  if (options.allVisible)
+    controls.push(`d=${options.freeImageData ? "A" : "a"}`);
+  else if (options.imageId != null) {
+    let imageId = uint32Control("i", options.imageId), placementId = uint32Control("p", options.placementId);
+    if (!imageId || options.placementId != null && !placementId)
+      return "";
+    controls.push(`d=${options.freeImageData ? "I" : "i"}`), controls.push(imageId), controls.push(placementId);
+  } else if (options.currentCell)
+    controls.push(`d=${options.freeImageData ? "C" : "c"}`);
+  else
+    return "";
+  return options.quiet !== !1 && controls.push("q=2"), `${ESC}_G${controls.filter(Boolean).join(",")}${ST}`;
+}
+function createIterm2InlineImageSequence(base64Data, options = {}) {
+  let data = sanitizeBase64(base64Data);
+  if (!data)
+    return "";
+  let params = [
+    "inline=1",
+    options.width != null ? `width=${formatItermDimension(options.width)}` : "",
+    options.height != null ? `height=${formatItermDimension(options.height)}` : "",
+    `preserveAspectRatio=${options.preserveAspectRatio === !1 ? 0 : 1}`,
+    options.doNotMoveCursor === !1 ? "" : "doNotMoveCursor=1"
+  ].filter(Boolean);
+  return `${ESC}]1337;File=${params.join(";")}:${data}${BEL}`;
+}
+function formatItermDimension(value) {
+  if (typeof value == "number") {
+    let n = Math.floor(value);
+    return Number.isFinite(n) ? String(Math.min(99999, Math.max(1, n))) : "auto";
+  }
+  let raw = String(value ?? "").trim();
+  return validateIterm2Dimension(raw) ? raw : "auto";
+}
+function resolveKittyPngSourceCrop(rect, fullRect, sourceWidth, sourceHeight) {
+  if (fullRect.w <= 0 || fullRect.h <= 0)
+    return null;
+  let offsetX = Math.max(0, rect.x - fullRect.x), offsetY = Math.max(0, rect.y - fullRect.y), visibleW = Math.max(0, Math.min(rect.w, fullRect.w - offsetX)), visibleH = Math.max(0, Math.min(rect.h, fullRect.h - offsetY));
+  if (offsetX <= 0 && offsetY <= 0 && visibleW >= fullRect.w && visibleH >= fullRect.h)
+    return null;
+  let sourceX = Math.max(
+    0,
+    Math.min(sourceWidth - 1, Math.floor(offsetX * sourceWidth / fullRect.w))
+  ), sourceY = Math.max(
+    0,
+    Math.min(sourceHeight - 1, Math.floor(offsetY * sourceHeight / fullRect.h))
+  ), sourceRight = Math.max(
+    sourceX + 1,
+    Math.min(sourceWidth, Math.ceil((offsetX + visibleW) * sourceWidth / fullRect.w))
+  ), sourceBottom = Math.max(
+    sourceY + 1,
+    Math.min(sourceHeight, Math.ceil((offsetY + visibleH) * sourceHeight / fullRect.h))
+  );
+  return {
+    sourceX,
+    sourceY,
+    sourceWidth: sourceRight - sourceX,
+    sourceHeight: sourceBottom - sourceY
+  };
+}
+function createTerminalGraphicPngSequence(options) {
+  if (options.protocol === "kitty") {
+    let placement = {
+      columns: options.placementColumns,
+      rows: options.placementRows
+    };
+    if (options.rect && options.fullRect && options.sourceWidth && options.sourceHeight) {
+      let crop = resolveKittyPngSourceCrop(
+        options.rect,
+        options.fullRect,
+        options.sourceWidth,
+        options.sourceHeight
+      );
+      crop && (placement = { ...placement, ...crop });
+    }
+    let transmissionPlacement = options.cropTransmission !== !1 ? placement : {
+      columns: options.transmissionColumns ?? options.placementColumns,
+      rows: options.transmissionRows ?? options.placementRows
+    };
+    return {
+      type: "sequence",
+      protocol: "kitty",
+      sequence: createKittyGraphicsSequence(options.base64, {
+        imageId: options.imageId,
+        placementId: options.placementId,
+        zIndex: options.zIndex,
+        ...transmissionPlacement
+      }),
+      resizeSequence: createKittyPlacementSequence({
+        imageId: options.imageId,
+        placementId: options.placementId,
+        zIndex: options.zIndex,
+        ...placement
+      }),
+      clearSequence: createKittyDeleteGraphicsSequence({
+        imageId: options.imageId,
+        placementId: options.placementId,
+        freeImageData: options.freeImageData
+      }),
+      ...options.fallback != null ? { fallback: options.fallback } : {},
+      ...options.cols != null ? { cols: options.cols } : {},
+      ...options.rows != null ? { rows: options.rows } : {},
+      ...options.sourceWidth != null ? { sourceWidth: options.sourceWidth } : {},
+      ...options.sourceHeight != null ? { sourceHeight: options.sourceHeight } : {},
+      ...options.zIndex != null ? { zIndex: options.zIndex } : {}
+    };
+  }
+  return options.protocol === "iterm2" ? {
+    type: "sequence",
+    protocol: "iterm2",
+    sequence: createIterm2InlineImageSequence(options.base64, {
+      width: options.cols,
+      height: options.rows,
+      preserveAspectRatio: !0,
+      doNotMoveCursor: !0
+    }),
+    ...options.fallback != null ? { fallback: options.fallback } : {},
+    ...options.cols != null ? { cols: options.cols } : {},
+    ...options.rows != null ? { rows: options.rows } : {},
+    ...options.sourceWidth != null ? { sourceWidth: options.sourceWidth } : {},
+    ...options.sourceHeight != null ? { sourceHeight: options.sourceHeight } : {}
+  } : null;
+}
+
+// src/vue/scheduler/frame-mailbox.ts
+var EMPTY = Symbol("frame-mailbox-empty");
+function createFrameMailbox(options) {
+  let disposed = !1, hasPending = !1, pending = EMPTY, queued = 0, pendingTaskId = null;
+  function clearPending() {
+    hasPending = !1, pending = EMPTY, queued = 0, pendingTaskId = null;
+  }
+  function currentTaskId() {
+    if (pendingTaskId)
+      return pendingTaskId;
+    let id = typeof options.id == "function" ? options.id() : options.id;
+    if (!id)
+      throw new Error("createFrameMailbox requires a non-empty task id");
+    return pendingTaskId = id, pendingTaskId;
+  }
+  function queue(value) {
+    if (disposed)
+      return !1;
+    let wasPending = hasPending, taskId = wasPending ? pendingTaskId : currentTaskId(), nextPending;
+    try {
+      nextPending = hasPending && options.merge ? options.merge(pending, value) : value;
+    } catch (error) {
+      throw clearPending(), wasPending && options.scheduler.cancelFrameTask?.(taskId), error;
+    }
+    if (pending = nextPending, hasPending = !0, queued++, wasPending)
+      return !0;
+    let accepted;
+    try {
+      accepted = options.scheduler.queueFrameTask({
+        id: taskId,
+        reason: options.reason,
+        priority: options.priority,
+        sync: options.sync,
+        run(ctx) {
+          if (disposed || !hasPending)
+            return;
+          let value2 = pending, count = queued, dropped = Math.max(0, count - 1);
+          clearPending(), ctx.reportMailboxDeliveryAttempt?.({
+            id: taskId,
+            queued: count,
+            dropped
+          }), options.apply(value2, ctx, {
+            queued: count,
+            dropped
+          }), ctx.reportDroppedUpdates?.(dropped);
+        }
+      });
+    } catch (error) {
+      throw clearPending(), error;
+    }
+    return accepted === !1 ? (clearPending(), !1) : !0;
+  }
+  function replacePending(value) {
+    return disposed ? !1 : hasPending ? (pending = value, !0) : queue(value);
+  }
+  function cancel() {
+    let taskId = pendingTaskId;
+    clearPending(), taskId && options.scheduler.cancelFrameTask?.(taskId);
+  }
+  function dispose() {
+    cancel(), disposed = !0;
+  }
+  return {
+    queue,
+    replacePending,
+    cancel,
+    dispose,
+    hasPending: () => hasPending,
+    // Ambiguous when T includes undefined. Pair with hasPending() to
+    // distinguish "pending undefined" from "no pending value".
+    peek: () => hasPending ? pending : void 0
+  };
+}
+
+// src/vue/components/TAgentTerminalGraphic.ts
+var import_vue8 = require("vue");
+
+// src/vue/composables/use-render-node.ts
+var import_vue7 = require("vue");
+
+// src/vue/composables/use-render-stack.ts
+var import_vue6 = require("vue");
+
+// src/vue/render/context.ts
+var RenderStackKey = injectionKey("RenderStack");
+
+// src/vue/composables/use-render-stack.ts
+function useRenderStack() {
+  let stack = (0, import_vue6.inject)(RenderStackKey, null);
+  if (!stack)
+    throw new Error("RenderStack is missing");
+  return stack;
+}
+
+// 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_vue7.inject)(RenderPlaneContextKey, (0, import_vue7.ref)("default")), id = (0, import_vue7.ref)(null), lastPlane = (0, import_vue7.ref)(plane.value), lastStack = null, lastZIndex = 0, lastHasRect = !1, lastRect = null, lastDeps, lastHasDeps = !1, options = (0, import_vue7.computed)(() => withTextWidthProvider(widthProvider, getOptions)), stop = (0, import_vue7.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_vue7.onBeforeUnmount)(() => {
+    stop(), id.value && (render.unregister(id.value), requestBatchedInvalidate(scheduler, lastPlane.value, "normal"));
+  }), { id };
+}
+
+// src/vue/components/TAgentTerminalGraphic.ts
+var NO_GRAPHICS_CAPABILITIES = Object.freeze({
+  supported: !1,
+  kitty: !1,
+  iterm2: !1,
+  sixel: !1,
+  preferredProtocol: null,
+  protocol: "unicode",
+  candidates: [],
+  stdoutIsTTY: !1,
+  insideTmux: !1,
+  insideScreen: !1,
+  insideZellij: !1,
+  multiplexer: null,
+  passthrough: !1,
+  forced: !1,
+  reason: "no-terminal-graphics-output"
+});
+function splitTextOutput(value) {
+  let lines = sanitizeTextBlock(sanitizeTerminalFallbackText(value).replace(/\r\n?/g, `
+`)).split(`
+`);
+  return lines.length ? lines : [""];
+}
+function hasVisibleOutput(value) {
+  return value.some((line) => line.trim().length > 0);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function positiveInt(value) {
+  let n = Math.floor(Number(value));
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function finiteInt(value) {
+  let n = Math.floor(Number(value));
+  return Number.isFinite(n) ? n : void 0;
+}
+function clampNumber(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function rectArea(rect) {
+  return Math.max(0, rect.w) * Math.max(0, rect.h);
+}
+function sameRect(a, b) {
+  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function subtractRect(rect, cover) {
+  let hit = intersectRect(rect, cover);
+  if (!hit)
+    return [rect];
+  let out = [], rectRight = rect.x + rect.w, rectBottom = rect.y + rect.h, hitRight = hit.x + hit.w, hitBottom = hit.y + hit.h;
+  return hit.y > rect.y && out.push({ x: rect.x, y: rect.y, w: rect.w, h: hit.y - rect.y }), hitBottom < rectBottom && out.push({ x: rect.x, y: hitBottom, w: rect.w, h: rectBottom - hitBottom }), hit.x > rect.x && out.push({ x: rect.x, y: hit.y, w: hit.x - rect.x, h: hit.h }), hitRight < rectRight && out.push({ x: hitRight, y: hit.y, w: rectRight - hitRight, h: hit.h }), out.filter((part) => part.w > 0 && part.h > 0);
+}
+function largestUncoveredRect(rect, covers) {
+  let parts = [rect];
+  for (let cover of covers)
+    if (parts = parts.flatMap((part) => subtractRect(part, cover)), !parts.length)
+      return null;
+  return parts.sort((a, b) => rectArea(b) - rectArea(a) || a.y - b.y || a.x - b.x), parts[0] ?? null;
+}
+function parseKittyClearControls(sequence) {
+  let prefix = "\x1B_G", terminator = "\x1B\\";
+  if (!sequence.startsWith(prefix) || !sequence.endsWith(terminator))
+    return null;
+  let body = sequence.slice(prefix.length, -terminator.length);
+  if (body.includes(terminator) || body.includes("\x1B") || body.includes("\x07"))
+    return null;
+  let semicolon = body.indexOf(";"), rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body, controls = /* @__PURE__ */ new Map();
+  for (let part of rawControls.split(",")) {
+    let eq = part.indexOf("=");
+    if (eq <= 0)
+      return null;
+    controls.set(part.slice(0, eq), part.slice(eq + 1));
+  }
+  return controls;
+}
+function kittyClearTargetsComponent(sequence, imageId, placementId) {
+  let controls = parseKittyClearControls(sequence);
+  if (!controls)
+    return !1;
+  let mode = controls.get("d");
+  return mode !== "i" && mode !== "I" ? !1 : controls.get("i") === String(imageId) && controls.get("p") === String(placementId);
+}
+function isSafeComponentClearSequence(sequence, protocol, imageId, placementId) {
+  return isSafeTerminalGraphicsSequence(sequence, protocol, "clear") ? protocol !== "kitty" || kittyClearTargetsComponent(sequence, imageId, placementId) : !1;
+}
+var textEncoder = null;
+function stringByteLength(value) {
+  if (typeof TextEncoder < "u")
+    return textEncoder ?? (textEncoder = new TextEncoder()), textEncoder.encode(value).length;
+  let bytes = 0;
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    code <= 127 ? bytes += 1 : code <= 2047 ? bytes += 2 : code >= 55296 && code <= 56319 && index + 1 < value.length ? (bytes += 4, index++) : bytes += 3;
+  }
+  return bytes;
+}
+function smallHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++)
+    hash ^= input.charCodeAt(i), hash = Math.imul(hash, 16777619);
+  return (hash >>> 0).toString(36);
+}
+var tAgentTerminalGraphicProps = {
+  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, required: !0 },
+  kind: {
+    type: String,
+    default: "image"
+  },
+  fallback: { 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 },
+  renderer: {
+    type: Function,
+    default: void 0
+  },
+  loadingText: {
+    type: String,
+    default: "Rendering terminal graphic..."
+  },
+  deferRenderUntilVisible: { type: Boolean, default: !0 },
+  suspendRawWhileScrolling: { type: Boolean, default: !0 },
+  suspendRenderWhileScrolling: { type: Boolean, default: !0 },
+  scrolling: { type: Boolean, default: !1 },
+  scrollVersion: { type: Number, default: 0 },
+  /** Advanced Kitty-only opt-in for moving an unchanged image via a reusable placement sequence. */
+  placementMoveWithoutClear: { type: Boolean, default: !1 },
+  preserveRawWhileRendering: { type: Boolean, default: !1 },
+  suspended: { type: Boolean, default: !1 },
+  retainRawWhileCovered: { type: Boolean, default: !1 },
+  ignoreRawCoverage: { type: Boolean, default: !1 },
+  ignoreSamePlaneRawCoverage: { type: Boolean, default: !1 },
+  cacheKey: { type: String, default: void 0 },
+  placementKey: { type: String, default: void 0 },
+  trace: {
+    type: Function,
+    default: void 0
+  }
+};
+function terminalDrawKey(current, rect, clearSequence, resizeSequence) {
+  return [
+    current.protocol,
+    rect.x,
+    rect.y,
+    rect.w,
+    rect.h,
+    current.sequenceHash,
+    clearSequence === current.clearSequence ? current.clearSequenceHash ?? "" : smallHash(clearSequence ?? ""),
+    resizeSequence === current.resizeSequence ? current.resizeSequenceHash ?? "" : smallHash(resizeSequence ?? "")
+  ].join(":");
+}
+var TAgentTerminalGraphic = (0, import_vue8.defineComponent)({
+  name: "TAgentTerminalGraphic",
+  props: tAgentTerminalGraphicProps,
+  setup(props) {
+    let instance = (0, import_vue8.getCurrentInstance)(), { terminal, defaultStyle, scheduler, widthProvider, render } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), graphicsActivity = (0, import_vue8.inject)(TerminalGraphicsActivityKey, null), status = (0, import_vue8.shallowRef)("idle"), error = (0, import_vue8.shallowRef)(""), graphic = (0, import_vue8.shallowRef)(null), documentVersion = (0, import_vue8.shallowRef)(0), builtOnce = !1, renderVersion = 0, renderAbort = null, alive = !0, lastRenderedContent = "", lastRenderRawVisible = !1, lastRenderProtocol = null, lastRenderGraphicsOutputVersion = 0, rawIdSeed = props.placementKey ? `placement:${props.placementKey}` : props.cacheKey ? `cache:${props.cacheKey}` : `instance:${instance?.uid ?? "unknown"}`, rawId = `TAgentTerminalGraphic:${smallHash(rawIdSeed)}`, frameTaskId = `${rawId}:render`, lastDrawnGraphic = (0, import_vue8.shallowRef)(null), rawClearPendingRepaint = (0, import_vue8.shallowRef)(null), rawDrawRejectedKey = (0, import_vue8.shallowRef)(null), reservedTerminalGraphicSize = (0, import_vue8.shallowRef)(null), terminalSizeVersion = (0, import_vue8.shallowRef)(0), renderNodeId = (0, import_vue8.shallowRef)(null), lastRawSkipScrollKey = "", lastDeferTraceKey = "", isParentScrolling = (0, import_vue8.computed)(
+      () => props.scrolling || !!graphicsActivity?.scrolling.value
+    ), graphicsActivityVersion = (0, import_vue8.computed)(
+      () => (graphicsActivity?.version.value ?? 0) + Math.floor(Number(props.scrollVersion ?? 0))
+    ), graphicsOutput = () => getTerminalGraphicsOutput(terminal), graphicsOutputVersion = (0, import_vue8.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+    }), unsubscribeTerminalResize = terminal.on("resize", () => {
+      terminalSizeVersion.value++;
+    }), fallbackText = () => props.fallback ?? (props.kind === "math" ? props.content : ""), contentIdentity = (0, import_vue8.computed)(() => `${props.content.length}:${smallHash(props.content)}`), stableGraphicKey = (0, import_vue8.computed)(
+      () => [
+        rawIdSeed,
+        props.cacheKey ?? "",
+        props.kind,
+        contentIdentity.value,
+        props.w,
+        props.h ?? "",
+        props.final ? "final" : "draft"
+      ].join("")
+    ), imageId = (0, import_vue8.computed)(
+      () => stableTerminalGraphicNumericId(`image:${stableGraphicKey.value}`)
+    ), placementId = (0, import_vue8.computed)(
+      () => stableTerminalGraphicNumericId(`placement:${stableGraphicKey.value}`)
+    );
+    function rememberTerminalGraphicSize(current) {
+      if (current.type !== "terminal")
+        return;
+      let rows = positiveInt(current.rows);
+      rows && (reservedTerminalGraphicSize.value = {
+        key: stableGraphicKey.value,
+        rows
+      });
+    }
+    function bump() {
+      documentVersion.value++;
+    }
+    function currentCapabilities() {
+      return graphicsOutput()?.capabilities ?? NO_GRAPHICS_CAPABILITIES;
+    }
+    function trace(type, extra = {}) {
+      let capabilities = currentCapabilities();
+      try {
+        props.trace?.({
+          type,
+          id: rawId,
+          kind: props.kind,
+          protocol: capabilities.protocol,
+          contentHash: smallHash(props.content),
+          ...extra
+        });
+      } catch {
+      }
+      let protocol = isTerminalGraphicsProtocol(capabilities.protocol) ? capabilities.protocol : void 0, key = props.cacheKey ?? smallHash(props.content);
+      type === "render-start" ? recordTerminalGraphicTrace({ type: "renderer-start", id: rawId, key, protocol }) : type === "render-end" ? recordTerminalGraphicTrace({
+        type: extra.reason ? "renderer-error" : "renderer-end",
+        id: rawId,
+        key,
+        protocol,
+        durationMs: extra.durationMs,
+        bytes: extra.sequenceBytes,
+        error: extra.reason
+      }) : type === "defer" ? recordTerminalGraphicTrace({
+        type: extra.reason === "scrolling" ? "skip-scrolling" : "skip-hidden",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }) : type === "raw-draw" || (type === "render-abort" ? recordTerminalGraphicTrace({
+        type: "renderer-abort",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }) : type === "raw-clear" ? recordTerminalGraphicTrace({ type: "clear", id: rawId, key, protocol }) : type === "raw-skip-scroll" && recordTerminalGraphicTrace({
+        type: "skip-scrolling",
+        id: rawId,
+        key,
+        protocol,
+        reason: extra.reason
+      }));
+    }
+    function traceDeferOnce(reason) {
+      let key = [reason, graphicsActivityVersion.value, stableGraphicKey.value].join(":");
+      lastDeferTraceKey !== key && (lastDeferTraceKey = key, trace("defer", { reason }));
+    }
+    function abortCurrentRender(reason) {
+      renderAbort && (renderAbort.abort(), renderAbort = null, trace("render-abort", { reason }));
+    }
+    function normalizeResult(result) {
+      if (result == null)
+        return {
+          type: "text",
+          text: fallbackText()
+        };
+      if (typeof result == "string")
+        return {
+          type: "text",
+          text: result
+        };
+      if (typeof result != "object")
+        return {
+          type: "text",
+          text: fallbackText()
+        };
+      if ("type" in result && result.type === "text")
+        return {
+          type: "text",
+          text: result.text
+        };
+      let maybeRaw = result;
+      if (!(maybeRaw.type === "sequence" || "sequence" in result || "protocol" in result) && "text" in result)
+        return {
+          type: "text",
+          text: result.text
+        };
+      let sequence = typeof maybeRaw.sequence == "string" ? maybeRaw.sequence : "", protocol = isTerminalGraphicsProtocol(maybeRaw.protocol) ? maybeRaw.protocol : null, fallback = typeof maybeRaw.fallback == "string" ? sanitizeTerminalFallbackText(maybeRaw.fallback) : fallbackText(), fallbackFromProps = typeof maybeRaw.fallback != "string";
+      if (!sequence || !protocol || !isSafeTerminalGraphicsSequence(sequence, protocol, "draw"))
+        return {
+          type: "text",
+          text: fallback
+        };
+      let rawClear = typeof maybeRaw.clearSequence == "string" ? maybeRaw.clearSequence : void 0, clearSequence = rawClear && isSafeComponentClearSequence(rawClear, protocol, imageId.value, placementId.value) ? rawClear : void 0, rawResize = typeof maybeRaw.resizeSequence == "string" ? maybeRaw.resizeSequence : void 0, resizeSequence = rawResize && isSafeTerminalGraphicsSequence(rawResize, protocol, "draw") ? rawResize : void 0, declaredRows = positiveInt(maybeRaw.rows), declaredCols = positiveInt(maybeRaw.cols), sourceWidth = positiveInt(maybeRaw.sourceWidth), sourceHeight = positiveInt(maybeRaw.sourceHeight), zIndex = finiteInt(maybeRaw.zIndex), declaredSize = declaredRows == null ? null : normalizeTerminalGraphicSize(declaredCols ?? props.w, declaredRows);
+      return {
+        type: "terminal",
+        protocol,
+        sequence,
+        sequenceHash: smallHash(sequence),
+        sequenceBytes: stringByteLength(sequence),
+        fallback,
+        fallbackFromProps,
+        clearSequence,
+        clearSequenceHash: clearSequence ? smallHash(clearSequence) : void 0,
+        resizeSequence,
+        resizeSequenceHash: resizeSequence ? smallHash(resizeSequence) : void 0,
+        cols: declaredRows == null ? declaredCols : declaredSize?.width,
+        rows: declaredSize?.height,
+        sourceWidth,
+        sourceHeight,
+        zIndex
+      };
+    }
+    function defaultClearSequence(protocol) {
+      return protocol === "kitty" ? createKittyDeleteGraphicsSequence({
+        imageId: imageId.value,
+        placementId: placementId.value
+      }) : "";
+    }
+    function resolveClearSequence(current) {
+      if (current.clearSequence)
+        return current.clearSequence;
+      let candidate = defaultClearSequence(current.protocol);
+      if (candidate)
+        return isSafeComponentClearSequence(
+          candidate,
+          current.protocol,
+          imageId.value,
+          placementId.value
+        ) ? candidate : void 0;
+    }
+    function resolveResizeSequence(current, rect, full) {
+      if (current.protocol !== "kitty")
+        return current.resizeSequence;
+      let sourceWidth = positiveInt(current.sourceWidth), sourceHeight = positiveInt(current.sourceHeight);
+      if (!sourceWidth || !sourceHeight || full.w <= 0 || full.h <= 0)
+        return current.resizeSequence;
+      let offsetX = Math.max(0, rect.x - full.x), offsetY = Math.max(0, rect.y - full.y), visibleW = Math.max(0, Math.min(rect.w, full.w - offsetX)), visibleH = Math.max(0, Math.min(rect.h, full.h - offsetY)), x0 = clampNumber(Math.floor(offsetX * sourceWidth / full.w), 0, sourceWidth - 1), y0 = clampNumber(Math.floor(offsetY * sourceHeight / full.h), 0, sourceHeight - 1), x1 = Math.max(
+        x0 + 1,
+        clampNumber(Math.ceil((offsetX + visibleW) * sourceWidth / full.w), 1, sourceWidth)
+      ), y1 = Math.max(
+        y0 + 1,
+        clampNumber(Math.ceil((offsetY + visibleH) * sourceHeight / full.h), 1, sourceHeight)
+      );
+      return createKittyPlacementSequence({
+        imageId: imageId.value,
+        placementId: placementId.value,
+        columns: rect.w,
+        rows: rect.h,
+        sourceX: x0,
+        sourceY: y0,
+        sourceWidth: x1 - x0,
+        sourceHeight: y1 - y0,
+        zIndex: current.zIndex
+      });
+    }
+    function queueClearLastGraphic(options = {}) {
+      let previous = lastDrawnGraphic.value;
+      if (!previous)
+        return !1;
+      let output = graphicsOutput(), accepted = !1;
+      if (output?.clear && !previous.retainOnClear)
+        try {
+          accepted = !!output.clear(previous.id);
+        } catch {
+          accepted = !1;
+        }
+      if (!accepted && output && previous.clearSequence)
+        try {
+          accepted = output.queue({
+            id: previous.id,
+            x: previous.x,
+            y: previous.y,
+            w: previous.w,
+            h: previous.h,
+            protocol: previous.protocol,
+            sequence: previous.clearSequence,
+            deferFlush: !0,
+            retainOnClear: previous.retainOnClear,
+            op: "clear"
+          });
+        } catch {
+          accepted = !1;
+        }
+      return accepted && ((options.markPendingRepaint ?? !0) && (rawClearPendingRepaint.value = previous), lastDrawnGraphic.value = null, trace("raw-clear", {
+        x: previous.x,
+        y: previous.y,
+        w: previous.w,
+        h: previous.h
+      })), accepted;
+    }
+    function queueDrawGraphic(output, current, rect, full = rect, options = {}) {
+      let clearSequence = resolveClearSequence(current), resizeSequence = resolveResizeSequence(current, rect, full), drawKey = terminalDrawKey(current, rect, clearSequence, resizeSequence), activePrevious = lastDrawnGraphic.value, retainedPrevious = rawClearPendingRepaint.value, previous = activePrevious ?? retainedPrevious, previousIsRetained = activePrevious == null && retainedPrevious != null, previousStillActive = previous ? typeof output.isActive == "function" ? output.isActive(previous.id) : !0 : !1, preservePreviousForAtomicReplace = props.preserveRawWhileRendering && activePrevious != null && !previousIsRetained && previousStillActive;
+      if (!previousIsRetained && !options.force && previous?.drawKey === drawKey && previousStillActive)
+        return !1;
+      let canReusePlacementSequence = previousStillActive && previous?.protocol === current.protocol && previous.sequenceHash === current.sequenceHash && current.protocol === "kitty" && !!resizeSequence, scrollVersion = Math.floor(Number(props.scrollVersion ?? 0)), canMoveWithoutClear = canReusePlacementSequence && !!options.placementMoveWithoutClear;
+      if (!previousIsRetained && previousStillActive && !resizeSequence && previous?.protocol === current.protocol && previous.sequenceHash === current.sequenceHash && previous.x === rect.x && previous.y === rect.y && rect.w <= previous.w && rect.h <= previous.h && (options.force || !sameRect(rect, full)))
+        return lastDrawnGraphic.value = {
+          ...previous,
+          w: rect.w,
+          h: rect.h,
+          clearSequence,
+          resizeSequence,
+          drawKey,
+          activityVersion: graphicsActivityVersion.value,
+          scrollVersion
+        }, lastRawSkipScrollKey = "", !1;
+      if (previousStillActive && !previousIsRetained && !canReusePlacementSequence && !preservePreviousForAtomicReplace) {
+        if (!queueClearLastGraphic({ markPendingRepaint: !1 }))
+          return !1;
+      } else
+        previous && (previousStillActive || (lastDrawnGraphic.value = null, rawClearPendingRepaint.value = null));
+      let accepted = !1;
+      try {
+        accepted = output.queue({
+          id: rawId,
+          x: rect.x,
+          y: rect.y,
+          w: rect.w,
+          h: rect.h,
+          protocol: current.protocol,
+          sequence: canReusePlacementSequence && resizeSequence ? resizeSequence : current.sequence,
+          resizeSequence,
+          clearSequence,
+          retainOnClear: !!(props.cacheKey && resizeSequence),
+          resizeRedraw: canReusePlacementSequence,
+          placementMoveWithoutClear: canMoveWithoutClear,
+          allowTextOverlay: options.allowTextOverlay,
+          forceDraw: options.force,
+          deferFlush: options.deferFlush ?? !0,
+          fallbackText: current.fallback
+        });
+      } catch {
+        accepted = !1;
+      }
+      return accepted ? (rawDrawRejectedKey.value = null, rawClearPendingRepaint.value = null, lastDrawnGraphic.value = {
+        id: rawId,
+        x: rect.x,
+        y: rect.y,
+        w: rect.w,
+        h: rect.h,
+        protocol: current.protocol,
+        sequenceHash: current.sequenceHash,
+        clearSequence,
+        resizeSequence,
+        retainOnClear: !!(props.cacheKey && resizeSequence),
+        allowTextOverlay: !!options.allowTextOverlay,
+        drawKey,
+        activityVersion: graphicsActivityVersion.value,
+        scrollVersion
+      }, lastRawSkipScrollKey = "", !0) : (preservePreviousForAtomicReplace ? (lastDrawnGraphic.value = activePrevious, queueClearLastGraphic({ markPendingRepaint: !1 })) : lastDrawnGraphic.value = null, rawDrawRejectedKey.value !== drawKey && (rawDrawRejectedKey.value = drawKey, scheduler.invalidate({ priority: "low", reason: "data" })), !1);
+    }
+    function hasRetainedActiveRawGraphic() {
+      let output = graphicsOutput();
+      return !!(status.value === "loading" && !graphic.value && output && typeof output.isActive == "function" && output.isActive(rawId));
+    }
+    let showingInitialLoadingText = (0, import_vue8.computed)(
+      () => status.value === "loading" && !graphic.value && !hasRetainedActiveRawGraphic()
+    ), fullRect = (0, import_vue8.computed)(() => {
+      let current = graphic.value, reserved = reservedTerminalGraphicSize.value, reservedRows = current?.type === "terminal" ? void 0 : status.value === "idle" && reserved?.key === stableGraphicKey.value ? reserved.rows : void 0, textLines = current?.type === "text" ? splitTextOutput(current.text) : splitTextOutput(fallbackText()), height = props.h ?? (current?.type === "terminal" ? current.rows : void 0) ?? reservedRows ?? Math.max(1, textLines.length);
+      return translateRect(
+        { x: props.x, y: props.y, w: props.w, h: height },
+        layout.originX,
+        layout.originY
+      );
+    }), absRect = (0, import_vue8.computed)(() => {
+      terminalSizeVersion.value;
+      let translated = fullRect.value, size = terminal.size(), terminalClip = {
+        x: 0,
+        y: 0,
+        w: Math.max(0, Math.floor(size.cols)),
+        h: Math.max(0, Math.floor(size.rows))
+      }, clip = layout.clipRect ? intersectRect(layout.clipRect, terminalClip) : terminalClip;
+      return clip ? intersectRect(translated, clip) ?? { x: 0, y: 0, w: 0, h: 0 } : { x: 0, y: 0, w: 0, h: 0 };
+    }), renderRect = (0, import_vue8.computed)(() => absRect.value);
+    function rawRectFitsTerminalViewport(rect) {
+      return canDrawTerminalGraphicRect(rect, terminal.size());
+    }
+    function rawCoveredByHigherRenderNode(rect = fullRect.value) {
+      if (props.retainRawWhileCovered)
+        return !1;
+      let id = renderNodeId.value;
+      return !props.ignoreRawCoverage && id != null && render.isRectCoveredByHigherNode(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      });
+    }
+    function retainedRawCoveredByHigherRenderNode(rect) {
+      if (!props.retainRawWhileCovered)
+        return !1;
+      let id = renderNodeId.value;
+      return !!(id != null && render.isRectCoveredByHigherNode(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      }));
+    }
+    function rawUncoveredRenderRect(rect) {
+      if (props.retainRawWhileCovered)
+        return rect;
+      let id = renderNodeId.value;
+      if (id == null)
+        return rect;
+      let covers = render.higherNodeCoverageRects(id, rect, {
+        ignoreSamePlane: props.ignoreSamePlaneRawCoverage
+      });
+      return covers.length ? props.ignoreRawCoverage ? largestUncoveredRect(rect, covers) : null : rect;
+    }
+    let rawCanRender = (0, import_vue8.computed)(() => {
+      graphicsOutputVersion.value, terminalSizeVersion.value;
+      let current = graphic.value, output = graphicsOutput(), rect = absRect.value;
+      return current?.type === "terminal" && rawRectFitsTerminalViewport(rect) && !!output?.capabilities.supported && output?.capabilities.preferredProtocol === current.protocol;
+    }), rawOutputCanRenderValue = (0, import_vue8.computed)(() => (graphicsOutputVersion.value, terminalSizeVersion.value, rawOutputCanRender())), rawSuppressedByScroll = (0, import_vue8.computed)(
+      () => props.suspended || props.suspendRawWhileScrolling && isParentScrolling.value
+    ), rawCanQueue = (0, import_vue8.computed)(() => rawCanRender.value && !rawSuppressedByScroll.value);
+    function traceRawSkipScrollOnce(reason) {
+      let r = absRect.value, key = [
+        reason,
+        graphicsActivityVersion.value,
+        stableGraphicKey.value,
+        r.x,
+        r.y,
+        r.w,
+        r.h
+      ].join(":");
+      lastRawSkipScrollKey !== key && (lastRawSkipScrollKey = key, trace("raw-skip-scroll", { reason }));
+    }
+    function hasPaintableRect() {
+      let r = absRect.value;
+      return visible.value && r.w > 0 && r.h > 0;
+    }
+    function rawOutputCanRender() {
+      let output = graphicsOutput(), rect = absRect.value;
+      return rawRectFitsTerminalViewport(rect) && !!output?.capabilities.supported;
+    }
+    function renderDeferReason() {
+      return props.suspended ? "suspended" : props.deferRenderUntilVisible && !hasPaintableRect() ? "not-visible" : props.suspendRenderWhileScrolling && isParentScrolling.value ? "scrolling" : null;
+    }
+    function shouldDeferRender() {
+      return renderDeferReason() != null;
+    }
+    function shouldRerenderForGraphicsOutputChange() {
+      if (!props.renderer || !props.content.trim() || shouldDeferRender() || rawSuppressedByScroll.value)
+        return !1;
+      let protocol = currentCapabilities().protocol;
+      return lastRenderProtocol != null && (lastRenderProtocol !== protocol || lastRenderGraphicsOutputVersion !== graphicsOutputVersion.value);
+    }
+    function shouldRetryTemporaryRawFallback(rawCovered = rawCoveredByHigherRenderNode()) {
+      return !!props.renderer && props.content.trim().length > 0 && graphic.value?.type === "text" && status.value !== "loading" && !lastRenderRawVisible && rawOutputCanRenderValue.value && !rawSuppressedByScroll.value && !rawCovered;
+    }
+    function setDeferredFallback(content) {
+      graphic.value = { type: "text", text: content.trim() ? fallbackText() : "" }, lastRenderedContent = content, status.value = "idle", error.value = "", bump();
+    }
+    function resolveRendererContext(signal) {
+      let capabilities = currentCapabilities(), visibleNow = hasPaintableRect(), rawVisible = rawOutputCanRenderValue.value && !rawSuppressedByScroll.value && !rawCoveredByHigherRenderNode();
+      return {
+        kind: props.kind,
+        width: props.w,
+        height: props.h,
+        final: props.final,
+        streaming: props.streaming,
+        protocol: capabilities.protocol,
+        capabilities,
+        signal,
+        imageId: imageId.value,
+        placementId: placementId.value,
+        visible: visibleNow,
+        rawVisible,
+        scrolling: isParentScrolling.value,
+        cacheKey: props.cacheKey,
+        viewport: {
+          visible: visibleNow,
+          rawVisible,
+          scrolling: isParentScrolling.value,
+          rect: absRect.value,
+          fullRect: fullRect.value
+        }
+      };
+    }
+    async function renderNow(version) {
+      let protocol = currentCapabilities().protocol;
+      recordTerminalGraphicTrace({
+        type: "request",
+        id: rawId,
+        key: props.cacheKey ?? smallHash(props.content),
+        protocol: isTerminalGraphicsProtocol(protocol) ? protocol : void 0
+      });
+      let content = props.content;
+      if (!content.trim()) {
+        if (abortCurrentRender("superseded"), !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: "" }, lastRenderedContent = content, status.value = "ready", error.value = "", bump();
+        return;
+      }
+      let renderer = props.renderer;
+      if (!renderer) {
+        if (abortCurrentRender("superseded"), !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: fallbackText() }, lastRenderedContent = content, status.value = "ready", error.value = "", bump();
+        return;
+      }
+      let deferred = renderDeferReason();
+      if (deferred) {
+        if (abortCurrentRender(deferred), !alive || version !== renderVersion)
+          return;
+        setDeferredFallback(content), traceDeferOnce(deferred);
+        return;
+      }
+      abortCurrentRender("superseded"), lastDeferTraceKey = "";
+      let abort = new AbortController();
+      renderAbort = abort;
+      let startedAt = nowTerminalGraphicTraceTime();
+      status.value = "loading", error.value = "", trace("render-start"), bump();
+      try {
+        let contextGraphicsOutputVersion = graphicsOutputVersion.value, context = resolveRendererContext(abort.signal);
+        lastRenderRawVisible = context.rawVisible, lastRenderProtocol = context.protocol, lastRenderGraphicsOutputVersion = contextGraphicsOutputVersion;
+        let result = await renderer(content, context);
+        if (abort.signal.aborted || !alive || version !== renderVersion)
+          return;
+        let normalized = normalizeResult(result);
+        rememberTerminalGraphicSize(normalized), graphic.value = normalized, lastRenderedContent = content, status.value = "ready", error.value = "", trace("render-end", {
+          durationMs: nowTerminalGraphicTraceTime() - startedAt,
+          sequenceChars: normalized.type === "terminal" ? normalized.sequence.length : 0,
+          sequenceBytes: normalized.type === "terminal" ? normalized.sequenceBytes : 0
+        }), bump(), normalized.type === "terminal" && scheduler.invalidate({ priority: "low", reason: "data" });
+      } catch (err) {
+        if (abort.signal.aborted || !alive || version !== renderVersion)
+          return;
+        graphic.value = { type: "text", text: fallbackText() }, lastRenderedContent = content, status.value = "ready", error.value = errorMessage(err), trace("render-end", {
+          durationMs: nowTerminalGraphicTraceTime() - startedAt,
+          reason: error.value
+        }), bump();
+      } finally {
+        renderAbort === abort && (renderAbort = null);
+      }
+    }
+    function scheduleRender(options = {}) {
+      let version = ++renderVersion;
+      if ((options.clearLastGraphic ?? !props.preserveRawWhileRendering) && queueClearLastGraphic(), !builtOnce || !props.streaming) {
+        builtOnce = !0, renderNow(version);
+        return;
+      }
+      scheduler.queueFrameTask({
+        id: frameTaskId,
+        reason: "stream",
+        priority: "low",
+        sync: !1,
+        run: () => {
+          alive && version === renderVersion && renderNow(version);
+        }
+      }) === !1 && renderNow(version);
+    }
+    (0, import_vue8.watch)(
+      [
+        () => props.content,
+        () => props.kind,
+        () => props.renderer,
+        () => props.w,
+        () => props.h,
+        () => props.streaming,
+        () => props.final,
+        () => props.deferRenderUntilVisible,
+        () => props.suspendRawWhileScrolling,
+        () => props.suspendRenderWhileScrolling,
+        () => props.scrolling,
+        () => props.preserveRawWhileRendering,
+        () => props.suspended,
+        () => props.retainRawWhileCovered,
+        () => props.ignoreRawCoverage,
+        () => props.ignoreSamePlaneRawCoverage,
+        () => props.cacheKey,
+        () => props.placementKey
+      ],
+      () => {
+        scheduleRender();
+      },
+      { immediate: !0 }
+    ), (0, import_vue8.watch)(
+      () => props.fallback,
+      () => {
+        let current = graphic.value;
+        if (current?.type === "terminal") {
+          if (current.fallbackFromProps) {
+            graphic.value = { ...current, fallback: fallbackText() }, bump(), scheduler.invalidate({ priority: "low", reason: "data" });
+            return;
+          }
+          scheduleRender({ clearLastGraphic: !1 });
+          return;
+        }
+        scheduleRender();
+      }
+    ), (0, import_vue8.watch)(
+      () => [graphicsOutputVersion.value, rawOutputCanRenderValue.value],
+      () => {
+        !props.renderer || !props.content.trim() || graphic.value?.type !== "terminal" && (!rawOutputCanRenderValue.value || shouldDeferRender() || scheduleRender({ clearLastGraphic: !1 }));
+      }
+    ), (0, import_vue8.watch)(
+      () => [props.x, props.y, props.w, props.h, props.scrollVersion],
+      () => {
+        if (graphic.value?.type === "terminal") {
+          scheduler.invalidate({ priority: "low", reason: "data" });
+          return;
+        }
+        props.kind !== "image" || status.value !== "loading" || !props.renderer || scheduleRender({ clearLastGraphic: !1 });
+      },
+      { flush: "sync" }
+    ), (0, import_vue8.onBeforeUnmount)(() => {
+      alive = !1, renderVersion++, unsubscribeTerminalResize(), unsubscribeGraphicsOutput(), abortCurrentRender("unmount"), scheduler.cancelFrameTask?.(frameTaskId), queueClearLastGraphic();
+    });
+    function resolveDisplayLines(rawPlaceholderAllowed) {
+      if (showingInitialLoadingText.value)
+        return splitTextOutput(props.loadingText);
+      let current = graphic.value;
+      if (!current)
+        return splitTextOutput(fallbackText());
+      if (current.type === "terminal" && rawPlaceholderAllowed) {
+        let clearSequence = resolveClearSequence(current), drawKey = terminalDrawKey(
+          current,
+          absRect.value,
+          clearSequence,
+          resolveResizeSequence(current, absRect.value, fullRect.value)
+        );
+        if (rawDrawRejectedKey.value !== drawKey)
+          return (0, import_vue8.markRaw)([""]);
+      }
+      let text = current.type === "terminal" ? current.fallback : current.text, lines = splitTextOutput(text);
+      return text.trim().length > 0 && !hasVisibleOutput(lines) ? splitTextOutput(fallbackText()) : lines;
+    }
+    let displayLines = (0, import_vue8.computed)(() => resolveDisplayLines(rawCanQueue.value)), currentStyle = (0, import_vue8.computed)(() => error.value ? props.errorStyle ?? props.style ?? defaultStyle.value : showingInitialLoadingText.value ? props.loadingStyle ?? props.style ?? defaultStyle.value : props.style ?? defaultStyle.value), renderNode = useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? renderRect.value : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        renderRect.value,
+        fullRect.value,
+        displayLines.value,
+        currentStyle.value,
+        props.clear,
+        status.value,
+        error.value,
+        documentVersion.value,
+        rawOutputCanRenderValue.value,
+        rawCanRender.value,
+        rawCanQueue.value,
+        rawClearPendingRepaint.value,
+        rawDrawRejectedKey.value,
+        rawSuppressedByScroll.value,
+        props.placementMoveWithoutClear,
+        props.retainRawWhileCovered,
+        isParentScrolling.value,
+        graphicsActivityVersion.value,
+        graphicsOutputVersion.value
+      ],
+      paint: (dirtyRows) => {
+        withTextWidthProvider(widthProvider, () => {
+          if (!visible.value) {
+            queueClearLastGraphic();
+            return;
+          }
+          let r = absRect.value, full = fullRect.value;
+          if (r.w <= 0 || r.h <= 0) {
+            queueClearLastGraphic();
+            return;
+          }
+          let style = currentStyle.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), current = graphic.value, output = graphicsOutput(), retainedActiveRawGraphic = hasRetainedActiveRawGraphic(), rawRectForPaint = rawUncoveredRenderRect(r), rawCoverageClipped = rawRectForPaint != null && props.ignoreRawCoverage && !sameRect(rawRectForPaint, r), rawCoveredForPaint = rawRectForPaint == null && rawCoveredByHigherRenderNode(r), rawCanQueueForPaint = current?.type === "terminal" && rawCanQueue.value && rawRectForPaint != null, preserveActiveRawGraphic = !1, forceActiveRawRedraw = !1, allowTextOverlay = !1;
+          if (rawCanQueueForPaint && output) {
+            let previous = lastDrawnGraphic.value;
+            if ((previous ? typeof output.isActive == "function" ? output.isActive(previous.id) : !0 : !1) && previous) {
+              let clearSequence = resolveClearSequence(current), resizeSequence = resolveResizeSequence(current, rawRectForPaint, full);
+              preserveActiveRawGraphic = rawClearPendingRepaint.value == null && previous.drawKey === terminalDrawKey(current, rawRectForPaint, clearSequence, resizeSequence), allowTextOverlay = retainedRawCoveredByHigherRenderNode(r), forceActiveRawRedraw = preserveActiveRawGraphic && (previous.activityVersion !== graphicsActivityVersion.value || previous.allowTextOverlay !== allowTextOverlay);
+            }
+          }
+          let preserveActiveRawGraphicForPaint = preserveActiveRawGraphic, out = rawCanQueueForPaint ? displayLines.value : resolveDisplayLines(!1), clearingRawGraphic = rawClearPendingRepaint.value != null || lastDrawnGraphic.value != null && !preserveActiveRawGraphicForPaint, clearOwnedRegion = preserveActiveRawGraphicForPaint || retainedActiveRawGraphic ? !1 : props.clear || clearingRawGraphic || !!rawCanQueueForPaint, blank = clearOwnedRegion ? spaces(r.w) : "", paintRow = (y) => {
+            if (y < r.y || y >= r.y + r.h)
+              return;
+            let rowIndex = y - fullY;
+            if (rowIndex < 0 || rowIndex >= out.length) {
+              clearOwnedRegion && terminal.write(blank, { x: r.x, y, style });
+              return;
+            }
+            let src = out[rowIndex] ?? "", clipped = dx > 0 ? sliceByCellsRange(src, dx, dx + r.w) : sliceByCells(src, r.w), value = clearOwnedRegion ? padEndByCells(clipped, r.w) : clipped;
+            (value || clearOwnedRegion) && terminal.write(value, { x: r.x, y, style });
+          }, paintRows = () => {
+            if (dirtyRows?.length)
+              for (let y of dirtyRows)
+                paintRow(y);
+            else
+              for (let y = r.y; y < r.y + r.h; y++)
+                paintRow(y);
+          };
+          if (paintRows(), current?.type === "terminal" && output?.capabilities.supported && output.capabilities.preferredProtocol === current.protocol && rawCanQueueForPaint) {
+            let drawKey = terminalDrawKey(
+              current,
+              rawRectForPaint,
+              resolveClearSequence(current),
+              resolveResizeSequence(current, rawRectForPaint, full)
+            );
+            queueDrawGraphic(output, current, rawRectForPaint, full, {
+              force: forceActiveRawRedraw,
+              deferFlush: preserveActiveRawGraphicForPaint,
+              placementMoveWithoutClear: props.placementMoveWithoutClear || rawCoverageClipped,
+              allowTextOverlay
+            }) ? trace("raw-draw", {
+              sequenceChars: current.sequence.length,
+              sequenceBytes: current.sequenceBytes,
+              x: rawRectForPaint.x,
+              y: rawRectForPaint.y,
+              w: rawRectForPaint.w,
+              h: rawRectForPaint.h
+            }) : rawDrawRejectedKey.value === drawKey && (out = resolveDisplayLines(!1), paintRows());
+          } else
+            current?.type === "terminal" && rawSuppressedByScroll.value && traceRawSkipScrollOnce(isParentScrolling.value ? "scrolling" : "suspended"), queueClearLastGraphic({ markPendingRepaint: !1 }), !shouldDeferRender() && shouldRetryTemporaryRawFallback(rawCoveredForPaint) && scheduleRender({ clearLastGraphic: !1 });
+          clearingRawGraphic && (rawClearPendingRepaint.value = null);
+        });
+      }
+    }));
+    return (0, import_vue8.watch)(
+      renderNode.id,
+      (id) => {
+        renderNodeId.value = id;
+      },
+      { immediate: !0 }
+    ), (0, import_vue8.watch)(
+      [
+        visible,
+        rawOutputCanRenderValue,
+        rawCanRender,
+        rawCanQueue,
+        rawSuppressedByScroll,
+        isParentScrolling,
+        graphicsActivityVersion,
+        graphicsOutputVersion,
+        () => renderRect.value.x,
+        () => renderRect.value.y,
+        () => renderRect.value.w,
+        () => renderRect.value.h,
+        () => fullRect.value.x,
+        () => fullRect.value.y,
+        () => fullRect.value.w,
+        () => fullRect.value.h
+      ],
+      () => {
+        if (!alive)
+          return;
+        let deferred = renderDeferReason();
+        deferred && (abortCurrentRender(deferred), (status.value === "loading" || !graphic.value || lastRenderedContent !== props.content) && setDeferredFallback(props.content), traceDeferOnce(deferred)), (!visible.value || !rawCanQueue.value) && queueClearLastGraphic();
+        let shouldRetryTemporaryFallback = shouldRetryTemporaryRawFallback(), shouldRerenderForOutputChange = shouldRerenderForGraphicsOutputChange();
+        if (!shouldDeferRender() && (!graphic.value || status.value === "idle" || shouldRetryTemporaryFallback || shouldRerenderForOutputChange)) {
+          scheduleRender();
+          return;
+        }
+        scheduler.invalidate({ priority: "low", reason: "data" });
+      },
+      { flush: "post" }
+    ), () => (0, import_vue8.h)("span", rootProps);
+  }
+});
+
+// src/vue/components/TText.ts
+var import_vue9 = require("vue");
+function fitText(text, max) {
+  return max <= 0 ? "" : (text = sanitizeInlineText(text), sliceByCells(text, max));
+}
+function splitLines(text) {
+  return sanitizeTextBlock(text).split(`
+`);
+}
+function computeDefaultWidth(text) {
+  let lines = splitLines(text), max = 0;
+  for (let line of lines)
+    max = Math.max(max, textCellWidth(line));
+  return max;
+}
+var TText = (0, import_vue9.defineComponent)({
+  name: "TText",
+  props: {
+    x: { type: Number, required: !0 },
+    y: { type: Number, required: !0 },
+    zIndex: { type: Number, default: 0 },
+    value: { type: String, required: !0 },
+    w: { type: Number, default: void 0 },
+    h: { type: Number, default: void 0 },
+    style: { type: Object, default: void 0 },
+    clear: { type: Boolean, default: !0 },
+    wrap: { type: Boolean, default: !1 },
+    /**
+     * Optional key that participates in render-node dependency tracking.
+     * Useful for forcing a repaint when the rendered output might change
+     * even if `value`, `style`, and geometry are unchanged (e.g. external
+     * terminal writes or higher-level virtualized row reuse).
+     */
+    depsKey: { type: null, default: void 0 }
+  },
+  setup(props) {
+    let { terminal, defaultStyle } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility(), defaultWidth = (0, import_vue9.computed)(() => computeDefaultWidth(props.value)), lines = (0, import_vue9.computed)(() => {
+      let w = props.w ?? defaultWidth.value;
+      if (w <= 0)
+        return [""];
+      if (!props.wrap)
+        return splitLines(props.value).map((l) => fitText(l, w));
+      let safe = sanitizeTextBlock(props.value);
+      return wrapByCells(safe, w).map((l) => fitText(l, w));
+    }), absRect = (0, import_vue9.computed)(() => {
+      let width = props.w ?? defaultWidth.value, height = props.h ?? (props.wrap, lines.value.length || 1), raw = { x: props.x, y: props.y, w: width, h: height }, translated = translateRect(raw, layout.originX, layout.originY);
+      return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
+    }), fullRect = (0, import_vue9.computed)(() => {
+      let width = props.w ?? defaultWidth.value, height = props.h ?? (props.wrap, lines.value.length || 1);
+      return translateRect(
+        { x: props.x, y: props.y, w: width, h: height },
+        layout.originX,
+        layout.originY
+      );
+    });
+    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,
+        props.value,
+        props.w,
+        props.h,
+        props.wrap,
+        props.style,
+        defaultStyle.value,
+        props.depsKey
+      ],
+      paint: (dirtyRows) => {
+        if (!visible.value)
+          return;
+        let r = absRect.value;
+        if (r.w <= 0 || r.h <= 0)
+          return;
+        let full = fullRect.value, style = props.style ?? defaultStyle.value, blank = props.clear ? spaces(r.w) : "", out = lines.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), paintRow = (y) => {
+          let relY = y - r.y;
+          if (relY < 0 || relY >= r.h)
+            return;
+          let i = y - fullY;
+          if (i < 0 || i >= out.length) {
+            props.clear && terminal.write(blank, { x: r.x, y, style });
+            return;
+          }
+          let src = out[i] ?? "", clipped = dx > 0 ? sliceByCellsRange(src, dx, dx + r.w) : sliceByCells(src, r.w);
+          terminal.write(padEndByCells(clipped, r.w), { x: r.x, y, style });
+        };
+        if (!dirtyRows) {
+          for (let i = 0; i < r.h; i++)
+            paintRow(r.y + i);
+          return;
+        }
+        for (let y of dirtyRows)
+          paintRow(y);
+      }
+    })), () => (0, import_vue9.h)("span", rootProps);
+  }
+});
+
+// src/vue/components/TView.ts
+var import_vue10 = require("vue");
+var EMPTY_RECT = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), TView = (0, import_vue10.defineComponent)({
+  name: "TView",
+  props: {
+    x: { type: Number, required: !0 },
+    y: { type: Number, required: !0 },
+    w: { type: Number, required: !0 },
+    h: { type: Number, required: !0 },
+    zIndex: { type: Number, default: 0 },
+    scrollX: { type: Number, default: 0 },
+    scrollY: { type: Number, default: 0 },
+    focusable: { type: Boolean, default: !1 },
+    selectable: { type: Boolean, default: void 0 },
+    selectionScrollBy: {
+      type: Function,
+      default: void 0
+    },
+    autoFocus: { type: Boolean, default: !1 }
+  },
+  emits: [
+    "clickCapture",
+    "click",
+    "dblclickCapture",
+    "dblclick",
+    "pointerdownCapture",
+    "pointerdown",
+    "pointerupCapture",
+    "pointerup",
+    "pointermoveCapture",
+    "pointermove",
+    "pointerenterCapture",
+    "pointerenter",
+    "pointerleaveCapture",
+    "pointerleave",
+    "wheelCapture",
+    "wheel",
+    "keydownCapture",
+    "keydown",
+    "keyupCapture",
+    "keyup",
+    "focusCapture",
+    "focus",
+    "blurCapture",
+    "blur"
+  ],
+  setup(props, { emit, slots }) {
+    let parent = useLayout(), { render, events } = useTerminal(), parentStack = useRenderStack(), { visible, rootProps } = useVisibility({ provide: !0 }), parentEventZ = (0, import_vue10.inject)(EventZIndexContextKey, (0, import_vue10.computed)(() => 0)), eventZ = (0, import_vue10.computed)(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0)), rawRect = (0, import_vue10.computed)(
+      () => translateRect(
+        { x: props.x, y: props.y, w: props.w, h: props.h },
+        parent.originX,
+        parent.originY
+      )
+    ), rect = (0, import_vue10.computed)(() => {
+      let translated = rawRect.value;
+      return parent.clipRect ? intersectRect(translated, parent.clipRect) ?? EMPTY_RECT : translated;
+    }), { id } = useTerminalNode(() => ({
+      rect: rect.value,
+      zIndex: eventZ.value,
+      visible: visible.value,
+      focusable: props.focusable,
+      selectable: props.selectable,
+      selectionScrollBy: props.selectionScrollBy,
+      handlers: {
+        clickCapture: (e) => emit("clickCapture", e),
+        click: (e) => emit("click", e),
+        dblclickCapture: (e) => emit("dblclickCapture", e),
+        dblclick: (e) => emit("dblclick", e),
+        pointerdownCapture: (e) => emit("pointerdownCapture", e),
+        pointerdown: (e) => emit("pointerdown", e),
+        pointerupCapture: (e) => emit("pointerupCapture", e),
+        pointerup: (e) => emit("pointerup", e),
+        pointermoveCapture: (e) => emit("pointermoveCapture", e),
+        pointermove: (e) => emit("pointermove", e),
+        pointerenterCapture: (e) => emit("pointerenterCapture", e),
+        pointerenter: (e) => emit("pointerenter", e),
+        pointerleaveCapture: (e) => emit("pointerleaveCapture", e),
+        pointerleave: (e) => emit("pointerleave", e),
+        wheelCapture: (e) => emit("wheelCapture", e),
+        wheel: (e) => emit("wheel", e),
+        keydownCapture: (e) => emit("keydownCapture", e),
+        keydown: (e) => emit("keydown", e),
+        keyupCapture: (e) => emit("keyupCapture", e),
+        keyup: (e) => emit("keyup", e),
+        focusCapture: (e) => emit("focusCapture", e),
+        focus: (e) => emit("focus", e),
+        blurCapture: (e) => emit("blurCapture", e),
+        blur: (e) => emit("blur", e)
+      }
+    }));
+    (0, import_vue10.watchEffect)(() => {
+      if (!props.autoFocus || !visible.value)
+        return;
+      let manager = events.value, nodeId = id.value;
+      !manager || !nodeId || manager.getFocused() !== nodeId && manager.focus(nodeId);
+    });
+    let childLayout = (0, import_vue10.shallowReactive)({
+      originX: 0,
+      originY: 0,
+      clipRect: null
+    }), childStack = (0, import_vue10.computed)(() => render.createStack(parentStack.value, props.zIndex));
+    return (0, import_vue10.watchEffect)(() => {
+      let translated = rawRect.value;
+      childLayout.originX = translated.x - Math.floor(props.scrollX), childLayout.originY = translated.y - Math.floor(props.scrollY), childLayout.clipRect = rect.value;
+    }), (0, import_vue10.provide)(LayoutContextKey, childLayout), (0, import_vue10.provide)(RenderStackKey, childStack), (0, import_vue10.provide)(EventZIndexContextKey, eventZ), () => (0, import_vue10.h)("div", rootProps, slots.default?.());
+  }
+});
+
+// src/vue/components/TVideo.ts
+var DEFAULT_MAX_FPS = 12, DEFAULT_MAX_PIXEL_WIDTH = 640, DEFAULT_MAX_PIXEL_HEIGHT = 360, MAX_PIXEL_DIMENSION = 4096, MAX_FRAME_BYTES = 8 * 1024 * 1024, MAX_GRAY8_FPS = 10, MAX_GRAY8_WIDTH = 512, MAX_GRAY8_HEIGHT = 256, ASCII_RAMP = " .:-=+*#%@", CONTROL_REFRESH_MS = 250, PLAYBACK_RATES = [1, 2, 3];
+function positiveInt2(value, fallback, max) {
+  let parsed = Math.floor(Number(value));
+  return !Number.isFinite(parsed) || parsed <= 0 ? Math.min(max, fallback) : Math.min(max, parsed);
+}
+function positiveNumber(value, fallback, max) {
+  let parsed = Number(value);
+  return !Number.isFinite(parsed) || parsed <= 0 ? fallback : Math.min(max, parsed);
+}
+function playbackRate(value) {
+  return value === 2 || value === 3 ? value : 1;
+}
+function optionalDuration(value) {
+  let parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function formatPlaybackTime(valueMs, hourDigits = 0) {
+  if (valueMs == null)
+    return "--:--";
+  let seconds = Math.max(0, Math.floor(valueMs / 1e3)), hours = Math.floor(seconds / 3600), minutes = Math.floor(seconds % 3600 / 60), remainder = seconds % 60;
+  return hours > 0 || hourDigits > 0 ? `${String(hours).padStart(Math.max(1, hourDigits), "0")}:${String(minutes).padStart(2, "0")}:${String(remainder).padStart(2, "0")}` : `${String(minutes).padStart(2, "0")}:${String(remainder).padStart(2, "0")}`;
+}
+function readUint32(bytes, offset) {
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+}
+function normalizeFrame(frame) {
+  if (frame.format === "gray8") {
+    let pixelWidth2 = Math.floor(Number(frame.pixelWidth)), pixelHeight2 = Math.floor(Number(frame.pixelHeight)), pixels = frame.pixels;
+    if (!Number.isFinite(pixelWidth2) || !Number.isFinite(pixelHeight2) || pixelWidth2 <= 0 || pixelHeight2 <= 0 || pixelWidth2 > MAX_GRAY8_WIDTH || pixelHeight2 > MAX_GRAY8_HEIGHT || !(pixels instanceof Uint8Array) || pixels.length !== pixelWidth2 * pixelHeight2 || pixels.length > MAX_FRAME_BYTES)
+      throw new Error("TVideo gray8 frame must match its bounded pixel dimensions");
+    return {
+      format: "gray8",
+      pixels,
+      timestampMs: Math.max(0, Number(frame.timestampMs) || 0),
+      pixelWidth: pixelWidth2,
+      pixelHeight: pixelHeight2,
+      fingerprint: frame.fingerprint,
+      durationMs: optionalDuration(frame.durationMs)
+    };
+  }
+  let png = frame.png;
+  if (!(png instanceof Uint8Array) || png.length < 24 || png.length > MAX_FRAME_BYTES)
+    throw new Error("TVideo frame must contain a bounded PNG Uint8Array");
+  if (png[0] !== 137 || png[1] !== 80 || png[2] !== 78 || png[3] !== 71 || png[4] !== 13 || png[5] !== 10 || png[6] !== 26 || png[7] !== 10)
+    throw new Error("TVideo frame source emitted invalid PNG data");
+  let pixelWidth = readUint32(png, 16), pixelHeight = readUint32(png, 20);
+  if (pixelWidth <= 0 || pixelHeight <= 0 || pixelWidth > MAX_PIXEL_DIMENSION || pixelHeight > MAX_PIXEL_DIMENSION)
+    throw new Error(`TVideo frame has an unsupported size: ${pixelWidth}x${pixelHeight}`);
+  return {
+    format: "png",
+    png,
+    timestampMs: Math.max(0, Number(frame.timestampMs) || 0),
+    pixelWidth,
+    pixelHeight,
+    fingerprint: frame.fingerprint,
+    durationMs: optionalDuration(frame.durationMs)
+  };
+}
+function frameBytes(frame) {
+  return frame.format === "gray8" ? frame.pixels : frame.png;
+}
+function gray8ToAscii(frame, cellWidth) {
+  let lines = [], width = Math.max(1, Math.floor(cellWidth));
+  for (let y = 0; y < frame.pixelHeight; y++) {
+    let line = "", rowStart = y * frame.pixelWidth;
+    for (let x = 0; x < frame.pixelWidth; x++) {
+      let value = frame.pixels[rowStart + x], glyph = ASCII_RAMP[Math.min(ASCII_RAMP.length - 1, value * ASCII_RAMP.length >> 8)];
+      line += `${glyph}${glyph}`;
+    }
+    lines.push(line.slice(0, width));
+  }
+  return lines.join(`
+`);
+}
+function sameBytes(left, right) {
+  if (left.length !== right.length)
+    return !1;
+  for (let index = 0; index < left.length; index++)
+    if (left[index] !== right[index])
+      return !1;
+  return !0;
+}
+function bytesToBase64(bytes) {
+  let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", chunks = [], chunk = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    let a = bytes[index], hasB = index + 1 < bytes.length, hasC = index + 2 < bytes.length, b = hasB ? bytes[index + 1] : 0, c = hasC ? bytes[index + 2] : 0;
+    chunk += alphabet[a >> 2] + alphabet[(a & 3) << 4 | b >> 4] + (hasB ? alphabet[(b & 15) << 2 | c >> 6] : "=") + (hasC ? alphabet[c & 63] : "="), chunk.length >= 16384 && (chunks.push(chunk), chunk = "");
+  }
+  return chunk && chunks.push(chunk), chunks.join("");
+}
+function createFrameRenderer(frame, cellWidth) {
+  if (frame.format === "gray8") {
+    let text = gray8ToAscii(frame, cellWidth);
+    return () => ({ type: "text", text });
+  }
+  let base64;
+  return (_content, context) => {
+    if (!context.visible || !context.rawVisible)
+      return null;
+    base64 ?? (base64 = bytesToBase64(frame.png));
+    let protocol = context.protocol;
+    return protocol !== "kitty" && protocol !== "iterm2" ? null : createTerminalGraphicPngSequence({
+      protocol,
+      base64,
+      imageId: context.imageId,
+      placementId: context.placementId,
+      cols: context.width,
+      rows: context.height,
+      sourceWidth: frame.pixelWidth,
+      sourceHeight: frame.pixelHeight,
+      placementColumns: Math.max(1, Math.floor(context.viewport.rect.w)),
+      placementRows: Math.max(1, Math.floor(context.viewport.rect.h)),
+      rect: context.viewport.rect,
+      fullRect: context.viewport.fullRect,
+      freeImageData: !0
+    });
+  };
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var tVideoProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, required: !0 },
+  zIndex: { type: Number, default: 0 },
+  src: { type: String, required: !0 },
+  frameSource: {
+    type: Function,
+    required: !0
+  },
+  paused: { type: Boolean, default: void 0 },
+  playbackRate: { type: Number, default: void 0 },
+  controls: { type: Boolean, default: !1 },
+  controlsLayout: {
+    type: String,
+    default: "compact"
+  },
+  durationMs: { type: Number, default: void 0 },
+  loop: { type: Boolean, default: !1 },
+  maxFps: { type: Number, default: DEFAULT_MAX_FPS },
+  pixelWidth: { type: Number, default: void 0 },
+  pixelHeight: { type: Number, default: void 0 },
+  fallback: { type: String, default: "[video]" },
+  style: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 }
+}, TVideo = (0, import_vue11.defineComponent)({
+  name: "TVideo",
+  props: tVideoProps,
+  emits: {
+    frame: (_event) => !0,
+    ended: () => !0,
+    error: (_error) => !0,
+    seek: (_event) => !0,
+    "update:paused": (_paused) => !0,
+    "update:playbackRate": (_rate) => !0
+  },
+  setup(props, { emit }) {
+    let instance = (0, import_vue11.getCurrentInstance)(), { terminal, scheduler } = useTerminal(), layout = useLayout(), { visible, rootProps } = useVisibility({ provide: !0 }), graphicsActivity = (0, import_vue11.inject)(TerminalGraphicsActivityKey, null), frameRenderer = (0, import_vue11.shallowRef)(), playbackError = (0, import_vue11.shallowRef)(""), internalPaused = (0, import_vue11.shallowRef)(props.paused ?? !1), internalPlaybackRate = (0, import_vue11.shallowRef)(playbackRate(props.playbackRate)), discoveredDurationMs = (0, import_vue11.shallowRef)(), displayedTimestampMs = (0, import_vue11.shallowRef)(0), seekPreviewMs = (0, import_vue11.shallowRef)(), seeking = (0, import_vue11.shallowRef)(!1), terminalSizeVersion = (0, import_vue11.shallowRef)(0), graphicsOutputVersion = (0, import_vue11.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), placementKey = `TVideo:${instance?.uid ?? "unknown"}`, mailboxId = `${placementKey}:frame`, alive = !0, generation = 0, activeAbort = null, lastSourceBytes = null, lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint, lastTimestampMs = 0, droppedFrames = 0, pendingEndedGeneration = null, suppressNextVideoClick = !1, controlPointerCapture = null, unsubscribeTerminalResize = terminal.on("resize", () => {
+      terminalSizeVersion.value++;
+    }), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+    }), showControls = (0, import_vue11.computed)(
+      () => props.controls && Math.floor(props.w) >= 14 && Math.floor(props.h) >= 2
+    ), resolvedControlsLayout = (0, import_vue11.computed)(
+      () => props.controlsLayout === "cinema" && Math.floor(props.h) >= 3 ? "cinema" : "compact"
+    ), controlRows = (0, import_vue11.computed)(
+      () => showControls.value ? resolvedControlsLayout.value === "cinema" ? 2 : 1 : 0
+    ), videoHeight = (0, import_vue11.computed)(() => Math.max(1, Math.floor(props.h) - controlRows.value)), resolvedMaxFps = (0, import_vue11.computed)(() => positiveNumber(props.maxFps, DEFAULT_MAX_FPS, 60)), resolvedPixelSize = (0, import_vue11.computed)(() => {
+      let desiredWidth = Math.max(2, Math.floor(props.w) * 8), desiredHeight = Math.max(2, videoHeight.value * 16);
+      if (props.pixelWidth == null && props.pixelHeight == null) {
+        let scale = Math.min(
+          1,
+          DEFAULT_MAX_PIXEL_WIDTH / desiredWidth,
+          DEFAULT_MAX_PIXEL_HEIGHT / desiredHeight
+        );
+        return {
+          width: Math.max(2, Math.floor(desiredWidth * scale)),
+          height: Math.max(2, Math.floor(desiredHeight * scale))
+        };
+      }
+      if (props.pixelWidth != null && props.pixelHeight == null) {
+        let width = positiveInt2(props.pixelWidth, desiredWidth, MAX_PIXEL_DIMENSION), inferredHeight = width * desiredHeight / desiredWidth, scale = Math.min(1, MAX_PIXEL_DIMENSION / inferredHeight);
+        return {
+          width: Math.max(2, Math.floor(width * scale)),
+          height: Math.max(2, Math.floor(inferredHeight * scale))
+        };
+      }
+      if (props.pixelWidth == null && props.pixelHeight != null) {
+        let height = positiveInt2(props.pixelHeight, desiredHeight, MAX_PIXEL_DIMENSION), inferredWidth = height * desiredWidth / desiredHeight, scale = Math.min(1, MAX_PIXEL_DIMENSION / inferredWidth);
+        return {
+          width: Math.max(2, Math.floor(inferredWidth * scale)),
+          height: Math.max(2, Math.floor(height * scale))
+        };
+      }
+      return {
+        width: positiveInt2(props.pixelWidth, desiredWidth, MAX_PIXEL_DIMENSION),
+        height: positiveInt2(props.pixelHeight, desiredHeight, MAX_PIXEL_DIMENSION)
+      };
+    }), resolvedPixelWidth = (0, import_vue11.computed)(() => resolvedPixelSize.value.width), resolvedPixelHeight = (0, import_vue11.computed)(() => resolvedPixelSize.value.height), paintable = (0, import_vue11.computed)(() => {
+      if (terminalSizeVersion.value, !visible.value)
+        return !1;
+      let size = terminal.size(), terminalRect = {
+        x: 0,
+        y: 0,
+        w: Math.max(0, Math.floor(size.cols)),
+        h: Math.max(0, Math.floor(size.rows))
+      }, clip = layout.clipRect ? intersectRect(layout.clipRect, terminalRect) : terminalRect;
+      if (!clip)
+        return !1;
+      let rect = translateRect(
+        { x: props.x, y: props.y, w: props.w, h: videoHeight.value },
+        layout.originX,
+        layout.originY
+      ), visibleRect = intersectRect(rect, clip);
+      return !!(visibleRect && visibleRect.w > 0 && visibleRect.h > 0);
+    }), graphicsProtocol = (0, import_vue11.computed)(() => (graphicsOutputVersion.value, getTerminalGraphicsOutput(terminal)?.capabilities.preferredProtocol ?? null)), preferredFormat = (0, import_vue11.computed)(
+      () => graphicsProtocol.value === "kitty" || graphicsProtocol.value === "iterm2" ? "png" : "gray8"
+    ), resolvedDecodeFps = (0, import_vue11.computed)(
+      () => preferredFormat.value === "gray8" ? Math.min(MAX_GRAY8_FPS, resolvedMaxFps.value) : resolvedMaxFps.value
+    ), resolvedDecodeWidth = (0, import_vue11.computed)(
+      () => preferredFormat.value === "gray8" ? positiveInt2(Math.ceil(props.w / 2), 1, MAX_GRAY8_WIDTH) : resolvedPixelWidth.value
+    ), resolvedDecodeHeight = (0, import_vue11.computed)(
+      () => preferredFormat.value === "gray8" ? positiveInt2(videoHeight.value, 1, MAX_GRAY8_HEIGHT) : resolvedPixelHeight.value
+    ), resolvedDurationMs = (0, import_vue11.computed)(
+      () => optionalDuration(props.durationMs) ?? discoveredDurationMs.value
+    ), effectivePaused = (0, import_vue11.computed)(() => props.paused ?? internalPaused.value), effectivePlaybackRate = (0, import_vue11.computed)(
+      () => props.playbackRate == null ? internalPlaybackRate.value : playbackRate(props.playbackRate)
+    ), controlTimestampMs = (0, import_vue11.computed)(() => seekPreviewMs.value ?? displayedTimestampMs.value), timeHourDigits = (0, import_vue11.computed)(() => {
+      let duration = resolvedDurationMs.value;
+      return !duration || duration < 36e5 ? 0 : String(Math.floor(duration / 36e5)).length;
+    }), currentTimeText = (0, import_vue11.computed)(
+      () => formatPlaybackTime(controlTimestampMs.value, timeHourDigits.value)
+    ), durationTimeText = (0, import_vue11.computed)(
+      () => formatPlaybackTime(resolvedDurationMs.value, timeHourDigits.value)
+    ), controlLayout = (0, import_vue11.computed)(() => {
+      let width = Math.max(1, Math.floor(props.w)), progressY = videoHeight.value, current = currentTimeText.value, duration = durationTimeText.value, timeWidth = Math.max(textCellWidth(current), textCellWidth(duration)), ratesWidth = 8;
+      if (resolvedControlsLayout.value === "cinema") {
+        let ratesX2 = Math.max(3, width - ratesWidth), timeText = `${current} / ${duration}`;
+        return {
+          width,
+          kind: "cinema",
+          progressX: 0,
+          progressY,
+          progressWidth: width,
+          actionY: progressY + 1,
+          ratesX: ratesX2,
+          showAllRates: !0,
+          showTimes: 3 + textCellWidth(timeText) < ratesX2,
+          current,
+          duration,
+          timeText,
+          timeWidth,
+          currentX: 3,
+          totalX: 0
+        };
+      }
+      let ratesX = width - ratesWidth, progressX = timeWidth + 4, totalX = ratesX - timeWidth - 1, progressWidth = totalX - progressX - 1;
+      if (progressWidth >= 4)
+        return {
+          width,
+          kind: "compact",
+          progressX,
+          progressY,
+          progressWidth,
+          actionY: progressY,
+          ratesX,
+          showAllRates: !0,
+          showTimes: !0,
+          current,
+          duration,
+          timeText: "",
+          timeWidth,
+          currentX: 3,
+          totalX
+        };
+      let compactRatesX = Math.max(4, width - 2);
+      return {
+        width,
+        kind: "compact",
+        progressX: 3,
+        progressY,
+        progressWidth: Math.max(1, compactRatesX - 4),
+        actionY: progressY,
+        ratesX: compactRatesX,
+        showAllRates: !1,
+        showTimes: !1,
+        current,
+        duration,
+        timeText: "",
+        timeWidth,
+        currentX: 0,
+        totalX: 0
+      };
+    }), rateStyles = (0, import_vue11.computed)(
+      () => PLAYBACK_RATES.map(
+        (rate) => rate === effectivePlaybackRate.value ? { ...props.style, inverse: !0 } : props.style
+      )
+    ), remainingProgressStyle = (0, import_vue11.computed)(() => ({ ...props.style, dim: !0 })), progressThumbStyle = (0, import_vue11.computed)(() => ({ ...props.style, inverse: !0 })), progressSegments = (0, import_vue11.computed)(() => {
+      let { progressWidth } = controlLayout.value, duration = resolvedDurationMs.value;
+      if (!duration)
+        return { playedWidth: 0, thumbWidth: 0, remainingWidth: progressWidth };
+      let ratio = Math.max(0, Math.min(1, controlTimestampMs.value / duration)), marker = Math.round(ratio * Math.max(0, progressWidth - 1));
+      return {
+        playedWidth: marker,
+        thumbWidth: 1,
+        remainingWidth: progressWidth - marker - 1
+      };
+    }), controlFill = (0, import_vue11.computed)(() => " ".repeat(controlLayout.value.width)), progressGlyphs = (0, import_vue11.computed)(() => ({
+      played: "\u2501".repeat(progressSegments.value.playedWidth),
+      remaining: "\u2500".repeat(progressSegments.value.remainingWidth)
+    })), playbackEnabled = (0, import_vue11.computed)(
+      () => alive && !effectivePaused.value && !graphicsActivity?.scrolling.value && props.src.trim().length > 0 && paintable.value
+    ), shouldPlay = (0, import_vue11.computed)(() => playbackEnabled.value && !seeking.value), visibleFallback = (0, import_vue11.computed)(
+      () => playbackError.value ? `${props.fallback}: ${playbackError.value}` : props.fallback
+    );
+    function timelineTimestamp(timestampMs) {
+      let duration = resolvedDurationMs.value;
+      return duration ? props.loop ? Math.max(0, timestampMs) % duration : Math.max(0, Math.min(duration, timestampMs)) : Math.max(0, timestampMs);
+    }
+    function seekTimestamp(timestampMs) {
+      let duration = resolvedDurationMs.value;
+      if (!duration)
+        return Math.max(0, timestampMs);
+      let end = props.loop ? Math.max(0, duration - 1) : duration;
+      return Math.max(0, Math.min(end, timestampMs));
+    }
+    function updateTimestamp(timestampMs, force = !1) {
+      let next = timelineTimestamp(timestampMs);
+      if (lastTimestampMs = next, !showControls.value)
+        return;
+      let threshold = CONTROL_REFRESH_MS * effectivePlaybackRate.value;
+      (force || next < displayedTimestampMs.value || Math.abs(next - displayedTimestampMs.value) >= threshold) && (displayedTimestampMs.value = next);
+    }
+    function commitFrame(frame, dropped) {
+      if (!alive)
+        return;
+      droppedFrames += dropped, frameRenderer.value = (0, import_vue11.markRaw)(createFrameRenderer(frame, props.w)), updateTimestamp(frame.timestampMs);
+      let durationMs = resolvedDurationMs.value;
+      emit("frame", {
+        timestampMs: frame.timestampMs,
+        pixelWidth: frame.pixelWidth,
+        pixelHeight: frame.pixelHeight,
+        droppedFrames,
+        ...durationMs ? { durationMs } : {},
+        playbackRate: effectivePlaybackRate.value
+      });
+    }
+    let mailbox = createFrameMailbox({
+      scheduler,
+      id: mailboxId,
+      reason: "stream",
+      priority: "low",
+      apply(frame, _context, meta) {
+        commitFrame(frame, meta.dropped), pendingEndedGeneration === generation && (pendingEndedGeneration = null, emit("ended"));
+      }
+    });
+    function stopPlayback() {
+      generation++, pendingEndedGeneration = null;
+      let discardedPendingFrame = mailbox.hasPending();
+      mailbox.cancel(), discardedPendingFrame && (lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint = void 0), activeAbort?.abort(), activeAbort = null;
+    }
+    function resetQueuedFrameIdentity() {
+      lastSourceBytes = null, lastQueuedBytes = null, lastQueuedFormat = null, lastQueuedFingerprint = void 0;
+    }
+    function setPaused(paused) {
+      effectivePaused.value !== paused && (props.paused == null && (internalPaused.value = paused), emit("update:paused", paused));
+    }
+    function setPlaybackRate(rate) {
+      let next = playbackRate(rate);
+      effectivePlaybackRate.value !== next && (props.playbackRate == null && (internalPlaybackRate.value = next), emit("update:playbackRate", next));
+    }
+    function applySeek(timestampMs, restart) {
+      let parsed = Number(timestampMs);
+      if (!Number.isFinite(parsed))
+        return;
+      stopPlayback(), resetQueuedFrameIdentity();
+      let next = seekTimestamp(parsed);
+      updateTimestamp(next, !0), seekPreviewMs.value = void 0;
+      let durationMs = resolvedDurationMs.value;
+      emit("seek", {
+        timestampMs: next,
+        ...durationMs ? { durationMs } : {}
+      }), restart && startPlayback(effectivePaused.value);
+    }
+    function controlCell(event) {
+      return {
+        x: Math.floor(event.cellX - layout.originX - props.x),
+        y: Math.floor(event.cellY - layout.originY - props.y)
+      };
+    }
+    function previewSeekAt(cellX) {
+      let duration = resolvedDurationMs.value;
+      if (!duration)
+        return;
+      let { progressX, progressWidth } = controlLayout.value, offset = Math.max(0, Math.min(progressWidth - 1, cellX - progressX));
+      seekPreviewMs.value = progressWidth <= 1 ? 0 : offset / Math.max(1, progressWidth - 1) * duration;
+    }
+    function captureControlPointer(event) {
+      let native = event.nativeEvent, pointerId = native?.pointerId, target = native?.target;
+      pointerId == null || !target?.setPointerCapture || (target.setPointerCapture(pointerId), controlPointerCapture = { pointerId, target });
+    }
+    function releaseControlPointer() {
+      controlPointerCapture && (controlPointerCapture.target.releasePointerCapture?.(controlPointerCapture.pointerId), controlPointerCapture = null);
+    }
+    function rateAt(cellX) {
+      let { ratesX, showAllRates } = controlLayout.value, offset = cellX - ratesX;
+      if (!showAllRates) {
+        if (offset < 0 || offset >= 2)
+          return;
+        let index = PLAYBACK_RATES.indexOf(effectivePlaybackRate.value);
+        return PLAYBACK_RATES[(index + 1) % PLAYBACK_RATES.length];
+      }
+      if (!(offset < 0 || offset % 3 >= 2))
+        return PLAYBACK_RATES[Math.floor(offset / 3)];
+    }
+    function onInteractivePointerDown(event) {
+      if (event.button != null && event.button !== 0)
+        return;
+      let { x: cellX, y: cellY } = controlCell(event);
+      if (cellY < videoHeight.value) {
+        suppressNextVideoClick = !1;
+        return;
+      }
+      if (!showControls.value)
+        return;
+      let { actionY, progressY, progressX, progressWidth } = controlLayout.value, rate = rateAt(cellX);
+      if (cellY === actionY && cellX <= 1) {
+        event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, setPaused(!effectivePaused.value);
+        return;
+      }
+      if (cellY === actionY && rate) {
+        event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, setPlaybackRate(rate);
+        return;
+      }
+      cellY !== progressY || !resolvedDurationMs.value || cellX < progressX || cellX >= progressX + progressWidth || (event.preventDefault(), event.stopPropagation(), suppressNextVideoClick = !0, seeking.value = !0, stopPlayback(), previewSeekAt(cellX), captureControlPointer(event));
+    }
+    function onInteractivePointerMove(event) {
+      if (seeking.value) {
+        if (event.buttons === 0) {
+          onInteractivePointerUp(event);
+          return;
+        }
+        event.preventDefault(), event.stopPropagation(), previewSeekAt(controlCell(event).x);
+      }
+    }
+    function onInteractivePointerUp(event) {
+      if (!seeking.value)
+        return;
+      event.preventDefault(), event.stopPropagation(), previewSeekAt(controlCell(event).x);
+      let timestampMs = seekPreviewMs.value ?? lastTimestampMs;
+      applySeek(timestampMs, !1), seeking.value = !1, releaseControlPointer(), startPlayback(effectivePaused.value);
+    }
+    function onVideoClick(event) {
+      if (!(event.button != null && event.button !== 0)) {
+        if (suppressNextVideoClick) {
+          suppressNextVideoClick = !1, event.preventDefault(), event.stopPropagation();
+          return;
+        }
+        controlCell(event).y >= videoHeight.value || (event.preventDefault(), event.stopPropagation(), setPaused(!effectivePaused.value));
+      }
+    }
+    function finishControlSeek() {
+      if (!seeking.value)
+        return;
+      let timestampMs = seekPreviewMs.value ?? lastTimestampMs;
+      applySeek(timestampMs, !1), seeking.value = !1, releaseControlPointer(), startPlayback(effectivePaused.value);
+    }
+    function onControlKeydown(event) {
+      if (event.key === "Enter" || event.key === " " || event.key === "Spacebar") {
+        event.preventDefault(), event.stopPropagation(), setPaused(!effectivePaused.value);
+        return;
+      }
+      if (event.key === "ArrowUp" || event.key === "ArrowDown") {
+        event.preventDefault(), event.stopPropagation();
+        let index = PLAYBACK_RATES.indexOf(effectivePlaybackRate.value), offset = event.key === "ArrowUp" ? 1 : -1;
+        setPlaybackRate(PLAYBACK_RATES[Math.max(0, Math.min(2, index + offset))]);
+        return;
+      }
+      if (!event.repeat && (event.key === "Home" || event.key === "End") && resolvedDurationMs.value) {
+        event.preventDefault(), event.stopPropagation(), applySeek(event.key === "Home" ? 0 : resolvedDurationMs.value, !0);
+        return;
+      }
+      (event.key === "1" || event.key === "2" || event.key === "3") && (event.preventDefault(), event.stopPropagation(), setPlaybackRate(Number(event.key)));
+    }
+    function queueFrame(frame, expectedFormat) {
+      let normalized = normalizeFrame(frame);
+      if (normalized.format !== expectedFormat)
+        throw new Error(`TVideo frame source did not provide requested ${expectedFormat} frames`);
+      normalized.durationMs != null && normalized.durationMs !== discoveredDurationMs.value && (discoveredDurationMs.value = normalized.durationMs), normalized = { ...normalized, timestampMs: timelineTimestamp(normalized.timestampMs) };
+      let sourceBytes = frameBytes(normalized), reusesSourceBuffer = sourceBytes === lastSourceBytes;
+      lastSourceBytes = sourceBytes;
+      let stableFrame = reusesSourceBuffer ? normalized.format === "gray8" ? { ...normalized, pixels: new Uint8Array(normalized.pixels) } : { ...normalized, png: new Uint8Array(normalized.png) } : normalized, bytes = frameBytes(stableFrame), sameFingerprint = normalized.format === lastQueuedFormat && normalized.fingerprint != null && lastQueuedFingerprint != null && normalized.fingerprint === lastQueuedFingerprint, canCompareBytes = normalized.fingerprint == null && lastQueuedFingerprint == null && !reusesSourceBuffer;
+      if (sameFingerprint || canCompareBytes && normalized.format === lastQueuedFormat && lastQueuedBytes && sameBytes(lastQueuedBytes, sourceBytes)) {
+        lastQueuedBytes = bytes, lastQueuedFormat = normalized.format, lastQueuedFingerprint = normalized.fingerprint, updateTimestamp(normalized.timestampMs), mailbox.hasPending() && mailbox.replacePending(stableFrame);
+        return;
+      }
+      lastQueuedBytes = bytes, lastQueuedFormat = normalized.format, lastQueuedFingerprint = normalized.fingerprint, mailbox.queue(stableFrame) || (commitFrame(stableFrame, 0), scheduler.invalidate({ priority: "low", reason: "stream" }));
+    }
+    function startPlayback(oneFrame = !1) {
+      if (stopPlayback(), !shouldPlay.value && !(oneFrame && alive && props.src.trim().length > 0 && paintable.value && !graphicsActivity?.scrolling.value))
+        return;
+      let currentGeneration = generation, abort = new AbortController();
+      activeAbort = abort, playbackError.value = "";
+      let source = props.frameSource, format = preferredFormat.value, context = {
+        src: props.src,
+        signal: abort.signal,
+        maxFps: resolvedDecodeFps.value,
+        pixelWidth: resolvedDecodeWidth.value,
+        pixelHeight: resolvedDecodeHeight.value,
+        startAtMs: lastTimestampMs,
+        preferredFormat: format,
+        playbackRate: effectivePlaybackRate.value,
+        loop: props.loop
+      };
+      (async () => {
+        try {
+          let frames = await source(context);
+          for await (let frame of frames)
+            if (!alive || abort.signal.aborted || currentGeneration !== generation || (queueFrame(frame, format), oneFrame))
+              return;
+          if (!alive || abort.signal.aborted || currentGeneration !== generation)
+            return;
+          mailbox.hasPending() ? pendingEndedGeneration = currentGeneration : emit("ended");
+        } catch (error) {
+          if (!alive || abort.signal.aborted || currentGeneration !== generation)
+            return;
+          playbackError.value = errorMessage2(error), emit("error", error), scheduler.invalidate({ priority: "low", reason: "data" });
+        } finally {
+          activeAbort === abort && (activeAbort = null);
+        }
+      })();
+    }
+    return (0, import_vue11.watch)(
+      () => props.paused,
+      (paused) => {
+        paused != null && (internalPaused.value = paused);
+      }
+    ), (0, import_vue11.watch)(
+      () => props.playbackRate,
+      (rate) => {
+        rate != null && (internalPlaybackRate.value = playbackRate(rate));
+      }
+    ), (0, import_vue11.watch)(
+      [
+        () => props.src,
+        () => props.frameSource,
+        playbackEnabled,
+        resolvedDecodeFps,
+        resolvedDecodeWidth,
+        resolvedDecodeHeight,
+        preferredFormat,
+        effectivePlaybackRate,
+        () => props.loop
+      ],
+      (next, previous) => {
+        let sourceChanged = !previous || next[0] !== previous[0] || next[1] !== previous[1], formatChanged = !previous || next[6] !== previous[6];
+        (sourceChanged || formatChanged) && (resetQueuedFrameIdentity(), sourceChanged && (lastTimestampMs = 0, displayedTimestampMs.value = 0, discoveredDurationMs.value = void 0, seekPreviewMs.value = void 0, seeking.value = !1, suppressNextVideoClick = !1, releaseControlPointer(), droppedFrames = 0), playbackError.value = "", frameRenderer.value = void 0), startPlayback();
+      },
+      { immediate: !0, flush: "post" }
+    ), (0, import_vue11.onBeforeUnmount)(() => {
+      alive = !1, stopPlayback(), releaseControlPointer(), mailbox.dispose(), unsubscribeTerminalResize(), unsubscribeGraphicsOutput();
+    }), () => {
+      let children = [
+        (0, import_vue11.h)(TAgentTerminalGraphic, {
+          x: props.x,
+          y: props.y,
+          w: props.w,
+          h: videoHeight.value,
+          zIndex: props.zIndex,
+          content: props.src.trim() ? props.src : "video",
+          fallback: visibleFallback.value,
+          style: props.style,
+          clear: props.clear,
+          final: !1,
+          streaming: !0,
+          renderer: frameRenderer.value,
+          placementKey,
+          preserveRawWhileRendering: !0,
+          ignoreSamePlaneRawCoverage: !0,
+          suspended: !paintable.value
+        })
+      ];
+      return props.controls && children.push(
+        (0, import_vue11.h)(
+          TView,
+          {
+            x: props.x,
+            y: props.y,
+            w: Math.max(0, Math.floor(props.w)),
+            h: Math.max(0, Math.floor(props.h)),
+            zIndex: props.zIndex,
+            focusable: !0,
+            selectable: !1,
+            onClick: onVideoClick,
+            onPointerdown: onInteractivePointerDown,
+            onPointermove: onInteractivePointerMove,
+            onPointerup: onInteractivePointerUp,
+            onKeydown: onControlKeydown,
+            onBlur: finishControlSeek
+          },
+          () => {
+            if (!showControls.value)
+              return [];
+            let layout2 = controlLayout.value, segments = progressSegments.value, controls = Array.from(
+              { length: controlRows.value },
+              (_, index) => (0, import_vue11.h)(TText, {
+                x: 0,
+                y: videoHeight.value + index,
+                w: layout2.width,
+                value: controlFill.value,
+                style: props.style
+              })
+            );
+            return controls.push(
+              (0, import_vue11.h)(TText, {
+                x: 0,
+                y: layout2.actionY,
+                w: 2,
+                value: effectivePaused.value ? "> " : "||",
+                style: props.style
+              })
+            ), layout2.showTimes && (layout2.kind === "cinema" ? controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.currentX,
+                y: layout2.actionY,
+                w: textCellWidth(layout2.timeText),
+                value: layout2.timeText,
+                style: props.style
+              })
+            ) : controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.currentX,
+                y: layout2.actionY,
+                w: layout2.timeWidth,
+                value: layout2.current,
+                style: props.style
+              }),
+              (0, import_vue11.h)(TText, {
+                x: layout2.totalX,
+                y: layout2.actionY,
+                w: layout2.timeWidth,
+                value: layout2.duration,
+                style: props.style
+              })
+            )), segments.playedWidth > 0 && controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.progressX,
+                y: layout2.progressY,
+                w: segments.playedWidth,
+                value: progressGlyphs.value.played,
+                style: props.style
+              })
+            ), segments.thumbWidth > 0 && controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.progressX + segments.playedWidth,
+                y: layout2.progressY,
+                w: 1,
+                value: "\u254B",
+                style: progressThumbStyle.value
+              })
+            ), segments.remainingWidth > 0 && controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.progressX + segments.playedWidth + segments.thumbWidth,
+                y: layout2.progressY,
+                w: segments.remainingWidth,
+                value: progressGlyphs.value.remaining,
+                style: remainingProgressStyle.value
+              })
+            ), layout2.showAllRates ? controls.push(
+              ...PLAYBACK_RATES.map(
+                (rate, index) => (0, import_vue11.h)(TText, {
+                  x: layout2.ratesX + index * 3,
+                  y: layout2.actionY,
+                  w: 2,
+                  value: `${rate}x`,
+                  style: rateStyles.value[index]
+                })
+              )
+            ) : controls.push(
+              (0, import_vue11.h)(TText, {
+                x: layout2.ratesX,
+                y: layout2.actionY,
+                w: 2,
+                value: `${effectivePlaybackRate.value}x`,
+                style: rateStyles.value[PLAYBACK_RATES.indexOf(effectivePlaybackRate.value)]
+              })
+            ), controls;
+          }
+        )
+      ), (0, import_vue11.h)("span", rootProps, children);
+    };
+  }
+});
+
+// src/vue/components/TBrowser.ts
+var EMPTY_RECT2 = Object.freeze({ x: 0, y: 0, w: 0, h: 0 }), tBrowserProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, required: !0 },
+  zIndex: { type: Number, default: 0 },
+  url: { type: String, required: !0 },
+  sessionFactory: {
+    type: Function,
+    required: !0
+  },
+  autoFocus: { type: Boolean, default: !1 },
+  maxFps: { type: Number, default: 60 },
+  pixelWidth: { type: Number, default: void 0 },
+  pixelHeight: { type: Number, default: void 0 },
+  fallback: { type: String, default: "[browser requires terminal graphics]" },
+  style: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 }
+};
+function modifiers(event) {
+  return {
+    ctrl: !!event.ctrlKey,
+    shift: !!event.shiftKey,
+    alt: !!event.altKey,
+    meta: !!event.metaKey
+  };
+}
+function eventText(event) {
+  return String(event.text ?? event.data ?? "");
+}
+function isBrowserShortcut(event) {
+  let key = event.key.toLowerCase();
+  return (event.ctrlKey || event.metaKey) && ["l", "r", "t", "w"].includes(key) || !!event.altKey && (event.key === "ArrowLeft" || event.key === "ArrowRight") || !!event.ctrlKey && (key === "c" || key === "q");
+}
+var TBrowser = (0, import_vue12.defineComponent)({
+  name: "TBrowser",
+  props: tBrowserProps,
+  emits: {
+    ready: (_session) => !0,
+    frame: (_event) => !0,
+    navigate: (_url) => !0,
+    titleChange: (_title) => !0,
+    requestAddress: () => !0,
+    close: () => !0,
+    error: (_error) => !0
+  },
+  setup(props, { emit }) {
+    let layout = useLayout(), { events } = useTerminal(), { visible } = useVisibility(), activeSession = null, activePixelWidth = Math.max(1, Math.floor(props.pixelWidth ?? props.w * 8)), activePixelHeight = Math.max(1, Math.floor(props.pixelHeight ?? props.h * 16)), alive = !0, skipNextInput = !1, requestedUrl = props.url, sessionQueue = Promise.resolve(), continuousInputScheduled = !1, continuousInputGeneration = 0, pendingContinuousInput = [], initialUrl = props.url, initialPixelWidth = Math.max(2, Math.floor(props.pixelWidth ?? props.w * 8)), initialPixelHeight = Math.max(2, Math.floor(props.pixelHeight ?? props.h * 16)), rawRect = (0, import_vue12.computed)(
+      () => translateRect(
+        {
+          x: Math.floor(props.x),
+          y: Math.floor(props.y),
+          w: Math.max(0, Math.floor(props.w)),
+          h: Math.max(0, Math.floor(props.h))
+        },
+        layout.originX,
+        layout.originY
+      )
+    ), rect = (0, import_vue12.computed)(() => {
+      let value = rawRect.value;
+      return layout.clipRect ? intersectRect(value, layout.clipRect) ?? EMPTY_RECT2 : value;
+    }), frameSource = async function* (context) {
+      activePixelWidth = context.pixelWidth, activePixelHeight = context.pixelHeight;
+      let session = await props.sessionFactory({
+        url: context.src,
+        signal: context.signal,
+        maxFps: context.maxFps,
+        pixelWidth: context.pixelWidth,
+        pixelHeight: context.pixelHeight,
+        preferredFormat: context.preferredFormat,
+        onNavigate: (url) => emit("navigate", url),
+        onTitleChange: (title) => emit("titleChange", title)
+      });
+      if (context.signal.aborted || !alive) {
+        await session.close();
+        return;
+      }
+      clearContinuousInput(), sessionQueue = Promise.resolve(), activeSession = session;
+      try {
+        if (requestedUrl !== context.src && session.navigate && await session.navigate(requestedUrl), context.signal.aborted || !alive)
+          return;
+        emit("ready", session);
+        for await (let frame of session.frames) {
+          if (context.signal.aborted || !alive)
+            return;
+          yield frame;
+        }
+      } finally {
+        activeSession === session && (activeSession = null, clearContinuousInput()), await session.close();
+      }
+    };
+    function reportError(error) {
+      alive && emit("error", error);
+    }
+    function clearContinuousInput() {
+      pendingContinuousInput.length = 0, continuousInputGeneration++, continuousInputScheduled = !1;
+    }
+    function scheduleContinuousInput(session) {
+      if (continuousInputScheduled || pendingContinuousInput.length === 0)
+        return;
+      let event = pendingContinuousInput.shift(), generation = continuousInputGeneration;
+      continuousInputScheduled = !0;
+      let pending = sessionQueue.then(() => {
+        if (!(generation !== continuousInputGeneration || activeSession !== session))
+          return session.dispatch(event);
+      });
+      sessionQueue = pending.catch((error) => {
+        activeSession === session && reportError(error);
+      });
+      let finish = () => {
+        generation === continuousInputGeneration && (continuousInputScheduled = !1, activeSession === session && scheduleContinuousInput(session));
+      };
+      pending.then(finish, finish);
+    }
+    function queueContinuousInput(session, event) {
+      let index = pendingContinuousInput.findIndex((pending) => pending.type === event.type);
+      if (index < 0)
+        pendingContinuousInput.push(event);
+      else if (event.type === "wheel") {
+        let previous = pendingContinuousInput[index], deltaY = (previous?.type === "wheel" ? previous.deltaY : 0) + event.deltaY;
+        deltaY === 0 ? pendingContinuousInput.splice(index, 1) : pendingContinuousInput[index] = { ...event, deltaY };
+      } else
+        pendingContinuousInput[index] = event;
+      scheduleContinuousInput(session);
+    }
+    function dispatch(event) {
+      let session = activeSession;
+      if (!session)
+        return;
+      if (event.type === "wheel" || event.type === "pointermove") {
+        queueContinuousInput(session, event);
+        return;
+      }
+      clearContinuousInput(), sessionQueue = sessionQueue.then(() => {
+        if (activeSession === session)
+          return session.dispatch(event);
+      }).catch((error) => {
+        activeSession === session && reportError(error);
+      });
+    }
+    function invoke(action) {
+      let session = activeSession;
+      if (!session)
+        return;
+      clearContinuousInput(), sessionQueue = sessionQueue.then(() => {
+        if (activeSession === session)
+          return action(session);
+      }).catch((error) => {
+        activeSession === session && reportError(error);
+      });
+    }
+    function closeCurrentPage() {
+      let session = activeSession;
+      if (!session?.closePage) {
+        emit("close");
+        return;
+      }
+      clearContinuousInput(), sessionQueue = sessionQueue.then(() => {
+        if (activeSession === session)
+          return session.closePage?.();
+      }).then((closed) => {
+        closed === !1 && activeSession === session && emit("close");
+      }).catch((error) => {
+        activeSession === session && reportError(error);
+      });
+    }
+    function point(event) {
+      let bounds = rawRect.value, cellX = Math.max(0, Math.min(bounds.w - 1, Math.floor(event.cellX - bounds.x))), cellY = Math.max(0, Math.min(bounds.h - 1, Math.floor(event.cellY - bounds.y)));
+      return {
+        x: Math.max(
+          0,
+          Math.min(activePixelWidth - 1, (cellX + 0.5) / bounds.w * activePixelWidth)
+        ),
+        y: Math.max(
+          0,
+          Math.min(activePixelHeight - 1, (cellY + 0.5) / bounds.h * activePixelHeight)
+        )
+      };
+    }
+    function capture(event) {
+      event.preventDefault(), event.stopPropagation();
+    }
+    function pointer(type, event) {
+      type === "pointerdown" && id.value && events.value?.focus(id.value), capture(event), dispatch({
+        type,
+        ...point(event),
+        button: event.button,
+        buttons: event.buttons,
+        modifiers: modifiers(event)
+      });
+    }
+    let { id } = useTerminalNode(() => ({
+      rect: rect.value,
+      zIndex: props.zIndex,
+      visible: visible.value,
+      focusable: !0,
+      selectable: !1,
+      handlers: {
+        pointerdown: (event) => pointer("pointerdown", event),
+        pointerup: (event) => pointer("pointerup", event),
+        pointermove: (event) => pointer("pointermove", event),
+        wheel: (event) => {
+          capture(event), dispatch({
+            type: "wheel",
+            ...point(event),
+            deltaY: Number(event.deltaY ?? 0),
+            modifiers: modifiers(event)
+          });
+        },
+        keydown: (event) => {
+          if (capture(event), (event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "l") {
+            emit("requestAddress");
+            return;
+          }
+          if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "r") {
+            invoke((session) => session.reload?.());
+            return;
+          }
+          if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "t") {
+            invoke((session) => session.newPage?.()), emit("requestAddress");
+            return;
+          }
+          if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "w") {
+            closeCurrentPage();
+            return;
+          }
+          if (event.altKey && event.key === "ArrowLeft") {
+            invoke((session) => session.back?.());
+            return;
+          }
+          if (event.altKey && event.key === "ArrowRight") {
+            invoke((session) => session.forward?.());
+            return;
+          }
+          if (event.ctrlKey && ["c", "q"].includes(event.key.toLowerCase())) {
+            emit("close");
+            return;
+          }
+          dispatch({
+            type: "keydown",
+            key: event.key,
+            code: event.code,
+            repeat: !!event.repeat,
+            modifiers: modifiers(event)
+          });
+        },
+        keyup: (event) => {
+          capture(event), !isBrowserShortcut(event) && dispatch({
+            type: "keyup",
+            key: event.key,
+            code: event.code,
+            repeat: !!event.repeat,
+            modifiers: modifiers(event)
+          });
+        },
+        paste: (event) => {
+          capture(event);
+          let text = eventText(event);
+          text && dispatch({ type: "paste", text });
+        },
+        compositionend: (event) => {
+          capture(event);
+          let text = eventText(event);
+          text && dispatch({ type: "text", text }), skipNextInput = !0, queueMicrotask(() => {
+            skipNextInput = !1;
+          });
+        },
+        input: (event) => {
+          if (capture(event), skipNextInput)
+            return;
+          let text = eventText(event);
+          text && dispatch({ type: "text", text });
+        }
+      }
+    }));
+    return (0, import_vue12.watchEffect)(() => {
+      !props.autoFocus || !visible.value || !id.value || events.value?.getFocused() !== id.value && events.value?.focus(id.value);
+    }), (0, import_vue12.watch)(
+      () => props.url,
+      (url) => {
+        requestedUrl = url, activeSession?.navigate && invoke((session) => session.navigate?.(url));
+      }
+    ), (0, import_vue12.onBeforeUnmount)(() => {
+      alive = !1, activeSession = null, clearContinuousInput();
+    }), () => (0, import_vue12.h)(TVideo, {
+      x: props.x,
+      y: props.y,
+      w: props.w,
+      h: props.h,
+      zIndex: props.zIndex,
+      src: initialUrl,
+      frameSource,
+      maxFps: props.maxFps,
+      pixelWidth: props.pixelWidth ?? initialPixelWidth,
+      pixelHeight: props.pixelHeight ?? initialPixelHeight,
+      fallback: props.fallback,
+      style: props.style,
+      clear: props.clear,
+      onFrame: (event) => emit("frame", event),
+      onError: (error) => emit("error", error)
+    });
+  }
+});