@jitl/opentui-core 0.1.97 → 0.2.15

package/{index-yxe6e14n.js → index-46f5e8m6.js}

@@ -6,18 +6,20 @@ import {
   BaseRenderable,
   BorderCharArrays,
   BorderChars,
+  BoxRenderable,
   CliRenderEvents,
   CliRenderer,
+  CodeRenderable,
   ConsolePosition,
+  DEFAULT_BACKGROUND_RGB,
+  DEFAULT_FOREGROUND_RGB,
   DataPathsManager,
   DebugOverlayCorner,
-  Edge,
   EditBuffer,
   EditBufferRenderable,
   EditBufferRenderableEvents,
   EditorView,
   ExtmarksController,
-  Gutter,
   InternalKeyHandler,
   KeyEvent,
   KeyHandler,
@@ -36,18 +38,25 @@ import {
   RenderableEvents,
   RendererControlState,
   RootRenderable,
+  RootTextNodeRenderable,
   Selection,
   SpanInfoStruct,
   StdinParser,
   StyledText,
+  SyntaxStyle,
   SystemClock,
   TargetChannel,
   TerminalConsole,
   TerminalPalette,
   TextAttributes,
   TextBuffer,
+  TextBufferRenderable,
+  TextBufferView,
+  TextNodeRenderable,
+  TextRenderable,
   TreeSitterClient,
   addDefaultParsers,
+  ansi256IndexToRgb,
   attributesWithLink,
   basenameToFiletype,
   bg,
@@ -74,9 +83,11 @@ import {
   brightYellow,
   buildKeyBindingsMap,
   buildKittyKeyboardFlags,
+  buildTerminalPaletteSignature,
   capture,
   clearEnvCache,
   convertGlobalToLocalSelection,
+  convertThemeToStyles,
   coordinateToCharacterIndex,
   createCliRenderer,
   createExtmarksController,
@@ -102,7 +113,7 @@ import {
   getBorderSides,
   getCharacterPositions,
   getDataPaths,
-  getKeyBindingKey,
+  getKeyBindingAction,
   getLinkId,
   getObjectsInViewport,
   getTreeSitterClient,
@@ -116,18 +127,20 @@ import {
   isEditBufferRenderable,
   isRenderable,
   isStyledText,
+  isTextNodeRenderable,
   isVNode,
   isValidBorderStyle,
-  isValidPercentage,
   italic,
   link,
   magenta,
-  main,
   maybeMakeRenderable,
   measureText,
   mergeKeyAliases,
   mergeKeyBindings,
   nonAlphanumericKeys,
+  normalizeColorValue,
+  normalizeIndexedColorIndex,
+  normalizeTerminalPalette,
   parseAlign,
   parseAlignItems,
   parseBorderStyle,
@@ -160,7 +173,7 @@ import {
   stringWidth,
   stripAnsiSequences,
   t,
-  toArrayBuffer,
+  terminalNamedSingleStrokeKeys,
   treeSitterToStyledText,
   treeSitterToTextChunks,
   underline,
@@ -168,10 +181,13 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-rhfjv9c1.js";
+} from "./index-g9agybj3.js";
+import {
+  toArrayBuffer
+} from "./index-5zwezmgj.js";
 import {
   __export
-} from "./index-re3ntm60.js";
+} from "./index-k18nf2r7.js";
 
 // src/index.ts
 var exports_src2 = {};
@@ -181,14 +197,15 @@ __export(exports_src2, {
   white: () => white,
   vstyles: () => vstyles,
   visualizeRenderableTree: () => visualizeRenderableTree,
-  updateAssets: () => main,
   underline: () => underline,
   treeSitterToTextChunks: () => treeSitterToTextChunks,
   treeSitterToStyledText: () => treeSitterToStyledText,
+  terminalNamedSingleStrokeKeys: () => terminalNamedSingleStrokeKeys,
   t: () => t,
   stripAnsiSequences: () => stripAnsiSequences,
   stringToStyledText: () => stringToStyledText,
   strikethrough: () => strikethrough,
+  setupAudio: () => setupAudio,
   setRenderLibPath: () => setRenderLibPath,
   rgbToHex: () => rgbToHex,
   reverse: () => reverse,
@@ -218,6 +235,9 @@ __export(exports_src2, {
   parseBorderStyle: () => parseBorderStyle,
   parseAlignItems: () => parseAlignItems,
   parseAlign: () => parseAlign,
+  normalizeTerminalPalette: () => normalizeTerminalPalette,
+  normalizeIndexedColorIndex: () => normalizeIndexedColorIndex,
+  normalizeColorValue: () => normalizeColorValue,
   nonAlphanumericKeys: () => nonAlphanumericKeys,
   measureText: () => measureText,
   maybeMakeRenderable: () => maybeMakeRenderable,
@@ -256,6 +276,7 @@ __export(exports_src2, {
   dim: () => dim,
   detectLinks: () => detectLinks,
   delegate: () => delegate,
+  defaultTextareaKeyBindings: () => defaultTextareaKeyBindings,
   decodePasteBytes: () => decodePasteBytes,
   cyan: () => cyan,
   createTimeline: () => createTimeline,
@@ -270,6 +291,7 @@ __export(exports_src2, {
   convertGlobalToLocalSelection: () => convertGlobalToLocalSelection,
   clearEnvCache: () => clearEnvCache,
   capture: () => capture,
+  buildTerminalPaletteSignature: () => buildTerminalPaletteSignature,
   buildKittyKeyboardFlags: () => buildKittyKeyboardFlags,
   brightYellow: () => brightYellow,
   brightWhite: () => brightWhite,
@@ -303,6 +325,7 @@ __export(exports_src2, {
   applyChromaticAberration: () => applyChromaticAberration,
   applyBrightness: () => applyBrightness,
   applyAsciiArt: () => applyAsciiArt,
+  ansi256IndexToRgb: () => ansi256IndexToRgb,
   addDefaultParsers: () => addDefaultParsers,
   Yoga: () => exports_src,
   VignetteEffect: () => VignetteEffect,
@@ -390,6 +413,8 @@ __export(exports_src2, {
   DataPathsManager: () => DataPathsManager,
   DEUTERANOPIA_SIM_MATRIX: () => DEUTERANOPIA_SIM_MATRIX,
   DEUTERANOPIA_COMP_MATRIX: () => DEUTERANOPIA_COMP_MATRIX,
+  DEFAULT_FOREGROUND_RGB: () => DEFAULT_FOREGROUND_RGB,
+  DEFAULT_BACKGROUND_RGB: () => DEFAULT_BACKGROUND_RGB,
   ConsolePosition: () => ConsolePosition,
   CodeRenderable: () => CodeRenderable,
   Code: () => Code,
@@ -403,6 +428,7 @@ __export(exports_src2, {
   BorderCharArrays: () => BorderCharArrays,
   BloomEffect: () => BloomEffect,
   BaseRenderable: () => BaseRenderable,
+  Audio: () => Audio,
   ArrowRenderable: () => ArrowRenderable,
   ATTRIBUTE_BASE_MASK: () => ATTRIBUTE_BASE_MASK,
   ATTRIBUTE_BASE_BITS: () => ATTRIBUTE_BASE_BITS,
@@ -412,327 +438,21 @@ __export(exports_src2, {
   ACHROMATOPSIA_MATRIX: () => ACHROMATOPSIA_MATRIX
 });
 
-// src/text-buffer-view.ts
-class TextBufferView {
-  lib;
-  viewPtr;
-  textBuffer;
-  _destroyed = false;
-  constructor(lib, ptr, textBuffer) {
-    this.lib = lib;
-    this.viewPtr = ptr;
-    this.textBuffer = textBuffer;
-  }
-  static create(textBuffer) {
-    const lib = resolveRenderLib();
-    const viewPtr = lib.createTextBufferView(textBuffer.ptr);
-    return new TextBufferView(lib, viewPtr, textBuffer);
-  }
-  guard() {
-    if (this._destroyed)
-      throw new Error("TextBufferView is destroyed");
-  }
-  get ptr() {
-    this.guard();
-    return this.viewPtr;
-  }
-  setSelection(start, end, bgColor, fgColor) {
-    this.guard();
-    this.lib.textBufferViewSetSelection(this.viewPtr, start, end, bgColor || null, fgColor || null);
-  }
-  updateSelection(end, bgColor, fgColor) {
-    this.guard();
-    this.lib.textBufferViewUpdateSelection(this.viewPtr, end, bgColor || null, fgColor || null);
-  }
-  resetSelection() {
-    this.guard();
-    this.lib.textBufferViewResetSelection(this.viewPtr);
-  }
-  getSelection() {
-    this.guard();
-    return this.lib.textBufferViewGetSelection(this.viewPtr);
-  }
-  hasSelection() {
-    this.guard();
-    return this.getSelection() !== null;
-  }
-  setLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
-    this.guard();
-    return this.lib.textBufferViewSetLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
-  }
-  updateLocalSelection(anchorX, anchorY, focusX, focusY, bgColor, fgColor) {
-    this.guard();
-    return this.lib.textBufferViewUpdateLocalSelection(this.viewPtr, anchorX, anchorY, focusX, focusY, bgColor || null, fgColor || null);
-  }
-  resetLocalSelection() {
-    this.guard();
-    this.lib.textBufferViewResetLocalSelection(this.viewPtr);
-  }
-  setWrapWidth(width) {
-    this.guard();
-    this.lib.textBufferViewSetWrapWidth(this.viewPtr, width ?? 0);
-  }
-  setWrapMode(mode) {
-    this.guard();
-    this.lib.textBufferViewSetWrapMode(this.viewPtr, mode);
-  }
-  setViewportSize(width, height) {
-    this.guard();
-    this.lib.textBufferViewSetViewportSize(this.viewPtr, width, height);
-  }
-  setViewport(x, y, width, height) {
-    this.guard();
-    this.lib.textBufferViewSetViewport(this.viewPtr, x, y, width, height);
-  }
-  get lineInfo() {
-    this.guard();
-    return this.lib.textBufferViewGetLineInfo(this.viewPtr);
-  }
-  get logicalLineInfo() {
-    this.guard();
-    return this.lib.textBufferViewGetLogicalLineInfo(this.viewPtr);
-  }
-  getSelectedText() {
-    this.guard();
-    const byteSize = this.textBuffer.byteSize;
-    if (byteSize === 0)
-      return "";
-    const selectedBytes = this.lib.textBufferViewGetSelectedTextBytes(this.viewPtr, byteSize);
-    if (!selectedBytes)
-      return "";
-    return this.lib.decoder.decode(selectedBytes);
-  }
-  getPlainText() {
-    this.guard();
-    const byteSize = this.textBuffer.byteSize;
-    if (byteSize === 0)
-      return "";
-    const plainBytes = this.lib.textBufferViewGetPlainTextBytes(this.viewPtr, byteSize);
-    if (!plainBytes)
-      return "";
-    return this.lib.decoder.decode(plainBytes);
-  }
-  setTabIndicator(indicator) {
-    this.guard();
-    const codePoint = typeof indicator === "string" ? indicator.codePointAt(0) ?? 0 : indicator;
-    this.lib.textBufferViewSetTabIndicator(this.viewPtr, codePoint);
-  }
-  setTabIndicatorColor(color) {
-    this.guard();
-    this.lib.textBufferViewSetTabIndicatorColor(this.viewPtr, color);
-  }
-  setTruncate(truncate) {
-    this.guard();
-    this.lib.textBufferViewSetTruncate(this.viewPtr, truncate);
-  }
-  measureForDimensions(width, height) {
-    this.guard();
-    return this.lib.textBufferViewMeasureForDimensions(this.viewPtr, width, height);
-  }
-  getVirtualLineCount() {
-    this.guard();
-    return this.lib.textBufferViewGetVirtualLineCount(this.viewPtr);
-  }
-  destroy() {
-    if (this._destroyed)
-      return;
-    this._destroyed = true;
-    this.lib.destroyTextBufferView(this.viewPtr);
-  }
+// src/post/effects.ts
+function toU8(value) {
+  return Math.round(Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0)) * 255);
 }
-// src/syntax-style.ts
-function convertThemeToStyles(theme) {
-  const flatStyles = {};
-  for (const tokenStyle of theme) {
-    const styleDefinition = {};
-    if (tokenStyle.style.foreground) {
-      styleDefinition.fg = parseColor(tokenStyle.style.foreground);
-    }
-    if (tokenStyle.style.background) {
-      styleDefinition.bg = parseColor(tokenStyle.style.background);
-    }
-    if (tokenStyle.style.bold !== undefined) {
-      styleDefinition.bold = tokenStyle.style.bold;
-    }
-    if (tokenStyle.style.italic !== undefined) {
-      styleDefinition.italic = tokenStyle.style.italic;
-    }
-    if (tokenStyle.style.underline !== undefined) {
-      styleDefinition.underline = tokenStyle.style.underline;
-    }
-    if (tokenStyle.style.dim !== undefined) {
-      styleDefinition.dim = tokenStyle.style.dim;
-    }
-    for (const scope of tokenStyle.scope) {
-      flatStyles[scope] = styleDefinition;
-    }
-  }
-  return flatStyles;
+function channel(buffer, index) {
+  return (buffer[index] & 255) / 255;
 }
-
-class SyntaxStyle {
-  lib;
-  stylePtr;
-  _destroyed = false;
-  nameCache = new Map;
-  styleDefs = new Map;
-  mergedCache = new Map;
-  constructor(lib, ptr) {
-    this.lib = lib;
-    this.stylePtr = ptr;
-  }
-  static create() {
-    const lib = resolveRenderLib();
-    const ptr = lib.createSyntaxStyle();
-    return new SyntaxStyle(lib, ptr);
-  }
-  static fromTheme(theme) {
-    const style = SyntaxStyle.create();
-    const flatStyles = convertThemeToStyles(theme);
-    for (const [name, styleDef] of Object.entries(flatStyles)) {
-      style.registerStyle(name, styleDef);
-    }
-    return style;
-  }
-  static fromStyles(styles) {
-    const style = SyntaxStyle.create();
-    for (const [name, styleDef] of Object.entries(styles)) {
-      style.registerStyle(name, styleDef);
-    }
-    return style;
-  }
-  guard() {
-    if (this._destroyed)
-      throw new Error("NativeSyntaxStyle is destroyed");
-  }
-  registerStyle(name, style) {
-    this.guard();
-    const attributes = createTextAttributes({
-      bold: style.bold,
-      italic: style.italic,
-      underline: style.underline,
-      dim: style.dim
-    });
-    const id = this.lib.syntaxStyleRegister(this.stylePtr, name, style.fg || null, style.bg || null, attributes);
-    this.nameCache.set(name, id);
-    this.styleDefs.set(name, style);
-    return id;
-  }
-  resolveStyleId(name) {
-    this.guard();
-    const cached = this.nameCache.get(name);
-    if (cached !== undefined)
-      return cached;
-    const id = this.lib.syntaxStyleResolveByName(this.stylePtr, name);
-    if (id !== null) {
-      this.nameCache.set(name, id);
-    }
-    return id;
-  }
-  getStyleId(name) {
-    this.guard();
-    const id = this.resolveStyleId(name);
-    if (id !== null)
-      return id;
-    if (name.includes(".")) {
-      const baseName = name.split(".")[0];
-      return this.resolveStyleId(baseName);
-    }
-    return null;
-  }
-  get ptr() {
-    this.guard();
-    return this.stylePtr;
-  }
-  getStyleCount() {
-    this.guard();
-    return this.lib.syntaxStyleGetStyleCount(this.stylePtr);
-  }
-  clearNameCache() {
-    this.nameCache.clear();
-  }
-  getStyle(name) {
-    this.guard();
-    if (Object.prototype.hasOwnProperty.call(this.styleDefs, name)) {
-      return;
-    }
-    const style = this.styleDefs.get(name);
-    if (style)
-      return style;
-    if (name.includes(".")) {
-      const baseName = name.split(".")[0];
-      if (Object.prototype.hasOwnProperty.call(this.styleDefs, baseName)) {
-        return;
-      }
-      return this.styleDefs.get(baseName);
-    }
-    return;
-  }
-  mergeStyles(...styleNames) {
-    this.guard();
-    const cacheKey = styleNames.join(":");
-    const cached = this.mergedCache.get(cacheKey);
-    if (cached)
-      return cached;
-    const styleDefinition = {};
-    for (const name of styleNames) {
-      const style = this.getStyle(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.mergedCache.set(cacheKey, merged);
-    return merged;
-  }
-  clearCache() {
-    this.guard();
-    this.mergedCache.clear();
-  }
-  getCacheSize() {
-    this.guard();
-    return this.mergedCache.size;
-  }
-  getAllStyles() {
-    this.guard();
-    return new Map(this.styleDefs);
-  }
-  getRegisteredNames() {
-    this.guard();
-    return Array.from(this.styleDefs.keys());
-  }
-  destroy() {
-    if (this._destroyed)
-      return;
-    this._destroyed = true;
-    this.nameCache.clear();
-    this.styleDefs.clear();
-    this.mergedCache.clear();
-    this.lib.destroySyntaxStyle(this.stylePtr);
-  }
+function setRgb(buffer, base, r, g, b) {
+  const a = buffer[base + 3] & 255;
+  buffer[base] = toU8(r);
+  buffer[base + 1] = toU8(g);
+  buffer[base + 2] = toU8(b);
+  buffer[base + 3] = a;
 }
-// src/post/effects.ts
+
 class DistortionEffect {
   glitchChancePerSecond = 0.5;
   maxGlitchLines = 3;
@@ -796,8 +516,8 @@ class DistortionEffect {
         if (glitch.type === "shift" || glitch.type === "flip") {
           if (!tempChar) {
             tempChar = new Uint32Array(width);
-            tempFg = new Float32Array(width * 4);
-            tempBg = new Float32Array(width * 4);
+            tempFg = new Uint16Array(width * 4);
+            tempBg = new Uint16Array(width * 4);
             tempAttr = new Uint8Array(width);
           }
           try {
@@ -904,12 +624,8 @@ class DistortionEffect {
               gBg = 1 - gFg;
               bBg = 1 - bFg;
             }
-            buf.fg[destColorIndex] = rFg;
-            buf.fg[destColorIndex + 1] = gFg;
-            buf.fg[destColorIndex + 2] = bFg;
-            buf.bg[destColorIndex] = rBg;
-            buf.bg[destColorIndex + 1] = gBg;
-            buf.bg[destColorIndex + 2] = bBg;
+            setRgb(buf.fg, destColorIndex, rFg, gFg, bFg);
+            setRgb(buf.bg, destColorIndex, rBg, gBg, bBg);
           }
         }
       }
@@ -1174,9 +890,7 @@ class FlamesEffect {
             g = flameIntensity * 0.5;
             b = 0;
           }
-          bg2[colorIndex] = Math.max(bg2[colorIndex], r * flameIntensity);
-          bg2[colorIndex + 1] = Math.max(bg2[colorIndex + 1], g * flameIntensity);
-          bg2[colorIndex + 2] = Math.max(bg2[colorIndex + 2], b * flameIntensity);
+          setRgb(bg2, colorIndex, Math.max(channel(bg2, colorIndex), r * flameIntensity), Math.max(channel(bg2, colorIndex + 1), g * flameIntensity), Math.max(channel(bg2, colorIndex + 2), b * flameIntensity));
         }
       }
     }
@@ -1242,12 +956,8 @@ class CRTRollingBarEffect {
         const rowMultiplier = 1 + this._intensity * barFactor;
         for (let x = 0;x < width; x++) {
           const colorIndex = (y * width + x) * 4;
-          fg2[colorIndex] = Math.min(1, fg2[colorIndex] * rowMultiplier);
-          fg2[colorIndex + 1] = Math.min(1, fg2[colorIndex + 1] * rowMultiplier);
-          fg2[colorIndex + 2] = Math.min(1, fg2[colorIndex + 2] * rowMultiplier);
-          bg2[colorIndex] = Math.min(1, bg2[colorIndex] * rowMultiplier);
-          bg2[colorIndex + 1] = Math.min(1, bg2[colorIndex + 1] * rowMultiplier);
-          bg2[colorIndex + 2] = Math.min(1, bg2[colorIndex + 2] * rowMultiplier);
+          setRgb(fg2, colorIndex, Math.min(1, channel(fg2, colorIndex) * rowMultiplier), Math.min(1, channel(fg2, colorIndex + 1) * rowMultiplier), Math.min(1, channel(fg2, colorIndex + 2) * rowMultiplier));
+          setRgb(bg2, colorIndex, Math.min(1, channel(bg2, colorIndex) * rowMultiplier), Math.min(1, channel(bg2, colorIndex + 1) * rowMultiplier), Math.min(1, channel(bg2, colorIndex + 2) * rowMultiplier));
         }
       }
     }
@@ -1346,23 +1056,34 @@ class RainbowTextEffect {
     for (let y = 0;y < height; y++) {
       for (let x = 0;x < width; x++) {
         const colorIndex = (y * width + x) * 4;
-        const r = fg2[colorIndex];
-        const g = fg2[colorIndex + 1];
-        const b = fg2[colorIndex + 2];
+        const r = channel(fg2, colorIndex);
+        const g = channel(fg2, colorIndex + 1);
+        const b = channel(fg2, colorIndex + 2);
         if (r >= whiteThreshold && g >= whiteThreshold && b >= whiteThreshold) {
           const projection = x * cosAngle + y * sinAngle;
           const maxProjection = width * cosAngle + height * sinAngle;
           const hue = (projection / maxProjection * repeats + this.time * 0.1) % 1;
           const [newR, newG, newB] = this.hsvToRgb(hue, saturation, value);
-          fg2[colorIndex] = newR;
-          fg2[colorIndex + 1] = newG;
-          fg2[colorIndex + 2] = newB;
+          setRgb(fg2, colorIndex, newR, newG, newB);
         }
       }
     }
   }
 }
 // src/post/filters.ts
+function toU82(value) {
+  return Math.round(Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0)) * 255);
+}
+function channel2(buffer, index) {
+  return (buffer[index] & 255) / 255;
+}
+function setRgb2(buffer, base, r, g, b) {
+  const a = buffer[base + 3] & 255;
+  buffer[base] = toU82(r);
+  buffer[base + 1] = toU82(g);
+  buffer[base + 2] = toU82(b);
+  buffer[base + 3] = a;
+}
 function applyScanlines(buffer, strength = 0.8, step = 2) {
   if (strength === 1 || step < 1)
     return;
@@ -1462,7 +1183,7 @@ function applyNoise(buffer, strength = 0.1) {
 function applyChromaticAberration(buffer, strength = 1) {
   const width = buffer.width;
   const height = buffer.height;
-  const srcFg = Float32Array.from(buffer.buffers.fg);
+  const srcFg = Uint16Array.from(buffer.buffers.fg);
   const destFg = buffer.buffers.fg;
   const centerX = width / 2;
   const centerY = height / 2;
@@ -1477,9 +1198,7 @@ function applyChromaticAberration(buffer, strength = 1) {
       const gIndex = (y * width + x) * 4;
       const bIndex = (y * width + bX) * 4;
       const destIndex = (y * width + x) * 4;
-      destFg[destIndex] = srcFg[rIndex];
-      destFg[destIndex + 1] = srcFg[gIndex + 1];
-      destFg[destIndex + 2] = srcFg[bIndex + 2];
+      setRgb2(destFg, destIndex, channel2(srcFg, rIndex), channel2(srcFg, gIndex + 1), channel2(srcFg, bIndex + 2));
     }
   }
 }
@@ -1493,9 +1212,9 @@ function applyAsciiArt(buffer, ramp = ' .\'`^"",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuv
     for (let x = 0;x < width; x++) {
       const index = y * width + x;
       const colorIndex = index * 4;
-      const bgR = bg2[colorIndex];
-      const bgG = bg2[colorIndex + 1];
-      const bgB = bg2[colorIndex + 2];
+      const bgR = channel2(bg2, colorIndex);
+      const bgG = channel2(bg2, colorIndex + 1);
+      const bgB = channel2(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);
@@ -1676,16 +1395,16 @@ class BloomEffect {
       return;
     const width = buffer.width;
     const height = buffer.height;
-    const srcFg = Float32Array.from(buffer.buffers.fg);
-    const srcBg = Float32Array.from(buffer.buffers.bg);
+    const srcFg = Uint16Array.from(buffer.buffers.fg);
+    const srcBg = Uint16Array.from(buffer.buffers.bg);
     const destFg = buffer.buffers.fg;
     const destBg = buffer.buffers.bg;
     const brightPixels = [];
     for (let y = 0;y < height; y++) {
       for (let x = 0;x < width; x++) {
         const index = (y * width + x) * 4;
-        const fgLum = 0.299 * srcFg[index] + 0.587 * srcFg[index + 1] + 0.114 * srcFg[index + 2];
-        const bgLum = 0.299 * srcBg[index] + 0.587 * srcBg[index + 1] + 0.114 * srcBg[index + 2];
+        const fgLum = 0.299 * channel2(srcFg, index) + 0.587 * channel2(srcFg, index + 1) + 0.114 * channel2(srcFg, index + 2);
+        const bgLum = 0.299 * channel2(srcBg, index) + 0.587 * channel2(srcBg, index + 1) + 0.114 * channel2(srcBg, index + 2);
         const lum = Math.max(fgLum, bgLum);
         if (lum > threshold) {
           const intensity = (lum - threshold) / (1 - threshold + 0.000001);
@@ -1711,12 +1430,8 @@ class BloomEffect {
               const falloff = 1 - distSq / radiusSq;
               const bloomAmount = bright.intensity * strength * falloff;
               const destIndex = (sampleY * width + sampleX) * 4;
-              destFg[destIndex] = Math.min(1, destFg[destIndex] + bloomAmount);
-              destFg[destIndex + 1] = Math.min(1, destFg[destIndex + 1] + bloomAmount);
-              destFg[destIndex + 2] = Math.min(1, destFg[destIndex + 2] + bloomAmount);
-              destBg[destIndex] = Math.min(1, destBg[destIndex] + bloomAmount);
-              destBg[destIndex + 1] = Math.min(1, destBg[destIndex + 1] + bloomAmount);
-              destBg[destIndex + 2] = Math.min(1, destBg[destIndex + 2] + bloomAmount);
+              setRgb2(destFg, destIndex, Math.min(1, channel2(destFg, destIndex) + bloomAmount), Math.min(1, channel2(destFg, destIndex + 1) + bloomAmount), Math.min(1, channel2(destFg, destIndex + 2) + bloomAmount));
+              setRgb2(destBg, destIndex, Math.min(1, channel2(destBg, destIndex) + bloomAmount), Math.min(1, channel2(destBg, destIndex + 1) + bloomAmount), Math.min(1, channel2(destBg, destIndex + 2) + bloomAmount));
             }
           }
         }
@@ -3061,15 +2776,6 @@ class SlotRenderable extends Renderable {
   }
 }
 // src/NativeSpanFeed.ts
-function toPointer(value) {
-  if (typeof value === "bigint") {
-    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error("Pointer exceeds safe integer range");
-    }
-    return Number(value);
-  }
-  return value;
-}
 function toNumber(value) {
   return typeof value === "bigint" ? Number(value) : value;
 }
@@ -3090,12 +2796,11 @@ class NativeSpanFeed {
   }
   static attach(streamPtr, _options) {
     const lib = resolveRenderLib();
-    const ptr = toPointer(streamPtr);
-    const stream = new NativeSpanFeed(ptr);
-    lib.registerNativeSpanFeedStream(ptr, stream.eventHandler);
-    const status = lib.attachNativeSpanFeed(ptr);
+    const stream = new NativeSpanFeed(streamPtr);
+    lib.registerNativeSpanFeedStream(streamPtr, stream.eventHandler);
+    const status = lib.attachNativeSpanFeed(streamPtr);
     if (status !== 0) {
-      lib.unregisterNativeSpanFeedStream(ptr);
+      lib.unregisterNativeSpanFeedStream(streamPtr);
       throw new Error(`Failed to attach stream: ${status}`);
     }
     return stream;
@@ -3229,7 +2934,7 @@ class NativeSpanFeed {
           break;
         }
         case 6 /* Error */: {
-          const code = arg0;
+          const code = toNumber(arg0);
           for (const handler of this.errorHandlers)
             handler(code);
           break;
@@ -3319,6 +3024,362 @@ class NativeSpanFeed {
     }
   }
 }
+// src/audio.ts
+import { EventEmitter } from "events";
+import { readFile } from "fs/promises";
+function statusToError(action, status) {
+  return new Error(`Audio ${action} failed: ${status}`);
+}
+function toBytes(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+
+class Audio extends EventEmitter {
+  static create(options = {}) {
+    return new Audio(resolveRenderLib(), options);
+  }
+  lib;
+  defaultStartOptions;
+  engine = null;
+  groups = new Map;
+  playbackStarted = false;
+  mixerStarted = false;
+  constructor(lib, options) {
+    super();
+    this.lib = lib;
+    this.defaultStartOptions = options.startOptions;
+    const createOptions = options.sampleRate == null && options.playbackChannels == null ? undefined : {
+      sampleRate: options.sampleRate == null ? undefined : Math.max(0, Math.trunc(options.sampleRate)),
+      playbackChannels: options.playbackChannels == null ? undefined : Math.max(0, Math.trunc(options.playbackChannels))
+    };
+    this.engine = this.lib.createAudioEngine(createOptions);
+    if (!this.engine) {
+      this.emitError("createAudioEngine", undefined, "Audio createAudioEngine returned null");
+      return;
+    }
+    if (options.autoStart ?? false) {
+      this.start(this.defaultStartOptions);
+    }
+  }
+  emitError(action, status, message, cause) {
+    const error = message ? new Error(message) : statusToError(action, status ?? -1);
+    if (cause)
+      error.cause = cause;
+    this.emit("error", error, { action, status });
+  }
+  start(options) {
+    if (this.playbackStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("start", undefined, "Audio engine unavailable during start");
+      return false;
+    }
+    const startOptions = options ?? this.defaultStartOptions;
+    const status = this.lib.audioStart(engine2, startOptions);
+    if (status !== 0) {
+      this.emitError("start", status);
+      return false;
+    }
+    this.playbackStarted = true;
+    this.mixerStarted = true;
+    this.emit("started");
+    return true;
+  }
+  startMixer() {
+    if (this.mixerStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("startMixer", undefined, "Audio engine unavailable during startMixer");
+      return false;
+    }
+    const status = this.lib.audioStartMixer(engine2);
+    if (status !== 0) {
+      this.emitError("startMixer", status);
+      return false;
+    }
+    this.mixerStarted = true;
+    this.emit("mixerStarted");
+    return true;
+  }
+  stop() {
+    if (!this.mixerStarted)
+      return true;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("stop", undefined, "Audio engine unavailable during stop");
+      return false;
+    }
+    const status = this.lib.audioStop(engine2);
+    if (status !== 0) {
+      this.emitError("stop", status);
+      return false;
+    }
+    this.playbackStarted = false;
+    this.mixerStarted = false;
+    this.emit("stopped");
+    return true;
+  }
+  isStarted() {
+    return this.playbackStarted;
+  }
+  isMixerStarted() {
+    return this.mixerStarted;
+  }
+  loadSound(data) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("loadSound", undefined, "Audio engine unavailable during loadSound");
+      return null;
+    }
+    const result = this.lib.audioLoad(engine2, toBytes(data));
+    if (result.status !== 0 || result.soundId == null) {
+      this.emitError("loadSound", result.status);
+      return null;
+    }
+    return result.soundId;
+  }
+  async loadSoundFile(filePath) {
+    const bytes = await readFile(filePath).catch((err) => {
+      this.emitError("loadSoundFile", undefined, `Failed to read file '${filePath}': ${err.message}`, err);
+      return null;
+    });
+    if (bytes == null)
+      return null;
+    return this.loadSound(bytes);
+  }
+  unloadSound(sound) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("unloadSound", undefined, "Audio engine unavailable during unloadSound");
+      return false;
+    }
+    const status = this.lib.audioUnload(engine2, sound);
+    if (status !== 0) {
+      this.emitError("unloadSound", status);
+      return false;
+    }
+    return true;
+  }
+  group(name) {
+    const existing = this.groups.get(name);
+    if (existing != null) {
+      return existing;
+    }
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("group", undefined, "Audio engine unavailable during group");
+      return null;
+    }
+    const result = this.lib.audioCreateGroup(engine2, name);
+    if (result.status !== 0 || result.groupId == null) {
+      this.emitError("group", result.status);
+      return null;
+    }
+    this.groups.set(name, result.groupId);
+    return result.groupId;
+  }
+  play(sound, options) {
+    const rawOptions = options ? {
+      volume: options.volume,
+      pan: options.pan,
+      loop: options.loop,
+      groupId: options.groupId ?? 0
+    } : undefined;
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("play", undefined, "Audio engine unavailable during play");
+      return null;
+    }
+    const result = this.lib.audioPlay(engine2, sound, rawOptions);
+    if (result.status !== 0 || result.voiceId == null) {
+      this.emitError("play", result.status);
+      return null;
+    }
+    return result.voiceId;
+  }
+  stopVoice(voice) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("stopVoice", undefined, "Audio engine unavailable during stopVoice");
+      return false;
+    }
+    const status = this.lib.audioStopVoice(engine2, voice);
+    if (status !== 0) {
+      this.emitError("stopVoice", status);
+      return false;
+    }
+    return true;
+  }
+  setVoiceGroup(voice, group) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setVoiceGroup", undefined, "Audio engine unavailable during setVoiceGroup");
+      return false;
+    }
+    const status = this.lib.audioSetVoiceGroup(engine2, voice, group);
+    if (status !== 0) {
+      this.emitError("setVoiceGroup", status);
+      return false;
+    }
+    return true;
+  }
+  setGroupVolume(group, volume) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setGroupVolume", undefined, "Audio engine unavailable during setGroupVolume");
+      return false;
+    }
+    const status = this.lib.audioSetGroupVolume(engine2, group, volume);
+    if (status !== 0) {
+      this.emitError("setGroupVolume", status);
+      return false;
+    }
+    return true;
+  }
+  setMasterVolume(volume) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("setMasterVolume", undefined, "Audio engine unavailable during setMasterVolume");
+      return false;
+    }
+    const status = this.lib.audioSetMasterVolume(engine2, volume);
+    if (status !== 0) {
+      this.emitError("setMasterVolume", status);
+      return false;
+    }
+    return true;
+  }
+  mixFrames(frameCount, channels = 2) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("mixFrames", undefined, "Audio engine unavailable during mixFrames");
+      return null;
+    }
+    const output = new Float32Array(frameCount * channels);
+    const status = this.lib.audioMixToBuffer(engine2, output, frameCount, channels);
+    if (status !== 0) {
+      this.emitError("mixFrames", status);
+      return null;
+    }
+    return output;
+  }
+  enableTap(capacityFrames = 8192) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("enableTap", undefined, "Audio engine unavailable during enableTap");
+      return false;
+    }
+    const status = this.lib.audioEnableTap(engine2, true, capacityFrames);
+    if (status !== 0) {
+      this.emitError("enableTap", status);
+      return false;
+    }
+    return true;
+  }
+  disableTap() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("enableTap", undefined, "Audio engine unavailable during disableTap");
+      return false;
+    }
+    const status = this.lib.audioEnableTap(engine2, false, 0);
+    if (status !== 0) {
+      this.emitError("enableTap", status);
+      return false;
+    }
+    return true;
+  }
+  readTapFrames(frameCount, channels = 2) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("readTapFrames", undefined, "Audio engine unavailable during readTapFrames");
+      return null;
+    }
+    const output = new Float32Array(frameCount * channels);
+    const result = this.lib.audioReadTap(engine2, output, frameCount, channels);
+    if (result.status !== 0) {
+      this.emitError("readTapFrames", result.status);
+      return null;
+    }
+    return { frames: output, framesRead: result.framesRead };
+  }
+  listPlaybackDevices() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("listPlaybackDevices", undefined, "Audio engine unavailable during listPlaybackDevices");
+      return null;
+    }
+    const refreshStatus = this.lib.audioRefreshPlaybackDevices(engine2);
+    if (refreshStatus !== 0) {
+      this.emitError("listPlaybackDevices", refreshStatus);
+      return null;
+    }
+    const count = this.lib.audioGetPlaybackDeviceCount(engine2);
+    const devices = [];
+    for (let index = 0;index < count; index += 1) {
+      devices.push({
+        index,
+        name: this.lib.audioGetPlaybackDeviceName(engine2, index),
+        isDefault: this.lib.audioIsPlaybackDeviceDefault(engine2, index)
+      });
+    }
+    return devices;
+  }
+  selectPlaybackDevice(index) {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("selectPlaybackDevice", undefined, "Audio engine unavailable during selectPlaybackDevice");
+      return false;
+    }
+    const refreshStatus = this.lib.audioRefreshPlaybackDevices(engine2);
+    if (refreshStatus !== 0) {
+      this.emitError("selectPlaybackDevice", refreshStatus);
+      return false;
+    }
+    const status = this.lib.audioSelectPlaybackDevice(engine2, index);
+    if (status !== 0) {
+      this.emitError("selectPlaybackDevice", status);
+      return false;
+    }
+    return true;
+  }
+  clearPlaybackDeviceSelection() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("clearPlaybackDeviceSelection", undefined, "Audio engine unavailable during clearPlaybackDeviceSelection");
+      return;
+    }
+    this.lib.audioClearPlaybackDeviceSelection(engine2);
+  }
+  getStats() {
+    const engine2 = this.engine;
+    if (!engine2) {
+      this.emitError("getStats", undefined, "Audio engine unavailable during getStats");
+      return null;
+    }
+    const stats = this.lib.audioGetStats(engine2);
+    if (stats == null) {
+      this.emitError("getStats", undefined, "Failed to retrieve audio stats");
+    }
+    return stats;
+  }
+  dispose() {
+    if (!this.engine)
+      return;
+    if (this.mixerStarted) {
+      this.stop();
+    }
+    this.groups.clear();
+    this.lib.destroyAudioEngine(this.engine);
+    this.engine = null;
+    this.emit("disposed");
+  }
+}
+function setupAudio(options = {}) {
+  return Audio.create(options);
+}
 // src/renderables/FrameBuffer.ts
 class FrameBufferRenderable extends Renderable {
   frameBuffer;
@@ -3506,1139 +3567,9 @@ class ASCIIFontRenderable extends FrameBufferRenderable {
     }
   }
 }
