@opentui/core 0.1.60 → 0.1.61

package/{index-916mvx7m.js → index-rysm4rsr.js}

@@ -2319,6 +2319,7 @@ var parseKeypress = (s = "", options = {}) => {
     const segs = [...s];
     if (segs[0] === "\x1B" && segs[1] === "\x1B") {
       key.option = true;
+      key.meta = true;
     }
     const code = [parts[1], parts[2], parts[4], parts[6]].filter(Boolean).join("");
     const modifier = parseInt(parts[3] || parts[5] || "1", 10) - 1;
@@ -9390,6 +9391,22 @@ class OptimizedBuffer {
     this.guard();
     this.lib.bufferClearScissorRects(this.bufferPtr);
   }
+  pushOpacity(opacity) {
+    this.guard();
+    this.lib.bufferPushOpacity(this.bufferPtr, Math.max(0, Math.min(1, opacity)));
+  }
+  popOpacity() {
+    this.guard();
+    this.lib.bufferPopOpacity(this.bufferPtr);
+  }
+  getCurrentOpacity() {
+    this.guard();
+    return this.lib.bufferGetCurrentOpacity(this.bufferPtr);
+  }
+  clearOpacity() {
+    this.guard();
+    this.lib.bufferClearOpacity(this.bufferPtr);
+  }
   encodeUnicode(text) {
     this.guard();
     return this.lib.encodeUnicode(text, this._widthMethod);
@@ -10132,6 +10149,9 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+var globalTraceSymbols = null;
+var globalFFILogWriter = null;
+var exitHandlerRegistered = false;
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
   const rawSymbols = dlopen(resolvedLibPath, {
@@ -10319,6 +10339,22 @@ function getOpenTUILib(libPath) {
       args: ["ptr"],
       returns: "void"
     },
+    bufferPushOpacity: {
+      args: ["ptr", "f32"],
+      returns: "void"
+    },
+    bufferPopOpacity: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    bufferGetCurrentOpacity: {
+      args: ["ptr"],
+      returns: "f32"
+    },
+    bufferClearOpacity: {
+      args: ["ptr"],
+      returns: "void"
+    },
     addToHitGrid: {
       args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
       returns: "void"
@@ -10859,6 +10895,14 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "ptr"],
       returns: "void"
     },
+    editorViewGetVisualSOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    editorViewGetVisualEOL: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
     editorViewSetPlaceholderStyledText: {
       args: ["ptr", "ptr", "usize"],
       returns: "void"
@@ -10924,19 +10968,22 @@ function getOpenTUILib(libPath) {
   return rawSymbols;
 }
 function convertToDebugSymbols(symbols) {
+  if (!globalTraceSymbols) {
+    globalTraceSymbols = {};
+  }
+  if (env.OTUI_DEBUG_FFI && !globalFFILogWriter) {
+    const now = new Date;
+    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+    const logFilePath = `ffi_otui_debug_${timestamp}.log`;
+    globalFFILogWriter = Bun.file(logFilePath).writer();
+  }
   const debugSymbols = {};
-  const traceSymbols = {};
   let hasTracing = false;
-  let ffiLogWriter = null;
   Object.entries(symbols).forEach(([key, value]) => {
     debugSymbols[key] = value;
   });
-  if (env.OTUI_DEBUG_FFI) {
-    const now = new Date;
-    const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
-    const logFilePath = `ffi_otui_debug_${timestamp}.log`;
-    ffiLogWriter = Bun.file(logFilePath).writer();
-    const writer = ffiLogWriter;
+  if (env.OTUI_DEBUG_FFI && globalFFILogWriter) {
+    const writer = globalFFILogWriter;
     const writeSync = (msg) => {
       const buffer = new TextEncoder().encode(msg + `
 `);
@@ -10958,89 +11005,104 @@ function convertToDebugSymbols(symbols) {
     hasTracing = true;
     Object.entries(symbols).forEach(([key, value]) => {
       if (typeof value === "function") {
-        traceSymbols[key] = [];
+        if (!globalTraceSymbols[key]) {
+          globalTraceSymbols[key] = [];
+        }
         const originalFunc = debugSymbols[key];
         debugSymbols[key] = (...args) => {
           const start = performance.now();
           const result = originalFunc(...args);
           const end = performance.now();
-          traceSymbols[key].push(end - start);
+          globalTraceSymbols[key].push(end - start);
           return result;
         };
       }
     });
   }
-  if (env.OTUI_DEBUG_FFI && ffiLogWriter) {
+  if ((env.OTUI_DEBUG_FFI || env.OTUI_TRACE_FFI) && !exitHandlerRegistered) {
+    exitHandlerRegistered = true;
     process.on("exit", () => {
       try {
-        ffiLogWriter.end();
+        if (globalFFILogWriter) {
+          globalFFILogWriter.end();
+        }
       } catch (e) {}
-    });
-  }
-  if (hasTracing) {
-    process.on("exit", () => {
-      const allStats = [];
-      for (const [key, timings] of Object.entries(traceSymbols)) {
-        if (!Array.isArray(timings) || timings.length === 0) {
-          continue;
+      if (globalTraceSymbols) {
+        const allStats = [];
+        for (const [key, timings] of Object.entries(globalTraceSymbols)) {
+          if (!Array.isArray(timings) || timings.length === 0) {
+            continue;
+          }
+          const sortedTimings = [...timings].sort((a, b) => a - b);
+          const count = sortedTimings.length;
+          const total = sortedTimings.reduce((acc, t2) => acc + t2, 0);
+          const average = total / count;
+          const min = sortedTimings[0];
+          const max = sortedTimings[count - 1];
+          const medianIndex = Math.floor(count / 2);
+          const p90Index = Math.floor(count * 0.9);
+          const p99Index = Math.floor(count * 0.99);
+          const median = sortedTimings[medianIndex];
+          const p90 = sortedTimings[Math.min(p90Index, count - 1)];
+          const p99 = sortedTimings[Math.min(p99Index, count - 1)];
+          allStats.push({
+            name: key,
+            count,
+            total,
+            average,
+            min,
+            max,
+            median,
+            p90,
+            p99
+          });
         }
-        const sortedTimings = [...timings].sort((a, b) => a - b);
-        const count = sortedTimings.length;
-        const total = sortedTimings.reduce((acc, t2) => acc + t2, 0);
-        const average = total / count;
-        const min = sortedTimings[0];
-        const max = sortedTimings[count - 1];
-        const medianIndex = Math.floor(count / 2);
-        const p90Index = Math.floor(count * 0.9);
-        const p99Index = Math.floor(count * 0.99);
-        const median = sortedTimings[medianIndex];
-        const p90 = sortedTimings[Math.min(p90Index, count - 1)];
-        const p99 = sortedTimings[Math.min(p99Index, count - 1)];
-        allStats.push({
-          name: key,
-          count,
-          total,
-          average,
-          min,
-          max,
-          median,
-          p90,
-          p99
-        });
-      }
-      allStats.sort((a, b) => b.total - a.total);
-      console.log(`
+        allStats.sort((a, b) => b.total - a.total);
+        const lines = [];
+        lines.push(`
 --- OpenTUI FFI Call Performance ---`);
-      console.log("Sorted by total time spent (descending)");
-      console.log("-------------------------------------------------------------------------------------------------------------------------");
-      if (allStats.length === 0) {
-        console.log("No trace data collected or all symbols had zero calls.");
-      } else {
-        const nameHeader = "Symbol";
-        const callsHeader = "Calls";
-        const totalHeader = "Total (ms)";
-        const avgHeader = "Avg (ms)";
-        const minHeader = "Min (ms)";
-        const maxHeader = "Max (ms)";
-        const medHeader = "Med (ms)";
-        const p90Header = "P90 (ms)";
-        const p99Header = "P99 (ms)";
-        const nameWidth = Math.max(nameHeader.length, ...allStats.map((s) => s.name.length));
-        const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
-        const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
-        const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
-        const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
-        const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
-        const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
-        const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
-        const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
-        console.log(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
-        console.log(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
-        allStats.forEach((stat) => {
-          console.log(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
-        });
+        lines.push("Sorted by total time spent (descending)");
+        lines.push("-------------------------------------------------------------------------------------------------------------------------");
+        if (allStats.length === 0) {
+          lines.push("No trace data collected or all symbols had zero calls.");
+        } else {
+          const nameHeader = "Symbol";
+          const callsHeader = "Calls";
+          const totalHeader = "Total (ms)";
+          const avgHeader = "Avg (ms)";
+          const minHeader = "Min (ms)";
+          const maxHeader = "Max (ms)";
+          const medHeader = "Med (ms)";
+          const p90Header = "P90 (ms)";
+          const p99Header = "P99 (ms)";
+          const nameWidth = Math.max(nameHeader.length, ...allStats.map((s) => s.name.length));
+          const countWidth = Math.max(callsHeader.length, ...allStats.map((s) => String(s.count).length));
+          const totalWidth = Math.max(totalHeader.length, ...allStats.map((s) => s.total.toFixed(2).length));
+          const avgWidth = Math.max(avgHeader.length, ...allStats.map((s) => s.average.toFixed(2).length));
+          const minWidth = Math.max(minHeader.length, ...allStats.map((s) => s.min.toFixed(2).length));
+          const maxWidth = Math.max(maxHeader.length, ...allStats.map((s) => s.max.toFixed(2).length));
+          const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
+          const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
+          const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
+          lines.push(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(minWidth)} | ${maxHeader.padStart(maxWidth)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
+          lines.push(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(minWidth)}-+-${"-".repeat(maxWidth)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
+          allStats.forEach((stat) => {
+            lines.push(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(minWidth)} | ${stat.max.toFixed(2).padStart(maxWidth)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
+          });
+        }
+        lines.push("-------------------------------------------------------------------------------------------------------------------------");
+        const output = lines.join(`
+`);
+        console.log(output);
+        try {
+          const now = new Date;
+          const timestamp = now.toISOString().replace(/[:.]/g, "-").replace(/T/, "_").split("Z")[0];
+          const traceFilePath = `ffi_otui_trace_${timestamp}.log`;
+          Bun.write(traceFilePath, output);
+        } catch (e) {
+          console.error("Failed to write FFI trace file:", e);
+        }
       }
-      console.log("-------------------------------------------------------------------------------------------------------------------------");
     });
   }
   return debugSymbols;
@@ -11982,6 +12044,16 @@ class FFIRenderLib {
     this.opentui.symbols.editorViewGetEOL(view, ptr3(cursorBuffer));
     return VisualCursorStruct.unpack(cursorBuffer);
   }
+  editorViewGetVisualSOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualSOL(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
+  editorViewGetVisualEOL(view) {
+    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
+    this.opentui.symbols.editorViewGetVisualEOL(view, ptr3(cursorBuffer));
+    return VisualCursorStruct.unpack(cursorBuffer);
+  }
   bufferPushScissorRect(buffer, x, y, width, height) {
     this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height);
   }
@@ -11991,6 +12063,18 @@ class FFIRenderLib {
   bufferClearScissorRects(buffer) {
     this.opentui.symbols.bufferClearScissorRects(buffer);
   }
+  bufferPushOpacity(buffer, opacity) {
+    this.opentui.symbols.bufferPushOpacity(buffer, opacity);
+  }
+  bufferPopOpacity(buffer) {
+    this.opentui.symbols.bufferPopOpacity(buffer);
+  }
+  bufferGetCurrentOpacity(buffer) {
+    return this.opentui.symbols.bufferGetCurrentOpacity(buffer);
+  }
+  bufferClearOpacity(buffer) {
+    this.opentui.symbols.bufferClearOpacity(buffer);
+  }
   getTerminalCapabilities(renderer) {
     const capsBuffer = new ArrayBuffer(TerminalCapabilitiesStruct.size);
     this.opentui.symbols.getTerminalCapabilities(renderer, ptr3(capsBuffer));
@@ -12483,6 +12567,7 @@ class Renderable extends BaseRenderable {
   _positionType = "relative";
   _overflow = "visible";
   _position = {};
+  _opacity = 1;
   _flexShrink = 1;
   renderableMapById = new Map;
   _childrenInLayoutOrder = [];
@@ -12515,6 +12600,7 @@ class Renderable extends BaseRenderable {
     this.buffered = options.buffered ?? false;
     this._live = options.live ?? false;
     this._liveCount = this._live && this._visible ? 1 : 0;
+    this._opacity = options.opacity !== undefined ? Math.max(0, Math.min(1, options.opacity)) : 1;
     this.yogaNode = src_default.Node.create(yogaConfig);
     this.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
     this.setupYogaProperties(options);
@@ -12564,6 +12650,16 @@ class Renderable extends BaseRenderable {
     }
     this.requestRender();
   }
+  get opacity() {
+    return this._opacity;
+  }
+  set opacity(value) {
+    const clamped = Math.max(0, Math.min(1, value));
+    if (this._opacity !== clamped) {
+      this._opacity = clamped;
+      this.requestRender();
+    }
+  }
   hasSelection() {
     return false;
   }
@@ -12682,7 +12778,7 @@ class Renderable extends BaseRenderable {
       this.parent.childrenPrimarySortDirty = true;
   }
   get x() {
-    if (this.parent && this._positionType === "relative") {
+    if (this.parent) {
       return this.parent.x + this._x + this._translateX;
     }
     return this._x + this._translateX;
@@ -12723,7 +12819,7 @@ class Renderable extends BaseRenderable {
     }
   }
   get y() {
-    if (this.parent && this._positionType === "relative") {
+    if (this.parent) {
       return this.parent.y + this._y + this._translateY;
     }
     return this._y + this._translateY;
@@ -13308,6 +13404,10 @@ class Renderable extends BaseRenderable {
     }
     if (this._isDestroyed)
       return;
+    const shouldPushOpacity = this._opacity < 1;
+    if (shouldPushOpacity) {
+      renderList.push({ action: "pushOpacity", opacity: this._opacity });
+    }
     renderList.push({ action: "render", renderable: this });
     this.ensureZIndexSorted();
     const shouldPushScissor = this._overflow !== "visible" && this.width > 0 && this.height > 0;
@@ -13332,6 +13432,9 @@ class Renderable extends BaseRenderable {
     if (shouldPushScissor) {
       renderList.push({ action: "popScissorRect" });
     }
+    if (shouldPushOpacity) {
+      renderList.push({ action: "popOpacity" });
+    }
   }
   render(buffer, deltaTime) {
     let renderBuffer = buffer;
@@ -13545,6 +13648,12 @@ class RootRenderable extends Renderable {
         case "popScissorRect":
           buffer.popScissorRect();
           break;
+        case "pushOpacity":
+          buffer.pushOpacity(command.opacity);
+          break;
+        case "popOpacity":
+          buffer.popOpacity();
+          break;
       }
     }
   }
@@ -13788,6 +13897,59 @@ class CapturedWritableStream extends Writable {
   }
 }
 
+// src/lib/keymapping.ts
+var defaultKeyAliases = {
+  enter: "return",
+  esc: "escape"
+};
+function mergeKeyAliases(defaults, custom) {
+  return { ...defaults, ...custom };
+}
+function mergeKeyBindings(defaults, custom) {
+  const map = new Map;
+  for (const binding of defaults) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  for (const binding of custom) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding);
+  }
+  return Array.from(map.values());
+}
+function getKeyBindingKey(binding) {
+  return `${binding.name}:${binding.ctrl ? 1 : 0}:${binding.shift ? 1 : 0}:${binding.meta ? 1 : 0}:${binding.super ? 1 : 0}`;
+}
+function buildKeyBindingsMap(bindings, aliasMap) {
+  const map = new Map;
+  const aliases = aliasMap || {};
+  for (const binding of bindings) {
+    const key = getKeyBindingKey(binding);
+    map.set(key, binding.action);
+  }
+  for (const binding of bindings) {
+    const normalizedName = aliases[binding.name] || binding.name;
+    if (normalizedName !== binding.name) {
+      const aliasedKey = getKeyBindingKey({ ...binding, name: normalizedName });
+      map.set(aliasedKey, binding.action);
+    }
+  }
+  return map;
+}
+function keyBindingToString(binding) {
+  const parts = [];
+  if (binding.ctrl)
+    parts.push("ctrl");
+  if (binding.shift)
+    parts.push("shift");
+  if (binding.meta)
+    parts.push("meta");
+  if (binding.super)
+    parts.push("super");
+  parts.push(binding.name);
+  return parts.join("+");
+}
+
 // src/console.ts
 function getCallerInfo() {
   const err = new Error;
@@ -13927,6 +14089,19 @@ var ConsolePosition;
   ConsolePosition2["LEFT"] = "left";
   ConsolePosition2["RIGHT"] = "right";
 })(ConsolePosition ||= {});
+var defaultConsoleKeybindings = [
+  { name: "up", action: "scroll-up" },
+  { name: "down", action: "scroll-down" },
+  { name: "up", shift: true, action: "scroll-to-top" },
+  { name: "down", shift: true, action: "scroll-to-bottom" },
+  { name: "p", ctrl: true, action: "position-previous" },
+  { name: "o", ctrl: true, action: "position-next" },
+  { name: "+", action: "size-increase" },
+  { name: "=", shift: true, action: "size-increase" },
+  { name: "-", action: "size-decrease" },
+  { name: "s", ctrl: true, action: "save-logs" },
+  { name: "c", ctrl: true, shift: true, action: "copy-selection" }
+];
 var DEFAULT_CONSOLE_OPTIONS = {
   position: "bottom" /* BOTTOM */,
   sizePercent: 30,
@@ -13943,7 +14118,12 @@ var DEFAULT_CONSOLE_OPTIONS = {
   titleBarTextColor: "#FFFFFF",
   cursorColor: "#00A0FF",
   maxStoredLogs: 2000,
-  maxDisplayLines: 3000
+  maxDisplayLines: 3000,
+  onCopySelection: undefined,
+  keyBindings: undefined,
+  keyAliasMap: undefined,
+  selectionColor: RGBA.fromValues(0.3, 0.5, 0.8, 0.5),
+  copyButtonColor: "#00A0FF"
 };
 var INDENT_WIDTH = 2;
 
@@ -13966,10 +14146,34 @@ class TerminalConsole extends EventEmitter8 {
   _allLogEntries = [];
   _needsFrameBufferUpdate = false;
   _entryListener;
+  _selectionStart = null;
+  _selectionEnd = null;
+  _isSelecting = false;
+  _copyButtonBounds = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  };
+  _autoScrollInterval = null;
+  _keyBindingsMap;
+  _keyAliasMap;
+  _keyBindings;
+  _mergedKeyBindings;
+  _actionHandlers;
   markNeedsRerender() {
     this._needsFrameBufferUpdate = true;
     this.renderer.requestRender();
   }
+  getCopyButtonLabel() {
+    const copyBindings = this._mergedKeyBindings.filter((b) => b.action === "copy-selection");
+    const copyBinding = copyBindings[copyBindings.length - 1];
+    if (copyBinding) {
+      const shortcut = keyBindingToString(copyBinding);
+      return `[Copy (${shortcut})]`;
+    }
+    return "[Copy]";
+  }
   _rgbaInfo;
   _rgbaWarn;
   _rgbaError;
@@ -13980,6 +14184,8 @@ class TerminalConsole extends EventEmitter8 {
   _rgbaTitleBarText;
   _title;
   _rgbaCursor;
+  _rgbaSelection;
+  _rgbaCopyButton;
   _positions = [
     "top" /* TOP */,
     "right" /* RIGHT */,
@@ -14003,6 +14209,13 @@ class TerminalConsole extends EventEmitter8 {
     this._rgbaTitleBarText = parseColor(this.options.titleBarTextColor || this.options.colorDefault);
     this._title = this.options.title;
     this._rgbaCursor = parseColor(this.options.cursorColor);
+    this._rgbaSelection = parseColor(this.options.selectionColor);
+    this._rgbaCopyButton = parseColor(this.options.copyButtonColor);
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, options.keyAliasMap || {});
+    this._keyBindings = options.keyBindings || [];
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this._actionHandlers = this.buildActionHandlers();
     this._updateConsoleDimensions();
     this._scrollToBottom(true);
     this._entryListener = (logEntry) => {
@@ -14013,6 +14226,20 @@ class TerminalConsole extends EventEmitter8 {
       this.show();
     }
   }
+  buildActionHandlers() {
+    return new Map([
+      ["scroll-up", () => this.scrollUp()],
+      ["scroll-down", () => this.scrollDown()],
+      ["scroll-to-top", () => this.scrollToTop()],
+      ["scroll-to-bottom", () => this.scrollToBottomAction()],
+      ["position-previous", () => this.positionPrevious()],
+      ["position-next", () => this.positionNext()],
+      ["size-increase", () => this.sizeIncrease()],
+      ["size-decrease", () => this.sizeDecrease()],
+      ["save-logs", () => this.saveLogsAction()],
+      ["copy-selection", () => this.triggerCopyAction()]
+    ]);
+  }
   activate() {
     terminalConsoleCache.activate();
   }
@@ -14039,8 +14266,8 @@ class TerminalConsole extends EventEmitter8 {
     this.markNeedsRerender();
   }
   _updateConsoleDimensions(termWidth, termHeight) {
-    const width = termWidth ?? this.renderer.terminalWidth;
-    const height = termHeight ?? this.renderer.terminalHeight;
+    const width = termWidth ?? this.renderer.width;
+    const height = termHeight ?? this.renderer.height;
     const sizePercent = this.options.sizePercent / 100;
     switch (this.options.position) {
       case "top" /* TOP */:
@@ -14071,68 +14298,103 @@ class TerminalConsole extends EventEmitter8 {
     this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
   }
   handleKeyPress(event) {
-    let needsRedraw = false;
-    const displayLineCount = this._displayLines.length;
-    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
-    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
-    const currentPositionIndex = this._positions.indexOf(this.options.position);
     if (event.name === "escape") {
       this.blur();
       return;
     }
-    if (event.name === "up" && event.shift) {
-      if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
-        this.scrollTopIndex = 0;
-        this.currentLineIndex = 0;
-        this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
-        needsRedraw = true;
-      }
-    } else if (event.name === "down" && event.shift) {
-      const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
-      const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
-      if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
-        this._scrollToBottom(true);
-        needsRedraw = true;
-      }
-    } else if (event.name === "up") {
-      if (this.currentLineIndex > 0) {
-        this.currentLineIndex--;
-        needsRedraw = true;
-      } else if (this.scrollTopIndex > 0) {
-        this.scrollTopIndex--;
-        this.isScrolledToBottom = false;
-        needsRedraw = true;
-      }
-    } else if (event.name === "down") {
-      const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
-      if (canCursorMoveDown) {
-        this.currentLineIndex++;
-        needsRedraw = true;
-      } else if (this.scrollTopIndex < maxScrollTop) {
-        this.scrollTopIndex++;
-        this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
-        needsRedraw = true;
-      }
-    } else if (event.name === "p" && event.ctrl) {
-      const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
-      this.options.position = this._positions[prevIndex];
-      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-    } else if (event.name === "o" && event.ctrl) {
-      const nextIndex = (currentPositionIndex + 1) % this._positions.length;
-      this.options.position = this._positions[nextIndex];
-      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-    } else if (event.name === "+" || event.name === "=" && event.shift) {
-      this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
-      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-    } else if (event.name === "-") {
-      this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
-      this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-    } else if (event.name === "s" && event.ctrl) {
-      this.saveLogsToFile();
-    }
-    if (needsRedraw) {
+    const bindingKey = getKeyBindingKey({
+      name: event.name,
+      ctrl: event.ctrl,
+      shift: event.shift,
+      meta: event.meta,
+      super: event.super,
+      action: "scroll-up"
+    });
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      const handler = this._actionHandlers.get(action);
+      if (handler) {
+        handler();
+        return;
+      }
+    }
+  }
+  scrollUp() {
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    if (this.currentLineIndex > 0) {
+      this.currentLineIndex--;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex > 0) {
+      this.scrollTopIndex--;
+      this.isScrolledToBottom = false;
       this.markNeedsRerender();
     }
+    return true;
+  }
+  scrollDown() {
+    const displayLineCount = this._displayLines.length;
+    const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+    const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+    const canCursorMoveDown = this.currentLineIndex < logAreaHeight - 1 && this.scrollTopIndex + this.currentLineIndex < displayLineCount - 1;
+    if (canCursorMoveDown) {
+      this.currentLineIndex++;
+      this.markNeedsRerender();
+    } else if (this.scrollTopIndex < maxScrollTop) {
+      this.scrollTopIndex++;
+      this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToTop() {
+    if (this.scrollTopIndex > 0 || this.currentLineIndex > 0) {
+      this.scrollTopIndex = 0;
+      this.currentLineIndex = 0;
+      this.isScrolledToBottom = this._displayLines.length <= Math.max(1, this.consoleHeight - 1);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  scrollToBottomAction() {
+    const logAreaHeightForScroll = Math.max(1, this.consoleHeight - 1);
+    const maxScrollPossible = Math.max(0, this._displayLines.length - logAreaHeightForScroll);
+    if (this.scrollTopIndex < maxScrollPossible || !this.isScrolledToBottom) {
+      this._scrollToBottom(true);
+      this.markNeedsRerender();
+    }
+    return true;
+  }
+  positionPrevious() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
+    this.options.position = this._positions[prevIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  positionNext() {
+    const currentPositionIndex = this._positions.indexOf(this.options.position);
+    const nextIndex = (currentPositionIndex + 1) % this._positions.length;
+    this.options.position = this._positions[nextIndex];
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeIncrease() {
+    this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  sizeDecrease() {
+    this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
+    this.resize(this.renderer.width, this.renderer.height);
+    return true;
+  }
+  saveLogsAction() {
+    this.saveLogsToFile();
+    return true;
+  }
+  triggerCopyAction() {
+    this.triggerCopy();
+    return true;
   }
   attachStdin() {
     if (this.isFocused)
@@ -14249,6 +14511,7 @@ class TerminalConsole extends EventEmitter8 {
     }
   }
   destroy() {
+    this.stopAutoScroll();
     this.hide();
     this.deactivate();
     terminalConsoleCache.off("entry", this._entryListener);
@@ -14268,13 +14531,26 @@ class TerminalConsole extends EventEmitter8 {
     const dynamicTitle = `${this._title}${this.isFocused ? " (Focused)" : ""}`;
     const titleX = Math.max(0, Math.floor((this.consoleWidth - dynamicTitle.length) / 2));
     this.frameBuffer.drawText(dynamicTitle, titleX, 0, this._rgbaTitleBarText, this._rgbaTitleBar);
+    const copyLabel = this.getCopyButtonLabel();
+    const copyButtonX = this.consoleWidth - copyLabel.length - 1;
+    if (copyButtonX >= 0) {
+      const copyButtonEnabled = this.hasSelection();
+      const disabledColor = RGBA.fromInts(100, 100, 100, 255);
+      const copyColor = copyButtonEnabled ? this._rgbaCopyButton : disabledColor;
+      this.frameBuffer.drawText(copyLabel, copyButtonX, 0, copyColor, this._rgbaTitleBar);
+      this._copyButtonBounds = { x: copyButtonX, y: 0, width: copyLabel.length, height: 1 };
+    } else {
+      this._copyButtonBounds = { x: -1, y: -1, width: 0, height: 0 };
+    }
     const startIndex = this.scrollTopIndex;
     const endIndex = Math.min(startIndex + logAreaHeight, displayLineCount);
     const visibleDisplayLines = displayLines.slice(startIndex, endIndex);
     let lineY = 1;
-    for (const displayLine of visibleDisplayLines) {
+    for (let i = 0;i < visibleDisplayLines.length; i++) {
       if (lineY >= this.consoleHeight)
         break;
+      const displayLine = visibleDisplayLines[i];
+      const absoluteLineIndex = startIndex + i;
       let levelColor = this._rgbaDefault;
       switch (displayLine.level) {
         case "INFO" /* INFO */:
@@ -14299,7 +14575,24 @@ class TerminalConsole extends EventEmitter8 {
       } else {
         this.frameBuffer.drawText(" ", 0, lineY, this._rgbaDefault, this.backgroundColor);
       }
-      this.frameBuffer.drawText(`${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`, 1, lineY, levelColor);
+      const fullText = `${linePrefix}${textToDraw.substring(0, textAvailableWidth)}`;
+      const selectionRange = this.getLineSelectionRange(absoluteLineIndex);
+      if (selectionRange) {
+        const adjustedStart = Math.max(0, selectionRange.start);
+        const adjustedEnd = Math.min(fullText.length, selectionRange.end);
+        if (adjustedStart > 0) {
+          this.frameBuffer.drawText(fullText.substring(0, adjustedStart), 1, lineY, levelColor);
+        }
+        if (adjustedStart < adjustedEnd) {
+          this.frameBuffer.fillRect(1 + adjustedStart, lineY, adjustedEnd - adjustedStart, 1, this._rgbaSelection);
+          this.frameBuffer.drawText(fullText.substring(adjustedStart, adjustedEnd), 1 + adjustedStart, lineY, levelColor, this._rgbaSelection);
+        }
+        if (adjustedEnd < fullText.length) {
+          this.frameBuffer.drawText(fullText.substring(adjustedEnd), 1 + adjustedEnd, lineY, levelColor);
+        }
+      } else {
+        this.frameBuffer.drawText(fullText, 1, lineY, levelColor);
+      }
       lineY++;
     }
   }
@@ -14322,6 +14615,24 @@ class TerminalConsole extends EventEmitter8 {
   toggleDebugMode() {
     this.setDebugMode(!this._debugModeEnabled);
   }
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this.markNeedsRerender();
+  }
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    this._mergedKeyBindings = mergeKeyBindings(defaultConsoleKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(this._mergedKeyBindings, this._keyAliasMap);
+    this.markNeedsRerender();
+  }
+  set onCopySelection(callback) {
+    this.options.onCopySelection = callback;
+  }
+  get onCopySelection() {
+    return this.options.onCopySelection;
+  }
   _scrollToBottom(forceCursorToLastLine = false) {
     const displayLineCount = this._displayLines.length;
     const logAreaHeight = Math.max(1, this.consoleHeight - 1);
@@ -14379,6 +14690,214 @@ class TerminalConsole extends EventEmitter8 {
       this._displayLines.splice(0, this._displayLines.length - this.options.maxDisplayLines);
     }
   }
+  hasSelection() {
+    if (this._selectionStart === null || this._selectionEnd === null)
+      return false;
+    return this._selectionStart.line !== this._selectionEnd.line || this._selectionStart.col !== this._selectionEnd.col;
+  }
+  normalizeSelection() {
+    if (!this._selectionStart || !this._selectionEnd)
+      return null;
+    const start = this._selectionStart;
+    const end = this._selectionEnd;
+    const startBeforeEnd = start.line < end.line || start.line === end.line && start.col <= end.col;
+    if (startBeforeEnd) {
+      return {
+        startLine: start.line,
+        startCol: start.col,
+        endLine: end.line,
+        endCol: end.col
+      };
+    } else {
+      return {
+        startLine: end.line,
+        startCol: end.col,
+        endLine: start.line,
+        endCol: start.col
+      };
+    }
+  }
+  getSelectedText() {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return "";
+    const lines = [];
+    for (let i = selection2.startLine;i <= selection2.endLine; i++) {
+      if (i < 0 || i >= this._displayLines.length)
+        continue;
+      const line = this._displayLines[i];
+      const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+      const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+      const fullText = linePrefix + line.text.substring(0, textAvailableWidth);
+      let text = fullText;
+      if (i === selection2.startLine && i === selection2.endLine) {
+        text = fullText.substring(selection2.startCol, selection2.endCol);
+      } else if (i === selection2.startLine) {
+        text = fullText.substring(selection2.startCol);
+      } else if (i === selection2.endLine) {
+        text = fullText.substring(0, selection2.endCol);
+      }
+      lines.push(text);
+    }
+    return lines.join(`
+`);
+  }
+  clearSelection() {
+    this._selectionStart = null;
+    this._selectionEnd = null;
+    this._isSelecting = false;
+    this.stopAutoScroll();
+  }
+  stopAutoScroll() {
+    if (this._autoScrollInterval !== null) {
+      clearInterval(this._autoScrollInterval);
+      this._autoScrollInterval = null;
+    }
+  }
+  startAutoScroll(direction) {
+    this.stopAutoScroll();
+    this._autoScrollInterval = setInterval(() => {
+      if (direction === "up") {
+        if (this.scrollTopIndex > 0) {
+          this.scrollTopIndex--;
+          this.isScrolledToBottom = false;
+          if (this._selectionEnd) {
+            this._selectionEnd = {
+              line: this.scrollTopIndex,
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
+      } else {
+        const displayLineCount = this._displayLines.length;
+        const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+        const maxScrollTop = Math.max(0, displayLineCount - logAreaHeight);
+        if (this.scrollTopIndex < maxScrollTop) {
+          this.scrollTopIndex++;
+          this.isScrolledToBottom = this.scrollTopIndex === maxScrollTop;
+          if (this._selectionEnd) {
+            const maxLine = this.scrollTopIndex + logAreaHeight - 1;
+            this._selectionEnd = {
+              line: Math.min(maxLine, displayLineCount - 1),
+              col: this._selectionEnd.col
+            };
+          }
+          this.markNeedsRerender();
+        } else {
+          this.stopAutoScroll();
+        }
+      }
+    }, 50);
+  }
+  triggerCopy() {
+    if (!this.hasSelection())
+      return;
+    const text = this.getSelectedText();
+    if (text && this.options.onCopySelection) {
+      try {
+        this.options.onCopySelection(text);
+      } catch {}
+      this.clearSelection();
+      this.markNeedsRerender();
+    }
+  }
+  getLineSelectionRange(lineIndex) {
+    const selection2 = this.normalizeSelection();
+    if (!selection2)
+      return null;
+    if (lineIndex < selection2.startLine || lineIndex > selection2.endLine) {
+      return null;
+    }
+    const line = this._displayLines[lineIndex];
+    if (!line)
+      return null;
+    const linePrefix = line.indent ? " ".repeat(INDENT_WIDTH) : "";
+    const textAvailableWidth = this.consoleWidth - 1 - (line.indent ? INDENT_WIDTH : 0);
+    const fullTextLength = linePrefix.length + Math.min(line.text.length, textAvailableWidth);
+    let start = 0;
+    let end = fullTextLength;
+    if (lineIndex === selection2.startLine) {
+      start = Math.max(0, selection2.startCol);
+    }
+    if (lineIndex === selection2.endLine) {
+      end = Math.min(fullTextLength, selection2.endCol);
+    }
+    if (start >= end)
+      return null;
+    return { start, end };
+  }
+  handleMouse(event) {
+    if (!this.isVisible)
+      return false;
+    const localX = event.x - this.consoleX;
+    const localY = event.y - this.consoleY;
+    if (localX < 0 || localX >= this.consoleWidth || localY < 0 || localY >= this.consoleHeight) {
+      return false;
+    }
+    if (event.type === "scroll" && event.scroll) {
+      if (event.scroll.direction === "up") {
+        this.scrollUp();
+      } else if (event.scroll.direction === "down") {
+        this.scrollDown();
+      }
+      return true;
+    }
+    if (localY === 0) {
+      if (event.type === "down" && event.button === 0 && localX >= this._copyButtonBounds.x && localX < this._copyButtonBounds.x + this._copyButtonBounds.width) {
+        this.triggerCopy();
+        return true;
+      }
+      return true;
+    }
+    const lineIndex = this.scrollTopIndex + (localY - 1);
+    const colIndex = Math.max(0, localX - 1);
+    if (event.type === "down" && event.button === 0) {
+      this.clearSelection();
+      this._selectionStart = { line: lineIndex, col: colIndex };
+      this._selectionEnd = { line: lineIndex, col: colIndex };
+      this._isSelecting = true;
+      this.markNeedsRerender();
+      return true;
+    }
+    if (event.type === "drag" && this._isSelecting) {
+      this._selectionEnd = { line: lineIndex, col: colIndex };
+      const logAreaHeight = Math.max(1, this.consoleHeight - 1);
+      const relativeY = localY - 1;
+      if (relativeY <= 0) {
+        this.startAutoScroll("up");
+      } else if (relativeY >= logAreaHeight - 1) {
+        this.startAutoScroll("down");
+      } else {
+        this.stopAutoScroll();
+      }
+      this.markNeedsRerender();
+      return true;
+    }
+    if (event.type === "up") {
+      if (this._isSelecting) {
+        this._selectionEnd = { line: lineIndex, col: colIndex };
+        this._isSelecting = false;
+        this.stopAutoScroll();
+        this.markNeedsRerender();
+      }
+      return true;
+    }
+    return true;
+  }
+  get visible() {
+    return this.isVisible;
+  }
+  get bounds() {
+    return {
+      x: this.consoleX,
+      y: this.consoleY,
+      width: this.consoleWidth,
+      height: this.consoleHeight
+    };
+  }
   saveLogsToFile() {
     try {
       const timestamp = Date.now();
@@ -14759,6 +15278,7 @@ class CliRenderer extends EventEmitter9 {
   _stdinBuffer;
   animationRequest = new Map;
   resizeTimeoutId = null;
+  capabilityTimeoutId = null;
   resizeDebounceDelay = 100;
   enableMouseMovement = false;
   _useMouse = true;
@@ -15201,7 +15721,8 @@ Captured output:
     this._terminalIsSetup = true;
     this.lib.setupTerminal(this.rendererPtr, this._useAlternateScreen);
     this._capabilities = this.lib.getTerminalCapabilities(this.rendererPtr);
-    setTimeout(() => {
+    this.capabilityTimeoutId = setTimeout(() => {
+      this.capabilityTimeoutId = null;
       this.removeInputHandler(this.capabilityHandler);
     }, 5000);
     if (this._useMouse) {
@@ -15298,6 +15819,15 @@ Captured output:
       }
       this._latestPointer.x = mouseEvent.x;
       this._latestPointer.y = mouseEvent.y;
+      if (this._console.visible) {
+        const consoleBounds = this._console.bounds;
+        if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
+          const event2 = new MouseEvent(null, mouseEvent);
+          const handled = this._console.handleMouse(event2);
+          if (handled)
+            return true;
+        }
+      }
       if (mouseEvent.type === "scroll") {
         const maybeRenderableId2 = this.lib.checkHit(this.rendererPtr, mouseEvent.x, mouseEvent.y);
         const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
@@ -15669,7 +16199,17 @@ Captured output:
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
     process.removeListener("warning", this.warningHandler);
+    process.removeListener("beforeExit", this.exitHandler);
     capture.removeListener("write", this.captureCallback);
+    this.removeExitListeners();
+    if (this.resizeTimeoutId !== null) {
+      clearTimeout(this.resizeTimeoutId);
+      this.resizeTimeoutId = null;
+    }
+    if (this.capabilityTimeoutId !== null) {
+      clearTimeout(this.capabilityTimeoutId);
+      this.capabilityTimeoutId = null;
+    }
     if (this.memorySnapshotTimer) {
       clearInterval(this.memorySnapshotTimer);
     }
@@ -15982,7 +16522,7 @@ Captured output:
   }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, DebugOverlayCorner, createTextAttributes, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extToFiletype, pathToFiletype, main, getTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, ANSI, defaultKeyAliases, mergeKeyAliases, mergeKeyBindings, getKeyBindingKey, buildKeyBindingsMap, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, buildKittyKeyboardFlags, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=DF99D6EBE6E4045C64756E2164756E21
-//# sourceMappingURL=index-916mvx7m.js.map
+//# debugId=0788E633A0C8647564756E2164756E21
+//# sourceMappingURL=index-rysm4rsr.js.map