@opentui/core 0.1.88 → 0.1.89

package/{index-nkrr8a4c.js → index-e89anq5x.js}

@@ -5093,6 +5093,12 @@ var DebugOverlayCorner;
   DebugOverlayCorner2[DebugOverlayCorner2["bottomLeft"] = 2] = "bottomLeft";
   DebugOverlayCorner2[DebugOverlayCorner2["bottomRight"] = 3] = "bottomRight";
 })(DebugOverlayCorner ||= {});
+var TargetChannel;
+((TargetChannel2) => {
+  TargetChannel2[TargetChannel2["FG"] = 1] = "FG";
+  TargetChannel2[TargetChannel2["BG"] = 2] = "BG";
+  TargetChannel2[TargetChannel2["Both"] = 3] = "Both";
+})(TargetChannel ||= {});
 
 // src/utils.ts
 function createTextAttributes({
@@ -5314,7 +5320,10 @@ function hastToStyledText(hast, syntaxStyle) {
 // src/lib/clock.ts
 class SystemClock {
   now() {
-    return Date.now();
+    if (!globalThis.performance || typeof globalThis.performance.now !== "function") {
+      throw new Error("SystemClock requires globalThis.performance.now()");
+    }
+    return globalThis.performance.now();
   }
   setTimeout(fn, delayMs) {
     return globalThis.setTimeout(fn, delayMs);
@@ -6411,13 +6420,7 @@ class MouseParser {
     };
     let type;
     let scrollInfo;
-    if (isScroll && pressRelease === "M") {
-      type = "scroll";
-      scrollInfo = {
-        direction: scrollDirection,
-        delta: 1
-      };
-    } else if (isMotion) {
+    if (isMotion) {
       const isDragging = this.mouseButtonsPressed.size > 0;
       if (button === 3) {
         type = "move";
@@ -6426,6 +6429,12 @@ class MouseParser {
       } else {
         type = "move";
       }
+    } else if (isScroll && pressRelease === "M") {
+      type = "scroll";
+      scrollInfo = {
+        direction: scrollDirection,
+        delta: 1
+      };
     } else {
       type = pressRelease === "M" ? "down" : "up";
       if (type === "down" && button !== 3) {
@@ -6456,16 +6465,16 @@ class MouseParser {
     let type;
     let actualButton;
     let scrollInfo;
-    if (isScroll) {
+    if (isMotion) {
+      type = "move";
+      actualButton = button === 3 ? -1 : button;
+    } else if (isScroll) {
       type = "scroll";
       actualButton = 0;
       scrollInfo = {
         direction: scrollDirection,
         delta: 1
       };
-    } else if (isMotion) {
-      type = "move";
-      actualButton = button === 3 ? -1 : button;
     } else {
       type = button === 3 ? "up" : "down";
       actualButton = button === 3 ? 0 : button;
@@ -6843,6 +6852,12 @@ var BRACKETED_PASTE_START = Buffer3.from("\x1B[200~");
 var BRACKETED_PASTE_END = Buffer3.from("\x1B[201~");
 var EMPTY_BYTES = new Uint8Array(0);
 var KEY_DECODER = new TextDecoder;
+var DEFAULT_PROTOCOL_CONTEXT = {
+  kittyKeyboardEnabled: false,
+  privateCapabilityRepliesActive: false,
+  pixelResolutionQueryActive: false,
+  explicitWidthCprActive: false
+};
 var RXVT_DOLLAR_CSI_RE = /^\x1b\[\d+\$$/;
 var SYSTEM_CLOCK = new SystemClock;
 
@@ -6982,6 +6997,66 @@ function isMouseSgrSequence(sequence) {
   }
   return part === 2 && hasDigit;
 }
+function isAsciiDigit(byte) {
+  return byte >= 48 && byte <= 57;
+}
+function parsePositiveDecimalPrefix(sequence, start, endExclusive) {
+  if (start >= endExclusive)
+    return null;
+  let value = 0;
+  let sawDigit = false;
+  for (let index = start;index < endExclusive; index += 1) {
+    const byte = sequence[index];
+    if (!isAsciiDigit(byte))
+      return null;
+    sawDigit = true;
+    value = value * 10 + (byte - 48);
+  }
+  return sawDigit ? value : null;
+}
+function canStillBeKittyU(state) {
+  return state.semicolons >= 1;
+}
+function canStillBeKittySpecial(state) {
+  return state.semicolons === 1 && state.segments > 1;
+}
+function canStillBeExplicitWidthCpr(state) {
+  return state.firstParamValue === 1 && state.semicolons === 1;
+}
+function canStillBePixelResolution(state) {
+  return state.firstParamValue === 4 && state.semicolons === 2;
+}
+function canDeferParametricCsi(state, context) {
+  return context.kittyKeyboardEnabled && (canStillBeKittyU(state) || canStillBeKittySpecial(state)) || context.explicitWidthCprActive && canStillBeExplicitWidthCpr(state) || context.pixelResolutionQueryActive && canStillBePixelResolution(state);
+}
+function canCompleteDeferredParametricCsi(state, byte, context) {
+  if (context.kittyKeyboardEnabled) {
+    if (state.hasDigit && byte === 117)
+      return true;
+    if (state.hasDigit && state.semicolons === 1 && state.segments > 1 && (byte === 126 || byte >= 65 && byte <= 90)) {
+      return true;
+    }
+  }
+  if (context.explicitWidthCprActive && state.hasDigit && state.firstParamValue === 1 && state.semicolons === 1 && byte === 82) {
+    return true;
+  }
+  if (context.pixelResolutionQueryActive && state.hasDigit && state.firstParamValue === 4 && state.semicolons === 2 && byte === 116) {
+    return true;
+  }
+  return false;
+}
+function canDeferPrivateReplyCsi(context) {
+  return context.privateCapabilityRepliesActive;
+}
+function canCompleteDeferredPrivateReplyCsi(state, byte, context) {
+  if (!context.privateCapabilityRepliesActive)
+    return false;
+  if (state.sawDollar)
+    return state.hasDigit && byte === 121;
+  if (byte === 99)
+    return state.hasDigit || state.semicolons > 0;
+  return state.hasDigit && byte === 117;
+}
 function concatBytes(left, right) {
   if (left.length === 0) {
     return right;
@@ -7052,6 +7127,7 @@ class StdinParser {
   useKittyKeyboard;
   mouseParser = new MouseParser;
   clock;
+  protocolContext;
   timeoutId = null;
   destroyed = false;
   pendingSinceMs = null;
@@ -7068,10 +7144,23 @@ class StdinParser {
     this.onTimeoutFlush = options.onTimeoutFlush ?? null;
     this.useKittyKeyboard = options.useKittyKeyboard ?? true;
     this.clock = options.clock ?? SYSTEM_CLOCK;
+    this.protocolContext = {
+      ...DEFAULT_PROTOCOL_CONTEXT,
+      kittyKeyboardEnabled: options.protocolContext?.kittyKeyboardEnabled ?? false,
+      privateCapabilityRepliesActive: options.protocolContext?.privateCapabilityRepliesActive ?? false,
+      pixelResolutionQueryActive: options.protocolContext?.pixelResolutionQueryActive ?? false,
+      explicitWidthCprActive: options.protocolContext?.explicitWidthCprActive ?? false
+    };
   }
   get bufferCapacity() {
     return this.pending.capacity;
   }
+  updateProtocolContext(patch) {
+    this.ensureAlive();
+    this.protocolContext = { ...this.protocolContext, ...patch };
+    this.reconcileDeferredStateWithProtocolContext();
+    this.reconcileTimeoutState();
+  }
   push(data) {
     this.ensureAlive();
     if (data.length === 0) {
@@ -7376,10 +7465,34 @@ class StdinParser {
               return;
             }
           }
+          if (byte === 60 && this.cursor === this.unitStart + 2) {
+            this.cursor += 1;
+            this.state = { tag: "csi_sgr_mouse", part: 0, hasDigit: false };
+            continue;
+          }
           if (byte === 91 && this.cursor === this.unitStart + 2) {
             this.cursor += 1;
             continue;
           }
+          if (byte === 63 && this.cursor === this.unitStart + 2) {
+            this.cursor += 1;
+            this.state = { tag: "csi_private_reply", semicolons: 0, hasDigit: false, sawDollar: false };
+            continue;
+          }
+          if (byte === 59) {
+            const firstParamValue = parsePositiveDecimalPrefix(bytes, this.unitStart + 2, this.cursor);
+            if (firstParamValue !== null) {
+              this.cursor += 1;
+              this.state = {
+                tag: "csi_parametric",
+                semicolons: 1,
+                segments: 1,
+                hasDigit: false,
+                firstParamValue
+              };
+              continue;
+            }
+          }
           if (byte >= 64 && byte <= 126) {
             const end = this.cursor + 1;
             const rawBytes = bytes.subarray(this.unitStart, end);
@@ -7403,6 +7516,281 @@ class StdinParser {
           this.cursor += 1;
           continue;
         }
+        case "csi_sgr_mouse": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            this.state = { tag: "csi_sgr_mouse_deferred", part: this.state.part, hasDigit: this.state.hasDigit };
+            this.pendingSinceMs = null;
+            this.forceFlush = false;
+            return;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte)) {
+            this.cursor += 1;
+            this.state = { tag: "csi_sgr_mouse", part: this.state.part, hasDigit: true };
+            continue;
+          }
+          if (byte === 59 && this.state.hasDigit && this.state.part < 2) {
+            this.cursor += 1;
+            this.state = { tag: "csi_sgr_mouse", part: this.state.part + 1, hasDigit: false };
+            continue;
+          }
+          if (byte >= 64 && byte <= 126) {
+            const end = this.cursor + 1;
+            const rawBytes = bytes.subarray(this.unitStart, end);
+            if (isMouseSgrSequence(rawBytes)) {
+              this.emitMouse(rawBytes, "sgr");
+            } else {
+              this.emitKeyOrResponse("csi", decodeUtf8(rawBytes));
+            }
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          this.state = { tag: "csi" };
+          continue;
+        }
+        case "csi_sgr_mouse_deferred": {
+          if (this.cursor >= bytes.length) {
+            this.pendingSinceMs = null;
+            this.forceFlush = false;
+            return;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte) || byte === 59 || byte === 77 || byte === 109) {
+            this.state = { tag: "csi_sgr_mouse", part: this.state.part, hasDigit: this.state.hasDigit };
+            continue;
+          }
+          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
+        case "csi_parametric": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            if (canDeferParametricCsi(this.state, this.protocolContext)) {
+              this.state = {
+                tag: "csi_parametric_deferred",
+                semicolons: this.state.semicolons,
+                segments: this.state.segments,
+                hasDigit: this.state.hasDigit,
+                firstParamValue: this.state.firstParamValue
+              };
+              this.pendingSinceMs = null;
+              this.forceFlush = false;
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte)) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_parametric",
+              semicolons: this.state.semicolons,
+              segments: this.state.segments,
+              hasDigit: true,
+              firstParamValue: this.state.firstParamValue
+            };
+            continue;
+          }
+          if (byte === 58 && this.state.hasDigit && this.state.segments < 3) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_parametric",
+              semicolons: this.state.semicolons,
+              segments: this.state.segments + 1,
+              hasDigit: false,
+              firstParamValue: this.state.firstParamValue
+            };
+            continue;
+          }
+          if (byte === 59 && this.state.semicolons < 2) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_parametric",
+              semicolons: this.state.semicolons + 1,
+              segments: 1,
+              hasDigit: false,
+              firstParamValue: this.state.firstParamValue
+            };
+            continue;
+          }
+          if (byte >= 64 && byte <= 126) {
+            const end = this.cursor + 1;
+            this.emitKeyOrResponse("csi", decodeUtf8(bytes.subarray(this.unitStart, end)));
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          this.state = { tag: "csi" };
+          continue;
+        }
+        case "csi_parametric_deferred": {
+          if (this.cursor >= bytes.length) {
+            this.pendingSinceMs = null;
+            this.forceFlush = false;
+            return;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte) || byte === 58 || byte === 59) {
+            this.state = {
+              tag: "csi_parametric",
+              semicolons: this.state.semicolons,
+              segments: this.state.segments,
+              hasDigit: this.state.hasDigit,
+              firstParamValue: this.state.firstParamValue
+            };
+            continue;
+          }
+          if (canCompleteDeferredParametricCsi(this.state, byte, this.protocolContext)) {
+            this.state = {
+              tag: "csi_parametric",
+              semicolons: this.state.semicolons,
+              segments: this.state.segments,
+              hasDigit: this.state.hasDigit,
+              firstParamValue: this.state.firstParamValue
+            };
+            continue;
+          }
+          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
+        case "csi_private_reply": {
+          if (this.cursor >= bytes.length) {
+            if (!this.forceFlush) {
+              this.markPending();
+              return;
+            }
+            if (canDeferPrivateReplyCsi(this.protocolContext)) {
+              this.state = {
+                tag: "csi_private_reply_deferred",
+                semicolons: this.state.semicolons,
+                hasDigit: this.state.hasDigit,
+                sawDollar: this.state.sawDollar
+              };
+              this.pendingSinceMs = null;
+              this.forceFlush = false;
+              return;
+            }
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte)) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_private_reply",
+              semicolons: this.state.semicolons,
+              hasDigit: true,
+              sawDollar: this.state.sawDollar
+            };
+            continue;
+          }
+          if (byte === 59) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_private_reply",
+              semicolons: this.state.semicolons + 1,
+              hasDigit: false,
+              sawDollar: false
+            };
+            continue;
+          }
+          if (byte === 36 && this.state.hasDigit && !this.state.sawDollar) {
+            this.cursor += 1;
+            this.state = {
+              tag: "csi_private_reply",
+              semicolons: this.state.semicolons,
+              hasDigit: true,
+              sawDollar: true
+            };
+            continue;
+          }
+          if (byte >= 64 && byte <= 126) {
+            const end = this.cursor + 1;
+            this.emitKeyOrResponse("csi", decodeUtf8(bytes.subarray(this.unitStart, end)));
+            this.state = { tag: "ground" };
+            this.consumePrefix(end);
+            continue;
+          }
+          this.state = { tag: "csi" };
+          continue;
+        }
+        case "csi_private_reply_deferred": {
+          if (this.cursor >= bytes.length) {
+            this.pendingSinceMs = null;
+            this.forceFlush = false;
+            return;
+          }
+          if (byte === ESC) {
+            this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+            this.state = { tag: "ground" };
+            this.consumePrefix(this.cursor);
+            continue;
+          }
+          if (isAsciiDigit(byte) || byte === 59 || byte === 36) {
+            this.state = {
+              tag: "csi_private_reply",
+              semicolons: this.state.semicolons,
+              hasDigit: this.state.hasDigit,
+              sawDollar: this.state.sawDollar
+            };
+            continue;
+          }
+          if (canCompleteDeferredPrivateReplyCsi(this.state, byte, this.protocolContext)) {
+            this.state = {
+              tag: "csi_private_reply",
+              semicolons: this.state.semicolons,
+              hasDigit: this.state.hasDigit,
+              sawDollar: this.state.sawDollar
+            };
+            continue;
+          }
+          this.emitOpaqueResponse("unknown", bytes.subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+          continue;
+        }
         case "osc": {
           if (this.cursor >= bytes.length) {
             if (!this.forceFlush) {
@@ -7657,6 +8045,24 @@ class StdinParser {
     this.paste.parts.push(Uint8Array.from(bytes));
     this.paste.totalLength += bytes.length;
   }
+  reconcileDeferredStateWithProtocolContext() {
+    switch (this.state.tag) {
+      case "csi_parametric_deferred":
+        if (!canDeferParametricCsi(this.state, this.protocolContext)) {
+          this.emitOpaqueResponse("unknown", this.pending.view().subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+        }
+        return;
+      case "csi_private_reply_deferred":
+        if (!canDeferPrivateReplyCsi(this.protocolContext)) {
+          this.emitOpaqueResponse("unknown", this.pending.view().subarray(this.unitStart, this.cursor));
+          this.state = { tag: "ground" };
+          this.consumePrefix(this.cursor);
+        }
+        return;
+    }
+  }
   reconcileTimeoutState() {
     if (!this.armTimeouts) {
       return;
@@ -8040,6 +8446,7 @@ function getParsers() {
     _cachedParsers = [
       {
         filetype: "javascript",
+        aliases: ["javascriptreact"],
         queries: {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), javascript_highlights)]
         },
@@ -8047,6 +8454,7 @@ function getParsers() {
       },
       {
         filetype: "typescript",
+        aliases: ["typescriptreact"],
         queries: {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)]
         },
@@ -8067,8 +8475,12 @@ function getParsers() {
           infoStringMap: {
             javascript: "javascript",
             js: "javascript",
+            jsx: "javascriptreact",
+            javascriptreact: "javascriptreact",
             typescript: "typescript",
             ts: "typescript",
+            tsx: "typescriptreact",
+            typescriptreact: "typescriptreact",
             markdown: "markdown",
             md: "markdown"
           }
@@ -8119,12 +8531,10 @@ registerEnvVar({
 var DEFAULT_PARSERS = getParsers();
 function addDefaultParsers(parsers) {
   for (const parser of parsers) {
-    const existingIndex = DEFAULT_PARSERS.findIndex((p) => p.filetype === parser.filetype);
-    if (existingIndex >= 0) {
-      DEFAULT_PARSERS[existingIndex] = parser;
-    } else {
-      DEFAULT_PARSERS.push(parser);
-    }
+    DEFAULT_PARSERS = [
+      ...DEFAULT_PARSERS.filter((existingParser) => existingParser.filetype !== parser.filetype),
+      parser
+    ];
   }
 }
 var isUrl = (path) => path.startsWith("http://") || path.startsWith("https://");
@@ -8242,6 +8652,7 @@ class TreeSitterClient extends EventEmitter2 {
   addFiletypeParser(filetypeParser) {
     const resolvedParser = {
       ...filetypeParser,
+      aliases: filetypeParser.aliases ? [...new Set(filetypeParser.aliases.filter((alias) => alias !== filetypeParser.filetype))] : undefined,
       wasm: this.resolvePath(filetypeParser.wasm),
       queries: {
         highlights: filetypeParser.queries.highlights.map((path) => this.resolvePath(path)),
@@ -8715,74 +9126,189 @@ function getDataPaths() {
 }
 
 // src/lib/tree-sitter/resolve-ft.ts
+import path2 from "path";
+var extensionToFiletype = new Map([
+  ["astro", "astro"],
+  ["bash", "bash"],
+  ["c", "c"],
+  ["cc", "cpp"],
+  ["cjs", "javascript"],
+  ["clj", "clojure"],
+  ["cljs", "clojure"],
+  ["cljc", "clojure"],
+  ["cpp", "cpp"],
+  ["cxx", "cpp"],
+  ["cs", "csharp"],
+  ["cts", "typescript"],
+  ["ctsx", "typescriptreact"],
+  ["dart", "dart"],
+  ["diff", "diff"],
+  ["edn", "clojure"],
+  ["go", "go"],
+  ["gemspec", "ruby"],
+  ["groovy", "groovy"],
+  ["h", "c"],
+  ["handlebars", "handlebars"],
+  ["hbs", "handlebars"],
+  ["hpp", "cpp"],
+  ["hxx", "cpp"],
+  ["h++", "cpp"],
+  ["hh", "cpp"],
+  ["hrl", "erlang"],
+  ["hs", "haskell"],
+  ["htm", "html"],
+  ["html", "html"],
+  ["ini", "ini"],
+  ["js", "javascript"],
+  ["jsx", "javascriptreact"],
+  ["jl", "julia"],
+  ["json", "json"],
+  ["ksh", "bash"],
+  ["kt", "kotlin"],
+  ["kts", "kotlin"],
+  ["latex", "latex"],
+  ["less", "less"],
+  ["lua", "lua"],
+  ["markdown", "markdown"],
+  ["md", "markdown"],
+  ["mdown", "markdown"],
+  ["mkd", "markdown"],
+  ["mjs", "javascript"],
+  ["ml", "ocaml"],
+  ["mli", "ocaml"],
+  ["mts", "typescript"],
+  ["mtsx", "typescriptreact"],
+  ["patch", "diff"],
+  ["php", "php"],
+  ["pl", "perl"],
+  ["pm", "perl"],
+  ["ps1", "powershell"],
+  ["psm1", "powershell"],
+  ["py", "python"],
+  ["pyi", "python"],
+  ["r", "r"],
+  ["rb", "ruby"],
+  ["rake", "ruby"],
+  ["rs", "rust"],
+  ["ru", "ruby"],
+  ["sass", "sass"],
+  ["sc", "scala"],
+  ["scala", "scala"],
+  ["scss", "scss"],
+  ["sh", "bash"],
+  ["sql", "sql"],
+  ["svelte", "svelte"],
+  ["swift", "swift"],
+  ["ts", "typescript"],
+  ["tsx", "typescriptreact"],
+  ["tex", "latex"],
+  ["toml", "toml"],
+  ["vue", "vue"],
+  ["vim", "vim"],
+  ["xml", "xml"],
+  ["xsl", "xsl"],
+  ["yaml", "yaml"],
+  ["yml", "yaml"],
+  ["zig", "zig"],
+  ["zon", "zig"],
+  ["zsh", "bash"],
+  ["c++", "cpp"],
+  ["erl", "erlang"],
+  ["exs", "elixir"],
+  ["ex", "elixir"],
+  ["elm", "elm"],
+  ["fsharp", "fsharp"],
+  ["fs", "fsharp"],
+  ["fsx", "fsharp"],
+  ["fsscript", "fsharp"],
+  ["fsi", "fsharp"],
+  ["java", "java"],
+  ["css", "css"]
+]);
+var basenameToFiletype = new Map([
+  [".bash_aliases", "bash"],
+  [".bash_logout", "bash"],
+  [".bash_profile", "bash"],
+  [".bashrc", "bash"],
+  [".kshrc", "bash"],
+  [".profile", "bash"],
+  [".vimrc", "vim"],
+  [".zlogin", "bash"],
+  [".zlogout", "bash"],
+  [".zprofile", "bash"],
+  [".zshenv", "bash"],
+  [".zshrc", "bash"],
+  ["appfile", "ruby"],
+  ["berksfile", "ruby"],
+  ["brewfile", "ruby"],
+  ["cheffile", "ruby"],
+  ["containerfile", "dockerfile"],
+  ["dockerfile", "dockerfile"],
+  ["fastfile", "ruby"],
+  ["gemfile", "ruby"],
+  ["gnumakefile", "make"],
+  ["gvimrc", "vim"],
+  ["guardfile", "ruby"],
+  ["makefile", "make"],
+  ["podfile", "ruby"],
+  ["rakefile", "ruby"],
+  ["thorfile", "ruby"],
+  ["vagrantfile", "ruby"]
+]);
+function normalizeFiletypeToken(value) {
+  const normalizedValue = value.trim().replace(/^\./, "").toLowerCase();
+  return normalizedValue || undefined;
+}
+function getBasename(value) {
+  const normalizedValue = value.trim().replaceAll("\\", "/");
+  if (!normalizedValue)
+    return;
+  const basename2 = path2.posix.basename(normalizedValue).toLowerCase();
+  return basename2 || undefined;
+}
 function extToFiletype(extension) {
-  const extensionToFiletype = new Map([
-    ["js", "javascript"],
-    ["jsx", "javascriptreact"],
-    ["ts", "typescript"],
-    ["tsx", "typescriptreact"],
-    ["md", "markdown"],
-    ["json", "json"],
-    ["py", "python"],
-    ["rb", "ruby"],
-    ["go", "go"],
-    ["rs", "rust"],
-    ["c", "c"],
-    ["cpp", "cpp"],
-    ["c++", "cpp"],
-    ["cs", "csharp"],
-    ["java", "java"],
-    ["kt", "kotlin"],
-    ["swift", "swift"],
-    ["php", "php"],
-    ["sql", "sql"],
-    ["pl", "perl"],
-    ["lua", "lua"],
-    ["erl", "erlang"],
-    ["exs", "elixir"],
-    ["ex", "elixir"],
-    ["elm", "elm"],
-    ["fsharp", "fsharp"],
-    ["fs", "fsharp"],
-    ["fsx", "fsharp"],
-    ["fsscript", "fsharp"],
-    ["fsi", "fsharp"],
-    ["h", "c"],
-    ["hpp", "cpp"],
-    ["html", "html"],
-    ["css", "css"],
-    ["scss", "scss"],
-    ["less", "less"],
-    ["sh", "shell"],
-    ["bash", "shell"],
-    ["zsh", "shell"],
-    ["vim", "vim"],
-    ["yaml", "yaml"],
-    ["yml", "yaml"],
-    ["toml", "toml"],
-    ["xml", "xml"],
-    ["zig", "zig"]
-  ]);
-  return extensionToFiletype.get(extension);
+  const normalizedExtension = normalizeFiletypeToken(extension);
+  if (!normalizedExtension)
+    return;
+  return extensionToFiletype.get(normalizedExtension);
 }
-function pathToFiletype(path2) {
-  if (typeof path2 !== "string")
+function pathToFiletype(path3) {
+  if (typeof path3 !== "string")
     return;
-  const lastDot = path2.lastIndexOf(".");
-  if (lastDot === -1 || lastDot === path2.length - 1) {
+  const basename2 = getBasename(path3);
+  if (!basename2)
     return;
+  const basenameFiletype = basenameToFiletype.get(basename2);
+  if (basenameFiletype) {
+    return basenameFiletype;
   }
-  const extension = path2.substring(lastDot + 1);
+  const lastDot = basename2.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === basename2.length - 1) {
+    return;
+  }
+  const extension = basename2.substring(lastDot + 1);
   return extToFiletype(extension);
 }
+function infoStringToFiletype(infoString) {
+  if (typeof infoString !== "string")
+    return;
+  const token = infoString.trim().split(/\s+/, 1)[0];
+  const directBasenameMatch = basenameToFiletype.get(token.toLowerCase());
+  if (directBasenameMatch)
+    return directBasenameMatch;
+  const normalizedToken = normalizeFiletypeToken(token);
+  if (!normalizedToken)
+    return;
+  return basenameToFiletype.get(normalizedToken) ?? pathToFiletype(normalizedToken) ?? extToFiletype(normalizedToken) ?? normalizedToken;
+}
 
 // src/lib/tree-sitter/assets/update.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/lib/tree-sitter/download-utils.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 
 class DownloadUtils {
   static hashUrl(url) {
@@ -8802,10 +9328,10 @@ class DownloadUtils {
         const hash = this.hashUrl(source);
         cacheFileName = filetype ? `${filetype}-${hash}${fileExtension}` : `${hash}${fileExtension}`;
       } else {
-        cacheFileName = path2.basename(source);
+        cacheFileName = path3.basename(source);
       }
-      const cacheFile = path2.join(cacheDir, cacheSubdir, cacheFileName);
-      await mkdir(path2.dirname(cacheFile), { recursive: true });
+      const cacheFile = path3.join(cacheDir, cacheSubdir, cacheFileName);
+      await mkdir(path3.dirname(cacheFile), { recursive: true });
       try {
         const cachedContent = await readFile(cacheFile);
         if (cachedContent.byteLength > 0) {
@@ -8842,7 +9368,7 @@ class DownloadUtils {
   }
   static async downloadToPath(source, targetPath) {
     const isUrl2 = source.startsWith("http://") || source.startsWith("https://");
-    await mkdir(path2.dirname(targetPath), { recursive: true });
+    await mkdir(path3.dirname(targetPath), { recursive: true });
     if (isUrl2) {
       try {
         console.log(`Downloading from URL: ${source}`);
@@ -8893,22 +9419,22 @@ import { readdir } from "fs/promises";
 var __dirname = "/Users/runner/work/opentui/opentui/packages/core/src/lib/tree-sitter/assets";
 function getDefaultOptions() {
   return {
-    configPath: path3.resolve(__dirname, "../parsers-config"),
-    assetsDir: path3.resolve(__dirname),
-    outputPath: path3.resolve(__dirname, "../default-parsers.ts")
+    configPath: path4.resolve(__dirname, "../parsers-config"),
+    assetsDir: path4.resolve(__dirname),
+    outputPath: path4.resolve(__dirname, "../default-parsers.ts")
   };
 }
 async function loadConfig(configPath) {
-  let ext = path3.extname(configPath);
+  let ext = path4.extname(configPath);
   let resolvedConfigPath = configPath;
   if (ext === "") {
-    const files = await readdir(path3.dirname(configPath));
-    const file = files.find((file2) => file2.startsWith(path3.basename(configPath)) && (file2.endsWith(".json") || file2.endsWith(".ts") || file2.endsWith(".js")));
+    const files = await readdir(path4.dirname(configPath));
+    const file = files.find((file2) => file2.startsWith(path4.basename(configPath)) && (file2.endsWith(".json") || file2.endsWith(".ts") || file2.endsWith(".js")));
     if (!file) {
       throw new Error(`No config file found for ${configPath}`);
     }
-    resolvedConfigPath = path3.join(path3.dirname(configPath), file);
-    ext = path3.extname(resolvedConfigPath);
+    resolvedConfigPath = path4.join(path4.dirname(configPath), file);
+    ext = path4.extname(resolvedConfigPath);
   }
   if (ext === ".json") {
     const configContent = await readFile2(resolvedConfigPath, "utf-8");
@@ -8920,25 +9446,25 @@ async function loadConfig(configPath) {
   throw new Error(`Unsupported config file extension: ${ext}`);
 }
 async function downloadLanguage(filetype, languageUrl, assetsDir, outputPath) {
-  const languageDir = path3.join(assetsDir, filetype);
-  const languageFilename = path3.basename(languageUrl);
-  const languagePath = path3.join(languageDir, languageFilename);
+  const languageDir = path4.join(assetsDir, filetype);
+  const languageFilename = path4.basename(languageUrl);
+  const languagePath = path4.join(languageDir, languageFilename);
   const result = await DownloadUtils.downloadToPath(languageUrl, languagePath);
   if (result.error) {
     throw new Error(`Failed to download language for ${filetype}: ${result.error}`);
   }
-  return "./" + path3.relative(path3.dirname(outputPath), languagePath);
+  return "./" + path4.relative(path4.dirname(outputPath), languagePath);
 }
 async function downloadAndCombineQueries(filetype, queryUrls, assetsDir, outputPath, queryType, configPath) {
-  const queriesDir = path3.join(assetsDir, filetype);
-  const queryPath = path3.join(queriesDir, `${queryType}.scm`);
+  const queriesDir = path4.join(assetsDir, filetype);
+  const queryPath = path4.join(queriesDir, `${queryType}.scm`);
   const queryContents = [];
   for (let i = 0;i < queryUrls.length; i++) {
     const queryUrl = queryUrls[i];
     if (queryUrl.startsWith("./")) {
       console.log(`    Using local query ${i + 1}/${queryUrls.length}: ${queryUrl}`);
       try {
-        const localPath = path3.resolve(path3.dirname(configPath), queryUrl);
+        const localPath = path4.resolve(path4.dirname(configPath), queryUrl);
         const content = await readFile2(localPath, "utf-8");
         if (content.trim()) {
           queryContents.push(content);
@@ -8975,7 +9501,7 @@ ${content}`);
 `);
   await writeFile2(queryPath, combinedContent, "utf-8");
   console.log(`  Combined ${queryContents.length} queries into ${queryPath}`);
-  return "./" + path3.relative(path3.dirname(outputPath), queryPath);
+  return "./" + path4.relative(path4.dirname(outputPath), queryPath);
 }
 async function generateDefaultParsersFile(parsers, outputPath) {
   const imports = parsers.map((parser) => {
@@ -9000,9 +9526,11 @@ async function generateDefaultParsersFile(parsers, outputPath) {
       queriesLines.push(`          injections: [resolve(dirname(fileURLToPath(import.meta.url)), ${safeFiletype}_injections)],`);
     }
     const injectionMappingLine = parser.injectionMapping ? `        injectionMapping: ${JSON.stringify(parser.injectionMapping, null, 10)},` : "";
+    const aliasesLine = parser.aliases?.length ? `        aliases: ${JSON.stringify(parser.aliases)},` : "";
     return `      {
         filetype: "${parser.filetype}",
-        queries: {
+${aliasesLine ? aliasesLine + `
+` : ""}        queries: {
 ${queriesLines.join(`
 `)}
         },
@@ -9033,9 +9561,9 @@ ${parserDefinitions},
   return _cachedParsers
 }
 `;
-  await mkdir2(path3.dirname(outputPath), { recursive: true });
+  await mkdir2(path4.dirname(outputPath), { recursive: true });
   await writeFile2(outputPath, fileContent, "utf-8");
-  console.log(`Generated ${path3.basename(outputPath)} with ${parsers.length} parsers`);
+  console.log(`Generated ${path4.basename(outputPath)} with ${parsers.length} parsers`);
 }
 async function main(options) {
   const opts = { ...getDefaultOptions(), ...options };
@@ -9060,6 +9588,7 @@ async function main(options) {
       }
       generatedParsers.push({
         filetype: parser.filetype,
+        aliases: parser.aliases,
         languagePath,
         highlightsPath,
         injectionsPath,
@@ -10334,6 +10863,21 @@ class OptimizedBuffer {
   fillRect(x, y, width, height, bg2) {
     this.lib.bufferFillRect(this.bufferPtr, x, y, width, height, bg2);
   }
+  colorMatrix(matrix, cellMask, strength = 1, target = 3 /* Both */) {
+    this.guard();
+    if (matrix.length !== 16)
+      throw new RangeError(`colorMatrix matrix must have length 16, got ${matrix.length}`);
+    const cellMaskCount = Math.floor(cellMask.length / 3);
+    this.lib.bufferColorMatrix(this.bufferPtr, ptr(matrix), ptr(cellMask), cellMaskCount, strength, target);
+  }
+  colorMatrixUniform(matrix, strength = 1, target = 3 /* Both */) {
+    this.guard();
+    if (matrix.length !== 16)
+      throw new RangeError(`colorMatrixUniform matrix must have length 16, got ${matrix.length}`);
+    if (strength === 0)
+      return;
+    this.lib.bufferColorMatrixUniform(this.bufferPtr, ptr(matrix), strength, target);
+  }
   drawFrameBuffer(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
     this.guard();
     this.lib.drawFrameBuffer(this.bufferPtr, destX, destY, frameBuffer.ptr, sourceX, sourceY, sourceWidth, sourceHeight);
@@ -11421,6 +11965,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32", "u32", "u32", "u32", "ptr"],
       returns: "void"
     },
+    bufferColorMatrix: {
+      args: ["ptr", "ptr", "ptr", "usize", "f32", "u8"],
+      returns: "void"
+    },
+    bufferColorMatrixUniform: {
+      args: ["ptr", "ptr", "f32", "u8"],
+      returns: "void"
+    },
     bufferResize: {
       args: ["ptr", "u32", "u32"],
       returns: "void"
@@ -12644,6 +13196,12 @@ class FFIRenderLib {
     const bg2 = color.buffer;
     this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg2);
   }
+  bufferColorMatrix(buffer, matrixPtr, cellMaskPtr, cellMaskCount, strength, target) {
+    this.opentui.symbols.bufferColorMatrix(buffer, matrixPtr, cellMaskPtr, cellMaskCount, strength, target);
+  }
+  bufferColorMatrixUniform(buffer, matrixPtr, strength, target) {
+    this.opentui.symbols.bufferColorMatrixUniform(buffer, matrixPtr, strength, target);
+  }
   bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
     const formatId = format === "bgra8unorm" ? 0 : 1;
     this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, formatId, alignedBytesPerRow);
@@ -12899,8 +13457,8 @@ class FFIRenderLib {
   textBufferAppendFromMemId(buffer, memId) {
     this.opentui.symbols.textBufferAppendFromMemId(buffer, memId);
   }
-  textBufferLoadFile(buffer, path4) {
-    const pathBytes = this.encoder.encode(path4);
+  textBufferLoadFile(buffer, path5) {
+    const pathBytes = this.encoder.encode(path5);
     return this.opentui.symbols.textBufferLoadFile(buffer, pathBytes, pathBytes.length);
   }
   textBufferSetStyledText(buffer, chunks) {
@@ -13767,11 +14325,11 @@ class TextBuffer {
     this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
     this._lineInfo = undefined;
   }
-  loadFile(path4) {
+  loadFile(path5) {
     this.guard();
-    const success = this.lib.textBufferLoadFile(this.bufferPtr, path4);
+    const success = this.lib.textBufferLoadFile(this.bufferPtr, path5);
     if (!success) {
-      throw new Error(`Failed to load file: ${path4}`);
+      throw new Error(`Failed to load file: ${path5}`);
     }
     this._length = this.lib.textBufferGetLength(this.bufferPtr);
     this._byteSize = this.lib.textBufferGetByteSize(this.bufferPtr);
@@ -15388,7 +15946,7 @@ function delegate(mapping, vnode) {
 import { EventEmitter as EventEmitter7 } from "events";
 import { Console } from "console";
 import fs from "fs";
-import path4 from "path";
+import path5 from "path";
 import util2 from "util";
 
 // src/lib/output.capture.ts
@@ -16445,7 +17003,7 @@ class TerminalConsole extends EventEmitter7 {
     try {
       const timestamp = Date.now();
       const filename = `_console_${timestamp}.log`;
-      const filepath = path4.join(process.cwd(), filename);
+      const filepath = path5.join(process.cwd(), filename);
       const allLogEntries = [...this._allLogEntries, ...terminalConsoleCache.cachedLogs];
       const logLines = [];
       for (const [date, level, args, callerInfo] of allLogEntries) {
@@ -16663,7 +17221,7 @@ registerEnvVar({
 });
 registerEnvVar({
   name: "OTUI_USE_ALTERNATE_SCREEN",
-  description: "Whether to use the console. Will not capture console output if set to false.",
+  description: "Use the terminal alternate screen buffer.",
   type: "boolean",
   default: true
 });
@@ -16829,8 +17387,15 @@ async function createCliRenderer(config = {}) {
 }
 var CliRenderEvents;
 ((CliRenderEvents2) => {
+  CliRenderEvents2["RESIZE"] = "resize";
+  CliRenderEvents2["FOCUS"] = "focus";
+  CliRenderEvents2["BLUR"] = "blur";
+  CliRenderEvents2["THEME_MODE"] = "theme_mode";
+  CliRenderEvents2["CAPABILITIES"] = "capabilities";
+  CliRenderEvents2["SELECTION"] = "selection";
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
   CliRenderEvents2["DESTROY"] = "destroy";
+  CliRenderEvents2["MEMORY_SNAPSHOT"] = "memory:snapshot";
 })(CliRenderEvents ||= {});
 var RendererControlState;
 ((RendererControlState2) => {
@@ -16954,6 +17519,7 @@ class CliRenderer extends EventEmitter8 {
   _paletteDetectionPromise = null;
   _onDestroy;
   _themeMode = null;
+  _terminalFocusState = null;
   sequenceHandlers = [];
   prependedInputHandlers = [];
   shouldRestoreModesOnNextFocus = false;
@@ -17091,6 +17657,12 @@ Captured output:
         this.drainStdinParser();
       },
       useKittyKeyboard: useKittyForParsing,
+      protocolContext: {
+        kittyKeyboardEnabled: useKittyForParsing,
+        privateCapabilityRepliesActive: false,
+        pixelResolutionQueryActive: false,
+        explicitWidthCprActive: false
+      },
       clock: this.clock
     });
     this._console = new TerminalConsole(this, {
@@ -17154,6 +17726,18 @@ Captured output:
   get currentFocusedRenderable() {
     return this._currentFocusedRenderable;
   }
+  normalizeClockTime(now, fallback) {
+    if (Number.isFinite(now)) {
+      return now;
+    }
+    return Number.isFinite(fallback) ? fallback : 0;
+  }
+  getElapsedMs(now, then) {
+    if (!Number.isFinite(now) || !Number.isFinite(then)) {
+      return 0;
+    }
+    return Math.max(now - then, 0);
+  }
   focusRenderable(renderable) {
     if (this._currentFocusedRenderable === renderable)
       return;
@@ -17210,8 +17794,8 @@ Captured output:
     }
     if (!this.updateScheduled && !this.renderTimeout) {
       this.updateScheduled = true;
-      const now = this.clock.now();
-      const elapsed = now - this.lastTime;
+      const now = this.normalizeClockTime(this.clock.now(), this.lastTime);
+      const elapsed = this.getElapsedMs(now, this.lastTime);
       const delay = Math.max(this.minTargetFrameTime - elapsed, 0);
       if (delay === 0) {
         process.nextTick(() => this.activateFrame());
@@ -17357,7 +17941,7 @@ Captured output:
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
     this.root.resize(this.width, this.height);
-    this.emit("resize", this.width, this.height);
+    this.emit("resize" /* RESIZE */, this.width, this.height);
     this.requestRender();
   }
   interceptStdoutWrite = (chunk, encoding, callback) => {
@@ -17408,9 +17992,11 @@ Captured output:
   }
   enableKittyKeyboard(flags = 3) {
     this.lib.enableKittyKeyboard(this.rendererPtr, flags);
+    this.updateStdinParserProtocolContext({ kittyKeyboardEnabled: true });
   }
   disableKittyKeyboard() {
     this.lib.disableKittyKeyboard(this.rendererPtr);
+    this.updateStdinParserProtocolContext({ kittyKeyboardEnabled: false }, true);
   }
   set useThread(useThread) {
     this._useThread = useThread;
@@ -17420,6 +18006,10 @@ Captured output:
     if (this._terminalIsSetup)
       return;
     this._terminalIsSetup = true;
+    this.updateStdinParserProtocolContext({
+      privateCapabilityRepliesActive: true,
+      explicitWidthCprActive: true
+    });
     this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
     if (this.debugOverlay.enabled) {
@@ -17433,6 +18023,10 @@ Captured output:
     this.capabilityTimeoutId = this.clock.setTimeout(() => {
       this.capabilityTimeoutId = null;
       this.removeInputHandler(this.capabilityHandler);
+      this.updateStdinParserProtocolContext({
+        privateCapabilityRepliesActive: false,
+        explicitWidthCprActive: false
+      }, true);
     }, 5000);
     if (this._useMouse) {
       this.enableMouse();
@@ -17459,6 +18053,13 @@ Captured output:
   removeInputHandler(handler) {
     this.sequenceHandlers = this.sequenceHandlers.filter((candidate) => candidate !== handler);
   }
+  updateStdinParserProtocolContext(patch, drain = false) {
+    if (!this.stdinParser)
+      return;
+    this.stdinParser.updateProtocolContext(patch);
+    if (drain)
+      this.drainStdinParser();
+  }
   subscribeOsc(handler) {
     this.oscSubscribers.add(handler);
     return () => {
@@ -17469,7 +18070,7 @@ Captured output:
     if (isCapabilityResponse(sequence)) {
       this.lib.processCapabilityResponse(this.rendererPtr, sequence);
       this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
-      this.emit("capabilities", this._capabilities);
+      this.emit("capabilities" /* CAPABILITIES */, this._capabilities);
       return true;
     }
     return false;
@@ -17480,12 +18081,18 @@ Captured output:
         this.lib.restoreTerminalModes(this.rendererPtr);
         this.shouldRestoreModesOnNextFocus = false;
       }
-      this.emit("focus");
+      if (this._terminalFocusState !== true) {
+        this._terminalFocusState = true;
+        this.emit("focus" /* FOCUS */);
+      }
       return true;
     }
     if (sequence === "\x1B[O") {
       this.shouldRestoreModesOnNextFocus = true;
-      this.emit("blur");
+      if (this._terminalFocusState !== false) {
+        this._terminalFocusState = false;
+        this.emit("blur" /* BLUR */);
+      }
       return true;
     }
     return false;
@@ -17494,14 +18101,14 @@ Captured output:
     if (sequence === "\x1B[?997;1n") {
       if (this._themeMode !== "dark") {
         this._themeMode = "dark";
-        this.emit("theme_mode", "dark");
+        this.emit("theme_mode" /* THEME_MODE */, "dark");
       }
       return true;
     }
     if (sequence === "\x1B[?997;2n") {
       if (this._themeMode !== "light") {
         this._themeMode = "light";
-        this.emit("theme_mode", "light");
+        this.emit("theme_mode" /* THEME_MODE */, "light");
       }
       return true;
     }
@@ -17577,8 +18184,9 @@ Captured output:
         const resolution = parsePixelResolution(sequence);
         if (resolution) {
           this._resolution = resolution;
-          this.waitingForPixelResolution = false;
         }
+        this.waitingForPixelResolution = false;
+        this.updateStdinParserProtocolContext({ pixelResolutionQueryActive: false }, true);
         return true;
       }
       return false;
@@ -17777,7 +18385,7 @@ Captured output:
       arrayBuffers: memoryUsage.arrayBuffers
     };
     this.lib.updateMemoryStats(this.rendererPtr, this.lastMemorySnapshot.heapUsed, this.lastMemorySnapshot.heapTotal, this.lastMemorySnapshot.arrayBuffers);
-    this.emit("memory:snapshot", this.lastMemorySnapshot);
+    this.emit("memory:snapshot" /* MEMORY_SNAPSHOT */, this.lastMemorySnapshot);
   }
   startMemorySnapshotTimer() {
     this.stopMemorySnapshotTimer();
@@ -17818,6 +18426,7 @@ Captured output:
   }
   queryPixelResolution() {
     this.waitingForPixelResolution = true;
+    this.updateStdinParserProtocolContext({ pixelResolutionQueryActive: true });
     this.lib.queryPixelResolution(this.rendererPtr);
   }
   processResize(width, height) {
@@ -17849,7 +18458,7 @@ Captured output:
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this._console.resize(this.width, this.height);
     this.root.resize(this.width, this.height);
-    this.emit("resize", this.width, this.height);
+    this.emit("resize" /* RESIZE */, this.width, this.height);
     this.requestRender();
   }
   setBackgroundColor(color) {
@@ -17991,6 +18600,12 @@ Captured output:
     this._suspendedMouseEnabled = this._useMouse;
     this.disableMouse();
     this.removeExitListeners();
+    this.waitingForPixelResolution = false;
+    this.updateStdinParserProtocolContext({
+      privateCapabilityRepliesActive: false,
+      pixelResolutionQueryActive: false,
+      explicitWidthCprActive: false
+    });
     this.stdinParser?.reset();
     this.stdin.removeListener("data", this.stdinListener);
     this.lib.suspendRenderer(this.rendererPtr);
@@ -18097,6 +18712,11 @@ Captured output:
     }
     this._isRunning = false;
     this.waitingForPixelResolution = false;
+    this.updateStdinParserProtocolContext({
+      privateCapabilityRepliesActive: false,
+      pixelResolutionQueryActive: false,
+      explicitWidthCprActive: false
+    }, true);
     this.setCapturedRenderable(undefined);
     try {
       this.root.destroyRecursively();
@@ -18129,7 +18749,7 @@ Captured output:
   startRenderLoop() {
     if (!this._isRunning)
       return;
-    this.lastTime = this.clock.now();
+    this.lastTime = this.normalizeClockTime(this.clock.now(), 0);
     this.frameCount = 0;
     this.lastFpsTime = this.lastTime;
     this.currentFps = 0;
@@ -18145,12 +18765,12 @@ Captured output:
       this.renderTimeout = null;
     }
     try {
-      const now = this.clock.now();
-      const elapsed = now - this.lastTime;
+      const now = this.normalizeClockTime(this.clock.now(), this.lastTime);
+      const elapsed = this.getElapsedMs(now, this.lastTime);
       const deltaTime = elapsed;
       this.lastTime = now;
       this.frameCount++;
-      if (now - this.lastFpsTime >= 1000) {
+      if (this.getElapsedMs(now, this.lastFpsTime) >= 1000) {
         this.currentFps = this.frameCount;
         this.frameCount = 0;
         this.lastFpsTime = now;
@@ -18336,7 +18956,7 @@ Captured output:
   finishSelection() {
     if (this.currentSelection) {
       this.currentSelection.isDragging = false;
-      this.emit("selection", this.currentSelection);
+      this.emit("selection" /* SELECTION */, this.currentSelection);
       this.notifySelectablesOfSelectionChange();
     }
   }
@@ -18409,7 +19029,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, decodePasteBytes, stripAnsiSequences, detectLinks, TextBuffer, SpanInfoStruct, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=CCC74025BA5612C764756E2164756E21
-//# sourceMappingURL=index-nkrr8a4c.js.map
+//# debugId=0CC64CF95771CED464756E2164756E21
+//# sourceMappingURL=index-e89anq5x.js.map