@opentui/core 0.1.79 → 0.1.80

package/{index-zrvzvh6r.js → index-vnvba6q9.js}

@@ -6074,8 +6074,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: "" };
@@ -6499,95 +6514,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
+    };
   }
 }
 
@@ -10315,6 +10403,59 @@ 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 GrowthPolicyEnum = defineEnum({ grow: 0, block: 1 }, "u8");
+var NativeSpanFeedOptionsStruct = defineStruct([
+  ["chunkSize", "u32", { default: 64 * 1024 }],
+  ["initialChunks", "u32", { default: 2 }],
+  ["maxBytes", "u64", { default: 0n }],
+  ["growthPolicy", GrowthPolicyEnum, { default: "grow" }],
+  ["autoCommitOnFull", "bool_u8", { default: true }],
+  ["spanQueueCapacity", "u32", { default: 0 }]
+]);
+var NativeSpanFeedStatsStruct = defineStruct([
+  ["bytesWritten", "u64"],
+  ["spansCommitted", "u64"],
+  ["chunks", "u32"],
+  ["pendingSpans", "u32"]
+]);
+var SpanInfoStruct = defineStruct([
+  ["chunkPtr", "pointer"],
+  ["offset", "u32"],
+  ["len", "u32"],
+  ["chunkIndex", "u32"],
+  ["reserved", "u32", { default: 0 }]
+], {
+  reduceValue: (value) => ({
+    chunkPtr: value.chunkPtr,
+    offset: value.offset,
+    len: value.len,
+    chunkIndex: value.chunkIndex
+  })
+});
+var ReserveInfoStruct = defineStruct([
+  ["ptr", "pointer"],
+  ["len", "u32"],
+  ["reserved", "u32", { default: 0 }]
+], {
+  reduceValue: (value) => ({
+    ptr: value.ptr,
+    len: value.len
+  })
+});
 
 // src/zig.ts
 var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
