@opentuah/core 0.1.95 → 0.1.96

package/{index-2fr3e57d.js → index-yc0yx782.js}

@@ -6077,8 +6077,23 @@ function extractCompleteSequences(buffer) {
         return { sequences, remainder: remaining };
       }
     } else {
-      sequences.push(remaining[0]);
-      pos++;
+      const code = remaining.charCodeAt(0);
+      if (code >= 55296 && code <= 56319) {
+        if (remaining.length === 1) {
+          return { sequences, remainder: remaining };
+        }
+        const next = remaining.charCodeAt(1);
+        if (next >= 56320 && next <= 57343) {
+          sequences.push(remaining.slice(0, 2));
+          pos += 2;
+        } else {
+          sequences.push(remaining[0]);
+          pos++;
+        }
+      } else {
+        sequences.push(remaining[0]);
+        pos++;
+      }
     }
   }
   return { sequences, remainder: "" };
@@ -6502,95 +6517,168 @@ class MouseParser {
   reset() {
     this.mouseButtonsPressed.clear();
   }
+  decodeInput(data) {
+    return data.toString();
+  }
   parseMouseEvent(data) {
-    const str = data.toString();
-    const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
-    if (sgrMatch) {
-      const [, buttonCode, x, y, pressRelease] = sgrMatch;
-      const rawButtonCode = parseInt(buttonCode);
-      const button = rawButtonCode & 3;
-      const isScroll = (rawButtonCode & 64) !== 0;
-      const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
-      const isMotion = (rawButtonCode & 32) !== 0;
-      const modifiers = {
-        shift: (rawButtonCode & 4) !== 0,
-        alt: (rawButtonCode & 8) !== 0,
-        ctrl: (rawButtonCode & 16) !== 0
-      };
-      let type;
-      let scrollInfo;
-      if (isScroll && pressRelease === "M") {
-        type = "scroll";
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else if (isMotion) {
-        const isDragging = this.mouseButtonsPressed.size > 0;
-        if (button === 3) {
-          type = "move";
-        } else if (isDragging) {
-          type = "drag";
-        } else {
-          type = "move";
+    const str = this.decodeInput(data);
+    const parsed = this.parseMouseSequenceAt(str, 0);
+    return parsed?.event ?? null;
+  }
+  parseAllMouseEvents(data) {
+    const str = this.decodeInput(data);
+    const events = [];
+    let offset = 0;
+    while (offset < str.length) {
+      const parsed = this.parseMouseSequenceAt(str, offset);
+      if (!parsed) {
+        break;
+      }
+      events.push(parsed.event);
+      offset += parsed.consumed;
+    }
+    return events;
+  }
+  parseMouseSequenceAt(str, offset) {
+    if (!str.startsWith("\x1B[", offset))
+      return null;
+    const introducer = str[offset + 2];
+    if (introducer === "<") {
+      return this.parseSgrSequence(str, offset);
+    }
+    if (introducer === "M") {
+      return this.parseBasicSequence(str, offset);
+    }
+    return null;
+  }
+  parseSgrSequence(str, offset) {
+    let index = offset + 3;
+    const values = [0, 0, 0];
+    let part = 0;
+    let hasDigit = false;
+    while (index < str.length) {
+      const char = str[index];
+      const charCode = str.charCodeAt(index);
+      if (charCode >= 48 && charCode <= 57) {
+        hasDigit = true;
+        values[part] = values[part] * 10 + (charCode - 48);
+        index++;
+        continue;
+      }
+      switch (char) {
+        case ";": {
+          if (!hasDigit || part >= 2)
+            return null;
+          part++;
+          hasDigit = false;
+          index++;
+          break;
         }
-      } else {
-        type = pressRelease === "M" ? "down" : "up";
-        if (type === "down" && button !== 3) {
-          this.mouseButtonsPressed.add(button);
-        } else if (type === "up") {
-          this.mouseButtonsPressed.clear();
+        case "M":
+        case "m": {
+          if (!hasDigit || part !== 2)
+            return null;
+          return {
+            event: this.decodeSgrEvent(values[0], values[1], values[2], char),
+            consumed: index - offset + 1
+          };
         }
+        default:
+          return null;
       }
-      return {
-        type,
-        button: button === 3 ? 0 : button,
-        x: parseInt(x) - 1,
-        y: parseInt(y) - 1,
-        modifiers,
-        scroll: scrollInfo
-      };
     }
-    if (str.startsWith("\x1B[M") && str.length >= 6) {
-      const buttonByte = str.charCodeAt(3) - 32;
-      const x = str.charCodeAt(4) - 33;
-      const y = str.charCodeAt(5) - 33;
-      const button = buttonByte & 3;
-      const isScroll = (buttonByte & 64) !== 0;
-      const isMotion = (buttonByte & 32) !== 0;
-      const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
-      const modifiers = {
-        shift: (buttonByte & 4) !== 0,
-        alt: (buttonByte & 8) !== 0,
-        ctrl: (buttonByte & 16) !== 0
+    return null;
+  }
+  parseBasicSequence(str, offset) {
+    if (offset + 6 > str.length)
+      return null;
+    const buttonByte = str.charCodeAt(offset + 3) - 32;
+    const x = str.charCodeAt(offset + 4) - 33;
+    const y = str.charCodeAt(offset + 5) - 33;
+    return {
+      event: this.decodeBasicEvent(buttonByte, x, y),
+      consumed: 6
+    };
+  }
+  decodeSgrEvent(rawButtonCode, wireX, wireY, pressRelease) {
+    const button = rawButtonCode & 3;
+    const isScroll = (rawButtonCode & 64) !== 0;
+    const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+    const isMotion = (rawButtonCode & 32) !== 0;
+    const modifiers = {
+      shift: (rawButtonCode & 4) !== 0,
+      alt: (rawButtonCode & 8) !== 0,
+      ctrl: (rawButtonCode & 16) !== 0
+    };
+    let type;
+    let scrollInfo;
+    if (isScroll && pressRelease === "M") {
+      type = "scroll";
+      scrollInfo = {
+        direction: scrollDirection,
+        delta: 1
       };
-      let type;
-      let actualButton;
-      let scrollInfo;
-      if (isScroll) {
-        type = "scroll";
-        actualButton = 0;
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else if (isMotion) {
+    } else if (isMotion) {
+      const isDragging = this.mouseButtonsPressed.size > 0;
+      if (button === 3) {
         type = "move";
-        actualButton = button === 3 ? -1 : button;
+      } else if (isDragging) {
+        type = "drag";
       } else {
-        type = button === 3 ? "up" : "down";
-        actualButton = button === 3 ? 0 : button;
+        type = "move";
       }
-      return {
-        type,
-        button: actualButton,
-        x,
-        y,
-        modifiers,
-        scroll: scrollInfo
+    } else {
+      type = pressRelease === "M" ? "down" : "up";
+      if (type === "down" && button !== 3) {
+        this.mouseButtonsPressed.add(button);
+      } else if (type === "up") {
+        this.mouseButtonsPressed.clear();
+      }
+    }
+    return {
+      type,
+      button: button === 3 ? 0 : button,
+      x: wireX - 1,
+      y: wireY - 1,
+      modifiers,
+      scroll: scrollInfo
+    };
+  }
+  decodeBasicEvent(buttonByte, x, y) {
+    const button = buttonByte & 3;
+    const isScroll = (buttonByte & 64) !== 0;
+    const isMotion = (buttonByte & 32) !== 0;
+    const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
+    const modifiers = {
+      shift: (buttonByte & 4) !== 0,
+      alt: (buttonByte & 8) !== 0,
+      ctrl: (buttonByte & 16) !== 0
+    };
+    let type;
+    let actualButton;
+    let scrollInfo;
+    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;
     }
-    return null;
+    return {
+      type,
+      button: actualButton,
+      x,
+      y,
+      modifiers,
+      scroll: scrollInfo
+    };
   }
 }
 
@@ -9649,6 +9737,15 @@ class OptimizedBuffer {
     this.guard();
     this.lib.freeUnicode(encoded);
   }
+  drawGrid(options) {
+    this.guard();
+    const columnCount = Math.max(0, options.columnOffsets.length - 1);
+    const rowCount = Math.max(0, options.rowOffsets.length - 1);
+    this.lib.bufferDrawGrid(this.bufferPtr, options.borderChars, options.borderFg, options.borderBg, options.columnOffsets, columnCount, options.rowOffsets, rowCount, {
+      drawInner: options.drawInner,
+      drawOuter: options.drawOuter
+    });
+  }
   drawChar(char, x, y, fg2, bg2, attributes = 0) {
     this.guard();
     this.lib.bufferDrawChar(this.bufferPtr, char, x, y, fg2, bg2, attributes);
@@ -10362,6 +10459,24 @@ var CursorStateStruct = defineStruct([
   ["b", "f32"],
   ["a", "f32"]
 ]);
+var CursorStyleOptionsStruct = defineStruct([
+  ["style", "u8", { default: 255 }],
+  ["blinking", "u8", { default: 255 }],
+  [
+    "color",
+    "pointer",
+    {
+      optional: true,
+      packTransform: rgbaPackTransform,
+      unpackTransform: rgbaUnpackTransform
+    }
+  ],
+  ["cursor", "u8", { default: 255 }]
+]);
+var GridDrawOptionsStruct = defineStruct([
+  ["drawInner", "bool_u8", { default: true }],
+  ["drawOuter", "bool_u8", { default: true }]
+]);
 var GrowthPolicyEnum = defineEnum({ grow: 0, block: 1 }, "u8");
 var NativeSpanFeedOptionsStruct = defineStruct([
   ["chunkSize", "u32", { default: 64 * 1024 }],
@@ -10449,10 +10564,10 @@ registerEnvVar({
   default: false
 });
 registerEnvVar({
-  name: "OPENTUI_NO_GRAPHICS",
-  description: "Disable Kitty graphics protocol detection",
+  name: "OPENTUI_GRAPHICS",
+  description: "Enable Kitty graphics protocol detection",
   type: "boolean",
-  default: false
+  default: true
 });
 registerEnvVar({
   name: "OPENTUI_FORCE_NOZWJ",
@@ -10460,6 +10575,9 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2 };
+var CURSOR_ID_TO_STYLE = ["block", "line", "underline"];
+var MOUSE_STYLE_TO_ID = { default: 0, pointer: 1, text: 2, crosshair: 3, move: 4, "not-allowed": 5 };
 var globalTraceSymbols = null;
 var globalFFILogWriter = null;
 var exitHandlerRegistered = false;
@@ -10490,6 +10608,10 @@ function getOpenTUILib(libPath) {
       args: ["u32", "u32", "bool", "bool"],
       returns: "ptr"
     },
+    setTerminalEnvVar: {
+      args: ["ptr", "ptr", "usize", "ptr", "usize"],
+      returns: "bool"
+    },
     destroyRenderer: {
       args: ["ptr"],
       returns: "void"
@@ -10634,10 +10756,6 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i32", "i32", "bool"],
       returns: "void"
     },
-    setCursorStyle: {
-      args: ["ptr", "ptr", "u32", "bool"],
-      returns: "void"
-    },
     setCursorColor: {
       args: ["ptr", "ptr"],
       returns: "void"
@@ -10646,6 +10764,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    setCursorStyleOptions: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     setDebugOverlay: {
       args: ["ptr", "bool", "u8"],
       returns: "void"
@@ -10682,6 +10804,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "ptr", "ptr"],
       returns: "void"
     },
+    bufferDrawGrid: {
+      args: ["ptr", "ptr", "ptr", "ptr", "ptr", "u32", "ptr", "u32", "ptr"],
+      returns: "void"
+    },
     bufferDrawBox: {
       args: ["ptr", "i32", "i32", "u32", "u32", "ptr", "u32", "ptr", "ptr", "ptr", "u32"],
       returns: "void"
@@ -11721,6 +11847,11 @@ class FFIRenderLib {
     const remote = options.remote ?? false;
     return this.opentui.symbols.createRenderer(width, height, testing, remote);
   }
+  setTerminalEnvVar(renderer, key, value) {
+    const keyBytes = this.encoder.encode(key);
+    const valueBytes = this.encoder.encode(value);
+    return this.opentui.symbols.setTerminalEnvVar(renderer, keyBytes, keyBytes.length, valueBytes, valueBytes.length);
+  }
   destroyRenderer(renderer) {
     this.opentui.symbols.destroyRenderer(renderer);
   }
@@ -11850,6 +11981,13 @@ class FFIRenderLib {
   bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2, bg2) {
     this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, fg2?.buffer ?? null, bg2?.buffer ?? null);
   }
+  bufferDrawGrid(buffer, borderChars, borderFg, borderBg, columnOffsets, columnCount, rowOffsets, rowCount, options) {
+    const optionsBuffer = GridDrawOptionsStruct.pack({
+      drawInner: options.drawInner,
+      drawOuter: options.drawOuter
+    });
+    this.opentui.symbols.bufferDrawGrid(buffer, borderChars, borderFg.buffer, borderBg.buffer, columnOffsets, columnCount, rowOffsets, rowCount, ptr4(optionsBuffer));
+  }
   bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, title) {
     const titleBytes = title ? this.encoder.encode(title) : null;
     const titleLen = title ? titleBytes.length : 0;
@@ -11880,10 +12018,6 @@ class FFIRenderLib {
   setCursorPosition(renderer, x, y, visible) {
     this.opentui.symbols.setCursorPosition(renderer, x, y, visible);
   }
-  setCursorStyle(renderer, style, blinking) {
-    const stylePtr = this.encoder.encode(style);
-    this.opentui.symbols.setCursorStyle(renderer, stylePtr, style.length, blinking);
-  }
   setCursorColor(renderer, color) {
     this.opentui.symbols.setCursorColor(renderer, color.buffer);
   }
@@ -11891,20 +12025,22 @@ class FFIRenderLib {
     const cursorBuffer = new ArrayBuffer(CursorStateStruct.size);
     this.opentui.symbols.getCursorState(renderer, ptr4(cursorBuffer));
     const struct = CursorStateStruct.unpack(cursorBuffer);
-    const styleMap = {
-      0: "block",
-      1: "line",
-      2: "underline"
-    };
     return {
       x: struct.x,
       y: struct.y,
       visible: struct.visible,
-      style: styleMap[struct.style] || "block",
+      style: CURSOR_ID_TO_STYLE[struct.style] ?? "block",
       blinking: struct.blinking,
       color: RGBA.fromValues(struct.r, struct.g, struct.b, struct.a)
     };
   }
+  setCursorStyleOptions(renderer, options) {
+    const style = options.style != null ? CURSOR_STYLE_TO_ID[options.style] : 255;
+    const blinking = options.blinking != null ? options.blinking ? 1 : 0 : 255;
+    const cursor = options.cursor != null ? MOUSE_STYLE_TO_ID[options.cursor] : 255;
+    const buffer = CursorStyleOptionsStruct.pack({ style, blinking, color: options.color, cursor });
+    this.opentui.symbols.setCursorStyleOptions(renderer, ptr4(buffer));
+  }
   render(renderer, force) {
     this.opentui.symbols.render(renderer, force);
   }
@@ -15918,6 +16054,24 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var DEFAULT_FORWARDED_ENV_KEYS = [
+  "TMUX",
+  "TERM",
+  "OPENTUI_GRAPHICS",
+  "TERM_PROGRAM",
+  "TERM_PROGRAM_VERSION",
+  "ALACRITTY_SOCKET",
+  "ALACRITTY_LOG",
+  "COLORTERM",
+  "TERMUX_VERSION",
+  "VHS_RECORD",
+  "OPENTUI_FORCE_WCWIDTH",
+  "OPENTUI_FORCE_UNICODE",
+  "OPENTUI_FORCE_NOZWJ",
+  "OPENTUI_FORCE_EXPLICIT_WIDTH",
+  "WT_SESSION",
+  "STY"
+];
 var KITTY_FLAG_DISAMBIGUATE = 1;
 var KITTY_FLAG_EVENT_TYPES = 2;
 var KITTY_FLAG_ALTERNATE_KEYS = 4;
@@ -16152,6 +16306,7 @@ class CliRenderer extends EventEmitter9 {
   _latestPointer = { x: 0, y: 0 };
   _hasPointer = false;
   _lastPointerModifiers = { shift: false, alt: false, ctrl: false };
+  _currentMousePointerStyle = undefined;
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
@@ -16226,6 +16381,13 @@ Captured output:
       lib.setRenderOffset(rendererPtr, this.renderOffset);
     }
     this.rendererPtr = rendererPtr;
+    const forwardEnvKeys = config.forwardEnvKeys ?? [...DEFAULT_FORWARDED_ENV_KEYS];
+    for (const key of forwardEnvKeys) {
+      const value = process.env[key];
+      if (value === undefined)
+        continue;
+      this.lib.setTerminalEnvVar(this.rendererPtr, key, value);
+    }
     this.exitOnCtrlC = config.exitOnCtrlC === undefined ? true : config.exitOnCtrlC;
     this.exitSignals = config.exitSignals || [
       "SIGINT",
@@ -16736,127 +16898,135 @@ Captured output:
     return event;
   }
   handleMouseData(data) {
-    const mouseEvent = this.mouseParser.parseMouseEvent(data);
-    if (mouseEvent) {
-      if (this._splitHeight > 0) {
-        if (mouseEvent.y < this.renderOffset) {
-          return false;
-        }
-        mouseEvent.y -= this.renderOffset;
-      }
-      this._latestPointer.x = mouseEvent.x;
-      this._latestPointer.y = mouseEvent.y;
-      this._hasPointer = true;
-      this._lastPointerModifiers = mouseEvent.modifiers;
-      if (this._console.visible) {
-        const consoleBounds = this._console.bounds;
-        if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
-          const event2 = new MouseEvent(null, mouseEvent);
-          const handled = this._console.handleMouse(event2);
-          if (handled)
-            return true;
-        }
+    const mouseEvents = this.mouseParser.parseAllMouseEvents(data);
+    if (mouseEvents.length === 0)
+      return false;
+    let anyHandled = false;
+    for (const mouseEvent of mouseEvents) {
+      if (this.processSingleMouseEvent(mouseEvent)) {
+        anyHandled = true;
       }
-      if (mouseEvent.type === "scroll") {
-        const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
-        const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
-        const fallbackTarget = this._currentFocusedRenderable && !this._currentFocusedRenderable.isDestroyed ? this._currentFocusedRenderable : null;
-        const scrollTarget = maybeRenderable2 ?? fallbackTarget;
-        if (scrollTarget) {
-          const event2 = new MouseEvent(scrollTarget, mouseEvent);
-          scrollTarget.processMouseEvent(event2);
-        }
-        return true;
+    }
+    return anyHandled;
+  }
+  processSingleMouseEvent(mouseEvent) {
+    if (this._splitHeight > 0) {
+      if (mouseEvent.y < this.renderOffset) {
+        return false;
       }
-      const maybeRenderableId = this.hitTest(mouseEvent.x, mouseEvent.y);
-      const sameElement = maybeRenderableId === this.lastOverRenderableNum;
-      this.lastOverRenderableNum = maybeRenderableId;
-      const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && !this.currentSelection?.isDragging && !mouseEvent.modifiers.ctrl) {
-        if (maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
-          this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-          this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+      mouseEvent.y -= this.renderOffset;
+    }
+    this._latestPointer.x = mouseEvent.x;
+    this._latestPointer.y = mouseEvent.y;
+    this._hasPointer = true;
+    this._lastPointerModifiers = mouseEvent.modifiers;
+    if (this._console.visible) {
+      const consoleBounds = this._console.bounds;
+      if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
+        const event2 = new MouseEvent(null, mouseEvent);
+        const handled = this._console.handleMouse(event2);
+        if (handled)
           return true;
-        }
       }
-      if (mouseEvent.type === "drag" && this.currentSelection?.isDragging) {
-        this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
-          maybeRenderable.processMouseEvent(event2);
-        }
-        return true;
+    }
+    if (mouseEvent.type === "scroll") {
+      const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
+      const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
+      const fallbackTarget = this._currentFocusedRenderable && !this._currentFocusedRenderable.isDestroyed && this._currentFocusedRenderable.focused ? this._currentFocusedRenderable : null;
+      const scrollTarget = maybeRenderable2 ?? fallbackTarget;
+      if (scrollTarget) {
+        const event2 = new MouseEvent(scrollTarget, mouseEvent);
+        scrollTarget.processMouseEvent(event2);
       }
-      if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
-          maybeRenderable.processMouseEvent(event2);
-        }
-        this.finishSelection();
+      return true;
+    }
+    const maybeRenderableId = this.hitTest(mouseEvent.x, mouseEvent.y);
+    const sameElement = maybeRenderableId === this.lastOverRenderableNum;
+    this.lastOverRenderableNum = maybeRenderableId;
+    const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
+    if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && !this.currentSelection?.isDragging && !mouseEvent.modifiers.ctrl) {
+      if (maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
+        this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+        this.dispatchMouseEvent(maybeRenderable, mouseEvent);
         return true;
       }
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && this.currentSelection) {
-        if (mouseEvent.modifiers.ctrl) {
-          this.currentSelection.isDragging = true;
-          this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-          return true;
-        }
+    }
+    if (mouseEvent.type === "drag" && this.currentSelection?.isDragging) {
+      this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+      if (maybeRenderable) {
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        maybeRenderable.processMouseEvent(event2);
       }
-      if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
-        if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
-          const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
-          this.lastOverRenderable.processMouseEvent(event2);
-        }
-        this.lastOverRenderable = maybeRenderable;
-        if (maybeRenderable) {
-          const event2 = new MouseEvent(maybeRenderable, {
-            ...mouseEvent,
-            type: "over",
-            source: this.capturedRenderable
-          });
-          maybeRenderable.processMouseEvent(event2);
-        }
+      return true;
+    }
+    if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
+      if (maybeRenderable) {
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        maybeRenderable.processMouseEvent(event2);
       }
-      if (this.capturedRenderable && mouseEvent.type !== "up") {
-        const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
-        this.capturedRenderable.processMouseEvent(event2);
+      this.finishSelection();
+      return true;
+    }
+    if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && this.currentSelection) {
+      if (mouseEvent.modifiers.ctrl) {
+        this.currentSelection.isDragging = true;
+        this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
         return true;
       }
-      if (this.capturedRenderable && mouseEvent.type === "up") {
-        const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
-        this.capturedRenderable.processMouseEvent(event2);
-        this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
-        if (maybeRenderable) {
-          const event3 = new MouseEvent(maybeRenderable, {
-            ...mouseEvent,
-            type: "drop",
-            source: this.capturedRenderable
-          });
-          maybeRenderable.processMouseEvent(event3);
-        }
-        this.lastOverRenderable = this.capturedRenderable;
-        this.lastOverRenderableNum = this.capturedRenderable.num;
-        this.setCapturedRenderable(undefined);
-        this.requestRender();
+    }
+    if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
+      if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
+        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
+        this.lastOverRenderable.processMouseEvent(event2);
       }
-      let event;
+      this.lastOverRenderable = maybeRenderable;
       if (maybeRenderable) {
-        if (mouseEvent.type === "drag" && mouseEvent.button === 0 /* LEFT */) {
-          this.setCapturedRenderable(maybeRenderable);
-        } else {
-          this.setCapturedRenderable(undefined);
-        }
-        event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+        const event2 = new MouseEvent(maybeRenderable, {
+          ...mouseEvent,
+          type: "over",
+          source: this.capturedRenderable
+        });
+        maybeRenderable.processMouseEvent(event2);
+      }
+    }
+    if (this.capturedRenderable && mouseEvent.type !== "up") {
+      const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
+      this.capturedRenderable.processMouseEvent(event2);
+      return true;
+    }
+    if (this.capturedRenderable && mouseEvent.type === "up") {
+      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
+      this.capturedRenderable.processMouseEvent(event2);
+      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
+      if (maybeRenderable) {
+        const event3 = new MouseEvent(maybeRenderable, {
+          ...mouseEvent,
+          type: "drop",
+          source: this.capturedRenderable
+        });
+        maybeRenderable.processMouseEvent(event3);
+      }
+      this.lastOverRenderable = this.capturedRenderable;
+      this.lastOverRenderableNum = this.capturedRenderable.num;
+      this.setCapturedRenderable(undefined);
+      this.requestRender();
+    }
+    let event;
+    if (maybeRenderable) {
+      if (mouseEvent.type === "drag" && mouseEvent.button === 0 /* LEFT */) {
+        this.setCapturedRenderable(maybeRenderable);
       } else {
         this.setCapturedRenderable(undefined);
-        this.lastOverRenderable = undefined;
-      }
-      if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
-        this.clearSelection();
       }
-      return true;
+      event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+    } else {
+      this.setCapturedRenderable(undefined);
+      this.lastOverRenderable = undefined;
     }
-    return false;
+    if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
+      this.clearSelection();
+    }
+    return true;
   }
   recheckHoverState() {
     if (this._isDestroyed || !this._hasPointer)
@@ -16891,6 +17061,10 @@ Captured output:
       hitRenderable.processMouseEvent(event);
     }
   }
+  setMousePointer(style) {
+    this._currentMousePointerStyle = style;
+    this.lib.setCursorStyleOptions(this.rendererPtr, { cursor: style });
+  }
   hitTest(x, y) {
     return this.lib.checkHit(this.rendererPtr, x, y);
   }
@@ -17033,11 +17207,11 @@ Captured output:
     const lib = resolveRenderLib();
     lib.setCursorPosition(renderer.rendererPtr, x, y, visible);
   }
-  static setCursorStyle(renderer, style, blinking = false, color) {
+  static setCursorStyle(renderer, options) {
     const lib = resolveRenderLib();
-    lib.setCursorStyle(renderer.rendererPtr, style, blinking);
-    if (color) {
-      lib.setCursorColor(renderer.rendererPtr, color);
+    lib.setCursorStyleOptions(renderer.rendererPtr, options);
+    if (options.cursor !== undefined) {
+      renderer._currentMousePointerStyle = options.cursor;
     }
   }
   static setCursorColor(renderer, color) {
@@ -17047,10 +17221,10 @@ Captured output:
   setCursorPosition(x, y, visible = true) {
     this.lib.setCursorPosition(this.rendererPtr, x, y, visible);
   }
-  setCursorStyle(style, blinking = false, color) {
-    this.lib.setCursorStyle(this.rendererPtr, style, blinking);
-    if (color) {
-      this.lib.setCursorColor(this.rendererPtr, color);
+  setCursorStyle(options) {
+    this.lib.setCursorStyleOptions(this.rendererPtr, options);
+    if (options.cursor !== undefined) {
+      this._currentMousePointerStyle = options.cursor;
     }
   }
   setCursorColor(color) {
@@ -17150,6 +17324,13 @@ Captured output:
   }
   internalPause() {
     this._isRunning = false;
+    if (this.renderTimeout) {
+      clearTimeout(this.renderTimeout);
+      this.renderTimeout = null;
+    }
+    if (!this.rendering) {
+      this.resolveIdleIfNeeded();
+    }
   }
   stop() {
     this._controlState = "explicit_stopped" /* EXPLICIT_STOPPED */;
@@ -17527,5 +17708,5 @@ Captured output:
 
 export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, 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, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, 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, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, VTermStyleFlags, vtermDataToStyledText, 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=DE4BB4A2DA7EC2CF64756E2164756E21
-//# sourceMappingURL=index-2fr3e57d.js.map
+//# debugId=C1193A584E7CA83964756E2164756E21
+//# sourceMappingURL=index-yc0yx782.js.map