@opentui/core 0.1.87 → 0.1.89

package/{index-0wbvecnk.js → index-e89anq5x.js}

@@ -1850,11 +1850,14 @@ class KeyEvent {
 }
 
 class PasteEvent {
-  text;
+  type = "paste";
+  bytes;
+  metadata;
   _defaultPrevented = false;
   _propagationStopped = false;
-  constructor(text) {
-    this.text = text;
+  constructor(bytes, metadata) {
+    this.bytes = bytes;
+    this.metadata = metadata;
   }
   get defaultPrevented() {
     return this._defaultPrevented;
@@ -1890,10 +1893,9 @@ class KeyHandler extends EventEmitter {
     }
     return true;
   }
-  processPaste(data) {
+  processPaste(bytes, metadata) {
     try {
-      const cleanedData = Bun.stripANSI(data);
-      this.emit("paste", new PasteEvent(cleanedData));
+      this.emit("paste", new PasteEvent(bytes, metadata));
     } catch (error) {
       console.error(`[KeyHandler] Error processing paste:`, error);
     }
@@ -5091,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({
@@ -5312,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);
@@ -5320,6 +5331,12 @@ class SystemClock {
   clearTimeout(handle) {
     globalThis.clearTimeout(handle);
   }
+  setInterval(fn, delayMs) {
+    return globalThis.setInterval(fn, delayMs);
+  }
+  clearInterval(handle) {
+    globalThis.clearInterval(handle);
+  }
 }
 
 // src/lib/parse.keypress.ts
@@ -5345,6 +5362,12 @@ var kittyKeyMap = {
   57355: "pagedown",
   57356: "home",
   57357: "end",
+  57358: "capslock",
+  57359: "scrolllock",
+  57360: "numlock",
+  57361: "printscreen",
+  57362: "pause",
+  57363: "menu",
   57364: "f1",
   57365: "f2",
   57366: "f3",
@@ -5397,6 +5420,18 @@ var kittyKeyMap = {
   57413: "kpplus",
   57414: "kpenter",
   57415: "kpequal",
+  57416: "kpseparator",
+  57417: "kpleft",
+  57418: "kpright",
+  57419: "kpup",
+  57420: "kpdown",
+  57421: "kppageup",
+  57422: "kppagedown",
+  57423: "kphome",
+  57424: "kpend",
+  57425: "kpinsert",
+  57426: "kpdelete",
+  57427: "clear",
   57428: "mediaplay",
   57429: "mediapause",
   57430: "mediaplaypause",
@@ -5444,9 +5479,9 @@ var functionalKeyMap = {
   D: "left",
   H: "home",
   F: "end",
+  E: "clear",
   P: "f1",
   Q: "f2",
-  R: "f3",
   S: "f4"
 };
 var tildeKeyMap = {
@@ -5469,7 +5504,9 @@ var tildeKeyMap = {
   "20": "f9",
   "21": "f10",
   "23": "f11",
-  "24": "f12"
+  "24": "f12",
+  "29": "menu",
+  "57427": "clear"
 };
 function parseKittySpecialKey(sequence) {
   const specialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Z~])$/;
@@ -5584,6 +5621,8 @@ function parseKittyKeyboard(sequence) {
   if (knownKey) {
     key.name = knownKey;
     key.code = `[${codepoint}u`;
+  } else if (codepoint === 0) {
+    key.name = "";
   } else {
     if (codepoint > 0 && codepoint <= 1114111) {
       const char = String.fromCodePoint(codepoint);
@@ -5649,8 +5688,14 @@ function parseKittyKeyboard(sequence) {
     text = " ";
   }
   if (text) {
+    if (codepoint === 0) {
+      key.name = text;
+    }
     key.sequence = text;
   }
+  if (codepoint === 0 && text === "") {
+    return null;
+  }
   return key;
 }
 
@@ -5679,6 +5724,8 @@ var keyName = {
   "[21~": "f10",
   "[23~": "f11",
   "[24~": "f12",
+  "[29~": "menu",
+  "[57427~": "clear",
   "[A": "up",
   "[B": "down",
   "[C": "right",
@@ -5686,6 +5733,9 @@ var keyName = {
   "[E": "clear",
   "[F": "end",
   "[H": "home",
+  "[P": "f1",
+  "[Q": "f2",
+  "[S": "f4",
   OA: "up",
   OB: "down",
   OC: "right",
@@ -6370,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";
@@ -6385,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) {
@@ -6415,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;
@@ -6802,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;
 
@@ -6941,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;
@@ -6981,10 +7097,25 @@ function decodeUtf8(bytes) {
 function createPasteCollector() {
   return {
     tail: EMPTY_BYTES,
-    decoder: new TextDecoder,
-    parts: []
+    parts: [],
+    totalLength: 0
   };
 }
+function joinPasteBytes(parts, totalLength) {
+  if (totalLength === 0) {
+    return EMPTY_BYTES;
+  }
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  const bytes = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const part of parts) {
+    bytes.set(part, offset);
+    offset += part.length;
+  }
+  return bytes;
+}
 
 class StdinParser {
   pending = new ByteQueue(INITIAL_PENDING_CAPACITY);
@@ -6996,6 +7127,7 @@ class StdinParser {
   useKittyKeyboard;
   mouseParser = new MouseParser;
   clock;
+  protocolContext;
   timeoutId = null;
   destroyed = false;
   pendingSinceMs = null;
@@ -7012,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) {
@@ -7320,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);
@@ -7347,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) {
@@ -7578,14 +8022,10 @@ class StdinParser {
     const combined = concatBytes(paste.tail, chunk);
     const endIndex = indexOfBytes(combined, BRACKETED_PASTE_END);
     if (endIndex !== -1) {
-      this.pushPasteText(combined.subarray(0, endIndex));
-      const tailText = paste.decoder.decode();
-      if (tailText.length > 0) {
-        paste.parts.push(tailText);
-      }
+      this.pushPasteBytes(combined.subarray(0, endIndex));
       this.events.push({
         type: "paste",
-        text: paste.parts.join("")
+        bytes: joinPasteBytes(paste.parts, paste.totalLength)
       });
       this.paste = null;
       return combined.subarray(endIndex + BRACKETED_PASTE_END.length);
@@ -7593,18 +8033,34 @@ class StdinParser {
     const keep = Math.min(BRACKETED_PASTE_END.length - 1, combined.length);
     const stableLength = combined.length - keep;
     if (stableLength > 0) {
-      this.pushPasteText(combined.subarray(0, stableLength));
+      this.pushPasteBytes(combined.subarray(0, stableLength));
     }
-    paste.tail = combined.slice(stableLength);
+    paste.tail = Uint8Array.from(combined.subarray(stableLength));
     return EMPTY_BYTES;
   }
-  pushPasteText(bytes) {
+  pushPasteBytes(bytes) {
     if (bytes.length === 0) {
       return;
     }
-    const text = this.paste.decoder.decode(bytes, { stream: true });
-    if (text.length > 0) {
-      this.paste.parts.push(text);
+    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() {
@@ -7990,6 +8446,7 @@ function getParsers() {
     _cachedParsers = [
       {
         filetype: "javascript",
+        aliases: ["javascriptreact"],
         queries: {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), javascript_highlights)]
         },
@@ -7997,6 +8454,7 @@ function getParsers() {
       },
       {
         filetype: "typescript",
+        aliases: ["typescriptreact"],
         queries: {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), typescript_highlights)]
         },
@@ -8017,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"
           }
@@ -8069,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://");
@@ -8192,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)),
@@ -8665,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 lastDot = basename2.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === basename2.length - 1) {
     return;
   }
-  const extension = path2.substring(lastDot + 1);
+  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) {
@@ -8752,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) {
@@ -8792,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}`);
@@ -8843,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");
@@ -8870,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);
@@ -8925,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) => {
@@ -8950,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(`
 `)}
         },
@@ -8983,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 };
@@ -9010,6 +9588,7 @@ async function main(options) {
       }
       generatedParsers.push({
         filetype: parser.filetype,
+        aliases: parser.aliases,
         languagePath,
         highlightsPath,
         injectionsPath,
@@ -9751,6 +10330,7 @@ function createExtmarksController(editBuffer, editorView) {
 }
 
 // src/lib/terminal-palette.ts
+var SYSTEM_CLOCK2 = new SystemClock;
 var OSC4_RESPONSE = /\x1b]4;(\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 var OSC_SPECIAL_RESPONSE = /\x1b](\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
 function scaleComponent(comp) {
@@ -9777,12 +10357,14 @@ class TerminalPalette {
   activeQuerySessions = [];
   inLegacyTmux;
   oscSource;
-  constructor(stdin, stdout, writeFn, isLegacyTmux, oscSource) {
+  clock;
+  constructor(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
     this.stdin = stdin;
     this.stdout = stdout;
     this.writeFn = writeFn || ((data) => stdout.write(data));
     this.inLegacyTmux = isLegacyTmux ?? false;
     this.oscSource = oscSource;
+    this.clock = clock ?? SYSTEM_CLOCK2;
   }
   writeOsc(osc) {
     const data = this.inLegacyTmux ? wrapForTmux(osc) : osc;
@@ -9814,7 +10396,7 @@ class TerminalPalette {
         return;
       closed = true;
       for (const timer of timers) {
-        clearTimeout(timer);
+        this.clock.clearTimeout(timer);
       }
       timers.clear();
       for (const unsubscribe of subscriptions) {
@@ -9828,16 +10410,16 @@ class TerminalPalette {
     this.activeQuerySessions.push(cleanup);
     return {
       setTimer: (fn, ms) => {
-        const timer = setTimeout(fn, ms);
+        const timer = this.clock.setTimeout(fn, ms);
         timers.add(timer);
         return timer;
       },
       resetTimer: (existing, fn, ms) => {
         if (existing) {
-          clearTimeout(existing);
+          this.clock.clearTimeout(existing);
           timers.delete(existing);
         }
-        const timer = setTimeout(fn, ms);
+        const timer = this.clock.setTimeout(fn, ms);
         timers.add(timer);
         return timer;
       },
@@ -10027,8 +10609,17 @@ class TerminalPalette {
     };
   }
 }
-function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource) {
-  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource);
+function createTerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock) {
+  return new TerminalPalette(stdin, stdout, writeFn, isLegacyTmux, oscSource, clock);
+}
+
+// src/lib/paste.ts
+var PASTE_TEXT_DECODER = new TextDecoder;
+function decodePasteBytes(bytes) {
+  return PASTE_TEXT_DECODER.decode(bytes);
+}
+function stripAnsiSequences(text) {
+  return Bun.stripANSI(text);
 }
 
 // src/lib/detect-links.ts
@@ -10272,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);
@@ -11359,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"
@@ -12582,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);
@@ -12837,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) {
@@ -13705,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);
@@ -15326,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
@@ -15635,6 +16255,7 @@ class TerminalConsole extends EventEmitter7 {
     height: 0
   };
   _autoScrollInterval = null;
+  clock;
   _keyBindingsMap;
   _keyAliasMap;
   _keyBindings;
@@ -15674,6 +16295,7 @@ class TerminalConsole extends EventEmitter7 {
   constructor(renderer, options = {}) {
     super();
     this.renderer = renderer;
+    this.clock = options.clock ?? new SystemClock;
     this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
     this.keyHandler = this.handleKeyPress.bind(this);
     this._debugModeEnabled = this.options.startInDebugMode;
@@ -16229,13 +16851,13 @@ class TerminalConsole extends EventEmitter7 {
   }
   stopAutoScroll() {
     if (this._autoScrollInterval !== null) {
-      clearInterval(this._autoScrollInterval);
+      this.clock.clearInterval(this._autoScrollInterval);
       this._autoScrollInterval = null;
     }
   }
   startAutoScroll(direction) {
     this.stopAutoScroll();
-    this._autoScrollInterval = setInterval(() => {
+    this._autoScrollInterval = this.clock.setInterval(() => {
       if (direction === "up") {
         if (this.scrollTopIndex > 0) {
           this.scrollTopIndex--;
@@ -16381,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) {
@@ -16599,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
 });
@@ -16765,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) => {
@@ -16813,6 +17442,7 @@ class CliRenderer extends EventEmitter8 {
   postProcessFns = [];
   backgroundColor = RGBA.fromInts(0, 0, 0, 0);
   waitingForPixelResolution = false;
+  clock;
   rendering = false;
   renderingNative = false;
   renderTimeout = null;
@@ -16889,6 +17519,7 @@ class CliRenderer extends EventEmitter8 {
   _paletteDetectionPromise = null;
   _onDestroy;
   _themeMode = null;
+  _terminalFocusState = null;
   sequenceHandlers = [];
   prependedInputHandlers = [];
   shouldRestoreModesOnNextFocus = false;
@@ -17016,6 +17647,7 @@ Captured output:
       }
     });
     this.addExitListeners();
+    this.clock = config.clock ?? new SystemClock;
     const stdinParserMaxBufferBytes = config.stdinParserMaxBufferBytes ?? DEFAULT_STDIN_PARSER_MAX_BUFFER_BYTES;
     this.stdinParser = new StdinParser({
       timeoutMs: 10,
@@ -17025,9 +17657,18 @@ Captured output:
         this.drainStdinParser();
       },
       useKittyKeyboard: useKittyForParsing,
-      clock: config.stdinParserClock
+      protocolContext: {
+        kittyKeyboardEnabled: useKittyForParsing,
+        privateCapabilityRepliesActive: false,
+        pixelResolutionQueryActive: false,
+        explicitWidthCprActive: false
+      },
+      clock: this.clock
+    });
+    this._console = new TerminalConsole(this, {
+      ...config.consoleOptions ?? {},
+      clock: this.clock
     });
-    this._console = new TerminalConsole(this, config.consoleOptions);
     this.useConsole = config.useConsole ?? true;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
     this._onDestroy = config.onDestroy;
@@ -17085,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;
@@ -17141,14 +17794,14 @@ Captured output:
     }
     if (!this.updateScheduled && !this.renderTimeout) {
       this.updateScheduled = true;
-      const now = Date.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());
         return;
       }
-      setTimeout(() => this.activateFrame(), delay);
+      this.clock.setTimeout(() => this.activateFrame(), delay);
     }
   }
   async activateFrame() {
@@ -17288,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) => {
@@ -17339,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;
@@ -17351,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) {
@@ -17361,9 +18020,13 @@ Captured output:
         this.automaticMemorySnapshot = true;
       }
     }
-    this.capabilityTimeoutId = setTimeout(() => {
+    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();
@@ -17390,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 () => {
@@ -17400,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;
@@ -17411,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;
@@ -17425,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;
     }
@@ -17474,7 +18150,7 @@ Captured output:
         this.dispatchSequenceHandlers(event.raw);
         return;
       case "paste":
-        this._keyHandler.processPaste(event.text);
+        this._keyHandler.processPaste(event.bytes, event.metadata);
         return;
       case "response":
         if (event.protocol === "osc") {
@@ -17508,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;
@@ -17708,17 +18385,17 @@ 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();
-    this.memorySnapshotTimer = setInterval(() => {
+    this.memorySnapshotTimer = this.clock.setInterval(() => {
       this.takeMemorySnapshot();
     }, this.memorySnapshotInterval);
   }
   stopMemorySnapshotTimer() {
     if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
       this.memorySnapshotTimer = null;
     }
   }
@@ -17727,7 +18404,7 @@ Captured output:
     if (this._isRunning && interval > 0) {
       this.startMemorySnapshotTimer();
     } else if (interval <= 0 && this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
       this.memorySnapshotTimer = null;
     }
   }
@@ -17739,16 +18416,17 @@ Captured output:
       return;
     }
     if (this.resizeTimeoutId !== null) {
-      clearTimeout(this.resizeTimeoutId);
+      this.clock.clearTimeout(this.resizeTimeoutId);
       this.resizeTimeoutId = null;
     }
-    this.resizeTimeoutId = setTimeout(() => {
+    this.resizeTimeoutId = this.clock.setTimeout(() => {
       this.resizeTimeoutId = null;
       this.processResize(width, height);
     }, this.resizeDebounceDelay);
   }
   queryPixelResolution() {
     this.waitingForPixelResolution = true;
+    this.updateStdinParserProtocolContext({ pixelResolutionQueryActive: true });
     this.lib.queryPixelResolution(this.rendererPtr);
   }
   processResize(width, height) {
@@ -17780,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) {
@@ -17922,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);
@@ -17955,7 +18639,7 @@ Captured output:
   internalPause() {
     this._isRunning = false;
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     if (!this.rendering) {
@@ -17970,11 +18654,11 @@ Captured output:
     if (this.isRunning && !this._isDestroyed) {
       this._isRunning = false;
       if (this.memorySnapshotTimer) {
-        clearInterval(this.memorySnapshotTimer);
+        this.clock.clearInterval(this.memorySnapshotTimer);
         this.memorySnapshotTimer = null;
       }
       if (this.renderTimeout) {
-        clearTimeout(this.renderTimeout);
+        this.clock.clearTimeout(this.renderTimeout);
         this.renderTimeout = null;
       }
       if (!this.rendering) {
@@ -18005,15 +18689,15 @@ Captured output:
     capture.removeListener("write", this.captureCallback);
     this.removeExitListeners();
     if (this.resizeTimeoutId !== null) {
-      clearTimeout(this.resizeTimeoutId);
+      this.clock.clearTimeout(this.resizeTimeoutId);
       this.resizeTimeoutId = null;
     }
     if (this.capabilityTimeoutId !== null) {
-      clearTimeout(this.capabilityTimeoutId);
+      this.clock.clearTimeout(this.capabilityTimeoutId);
       this.capabilityTimeoutId = null;
     }
     if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
+      this.clock.clearInterval(this.memorySnapshotTimer);
     }
     if (this._paletteDetector) {
       this._paletteDetector.cleanup();
@@ -18023,11 +18707,16 @@ Captured output:
     this._cachedPalette = null;
     this.emit("destroy" /* DESTROY */);
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     this._isRunning = false;
     this.waitingForPixelResolution = false;
+    this.updateStdinParserProtocolContext({
+      privateCapabilityRepliesActive: false,
+      pixelResolutionQueryActive: false,
+      explicitWidthCprActive: false
+    }, true);
     this.setCapturedRenderable(undefined);
     try {
       this.root.destroyRecursively();
@@ -18060,7 +18749,7 @@ Captured output:
   startRenderLoop() {
     if (!this._isRunning)
       return;
-    this.lastTime = Date.now();
+    this.lastTime = this.normalizeClockTime(this.clock.now(), 0);
     this.frameCount = 0;
     this.lastFpsTime = this.lastTime;
     this.currentFps = 0;
@@ -18072,16 +18761,16 @@ Captured output:
     this.renderTimeout = null;
     this.rendering = true;
     if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
+      this.clock.clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
     try {
-      const now = Date.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;
@@ -18127,12 +18816,12 @@ Captured output:
           const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
           const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
           this.immediateRerenderRequested = false;
-          this.renderTimeout = setTimeout(() => {
+          this.renderTimeout = this.clock.setTimeout(() => {
             this.renderTimeout = null;
             this.loop();
           }, delay);
         } else {
-          clearTimeout(this.renderTimeout);
+          this.clock.clearTimeout(this.renderTimeout);
           this.renderTimeout = null;
         }
       }
@@ -18267,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();
     }
   }
@@ -18329,7 +19018,7 @@ Captured output:
       const isLegacyTmux = this.capabilities?.terminal?.name?.toLowerCase()?.includes("tmux") && this.capabilities?.terminal?.version?.localeCompare("3.6") < 0;
       this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this), isLegacyTmux, {
         subscribeOsc: this.subscribeOsc.bind(this)
-      });
+      }, this.clock);
     }
     this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
       this._cachedPalette = result;
@@ -18340,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, 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=EFEF7A9F3BA3925B64756E2164756E21
-//# sourceMappingURL=index-0wbvecnk.js.map
+//# debugId=0CC64CF95771CED464756E2164756E21
+//# sourceMappingURL=index-e89anq5x.js.map