@@ -10361,9 +10502,24 @@ 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;
+function toPointer(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Pointer exceeds safe integer range");
+    }
+    return Number(value);
+  }
+  return value;
+}
+function toNumber(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
   const rawSymbols = dlopen(resolvedLibPath, {
@@ -10523,10 +10679,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"
@@ -10535,6 +10687,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    setCursorStyleOptions: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     setDebugOverlay: {
       args: ["ptr", "bool", "u8"],
       returns: "void"
@@ -11262,6 +11418,54 @@ function getOpenTUILib(libPath) {
     bufferDrawChar: {
       args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u32"],
       returns: "void"
+    },
+    createNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    attachNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    destroyNativeSpanFeed: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    streamWrite: {
+      args: ["ptr", "ptr", "u64"],
+      returns: "i32"
+    },
+    streamCommit: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamDrainSpans: {
+      args: ["ptr", "ptr", "u32"],
+      returns: "u32"
+    },
+    streamClose: {
+      args: ["ptr"],
+      returns: "i32"
+    },
+    streamReserve: {
+      args: ["ptr", "u32", "ptr"],
+      returns: "i32"
+    },
+    streamCommitReserved: {
+      args: ["ptr", "u32"],
+      returns: "i32"
+    },
+    streamSetOptions: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamGetStats: {
+      args: ["ptr", "ptr"],
+      returns: "i32"
+    },
+    streamSetCallback: {
+      args: ["ptr", "ptr"],
+      returns: "void"
     }
   });
   if (env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) {
@@ -11427,6 +11631,8 @@ class FFIRenderLib {
   eventCallbackWrapper;
   _nativeEvents = new EventEmitter5;
   _anyEventHandlers = [];
+  nativeSpanFeedCallbackWrapper = null;
+  nativeSpanFeedHandlers = new Map;
   constructor(libPath) {
     this.opentui = getOpenTUILib(libPath);
     this.setupLogging();
@@ -11516,6 +11722,25 @@ class FFIRenderLib {
     }
     this.setEventCallback(eventCallback.ptr);
   }
+  ensureNativeSpanFeedCallback() {
+    if (this.nativeSpanFeedCallbackWrapper) {
+      return this.nativeSpanFeedCallbackWrapper;
+    }
+    const callback = new JSCallback((streamPtr, eventId, arg0, arg1) => {
+      const handler = this.nativeSpanFeedHandlers.get(toPointer(streamPtr));
+      if (handler) {
+        handler(eventId, arg0, arg1);
+      }
+    }, {
+      args: ["ptr", "u32", "ptr", "u64"],
+      returns: "void"
+    });
+    this.nativeSpanFeedCallbackWrapper = callback;
+    if (!callback.ptr) {
+      throw new Error("Failed to create native span feed callback");
+    }
+    return callback;
+  }
   setEventCallback(callbackPtr) {
     this.opentui.symbols.setEventCallback(callbackPtr);
   }
@@ -11683,10 +11908,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);
   }
@@ -11694,20 +11915,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);
   }
@@ -12547,6 +12770,73 @@ class FFIRenderLib {
   bufferDrawChar(buffer, char, x, y, fg2, bg2, attributes = 0) {
     this.opentui.symbols.bufferDrawChar(buffer, char, x, y, fg2.buffer, bg2.buffer, attributes);
   }
+  registerNativeSpanFeedStream(stream, handler) {
+    const callback = this.ensureNativeSpanFeedCallback();
+    this.nativeSpanFeedHandlers.set(toPointer(stream), handler);
+    this.opentui.symbols.streamSetCallback(stream, callback.ptr);
+  }
+  unregisterNativeSpanFeedStream(stream) {
+    this.opentui.symbols.streamSetCallback(stream, null);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  createNativeSpanFeed(options) {
+    const optionsBuffer = options == null ? null : NativeSpanFeedOptionsStruct.pack(options);
+    const streamPtr = this.opentui.symbols.createNativeSpanFeed(optionsBuffer ? ptr4(optionsBuffer) : null);
+    if (!streamPtr) {
+      throw new Error("Failed to create stream");
+    }
+    return toPointer(streamPtr);
+  }
+  attachNativeSpanFeed(stream) {
+    return this.opentui.symbols.attachNativeSpanFeed(stream);
+  }
+  destroyNativeSpanFeed(stream) {
+    this.opentui.symbols.destroyNativeSpanFeed(stream);
+    this.nativeSpanFeedHandlers.delete(toPointer(stream));
+  }
+  streamWrite(stream, data) {
+    const bytes = typeof data === "string" ? this.encoder.encode(data) : data;
+    return this.opentui.symbols.streamWrite(stream, ptr4(bytes), bytes.length);
+  }
+  streamCommit(stream) {
+    return this.opentui.symbols.streamCommit(stream);
+  }
+  streamDrainSpans(stream, outBuffer, maxSpans) {
+    const count = this.opentui.symbols.streamDrainSpans(stream, ptr4(outBuffer), maxSpans);
+    return toNumber(count);
+  }
+  streamClose(stream) {
+    return this.opentui.symbols.streamClose(stream);
+  }
+  streamSetOptions(stream, options) {
+    const optionsBuffer = NativeSpanFeedOptionsStruct.pack(options);
+    return this.opentui.symbols.streamSetOptions(stream, ptr4(optionsBuffer));
+  }
+  streamGetStats(stream) {
+    const statsBuffer = new ArrayBuffer(NativeSpanFeedStatsStruct.size);
+    const status = this.opentui.symbols.streamGetStats(stream, ptr4(statsBuffer));
+    if (status !== 0) {
+      return null;
+    }
+    const stats = NativeSpanFeedStatsStruct.unpack(statsBuffer);
+    return {
+      bytesWritten: typeof stats.bytesWritten === "bigint" ? stats.bytesWritten : BigInt(stats.bytesWritten),
+      spansCommitted: typeof stats.spansCommitted === "bigint" ? stats.spansCommitted : BigInt(stats.spansCommitted),
+      chunks: stats.chunks,
+      pendingSpans: stats.pendingSpans
+    };
+  }
+  streamReserve(stream, minLen) {
+    const reserveBuffer = new ArrayBuffer(ReserveInfoStruct.size);
+    const status = this.opentui.symbols.streamReserve(stream, minLen, ptr4(reserveBuffer));
+    if (status !== 0) {
+      return { status, info: null };
+    }
+    return { status, info: ReserveInfoStruct.unpack(reserveBuffer) };
+  }
+  streamCommitReserved(stream, length) {
+    return this.opentui.symbols.streamCommitReserved(stream, length);
+  }
   createSyntaxStyle() {
     const stylePtr = this.opentui.symbols.createSyntaxStyle();
     if (!stylePtr) {
@@ -15826,6 +16116,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;
@@ -16410,127 +16701,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.focused ? 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)
@@ -16565,6 +16864,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);
   }
@@ -16707,11 +17010,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) {
@@ -16721,10 +17024,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) {
@@ -17199,7 +17502,7 @@ 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, TextBuffer, 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, 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, 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=349D815F1273207064756E2164756E21
-//# sourceMappingURL=index-zrvzvh6r.js.map
+//# debugId=130B8D293012A10764756E2164756E21
+//# sourceMappingURL=index-vnvba6q9.js.map