-// src/renderables/Box.ts
-function isGapType(value) {
-  if (value === undefined) {
-    return true;
-  }
-  if (typeof value === "number" && !Number.isNaN(value)) {
-    return true;
-  }
-  return isValidPercentage(value);
-}
-
-class BoxRenderable extends Renderable {
-  _backgroundColor;
-  _border;
-  _borderStyle;
-  _borderColor;
-  _focusedBorderColor;
-  _customBorderCharsObj;
-  _customBorderChars;
-  borderSides;
-  shouldFill;
-  _title;
-  _titleAlignment;
-  _bottomTitle;
-  _bottomTitleAlignment;
-  _defaultOptions = {
-    backgroundColor: "transparent",
-    borderStyle: "single",
-    border: false,
-    borderColor: "#FFFFFF",
-    shouldFill: true,
-    titleAlignment: "left",
-    bottomTitleAlignment: "left",
-    focusedBorderColor: "#00AAFF"
-  };
-  constructor(ctx, options) {
-    super(ctx, options);
-    if (options.focusable === true) {
-      this._focusable = true;
-    }
-    this._backgroundColor = parseColor(options.backgroundColor || this._defaultOptions.backgroundColor);
-    this._border = options.border ?? this._defaultOptions.border;
-    if (!options.border && (options.borderStyle || options.borderColor || options.focusedBorderColor || options.customBorderChars)) {
-      this._border = true;
-    }
-    this._borderStyle = parseBorderStyle(options.borderStyle, this._defaultOptions.borderStyle);
-    this._borderColor = parseColor(options.borderColor || this._defaultOptions.borderColor);
-    this._focusedBorderColor = parseColor(options.focusedBorderColor || this._defaultOptions.focusedBorderColor);
-    this._customBorderCharsObj = options.customBorderChars;
-    this._customBorderChars = this._customBorderCharsObj ? borderCharsToArray(this._customBorderCharsObj) : undefined;
-    this.borderSides = getBorderSides(this._border);
-    this.shouldFill = options.shouldFill ?? this._defaultOptions.shouldFill;
-    this._title = options.title;
-    this._titleAlignment = options.titleAlignment || this._defaultOptions.titleAlignment;
-    this._bottomTitle = options.bottomTitle;
-    this._bottomTitleAlignment = options.bottomTitleAlignment || this._defaultOptions.bottomTitleAlignment;
-    this.applyYogaBorders();
-    const hasInitialGapProps = options.gap !== undefined || options.rowGap !== undefined || options.columnGap !== undefined;
-    if (hasInitialGapProps) {
-      this.applyYogaGap(options);
-    }
-  }
-  initializeBorder() {
-    if (this._border === false) {
-      this._border = true;
-      this.borderSides = getBorderSides(this._border);
-      this.applyYogaBorders();
-    }
-  }
-  get customBorderChars() {
-    return this._customBorderCharsObj;
-  }
-  set customBorderChars(value) {
-    this._customBorderCharsObj = value;
-    this._customBorderChars = value ? borderCharsToArray(value) : undefined;
-    this.requestRender();
-  }
-  get backgroundColor() {
-    return this._backgroundColor;
-  }
-  set backgroundColor(value) {
-    const newColor = parseColor(value ?? this._defaultOptions.backgroundColor);
-    if (this._backgroundColor !== newColor) {
-      this._backgroundColor = newColor;
-      this.requestRender();
-    }
-  }
-  get border() {
-    return this._border;
-  }
-  set border(value) {
-    if (this._border !== value) {
-      this._border = value;
-      this.borderSides = getBorderSides(value);
-      this.applyYogaBorders();
-      this.requestRender();
-    }
-  }
-  get borderStyle() {
-    return this._borderStyle;
-  }
-  set borderStyle(value) {
-    const _value = parseBorderStyle(value, this._defaultOptions.borderStyle);
-    if (this._borderStyle !== _value || !this._border) {
-      this._borderStyle = _value;
-      this._customBorderChars = undefined;
-      this.initializeBorder();
-      this.requestRender();
-    }
-  }
-  get borderColor() {
-    return this._borderColor;
-  }
-  set borderColor(value) {
-    const newColor = parseColor(value ?? this._defaultOptions.borderColor);
-    if (this._borderColor !== newColor) {
-      this._borderColor = newColor;
-      this.initializeBorder();
-      this.requestRender();
-    }
-  }
-  get focusedBorderColor() {
-    return this._focusedBorderColor;
-  }
-  set focusedBorderColor(value) {
-    const newColor = parseColor(value ?? this._defaultOptions.focusedBorderColor);
-    if (this._focusedBorderColor !== newColor) {
-      this._focusedBorderColor = newColor;
-      this.initializeBorder();
-      if (this._focused) {
-        this.requestRender();
-      }
-    }
-  }
-  get title() {
-    return this._title;
-  }
-  set title(value) {
-    if (this._title !== value) {
-      this._title = value;
-      this.requestRender();
-    }
-  }
-  get titleAlignment() {
-    return this._titleAlignment;
-  }
-  set titleAlignment(value) {
-    if (this._titleAlignment !== value) {
-      this._titleAlignment = value;
-      this.requestRender();
-    }
-  }
-  get bottomTitle() {
-    return this._bottomTitle;
-  }
-  set bottomTitle(value) {
-    if (this._bottomTitle !== value) {
-      this._bottomTitle = value;
-      this.requestRender();
-    }
-  }
-  get bottomTitleAlignment() {
-    return this._bottomTitleAlignment;
-  }
-  set bottomTitleAlignment(value) {
-    if (this._bottomTitleAlignment !== value) {
-      this._bottomTitleAlignment = value;
-      this.requestRender();
-    }
-  }
-  renderSelf(buffer) {
-    const currentBorderColor = this._focused ? this._focusedBorderColor : this._borderColor;
-    buffer.drawBox({
-      x: this.x,
-      y: this.y,
-      width: this.width,
-      height: this.height,
-      borderStyle: this._borderStyle,
-      customBorderChars: this._customBorderChars,
-      border: this._border,
-      borderColor: currentBorderColor,
-      backgroundColor: this._backgroundColor,
-      shouldFill: this.shouldFill,
-      title: this._title,
-      titleAlignment: this._titleAlignment,
-      bottomTitle: this._bottomTitle,
-      bottomTitleAlignment: this._bottomTitleAlignment
-    });
-  }
-  getScissorRect() {
-    const baseRect = super.getScissorRect();
-    if (!this.borderSides.top && !this.borderSides.right && !this.borderSides.bottom && !this.borderSides.left) {
-      return baseRect;
-    }
-    const leftInset = this.borderSides.left ? 1 : 0;
-    const rightInset = this.borderSides.right ? 1 : 0;
-    const topInset = this.borderSides.top ? 1 : 0;
-    const bottomInset = this.borderSides.bottom ? 1 : 0;
-    return {
-      x: baseRect.x + leftInset,
-      y: baseRect.y + topInset,
-      width: Math.max(0, baseRect.width - leftInset - rightInset),
-      height: Math.max(0, baseRect.height - topInset - bottomInset)
-    };
-  }
-  applyYogaBorders() {
-    const node = this.yogaNode;
-    node.setBorder(Edge.Left, this.borderSides.left ? 1 : 0);
-    node.setBorder(Edge.Right, this.borderSides.right ? 1 : 0);
-    node.setBorder(Edge.Top, this.borderSides.top ? 1 : 0);
-    node.setBorder(Edge.Bottom, this.borderSides.bottom ? 1 : 0);
-    this.requestRender();
-  }
-  applyYogaGap(options) {
-    const node = this.yogaNode;
-    if (isGapType(options.gap)) {
-      node.setGap(Gutter.All, options.gap);
-    }
-    if (isGapType(options.rowGap)) {
-      node.setGap(Gutter.Row, options.rowGap);
-    }
-    if (isGapType(options.columnGap)) {
-      node.setGap(Gutter.Column, options.columnGap);
-    }
-  }
-  set gap(gap) {
-    if (isGapType(gap)) {
-      this.yogaNode.setGap(Gutter.All, gap);
-      this.requestRender();
-    }
-  }
-  set rowGap(rowGap) {
-    if (isGapType(rowGap)) {
-      this.yogaNode.setGap(Gutter.Row, rowGap);
-      this.requestRender();
-    }
-  }
-  set columnGap(columnGap) {
-    if (isGapType(columnGap)) {
-      this.yogaNode.setGap(Gutter.Column, columnGap);
-      this.requestRender();
-    }
-  }
-}
-// src/renderables/TextBufferRenderable.ts
-class TextBufferRenderable extends Renderable {
-  selectable = true;
-  _defaultFg;
-  _defaultBg;
-  _defaultAttributes;
-  _selectionBg;
-  _selectionFg;
-  _wrapMode = "word";
-  lastLocalSelection = null;
-  _tabIndicator;
-  _tabIndicatorColor;
-  _scrollX = 0;
-  _scrollY = 0;
-  _truncate = false;
-  textBuffer;
-  textBufferView;
-  _textBufferSyntaxStyle;
-  _defaultOptions = {
-    fg: RGBA.fromValues(1, 1, 1, 1),
-    bg: RGBA.fromValues(0, 0, 0, 0),
-    selectionBg: undefined,
-    selectionFg: undefined,
-    selectable: true,
-    attributes: 0,
-    wrapMode: "word",
-    tabIndicator: undefined,
-    tabIndicatorColor: undefined,
-    truncate: false
-  };
-  constructor(ctx, options) {
-    super(ctx, options);
-    this._defaultFg = parseColor(options.fg ?? this._defaultOptions.fg);
-    this._defaultBg = parseColor(options.bg ?? this._defaultOptions.bg);
-    this._defaultAttributes = options.attributes ?? this._defaultOptions.attributes;
-    this._selectionBg = options.selectionBg ? parseColor(options.selectionBg) : this._defaultOptions.selectionBg;
-    this._selectionFg = options.selectionFg ? parseColor(options.selectionFg) : this._defaultOptions.selectionFg;
-    this.selectable = options.selectable ?? this._defaultOptions.selectable;
-    this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
-    this._tabIndicator = options.tabIndicator ?? this._defaultOptions.tabIndicator;
-    this._tabIndicatorColor = options.tabIndicatorColor ? parseColor(options.tabIndicatorColor) : this._defaultOptions.tabIndicatorColor;
-    this._truncate = options.truncate ?? this._defaultOptions.truncate;
-    this.textBuffer = TextBuffer.create(this._ctx.widthMethod);
-    this.textBufferView = TextBufferView.create(this.textBuffer);
-    this._textBufferSyntaxStyle = SyntaxStyle.create();
-    this.textBuffer.setSyntaxStyle(this._textBufferSyntaxStyle);
-    this.textBufferView.setWrapMode(this._wrapMode);
-    this.setupMeasureFunc();
-    this.textBuffer.setDefaultFg(this._defaultFg);
-    this.textBuffer.setDefaultBg(this._defaultBg);
-    this.textBuffer.setDefaultAttributes(this._defaultAttributes);
-    if (this._tabIndicator !== undefined) {
-      this.textBufferView.setTabIndicator(this._tabIndicator);
-    }
-    if (this._tabIndicatorColor !== undefined) {
-      this.textBufferView.setTabIndicatorColor(this._tabIndicatorColor);
-    }
-    if (this._wrapMode !== "none" && this.width > 0) {
-      this.textBufferView.setWrapWidth(this.width);
-    }
-    if (this.width > 0 && this.height > 0) {
-      this.textBufferView.setViewport(this._scrollX, this._scrollY, this.width, this.height);
-    }
-    this.textBufferView.setTruncate(this._truncate);
-    this.updateTextInfo();
-  }
-  onMouseEvent(event) {
-    if (event.type === "scroll") {
-      this.handleScroll(event);
-    }
-  }
-  handleScroll(event) {
-    if (!event.scroll)
-      return;
-    const { direction, delta } = event.scroll;
-    if (direction === "up") {
-      this.scrollY -= delta;
-    } else if (direction === "down") {
-      this.scrollY += delta;
-    }
-    if (this._wrapMode === "none") {
-      if (direction === "left") {
-        this.scrollX -= delta;
-      } else if (direction === "right") {
-        this.scrollX += delta;
-      }
-    }
-  }
-  get lineInfo() {
-    return this.textBufferView.logicalLineInfo;
-  }
-  get lineCount() {
-    return this.textBuffer.getLineCount();
-  }
-  get virtualLineCount() {
-    return this.textBufferView.getVirtualLineCount();
-  }
-  get scrollY() {
-    return this._scrollY;
-  }
-  set scrollY(value) {
-    const maxScrollY = Math.max(0, this.scrollHeight - this.height);
-    const clamped = Math.max(0, Math.min(value, maxScrollY));
-    if (this._scrollY !== clamped) {
-      this._scrollY = clamped;
-      this.updateViewportOffset();
-      this.requestRender();
-    }
-  }
-  get scrollX() {
-    return this._scrollX;
-  }
-  set scrollX(value) {
-    const maxScrollX = Math.max(0, this.scrollWidth - this.width);
-    const clamped = Math.max(0, Math.min(value, maxScrollX));
-    if (this._scrollX !== clamped) {
-      this._scrollX = clamped;
-      this.updateViewportOffset();
-      this.requestRender();
-    }
-  }
-  get scrollWidth() {
-    return this.lineInfo.lineWidthColsMax;
-  }
-  get scrollHeight() {
-    return this.lineInfo.lineStartCols.length;
-  }
-  get maxScrollY() {
-    return Math.max(0, this.scrollHeight - this.height);
-  }
-  get maxScrollX() {
-    return Math.max(0, this.scrollWidth - this.width);
-  }
-  updateViewportOffset() {
-    if (this.width > 0 && this.height > 0) {
-      this.textBufferView.setViewport(this._scrollX, this._scrollY, this.width, this.height);
-    }
-  }
-  get plainText() {
-    return this.textBuffer.getPlainText();
-  }
-  get textLength() {
-    return this.textBuffer.length;
-  }
-  get fg() {
-    return this._defaultFg;
-  }
-  set fg(value) {
-    const newColor = parseColor(value ?? this._defaultOptions.fg);
-    if (this._defaultFg !== newColor) {
-      this._defaultFg = newColor;
-      this.textBuffer.setDefaultFg(this._defaultFg);
-      this.onFgChanged(newColor);
-      this.requestRender();
-    }
-  }
-  get selectionBg() {
-    return this._selectionBg;
-  }
-  set selectionBg(value) {
-    const newColor = value ? parseColor(value) : this._defaultOptions.selectionBg;
-    if (this._selectionBg !== newColor) {
-      this._selectionBg = newColor;
-      if (this.lastLocalSelection) {
-        this.updateLocalSelection(this.lastLocalSelection);
-      }
-      this.requestRender();
-    }
-  }
-  get selectionFg() {
-    return this._selectionFg;
-  }
-  set selectionFg(value) {
-    const newColor = value ? parseColor(value) : this._defaultOptions.selectionFg;
-    if (this._selectionFg !== newColor) {
-      this._selectionFg = newColor;
-      if (this.lastLocalSelection) {
-        this.updateLocalSelection(this.lastLocalSelection);
-      }
-      this.requestRender();
-    }
-  }
-  get bg() {
-    return this._defaultBg;
-  }
-  set bg(value) {
-    const newColor = parseColor(value ?? this._defaultOptions.bg);
-    if (this._defaultBg !== newColor) {
-      this._defaultBg = newColor;
-      this.textBuffer.setDefaultBg(this._defaultBg);
-      this.onBgChanged(newColor);
-      this.requestRender();
-    }
-  }
-  get attributes() {
-    return this._defaultAttributes;
-  }
-  set attributes(value) {
-    if (this._defaultAttributes !== value) {
-      this._defaultAttributes = value;
-      this.textBuffer.setDefaultAttributes(this._defaultAttributes);
-      this.onAttributesChanged(value);
-      this.requestRender();
-    }
-  }
-  get wrapMode() {
-    return this._wrapMode;
-  }
-  set wrapMode(value) {
-    if (this._wrapMode !== value) {
-      this._wrapMode = value;
-      this.textBufferView.setWrapMode(this._wrapMode);
-      if (value !== "none" && this.width > 0) {
-        this.textBufferView.setWrapWidth(this.width);
-      }
-      this.yogaNode.markDirty();
-      this.requestRender();
-    }
-  }
-  get tabIndicator() {
-    return this._tabIndicator;
-  }
-  set tabIndicator(value) {
-    if (this._tabIndicator !== value) {
-      this._tabIndicator = value;
-      if (value !== undefined) {
-        this.textBufferView.setTabIndicator(value);
-      }
-      this.requestRender();
-    }
-  }
-  get tabIndicatorColor() {
-    return this._tabIndicatorColor;
-  }
-  set tabIndicatorColor(value) {
-    const newColor = value ? parseColor(value) : undefined;
-    if (this._tabIndicatorColor !== newColor) {
-      this._tabIndicatorColor = newColor;
-      if (newColor !== undefined) {
-        this.textBufferView.setTabIndicatorColor(newColor);
-      }
-      this.requestRender();
-    }
-  }
-  get truncate() {
-    return this._truncate;
-  }
-  set truncate(value) {
-    if (this._truncate !== value) {
-      this._truncate = value;
-      this.textBufferView.setTruncate(value);
-      this.requestRender();
-    }
-  }
-  onResize(width, height) {
-    this.textBufferView.setViewport(this._scrollX, this._scrollY, width, height);
-    this.yogaNode.markDirty();
-    this.requestRender();
-    this.emit("line-info-change");
-  }
-  refreshLocalSelection() {
-    if (this.lastLocalSelection) {
-      return this.updateLocalSelection(this.lastLocalSelection);
-    }
-    return false;
-  }
-  updateLocalSelection(localSelection) {
-    if (!localSelection?.isActive) {
-      this.textBufferView.resetLocalSelection();
-      return true;
-    }
-    return this.textBufferView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
-  }
-  updateTextInfo() {
-    if (this.lastLocalSelection) {
-      this.updateLocalSelection(this.lastLocalSelection);
-    }
-    this.yogaNode.markDirty();
-    this.requestRender();
-    this.emit("line-info-change");
-  }
-  setupMeasureFunc() {
-    const measureFunc = (width, widthMode, height, heightMode) => {
-      let effectiveWidth;
-      if (widthMode === MeasureMode.Undefined || isNaN(width)) {
-        effectiveWidth = 0;
-      } else {
-        effectiveWidth = width;
-      }
-      const effectiveHeight = isNaN(height) ? 1 : height;
-      const measureResult = this.textBufferView.measureForDimensions(Math.floor(effectiveWidth), Math.floor(effectiveHeight));
-      const measuredWidth = measureResult ? Math.max(1, measureResult.widthColsMax) : 1;
-      const measuredHeight = measureResult ? Math.max(1, measureResult.lineCount) : 1;
-      if (widthMode === MeasureMode.AtMost && this._positionType !== "absolute") {
-        return {
-          width: Math.min(effectiveWidth, measuredWidth),
-          height: Math.min(effectiveHeight, measuredHeight)
-        };
-      }
-      return {
-        width: measuredWidth,
-        height: measuredHeight
-      };
-    };
-    this.yogaNode.setMeasureFunc(measureFunc);
-  }
-  shouldStartSelection(x, y) {
-    if (!this.selectable)
-      return false;
-    const localX = x - this.x;
-    const localY = y - this.y;
-    return localX >= 0 && localX < this.width && localY >= 0 && localY < this.height;
-  }
-  onSelectionChanged(selection) {
-    const localSelection = convertGlobalToLocalSelection(selection, this.x, this.y);
-    this.lastLocalSelection = localSelection;
-    let changed;
-    if (!localSelection?.isActive) {
-      this.textBufferView.resetLocalSelection();
-      changed = true;
-    } else if (selection?.isStart) {
-      changed = this.textBufferView.setLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
-    } else {
-      changed = this.textBufferView.updateLocalSelection(localSelection.anchorX, localSelection.anchorY, localSelection.focusX, localSelection.focusY, this._selectionBg, this._selectionFg);
-    }
-    if (changed) {
-      this.requestRender();
-    }
-    return this.hasSelection();
-  }
-  getSelectedText() {
-    return this.textBufferView.getSelectedText();
-  }
-  hasSelection() {
-    return this.textBufferView.hasSelection();
-  }
-  getSelection() {
-    return this.textBufferView.getSelection();
-  }
-  render(buffer, deltaTime) {
-    if (!this.visible)
-      return;
-    this.markClean();
-    this._ctx.addToHitGrid(this.x, this.y, this.width, this.height, this.num);
-    this.renderSelf(buffer);
-    if (this.buffered && this.frameBuffer) {
-      buffer.drawFrameBuffer(this.x, this.y, this.frameBuffer);
-    }
-  }
-  renderSelf(buffer) {
-    if (this.textBuffer.ptr) {
-      buffer.drawTextBuffer(this.textBufferView, this.x, this.y);
-    }
-  }
-  destroy() {
-    if (this.isDestroyed)
-      return;
-    this.textBuffer.setSyntaxStyle(null);
-    this._textBufferSyntaxStyle.destroy();
-    this.textBufferView.destroy();
-    this.textBuffer.destroy();
-    super.destroy();
-  }
-  onFgChanged(newColor) {}
-  onBgChanged(newColor) {}
-  onAttributesChanged(newAttributes) {}
-}
-
-// src/renderables/Code.ts
-class CodeRenderable extends TextBufferRenderable {
-  _content;
-  _filetype;
-  _syntaxStyle;
-  _isHighlighting = false;
-  _treeSitterClient;
-  _highlightsDirty = false;
-  _highlightSnapshotId = 0;
-  _conceal;
-  _drawUnstyledText;
-  _shouldRenderTextBuffer = true;
-  _streaming;
-  _hadInitialContent = false;
-  _lastHighlights = [];
-  _onHighlight;
-  _onChunks;
-  _highlightingPromise = Promise.resolve();
-  _contentDefaultOptions = {
-    content: "",
-    conceal: true,
-    drawUnstyledText: true,
-    streaming: false
-  };
-  constructor(ctx, options) {
-    super(ctx, options);
-    this._content = options.content ?? this._contentDefaultOptions.content;
-    this._filetype = options.filetype;
-    this._syntaxStyle = options.syntaxStyle;
-    this._treeSitterClient = options.treeSitterClient ?? getTreeSitterClient();
-    this._conceal = options.conceal ?? this._contentDefaultOptions.conceal;
-    this._drawUnstyledText = options.drawUnstyledText ?? this._contentDefaultOptions.drawUnstyledText;
-    this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
-    this._onHighlight = options.onHighlight;
-    this._onChunks = options.onChunks;
-    if (this._content.length > 0) {
-      this.textBuffer.setText(this._content);
-      this.updateTextInfo();
-      this._shouldRenderTextBuffer = this._drawUnstyledText || !this._filetype;
-    }
-    this._highlightsDirty = this._content.length > 0;
-  }
-  get content() {
-    return this._content;
-  }
-  set content(value) {
-    if (this._content !== value) {
-      this._content = value;
-      this._highlightsDirty = true;
-      this._highlightSnapshotId++;
-      if (this._streaming && !this._drawUnstyledText && this._filetype) {
-        return;
-      }
-      this.textBuffer.setText(value);
-      this.updateTextInfo();
-    }
-  }
-  get filetype() {
-    return this._filetype;
-  }
-  set filetype(value) {
-    if (this._filetype !== value) {
-      this._filetype = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get syntaxStyle() {
-    return this._syntaxStyle;
-  }
-  set syntaxStyle(value) {
-    if (this._syntaxStyle !== value) {
-      this._syntaxStyle = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get conceal() {
-    return this._conceal;
-  }
-  set conceal(value) {
-    if (this._conceal !== value) {
-      this._conceal = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get drawUnstyledText() {
-    return this._drawUnstyledText;
-  }
-  set drawUnstyledText(value) {
-    if (this._drawUnstyledText !== value) {
-      this._drawUnstyledText = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get streaming() {
-    return this._streaming;
-  }
-  set streaming(value) {
-    if (this._streaming !== value) {
-      this._streaming = value;
-      this._hadInitialContent = false;
-      this._lastHighlights = [];
-      this._highlightsDirty = true;
-    }
-  }
-  get treeSitterClient() {
-    return this._treeSitterClient;
-  }
-  set treeSitterClient(value) {
-    if (this._treeSitterClient !== value) {
-      this._treeSitterClient = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get onHighlight() {
-    return this._onHighlight;
-  }
-  set onHighlight(value) {
-    if (this._onHighlight !== value) {
-      this._onHighlight = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get onChunks() {
-    return this._onChunks;
-  }
-  set onChunks(value) {
-    if (this._onChunks !== value) {
-      this._onChunks = value;
-      this._highlightsDirty = true;
-    }
-  }
-  get isHighlighting() {
-    return this._isHighlighting;
-  }
-  get highlightingDone() {
-    return this._highlightingPromise;
-  }
-  async transformChunks(chunks, context) {
-    if (!this._onChunks)
-      return chunks;
-    const modified = await this._onChunks(chunks, context);
-    return modified ?? chunks;
-  }
-  ensureVisibleTextBeforeHighlight() {
-    if (this.isDestroyed)
-      return;
-    const content = this._content;
-    if (!this._filetype) {
-      this._shouldRenderTextBuffer = true;
-      return;
-    }
-    const isInitialContent = this._streaming && !this._hadInitialContent;
-    const shouldDrawUnstyledNow = this._streaming ? isInitialContent && this._drawUnstyledText : this._drawUnstyledText;
-    if (this._streaming && !isInitialContent) {
-      this._shouldRenderTextBuffer = true;
-    } else if (shouldDrawUnstyledNow) {
-      this.textBuffer.setText(content);
-      this._shouldRenderTextBuffer = true;
-    } else {
-      this._shouldRenderTextBuffer = false;
-    }
-  }
-  async startHighlight() {
-    const content = this._content;
-    const filetype = this._filetype;
-    const snapshotId = ++this._highlightSnapshotId;
-    if (!filetype)
-      return;
-    const isInitialContent = this._streaming && !this._hadInitialContent;
-    if (isInitialContent) {
-      this._hadInitialContent = true;
-    }
-    this._isHighlighting = true;
-    try {
-      const result = await this._treeSitterClient.highlightOnce(content, filetype);
-      if (snapshotId !== this._highlightSnapshotId) {
-        return;
-      }
-      if (this.isDestroyed)
-        return;
-      let highlights = result.highlights ?? [];
-      if (this._onHighlight && highlights.length >= 0) {
-        const context = {
-          content,
-          filetype,
-          syntaxStyle: this._syntaxStyle
-        };
-        const modified = await this._onHighlight(highlights, context);
-        if (modified !== undefined) {
-          highlights = modified;
-        }
-      }
-      if (snapshotId !== this._highlightSnapshotId) {
-        return;
-      }
-      if (this.isDestroyed)
-        return;
-      if (highlights.length > 0) {
-        if (this._streaming) {
-          this._lastHighlights = highlights;
-        }
-      }
-      if (highlights.length > 0 || this._onChunks) {
-        const context = {
-          content,
-          filetype,
-          syntaxStyle: this._syntaxStyle,
-          highlights
-        };
-        let chunks = treeSitterToTextChunks(content, highlights, this._syntaxStyle, {
-          enabled: this._conceal
-        });
-        chunks = await this.transformChunks(chunks, context);
-        if (snapshotId !== this._highlightSnapshotId) {
-          return;
-        }
-        if (this.isDestroyed)
-          return;
-        const styledText = new StyledText(chunks);
-        this.textBuffer.setStyledText(styledText);
-      } else {
-        this.textBuffer.setText(content);
-      }
-      this._shouldRenderTextBuffer = true;
-      this._isHighlighting = false;
-      this._highlightsDirty = false;
-      this.updateTextInfo();
-      this.requestRender();
-    } catch (error) {
-      if (snapshotId !== this._highlightSnapshotId) {
-        return;
-      }
-      console.warn("Code highlighting failed, falling back to plain text:", error);
-      if (this.isDestroyed)
-        return;
-      this.textBuffer.setText(content);
-      this._shouldRenderTextBuffer = true;
-      this._isHighlighting = false;
-      this._highlightsDirty = false;
-      this.updateTextInfo();
-      this.requestRender();
-    }
-  }
-  getLineHighlights(lineIdx) {
-    return this.textBuffer.getLineHighlights(lineIdx);
-  }
-  renderSelf(buffer) {
-    if (this._highlightsDirty) {
-      if (this.isDestroyed)
-        return;
-      if (this._content.length === 0) {
-        this._shouldRenderTextBuffer = false;
-        this._highlightsDirty = false;
-      } else if (!this._filetype) {
-        this._shouldRenderTextBuffer = true;
-        this._highlightsDirty = false;
-      } else {
-        this.ensureVisibleTextBeforeHighlight();
-        this._highlightsDirty = false;
-        this._highlightingPromise = this.startHighlight();
-      }
-    }
-    if (!this._shouldRenderTextBuffer)
-      return;
-    super.renderSelf(buffer);
-  }
-}
-// src/renderables/TextNode.ts
-var BrandedTextNodeRenderable = Symbol.for("@jitl/opentui-core/TextNodeRenderable");
-function isTextNodeRenderable(obj) {
-  return !!obj?.[BrandedTextNodeRenderable];
-}
-function styledTextToTextNodes(styledText) {
-  return styledText.chunks.map((chunk) => {
-    const node = new TextNodeRenderable({
-      fg: chunk.fg,
-      bg: chunk.bg,
-      attributes: chunk.attributes,
-      link: chunk.link
-    });
-    node.add(chunk.text);
-    return node;
-  });
-}
-
-class TextNodeRenderable extends BaseRenderable {
-  [BrandedTextNodeRenderable] = true;
-  _fg;
-  _bg;
-  _attributes;
-  _link;
-  _children = [];
-  parent = null;
-  constructor(options) {
-    super(options);
-    this._fg = options.fg ? parseColor(options.fg) : undefined;
-    this._bg = options.bg ? parseColor(options.bg) : undefined;
-    this._attributes = options.attributes ?? 0;
-    this._link = options.link;
-  }
-  get children() {
-    return this._children;
-  }
-  set children(children) {
-    this._children = children;
-    this.requestRender();
-  }
-  requestRender() {
-    this.markDirty();
-    this.parent?.requestRender();
-  }
-  add(obj, index) {
-    if (typeof obj === "string") {
-      if (index !== undefined) {
-        this._children.splice(index, 0, obj);
-        this.requestRender();
-        return index;
-      }
-      const insertIndex = this._children.length;
-      this._children.push(obj);
-      this.requestRender();
-      return insertIndex;
-    }
-    if (isTextNodeRenderable(obj)) {
-      if (index !== undefined) {
-        this._children.splice(index, 0, obj);
-        obj.parent = this;
-        this.requestRender();
-        return index;
-      }
-      const insertIndex = this._children.length;
-      this._children.push(obj);
-      obj.parent = this;
-      this.requestRender();
-      return insertIndex;
-    }
-    if (isStyledText(obj)) {
-      const textNodes = styledTextToTextNodes(obj);
-      if (index !== undefined) {
-        this._children.splice(index, 0, ...textNodes);
-        textNodes.forEach((node) => node.parent = this);
-        this.requestRender();
-        return index;
-      }
-      const insertIndex = this._children.length;
-      this._children.push(...textNodes);
-      textNodes.forEach((node) => node.parent = this);
-      this.requestRender();
-      return insertIndex;
-    }
-    throw new Error("TextNodeRenderable only accepts strings, TextNodeRenderable instances, or StyledText instances");
-  }
-  replace(obj, index) {
-    this._children[index] = obj;
-    if (typeof obj !== "string") {
-      obj.parent = this;
-    }
-    this.requestRender();
-  }
-  insertBefore(child, anchorNode) {
-    if (!anchorNode || !isTextNodeRenderable(anchorNode)) {
-      throw new Error("Anchor must be a TextNodeRenderable");
-    }
-    const anchorIndex = this._children.indexOf(anchorNode);
-    if (anchorIndex === -1) {
-      throw new Error("Anchor node not found in children");
-    }
-    if (typeof child === "string") {
-      this._children.splice(anchorIndex, 0, child);
-    } else if (isTextNodeRenderable(child)) {
-      this._children.splice(anchorIndex, 0, child);
-      child.parent = this;
-    } else if (child instanceof StyledText) {
-      const textNodes = styledTextToTextNodes(child);
-      this._children.splice(anchorIndex, 0, ...textNodes);
-      textNodes.forEach((node) => node.parent = this);
-    } else {
-      throw new Error("Child must be a string, TextNodeRenderable, or StyledText instance");
-    }
-    this.requestRender();
-    return this;
-  }
-  remove(id) {
-    const childIndex = this.getRenderableIndex(id);
-    if (childIndex === -1) {
-      throw new Error("Child not found in children");
-    }
-    const child = this._children[childIndex];
-    this._children.splice(childIndex, 1);
-    child.parent = null;
-    this.requestRender();
-    return this;
-  }
-  clear() {
-    this._children = [];
-    this.requestRender();
-  }
-  mergeStyles(parentStyle) {
-    return {
-      fg: this._fg ?? parentStyle.fg,
-      bg: this._bg ?? parentStyle.bg,
-      attributes: this._attributes | parentStyle.attributes,
-      link: this._link ?? parentStyle.link
-    };
-  }
-  gatherWithInheritedStyle(parentStyle = {
-    fg: undefined,
-    bg: undefined,
-    attributes: 0
-  }) {
-    const currentStyle = this.mergeStyles(parentStyle);
-    const chunks = [];
-    for (const child of this._children) {
-      if (typeof child === "string") {
-        chunks.push({
-          __isChunk: true,
-          text: child,
-          fg: currentStyle.fg,
-          bg: currentStyle.bg,
-          attributes: currentStyle.attributes,
-          link: currentStyle.link
-        });
-      } else {
-        const childChunks = child.gatherWithInheritedStyle(currentStyle);
-        chunks.push(...childChunks);
-      }
-    }
-    this.markClean();
-    return chunks;
-  }
-  static fromString(text, options = {}) {
-    const node = new TextNodeRenderable(options);
-    node.add(text);
-    return node;
-  }
-  static fromNodes(nodes, options = {}) {
-    const node = new TextNodeRenderable(options);
-    for (const childNode of nodes) {
-      node.add(childNode);
-    }
-    return node;
-  }
-  toChunks(parentStyle = {
-    fg: undefined,
-    bg: undefined,
-    attributes: 0
-  }) {
-    return this.gatherWithInheritedStyle(parentStyle);
-  }
-  getChildren() {
-    return this._children.filter((child) => typeof child !== "string");
-  }
-  getChildrenCount() {
-    return this._children.length;
-  }
-  getRenderable(id) {
-    return this._children.find((child) => typeof child !== "string" && child.id === id);
-  }
-  getRenderableIndex(id) {
-    return this._children.findIndex((child) => isTextNodeRenderable(child) && child.id === id);
-  }
-  get fg() {
-    return this._fg;
-  }
-  set fg(fg2) {
-    if (!fg2) {
-      this._fg = undefined;
-      this.requestRender();
-      return;
-    }
-    this._fg = parseColor(fg2);
-    this.requestRender();
-  }
-  set bg(bg2) {
-    if (!bg2) {
-      this._bg = undefined;
-      this.requestRender();
-      return;
-    }
-    this._bg = parseColor(bg2);
-    this.requestRender();
-  }
-  get bg() {
-    return this._bg;
-  }
-  set attributes(attributes) {
-    this._attributes = attributes;
-    this.requestRender();
-  }
-  get attributes() {
-    return this._attributes;
-  }
-  set link(link2) {
-    this._link = link2;
-    this.requestRender();
-  }
-  get link() {
-    return this._link;
-  }
-  findDescendantById(id) {
-    return;
-  }
-}
-
-class RootTextNodeRenderable extends TextNodeRenderable {
-  ctx;
-  textParent;
-  constructor(ctx, options, textParent) {
-    super(options);
-    this.ctx = ctx;
-    this.textParent = textParent;
-  }
-  requestRender() {
-    this.markDirty();
-    this.ctx.requestRender();
-  }
-}
-
-// src/renderables/composition/constructs.ts
-function Generic(props, ...children) {
-  return h(VRenderable, props || {}, ...children);
+// src/renderables/composition/constructs.ts
+function Generic(props, ...children) {
+  return h(VRenderable, props || {}, ...children);
 }
 function Box(props, ...children) {
   return h(BoxRenderable, props || {}, ...children);
@@ -5235,49 +4166,271 @@ class LineNumberRenderable extends Renderable {
     }
   }
 }
-// ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/patch/parse.js
+// ../../node_modules/.bun/diff@9.0.0/node_modules/diff/libesm/patch/parse.js
 function parsePatch(uniDiff) {
   const diffstr = uniDiff.split(/\n/), list = [];
   let i = 0;
+  function isGitDiffHeader(line) {
+    return /^diff --git /.test(line);
+  }
+  function isDiffHeader(line) {
+    return isGitDiffHeader(line) || /^Index:\s/.test(line) || /^diff(?: -r \w+)+\s/.test(line);
+  }
+  function isFileHeader(line) {
+    return /^(---|\+\+\+)\s/.test(line);
+  }
+  function isHunkHeader(line) {
+    return /^@@\s/.test(line);
+  }
   function parseIndex() {
+    var _a;
     const index = {};
+    index.hunks = [];
     list.push(index);
+    let seenDiffHeader = false;
     while (i < diffstr.length) {
       const line = diffstr[i];
-      if (/^(---|\+\+\+|@@)\s/.test(line)) {
+      if (isFileHeader(line) || isHunkHeader(line)) {
         break;
       }
-      const header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
-      if (header) {
-        index.index = header[1];
+      if (isGitDiffHeader(line)) {
+        if (seenDiffHeader) {
+          return;
+        }
+        seenDiffHeader = true;
+        index.isGit = true;
+        const paths = parseGitDiffHeader(line);
+        if (paths) {
+          index.oldFileName = paths.oldFileName;
+          index.newFileName = paths.newFileName;
+        }
+        i++;
+        while (i < diffstr.length) {
+          const extLine = diffstr[i];
+          if (isFileHeader(extLine) || isHunkHeader(extLine) || isDiffHeader(extLine)) {
+            break;
+          }
+          const renameFromMatch = /^rename from (.*)/.exec(extLine);
+          if (renameFromMatch) {
+            index.oldFileName = "a/" + unquoteIfQuoted(renameFromMatch[1]);
+            index.isRename = true;
+          }
+          const renameToMatch = /^rename to (.*)/.exec(extLine);
+          if (renameToMatch) {
+            index.newFileName = "b/" + unquoteIfQuoted(renameToMatch[1]);
+            index.isRename = true;
+          }
+          const copyFromMatch = /^copy from (.*)/.exec(extLine);
+          if (copyFromMatch) {
+            index.oldFileName = "a/" + unquoteIfQuoted(copyFromMatch[1]);
+            index.isCopy = true;
+          }
+          const copyToMatch = /^copy to (.*)/.exec(extLine);
+          if (copyToMatch) {
+            index.newFileName = "b/" + unquoteIfQuoted(copyToMatch[1]);
+            index.isCopy = true;
+          }
+          const newFileModeMatch = /^new file mode (\d+)/.exec(extLine);
+          if (newFileModeMatch) {
+            index.isCreate = true;
+            index.newMode = newFileModeMatch[1];
+          }
+          const deletedFileModeMatch = /^deleted file mode (\d+)/.exec(extLine);
+          if (deletedFileModeMatch) {
+            index.isDelete = true;
+            index.oldMode = deletedFileModeMatch[1];
+          }
+          const oldModeMatch = /^old mode (\d+)/.exec(extLine);
+          if (oldModeMatch) {
+            index.oldMode = oldModeMatch[1];
+          }
+          const newModeMatch = /^new mode (\d+)/.exec(extLine);
+          if (newModeMatch) {
+            index.newMode = newModeMatch[1];
+          }
+          if (/^Binary files /.test(extLine)) {
+            index.isBinary = true;
+          }
+          i++;
+        }
+        continue;
+      } else if (isDiffHeader(line)) {
+        if (seenDiffHeader) {
+          return;
+        }
+        seenDiffHeader = true;
+        const headerMatch = /^(?:Index:|diff(?: -r \w+)+)\s+/.exec(line);
+        if (headerMatch) {
+          index.index = line.substring(headerMatch[0].length).trim();
+        }
       }
       i++;
     }
     parseFileHeader(index);
     parseFileHeader(index);
-    index.hunks = [];
+    if (index.oldFileName === undefined !== (index.newFileName === undefined)) {
+      throw new Error("Missing " + (index.oldFileName !== undefined ? '"+++ ..."' : '"--- ..."') + " file header for " + ((_a = index.oldFileName) !== null && _a !== undefined ? _a : index.newFileName));
+    }
     while (i < diffstr.length) {
       const line = diffstr[i];
-      if (/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/.test(line)) {
+      if (isDiffHeader(line) || isFileHeader(line) || /^===================================================================/.test(line)) {
         break;
-      } else if (/^@@/.test(line)) {
+      } else if (isHunkHeader(line)) {
         index.hunks.push(parseHunk());
-      } else if (line) {
-        throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(line));
       } else {
         i++;
       }
     }
   }
+  function parseGitDiffHeader(line) {
+    const rest = line.substring("diff --git ".length);
+    if (rest.startsWith('"')) {
+      const oldPath = parseQuotedFileName(rest);
+      if (oldPath === null) {
+        return null;
+      }
+      const afterOld = rest.substring(oldPath.rawLength + 1);
+      let newFileName;
+      if (afterOld.startsWith('"')) {
+        const newPath = parseQuotedFileName(afterOld);
+        if (newPath === null) {
+          return null;
+        }
+        newFileName = newPath.fileName;
+      } else {
+        newFileName = afterOld;
+      }
+      return {
+        oldFileName: oldPath.fileName,
+        newFileName
+      };
+    }
+    const quoteIdx = rest.indexOf('"');
+    if (quoteIdx > 0) {
+      const oldFileName = rest.substring(0, quoteIdx - 1);
+      const newPath = parseQuotedFileName(rest.substring(quoteIdx));
+      if (newPath === null) {
+        return null;
+      }
+      return {
+        oldFileName,
+        newFileName: newPath.fileName
+      };
+    }
+    if (rest.startsWith("a/")) {
+      const splits = [];
+      let idx = 0;
+      while (true) {
+        idx = rest.indexOf(" b/", idx + 1);
+        if (idx === -1) {
+          break;
+        }
+        splits.push(idx);
+      }
+      if (splits.length > 0) {
+        const mid = splits[Math.floor(splits.length / 2)];
+        return {
+          oldFileName: rest.substring(0, mid),
+          newFileName: rest.substring(mid + 1)
+        };
+      }
+    }
+    return null;
+  }
+  function unquoteIfQuoted(s) {
+    if (s.startsWith('"')) {
+      const parsed = parseQuotedFileName(s);
+      if (parsed) {
+        return parsed.fileName;
+      }
+    }
+    return s;
+  }
+  function parseQuotedFileName(s) {
+    if (!s.startsWith('"')) {
+      return null;
+    }
+    let result = "";
+    let j = 1;
+    while (j < s.length) {
+      if (s[j] === '"') {
+        return { fileName: result, rawLength: j + 1 };
+      }
+      if (s[j] === "\\" && j + 1 < s.length) {
+        j++;
+        switch (s[j]) {
+          case "a":
+            result += "\x07";
+            break;
+          case "b":
+            result += "\b";
+            break;
+          case "f":
+            result += "\f";
+            break;
+          case "n":
+            result += `
+`;
+            break;
+          case "r":
+            result += "\r";
+            break;
+          case "t":
+            result += "\t";
+            break;
+          case "v":
+            result += "\v";
+            break;
+          case "\\":
+            result += "\\";
+            break;
+          case '"':
+            result += '"';
+            break;
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7": {
+            if (j + 2 >= s.length || s[j + 1] < "0" || s[j + 1] > "7" || s[j + 2] < "0" || s[j + 2] > "7") {
+              return null;
+            }
+            const bytes = [parseInt(s.substring(j, j + 3), 8)];
+            j += 3;
+            while (s[j] === "\\" && s[j + 1] >= "0" && s[j + 1] <= "7") {
+              if (j + 3 >= s.length || s[j + 2] < "0" || s[j + 2] > "7" || s[j + 3] < "0" || s[j + 3] > "7") {
+                return null;
+              }
+              bytes.push(parseInt(s.substring(j + 1, j + 4), 8));
+              j += 4;
+            }
+            result += new TextDecoder("utf-8").decode(new Uint8Array(bytes));
+            continue;
+          }
+          default:
+            return null;
+        }
+      } else {
+        result += s[j];
+      }
+      j++;
+    }
+    return null;
+  }
   function parseFileHeader(index) {
-    const fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
-    if (fileHeader) {
-      const data = fileHeader[2].split("\t", 2), header = (data[1] || "").trim();
-      let fileName = data[0].replace(/\\\\/g, "\\");
-      if (/^".*"$/.test(fileName)) {
-        fileName = fileName.substr(1, fileName.length - 2);
-      }
-      if (fileHeader[1] === "---") {
+    const fileHeaderMatch = /^(---|\+\+\+)\s+/.exec(diffstr[i]);
+    if (fileHeaderMatch) {
+      const prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split("\t", 2), header = (data[1] || "").trim();
+      let fileName = data[0];
+      if (fileName.startsWith('"')) {
+        fileName = unquoteIfQuoted(fileName);
+      } else {
+        fileName = fileName.replace(/\\\\/g, "\\");
+      }
+      if (prefix === "---") {
         index.oldFileName = fileName;
         index.oldHeader = header;
       } else {
@@ -5332,110 +4485,16 @@ function parsePatch(uniDiff) {
     if (removeCount !== hunk.oldLines) {
       throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
     }
-    return hunk;
-  }
-  while (i < diffstr.length) {
-    parseIndex();
-  }
-  return list;
-}
-// src/renderables/Text.ts
-class TextRenderable extends TextBufferRenderable {
-  _text;
-  _hasManualStyledText = false;
-  rootTextNode;
-  _contentDefaultOptions = {
-    content: ""
-  };
-  constructor(ctx, options) {
-    super(ctx, options);
-    const content = options.content ?? this._contentDefaultOptions.content;
-    const styledText = typeof content === "string" ? stringToStyledText(content) : content;
-    this._text = styledText;
-    this._hasManualStyledText = options.content !== undefined && content !== "";
-    this.rootTextNode = new RootTextNodeRenderable(ctx, {
-      id: `${this.id}-root`,
-      fg: this._defaultFg,
-      bg: this._defaultBg,
-      attributes: this._defaultAttributes
-    }, this);
-    this.updateTextBuffer(styledText);
-  }
-  updateTextBuffer(styledText) {
-    this.textBuffer.setStyledText(styledText);
-    this.clearChunks(styledText);
-  }
-  clearChunks(styledText) {}
-  get content() {
-    return this._text;
-  }
-  get chunks() {
-    return this._text.chunks;
-  }
-  get textNode() {
-    return this.rootTextNode;
-  }
-  set content(value) {
-    this._hasManualStyledText = true;
-    const styledText = typeof value === "string" ? stringToStyledText(value) : value;
-    if (this._text !== styledText) {
-      this._text = styledText;
-      this.updateTextBuffer(styledText);
-      this.updateTextInfo();
-    }
-  }
-  updateTextFromNodes() {
-    if (this.rootTextNode.isDirty && !this._hasManualStyledText) {
-      const chunks = this.rootTextNode.gatherWithInheritedStyle({
-        fg: this._defaultFg,
-        bg: this._defaultBg,
-        attributes: this._defaultAttributes,
-        link: undefined
-      });
-      this.textBuffer.setStyledText(new StyledText(chunks));
-      this.refreshLocalSelection();
-      this.yogaNode.markDirty();
+    if (i < diffstr.length && diffstr[i] && /^[+ -]/.test(diffstr[i]) && !isFileHeader(diffstr[i])) {
+      throw new Error("Hunk at line " + (chunkHeaderIndex + 1) + " has more lines than expected (expected " + hunk.oldLines + " old lines and " + hunk.newLines + " new lines)");
     }
+    return hunk;
   }
-  add(obj, index) {
-    return this.rootTextNode.add(obj, index);
-  }
-  remove(id) {
-    this.rootTextNode.remove(id);
-  }
-  insertBefore(obj, anchor) {
-    this.rootTextNode.insertBefore(obj, anchor);
-    return this.rootTextNode.children.indexOf(obj);
-  }
-  getTextChildren() {
-    return this.rootTextNode.getChildren();
-  }
-  clear() {
-    this.rootTextNode.clear();
-    const emptyStyledText = stringToStyledText("");
-    this._text = emptyStyledText;
-    this.updateTextBuffer(emptyStyledText);
-    this.updateTextInfo();
-    this.requestRender();
-  }
-  onLifecyclePass = () => {
-    this.updateTextFromNodes();
-  };
-  onFgChanged(newColor) {
-    this.rootTextNode.fg = newColor;
-  }
-  onBgChanged(newColor) {
-    this.rootTextNode.bg = newColor;
-  }
-  onAttributesChanged(newAttributes) {
-    this.rootTextNode.attributes = newAttributes;
-  }
-  destroy() {
-    this.rootTextNode.children.length = 0;
-    super.destroy();
+  while (i < diffstr.length) {
+    parseIndex();
   }
+  return list;
 }
-
 // src/renderables/Diff.ts
 class DiffRenderable extends Renderable {
   _diff;
@@ -6412,7 +5471,7 @@ class DiffRenderable extends Renderable {
   }
 }
 // src/renderables/Textarea.ts
-var defaultTextareaKeybindings = [
+var defaultTextareaKeyBindings = [
   { name: "left", action: "move-left" },
   { name: "right", action: "move-right" },
   { name: "up", action: "move-up" },
@@ -6449,8 +5508,10 @@ var defaultTextareaKeybindings = [
   { name: "delete", action: "delete" },
   { name: "delete", shift: true, action: "delete" },
   { name: "return", action: "newline" },
+  { name: "kpenter", action: "newline" },
   { name: "linefeed", action: "newline" },
   { name: "return", meta: true, action: "submit" },
+  { name: "kpenter", meta: true, action: "submit" },
   { name: "-", ctrl: true, action: "undo" },
   { name: ".", ctrl: true, action: "redo" },
   { name: "z", super: true, action: "undo" },
@@ -6514,7 +5575,7 @@ class TextareaRenderable extends EditBufferRenderable {
     this._placeholderColor = parseColor(options.placeholderColor ?? defaults.placeholderColor);
     this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
     this._keyBindings = options.keyBindings || [];
-    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, this._keyBindings);
+    const mergedBindings = mergeKeyBindings(defaultTextareaKeyBindings, this._keyBindings);
     this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
     this._actionHandlers = this.buildActionHandlers();
     this._submitListener = options.onSubmit;
@@ -6582,19 +5643,13 @@ class TextareaRenderable extends EditBufferRenderable {
     this.insertText(stripAnsiSequences(decodePasteBytes(event.bytes)));
   }
   handleKeyPress(key) {
-    const bindingKey = getKeyBindingKey({
-      name: key.name,
-      ctrl: key.ctrl,
-      shift: key.shift,
-      meta: key.meta,
-      super: key.super,
-      action: "move-left"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
-    if (action) {
-      const handler = this._actionHandlers.get(action);
-      if (handler) {
-        return handler();
+    if (this.traits.suspend !== true) {
+      const action = getKeyBindingAction(this._keyBindingsMap, key);
+      if (action) {
+        const handler = this._actionHandlers.get(action);
+        if (handler) {
+          return handler();
+        }
       }
     }
     if (!key.ctrl && !key.meta && !key.super && !key.hyper) {
@@ -6708,12 +5763,12 @@ class TextareaRenderable extends EditBufferRenderable {
   }
   set keyBindings(bindings) {
     this._keyBindings = bindings;
-    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, bindings);
+    const mergedBindings = mergeKeyBindings(defaultTextareaKeyBindings, bindings);
     this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
   set keyAliasMap(aliases) {
     this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
-    const mergedBindings = mergeKeyBindings(defaultTextareaKeybindings, this._keyBindings);
+    const mergedBindings = mergeKeyBindings(defaultTextareaKeyBindings, this._keyBindings);
     this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
   get extmarks() {
@@ -6750,6 +5805,7 @@ class InputRenderable extends TextareaRenderable {
       wrapMode: "none",
       keyBindings: [
         { name: "return", action: "submit" },
+        { name: "kpenter", action: "submit" },
         { name: "linefeed", action: "submit" },
         ...options.keyBindings || []
       ]
@@ -6895,7 +5951,9 @@ class TextTableRenderable extends Renderable {
   _wrapMode;
   _columnWidthMode;
   _columnFitter;
-  _cellPadding;
+  _cellPaddingX;
+  _cellPaddingY;
+  _columnGap;
   _showBorders;
   _border;
   _outerBorder;
@@ -6926,6 +5984,9 @@ class TextTableRenderable extends Renderable {
     columnWidthMode: "full",
     columnFitter: "proportional",
     cellPadding: 0,
+    cellPaddingX: undefined,
+    cellPaddingY: undefined,
+    columnGap: 0,
     showBorders: true,
     border: true,
     outerBorder: true,
@@ -6946,7 +6007,9 @@ class TextTableRenderable extends Renderable {
     this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
     this._columnWidthMode = options.columnWidthMode ?? this._defaultOptions.columnWidthMode;
     this._columnFitter = this.resolveColumnFitter(options.columnFitter);
-    this._cellPadding = this.resolveCellPadding(options.cellPadding);
+    this._cellPaddingX = this.resolveCellPadding(options.cellPaddingX ?? options.cellPadding);
+    this._cellPaddingY = this.resolveCellPadding(options.cellPaddingY ?? options.cellPadding);
+    this._columnGap = this.resolveColumnGap(options.columnGap);
     this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
     this._border = options.border ?? this._defaultOptions.border;
     this._hasExplicitOuterBorder = options.outerBorder !== undefined;
@@ -7005,13 +6068,44 @@ class TextTableRenderable extends Renderable {
     this.invalidateLayoutAndRaster();
   }
   get cellPadding() {
-    return this._cellPadding;
+    return this._cellPaddingX === this._cellPaddingY ? this._cellPaddingX : 0;
   }
   set cellPadding(value) {
     const next = this.resolveCellPadding(value);
-    if (this._cellPadding === next)
+    if (this._cellPaddingX === next && this._cellPaddingY === next)
+      return;
+    this._cellPaddingX = next;
+    this._cellPaddingY = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get cellPaddingX() {
+    return this._cellPaddingX;
+  }
+  set cellPaddingX(value) {
+    const next = this.resolveCellPadding(value);
+    if (this._cellPaddingX === next)
+      return;
+    this._cellPaddingX = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get cellPaddingY() {
+    return this._cellPaddingY;
+  }
+  set cellPaddingY(value) {
+    const next = this.resolveCellPadding(value);
+    if (this._cellPaddingY === next)
       return;
-    this._cellPadding = next;
+    this._cellPaddingY = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get columnGap() {
+    return this._columnGap;
+  }
+  set columnGap(value) {
+    const next = this.resolveColumnGap(value);
+    if (this._columnGap === next)
+      return;
+    this._columnGap = next;
     this.invalidateLayoutAndRaster();
   }
   get showBorders() {
@@ -7327,7 +6421,7 @@ class TextTableRenderable extends Renderable {
     const borderLayout = this.resolveBorderLayout();
     const columnWidths = this.computeColumnWidths(maxTableWidth, borderLayout);
     const rowHeights = this.computeRowHeights(columnWidths);
-    const columnOffsets = this.computeOffsets(columnWidths, borderLayout.left, borderLayout.right, borderLayout.innerVertical);
+    const columnOffsets = this.computeOffsets(columnWidths, borderLayout.left, borderLayout.right, borderLayout.innerVertical, this.getInterColumnGap(borderLayout));
     const rowOffsets = this.computeOffsets(rowHeights, borderLayout.top, borderLayout.bottom, borderLayout.innerHorizontal);
     return {
       columnWidths,
@@ -7359,7 +6453,7 @@ class TextTableRenderable extends Renderable {
     if (maxTableWidth === undefined || !Number.isFinite(maxTableWidth) || maxTableWidth <= 0) {
       return intrinsicWidths;
     }
-    const maxContentWidth = Math.max(1, Math.floor(maxTableWidth) - this.getVerticalBorderCount(borderLayout));
+    const maxContentWidth = Math.max(1, Math.floor(maxTableWidth) - this.getVerticalBorderCount(borderLayout) - this.getTotalInterColumnGap(borderLayout));
     const currentWidth = intrinsicWidths.reduce((sum, width) => sum + width, 0);
     if (currentWidth === maxContentWidth) {
       return intrinsicWidths;
@@ -7542,17 +6636,26 @@ class TextTableRenderable extends Renderable {
     }
     return rowHeights;
   }
-  computeOffsets(parts, startBoundary, endBoundary, includeInnerBoundaries) {
+  computeOffsets(parts, startBoundary, endBoundary, includeInnerBoundaries, innerGap = 0) {
     const offsets = [startBoundary ? 0 : -1];
     let cursor = offsets[0] ?? 0;
     for (let idx = 0;idx < parts.length; idx++) {
       const size = parts[idx] ?? 1;
-      const hasBoundaryAfter = idx < parts.length - 1 ? includeInnerBoundaries : endBoundary;
-      cursor += size + (hasBoundaryAfter ? 1 : 0);
+      const separatorAfter = idx < parts.length - 1 ? includeInnerBoundaries ? 1 : innerGap : endBoundary ? 1 : 0;
+      cursor += size + separatorAfter;
       offsets.push(cursor);
     }
     return offsets;
   }
+  getInterColumnGap(borderLayout) {
+    if (borderLayout.innerVertical) {
+      return 0;
+    }
+    return this._columnGap;
+  }
+  getTotalInterColumnGap(borderLayout) {
+    return Math.max(0, this._columnCount - 1) * this.getInterColumnGap(borderLayout);
+  }
   applyLayoutToViews(layout) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const verticalPadding = this.getVerticalCellPadding();
@@ -7614,14 +6717,15 @@ class TextTableRenderable extends Renderable {
   drawCellRange(buffer, firstRow, lastRow) {
     const colOffsets = this._layout.columnOffsets;
     const rowOffsets = this._layout.rowOffsets;
-    const cellPadding = this._cellPadding;
+    const cellPaddingX = this._cellPaddingX;
+    const cellPaddingY = this._cellPaddingY;
     for (let rowIdx = firstRow;rowIdx <= lastRow; rowIdx++) {
-      const cellY = (rowOffsets[rowIdx] ?? 0) + 1 + cellPadding;
+      const cellY = (rowOffsets[rowIdx] ?? 0) + 1 + cellPaddingY;
       for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
         const cell = this._cells[rowIdx]?.[colIdx];
         if (!cell)
           continue;
-        buffer.drawTextBuffer(cell.textBufferView, (colOffsets[colIdx] ?? 0) + 1 + cellPadding, cellY);
+        buffer.drawTextBuffer(cell.textBufferView, (colOffsets[colIdx] ?? 0) + 1 + cellPaddingX, cellY);
       }
     }
   }
@@ -7650,7 +6754,15 @@ class TextTableRenderable extends Renderable {
       for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
         const cellX = (colOffsets[colIdx] ?? 0) + 1;
         const colWidth = colWidths[colIdx] ?? 1;
-        buffer.fillRect(cellX, cellY, colWidth, rowHeight, this._backgroundColor);
+        if (this._backgroundColor.a < 1) {
+          for (let y = cellY;y < cellY + rowHeight; y++) {
+            for (let x = cellX;x < cellX + colWidth; x++) {
+              buffer.setCell(x, y, " ", this._defaultFg, this._backgroundColor, this._defaultAttributes);
+            }
+          }
+        } else {
+          buffer.fillRect(cellX, cellY, colWidth, rowHeight, this._backgroundColor);
+        }
       }
     }
   }
@@ -7690,6 +6802,11 @@ class TextTableRenderable extends Renderable {
     return { rowIdx, colIdx };
   }
   applySelectionToCells(localSelection, isStart) {
+    if (localSelection.anchorX === localSelection.focusX && localSelection.anchorY === localSelection.focusY) {
+      this.resetCellSelections();
+      this._lastSelectionMode = null;
+      return;
+    }
     const minSelY = Math.min(localSelection.anchorY, localSelection.focusY);
     const maxSelY = Math.max(localSelection.anchorY, localSelection.focusY);
     const firstRow = this.findRowForLocalY(minSelY);
@@ -7703,7 +6820,7 @@ class TextTableRenderable extends Renderable {
         this.resetRowSelection(rowIdx);
         continue;
       }
-      const cellTop = (this._layout.rowOffsets[rowIdx] ?? 0) + 1 + this._cellPadding;
+      const cellTop = (this._layout.rowOffsets[rowIdx] ?? 0) + 1 + this._cellPaddingY;
       for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
         const cell = this._cells[rowIdx]?.[colIdx];
         if (!cell)
@@ -7712,7 +6829,7 @@ class TextTableRenderable extends Renderable {
           cell.textBufferView.resetLocalSelection();
           continue;
         }
-        const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPadding;
+        const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPaddingX;
         let coords = {
           anchorX: localSelection.anchorX - cellLeft,
           anchorY: localSelection.anchorY - cellTop,
@@ -7720,6 +6837,10 @@ class TextTableRenderable extends Renderable {
           focusY: localSelection.focusY - cellTop
         };
         const isAnchorCell = selection.anchorCell !== null && selection.anchorCell.rowIdx === rowIdx && selection.anchorCell.colIdx === colIdx;
+        if (selection.mode === "single-cell" && !isAnchorCell) {
+          cell.textBufferView.resetLocalSelection();
+          continue;
+        }
         const forceSet = isAnchorCell && selection.mode !== "single-cell";
         if (forceSet) {
           coords = this.getFullCellSelectionCoords(rowIdx, colIdx);
@@ -7854,10 +6975,10 @@ class TextTableRenderable extends Renderable {
     return;
   }
   getHorizontalCellPadding() {
-    return this._cellPadding * 2;
+    return this._cellPaddingX * 2;
   }
   getVerticalCellPadding() {
-    return this._cellPadding * 2;
+    return this._cellPaddingY * 2;
   }
   resolveColumnFitter(value) {
     if (value === undefined) {
@@ -7871,6 +6992,12 @@ class TextTableRenderable extends Renderable {
     }
     return Math.max(0, Math.floor(value));
   }
+  resolveColumnGap(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+      return this._defaultOptions.columnGap;
+    }
+    return Math.max(0, Math.floor(value));
+  }
   invalidateLayoutAndRaster(markYogaDirty = true) {
     this._layoutDirty = true;
     this._rasterDirty = true;
@@ -9157,9 +8284,13 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
   if (!prevState || prevState.tokens.length === 0) {
     try {
       const tokens = x.lex(newContent, { gfm: true });
-      return { content: newContent, tokens };
+      return {
+        content: newContent,
+        tokens,
+        stableTokenCount: Math.max(0, tokens.length - trailingUnstable)
+      };
     } catch {
-      return { content: newContent, tokens: [] };
+      return { content: newContent, tokens: [], stableTokenCount: 0 };
     }
   }
   let offset = 0;
@@ -9181,23 +8312,32 @@ function parseMarkdownIncremental(newContent, prevState, trailingUnstable = 2) {
   const stableTokens = prevState.tokens.slice(0, reuseCount);
   const remainingContent = newContent.slice(offset);
   if (!remainingContent) {
-    return { content: newContent, tokens: stableTokens };
+    return {
+      content: newContent,
+      tokens: stableTokens,
+      stableTokenCount: stableTokens.length
+    };
   }
   try {
     const newTokens = x.lex(remainingContent, { gfm: true });
-    return { content: newContent, tokens: [...stableTokens, ...newTokens] };
+    return {
+      content: newContent,
+      tokens: [...stableTokens, ...newTokens],
+      stableTokenCount: trailingUnstable === 0 ? stableTokens.length + newTokens.length : stableTokens.length
+    };
   } catch {
     try {
       const fullTokens = x.lex(newContent, { gfm: true });
-      return { content: newContent, tokens: fullTokens };
+      return { content: newContent, tokens: fullTokens, stableTokenCount: 0 };
     } catch {
-      return { content: newContent, tokens: [] };
+      return { content: newContent, tokens: [], stableTokenCount: 0 };
     }
   }
 }
 
 // src/renderables/Markdown.ts
 var TRAILING_MARKDOWN_BLOCK_BREAKS_RE = /(?:\r?\n){2,}$/;
+var TRAILING_MARKDOWN_BLOCK_NEWLINES_RE = /(?:\r?\n)+$/;
 function colorsEqual(left, right) {
   if (!left || !right)
     return left === right;
@@ -9214,9 +8354,11 @@ class MarkdownRenderable extends Renderable {
   _treeSitterClient;
   _tableOptions;
   _renderNode;
+  _internalBlockMode;
   _parseState = null;
   _streaming = false;
   _blockStates = [];
+  _stableBlockCount = 0;
   _styleDirty = false;
   _linkifyMarkdownChunks = (chunks, context) => detectLinks(chunks, {
     content: context.content,
@@ -9226,7 +8368,8 @@ class MarkdownRenderable extends Renderable {
     content: "",
     conceal: true,
     concealCode: false,
-    streaming: false
+    streaming: false,
+    internalBlockMode: "coalesced"
   };
   constructor(ctx, options) {
     super(ctx, {
@@ -9244,6 +8387,7 @@ class MarkdownRenderable extends Renderable {
     this._tableOptions = options.tableOptions;
     this._renderNode = options.renderNode;
     this._streaming = options.streaming ?? this._contentDefaultOptions.streaming;
+    this._internalBlockMode = options.internalBlockMode ?? this._contentDefaultOptions.internalBlockMode;
     this.updateBlocks();
   }
   get content() {
@@ -9323,6 +8467,28 @@ class MarkdownRenderable extends Renderable {
     this._tableOptions = value;
     this.applyTableOptionsToBlocks();
   }
+  get renderNode() {
+    return this._renderNode;
+  }
+  set renderNode(value) {
+    if (this._renderNode === value)
+      return;
+    this._renderNode = value;
+    this.clearBlockStates();
+    this._parseState = null;
+    this.updateBlocks(true);
+    this.requestRender();
+  }
+  get internalBlockMode() {
+    return this._internalBlockMode;
+  }
+  set internalBlockMode(value) {
+    if (this._internalBlockMode === value)
+      return;
+    this._internalBlockMode = value;
+    this.updateBlocks(true);
+    this.requestRender();
+  }
   getStyle(group) {
     if (!this._syntaxStyle)
       return;
@@ -9475,7 +8641,11 @@ class MarkdownRenderable extends Renderable {
         break;
     }
   }
-  createMarkdownCodeRenderable(content, id, marginBottom = 0) {
+  applyMargins(renderable, marginTop, marginBottom) {
+    renderable.marginTop = marginTop;
+    renderable.marginBottom = marginBottom;
+  }
+  createMarkdownCodeRenderable(content, id, marginBottom = 0, onChunks = this._linkifyMarkdownChunks, baseHighlight) {
     return new CodeRenderable(this.ctx, {
       id,
       content,
@@ -9486,12 +8656,239 @@ class MarkdownRenderable extends Renderable {
       conceal: this._conceal,
       drawUnstyledText: false,
       streaming: true,
-      onChunks: this._linkifyMarkdownChunks,
+      baseHighlight,
+      onChunks,
       treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
   }
+  getBlockquoteContent(token) {
+    return "text" in token && typeof token.text === "string" && token.text ? token.text : " ";
+  }
+  getBlockquoteBorderColor() {
+    return this.getStyle("conceal")?.fg ?? this.getStyle("default")?.fg ?? this._fg ?? "#FFFFFF";
+  }
+  createBlockquoteRenderable(token, id, marginBottom = 0) {
+    const renderable = new BoxRenderable(this.ctx, {
+      id,
+      width: "100%",
+      border: ["left"],
+      borderColor: this.getBlockquoteBorderColor(),
+      paddingLeft: 1,
+      flexShrink: 0,
+      marginBottom
+    });
+    renderable.add(this.createMarkdownCodeRenderable(this.getBlockquoteContent(token), `${id}-content`, 0, this._linkifyMarkdownChunks, "markup.quote"));
+    return renderable;
+  }
+  createListRenderable(token, id, marginBottom = 0) {
+    const list = new BoxRenderable(this.ctx, {
+      id,
+      width: "100%",
+      flexDirection: "column",
+      flexShrink: 0,
+      marginBottom
+    });
+    for (const item of this.getListItemInputs(token, id)) {
+      list.add(this.createListItemRenderable(item));
+    }
+    return list;
+  }
+  getListItemInputs(token, id) {
+    const items = token.items ?? [];
+    const start = token.start === "" || token.start === undefined || token.start === null ? 1 : Number(token.start);
+    const markerWidth = Math.max(1, ...items.map((_2, index) => (token.ordered ? `${start + index}.` : "-").length));
+    return items.map((item, index) => ({
+      item,
+      marker: token.ordered ? `${start + index}.` : "-",
+      markerWidth,
+      id: `${id}-item-${index}`
+    }));
+  }
+  applyListRenderable(renderable, token, previousToken, id, marginBottom = 0) {
+    if (!(renderable instanceof BoxRenderable))
+      return false;
+    renderable.marginBottom = marginBottom;
+    const inputs = this.getListItemInputs(token, id);
+    const previousItems = previousToken?.items ?? [];
+    const rows = renderable.getChildren();
+    for (let index = 0;index < inputs.length; index += 1) {
+      const input = inputs[index];
+      const existing = rows[index];
+      if (existing instanceof BoxRenderable && this.applyListItemRenderable(existing, input, previousItems[index])) {
+        continue;
+      }
+      existing?.destroyRecursively();
+      renderable.add(this.createListItemRenderable(input), index);
+    }
+    for (let index = rows.length - 1;index >= inputs.length; index -= 1) {
+      rows[index]?.destroyRecursively();
+    }
+    return true;
+  }
+  createListItemRenderable(input) {
+    const row = new BoxRenderable(this.ctx, {
+      id: input.id,
+      width: "100%",
+      flexDirection: "row",
+      flexShrink: 0,
+      marginBottom: /\n[ \t]*\n$/.test(input.item.raw) ? 1 : 0
+    });
+    row.add(new TextRenderable(this.ctx, {
+      id: `${input.id}-marker`,
+      content: new StyledText([this.createChunk(input.marker.padStart(input.markerWidth) + " ", "markup.list")]),
+      width: input.markerWidth + 1,
+      flexShrink: 0
+    }));
+    const content = new BoxRenderable(this.ctx, {
+      id: `${input.id}-content`,
+      flexDirection: "column",
+      flexGrow: 1,
+      flexShrink: 1
+    });
+    row.add(content);
+    let pendingMarginTop = 0;
+    for (let index = 0;index < input.item.tokens.length; index += 1) {
+      const child = input.item.tokens[index];
+      if (!child)
+        continue;
+      if (child.type === "checkbox")
+        continue;
+      if (child.type === "space") {
+        pendingMarginTop = Math.max(pendingMarginTop, 1);
+        continue;
+      }
+      const renderable = this.createListChildRenderable(child, `${input.id}-child-${index}`);
+      if (!renderable)
+        continue;
+      renderable.marginTop = child.type === "list" ? 0 : pendingMarginTop;
+      pendingMarginTop = 0;
+      content.add(renderable);
+    }
+    return row;
+  }
+  applyListItemRenderable(row, input, previousItem) {
+    this.applyListItemMarker(row, input);
+    const content = row.getChildren()[1];
+    if (!(content instanceof BoxRenderable))
+      return false;
+    if (previousItem && previousItem.raw === input.item.raw) {
+      return true;
+    }
+    return this.applyListItemChildren(content, input.item, previousItem, input.id);
+  }
+  applyListItemChildren(content, item, previousItem, id) {
+    const previousTokens = previousItem ? this.getRenderableListItemTokens(previousItem) : [];
+    const children = content.getChildren();
+    let childIndex = 0;
+    let pendingMarginTop = 0;
+    for (let tokenIndex = 0;tokenIndex < item.tokens.length; tokenIndex += 1) {
+      const token = item.tokens[tokenIndex];
+      if (!token)
+        continue;
+      if (token.type === "checkbox")
+        continue;
+      if (token.type === "space") {
+        pendingMarginTop = Math.max(pendingMarginTop, 1);
+        continue;
+      }
+      const existing = children[childIndex];
+      const childId = `${id}-child-${tokenIndex}`;
+      const marginTop = token.type === "list" ? 0 : pendingMarginTop;
+      pendingMarginTop = 0;
+      if (!existing) {
+        const renderable = this.createListChildRenderable(token, childId);
+        if (!renderable)
+          return false;
+        renderable.marginTop = marginTop;
+        content.add(renderable, childIndex);
+        childIndex += 1;
+        continue;
+      }
+      if (!this.applyListChildRenderable(existing, token, previousTokens[childIndex], childId)) {
+        return false;
+      }
+      existing.marginTop = marginTop;
+      childIndex += 1;
+    }
+    this.destroyListItemChildrenAfter(content, childIndex);
+    return true;
+  }
+  getRenderableListItemTokens(item) {
+    const tokens = [];
+    for (const token of item.tokens) {
+      if (token.type === "checkbox" || token.type === "space")
+        continue;
+      tokens.push(token);
+    }
+    return tokens;
+  }
+  applyListChildRenderable(renderable, token, previousToken, id) {
+    if ((token.type === "text" || token.type === "paragraph") && renderable instanceof CodeRenderable) {
+      this.applyMarkdownCodeRenderable(renderable, this.getListChildMarkdownRaw(token), 0);
+      return true;
+    }
+    if (token.type === "list" && renderable instanceof BoxRenderable) {
+      return this.applyListRenderable(renderable, token, previousToken, id);
+    }
+    if (token.type === "code" && renderable instanceof CodeRenderable) {
+      this.applyCodeBlockRenderable(renderable, token, 0);
+      return true;
+    }
+    return previousToken?.raw === token.raw;
+  }
+  destroyListItemChildrenAfter(content, index) {
+    const children = content.getChildren();
+    for (let i = children.length - 1;i >= index; i -= 1) {
+      children[i]?.destroyRecursively();
+    }
+  }
+  getListChildMarkdownRaw(token) {
+    return token.type === "paragraph" ? this.normalizeScrollbackMarkdownBlockRaw(token.raw) : token.raw;
+  }
+  applyListItemMarker(row, input) {
+    const marker = row.getChildren()[0];
+    if (!(marker instanceof TextRenderable))
+      return;
+    const marginBottom = /\n[ \t]*\n$/.test(input.item.raw) ? 1 : 0;
+    const markerWidth = input.markerWidth + 1;
+    const markerText = input.marker.padStart(input.markerWidth) + " ";
+    if (row.marginBottom !== marginBottom)
+      row.marginBottom = marginBottom;
+    if (marker.width !== markerWidth)
+      marker.width = markerWidth;
+    if (marker.chunks[0]?.text !== markerText) {
+      marker.content = new StyledText([this.createChunk(markerText, "markup.list")]);
+    }
+  }
+  createListChildRenderable(token, id) {
+    if (token.type === "text" || token.type === "paragraph") {
+      return this.createMarkdownCodeRenderable(this.getListChildMarkdownRaw(token), id);
+    }
+    if (token.type === "list")
+      return this.createListRenderable(token, id);
+    if (token.type === "code")
+      return this.createCodeRenderable(token, id);
+    if (token.type === "blockquote")
+      return this.createBlockquoteRenderable(token, id);
+    if (token.type === "hr")
+      return this.createHorizontalRuleRenderable(id);
+    if (token.type === "table")
+      return this.createTableBlock(token, id).renderable;
+    return token.raw ? this.createMarkdownCodeRenderable(token.raw, id) : null;
+  }
+  createHorizontalRuleRenderable(id, marginBottom = 0) {
+    return new BoxRenderable(this.ctx, {
+      id,
+      width: "100%",
+      height: 1,
+      border: ["top"],
+      borderColor: this.getStyle("conceal")?.fg ?? this._fg ?? "#888888",
+      flexShrink: 0,
+      marginBottom
+    });
+  }
   createCodeRenderable(token, id, marginBottom = 0) {
     return new CodeRenderable(this.ctx, {
       id,
@@ -9501,14 +8898,14 @@ class MarkdownRenderable extends Renderable {
       fg: this._fg,
       bg: this._bg,
       conceal: this._concealCode,
-      drawUnstyledText: !(this._streaming && this._concealCode),
+      drawUnstyledText: !this._streaming,
       streaming: this._streaming,
       treeSitterClient: this._treeSitterClient,
       width: "100%",
       marginBottom
     });
   }
-  applyMarkdownCodeRenderable(renderable, content, marginBottom) {
+  applyMarkdownCodeRenderable(renderable, content, marginBottom, baseHighlight) {
     renderable.content = content;
     renderable.filetype = "markdown";
     renderable.syntaxStyle = this._syntaxStyle;
@@ -9517,21 +8914,39 @@ class MarkdownRenderable extends Renderable {
     renderable.conceal = this._conceal;
     renderable.drawUnstyledText = false;
     renderable.streaming = true;
+    renderable.baseHighlight = baseHighlight;
+    renderable.marginBottom = marginBottom;
+  }
+  applyBlockquoteRenderable(renderable, token, marginBottom) {
+    if (!(renderable instanceof BoxRenderable))
+      return;
+    renderable.borderColor = this.getBlockquoteBorderColor();
     renderable.marginBottom = marginBottom;
+    const child = renderable.getChildren()[0];
+    if (child instanceof CodeRenderable) {
+      this.applyMarkdownCodeRenderable(child, this.getBlockquoteContent(token), 0, "markup.quote");
+      return;
+    }
+    for (const existing of renderable.getChildren()) {
+      existing.destroyRecursively();
+    }
+    renderable.add(this.createMarkdownCodeRenderable(this.getBlockquoteContent(token), `${renderable.id}-content`, 0, this._linkifyMarkdownChunks, "markup.quote"));
   }
   applyCodeBlockRenderable(renderable, token, marginBottom) {
-    renderable.content = token.text;
+    if (!(renderable instanceof CodeRenderable))
+      return;
     renderable.filetype = infoStringToFiletype(token.lang ?? "");
     renderable.syntaxStyle = this._syntaxStyle;
     renderable.fg = this._fg;
     renderable.bg = this._bg;
     renderable.conceal = this._concealCode;
-    renderable.drawUnstyledText = !(this._streaming && this._concealCode);
+    renderable.drawUnstyledText = !this._streaming;
     renderable.streaming = this._streaming;
+    renderable.content = token.text;
     renderable.marginBottom = marginBottom;
   }
   shouldRenderSeparately(token) {
-    return token.type === "code" || token.type === "table" || token.type === "blockquote";
+    return token.type === "code" || token.type === "table" || token.type === "blockquote" || token.type === "hr";
   }
   getInterBlockMargin(token, hasNextToken) {
     if (!hasNextToken)
@@ -9550,6 +8965,9 @@ class MarkdownRenderable extends Renderable {
     return raw.replace(TRAILING_MARKDOWN_BLOCK_BREAKS_RE, `
 `);
   }
+  normalizeScrollbackMarkdownBlockRaw(raw) {
+    return raw.replace(TRAILING_MARKDOWN_BLOCK_NEWLINES_RE, "");
+  }
   buildRenderableTokens(tokens) {
     if (this._renderNode) {
       return tokens.filter((token) => token.type !== "space");
@@ -9591,6 +9009,36 @@ class MarkdownRenderable extends Renderable {
     flushMarkdownRaw();
     return renderTokens;
   }
+  buildTopLevelRenderBlocks(tokens) {
+    const blocks = [];
+    let gapBefore = "";
+    for (let i = 0;i < tokens.length; i += 1) {
+      const token = tokens[i];
+      if (token.type === "space") {
+        gapBefore += token.raw;
+        continue;
+      }
+      const prev = blocks[blocks.length - 1];
+      const marginTop = prev && this.shouldAddTopLevelMargin(prev.token, token, gapBefore) ? 1 : 0;
+      blocks.push({
+        token,
+        sourceTokenEnd: i + 1,
+        marginTop
+      });
+      gapBefore = "";
+    }
+    return blocks;
+  }
+  shouldAddTopLevelMargin(prev, current, gapBefore) {
+    if (this.isSeparatedTopLevelBlock(prev) || this.isSeparatedTopLevelBlock(current))
+      return true;
+    if (prev.type !== "paragraph" || current.type !== "paragraph")
+      return false;
+    return TRAILING_MARKDOWN_BLOCK_BREAKS_RE.test(prev.raw + gapBefore);
+  }
+  isSeparatedTopLevelBlock(token) {
+    return token.type === "heading" || token.type === "list" || this.shouldRenderSeparately(token);
+  }
   getTableRowsToRender(table) {
     return table.rows;
   }
@@ -9712,13 +9160,31 @@ class MarkdownRenderable extends Renderable {
       changed
     };
   }
+  resolveTableStyle(options = this._tableOptions) {
+    if (options?.style === "columns") {
+      return "columns";
+    }
+    if (options?.style === "grid") {
+      return "grid";
+    }
+    return this._internalBlockMode === "top-level" ? "columns" : "grid";
+  }
+  usesBorderlessColumnSpacing(options = this._tableOptions) {
+    const style = this.resolveTableStyle(options);
+    const borders = options?.borders ?? style === "grid";
+    return style === "columns" && !borders;
+  }
   resolveTableRenderableOptions() {
-    const borders = this._tableOptions?.borders ?? true;
+    const style = this.resolveTableStyle();
+    const borders = this._tableOptions?.borders ?? style === "grid";
     return {
-      columnWidthMode: this._tableOptions?.widthMode ?? "full",
+      columnWidthMode: this._tableOptions?.widthMode ?? (style === "columns" ? "content" : "full"),
       columnFitter: this._tableOptions?.columnFitter ?? "proportional",
       wrapMode: this._tableOptions?.wrapMode ?? "word",
       cellPadding: this._tableOptions?.cellPadding ?? 0,
+      cellPaddingX: this._tableOptions?.cellPaddingX ?? this._tableOptions?.cellPadding ?? 0,
+      cellPaddingY: this._tableOptions?.cellPaddingY ?? this._tableOptions?.cellPadding ?? 0,
+      columnGap: this.usesBorderlessColumnSpacing() ? 2 : 0,
       border: borders,
       outerBorder: this._tableOptions?.outerBorder ?? borders,
       showBorders: borders,
@@ -9731,7 +9197,9 @@ class MarkdownRenderable extends Renderable {
     tableRenderable.columnWidthMode = options.columnWidthMode;
     tableRenderable.columnFitter = options.columnFitter;
     tableRenderable.wrapMode = options.wrapMode;
-    tableRenderable.cellPadding = options.cellPadding;
+    tableRenderable.cellPaddingX = options.cellPaddingX;
+    tableRenderable.cellPaddingY = options.cellPaddingY;
+    tableRenderable.columnGap = options.columnGap;
     tableRenderable.border = options.border;
     tableRenderable.outerBorder = options.outerBorder;
     tableRenderable.showBorders = options.showBorders;
@@ -9763,6 +9231,9 @@ class MarkdownRenderable extends Renderable {
       columnFitter: options.columnFitter,
       wrapMode: options.wrapMode,
       cellPadding: options.cellPadding,
+      cellPaddingX: options.cellPaddingX,
+      cellPaddingY: options.cellPaddingY,
+      columnGap: options.columnGap,
       border: options.border,
       outerBorder: options.outerBorder,
       showBorders: options.showBorders,
@@ -9783,12 +9254,106 @@ class MarkdownRenderable extends Renderable {
       tableContentCache: cache
     };
   }
+  getStableBlockCount(blocks, stableTokenCount) {
+    if (this._internalBlockMode !== "top-level") {
+      return 0;
+    }
+    let stableBlockCount = 0;
+    for (const block of blocks) {
+      if (block.sourceTokenEnd <= stableTokenCount) {
+        stableBlockCount += 1;
+        continue;
+      }
+      break;
+    }
+    return stableBlockCount;
+  }
+  syncTopLevelBlockState(state, block, tableContentCache = state.tableContentCache) {
+    state.token = block.token;
+    state.tokenRaw = block.token.raw;
+    state.marginTop = block.marginTop;
+    state.tableContentCache = tableContentCache;
+  }
+  getTopLevelBlockRaw(token) {
+    if (!token.raw) {
+      return;
+    }
+    return this.shouldRenderSeparately(token) ? token.raw : this.normalizeScrollbackMarkdownBlockRaw(token.raw);
+  }
+  createTopLevelDefaultRenderable(block, index) {
+    const { token, marginTop } = block;
+    const id = `${this.id}-block-${index}`;
+    if (token.type === "code") {
+      const renderable2 = this.createCodeRenderable(token, id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
+    if (token.type === "table") {
+      const next = this.createTableBlock(token, id);
+      next.renderable.marginTop = marginTop;
+      return next;
+    }
+    if (token.type === "blockquote") {
+      const renderable2 = this.createBlockquoteRenderable(token, id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
+    if (token.type === "list") {
+      const renderable2 = this.createListRenderable(token, id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
+    if (token.type === "hr") {
+      const renderable2 = this.createHorizontalRuleRenderable(id);
+      renderable2.marginTop = marginTop;
+      return { renderable: renderable2 };
+    }
+    const markdownRaw = this.getTopLevelBlockRaw(token);
+    if (!markdownRaw) {
+      return { renderable: undefined };
+    }
+    const renderable = this.createMarkdownCodeRenderable(markdownRaw, id);
+    renderable.marginTop = marginTop;
+    return { renderable };
+  }
+  createTopLevelRenderable(block, index) {
+    if (!this._renderNode) {
+      return this.createTopLevelDefaultRenderable(block, index);
+    }
+    let next;
+    const context = {
+      syntaxStyle: this._syntaxStyle,
+      conceal: this._conceal,
+      concealCode: this._concealCode,
+      treeSitterClient: this._treeSitterClient,
+      defaultRender: () => {
+        next = this.createTopLevelDefaultRenderable(block, index);
+        return next.renderable ?? null;
+      }
+    };
+    const custom = this._renderNode(block.token, context);
+    if (custom) {
+      const marginTop = typeof custom.marginTop === "number" ? Math.max(custom.marginTop, block.marginTop) : block.marginTop;
+      this.applyMargins(custom, marginTop, 0);
+      return { renderable: custom };
+    }
+    return next ?? this.createTopLevelDefaultRenderable(block, index);
+  }
   createDefaultRenderable(token, index, hasNextToken = false) {
     const id = `${this.id}-block-${index}`;
     const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
       return this.createCodeRenderable(token, id, marginBottom);
     }
+    if (token.type === "blockquote") {
+      return this.createBlockquoteRenderable(token, id, marginBottom);
+    }
+    if (token.type === "list") {
+      return this.createListRenderable(token, id, marginBottom);
+    }
+    if (token.type === "hr") {
+      return this.createHorizontalRuleRenderable(id, marginBottom);
+    }
     if (token.type === "table") {
       return this.createTableBlock(token, id, marginBottom).renderable;
     }
@@ -9800,12 +9365,28 @@ class MarkdownRenderable extends Renderable {
     }
     return this.createMarkdownCodeRenderable(token.raw, id, marginBottom);
   }
-  updateBlockRenderable(state, token, index, hasNextToken) {
+  updateBlockRenderable(state, token, index, hasNextToken, forceListRefresh = false) {
     const marginBottom = this.getInterBlockMargin(token, hasNextToken);
     if (token.type === "code") {
       this.applyCodeBlockRenderable(state.renderable, token, marginBottom);
       return;
     }
+    if (token.type === "blockquote") {
+      this.applyBlockquoteRenderable(state.renderable, token, marginBottom);
+      return;
+    }
+    if (token.type === "list") {
+      if (!this.applyListRenderable(state.renderable, token, forceListRefresh ? undefined : state.token, `${this.id}-block-${index}`, marginBottom)) {
+        state.renderable.destroyRecursively();
+        state.renderable = this.createListRenderable(token, `${this.id}-block-${index}`, marginBottom);
+        this.add(state.renderable, index);
+      }
+      return;
+    }
+    if (token.type === "hr") {
+      state.renderable.marginBottom = marginBottom;
+      return;
+    }
     if (token.type === "table") {
       const tableToken = token;
       const { cache, changed } = this.buildTableContentCache(tableToken, state.tableContentCache);
@@ -9817,7 +9398,7 @@ class MarkdownRenderable extends Renderable {
         }
         state.renderable.destroyRecursively();
         const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${index}`, marginBottom);
-        this.add(fallbackRenderable);
+        this.add(fallbackRenderable, index);
         state.renderable = fallbackRenderable;
         state.tableContentCache = undefined;
         return;
@@ -9833,26 +9414,94 @@ class MarkdownRenderable extends Renderable {
       }
       state.renderable.destroyRecursively();
       const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${index}`, marginBottom);
-      this.add(tableRenderable);
+      this.add(tableRenderable, index);
       state.renderable = tableRenderable;
       state.tableContentCache = cache;
       return;
     }
     if (state.renderable instanceof CodeRenderable) {
-      this.applyMarkdownCodeRenderable(state.renderable, token.raw, marginBottom);
+      this.applyMarkdownCodeRenderable(state.renderable, this.getTopLevelBlockRaw(token) ?? token.raw, marginBottom);
       return;
     }
     state.renderable.destroyRecursively();
-    const markdownRenderable = this.createMarkdownCodeRenderable(token.raw, `${this.id}-block-${index}`, marginBottom);
-    this.add(markdownRenderable);
+    const markdownRenderable = this.createMarkdownCodeRenderable(this.getTopLevelBlockRaw(token) ?? token.raw, `${this.id}-block-${index}`, marginBottom);
+    this.add(markdownRenderable, index);
     state.renderable = markdownRenderable;
   }
+  updateTopLevelBlocks(tokens, forceTableRefresh) {
+    const blocks = this.buildTopLevelRenderBlocks(tokens);
+    this._stableBlockCount = this.getStableBlockCount(blocks, this._parseState?.stableTokenCount ?? 0);
+    let blockIndex = 0;
+    for (let i = 0;i < blocks.length; i += 1) {
+      const block = blocks[i];
+      const existing = this._blockStates[blockIndex];
+      if (existing && existing.token === block.token && !forceTableRefresh) {
+        if (existing.marginTop !== block.marginTop) {
+          this.applyMargins(existing.renderable, block.marginTop, 0);
+        }
+        this.syncTopLevelBlockState(existing, block);
+        blockIndex++;
+        continue;
+      }
+      if (existing && existing.tokenRaw === block.token.raw && existing.token.type === block.token.type && !forceTableRefresh) {
+        if (existing.marginTop !== block.marginTop) {
+          this.applyMargins(existing.renderable, block.marginTop, 0);
+        }
+        this.syncTopLevelBlockState(existing, block);
+        blockIndex++;
+        continue;
+      }
+      if (existing && !forceTableRefresh && !this._renderNode && existing.token.type === block.token.type && this.canUpdateBlockRenderable(existing.renderable, block.token)) {
+        this.updateBlockRenderable(existing, block.token, blockIndex, blockIndex < blocks.length - 1);
+        existing.renderable.marginBottom = 0;
+        if (existing.marginTop !== block.marginTop) {
+          this.applyMargins(existing.renderable, block.marginTop, 0);
+        }
+        this.syncTopLevelBlockState(existing, block);
+        blockIndex++;
+        continue;
+      }
+      if (existing) {
+        existing.renderable.destroyRecursively();
+      }
+      const next = this.createTopLevelRenderable(block, blockIndex);
+      if (next.renderable) {
+        this.add(next.renderable, blockIndex);
+        this._blockStates[blockIndex] = {
+          token: block.token,
+          tokenRaw: block.token.raw,
+          marginTop: block.marginTop,
+          renderable: next.renderable,
+          tableContentCache: next.tableContentCache
+        };
+      }
+      blockIndex++;
+    }
+    while (this._blockStates.length > blockIndex) {
+      const removed = this._blockStates.pop();
+      removed.renderable.destroyRecursively();
+    }
+  }
+  canUpdateBlockRenderable(renderable, token) {
+    if (token.type === "code")
+      return renderable instanceof CodeRenderable;
+    if (token.type === "table")
+      return renderable instanceof TextTableRenderable;
+    if (token.type === "blockquote")
+      return renderable instanceof BoxRenderable;
+    if (token.type === "list")
+      return renderable instanceof BoxRenderable;
+    if (token.type === "hr")
+      return renderable instanceof BoxRenderable;
+    return renderable instanceof CodeRenderable;
+  }
   updateBlocks(forceTableRefresh = false) {
     if (this.isDestroyed)
       return;
     if (!this._content) {
       this.clearBlockStates();
       this._parseState = null;
+      this._stableBlockCount = 0;
       return;
     }
     const trailingUnstable = this._streaming ? 2 : 0;
@@ -9860,17 +9509,24 @@ class MarkdownRenderable extends Renderable {
     const tokens = this._parseState.tokens;
     if (tokens.length === 0 && this._content.length > 0) {
       this.clearBlockStates();
+      this._stableBlockCount = 0;
       const fallback = this.createMarkdownCodeRenderable(this._content, `${this.id}-fallback`);
       this.add(fallback);
       this._blockStates = [
         {
           token: { type: "text", raw: this._content, text: this._content },
           tokenRaw: this._content,
+          marginTop: 0,
           renderable: fallback
         }
       ];
       return;
     }
+    if (this._internalBlockMode === "top-level") {
+      this.updateTopLevelBlocks(tokens, forceTableRefresh);
+      return;
+    }
+    this._stableBlockCount = 0;
     const blockTokens = this.buildRenderableTokens(tokens);
     const lastBlockIndex = blockTokens.length - 1;
     let blockIndex = 0;
@@ -9935,7 +9591,7 @@ class MarkdownRenderable extends Renderable {
         tableContentCache = cache ?? undefined;
       }
       if (renderable) {
-        this.add(renderable);
+        this.add(renderable, blockIndex);
         this._blockStates[blockIndex] = {
           token,
           tokenRaw: token.raw,
@@ -9955,8 +9611,13 @@ class MarkdownRenderable extends Renderable {
       state.renderable.destroyRecursively();
     }
     this._blockStates = [];
+    this._stableBlockCount = 0;
   }
   rerenderBlocks() {
+    if (this._internalBlockMode === "top-level") {
+      this.updateBlocks(true);
+      return;
+    }
     for (let i = 0;i < this._blockStates.length; i++) {
       const state = this._blockStates[i];
       const hasNextToken = i < this._blockStates.length - 1;
@@ -9965,6 +9626,18 @@ class MarkdownRenderable extends Renderable {
         this.applyCodeBlockRenderable(state.renderable, state.token, marginBottom);
         continue;
       }
+      if (state.token.type === "blockquote") {
+        this.applyBlockquoteRenderable(state.renderable, state.token, marginBottom);
+        continue;
+      }
+      if (state.token.type === "list") {
+        this.updateBlockRenderable(state, state.token, i, hasNextToken, true);
+        continue;
+      }
+      if (state.token.type === "hr") {
+        state.renderable.marginBottom = marginBottom;
+        continue;
+      }
       if (state.token.type === "table") {
         const tableToken = state.token;
         const { cache } = this.buildTableContentCache(tableToken, state.tableContentCache, true);
@@ -9974,7 +9647,7 @@ class MarkdownRenderable extends Renderable {
           } else {
             state.renderable.destroyRecursively();
             const fallbackRenderable = this.createMarkdownCodeRenderable(tableToken.raw, `${this.id}-block-${i}`, marginBottom);
-            this.add(fallbackRenderable);
+            this.add(fallbackRenderable, i);
             state.renderable = fallbackRenderable;
           }
           state.tableContentCache = undefined;
@@ -9989,18 +9662,18 @@ class MarkdownRenderable extends Renderable {
         }
         state.renderable.destroyRecursively();
         const tableRenderable = this.createTextTableRenderable(cache.content, `${this.id}-block-${i}`, marginBottom);
-        this.add(tableRenderable);
+        this.add(tableRenderable, i);
         state.renderable = tableRenderable;
         state.tableContentCache = cache;
         continue;
       }
       if (state.renderable instanceof CodeRenderable) {
-        this.applyMarkdownCodeRenderable(state.renderable, state.token.raw, marginBottom);
+        this.applyMarkdownCodeRenderable(state.renderable, this.getTopLevelBlockRaw(state.token) ?? state.token.raw, marginBottom);
         continue;
       }
       state.renderable.destroyRecursively();
-      const markdownRenderable = this.createMarkdownCodeRenderable(state.token.raw, `${this.id}-block-${i}`, marginBottom);
-      this.add(markdownRenderable);
+      const markdownRenderable = this.createMarkdownCodeRenderable(this.getTopLevelBlockRaw(state.token) ?? state.token.raw, `${this.id}-block-${i}`, marginBottom);
+      this.add(markdownRenderable, i);
       state.renderable = markdownRenderable;
     }
   }
@@ -10619,11 +10292,19 @@ class ContentRenderable extends BoxRenderable {
   set viewportCulling(value) {
     this._viewportCulling = value;
   }
+  _hasVisibleChildFilter() {
+    return this._viewportCulling;
+  }
   _getVisibleChildren() {
     if (this._viewportCulling) {
-      return getObjectsInViewport(this.viewport, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis, 0).map((child) => child.num);
+      return getObjectsInViewport({
+        x: this.viewport.screenX,
+        y: this.viewport.screenY,
+        width: this.viewport.width,
+        height: this.viewport.height
+      }, this.getChildrenSortedByPrimaryAxis(), this.primaryAxis, 0).map((child) => child.num);
     }
-    return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
+    return super._getVisibleChildren();
   }
 }
 var SCROLLBOX_PADDING_KEYS = [
@@ -11210,7 +10891,9 @@ class ScrollBoxRenderable extends BoxRenderable {
     } finally {
       this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
-    this.requestRender();
+    process.nextTick(() => {
+      this.requestRender();
+    });
   }
   set padding(value) {
     this.content.padding = value;
@@ -11516,15 +11199,7 @@ class SelectRenderable extends Renderable {
     this.requestRender();
   }
   handleKeyPress(key) {
-    const bindingKey = getKeyBindingKey({
-      name: key.name,
-      ctrl: key.ctrl,
-      shift: key.shift,
-      meta: key.meta,
-      super: key.super,
-      action: "move-up"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
+    const action = getKeyBindingAction(this._keyBindingsMap, key);
     if (action) {
       switch (action) {
         case "move-up":
@@ -11884,15 +11559,7 @@ class TabSelectRenderable extends Renderable {
     return this._tabWidth;
   }
   handleKeyPress(key) {
-    const bindingKey = getKeyBindingKey({
-      name: key.name,
-      ctrl: key.ctrl,
-      shift: key.shift,
-      meta: key.meta,
-      super: key.super,
-      action: "move-left"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
+    const action = getKeyBindingAction(this._keyBindingsMap, key);
     if (action) {
       switch (action) {
         case "move-left":
@@ -12068,7 +11735,7 @@ class TimeToFirstDrawRenderable extends Renderable {
     return Math.max(0, Math.floor(value));
   }
 }
-export { TextBufferView, convertThemeToStyles, SyntaxStyle, DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, FrameBufferRenderable, ASCIIFontRenderable, BoxRenderable, TextBufferRenderable, CodeRenderable, isTextNodeRenderable, TextNodeRenderable, RootTextNodeRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, TextRenderable, DiffRenderable, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
+export { DistortionEffect, VignetteEffect, CloudsEffect, FlamesEffect, CRTRollingBarEffect, RainbowTextEffect, applyScanlines, applyInvert, applyNoise, applyChromaticAberration, applyAsciiArt, applyBrightness, applyGain, applySaturation, BloomEffect, SEPIA_MATRIX, PROTANOPIA_SIM_MATRIX, DEUTERANOPIA_SIM_MATRIX, TRITANOPIA_SIM_MATRIX, ACHROMATOPSIA_MATRIX, PROTANOPIA_COMP_MATRIX, DEUTERANOPIA_COMP_MATRIX, TRITANOPIA_COMP_MATRIX, TECHNICOLOR_MATRIX, SOLARIZATION_MATRIX, SYNTHWAVE_MATRIX, GREENSCALE_MATRIX, GRAYSCALE_MATRIX, INVERT_MATRIX, Timeline, engine, createTimeline, SlotRegistry, createSlotRegistry, createCoreSlotRegistry, registerCorePlugin, resolveCoreSlot, SlotRenderable, NativeSpanFeed, Audio, setupAudio, FrameBufferRenderable, ASCIIFontRenderable, Generic, Box, Text, ASCIIFont, Input, Select, TabSelect, FrameBuffer, Code, ScrollBox, vstyles, VRenderable, LineNumberRenderable, DiffRenderable, defaultTextareaKeyBindings, TextareaRenderable, InputRenderableEvents, InputRenderable, TextTableRenderable, MarkdownRenderable, SliderRenderable, ScrollBarRenderable, ArrowRenderable, ScrollBoxRenderable, SelectRenderableEvents, SelectRenderable, TabSelectRenderableEvents, TabSelectRenderable, TimeToFirstDrawRenderable, exports_src2 as exports_src };
 
-//# debugId=AD3EE32E00BF5BFC64756E2164756E21
-//# sourceMappingURL=index-yxe6e14n.js.map
+//# debugId=F2F05271FFA5C07164756E2164756E21
+//# sourceMappingURL=index-46f5e8m6.js.map