@opentui/core 0.1.14 → 0.1.15

package/{index-rv93tneq.js → index-sw194bbj.js}

@@ -3867,7 +3867,7 @@ function renderFontToFrameBuffer(buffer, {
             if (renderX >= 0 && renderX < width) {
               const fontChar = segment.text[charIdx];
               if (fontChar !== " ") {
-                buffer.setCell(renderX, renderY, fontChar, segmentColor, bg);
+                buffer.setCellWithAlphaBlending(renderX, renderY, fontChar, segmentColor, bg);
               }
             }
           }
@@ -3942,44 +3942,23 @@ var textEncoder = new TextEncoder;
 
 class StyledText {
   chunks;
-  _plainText = "";
   constructor(chunks) {
     this.chunks = chunks;
-    for (let i = 0;i < chunks.length; i++) {
-      this._plainText += chunks[i].plainText;
-    }
-  }
-  toString() {
-    return this._plainText;
   }
-  static _createInstance(chunks, plainText) {
+  static _createInstance(chunks) {
     const newInstance = Object.create(StyledText.prototype);
     newInstance.chunks = chunks;
-    newInstance._plainText = plainText;
     return newInstance;
   }
-  static _chunksToPlainText(chunks) {
-    let plainText = "";
-    for (const chunk of chunks) {
-      plainText += chunk.plainText;
-    }
-    return plainText;
-  }
   insert(chunk, index) {
     const originalLength = this.chunks.length;
     let newChunks;
-    let newPlainText;
-    if (index === undefined) {
-      newChunks = [...this.chunks, chunk];
-      newPlainText = this._plainText + chunk.plainText;
-    } else if (index === originalLength) {
+    if (index === undefined || index === originalLength) {
       newChunks = [...this.chunks, chunk];
-      newPlainText = this._plainText + chunk.plainText;
     } else {
       newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index)];
-      newPlainText = StyledText._chunksToPlainText(newChunks);
     }
-    return StyledText._createInstance(newChunks, newPlainText);
+    return StyledText._createInstance(newChunks);
   }
   remove(chunk) {
     const originalLength = this.chunks.length;
@@ -3987,30 +3966,24 @@ class StyledText {
     if (index === -1)
       return this;
     let newChunks;
-    let newPlainText;
     if (index === originalLength - 1) {
       newChunks = this.chunks.slice(0, -1);
-      newPlainText = this._plainText.slice(0, this._plainText.length - chunk.plainText.length);
     } else {
       newChunks = [...this.chunks.slice(0, index), ...this.chunks.slice(index + 1)];
-      newPlainText = StyledText._chunksToPlainText(newChunks);
     }
-    return StyledText._createInstance(newChunks, newPlainText);
+    return StyledText._createInstance(newChunks);
   }
   replace(chunk, oldChunk) {
     const index = this.chunks.indexOf(oldChunk);
     if (index === -1)
       return this;
     let newChunks;
-    let newPlainText;
     if (index === this.chunks.length - 1) {
       newChunks = [...this.chunks.slice(0, -1), chunk];
-      newPlainText = this._plainText.slice(0, this._plainText.length - oldChunk.plainText.length) + chunk.plainText;
     } else {
       newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index + 1)];
-      newPlainText = StyledText._chunksToPlainText(newChunks);
     }
-    return StyledText._createInstance(newChunks, newPlainText);
+    return StyledText._createInstance(newChunks);
   }
 }
 function stringToStyledText(content) {
@@ -4089,8 +4062,6 @@ var fg = (color) => (input) => applyStyle(input, { fg: color });
 var bg = (color) => (input) => applyStyle(input, { bg: color });
 function tn(strings, ...values) {
   const chunks = [];
-  let length = 0;
-  let plainText = "";
   for (let i = 0;i < strings.length; i++) {
     const raw = strings[i];
     if (raw) {
@@ -4100,14 +4071,10 @@ function tn(strings, ...values) {
         plainText: raw,
         attributes: 0
       });
-      length += raw.length;
-      plainText += raw;
     }
     const val = values[i];
     if (typeof val === "object" && "__isChunk" in val) {
       chunks.push(val);
-      length += val.plainText.length;
-      plainText += val.plainText;
     } else if (val !== undefined) {
       const plainTextStr = String(val);
       chunks.push({
@@ -4116,16 +4083,12 @@ function tn(strings, ...values) {
         plainText: plainTextStr,
         attributes: 0
       });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
     }
   }
   return new StyledText(chunks);
 }
 function t(strings, ...values) {
   let cachedStringChunks = templateCache.get(strings);
-  let length = 0;
-  let plainText = "";
   if (!cachedStringChunks) {
     cachedStringChunks = [];
     for (let i = 0;i < strings.length; i++) {
@@ -4148,14 +4111,10 @@ function t(strings, ...values) {
     const stringChunk = cachedStringChunks[i];
     if (stringChunk) {
       chunks.push(stringChunk);
-      length += stringChunk.plainText.length;
-      plainText += stringChunk.plainText;
     }
     const val = values[i];
     if (typeof val === "object" && "__isChunk" in val) {
       chunks.push(val);
-      length += val.plainText.length;
-      plainText += val.plainText;
     } else if (val !== undefined) {
       const plainTextStr = String(val);
       chunks.push({
@@ -4164,8 +4123,6 @@ function t(strings, ...values) {
         plainText: plainTextStr,
         attributes: 0
       });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
     }
   }
   return new StyledText(chunks);
@@ -4478,10 +4435,10 @@ function parseWrap(value) {
 class MouseParser {
   mouseButtonsPressed = new Set;
   static SCROLL_DIRECTIONS = {
-    64: "up",
-    65: "down",
-    66: "left",
-    67: "right"
+    0: "up",
+    1: "down",
+    2: "left",
+    3: "right"
   };
   reset() {
     this.mouseButtonsPressed.clear();
@@ -4492,9 +4449,9 @@ class MouseParser {
     if (sgrMatch) {
       const [, buttonCode, x, y, pressRelease] = sgrMatch;
       const rawButtonCode = parseInt(buttonCode);
-      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[rawButtonCode];
-      const isScroll = scrollDirection !== undefined;
       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,
@@ -4539,9 +4496,9 @@ class MouseParser {
       const buttonByte = str.charCodeAt(3) - 32;
       const x = str.charCodeAt(4) - 33;
       const y = str.charCodeAt(5) - 33;
-      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[buttonByte];
-      const isScroll = scrollDirection !== undefined;
       const button = buttonByte & 3;
+      const isScroll = (buttonByte & 64) !== 0;
+      const scrollDirection = !isScroll ? undefined : MouseParser.SCROLL_DIRECTIONS[button];
       const modifiers = {
         shift: (buttonByte & 4) !== 0,
         alt: (buttonByte & 8) !== 0,
@@ -4575,31 +4532,89 @@ class MouseParser {
 }
 
 // src/lib/selection.ts
+class SelectionAnchor {
+  renderable;
+  relativeX;
+  relativeY;
+  constructor(renderable, absoluteX, absoluteY) {
+    this.renderable = renderable;
+    this.relativeX = absoluteX - this.renderable.x;
+    this.relativeY = absoluteY - this.renderable.y;
+  }
+  get x() {
+    return this.renderable.x + this.relativeX;
+  }
+  get y() {
+    return this.renderable.y + this.relativeY;
+  }
+}
+
 class Selection {
   _anchor;
-  _focus;
+  _originalFocus;
+  _normalizedAnchor;
+  _normalizedFocus;
   _selectedRenderables = [];
-  constructor(anchor, focus) {
-    this._anchor = { ...anchor };
-    this._focus = { ...focus };
+  _touchedRenderables = [];
+  _isActive = true;
+  _isSelecting = true;
+  constructor(anchorRenderable, anchor, focus) {
+    this._anchor = new SelectionAnchor(anchorRenderable, anchor.x, anchor.y);
+    this._originalFocus = { ...focus };
+    this._updateNormalizedSelection();
   }
   get anchor() {
-    return { ...this._anchor };
+    return { ...this._normalizedAnchor };
   }
   get focus() {
-    return { ...this._focus };
+    return { ...this._normalizedFocus };
+  }
+  set focus(value) {
+    this._originalFocus = { ...value };
+    this._updateNormalizedSelection();
+  }
+  _updateNormalizedSelection() {
+    const anchorBeforeFocus = this._anchor.y < this._originalFocus.y || this._anchor.y === this._originalFocus.y && this._anchor.x <= this._originalFocus.x;
+    if (anchorBeforeFocus) {
+      this._normalizedAnchor = { x: this._anchor.x, y: this._anchor.y };
+      this._normalizedFocus = { ...this._originalFocus };
+    } else {
+      this._normalizedAnchor = { ...this._originalFocus };
+      this._normalizedFocus = { x: this._anchor.x + 1, y: this._anchor.y };
+    }
+  }
+  get isActive() {
+    return this._isActive;
+  }
+  set isActive(value) {
+    this._isActive = value;
+  }
+  get isSelecting() {
+    return this._isSelecting;
+  }
+  set isSelecting(value) {
+    this._isSelecting = value;
   }
   get bounds() {
     return {
-      startX: Math.min(this._anchor.x, this._focus.x),
-      startY: Math.min(this._anchor.y, this._focus.y),
-      endX: Math.max(this._anchor.x, this._focus.x),
-      endY: Math.max(this._anchor.y, this._focus.y)
+      x: Math.min(this._normalizedAnchor.x, this._normalizedFocus.x),
+      y: Math.min(this._normalizedAnchor.y, this._normalizedFocus.y),
+      width: Math.max(this._normalizedAnchor.x, this._normalizedFocus.x) - Math.min(this._normalizedAnchor.x, this._normalizedFocus.x),
+      height: Math.max(this._normalizedAnchor.y, this._normalizedFocus.y) - Math.min(this._normalizedAnchor.y, this._normalizedFocus.y)
     };
   }
   updateSelectedRenderables(selectedRenderables) {
     this._selectedRenderables = selectedRenderables;
   }
+  get selectedRenderables() {
+    return this._selectedRenderables;
+  }
+  updateTouchedRenderables(touchedRenderables) {
+    this._touchedRenderables = touchedRenderables;
+  }
+  get touchedRenderables() {
+    return this._touchedRenderables;
+  }
   getSelectedText() {
     const selectedTexts = this._selectedRenderables.sort((a, b) => {
       const aY = a.y;
@@ -4613,133 +4628,24 @@ class Selection {
 `);
   }
 }
-
-class TextSelectionHelper {
-  getX;
-  getY;
-  getTextLength;
-  getLineInfo;
-  localSelection = null;
-  cachedGlobalSelection = null;
-  constructor(getX, getY, getTextLength, getLineInfo) {
-    this.getX = getX;
-    this.getY = getY;
-    this.getTextLength = getTextLength;
-    this.getLineInfo = getLineInfo;
-  }
-  hasSelection() {
-    return this.localSelection !== null;
-  }
-  getSelection() {
-    return this.localSelection;
-  }
-  reevaluateSelection(width, height = 1) {
-    if (!this.cachedGlobalSelection) {
-      return false;
-    }
-    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
-  }
-  shouldStartSelection(x, y, width, height) {
-    const localX = x - this.getX();
-    const localY = y - this.getY();
-    return localX >= 0 && localX < width && localY >= 0 && localY < height;
-  }
-  onSelectionChanged(selection, width, height = 1) {
-    this.cachedGlobalSelection = selection;
-    const previousSelection = this.localSelection;
-    if (!selection?.isActive) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    const myY = this.getY();
-    const myEndY = myY + height - 1;
-    if (myEndY < selection.anchor.y || myY > selection.focus.y) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    if (height === 1) {
-      this.localSelection = this.calculateSingleLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x, width);
-    } else {
-      this.localSelection = this.calculateMultiLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x);
-    }
-    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
-  }
-  calculateSingleLineSelection(lineY, anchorY, focusY, anchorX, focusX, width) {
-    const textLength = this.getTextLength();
-    const myX = this.getX();
-    if (lineY > anchorY && lineY < focusY) {
-      return { start: 0, end: textLength };
-    }
-    if (lineY === anchorY && lineY === focusY) {
-      const start = Math.max(0, Math.min(anchorX - myX, textLength));
-      const end = Math.max(0, Math.min(focusX - myX, textLength));
-      return start < end ? { start, end } : null;
-    }
-    if (lineY === anchorY) {
-      const start = Math.max(0, Math.min(anchorX - myX, textLength));
-      return start < textLength ? { start, end: textLength } : null;
-    }
-    if (lineY === focusY) {
-      const end = Math.max(0, Math.min(focusX - myX, textLength));
-      return end > 0 ? { start: 0, end } : null;
-    }
+function convertGlobalToLocalSelection(globalSelection, localX, localY) {
+  if (!globalSelection?.isActive) {
     return null;
   }
-  calculateMultiLineSelection(startY, anchorY, focusY, anchorX, focusX) {
-    const lineInfo = this.getLineInfo?.();
-    if (!lineInfo) {
-      return { start: 0, end: this.getTextLength() };
-    }
-    const myX = this.getX();
-    let selectionStart = null;
-    let selectionEnd = null;
-    for (let i = 0;i < lineInfo.lineStarts.length; i++) {
-      const lineY = startY + i;
-      if (lineY < anchorY || lineY > focusY)
-        continue;
-      const lineStart = lineInfo.lineStarts[i];
-      const lineEnd = i < lineInfo.lineStarts.length - 1 ? lineInfo.lineStarts[i + 1] - 1 : this.getTextLength();
-      const lineWidth = lineInfo.lineWidths[i];
-      if (lineY > anchorY && lineY < focusY) {
-        if (selectionStart === null)
-          selectionStart = lineStart;
-        selectionEnd = lineEnd;
-      } else if (lineY === anchorY && lineY === focusY) {
-        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
-        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
-        if (localStartX < localEndX) {
-          selectionStart = lineStart + localStartX;
-          selectionEnd = lineStart + localEndX;
-        }
-      } else if (lineY === anchorY) {
-        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
-        if (localStartX < lineWidth) {
-          selectionStart = lineStart + localStartX;
-          selectionEnd = lineEnd;
-        }
-      } else if (lineY === focusY) {
-        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
-        if (localEndX > 0) {
-          if (selectionStart === null)
-            selectionStart = lineStart;
-          selectionEnd = lineStart + localEndX;
-        }
-      }
-    }
-    return selectionStart !== null && selectionEnd !== null && selectionStart < selectionEnd ? { start: selectionStart, end: selectionEnd } : null;
-  }
+  return {
+    anchorX: globalSelection.anchor.x - localX,
+    anchorY: globalSelection.anchor.y - localY,
+    focusX: globalSelection.focus.x - localX,
+    focusY: globalSelection.focus.y - localY,
+    isActive: true
+  };
 }
 
 class ASCIIFontSelectionHelper {
-  getX;
-  getY;
   getText;
   getFont;
   localSelection = null;
-  cachedGlobalSelection = null;
-  constructor(getX, getY, getText, getFont) {
-    this.getX = getX;
-    this.getY = getY;
+  constructor(getText, getFont) {
     this.getText = getText;
     this.getFont = getFont;
   }
@@ -4749,9 +4655,7 @@ class ASCIIFontSelectionHelper {
   getSelection() {
     return this.localSelection;
   }
-  shouldStartSelection(x, y, width, height) {
-    const localX = x - this.getX();
-    const localY = y - this.getY();
+  shouldStartSelection(localX, localY, width, height) {
     if (localX < 0 || localX >= width || localY < 0 || localY >= height) {
       return false;
     }
@@ -4760,49 +4664,36 @@ class ASCIIFontSelectionHelper {
     const charIndex = coordinateToCharacterIndex(localX, text, font);
     return charIndex >= 0 && charIndex <= text.length;
   }
-  onSelectionChanged(selection, width, height) {
-    this.cachedGlobalSelection = selection;
+  onLocalSelectionChanged(localSelection, width, height) {
     const previousSelection = this.localSelection;
-    if (!selection?.isActive) {
+    if (!localSelection?.isActive) {
       this.localSelection = null;
       return previousSelection !== null;
     }
-    const myX = this.getX();
-    const myY = this.getY();
-    const myEndY = myY + height - 1;
     const text = this.getText();
     const font = this.getFont();
-    let selStart;
-    let selEnd;
-    if (selection.anchor.y < selection.focus.y || selection.anchor.y === selection.focus.y && selection.anchor.x <= selection.focus.x) {
-      selStart = selection.anchor;
-      selEnd = selection.focus;
-    } else {
-      selStart = selection.focus;
-      selEnd = selection.anchor;
-    }
-    if (myEndY < selStart.y || myY > selEnd.y) {
+    const selStart = { x: localSelection.anchorX, y: localSelection.anchorY };
+    const selEnd = { x: localSelection.focusX, y: localSelection.focusY };
+    if (height - 1 < selStart.y || 0 > selEnd.y) {
       this.localSelection = null;
       return previousSelection !== null;
     }
     let startCharIndex = 0;
     let endCharIndex = text.length;
-    if (selStart.y > myEndY) {
+    if (selStart.y > height - 1) {
       this.localSelection = null;
       return previousSelection !== null;
-    } else if (selStart.y >= myY && selStart.y <= myEndY) {
-      const localX = selStart.x - myX;
-      if (localX > 0) {
-        startCharIndex = coordinateToCharacterIndex(localX, text, font);
+    } else if (selStart.y >= 0 && selStart.y <= height - 1) {
+      if (selStart.x > 0) {
+        startCharIndex = coordinateToCharacterIndex(selStart.x, text, font);
       }
     }
-    if (selEnd.y < myY) {
+    if (selEnd.y < 0) {
       this.localSelection = null;
       return previousSelection !== null;
-    } else if (selEnd.y >= myY && selEnd.y <= myEndY) {
-      const localX = selEnd.x - myX;
-      if (localX >= 0) {
-        endCharIndex = coordinateToCharacterIndex(localX, text, font);
+    } else if (selEnd.y >= 0 && selEnd.y <= height - 1) {
+      if (selEnd.x >= 0) {
+        endCharIndex = coordinateToCharacterIndex(selEnd.x, text, font);
       } else {
         endCharIndex = 0;
       }
@@ -4812,23 +4703,15 @@ class ASCIIFontSelectionHelper {
     } else {
       this.localSelection = null;
     }
-    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
-  }
-  reevaluateSelection(width, height) {
-    if (!this.cachedGlobalSelection) {
-      return false;
-    }
-    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
+    return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
 }
 // src/zig.ts
-import { dlopen, toArrayBuffer, JSCallback } from "bun:ffi";
+import { dlopen, toArrayBuffer as toArrayBuffer2, JSCallback, ptr } from "bun:ffi";
 import { existsSync } from "fs";
 
 // src/buffer.ts
-function isRGBAWithAlpha(color) {
-  return color.a < 1;
-}
+import { toArrayBuffer } from "bun:ffi";
 function packDrawOptions(border2, shouldFill, titleAlignment) {
   let packed = 0;
   if (border2 === true) {
@@ -4855,48 +4738,42 @@ function packDrawOptions(border2, shouldFill, titleAlignment) {
   packed |= alignment << 5;
   return packed;
 }
-function blendColors(overlay, text) {
-  const [overlayR, overlayG, overlayB, overlayA] = overlay.buffer;
-  const [textR, textG, textB, textA] = text.buffer;
-  if (overlayA === 1) {
-    return overlay;
-  }
-  const alpha = overlayA;
-  let perceptualAlpha;
-  if (alpha > 0.8) {
-    const normalizedHighAlpha = (alpha - 0.8) * 5;
-    const curvedHighAlpha = Math.pow(normalizedHighAlpha, 0.2);
-    perceptualAlpha = 0.8 + curvedHighAlpha * 0.2;
-  } else {
-    perceptualAlpha = Math.pow(alpha, 0.9);
-  }
-  const r = overlayR * perceptualAlpha + textR * (1 - perceptualAlpha);
-  const g = overlayG * perceptualAlpha + textG * (1 - perceptualAlpha);
-  const b = overlayB * perceptualAlpha + textB * (1 - perceptualAlpha);
-  return RGBA.fromValues(r, g, b, textA);
-}
 
 class OptimizedBuffer {
   static fbIdCounter = 0;
   id;
   lib;
   bufferPtr;
-  buffer;
   _width;
   _height;
   respectAlpha = false;
-  useFFI = true;
+  _rawBuffers = null;
   get ptr() {
     return this.bufferPtr;
   }
-  constructor(lib, ptr, buffer, width, height, options) {
+  get buffers() {
+    if (this._rawBuffers === null) {
+      const size = this._width * this._height;
+      const charPtr = this.lib.bufferGetCharPtr(this.bufferPtr);
+      const fgPtr = this.lib.bufferGetFgPtr(this.bufferPtr);
+      const bgPtr = this.lib.bufferGetBgPtr(this.bufferPtr);
+      const attributesPtr = this.lib.bufferGetAttributesPtr(this.bufferPtr);
+      this._rawBuffers = {
+        char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
+        fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
+        bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
+        attributes: new Uint8Array(toArrayBuffer(attributesPtr, 0, size))
+      };
+    }
+    return this._rawBuffers;
+  }
+  constructor(lib, ptr, width, height, options) {
     this.id = options.id || `fb_${OptimizedBuffer.fbIdCounter++}`;
     this.lib = lib;
     this.respectAlpha = options.respectAlpha || false;
     this._width = width;
     this._height = height;
     this.bufferPtr = ptr;
-    this.buffer = buffer;
   }
   static create(width, height, widthMethod, options = {}) {
     const lib = resolveRenderLib();
@@ -4904,9 +4781,6 @@ class OptimizedBuffer {
     const id = options.id && options.id.trim() !== "" ? options.id : "unnamed buffer";
     return lib.createOptimizedBuffer(width, height, widthMethod, respectAlpha, id);
   }
-  get buffers() {
-    return this.buffer;
-  }
   coordsToIndex(x, y) {
     return y * this._width + x;
   }
@@ -4923,91 +4797,18 @@ class OptimizedBuffer {
   getNativeId() {
     return this.lib.bufferGetId(this.bufferPtr);
   }
-  clear(bg2 = RGBA.fromValues(0, 0, 0, 1), clearChar = " ") {
-    if (this.useFFI) {
-      this.clearFFI(bg2);
-    } else {
-      this.clearLocal(bg2, clearChar);
-    }
-  }
-  clearLocal(bg2 = RGBA.fromValues(0, 0, 0, 1), clearChar = " ") {
-    this.buffer.char.fill(clearChar.charCodeAt(0));
-    this.buffer.attributes.fill(0);
-    for (let i = 0;i < this._width * this._height; i++) {
-      const index = i * 4;
-      this.buffer.fg[index] = 1;
-      this.buffer.fg[index + 1] = 1;
-      this.buffer.fg[index + 2] = 1;
-      this.buffer.fg[index + 3] = 1;
-      this.buffer.bg[index] = bg2.r;
-      this.buffer.bg[index + 1] = bg2.g;
-      this.buffer.bg[index + 2] = bg2.b;
-      this.buffer.bg[index + 3] = bg2.a;
-    }
+  clear(bg2 = RGBA.fromValues(0, 0, 0, 1)) {
+    this.lib.bufferClear(this.bufferPtr, bg2);
   }
   setCell(x, y, char, fg2, bg2, attributes = 0) {
-    if (x < 0 || x >= this._width || y < 0 || y >= this._height)
-      return;
-    const index = this.coordsToIndex(x, y);
-    const colorIndex = index * 4;
-    this.buffer.char[index] = char.charCodeAt(0);
-    this.buffer.attributes[index] = attributes;
-    this.buffer.fg[colorIndex] = fg2.r;
-    this.buffer.fg[colorIndex + 1] = fg2.g;
-    this.buffer.fg[colorIndex + 2] = fg2.b;
-    this.buffer.fg[colorIndex + 3] = fg2.a;
-    this.buffer.bg[colorIndex] = bg2.r;
-    this.buffer.bg[colorIndex + 1] = bg2.g;
-    this.buffer.bg[colorIndex + 2] = bg2.b;
-    this.buffer.bg[colorIndex + 3] = bg2.a;
-  }
-  get(x, y) {
-    if (x < 0 || x >= this._width || y < 0 || y >= this._height)
-      return null;
-    const index = this.coordsToIndex(x, y);
-    const colorIndex = index * 4;
-    return {
-      char: this.buffer.char[index],
-      fg: RGBA.fromArray(this.buffer.fg.slice(colorIndex, colorIndex + 4)),
-      bg: RGBA.fromArray(this.buffer.bg.slice(colorIndex, colorIndex + 4)),
-      attributes: this.buffer.attributes[index]
-    };
+    this.lib.bufferSetCell(this.bufferPtr, x, y, char, fg2, bg2, attributes);
   }
   setCellWithAlphaBlending(x, y, char, fg2, bg2, attributes = 0) {
-    if (this.useFFI) {
-      this.setCellWithAlphaBlendingFFI(x, y, char, fg2, bg2, attributes);
-    } else {
-      this.setCellWithAlphaBlendingLocal(x, y, char, fg2, bg2, attributes);
-    }
-  }
-  setCellWithAlphaBlendingLocal(x, y, char, fg2, bg2, attributes = 0) {
-    if (x < 0 || x >= this._width || y < 0 || y >= this._height)
-      return;
-    const hasBgAlpha = isRGBAWithAlpha(bg2);
-    const hasFgAlpha = isRGBAWithAlpha(fg2);
-    if (hasBgAlpha || hasFgAlpha) {
-      const destCell = this.get(x, y);
-      if (destCell) {
-        const blendedBgRgb = hasBgAlpha ? blendColors(bg2, destCell.bg) : bg2;
-        const preserveChar = char === " " && destCell.char !== 0 && String.fromCharCode(destCell.char) !== " ";
-        const finalChar = preserveChar ? destCell.char : char.charCodeAt(0);
-        let finalFg;
-        if (preserveChar) {
-          finalFg = blendColors(bg2, destCell.fg);
-        } else {
-          finalFg = hasFgAlpha ? blendColors(fg2, destCell.bg) : fg2;
-        }
-        const finalAttributes = preserveChar ? destCell.attributes : attributes;
-        const finalBg = RGBA.fromValues(blendedBgRgb.r, blendedBgRgb.g, blendedBgRgb.b, bg2.a);
-        this.setCell(x, y, String.fromCharCode(finalChar), finalFg, finalBg, finalAttributes);
-        return;
-      }
-    }
-    this.setCell(x, y, char, fg2, bg2, attributes);
+    this.lib.bufferSetCellWithAlphaBlending(this.bufferPtr, x, y, char, fg2, bg2, attributes);
   }
   drawText(text, x, y, fg2, bg2, attributes = 0, selection2) {
     if (!selection2) {
-      this.drawTextFFI.call(this, text, x, y, fg2, bg2, attributes);
+      this.lib.bufferDrawText(this.bufferPtr, text, x, y, fg2, bg2, attributes);
       return;
     }
     const { start, end } = selection2;
@@ -5023,123 +4824,22 @@ class OptimizedBuffer {
     }
     if (start > 0) {
       const beforeText = text.slice(0, start);
-      this.drawTextFFI.call(this, beforeText, x, y, fg2, bg2, attributes);
+      this.lib.bufferDrawText(this.bufferPtr, beforeText, x, y, fg2, bg2, attributes);
     }
     if (end > start) {
       const selectedText = text.slice(start, end);
-      this.drawTextFFI.call(this, selectedText, x + start, y, selectionFg, selectionBg, attributes);
+      this.lib.bufferDrawText(this.bufferPtr, selectedText, x + start, y, selectionFg, selectionBg, attributes);
     }
     if (end < text.length) {
       const afterText = text.slice(end);
-      this.drawTextFFI.call(this, afterText, x + end, y, fg2, bg2, attributes);
+      this.lib.bufferDrawText(this.bufferPtr, afterText, x + end, y, fg2, bg2, attributes);
     }
   }
   fillRect(x, y, width, height, bg2) {
-    if (this.useFFI) {
-      this.fillRectFFI(x, y, width, height, bg2);
-    } else {
-      this.fillRectLocal(x, y, width, height, bg2);
-    }
-  }
-  fillRectLocal(x, y, width, height, bg2) {
-    const startX = Math.max(0, x);
-    const startY = Math.max(0, y);
-    const endX = Math.min(this.width - 1, x + width - 1);
-    const endY = Math.min(this.height - 1, y + height - 1);
-    if (startX > endX || startY > endY)
-      return;
-    const hasAlpha = isRGBAWithAlpha(bg2);
-    if (hasAlpha) {
-      const fg2 = RGBA.fromValues(1, 1, 1, 1);
-      for (let fillY = startY;fillY <= endY; fillY++) {
-        for (let fillX = startX;fillX <= endX; fillX++) {
-          this.setCellWithAlphaBlending(fillX, fillY, " ", fg2, bg2, 0);
-        }
-      }
-    } else {
-      for (let fillY = startY;fillY <= endY; fillY++) {
-        for (let fillX = startX;fillX <= endX; fillX++) {
-          const index = this.coordsToIndex(fillX, fillY);
-          const colorIndex = index * 4;
-          this.buffer.char[index] = 32;
-          this.buffer.attributes[index] = 0;
-          this.buffer.fg[colorIndex] = 1;
-          this.buffer.fg[colorIndex + 1] = 1;
-          this.buffer.fg[colorIndex + 2] = 1;
-          this.buffer.fg[colorIndex + 3] = 1;
-          this.buffer.bg[colorIndex] = bg2.r;
-          this.buffer.bg[colorIndex + 1] = bg2.g;
-          this.buffer.bg[colorIndex + 2] = bg2.b;
-          this.buffer.bg[colorIndex + 3] = bg2.a;
-        }
-      }
-    }
+    this.lib.bufferFillRect(this.bufferPtr, x, y, width, height, bg2);
   }
   drawFrameBuffer(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
-    this.drawFrameBufferFFI(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight);
-  }
-  drawFrameBufferLocal(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
-    const srcX = sourceX ?? 0;
-    const srcY = sourceY ?? 0;
-    const srcWidth = sourceWidth ?? frameBuffer.width;
-    const srcHeight = sourceHeight ?? frameBuffer.height;
-    if (srcX >= frameBuffer.width || srcY >= frameBuffer.height)
-      return;
-    if (srcWidth === 0 || srcHeight === 0)
-      return;
-    const clampedSrcWidth = Math.min(srcWidth, frameBuffer.width - srcX);
-    const clampedSrcHeight = Math.min(srcHeight, frameBuffer.height - srcY);
-    const startDestX = Math.max(0, destX);
-    const startDestY = Math.max(0, destY);
-    const endDestX = Math.min(this._width - 1, destX + clampedSrcWidth - 1);
-    const endDestY = Math.min(this._height - 1, destY + clampedSrcHeight - 1);
-    if (!frameBuffer.respectAlpha) {
-      for (let dY = startDestY;dY <= endDestY; dY++) {
-        for (let dX = startDestX;dX <= endDestX; dX++) {
-          const relativeDestX = dX - destX;
-          const relativeDestY = dY - destY;
-          const sX = srcX + relativeDestX;
-          const sY = srcY + relativeDestY;
-          if (sX >= frameBuffer.width || sY >= frameBuffer.height)
-            continue;
-          const destIndex = this.coordsToIndex(dX, dY);
-          const srcIndex = frameBuffer.coordsToIndex(sX, sY);
-          const destColorIndex = destIndex * 4;
-          const srcColorIndex = srcIndex * 4;
-          this.buffer.char[destIndex] = frameBuffer.buffer.char[srcIndex];
-          this.buffer.attributes[destIndex] = frameBuffer.buffer.attributes[srcIndex];
-          this.buffer.fg[destColorIndex] = frameBuffer.buffer.fg[srcColorIndex];
-          this.buffer.fg[destColorIndex + 1] = frameBuffer.buffer.fg[srcColorIndex + 1];
-          this.buffer.fg[destColorIndex + 2] = frameBuffer.buffer.fg[srcColorIndex + 2];
-          this.buffer.fg[destColorIndex + 3] = frameBuffer.buffer.fg[srcColorIndex + 3];
-          this.buffer.bg[destColorIndex] = frameBuffer.buffer.bg[srcColorIndex];
-          this.buffer.bg[destColorIndex + 1] = frameBuffer.buffer.bg[srcColorIndex + 1];
-          this.buffer.bg[destColorIndex + 2] = frameBuffer.buffer.bg[srcColorIndex + 2];
-          this.buffer.bg[destColorIndex + 3] = frameBuffer.buffer.bg[srcColorIndex + 3];
-        }
-      }
-      return;
-    }
-    for (let dY = startDestY;dY <= endDestY; dY++) {
-      for (let dX = startDestX;dX <= endDestX; dX++) {
-        const relativeDestX = dX - destX;
-        const relativeDestY = dY - destY;
-        const sX = srcX + relativeDestX;
-        const sY = srcY + relativeDestY;
-        if (sX >= frameBuffer.width || sY >= frameBuffer.height)
-          continue;
-        const srcIndex = frameBuffer.coordsToIndex(sX, sY);
-        const srcColorIndex = srcIndex * 4;
-        if (frameBuffer.buffer.bg[srcColorIndex + 3] === 0 && frameBuffer.buffer.fg[srcColorIndex + 3] === 0) {
-          continue;
-        }
-        const charCode = frameBuffer.buffer.char[srcIndex];
-        const fg2 = RGBA.fromArray(frameBuffer.buffer.fg.slice(srcColorIndex, srcColorIndex + 4));
-        const bg2 = RGBA.fromArray(frameBuffer.buffer.bg.slice(srcColorIndex, srcColorIndex + 4));
-        const attributes = frameBuffer.buffer.attributes[srcIndex];
-        this.setCellWithAlphaBlending(dX, dY, String.fromCharCode(charCode), fg2, bg2, attributes);
-      }
-    }
+    this.lib.drawFrameBuffer(this.bufferPtr, destX, destY, frameBuffer.ptr, sourceX, sourceY, sourceWidth, sourceHeight);
   }
   destroy() {
     this.lib.destroyOptimizedBuffer(this.bufferPtr);
@@ -5148,35 +4848,18 @@ class OptimizedBuffer {
     this.lib.bufferDrawTextBuffer(this.bufferPtr, textBuffer.ptr, x, y, clipRect);
   }
   drawSuperSampleBuffer(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
-    this.drawSuperSampleBufferFFI(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow);
-  }
-  drawSuperSampleBufferFFI(x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
     this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow);
   }
   drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.lib.bufferDrawPackedBuffer(this.bufferPtr, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
-  setCellWithAlphaBlendingFFI(x, y, char, fg2, bg2, attributes) {
-    this.lib.bufferSetCellWithAlphaBlending(this.bufferPtr, x, y, char, fg2, bg2, attributes);
-  }
-  fillRectFFI(x, y, width, height, bg2) {
-    this.lib.bufferFillRect(this.bufferPtr, x, y, width, height, bg2);
-  }
   resize(width, height) {
     if (this._width === width && this._height === height)
       return;
     this._width = width;
     this._height = height;
-    this.buffer = this.lib.bufferResize(this.bufferPtr, width, height);
-  }
-  clearFFI(bg2 = RGBA.fromValues(0, 0, 0, 1)) {
-    this.lib.bufferClear(this.bufferPtr, bg2);
-  }
-  drawTextFFI(text, x, y, fg2 = RGBA.fromValues(1, 1, 1, 1), bg2, attributes = 0) {
-    this.lib.bufferDrawText(this.bufferPtr, text, x, y, fg2, bg2, attributes);
-  }
-  drawFrameBufferFFI(destX, destY, frameBuffer, sourceX, sourceY, sourceWidth, sourceHeight) {
-    this.lib.drawFrameBuffer(this.bufferPtr, destX, destY, frameBuffer.ptr, sourceX, sourceY, sourceWidth, sourceHeight);
+    this._rawBuffers = null;
+    this.lib.bufferResize(this.bufferPtr, width, height);
   }
   drawBox(options) {
     const style = options.borderStyle || "single";
@@ -5308,6 +4991,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
       returns: "void"
     },
+    bufferSetCell: {
+      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
+      returns: "void"
+    },
     bufferFillRect: {
       args: ["ptr", "u32", "u32", "u32", "u32", "ptr"],
       returns: "void"
@@ -5420,30 +5107,10 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "ptr"
     },
-    textBufferGetFgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetBgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetAttributesPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
     textBufferGetLength: {
       args: ["ptr"],
       returns: "u32"
     },
-    textBufferSetCell: {
-      args: ["ptr", "u32", "u32", "ptr", "ptr", "u16"],
-      returns: "void"
-    },
-    textBufferConcat: {
-      args: ["ptr", "ptr"],
-      returns: "ptr"
-    },
     textBufferResize: {
       args: ["ptr", "u32"],
       returns: "void"
@@ -5488,17 +5155,29 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
-    textBufferGetLineStartsPtr: {
+    textBufferGetLineCount: {
       args: ["ptr"],
-      returns: "ptr"
+      returns: "u32"
+    },
+    textBufferGetLineInfoDirect: {
+      args: ["ptr", "ptr", "ptr"],
+      returns: "void"
     },
-    textBufferGetLineWidthsPtr: {
+    textBufferGetSelectionInfo: {
       args: ["ptr"],
-      returns: "ptr"
+      returns: "u64"
     },
-    textBufferGetLineCount: {
+    textBufferGetSelectedText: {
+      args: ["ptr", "ptr", "usize"],
+      returns: "usize"
+    },
+    textBufferSetLocalSelection: {
+      args: ["ptr", "i32", "i32", "i32", "i32", "ptr", "ptr"],
+      returns: "bool"
+    },
+    textBufferResetLocalSelection: {
       args: ["ptr"],
-      returns: "u32"
+      returns: "void"
     },
     bufferDrawTextBuffer: {
       args: ["ptr", "ptr", "i32", "i32", "i32", "i32", "u32", "u32", "bool"],
@@ -5541,7 +5220,7 @@ class FFIRenderLib {
         if (msgLen === 0 || !msgPtr) {
           return;
         }
-        const msgBuffer = toArrayBuffer(msgPtr, 0, msgLen);
+        const msgBuffer = toArrayBuffer2(msgPtr, 0, msgLen);
         const msgBytes = new Uint8Array(msgBuffer);
         const message = this.decoder.decode(msgBytes);
         switch (level) {
@@ -5604,9 +5283,7 @@ class FFIRenderLib {
     }
     const width = this.opentui.symbols.getBufferWidth(bufferPtr);
     const height = this.opentui.symbols.getBufferHeight(bufferPtr);
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, { id: "next buffer" });
+    return new OptimizedBuffer(this, bufferPtr, width, height, { id: "next buffer" });
   }
   getCurrentBuffer(renderer) {
     const bufferPtr = this.opentui.symbols.getCurrentBuffer(renderer);
@@ -5615,41 +5292,7 @@ class FFIRenderLib {
     }
     const width = this.opentui.symbols.getBufferWidth(bufferPtr);
     const height = this.opentui.symbols.getBufferHeight(bufferPtr);
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, { id: "current buffer" });
-  }
-  getBuffer(bufferPtr, size) {
-    const charPtr = this.opentui.symbols.bufferGetCharPtr(bufferPtr);
-    const fgPtr = this.opentui.symbols.bufferGetFgPtr(bufferPtr);
-    const bgPtr = this.opentui.symbols.bufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.opentui.symbols.bufferGetAttributesPtr(bufferPtr);
-    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
-      throw new Error("Failed to get buffer pointers");
-    }
-    const buffers = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-      attributes: new Uint8Array(toArrayBuffer(attributesPtr, 0, size))
-    };
-    return buffers;
-  }
-  getTextBuffer(bufferPtr, size) {
-    const charPtr = this.opentui.symbols.textBufferGetCharPtr(bufferPtr);
-    const fgPtr = this.opentui.symbols.textBufferGetFgPtr(bufferPtr);
-    const bgPtr = this.opentui.symbols.textBufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.opentui.symbols.textBufferGetAttributesPtr(bufferPtr);
-    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
-      throw new Error("Failed to get text buffer pointers");
-    }
-    const buffers = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, size * 2))
-    };
-    return buffers;
+    return new OptimizedBuffer(this, bufferPtr, width, height, { id: "current buffer" });
   }
   bufferGetCharPtr(buffer) {
     const ptr2 = this.opentui.symbols.bufferGetCharPtr(buffer);
@@ -5714,6 +5357,12 @@ class FFIRenderLib {
     const fg2 = color.buffer;
     this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x, y, charPtr, fg2, bg2, attributes ?? 0);
   }
+  bufferSetCell(buffer, x, y, char, color, bgColor, attributes) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
+    const bg2 = bgColor.buffer;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferSetCell(buffer, x, y, charPtr, fg2, bg2, attributes ?? 0);
+  }
   bufferFillRect(buffer, x, y, width, height, color) {
     const bg2 = color.buffer;
     this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg2);
@@ -5733,8 +5382,6 @@ class FFIRenderLib {
   }
   bufferResize(buffer, width, height) {
     this.opentui.symbols.bufferResize(buffer, width, height);
-    const buffers = this.getBuffer(buffer, width * height);
-    return buffers;
   }
   resizeRenderer(renderer, width, height) {
     this.opentui.symbols.resizeRenderer(renderer, width, height);
@@ -5763,9 +5410,7 @@ class FFIRenderLib {
     if (!bufferPtr) {
       throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
     }
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, { respectAlpha, id });
+    return new OptimizedBuffer(this, bufferPtr, width, height, { respectAlpha, id });
   }
   destroyOptimizedBuffer(bufferPtr) {
     this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
@@ -5825,17 +5470,7 @@ class FFIRenderLib {
     if (!bufferPtr) {
       throw new Error(`Failed to create TextBuffer with capacity ${capacity}`);
     }
-    const charPtr = this.textBufferGetCharPtr(bufferPtr);
-    const fgPtr = this.textBufferGetFgPtr(bufferPtr);
-    const bgPtr = this.textBufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.textBufferGetAttributesPtr(bufferPtr);
-    const buffer = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, capacity * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, capacity * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, capacity * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, capacity * 2))
-    };
-    return new TextBuffer(this, bufferPtr, buffer, capacity);
+    return new TextBuffer(this, bufferPtr, capacity);
   }
   destroyTextBuffer(buffer) {
     this.opentui.symbols.destroyTextBuffer(buffer);
@@ -5847,55 +5482,11 @@ class FFIRenderLib {
     }
     return ptr2;
   }
-  textBufferGetFgPtr(buffer) {
-    const ptr2 = this.opentui.symbols.textBufferGetFgPtr(buffer);
-    if (!ptr2) {
-      throw new Error("Failed to get TextBuffer fg pointer");
-    }
-    return ptr2;
-  }
-  textBufferGetBgPtr(buffer) {
-    const ptr2 = this.opentui.symbols.textBufferGetBgPtr(buffer);
-    if (!ptr2) {
-      throw new Error("Failed to get TextBuffer bg pointer");
-    }
-    return ptr2;
-  }
-  textBufferGetAttributesPtr(buffer) {
-    const ptr2 = this.opentui.symbols.textBufferGetAttributesPtr(buffer);
-    if (!ptr2) {
-      throw new Error("Failed to get TextBuffer attributes pointer");
-    }
-    return ptr2;
-  }
   textBufferGetLength(buffer) {
     return this.opentui.symbols.textBufferGetLength(buffer);
   }
-  textBufferSetCell(buffer, index, char, fg2, bg2, attr) {
-    this.opentui.symbols.textBufferSetCell(buffer, index, char, fg2, bg2, attr);
-  }
-  textBufferConcat(buffer1, buffer2) {
-    const resultPtr = this.opentui.symbols.textBufferConcat(buffer1, buffer2);
-    if (!resultPtr) {
-      throw new Error("Failed to concatenate TextBuffers");
-    }
-    const length = this.textBufferGetLength(resultPtr);
-    const charPtr = this.textBufferGetCharPtr(resultPtr);
-    const fgPtr = this.textBufferGetFgPtr(resultPtr);
-    const bgPtr = this.textBufferGetBgPtr(resultPtr);
-    const attributesPtr = this.textBufferGetAttributesPtr(resultPtr);
-    const buffer = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, length * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, length * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, length * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, length * 2))
-    };
-    return new TextBuffer(this, resultPtr, buffer, length);
-  }
   textBufferResize(buffer, newLength) {
     this.opentui.symbols.textBufferResize(buffer, newLength);
-    const buffers = this.getTextBuffer(buffer, newLength);
-    return buffers;
   }
   textBufferReset(buffer) {
     this.opentui.symbols.textBufferReset(buffer);
@@ -5933,24 +5524,56 @@ class FFIRenderLib {
   textBufferFinalizeLineInfo(buffer) {
     this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
   }
+  textBufferGetLineCount(buffer) {
+    return this.opentui.symbols.textBufferGetLineCount(buffer);
+  }
+  textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr) {
+    this.opentui.symbols.textBufferGetLineInfoDirect(buffer, lineStartsPtr, lineWidthsPtr);
+  }
+  textBufferGetSelection(buffer) {
+    const packedInfo = this.textBufferGetSelectionInfo(buffer);
+    if (packedInfo === 0xffff_ffff_ffff_ffffn) {
+      return null;
+    }
+    const start = Number(packedInfo >> 32n);
+    const end = Number(packedInfo & 0xffff_ffffn);
+    return { start, end };
+  }
+  textBufferGetSelectionInfo(buffer) {
+    return this.opentui.symbols.textBufferGetSelectionInfo(buffer);
+  }
+  textBufferGetSelectedText(buffer, outPtr, maxLen) {
+    const result = this.opentui.symbols.textBufferGetSelectedText(buffer, outPtr, maxLen);
+    return typeof result === "bigint" ? Number(result) : result;
+  }
+  getSelectedTextBytes(buffer, maxLength) {
+    const outBuffer = new Uint8Array(maxLength);
+    const actualLen = this.textBufferGetSelectedText(buffer, ptr(outBuffer), maxLength);
+    if (actualLen === 0) {
+      return null;
+    }
+    return outBuffer.slice(0, actualLen);
+  }
+  textBufferSetLocalSelection(buffer, anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    return this.opentui.symbols.textBufferSetLocalSelection(buffer, anchorX, anchorY, focusX, focusY, bg2, fg2);
+  }
+  textBufferResetLocalSelection(buffer) {
+    this.opentui.symbols.textBufferResetLocalSelection(buffer);
+  }
   textBufferGetLineInfo(buffer) {
-    const lineCount = this.opentui.symbols.textBufferGetLineCount(buffer);
+    const lineCount = this.textBufferGetLineCount(buffer);
     if (lineCount === 0) {
       return { lineStarts: [], lineWidths: [] };
     }
-    const lineStartsPtr = this.opentui.symbols.textBufferGetLineStartsPtr(buffer);
-    const lineWidthsPtr = this.opentui.symbols.textBufferGetLineWidthsPtr(buffer);
-    if (!lineStartsPtr || !lineWidthsPtr) {
-      return { lineStarts: [], lineWidths: [] };
-    }
-    const lineStartsArray = new Uint32Array(toArrayBuffer(lineStartsPtr, 0, lineCount * 4));
-    const lineWidthsArray = new Uint32Array(toArrayBuffer(lineWidthsPtr, 0, lineCount * 4));
-    const lineStarts = Array.from(lineStartsArray);
-    const lineWidths = Array.from(lineWidthsArray);
-    return { lineStarts, lineWidths };
-  }
-  getTextBufferArrays(buffer, size) {
-    return this.getTextBuffer(buffer, size);
+    const lineStarts = new Uint32Array(lineCount);
+    const lineWidths = new Uint32Array(lineCount);
+    this.textBufferGetLineInfoDirect(buffer, ptr(lineStarts), ptr(lineWidths));
+    return {
+      lineStarts: Array.from(lineStarts),
+      lineWidths: Array.from(lineWidths)
+    };
   }
   bufferDrawTextBuffer(buffer, textBuffer, x, y, clipRect) {
     const hasClipRect = clipRect !== undefined && clipRect !== null;
@@ -6021,25 +5644,18 @@ try {
 class TextBuffer {
   lib;
   bufferPtr;
-  buffer;
   _length = 0;
   _capacity;
   _lineInfo;
-  constructor(lib, ptr2, buffer, capacity) {
+  constructor(lib, ptr2, capacity) {
     this.lib = lib;
     this.bufferPtr = ptr2;
-    this.buffer = buffer;
     this._capacity = capacity;
   }
   static create(capacity = 256, widthMethod) {
     const lib = resolveRenderLib();
     return lib.createTextBuffer(capacity, widthMethod);
   }
-  syncBuffersAfterResize() {
-    const capacity = this.lib.textBufferGetCapacity(this.bufferPtr);
-    this.buffer = this.lib.getTextBufferArrays(this.bufferPtr, capacity);
-    this._capacity = capacity;
-  }
   setStyledText(text) {
     this.lib.textBufferReset(this.bufferPtr);
     this._length = 0;
@@ -6047,7 +5663,7 @@ class TextBuffer {
     for (const chunk of text.chunks) {
       const result = this.lib.textBufferWriteChunk(this.bufferPtr, chunk.text, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
       if (result & 1) {
-        this.syncBuffersAfterResize();
+        this._capacity = this.lib.textBufferGetCapacity(this.bufferPtr);
       }
     }
     this.lib.textBufferFinalizeLineInfo(this.bufferPtr);
@@ -6074,28 +5690,38 @@ class TextBuffer {
   get ptr() {
     return this.bufferPtr;
   }
+  getSelectedText() {
+    if (this._length === 0)
+      return "";
+    const selectedBytes = this.lib.getSelectedTextBytes(this.bufferPtr, this._length);
+    if (!selectedBytes)
+      return "";
+    return this.lib.decoder.decode(selectedBytes);
+  }
   get lineInfo() {
     if (!this._lineInfo) {
       this._lineInfo = this.lib.textBufferGetLineInfo(this.bufferPtr);
     }
     return this._lineInfo;
   }
-  toString() {
-    const chars = [];
-    for (let i = 0;i < this._length; i++) {
-      chars.push(String.fromCharCode(this.buffer.char[i]));
-    }
-    return chars.join("");
-  }
-  concat(other) {
-    return this.lib.textBufferConcat(this.bufferPtr, other.bufferPtr);
-  }
   setSelection(start, end, bgColor, fgColor) {
     this.lib.textBufferSetSelection(this.bufferPtr, start, end, bgColor || null, fgColor || null);
   }
   resetSelection() {
     this.lib.textBufferResetSelection(this.bufferPtr);
   }
+  setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
+    return this.lib.textBufferSetLocalSelection(this.bufferPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
+  }
+  resetLocalSelection() {
+    this.lib.textBufferResetLocalSelection(this.bufferPtr);
+  }
+  getSelection() {
+    return this.lib.textBufferGetSelection(this.bufferPtr);
+  }
+  hasSelection() {
+    return this.getSelection() !== null;
+  }
   destroy() {
     this.lib.destroyTextBuffer(this.bufferPtr);
   }
@@ -6103,6 +5729,7 @@ class TextBuffer {
 
 // src/Renderable.ts
 import { EventEmitter as EventEmitter3 } from "events";
+var BrandedRenderable = Symbol.for("@opentui/core/Renderable");
 var LayoutEvents;
 ((LayoutEvents2) => {
   LayoutEvents2["LAYOUT_CHANGED"] = "layout-changed";
@@ -6186,8 +5813,12 @@ function isSizeType(value) {
   }
   return isValidPercentage(value);
 }
+function isRenderable(obj) {
+  return !!obj?.[BrandedRenderable];
+}
 
 class Renderable extends EventEmitter3 {
+  [BrandedRenderable] = true;
   static renderableNumber = 1;
   static renderablesByNumber = new Map;
   id;
@@ -6213,6 +5844,7 @@ class Renderable extends EventEmitter3 {
   keypressHandler = null;
   _live = false;
   _liveCount = 0;
+  _sizeChangeListener = undefined;
   _mouseListener = null;
   _mouseListeners = {};
   _keyListeners = {};
@@ -6220,11 +5852,12 @@ class Renderable extends EventEmitter3 {
   _positionType = "relative";
   _overflow = "visible";
   _position = {};
-  _childHostOverride = null;
   renderableMap = new Map;
   renderableArray = [];
   needsZIndexSort = false;
   parent = null;
+  childrenPrimarySortDirty = true;
+  childrenSortedByPrimaryAxis = [];
   renderBefore;
   renderAfter;
   constructor(ctx, options) {
@@ -6294,10 +5927,6 @@ class Renderable extends EventEmitter3 {
     return false;
   }
   focus() {
-    if (this.childHost !== this) {
-      this.childHost.focus();
-      return;
-    }
     if (this._focused || !this.focusable)
       return;
     this._focused = true;
@@ -6312,10 +5941,6 @@ class Renderable extends EventEmitter3 {
     this.emit("focused" /* FOCUSED */);
   }
   blur() {
-    if (this.childHost !== this) {
-      this.childHost.blur();
-      return;
-    }
     if (!this._focused || !this.focusable)
       return;
     this._focused = false;
@@ -6351,12 +5976,6 @@ class Renderable extends EventEmitter3 {
   get isDirty() {
     return this._dirty;
   }
-  get childHost() {
-    return this._childHostOverride || this;
-  }
-  set childHost(host) {
-    this._childHostOverride = host;
-  }
   findDescendantById(id) {
     for (const child of this.renderableArray) {
       if (child.id === id)
@@ -6367,14 +5986,6 @@ class Renderable extends EventEmitter3 {
     }
     return;
   }
-  setChildHostById(id) {
-    const found = this.findDescendantById(id);
-    if (found) {
-      this._childHostOverride = found;
-      return true;
-    }
-    return false;
-  }
   markClean() {
     this._dirty = false;
   }
@@ -6390,6 +6001,8 @@ class Renderable extends EventEmitter3 {
       return;
     this._translateX = value;
     this.requestRender();
+    if (this.parent)
+      this.parent.childrenPrimarySortDirty = true;
   }
   get translateY() {
     return this._translateY;
@@ -6399,6 +6012,8 @@ class Renderable extends EventEmitter3 {
       return;
     this._translateY = value;
     this.requestRender();
+    if (this.parent)
+      this.parent.childrenPrimarySortDirty = true;
   }
   get x() {
     if (this.parent && this._positionType === "relative") {
@@ -6488,6 +6103,96 @@ class Renderable extends EventEmitter3 {
       this.needsZIndexSort = false;
     }
   }
+  getChildrenInViewport(viewport, padding = 10, minTriggerSize = 16) {
+    if (this.renderableArray.length < minTriggerSize)
+      return this.renderableArray;
+    const viewportTop = viewport.y - padding;
+    const viewportBottom = viewport.y + viewport.height + padding;
+    const viewportLeft = viewport.x - padding;
+    const viewportRight = viewport.x + viewport.width + padding;
+    const dir = this.layoutNode.yogaNode.getFlexDirection();
+    const isRow = dir === 2 || dir === 3;
+    const children = this.getChildrenSortedByPrimaryAxis();
+    const totalChildren = children.length;
+    if (totalChildren === 0)
+      return [];
+    const vpStart = isRow ? viewportLeft : viewportTop;
+    const vpEnd = isRow ? viewportRight : viewportBottom;
+    let lo = 0;
+    let hi = totalChildren - 1;
+    let candidate = -1;
+    while (lo <= hi) {
+      const mid = lo + hi >> 1;
+      const c = children[mid];
+      const start = isRow ? c.x : c.y;
+      const end = isRow ? c.x + c.width : c.y + c.height;
+      if (end < vpStart) {
+        lo = mid + 1;
+      } else if (start > vpEnd) {
+        hi = mid - 1;
+      } else {
+        candidate = mid;
+        break;
+      }
+    }
+    const visibleChildren = [];
+    if (candidate === -1) {
+      return visibleChildren;
+    }
+    let left = candidate;
+    while (left - 1 >= 0) {
+      const prev = children[left - 1];
+      if ((isRow ? prev.x + prev.width : prev.y + prev.height) < vpStart)
+        break;
+      left--;
+    }
+    let right = candidate + 1;
+    while (right < totalChildren) {
+      const next = children[right];
+      if ((isRow ? next.x : next.y) > vpEnd)
+        break;
+      right++;
+    }
+    for (let i = left;i < right; i++) {
+      const child = children[i];
+      if (isRow) {
+        const childBottom = child.y + child.height;
+        if (childBottom < viewportTop)
+          continue;
+        const childTop = child.y;
+        if (childTop > viewportBottom)
+          continue;
+      } else {
+        const childRight = child.x + child.width;
+        if (childRight < viewportLeft)
+          continue;
+        const childLeft = child.x;
+        if (childLeft > viewportRight)
+          continue;
+      }
+      visibleChildren.push(child);
+    }
+    if (visibleChildren.length > 1) {
+      visibleChildren.sort((a, b) => a.zIndex > b.zIndex ? 1 : a.zIndex < b.zIndex ? -1 : 0);
+    }
+    return visibleChildren;
+  }
+  getChildrenSortedByPrimaryAxis() {
+    if (!this.childrenPrimarySortDirty && this.childrenSortedByPrimaryAxis.length === this.renderableArray.length) {
+      return this.childrenSortedByPrimaryAxis;
+    }
+    const dir = this.layoutNode.yogaNode.getFlexDirection();
+    const axis = dir === 2 || dir === 3 ? "x" : "y";
+    const sorted = [...this.renderableArray];
+    sorted.sort((a, b) => {
+      const va = axis === "y" ? a.y : a.x;
+      const vb = axis === "y" ? b.y : b.x;
+      return va - vb;
+    });
+    this.childrenSortedByPrimaryAxis = sorted;
+    this.childrenPrimarySortDirty = false;
+    return this.childrenSortedByPrimaryAxis;
+  }
   setupYogaProperties(options) {
     const node = this.layoutNode.yogaNode;
     if (isFlexBasisType(options.flexBasis)) {
@@ -6783,6 +6488,8 @@ class Renderable extends EventEmitter3 {
   }
   updateFromLayout() {
     const layout = this.layoutNode.yogaNode.getComputedLayout();
+    const oldX = this._x;
+    const oldY = this._y;
     this._x = layout.left;
     this._y = layout.top;
     const newWidth = Math.max(layout.width, 1);
@@ -6793,6 +6500,10 @@ class Renderable extends EventEmitter3 {
     if (sizeChanged) {
       this.onLayoutResize(newWidth, newHeight);
     }
+    if (oldX !== this._x || oldY !== this._y) {
+      if (this.parent)
+        this.parent.childrenPrimarySortDirty = true;
+    }
   }
   onLayoutResize(width, height) {
     if (this._visible) {
@@ -6828,6 +6539,7 @@ class Renderable extends EventEmitter3 {
     }
   }
   onResize(width, height) {
+    this.onSizeChange?.();
     this.emit("resize");
   }
   replaceParent(obj) {
@@ -6837,9 +6549,6 @@ class Renderable extends EventEmitter3 {
     obj.parent = this;
   }
   add(obj, index) {
-    if (this.childHost !== this) {
-      return this.childHost.add(obj, index);
-    }
     obj = ensureRenderable(this._ctx, obj);
     if (this.renderableMap.has(obj.id)) {
       console.warn(`A renderable with id ${obj.id} already exists in ${this.id}, removing it`);
@@ -6856,6 +6565,7 @@ class Renderable extends EventEmitter3 {
       insertedIndex = this.layoutNode.addChild(childLayoutNode);
     }
     this.needsZIndexSort = true;
+    this.childrenPrimarySortDirty = true;
     this.renderableMap.set(obj.id, obj);
     if (obj._liveCount > 0) {
       this.propagateLiveCount(obj._liveCount);
@@ -6864,10 +6574,6 @@ class Renderable extends EventEmitter3 {
     return insertedIndex;
   }
   insertBefore(obj, anchor) {
-    if (this.childHost !== this) {
-      const idx = this.childHost.insertBefore(obj, anchor);
-      return idx;
-    }
     obj = ensureRenderable(this._ctx, obj);
     if (!anchor) {
       return this.add(obj);
@@ -6882,15 +6588,9 @@ class Renderable extends EventEmitter3 {
     return this.add(obj, anchorIndex);
   }
   getRenderable(id) {
-    if (this.childHost !== this)
-      return this.childHost.getRenderable(id);
     return this.renderableMap.get(id);
   }
   remove(id) {
-    if (this.childHost !== this) {
-      this.childHost.remove(id);
-      return;
-    }
     if (!id) {
       return;
     }
@@ -6911,18 +6611,20 @@ class Renderable extends EventEmitter3 {
       if (index !== -1) {
         this.renderableArray.splice(index, 1);
       }
+      this.childrenPrimarySortDirty = true;
     }
   }
   onRemove() {}
   getChildren() {
-    if (this.childHost !== this)
-      return this.childHost.getChildren();
     return [...this.renderableArray];
   }
+  getChildrenCount() {
+    return this.renderableArray.length;
+  }
   render(buffer, deltaTime) {
     if (!this.visible)
       return;
-    this.beforeRender();
+    this.onUpdate(deltaTime);
     this.updateFromLayout();
     let renderBuffer = buffer;
     if (this.buffered && this.frameBuffer) {
@@ -6943,7 +6645,7 @@ class Renderable extends EventEmitter3 {
       const scissorRect = this.getScissorRect();
       renderBuffer.pushScissorRect(scissorRect.x, scissorRect.y, scissorRect.width, scissorRect.height);
     }
-    for (const child of this.renderableArray) {
+    for (const child of this._getChildren()) {
       child.render(renderBuffer, deltaTime);
     }
     if (shouldPushScissor) {
@@ -6953,7 +6655,10 @@ class Renderable extends EventEmitter3 {
       buffer.drawFrameBuffer(this.x, this.y, this.frameBuffer);
     }
   }
-  beforeRender() {}
+  _getChildren() {
+    return this.renderableArray;
+  }
+  onUpdate(deltaTime) {}
   getScissorRect() {
     return {
       x: this.buffered ? 0 : this.x,
@@ -6994,7 +6699,7 @@ class Renderable extends EventEmitter3 {
     this._mouseListener?.call(this, event);
     this._mouseListeners[event.type]?.call(this, event);
     this.onMouseEvent(event);
-    if (this.parent && !event.defaultPrevented) {
+    if (this.parent && !event.propagationStopped) {
       this.parent.processMouseEvent(event);
     }
   }
@@ -7068,6 +6773,12 @@ class Renderable extends EventEmitter3 {
   get onKeyDown() {
     return this._keyListeners["down"];
   }
+  set onSizeChange(handler) {
+    this._sizeChangeListener = handler;
+  }
+  get onSizeChange() {
+    return this._sizeChangeListener;
+  }
   applyEventOptions(options) {
     this.onMouse = options.onMouse;
     this.onMouseDown = options.onMouseDown;
@@ -7080,6 +6791,7 @@ class Renderable extends EventEmitter3 {
     this.onMouseOut = options.onMouseOut;
     this.onMouseScroll = options.onMouseScroll;
     this.onKeyDown = options.onKeyDown;
+    this.onSizeChange = options.onSizeChange;
   }
 }
 
@@ -7117,7 +6829,7 @@ class RootRenderable extends Renderable {
     this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
-  beforeRender() {
+  onUpdate() {
     if (this.layoutNode.yogaNode.isDirty()) {
       this.calculateLayout();
     }
@@ -7198,7 +6910,7 @@ function isVNode(node) {
   return node && node.__isVNode;
 }
 function ensureRenderable(ctx, node) {
-  if (node instanceof Renderable)
+  if (isRenderable(node))
     return node;
   return instantiate(ctx, node);
 }
@@ -7246,7 +6958,7 @@ function wrapWithDelegates(instance, delegateMap) {
   return proxy;
 }
 function instantiate(ctx, node) {
-  if (node instanceof Renderable)
+  if (isRenderable(node))
     return node;
   if (!node || typeof node !== "object") {
     throw new TypeError("mount() received an invalid vnode");
@@ -7258,7 +6970,7 @@ function instantiate(ctx, node) {
   if (isRenderableConstructor(type)) {
     const instance = new type(ctx, props || {});
     for (const child of children) {
-      if (child instanceof Renderable) {
+      if (isRenderable(child)) {
         instance.add(child);
       } else {
         const mounted = instantiate(ctx, child);
@@ -7283,7 +6995,7 @@ function instantiate(ctx, node) {
   return wrapWithDelegates(inst, delegateMap);
 }
 function delegate(mapping, vnode) {
-  if (vnode instanceof Renderable) {
+  if (isRenderable(vnode)) {
     return wrapWithDelegates(vnode, mapping);
   }
   if (!vnode || typeof vnode !== "object")
@@ -7295,9 +7007,9 @@ function delegate(mapping, vnode) {
 // src/console.ts
 import { EventEmitter as EventEmitter5 } from "events";
 import { Console } from "console";
-import util from "util";
 import fs from "fs";
 import path from "path";
+import util from "util";
 
 // src/lib/output.capture.ts
 import { Writable } from "stream";
@@ -7365,27 +7077,9 @@ function getCallerInfo() {
   const columnNumber = parseInt(match[4], 10) || 0;
   return { functionName, fullPath, fileName, lineNumber, columnNumber };
 }
-var { capture } = singleton("ConsoleCapture", () => {
-  const capture2 = new Capture;
-  const mockStdout = new CapturedWritableStream("stdout", capture2);
-  const mockStderr = new CapturedWritableStream("stderr", capture2);
-  if (process.env.SKIP_CONSOLE_CACHE !== "true") {
-    global.console = new Console({
-      stdout: mockStdout,
-      stderr: mockStderr,
-      colorMode: true,
-      inspectOptions: {
-        compact: false,
-        breakLength: 80,
-        depth: 2
-      }
-    });
-  }
-  return { capture: capture2 };
-});
+var capture = singleton("ConsoleCapture", () => new Capture);
 
 class TerminalConsoleCache extends EventEmitter5 {
-  originalConsole;
   _cachedLogs = [];
   MAX_CACHE_SIZE = 1000;
   _collectCallerInfo = false;
@@ -7395,35 +7089,26 @@ class TerminalConsoleCache extends EventEmitter5 {
   }
   constructor() {
     super();
-    this.originalConsole = {
-      log: console.log,
-      info: console.info,
-      warn: console.warn,
-      error: console.error,
-      debug: console.debug
-    };
-    if (process.env.SKIP_CONSOLE_CACHE !== "true") {
-      this.activate();
-    }
   }
   activate() {
+    this.setupConsoleCapture();
     this.overrideConsoleMethods();
   }
-  setCollectCallerInfo(enabled) {
-    this._collectCallerInfo = enabled;
-  }
-  clearConsole() {
-    this._cachedLogs = [];
-  }
-  setCachingEnabled(enabled) {
-    this._cachingEnabled = enabled;
-  }
-  deactivate() {
-    console.log = this.originalConsole.log;
-    console.info = this.originalConsole.info;
-    console.warn = this.originalConsole.warn;
-    console.error = this.originalConsole.error;
-    console.debug = this.originalConsole.debug;
+  setupConsoleCapture() {
+    if (process.env.OTUI_USE_CONSOLE === "false")
+      return;
+    const mockStdout = new CapturedWritableStream("stdout", capture);
+    const mockStderr = new CapturedWritableStream("stderr", capture);
+    global.console = new Console({
+      stdout: mockStdout,
+      stderr: mockStderr,
+      colorMode: true,
+      inspectOptions: {
+        compact: false,
+        breakLength: 80,
+        depth: 2
+      }
+    });
   }
   overrideConsoleMethods() {
     console.log = (...args) => {
@@ -7442,6 +7127,23 @@ class TerminalConsoleCache extends EventEmitter5 {
       this.appendToConsole("DEBUG" /* DEBUG */, ...args);
     };
   }
+  setCollectCallerInfo(enabled) {
+    this._collectCallerInfo = enabled;
+  }
+  clearConsole() {
+    this._cachedLogs = [];
+  }
+  setCachingEnabled(enabled) {
+    this._cachingEnabled = enabled;
+  }
+  deactivate() {
+    this.restoreOriginalConsole();
+  }
+  restoreOriginalConsole() {
+    const originalNodeConsole = __require("console");
+    global.console = originalNodeConsole;
+    this.setupConsoleCapture();
+  }
   addLogEntry(level, ...args) {
     const callerInfo = this._collectCallerInfo ? getCallerInfo() : null;
     const logEntry = [new Date, level, args, callerInfo];
@@ -7999,9 +7701,10 @@ class MouseEvent {
   modifiers;
   scroll;
   target;
-  _defaultPrevented = false;
-  get defaultPrevented() {
-    return this._defaultPrevented;
+  isSelecting;
+  _propagationStopped = false;
+  get propagationStopped() {
+    return this._propagationStopped;
   }
   constructor(target, attributes) {
     this.target = target;
@@ -8012,9 +7715,10 @@ class MouseEvent {
     this.modifiers = attributes.modifiers;
     this.scroll = attributes.scroll;
     this.source = attributes.source;
+    this.isSelecting = attributes.isSelecting;
   }
-  preventDefault() {
-    this._defaultPrevented = true;
+  stopPropagation() {
+    this._propagationStopped = true;
   }
 }
 var MouseButton;
@@ -8125,7 +7829,6 @@ class CliRenderer extends EventEmitter6 {
   lastOverRenderableNum = 0;
   lastOverRenderable;
   currentSelection = null;
-  selectionState = null;
   selectionContainers = [];
   _splitHeight = 0;
   renderOffset = 0;
@@ -8219,6 +7922,9 @@ Error details:
         process.exit(1);
       });
     };
+    process.on("warning", (warning) => {
+      console.warn(JSON.stringify(warning.message, null, 2));
+    });
     process.on("uncaughtException", handleError);
     process.on("unhandledRejection", handleError);
     process.on("exit", () => {
@@ -8488,22 +8194,38 @@ Error details:
       const sameElement = maybeRenderableId === this.lastOverRenderableNum;
       this.lastOverRenderableNum = maybeRenderableId;
       const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */) {
+      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && !this.currentSelection?.isSelecting && !mouseEvent.modifiers.ctrl) {
         if (maybeRenderable && maybeRenderable.selectable && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y)) {
           this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+          const event = new MouseEvent(maybeRenderable, mouseEvent);
+          maybeRenderable.processMouseEvent(event);
           return true;
         }
       }
-      if (mouseEvent.type === "drag" && this.selectionState?.isSelecting) {
+      if (mouseEvent.type === "drag" && this.currentSelection?.isSelecting) {
         this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+        if (maybeRenderable) {
+          const event = new MouseEvent(maybeRenderable, { ...mouseEvent, isSelecting: true });
+          maybeRenderable.processMouseEvent(event);
+        }
         return true;
       }
-      if (mouseEvent.type === "up" && this.selectionState?.isSelecting) {
+      if (mouseEvent.type === "up" && this.currentSelection?.isSelecting) {
+        if (maybeRenderable) {
+          const event = new MouseEvent(maybeRenderable, { ...mouseEvent, isSelecting: true });
+          maybeRenderable.processMouseEvent(event);
+        }
         this.finishSelection();
         return true;
       }
-      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && this.selectionState) {
-        this.clearSelection();
+      if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */ && this.currentSelection) {
+        if (mouseEvent.modifiers.ctrl) {
+          this.currentSelection.isSelecting = true;
+          this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
+          return true;
+        } else {
+          this.clearSelection();
+        }
       }
       if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
         if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
@@ -8623,7 +8345,7 @@ Error details:
       this.renderOffset = height - this._splitHeight;
       this.width = width;
       this.height = this._splitHeight;
-      this.currentRenderBuffer.clearLocal(RGBA.fromHex("#000000"), "\u0A00");
+      this.currentRenderBuffer.clear(RGBA.fromHex("#000000"));
       this.lib.setRenderOffset(this.rendererPtr, this.renderOffset);
     } else {
       this.width = width;
@@ -8904,35 +8626,32 @@ Error details:
   getSelection() {
     return this.currentSelection;
   }
+  get hasSelection() {
+    return !!this.currentSelection;
+  }
   getSelectionContainer() {
     return this.selectionContainers.length > 0 ? this.selectionContainers[this.selectionContainers.length - 1] : null;
   }
-  hasSelection() {
-    return this.currentSelection !== null;
-  }
   clearSelection() {
-    if (this.selectionState) {
-      this.selectionState = null;
-      this.notifySelectablesOfSelectionChange();
+    if (this.currentSelection) {
+      for (const renderable of this.currentSelection.touchedRenderables) {
+        if (renderable.selectable) {
+          renderable.onSelectionChanged(null);
+        }
+      }
+      this.currentSelection = null;
     }
-    this.currentSelection = null;
     this.selectionContainers = [];
   }
   startSelection(startRenderable, x, y) {
     this.clearSelection();
     this.selectionContainers.push(startRenderable.parent || this.root);
-    this.selectionState = {
-      anchor: { x, y },
-      focus: { x, y },
-      isActive: true,
-      isSelecting: true
-    };
-    this.currentSelection = new Selection({ x, y }, { x, y });
+    this.currentSelection = new Selection(startRenderable, { x, y }, { x, y });
     this.notifySelectablesOfSelectionChange();
   }
   updateSelection(currentRenderable, x, y) {
-    if (this.selectionState) {
-      this.selectionState.focus = { x, y };
+    if (this.currentSelection) {
+      this.currentSelection.focus = { x, y };
       if (this.selectionContainers.length > 0) {
         const currentContainer = this.selectionContainers[this.selectionContainers.length - 1];
         if (!currentRenderable || !this.isWithinContainer(currentRenderable, currentContainer)) {
@@ -8949,12 +8668,18 @@ Error details:
           }
         }
       }
-      if (this.currentSelection) {
-        this.currentSelection = new Selection(this.selectionState.anchor, this.selectionState.focus);
-      }
       this.notifySelectablesOfSelectionChange();
     }
   }
+  requestSelectionUpdate() {
+    if (this.currentSelection?.isSelecting) {
+      const lastMouseX = this.currentSelection.focus.x;
+      const lastMouseY = this.currentSelection.focus.y;
+      const maybeRenderableId = this.lib.checkHit(this.rendererPtr, lastMouseX, lastMouseY);
+      const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
+      this.updateSelection(maybeRenderable, lastMouseX, lastMouseY);
+    }
+  }
   isWithinContainer(renderable, container) {
     let current = renderable;
     while (current) {
@@ -8965,46 +8690,44 @@ Error details:
     return false;
   }
   finishSelection() {
-    if (this.selectionState) {
-      this.selectionState.isSelecting = false;
+    if (this.currentSelection) {
+      this.currentSelection.isSelecting = false;
       this.emit("selection", this.currentSelection);
     }
   }
   notifySelectablesOfSelectionChange() {
-    let normalizedSelection = null;
-    if (this.selectionState) {
-      normalizedSelection = { ...this.selectionState };
-      if (normalizedSelection.anchor.y > normalizedSelection.focus.y || normalizedSelection.anchor.y === normalizedSelection.focus.y && normalizedSelection.anchor.x > normalizedSelection.focus.x) {
-        const temp = normalizedSelection.anchor;
-        normalizedSelection.anchor = normalizedSelection.focus;
-        normalizedSelection.focus = {
-          x: temp.x + 1,
-          y: temp.y
-        };
-      }
-    }
     const selectedRenderables = [];
-    for (const [, renderable] of Renderable.renderablesByNumber) {
-      if (renderable.visible && renderable.selectable) {
-        const currentContainer = this.selectionContainers.length > 0 ? this.selectionContainers[this.selectionContainers.length - 1] : null;
-        let hasSelection = false;
-        if (!currentContainer || this.isWithinContainer(renderable, currentContainer)) {
-          hasSelection = renderable.onSelectionChanged(normalizedSelection);
-        } else {
-          hasSelection = renderable.onSelectionChanged(normalizedSelection ? { ...normalizedSelection, isActive: false } : null);
+    const touchedRenderables = [];
+    const currentContainer = this.selectionContainers.length > 0 ? this.selectionContainers[this.selectionContainers.length - 1] : this.root;
+    if (this.currentSelection) {
+      this.walkSelectableRenderables(currentContainer, this.currentSelection.bounds, selectedRenderables, touchedRenderables);
+      for (const renderable of this.currentSelection.touchedRenderables) {
+        if (!touchedRenderables.includes(renderable)) {
+          renderable.onSelectionChanged(null);
         }
+      }
+      this.currentSelection.updateSelectedRenderables(selectedRenderables);
+      this.currentSelection.updateTouchedRenderables(touchedRenderables);
+    }
+  }
+  walkSelectableRenderables(container, selectionBounds, selectedRenderables, touchedRenderables) {
+    const children = container.getChildrenInViewport(selectionBounds, 0);
+    for (const child of children) {
+      if (child.selectable) {
+        const hasSelection = child.onSelectionChanged(this.currentSelection);
         if (hasSelection) {
-          selectedRenderables.push(renderable);
+          selectedRenderables.push(child);
         }
+        touchedRenderables.push(child);
+      }
+      if (child.getChildrenCount() > 0) {
+        this.walkSelectableRenderables(child, selectionBounds, selectedRenderables, touchedRenderables);
       }
-    }
-    if (this.currentSelection) {
-      this.currentSelection.updateSelectedRenderables(selectedRenderables);
     }
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, TrackedNode, createTrackedNode, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, 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, tn, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, TextSelectionHelper, ASCIIFontSelectionHelper, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, ensureRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isValidPercentage, isMarginType, isPaddingType, isPositionType, isPositionTypeType, isOverflowType, isDimensionType, isFlexBasisType, isSizeType, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, TrackedNode, createTrackedNode, nonAlphanumericKeys, parseKeypress, KeyHandler, getKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, 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, tn, t, SyntaxStyle, hastToStyledText, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, ensureRenderable, wrapWithDelegates, instantiate, delegate, LayoutEvents, RenderableEvents, isValidPercentage, isMarginType, isPaddingType, isPositionType, isPositionTypeType, isOverflowType, isDimensionType, isFlexBasisType, isSizeType, isRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, CliRenderer };
 
-//# debugId=ADDBBC6DB7FFCF1064756E2164756E21
-//# sourceMappingURL=index-rv93tneq.js.map
+//# debugId=4847DC8F7CFD610964756E2164756E21
+//# sourceMappingURL=index-sw194bbj.js.map