@opentui/core 0.1.5 → 0.1.7

package/index.js

@@ -2046,6 +2046,18 @@ function parseJustify(value) {
       return Justify.FlexStart;
   }
 }
+function parsePositionType(value) {
+  switch (value.toLowerCase()) {
+    case "static":
+      return PositionType.Static;
+    case "relative":
+      return PositionType.Relative;
+    case "absolute":
+      return PositionType.Absolute;
+    default:
+      return PositionType.Static;
+  }
+}
 
 // src/Renderable.ts
 var LayoutEvents;
@@ -2368,8 +2380,8 @@ class Renderable extends EventEmitter3 {
       this.layoutNode.setHeight(options.height);
     }
     this._positionType = options.position ?? "relative";
-    if (this._positionType === "absolute") {
-      node.setPositionType(PositionType.Absolute);
+    if (this._positionType !== "relative") {
+      node.setPositionType(parsePositionType(this._positionType));
     }
     const hasPositionProps = options.top !== undefined || options.right !== undefined || options.bottom !== undefined || options.left !== undefined;
     if (hasPositionProps) {
@@ -2428,6 +2440,14 @@ class Renderable extends EventEmitter3 {
       node.setPadding(Edge.Left, options.paddingLeft);
     }
   }
+  set position(positionType) {
+    if (this._positionType === positionType)
+      return;
+    this._positionType = positionType;
+    this.layoutNode.yogaNode.setPositionType(parsePositionType(positionType));
+    this.needsUpdate();
+    this._yogaPerformancePositionUpdated = true;
+  }
   setPosition(position) {
     this._position = { ...this._position, ...position };
     this.updateYogaPosition(position);
@@ -3140,7 +3160,7 @@ function getOpenTUILib(libPath) {
       returns: "ptr"
     },
     destroyRenderer: {
-      args: ["ptr"],
+      args: ["ptr", "bool", "u32"],
       returns: "void"
     },
     setUseThread: {
@@ -3295,6 +3315,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i64"],
       returns: "void"
     },
+    enableMouse: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    disableMouse: {
+      args: ["ptr"],
+      returns: "void"
+    },
     createTextBuffer: {
       args: ["u32"],
       returns: "ptr"
@@ -3403,8 +3431,8 @@ class FFIRenderLib {
   createRenderer(width, height) {
     return this.opentui.symbols.createRenderer(width, height);
   }
-  destroyRenderer(renderer) {
-    this.opentui.symbols.destroyRenderer(renderer);
+  destroyRenderer(renderer, useAlternateScreen, splitHeight) {
+    this.opentui.symbols.destroyRenderer(renderer, useAlternateScreen, splitHeight);
   }
   setUseThread(renderer, useThread) {
     this.opentui.symbols.setUseThread(renderer, useThread);
@@ -3614,6 +3642,12 @@ class FFIRenderLib {
     const ts = timestamp ?? Date.now();
     this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
   }
+  enableMouse(renderer, enableMovement) {
+    this.opentui.symbols.enableMouse(renderer, enableMovement);
+  }
+  disableMouse(renderer) {
+    this.opentui.symbols.disableMouse(renderer);
+  }
   createTextBuffer(capacity) {
     const bufferPtr = this.opentui.symbols.createTextBuffer(capacity);
     if (!bufferPtr) {
@@ -5472,6 +5506,306 @@ function renderFontToFrameBuffer(buffer, {
     height: fontDef.lines
   };
 }
+// src/lib/styled-text.ts
+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;
+  }
+  _chunksToPlainText() {
+    this._plainText = "";
+    for (const chunk of this.chunks) {
+      this._plainText += chunk.plainText;
+    }
+  }
+  insert(chunk, index) {
+    const originalLength = this.chunks.length;
+    if (index === undefined) {
+      this.chunks.push(chunk);
+    } else {
+      this.chunks.splice(index, 0, chunk);
+    }
+    if (index === undefined || index === originalLength) {
+      this._plainText += chunk.plainText;
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+  remove(chunk) {
+    const originalLength = this.chunks.length;
+    const index = this.chunks.indexOf(chunk);
+    if (index === -1)
+      return;
+    this.chunks.splice(index, 1);
+    if (index === originalLength - 1) {
+      this._plainText = this._plainText.slice(0, this._plainText.length - chunk.plainText.length);
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+  replace(chunk, oldChunk) {
+    const index = this.chunks.indexOf(oldChunk);
+    if (index === -1)
+      return;
+    this.chunks.splice(index, 1, chunk);
+    if (index === this.chunks.length - 1) {
+      this._plainText = this._plainText.slice(0, this._plainText.length - oldChunk.plainText.length) + chunk.plainText;
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+}
+function stringToStyledText(content) {
+  const textEncoder2 = new TextEncoder;
+  const chunk = {
+    __isChunk: true,
+    text: textEncoder2.encode(content),
+    plainText: content
+  };
+  return new StyledText([chunk]);
+}
+var templateCache = new WeakMap;
+function applyStyle(input, style) {
+  if (typeof input === "object" && "__isChunk" in input) {
+    const existingChunk = input;
+    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
+    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
+    const newAttrs = createTextAttributes(style);
+    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
+    return {
+      __isChunk: true,
+      text: existingChunk.text,
+      plainText: existingChunk.plainText,
+      fg,
+      bg,
+      attributes: mergedAttrs
+    };
+  } else {
+    const plainTextStr = String(input);
+    const text = textEncoder.encode(plainTextStr);
+    const fg = style.fg ? parseColor(style.fg) : undefined;
+    const bg = style.bg ? parseColor(style.bg) : undefined;
+    const attributes = createTextAttributes(style);
+    return {
+      __isChunk: true,
+      text,
+      plainText: plainTextStr,
+      fg,
+      bg,
+      attributes
+    };
+  }
+}
+var black = (input) => applyStyle(input, { fg: "black" });
+var red = (input) => applyStyle(input, { fg: "red" });
+var green = (input) => applyStyle(input, { fg: "green" });
+var yellow = (input) => applyStyle(input, { fg: "yellow" });
+var blue = (input) => applyStyle(input, { fg: "blue" });
+var magenta = (input) => applyStyle(input, { fg: "magenta" });
+var cyan = (input) => applyStyle(input, { fg: "cyan" });
+var white = (input) => applyStyle(input, { fg: "white" });
+var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
+var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
+var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
+var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
+var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
+var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
+var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
+var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
+var bgBlack = (input) => applyStyle(input, { bg: "black" });
+var bgRed = (input) => applyStyle(input, { bg: "red" });
+var bgGreen = (input) => applyStyle(input, { bg: "green" });
+var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
+var bgBlue = (input) => applyStyle(input, { bg: "blue" });
+var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
+var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
+var bgWhite = (input) => applyStyle(input, { bg: "white" });
+var bold = (input) => applyStyle(input, { bold: true });
+var italic = (input) => applyStyle(input, { italic: true });
+var underline = (input) => applyStyle(input, { underline: true });
+var strikethrough = (input) => applyStyle(input, { strikethrough: true });
+var dim = (input) => applyStyle(input, { dim: true });
+var reverse = (input) => applyStyle(input, { reverse: true });
+var blink = (input) => applyStyle(input, { blink: true });
+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) {
+      chunks.push({
+        __isChunk: true,
+        text: textEncoder.encode(raw),
+        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({
+        __isChunk: true,
+        text: textEncoder.encode(plainTextStr),
+        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++) {
+      const raw = strings[i];
+      if (raw) {
+        cachedStringChunks.push({
+          __isChunk: true,
+          text: textEncoder.encode(raw),
+          plainText: raw,
+          attributes: 0
+        });
+      } else {
+        cachedStringChunks.push(null);
+      }
+    }
+    templateCache.set(strings, cachedStringChunks);
+  }
+  const chunks = [];
+  for (let i = 0;i < strings.length; i++) {
+    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({
+        __isChunk: true,
+        text: textEncoder.encode(plainTextStr),
+        plainText: plainTextStr,
+        attributes: 0
+      });
+      length += plainTextStr.length;
+      plainText += plainTextStr;
+    }
+  }
+  return new StyledText(chunks);
+}
+
+// src/lib/hast-styled-text.ts
+class SyntaxStyle {
+  styles;
+  mergedStyleCache;
+  constructor(styles) {
+    this.styles = styles;
+    this.mergedStyleCache = new Map;
+  }
+  mergeStyles(...styleNames) {
+    const cacheKey = styleNames.join(":");
+    const cached = this.mergedStyleCache.get(cacheKey);
+    if (cached)
+      return cached;
+    const styleDefinition = {};
+    for (const name of styleNames) {
+      const style = this.styles[name];
+      if (!style)
+        continue;
+      if (style.fg)
+        styleDefinition.fg = style.fg;
+      if (style.bg)
+        styleDefinition.bg = style.bg;
+      if (style.bold !== undefined)
+        styleDefinition.bold = style.bold;
+      if (style.italic !== undefined)
+        styleDefinition.italic = style.italic;
+      if (style.underline !== undefined)
+        styleDefinition.underline = style.underline;
+      if (style.dim !== undefined)
+        styleDefinition.dim = style.dim;
+    }
+    const attributes = createTextAttributes({
+      bold: styleDefinition.bold,
+      italic: styleDefinition.italic,
+      underline: styleDefinition.underline,
+      dim: styleDefinition.dim
+    });
+    const merged = {
+      fg: styleDefinition.fg,
+      bg: styleDefinition.bg,
+      attributes
+    };
+    this.mergedStyleCache.set(cacheKey, merged);
+    return merged;
+  }
+  clearCache() {
+    this.mergedStyleCache.clear();
+  }
+  getCacheSize() {
+    return this.mergedStyleCache.size;
+  }
+}
+var textEncoder2 = new TextEncoder;
+function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
+  const chunks = [];
+  if (node.type === "text") {
+    const stylesToMerge = parentStyles.length > 0 ? parentStyles : ["default"];
+    const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
+    chunks.push({
+      __isChunk: true,
+      text: textEncoder2.encode(node.value),
+      plainText: node.value,
+      fg: mergedStyle.fg,
+      bg: mergedStyle.bg,
+      attributes: mergedStyle.attributes
+    });
+  } else if (node.type === "element") {
+    let currentStyles = [...parentStyles];
+    if (node.properties?.className) {
+      const classes = node.properties.className.split(" ");
+      for (const cls of classes) {
+        currentStyles.push(cls);
+      }
+    }
+    for (const child of node.children) {
+      chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
+    }
+  }
+  return chunks;
+}
+function hastToStyledText(hast, syntaxStyle) {
+  const chunks = hastToTextChunks(hast, syntaxStyle);
+  return new StyledText(chunks);
+}
 // src/buffer.ts
 var fbIdCounter = 0;
 function isRGBAWithAlpha(color) {
@@ -5566,14 +5900,14 @@ class OptimizedBuffer {
     this.lib.bufferSetRespectAlpha(this.bufferPtr, respectAlpha);
     this.respectAlpha = respectAlpha;
   }
-  clear(bg = RGBA.fromValues(0, 0, 0, 1), clearChar = " ") {
+  clear(bg2 = RGBA.fromValues(0, 0, 0, 1), clearChar = " ") {
     if (this.useFFI) {
-      this.clearFFI(bg);
+      this.clearFFI(bg2);
     } else {
-      this.clearLocal(bg, clearChar);
+      this.clearLocal(bg2, clearChar);
     }
   }
-  clearLocal(bg = RGBA.fromValues(0, 0, 0, 1), 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++) {
@@ -5582,27 +5916,27 @@ class OptimizedBuffer {
       this.buffer.fg[index + 1] = 1;
       this.buffer.fg[index + 2] = 1;
       this.buffer.fg[index + 3] = 1;
-      this.buffer.bg[index] = bg.r;
-      this.buffer.bg[index + 1] = bg.g;
-      this.buffer.bg[index + 2] = bg.b;
-      this.buffer.bg[index + 3] = bg.a;
+      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;
     }
   }
-  setCell(x, y, char, fg, bg, attributes = 0) {
+  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] = fg.r;
-    this.buffer.fg[colorIndex + 1] = fg.g;
-    this.buffer.fg[colorIndex + 2] = fg.b;
-    this.buffer.fg[colorIndex + 3] = fg.a;
-    this.buffer.bg[colorIndex] = bg.r;
-    this.buffer.bg[colorIndex + 1] = bg.g;
-    this.buffer.bg[colorIndex + 2] = bg.b;
-    this.buffer.bg[colorIndex + 3] = bg.a;
+    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)
@@ -5616,41 +5950,41 @@ class OptimizedBuffer {
       attributes: this.buffer.attributes[index]
     };
   }
-  setCellWithAlphaBlending(x, y, char, fg, bg, attributes = 0) {
+  setCellWithAlphaBlending(x, y, char, fg2, bg2, attributes = 0) {
     if (this.useFFI) {
-      this.setCellWithAlphaBlendingFFI(x, y, char, fg, bg, attributes);
+      this.setCellWithAlphaBlendingFFI(x, y, char, fg2, bg2, attributes);
     } else {
-      this.setCellWithAlphaBlendingLocal(x, y, char, fg, bg, attributes);
+      this.setCellWithAlphaBlendingLocal(x, y, char, fg2, bg2, attributes);
     }
   }
-  setCellWithAlphaBlendingLocal(x, y, char, fg, bg, attributes = 0) {
+  setCellWithAlphaBlendingLocal(x, y, char, fg2, bg2, attributes = 0) {
     if (x < 0 || x >= this.width || y < 0 || y >= this.height)
       return;
-    const hasBgAlpha = isRGBAWithAlpha(bg);
-    const hasFgAlpha = isRGBAWithAlpha(fg);
+    const hasBgAlpha = isRGBAWithAlpha(bg2);
+    const hasFgAlpha = isRGBAWithAlpha(fg2);
     if (hasBgAlpha || hasFgAlpha) {
       const destCell = this.get(x, y);
       if (destCell) {
-        const blendedBgRgb = hasBgAlpha ? blendColors(bg, destCell.bg) : bg;
+        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(bg, destCell.fg);
+          finalFg = blendColors(bg2, destCell.fg);
         } else {
-          finalFg = hasFgAlpha ? blendColors(fg, destCell.bg) : fg;
+          finalFg = hasFgAlpha ? blendColors(fg2, destCell.bg) : fg2;
         }
         const finalAttributes = preserveChar ? destCell.attributes : attributes;
-        const finalBg = RGBA.fromValues(blendedBgRgb.r, blendedBgRgb.g, blendedBgRgb.b, bg.a);
+        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, fg, bg, attributes);
+    this.setCell(x, y, char, fg2, bg2, attributes);
   }
-  drawText(text, x, y, fg, bg, attributes = 0, selection) {
+  drawText(text, x, y, fg2, bg2, attributes = 0, selection) {
     if (!selection) {
-      this.drawTextFFI.call(this, text, x, y, fg, bg, attributes);
+      this.drawTextFFI.call(this, text, x, y, fg2, bg2, attributes);
       return;
     }
     const { start, end } = selection;
@@ -5658,15 +5992,15 @@ class OptimizedBuffer {
     let selectionFg;
     if (selection.bgColor) {
       selectionBg = selection.bgColor;
-      selectionFg = selection.fgColor || fg;
+      selectionFg = selection.fgColor || fg2;
     } else {
-      const defaultBg = bg || RGBA.fromValues(0, 0, 0, 0);
+      const defaultBg = bg2 || RGBA.fromValues(0, 0, 0, 0);
       selectionFg = defaultBg.a > 0 ? defaultBg : RGBA.fromValues(0, 0, 0, 1);
-      selectionBg = fg;
+      selectionBg = fg2;
     }
     if (start > 0) {
       const beforeText = text.slice(0, start);
-      this.drawTextFFI.call(this, beforeText, x, y, fg, bg, attributes);
+      this.drawTextFFI.call(this, beforeText, x, y, fg2, bg2, attributes);
     }
     if (end > start) {
       const selectedText = text.slice(start, end);
@@ -5674,29 +6008,29 @@ class OptimizedBuffer {
     }
     if (end < text.length) {
       const afterText = text.slice(end);
-      this.drawTextFFI.call(this, afterText, x + end, y, fg, bg, attributes);
+      this.drawTextFFI.call(this, afterText, x + end, y, fg2, bg2, attributes);
     }
   }
-  fillRect(x, y, width, height, bg) {
+  fillRect(x, y, width, height, bg2) {
     if (this.useFFI) {
-      this.fillRectFFI(x, y, width, height, bg);
+      this.fillRectFFI(x, y, width, height, bg2);
     } else {
-      this.fillRectLocal(x, y, width, height, bg);
+      this.fillRectLocal(x, y, width, height, bg2);
     }
   }
-  fillRectLocal(x, y, width, height, bg) {
+  fillRectLocal(x, y, width, height, bg2) {
     const startX = Math.max(0, x);
     const startY = Math.max(0, y);
     const endX = Math.min(this.getWidth() - 1, x + width - 1);
     const endY = Math.min(this.getHeight() - 1, y + height - 1);
     if (startX > endX || startY > endY)
       return;
-    const hasAlpha = isRGBAWithAlpha(bg);
+    const hasAlpha = isRGBAWithAlpha(bg2);
     if (hasAlpha) {
-      const fg = RGBA.fromValues(1, 1, 1, 1);
+      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, " ", fg, bg, 0);
+          this.setCellWithAlphaBlending(fillX, fillY, " ", fg2, bg2, 0);
         }
       }
     } else {
@@ -5710,10 +6044,10 @@ class OptimizedBuffer {
           this.buffer.fg[colorIndex + 1] = 1;
           this.buffer.fg[colorIndex + 2] = 1;
           this.buffer.fg[colorIndex + 3] = 1;
-          this.buffer.bg[colorIndex] = bg.r;
-          this.buffer.bg[colorIndex + 1] = bg.g;
-          this.buffer.bg[colorIndex + 2] = bg.b;
-          this.buffer.bg[colorIndex + 3] = bg.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;
         }
       }
     }
@@ -5777,10 +6111,10 @@ class OptimizedBuffer {
           continue;
         }
         const charCode = frameBuffer.buffer.char[srcIndex];
-        const fg = RGBA.fromArray(frameBuffer.buffer.fg.slice(srcColorIndex, srcColorIndex + 4));
-        const bg = RGBA.fromArray(frameBuffer.buffer.bg.slice(srcColorIndex, srcColorIndex + 4));
+        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), fg, bg, attributes);
+        this.setCellWithAlphaBlending(dX, dY, String.fromCharCode(charCode), fg2, bg2, attributes);
       }
     }
   }
@@ -5799,11 +6133,11 @@ class OptimizedBuffer {
   drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.lib.bufferDrawPackedBuffer(this.bufferPtr, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
-  setCellWithAlphaBlendingFFI(x, y, char, fg, bg, attributes) {
-    this.lib.bufferSetCellWithAlphaBlending(this.bufferPtr, x, y, char, fg, bg, attributes);
+  setCellWithAlphaBlendingFFI(x, y, char, fg2, bg2, attributes) {
+    this.lib.bufferSetCellWithAlphaBlending(this.bufferPtr, x, y, char, fg2, bg2, attributes);
   }
-  fillRectFFI(x, y, width, height, bg) {
-    this.lib.bufferFillRect(this.bufferPtr, x, y, width, height, bg);
+  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)
@@ -5812,11 +6146,11 @@ class OptimizedBuffer {
     this.height = height;
     this.buffer = this.lib.bufferResize(this.bufferPtr, width, height);
   }
-  clearFFI(bg = RGBA.fromValues(0, 0, 0, 1)) {
-    this.lib.bufferClear(this.bufferPtr, bg);
+  clearFFI(bg2 = RGBA.fromValues(0, 0, 0, 1)) {
+    this.lib.bufferClear(this.bufferPtr, bg2);
   }
-  drawTextFFI(text, x, y, fg = RGBA.fromValues(1, 1, 1, 1), bg, attributes = 0) {
-    this.lib.bufferDrawText(this.bufferPtr, text, x, y, fg, bg, attributes);
+  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);
@@ -5832,91 +6166,91 @@ class OptimizedBuffer {
 function applyScanlines(buffer, strength = 0.8, step = 2) {
   const width = buffer.getWidth();
   const height = buffer.getHeight();
-  const bg = buffer.buffers.bg;
+  const bg2 = buffer.buffers.bg;
   for (let y = 0;y < height; y += step) {
     for (let x = 0;x < width; x++) {
       const colorIndex = (y * width + x) * 4;
-      bg[colorIndex] *= strength;
-      bg[colorIndex + 1] *= strength;
-      bg[colorIndex + 2] *= strength;
+      bg2[colorIndex] *= strength;
+      bg2[colorIndex + 1] *= strength;
+      bg2[colorIndex + 2] *= strength;
     }
   }
 }
 function applyGrayscale(buffer) {
   const size = buffer.getWidth() * buffer.getHeight();
-  const fg = buffer.buffers.fg;
-  const bg = buffer.buffers.bg;
+  const fg2 = buffer.buffers.fg;
+  const bg2 = buffer.buffers.bg;
   for (let i = 0;i < size; i++) {
     const colorIndex = i * 4;
-    const fgR = fg[colorIndex];
-    const fgG = fg[colorIndex + 1];
-    const fgB = fg[colorIndex + 2];
+    const fgR = fg2[colorIndex];
+    const fgG = fg2[colorIndex + 1];
+    const fgB = fg2[colorIndex + 2];
     const fgLum = 0.299 * fgR + 0.587 * fgG + 0.114 * fgB;
-    fg[colorIndex] = fgLum;
-    fg[colorIndex + 1] = fgLum;
-    fg[colorIndex + 2] = fgLum;
-    const bgR = bg[colorIndex];
-    const bgG = bg[colorIndex + 1];
-    const bgB = bg[colorIndex + 2];
+    fg2[colorIndex] = fgLum;
+    fg2[colorIndex + 1] = fgLum;
+    fg2[colorIndex + 2] = fgLum;
+    const bgR = bg2[colorIndex];
+    const bgG = bg2[colorIndex + 1];
+    const bgB = bg2[colorIndex + 2];
     const bgLum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB;
-    bg[colorIndex] = bgLum;
-    bg[colorIndex + 1] = bgLum;
-    bg[colorIndex + 2] = bgLum;
+    bg2[colorIndex] = bgLum;
+    bg2[colorIndex + 1] = bgLum;
+    bg2[colorIndex + 2] = bgLum;
   }
 }
 function applySepia(buffer) {
   const size = buffer.getWidth() * buffer.getHeight();
-  const fg = buffer.buffers.fg;
-  const bg = buffer.buffers.bg;
+  const fg2 = buffer.buffers.fg;
+  const bg2 = buffer.buffers.bg;
   for (let i = 0;i < size; i++) {
     const colorIndex = i * 4;
-    let fgR = fg[colorIndex];
-    let fgG = fg[colorIndex + 1];
-    let fgB = fg[colorIndex + 2];
+    let fgR = fg2[colorIndex];
+    let fgG = fg2[colorIndex + 1];
+    let fgB = fg2[colorIndex + 2];
     let newFgR = Math.min(1, fgR * 0.393 + fgG * 0.769 + fgB * 0.189);
     let newFgG = Math.min(1, fgR * 0.349 + fgG * 0.686 + fgB * 0.168);
     let newFgB = Math.min(1, fgR * 0.272 + fgG * 0.534 + fgB * 0.131);
-    fg[colorIndex] = newFgR;
-    fg[colorIndex + 1] = newFgG;
-    fg[colorIndex + 2] = newFgB;
-    let bgR = bg[colorIndex];
-    let bgG = bg[colorIndex + 1];
-    let bgB = bg[colorIndex + 2];
+    fg2[colorIndex] = newFgR;
+    fg2[colorIndex + 1] = newFgG;
+    fg2[colorIndex + 2] = newFgB;
+    let bgR = bg2[colorIndex];
+    let bgG = bg2[colorIndex + 1];
+    let bgB = bg2[colorIndex + 2];
     let newBgR = Math.min(1, bgR * 0.393 + bgG * 0.769 + bgB * 0.189);
     let newBgG = Math.min(1, bgR * 0.349 + bgG * 0.686 + bgB * 0.168);
     let newBgB = Math.min(1, bgR * 0.272 + bgG * 0.534 + bgB * 0.131);
-    bg[colorIndex] = newBgR;
-    bg[colorIndex + 1] = newBgG;
-    bg[colorIndex + 2] = newBgB;
+    bg2[colorIndex] = newBgR;
+    bg2[colorIndex + 1] = newBgG;
+    bg2[colorIndex + 2] = newBgB;
   }
 }
 function applyInvert(buffer) {
   const size = buffer.getWidth() * buffer.getHeight();
-  const fg = buffer.buffers.fg;
-  const bg = buffer.buffers.bg;
+  const fg2 = buffer.buffers.fg;
+  const bg2 = buffer.buffers.bg;
   for (let i = 0;i < size; i++) {
     const colorIndex = i * 4;
-    fg[colorIndex] = 1 - fg[colorIndex];
-    fg[colorIndex + 1] = 1 - fg[colorIndex + 1];
-    fg[colorIndex + 2] = 1 - fg[colorIndex + 2];
-    bg[colorIndex] = 1 - bg[colorIndex];
-    bg[colorIndex + 1] = 1 - bg[colorIndex + 1];
-    bg[colorIndex + 2] = 1 - bg[colorIndex + 2];
+    fg2[colorIndex] = 1 - fg2[colorIndex];
+    fg2[colorIndex + 1] = 1 - fg2[colorIndex + 1];
+    fg2[colorIndex + 2] = 1 - fg2[colorIndex + 2];
+    bg2[colorIndex] = 1 - bg2[colorIndex];
+    bg2[colorIndex + 1] = 1 - bg2[colorIndex + 1];
+    bg2[colorIndex + 2] = 1 - bg2[colorIndex + 2];
   }
 }
 function applyNoise(buffer, strength = 0.1) {
   const size = buffer.getWidth() * buffer.getHeight();
-  const fg = buffer.buffers.fg;
-  const bg = buffer.buffers.bg;
+  const fg2 = buffer.buffers.fg;
+  const bg2 = buffer.buffers.bg;
   for (let i = 0;i < size; i++) {
     const colorIndex = i * 4;
     const noise = (Math.random() - 0.5) * strength;
-    fg[colorIndex] = Math.max(0, Math.min(1, fg[colorIndex] + noise));
-    fg[colorIndex + 1] = Math.max(0, Math.min(1, fg[colorIndex + 1] + noise));
-    fg[colorIndex + 2] = Math.max(0, Math.min(1, fg[colorIndex + 2] + noise));
-    bg[colorIndex] = Math.max(0, Math.min(1, bg[colorIndex] + noise));
-    bg[colorIndex + 1] = Math.max(0, Math.min(1, bg[colorIndex + 1] + noise));
-    bg[colorIndex + 2] = Math.max(0, Math.min(1, bg[colorIndex + 2] + noise));
+    fg2[colorIndex] = Math.max(0, Math.min(1, fg2[colorIndex] + noise));
+    fg2[colorIndex + 1] = Math.max(0, Math.min(1, fg2[colorIndex + 1] + noise));
+    fg2[colorIndex + 2] = Math.max(0, Math.min(1, fg2[colorIndex + 2] + noise));
+    bg2[colorIndex] = Math.max(0, Math.min(1, bg2[colorIndex] + noise));
+    bg2[colorIndex + 1] = Math.max(0, Math.min(1, bg2[colorIndex + 1] + noise));
+    bg2[colorIndex + 2] = Math.max(0, Math.min(1, bg2[colorIndex + 2] + noise));
   }
 }
 function applyChromaticAberration(buffer, strength = 1) {
@@ -5947,15 +6281,15 @@ function applyAsciiArt(buffer, ramp = " .:-=+*#%@") {
   const width = buffer.getWidth();
   const height = buffer.getHeight();
   const chars = buffer.buffers.char;
-  const bg = buffer.buffers.bg;
+  const bg2 = buffer.buffers.bg;
   const rampLength = ramp.length;
   for (let y = 0;y < height; y++) {
     for (let x = 0;x < width; x++) {
       const index = y * width + x;
       const colorIndex = index * 4;
-      const bgR = bg[colorIndex];
-      const bgG = bg[colorIndex + 1];
-      const bgB = bg[colorIndex + 2];
+      const bgR = bg2[colorIndex];
+      const bgG = bg2[colorIndex + 1];
+      const bgB = bg2[colorIndex + 2];
       const lum = 0.299 * bgR + 0.587 * bgG + 0.114 * bgB;
       const rampIndex = Math.min(rampLength - 1, Math.floor(lum * rampLength));
       chars[index] = ramp[rampIndex].charCodeAt(0);
@@ -6215,20 +6549,20 @@ class BrightnessEffect {
   }
   apply(buffer) {
     const size = buffer.getWidth() * buffer.getHeight();
-    const fg = buffer.buffers.fg;
-    const bg = buffer.buffers.bg;
+    const fg2 = buffer.buffers.fg;
+    const bg2 = buffer.buffers.bg;
     const factor = this._brightness;
     if (factor === 1) {
       return;
     }
     for (let i = 0;i < size; i++) {
       const colorIndex = i * 4;
-      fg[colorIndex] = Math.min(1, fg[colorIndex] * factor);
-      fg[colorIndex + 1] = Math.min(1, fg[colorIndex + 1] * factor);
-      fg[colorIndex + 2] = Math.min(1, fg[colorIndex + 2] * factor);
-      bg[colorIndex] = Math.min(1, bg[colorIndex] * factor);
-      bg[colorIndex + 1] = Math.min(1, bg[colorIndex + 1] * factor);
-      bg[colorIndex + 2] = Math.min(1, bg[colorIndex + 2] * factor);
+      fg2[colorIndex] = Math.min(1, fg2[colorIndex] * factor);
+      fg2[colorIndex + 1] = Math.min(1, fg2[colorIndex + 1] * factor);
+      fg2[colorIndex + 2] = Math.min(1, fg2[colorIndex + 2] * factor);
+      bg2[colorIndex] = Math.min(1, bg2[colorIndex] * factor);
+      bg2[colorIndex + 1] = Math.min(1, bg2[colorIndex + 1] * factor);
+      bg2[colorIndex + 2] = Math.min(1, bg2[colorIndex + 2] * factor);
     }
   }
 }
@@ -6480,45 +6814,45 @@ class BloomEffect {
 }
 // src/animation/Timeline.ts
 var easingFunctions = {
-  linear: (t) => t,
-  inQuad: (t) => t * t,
-  outQuad: (t) => t * (2 - t),
-  inOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
-  inExpo: (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1)),
-  outExpo: (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t),
-  inOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
-  outBounce: (t) => {
+  linear: (t2) => t2,
+  inQuad: (t2) => t2 * t2,
+  outQuad: (t2) => t2 * (2 - t2),
+  inOutQuad: (t2) => t2 < 0.5 ? 2 * t2 * t2 : -1 + (4 - 2 * t2) * t2,
+  inExpo: (t2) => t2 === 0 ? 0 : Math.pow(2, 10 * (t2 - 1)),
+  outExpo: (t2) => t2 === 1 ? 1 : 1 - Math.pow(2, -10 * t2),
+  inOutSine: (t2) => -(Math.cos(Math.PI * t2) - 1) / 2,
+  outBounce: (t2) => {
     const n1 = 7.5625;
     const d1 = 2.75;
-    if (t < 1 / d1) {
-      return n1 * t * t;
-    } else if (t < 2 / d1) {
-      return n1 * (t -= 1.5 / d1) * t + 0.75;
-    } else if (t < 2.5 / d1) {
-      return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    if (t2 < 1 / d1) {
+      return n1 * t2 * t2;
+    } else if (t2 < 2 / d1) {
+      return n1 * (t2 -= 1.5 / d1) * t2 + 0.75;
+    } else if (t2 < 2.5 / d1) {
+      return n1 * (t2 -= 2.25 / d1) * t2 + 0.9375;
     } else {
-      return n1 * (t -= 2.625 / d1) * t + 0.984375;
+      return n1 * (t2 -= 2.625 / d1) * t2 + 0.984375;
     }
   },
-  outElastic: (t) => {
+  outElastic: (t2) => {
     const c4 = 2 * Math.PI / 3;
-    return t === 0 ? 0 : t === 1 ? 1 : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    return t2 === 0 ? 0 : t2 === 1 ? 1 : Math.pow(2, -10 * t2) * Math.sin((t2 * 10 - 0.75) * c4) + 1;
   },
-  inBounce: (t) => 1 - easingFunctions.outBounce(1 - t),
-  inCirc: (t) => 1 - Math.sqrt(1 - t * t),
-  outCirc: (t) => Math.sqrt(1 - Math.pow(t - 1, 2)),
-  inOutCirc: (t) => {
-    if ((t *= 2) < 1)
-      return -0.5 * (Math.sqrt(1 - t * t) - 1);
-    return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
+  inBounce: (t2) => 1 - easingFunctions.outBounce(1 - t2),
+  inCirc: (t2) => 1 - Math.sqrt(1 - t2 * t2),
+  outCirc: (t2) => Math.sqrt(1 - Math.pow(t2 - 1, 2)),
+  inOutCirc: (t2) => {
+    if ((t2 *= 2) < 1)
+      return -0.5 * (Math.sqrt(1 - t2 * t2) - 1);
+    return 0.5 * (Math.sqrt(1 - (t2 -= 2) * t2) + 1);
   },
-  inBack: (t, s = 1.70158) => t * t * ((s + 1) * t - s),
-  outBack: (t, s = 1.70158) => --t * t * ((s + 1) * t + s) + 1,
-  inOutBack: (t, s = 1.70158) => {
+  inBack: (t2, s = 1.70158) => t2 * t2 * ((s + 1) * t2 - s),
+  outBack: (t2, s = 1.70158) => --t2 * t2 * ((s + 1) * t2 + s) + 1,
+  inOutBack: (t2, s = 1.70158) => {
     s *= 1.525;
-    if ((t *= 2) < 1)
-      return 0.5 * (t * t * ((s + 1) * t - s));
-    return 0.5 * ((t -= 2) * t * ((s + 1) * t + s) + 2);
+    if ((t2 *= 2) < 1)
+      return 0.5 * (t2 * t2 * ((s + 1) * t2 - s));
+    return 0.5 * ((t2 -= 2) * t2 * ((s + 1) * t2 + s) + 2);
   }
 };
 function captureInitialValues(item) {
@@ -6850,182 +7184,6 @@ function createTimeline(options = {}) {
   engine.register(timeline);
   return timeline;
 }
-// src/lib/styled-text.ts
-var textEncoder = new TextEncoder;
-
-class StyledText {
-  chunks;
-  _length;
-  _plainText;
-  constructor(chunks, length, plainText) {
-    this.chunks = chunks;
-    this._length = length;
-    this._plainText = plainText;
-  }
-  toString() {
-    return this._plainText;
-  }
-  get length() {
-    return this._length;
-  }
-}
-function stringToStyledText(content) {
-  const textEncoder2 = new TextEncoder;
-  const chunk = {
-    __isChunk: true,
-    text: textEncoder2.encode(content),
-    plainText: content
-  };
-  return new StyledText([chunk], content.length, content);
-}
-var templateCache = new WeakMap;
-function applyStyle(input, style) {
-  if (typeof input === "object" && "__isChunk" in input) {
-    const existingChunk = input;
-    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
-    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
-    const newAttrs = createTextAttributes(style);
-    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
-    return {
-      __isChunk: true,
-      text: existingChunk.text,
-      plainText: existingChunk.plainText,
-      fg,
-      bg,
-      attributes: mergedAttrs
-    };
-  } else {
-    const plainTextStr = String(input);
-    const text = textEncoder.encode(plainTextStr);
-    const fg = style.fg ? parseColor(style.fg) : undefined;
-    const bg = style.bg ? parseColor(style.bg) : undefined;
-    const attributes = createTextAttributes(style);
-    return {
-      __isChunk: true,
-      text,
-      plainText: plainTextStr,
-      fg,
-      bg,
-      attributes
-    };
-  }
-}
-var black = (input) => applyStyle(input, { fg: "black" });
-var red = (input) => applyStyle(input, { fg: "red" });
-var green = (input) => applyStyle(input, { fg: "green" });
-var yellow = (input) => applyStyle(input, { fg: "yellow" });
-var blue = (input) => applyStyle(input, { fg: "blue" });
-var magenta = (input) => applyStyle(input, { fg: "magenta" });
-var cyan = (input) => applyStyle(input, { fg: "cyan" });
-var white = (input) => applyStyle(input, { fg: "white" });
-var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
-var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
-var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
-var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
-var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
-var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
-var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
-var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
-var bgBlack = (input) => applyStyle(input, { bg: "black" });
-var bgRed = (input) => applyStyle(input, { bg: "red" });
-var bgGreen = (input) => applyStyle(input, { bg: "green" });
-var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
-var bgBlue = (input) => applyStyle(input, { bg: "blue" });
-var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
-var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
-var bgWhite = (input) => applyStyle(input, { bg: "white" });
-var bold = (input) => applyStyle(input, { bold: true });
-var italic = (input) => applyStyle(input, { italic: true });
-var underline = (input) => applyStyle(input, { underline: true });
-var strikethrough = (input) => applyStyle(input, { strikethrough: true });
-var dim = (input) => applyStyle(input, { dim: true });
-var reverse = (input) => applyStyle(input, { reverse: true });
-var blink = (input) => applyStyle(input, { blink: true });
-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) {
-      chunks.push({
-        __isChunk: true,
-        text: textEncoder.encode(raw),
-        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({
-        __isChunk: true,
-        text: textEncoder.encode(plainTextStr),
-        plainText: plainTextStr,
-        attributes: 0
-      });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
-    }
-  }
-  return new StyledText(chunks, length, plainText);
-}
-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++) {
-      const raw = strings[i];
-      if (raw) {
-        cachedStringChunks.push({
-          __isChunk: true,
-          text: textEncoder.encode(raw),
-          plainText: raw,
-          attributes: 0
-        });
-      } else {
-        cachedStringChunks.push(null);
-      }
-    }
-    templateCache.set(strings, cachedStringChunks);
-  }
-  const chunks = [];
-  for (let i = 0;i < strings.length; i++) {
-    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({
-        __isChunk: true,
-        text: textEncoder.encode(plainTextStr),
-        plainText: plainTextStr,
-        attributes: 0
-      });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
-    }
-  }
-  return new StyledText(chunks, length, plainText);
-}
 // src/lib/selection.ts
 class Selection {
   _anchor;
@@ -7298,7 +7456,10 @@ var ANSI = {
   enableAnyEventTracking: "\x1B[?1003h",
   disableAnyEventTracking: "\x1B[?1003l",
   enableSGRMouseMode: "\x1B[?1006h",
-  disableSGRMouseMode: "\x1B[?1006l"
+  disableSGRMouseMode: "\x1B[?1006l",
+  makeRoomForRenderer: (height) => `
+`.repeat(height) + `\x1B[${height}A`,
+  clearRendererSpace: (height) => `\x1B[${height}A\x1B[1G\x1B[J`
 };
 
 // src/console.ts
@@ -7473,6 +7634,13 @@ var terminalConsoleCache = new TerminalConsoleCache;
 process.on("exit", () => {
   terminalConsoleCache.destroy();
 });
+var ConsolePosition;
+((ConsolePosition2) => {
+  ConsolePosition2["TOP"] = "top";
+  ConsolePosition2["BOTTOM"] = "bottom";
+  ConsolePosition2["LEFT"] = "left";
+  ConsolePosition2["RIGHT"] = "right";
+})(ConsolePosition ||= {});
 var DEFAULT_CONSOLE_OPTIONS = {
   position: "bottom" /* BOTTOM */,
   sizePercent: 30,
@@ -8089,6 +8257,11 @@ var MouseButton;
   MouseButton2[MouseButton2["WHEEL_UP"] = 4] = "WHEEL_UP";
   MouseButton2[MouseButton2["WHEEL_DOWN"] = 5] = "WHEEL_DOWN";
 })(MouseButton ||= {});
+["SIGINT", "SIGTERM", "SIGQUIT", "SIGABRT"].forEach((signal) => {
+  process.on(signal, () => {
+    process.exit();
+  });
+});
 async function createCliRenderer(config = {}) {
   if (process.argv.includes("--delay-start")) {
     await new Promise((resolve) => setTimeout(resolve, 5000));
@@ -8125,7 +8298,6 @@ class CliRenderer extends EventEmitter6 {
   stdout;
   exitOnCtrlC;
   isDestroyed = false;
-  isShuttingDown = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -8147,6 +8319,7 @@ class CliRenderer extends EventEmitter6 {
   postProcessFns = [];
   backgroundColor = RGBA.fromHex("#000000");
   waitingForPixelResolution = false;
+  shutdownRequested = null;
   rendering = false;
   renderingNative = false;
   renderTimeout = null;
@@ -8250,8 +8423,6 @@ class CliRenderer extends EventEmitter6 {
     }
     this.stdout.write = this.interceptStdoutWrite.bind(this);
     this.sigwinchHandler = () => {
-      if (this.isShuttingDown)
-        return;
       const width2 = this.stdout.columns || 80;
       const height2 = this.stdout.rows || 24;
       this.handleResize(width2, height2);
@@ -8259,6 +8430,7 @@ class CliRenderer extends EventEmitter6 {
     process.on("SIGWINCH", this.sigwinchHandler);
     const handleError = (error) => {
       this.stop();
+      this.destroy();
       new Promise((resolve) => {
         setTimeout(() => {
           resolve(true);
@@ -8292,8 +8464,7 @@ Error details:
     };
     process.on("uncaughtException", handleError);
     process.on("unhandledRejection", handleError);
-    process.on("exit", (code) => {
-      this.stop();
+    process.on("exit", () => {
       this.destroy();
     });
     this._console = new TerminalConsole(this, config.consoleOptions);
@@ -8312,6 +8483,13 @@ Error details:
     }
     global.window.requestAnimationFrame = requestAnimationFrame;
     this.queryPixelResolution();
+    if (process.env.OTUI_NO_NATIVE_RENDER === "true") {
+      this.renderNative = () => {
+        if (this._splitHeight > 0) {
+          this.flushStdoutCache(this._splitHeight);
+        }
+      };
+    }
   }
   writeOut(chunk, encoding, callback) {
     return this.realStdoutWrite.call(this.stdout, chunk, encoding, callback);
@@ -8443,30 +8621,17 @@ Error details:
     return true;
   }
   enableMouse() {
-    this.writeOut(ANSI.enableSGRMouseMode);
-    this.writeOut(ANSI.enableMouseTracking);
-    this.writeOut(ANSI.enableButtonEventTracking);
-    if (this.enableMouseMovement) {
-      this.writeOut(ANSI.enableAnyEventTracking);
-    }
+    this.lib.enableMouse(this.rendererPtr, this.enableMouseMovement);
   }
   disableMouse() {
-    if (this.enableMouseMovement) {
-      this.writeOut(ANSI.disableAnyEventTracking);
-    }
-    this.writeOut(ANSI.disableButtonEventTracking);
-    this.writeOut(ANSI.disableMouseTracking);
-    this.writeOut(ANSI.disableSGRMouseMode);
     this.capturedRenderable = undefined;
     this.mouseParser.reset();
+    this.lib.disableMouse(this.rendererPtr);
   }
   set useThread(useThread) {
     this._useThread = useThread;
     this.lib.setUseThread(this.rendererPtr, useThread);
   }
-  setTerminalSize(width, height) {
-    this.handleResize(width, height);
-  }
   setupTerminal() {
     this.writeOut(ANSI.saveCursorState);
     if (this.stdin.setRawMode) {
@@ -8493,7 +8658,7 @@ Error details:
       }
       if (this.exitOnCtrlC && str === "\x03") {
         process.nextTick(() => {
-          process.exit(0);
+          process.exit();
         });
         return;
       }
@@ -8504,6 +8669,8 @@ Error details:
     });
     if (this._useAlternateScreen) {
       this.writeOut(ANSI.switchToAlternateScreen);
+    } else {
+      this.writeOut(ANSI.makeRoomForRenderer(this.height - 1));
     }
     this.setCursorPosition(0, 0, false);
   }
@@ -8625,7 +8792,7 @@ Error details:
     }
   }
   handleResize(width, height) {
-    if (this.isShuttingDown)
+    if (this.isDestroyed)
       return;
     if (this._splitHeight > 0) {
       this.processResize(width, height);
@@ -8762,44 +8929,31 @@ Error details:
     this._isRunning = false;
   }
   stop() {
-    if (this.isShuttingDown)
+    if (this.isRunning && !this.isDestroyed) {
+      this._isRunning = false;
+      if (this.memorySnapshotTimer) {
+        clearInterval(this.memorySnapshotTimer);
+        this.memorySnapshotTimer = null;
+      }
+      if (this.renderTimeout) {
+        clearTimeout(this.renderTimeout);
+        this.renderTimeout = null;
+      }
+    }
+  }
+  destroy() {
+    if (this.isDestroyed)
       return;
-    this._isRunning = false;
-    this.isShuttingDown = true;
+    this.isDestroyed = true;
     this.waitingForPixelResolution = false;
+    this.capturedRenderable = undefined;
     if (this.sigwinchHandler) {
       process.removeListener("SIGWINCH", this.sigwinchHandler);
       this.sigwinchHandler = null;
     }
     this._console.deactivate();
+    this.lib.destroyRenderer(this.rendererPtr, this._useAlternateScreen, this._splitHeight);
     this.disableStdoutInterception();
-    if (this.renderTimeout) {
-      clearTimeout(this.renderTimeout);
-      this.renderTimeout = null;
-    }
-    if (this.memorySnapshotTimer) {
-      clearInterval(this.memorySnapshotTimer);
-      this.memorySnapshotTimer = null;
-    }
-    if (this._splitHeight > 0) {
-      const consoleEndLine = this._terminalHeight - this._splitHeight;
-      this.writeOut(ANSI.moveCursor(consoleEndLine, 1));
-    }
-    this.capturedRenderable = undefined;
-    if (this._useMouse) {
-      this.disableMouse();
-    }
-    this.writeOut(ANSI.resetCursorColor);
-    this.writeOut(ANSI.showCursor);
-    if (this._useAlternateScreen) {
-      this.writeOut(ANSI.switchToMainScreen);
-    }
-  }
-  destroy() {
-    if (this.isDestroyed)
-      return;
-    this.lib.destroyRenderer(this.rendererPtr);
-    this.isDestroyed = true;
   }
   startRenderLoop() {
     if (!this._isRunning)
@@ -8812,7 +8966,7 @@ Error details:
     this.loop();
   }
   async loop() {
-    if (this.rendering)
+    if (this.rendering || this.isDestroyed)
       return;
     this.rendering = true;
     if (this.renderTimeout) {
@@ -9217,8 +9371,6 @@ class TextRenderable extends Renderable {
   set content(value) {
     this._text = typeof value === "string" ? stringToStyledText(value) : value;
     this.updateTextInfo();
-    this.setupMeasureFunc();
-    this.needsUpdate();
   }
   get fg() {
     return this._defaultFg;
@@ -9280,8 +9432,8 @@ class TextRenderable extends Renderable {
     const changed = this.selectionHelper.reevaluateSelection(this.width, this.height);
     if (changed) {
       this.syncSelectionToTextBuffer();
-      this.needsUpdate();
     }
+    this.needsUpdate();
   }
   setupMeasureFunc() {
     if (this._positionType === "relative" && this._width === "auto") {
@@ -10286,6 +10438,7 @@ export {
   isDimensionType,
   hsvToRgb,
   hexToRgb,
+  hastToStyledText,
   green,
   getKeyHandler,
   getCharacterPositions,
@@ -10301,6 +10454,7 @@ export {
   createTextAttributes,
   createCliRenderer,
   coordinateToCharacterIndex,
+  capture,
   brightYellow,
   brightWhite,
   brightRed,
@@ -10337,8 +10491,10 @@ export {
   TextRenderable,
   TextBuffer,
   TextAttributes,
+  TerminalConsole,
   TabSelectRenderableEvents,
   TabSelectRenderable,
+  SyntaxStyle,
   StyledText,
   Selection,
   SelectRenderableEvents,
@@ -10358,6 +10514,7 @@ export {
   FrameBufferRenderable,
   DistortionEffect,
   DebugOverlayCorner,
+  ConsolePosition,
   CliRenderer,
   CliRenderEvents,
   BrightnessEffect,