@opentui/core 0.1.35 → 0.1.37

package/{index-n8nbvvhk.js → index-7bav3fax.js}

@@ -5631,6 +5631,8 @@ import markdown_language from "./assets/markdown/tree-sitter-markdown.wasm" with
 import markdown_injections from "./assets/markdown/injections.scm" with { type: "file" };
 import markdown_inline_highlights from "./assets/markdown_inline/highlights.scm" with { type: "file" };
 import markdown_inline_language from "./assets/markdown_inline/tree-sitter-markdown_inline.wasm" with { type: "file" };
+import zig_highlights from "./assets/zig/highlights.scm" with { type: "file" };
+import zig_language from "./assets/zig/tree-sitter-zig.wasm" with { type: "file" };
 var _cachedParsers;
 function getParsers() {
   if (!_cachedParsers) {
@@ -5677,6 +5679,13 @@ function getParsers() {
           highlights: [resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_highlights)]
         },
         wasm: resolve(dirname(fileURLToPath(import.meta.url)), markdown_inline_language)
+      },
+      {
+        filetype: "zig",
+        queries: {
+          highlights: [resolve(dirname(fileURLToPath(import.meta.url)), zig_highlights)]
+        },
+        wasm: resolve(dirname(fileURLToPath(import.meta.url)), zig_language)
       }
     ];
   }
@@ -7341,6 +7350,271 @@ class ExtmarksController {
 function createExtmarksController(editBuffer, editorView) {
   return new ExtmarksController(editBuffer, editorView);
 }
+
+// src/lib/terminal-palette.ts
+var OSC4_RESPONSE = /\x1b]4;(\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
+var OSC_SPECIAL_RESPONSE = /\x1b](\d+);(?:(?:rgb:)([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)|#([0-9a-fA-F]{6}))(?:\x07|\x1b\\)/g;
+function scaleComponent(comp) {
+  const val = parseInt(comp, 16);
+  const maxIn = (1 << 4 * comp.length) - 1;
+  return Math.round(val / maxIn * 255).toString(16).padStart(2, "0");
+}
+function toHex(r, g, b, hex6) {
+  if (hex6)
+    return `#${hex6.toLowerCase()}`;
+  if (r && g && b)
+    return `#${scaleComponent(r)}${scaleComponent(g)}${scaleComponent(b)}`;
+  return "#000000";
+}
+
+class TerminalPalette {
+  stdin;
+  stdout;
+  writeFn;
+  activeListeners = [];
+  activeTimers = [];
+  constructor(stdin, stdout, writeFn) {
+    this.stdin = stdin;
+    this.stdout = stdout;
+    this.writeFn = writeFn || ((data) => stdout.write(data));
+  }
+  cleanup() {
+    for (const { event, handler } of this.activeListeners) {
+      this.stdin.removeListener(event, handler);
+    }
+    this.activeListeners = [];
+    for (const timer of this.activeTimers) {
+      clearTimeout(timer);
+    }
+    this.activeTimers = [];
+  }
+  async detectOSCSupport(timeoutMs = 300) {
+    const out = this.stdout;
+    const inp = this.stdin;
+    if (!out.isTTY || !inp.isTTY)
+      return false;
+    return new Promise((resolve4) => {
+      let buffer = "";
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        OSC4_RESPONSE.lastIndex = 0;
+        if (OSC4_RESPONSE.test(buffer)) {
+          cleanup();
+          resolve4(true);
+        }
+      };
+      const onTimeout = () => {
+        cleanup();
+        resolve4(false);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        inp.removeListener("data", onData);
+        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
+        if (listenerIdx !== -1)
+          this.activeListeners.splice(listenerIdx, 1);
+        const timerIdx = this.activeTimers.indexOf(timer);
+        if (timerIdx !== -1)
+          this.activeTimers.splice(timerIdx, 1);
+      };
+      const timer = setTimeout(onTimeout, timeoutMs);
+      this.activeTimers.push(timer);
+      inp.on("data", onData);
+      this.activeListeners.push({ event: "data", handler: onData });
+      this.writeFn("\x1B]4;0;?\x07");
+    });
+  }
+  async queryPalette(indices, timeoutMs = 1200) {
+    const out = this.stdout;
+    const inp = this.stdin;
+    const results = new Map;
+    indices.forEach((i) => results.set(i, null));
+    if (!out.isTTY || !inp.isTTY) {
+      return results;
+    }
+    return new Promise((resolve4) => {
+      let buffer = "";
+      let lastResponseTime = Date.now();
+      let idleTimer = null;
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        lastResponseTime = Date.now();
+        let m;
+        OSC4_RESPONSE.lastIndex = 0;
+        while (m = OSC4_RESPONSE.exec(buffer)) {
+          const idx = parseInt(m[1], 10);
+          if (results.has(idx))
+            results.set(idx, toHex(m[2], m[3], m[4], m[5]));
+        }
+        if (buffer.length > 8192)
+          buffer = buffer.slice(-4096);
+        const done = [...results.values()].filter((v) => v !== null).length;
+        if (done === results.size) {
+          cleanup();
+          resolve4(results);
+          return;
+        }
+        if (idleTimer)
+          clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          cleanup();
+          resolve4(results);
+        }, 150);
+        if (idleTimer)
+          this.activeTimers.push(idleTimer);
+      };
+      const onTimeout = () => {
+        cleanup();
+        resolve4(results);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (idleTimer)
+          clearTimeout(idleTimer);
+        inp.removeListener("data", onData);
+        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
+        if (listenerIdx !== -1)
+          this.activeListeners.splice(listenerIdx, 1);
+        const timerIdx = this.activeTimers.indexOf(timer);
+        if (timerIdx !== -1)
+          this.activeTimers.splice(timerIdx, 1);
+        if (idleTimer) {
+          const idleTimerIdx = this.activeTimers.indexOf(idleTimer);
+          if (idleTimerIdx !== -1)
+            this.activeTimers.splice(idleTimerIdx, 1);
+        }
+      };
+      const timer = setTimeout(onTimeout, timeoutMs);
+      this.activeTimers.push(timer);
+      inp.on("data", onData);
+      this.activeListeners.push({ event: "data", handler: onData });
+      this.writeFn(indices.map((i) => `\x1B]4;${i};?\x07`).join(""));
+    });
+  }
+  async querySpecialColors(timeoutMs = 1200) {
+    const out = this.stdout;
+    const inp = this.stdin;
+    const results = {
+      10: null,
+      11: null,
+      12: null,
+      13: null,
+      14: null,
+      15: null,
+      16: null,
+      17: null,
+      19: null
+    };
+    if (!out.isTTY || !inp.isTTY) {
+      return results;
+    }
+    return new Promise((resolve4) => {
+      let buffer = "";
+      let idleTimer = null;
+      const onData = (chunk) => {
+        buffer += chunk.toString();
+        let m;
+        OSC_SPECIAL_RESPONSE.lastIndex = 0;
+        while (m = OSC_SPECIAL_RESPONSE.exec(buffer)) {
+          const idx = parseInt(m[1], 10);
+          if (idx in results) {
+            results[idx] = toHex(m[2], m[3], m[4], m[5]);
+          }
+        }
+        if (buffer.length > 8192)
+          buffer = buffer.slice(-4096);
+        const done = Object.values(results).filter((v) => v !== null).length;
+        if (done === Object.keys(results).length) {
+          cleanup();
+          resolve4(results);
+          return;
+        }
+        if (idleTimer)
+          clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          cleanup();
+          resolve4(results);
+        }, 150);
+        if (idleTimer)
+          this.activeTimers.push(idleTimer);
+      };
+      const onTimeout = () => {
+        cleanup();
+        resolve4(results);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (idleTimer)
+          clearTimeout(idleTimer);
+        inp.removeListener("data", onData);
+        const listenerIdx = this.activeListeners.findIndex((l) => l.handler === onData);
+        if (listenerIdx !== -1)
+          this.activeListeners.splice(listenerIdx, 1);
+        const timerIdx = this.activeTimers.indexOf(timer);
+        if (timerIdx !== -1)
+          this.activeTimers.splice(timerIdx, 1);
+        if (idleTimer) {
+          const idleTimerIdx = this.activeTimers.indexOf(idleTimer);
+          if (idleTimerIdx !== -1)
+            this.activeTimers.splice(idleTimerIdx, 1);
+        }
+      };
+      const timer = setTimeout(onTimeout, timeoutMs);
+      this.activeTimers.push(timer);
+      inp.on("data", onData);
+      this.activeListeners.push({ event: "data", handler: onData });
+      this.writeFn([
+        "\x1B]10;?\x07",
+        "\x1B]11;?\x07",
+        "\x1B]12;?\x07",
+        "\x1B]13;?\x07",
+        "\x1B]14;?\x07",
+        "\x1B]15;?\x07",
+        "\x1B]16;?\x07",
+        "\x1B]17;?\x07",
+        "\x1B]19;?\x07"
+      ].join(""));
+    });
+  }
+  async detect(options) {
+    const { timeout = 5000, size = 16 } = options || {};
+    const supported = await this.detectOSCSupport();
+    if (!supported) {
+      return {
+        palette: Array(size).fill(null),
+        defaultForeground: null,
+        defaultBackground: null,
+        cursorColor: null,
+        mouseForeground: null,
+        mouseBackground: null,
+        tekForeground: null,
+        tekBackground: null,
+        highlightBackground: null,
+        highlightForeground: null
+      };
+    }
+    const indicesToQuery = [...Array(size).keys()];
+    const [paletteResults, specialColors] = await Promise.all([
+      this.queryPalette(indicesToQuery, timeout),
+      this.querySpecialColors(timeout)
+    ]);
+    return {
+      palette: [...Array(size).keys()].map((i) => paletteResults.get(i) ?? null),
+      defaultForeground: specialColors[10],
+      defaultBackground: specialColors[11],
+      cursorColor: specialColors[12],
+      mouseForeground: specialColors[13],
+      mouseBackground: specialColors[14],
+      tekForeground: specialColors[15],
+      tekBackground: specialColors[16],
+      highlightBackground: specialColors[17],
+      highlightForeground: specialColors[19]
+    };
+  }
+}
+function createTerminalPalette(stdin, stdout, writeFn) {
+  return new TerminalPalette(stdin, stdout, writeFn);
+}
 // src/zig.ts
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr3 } from "bun:ffi";
 import { existsSync as existsSync2 } from "fs";
@@ -10429,7 +10703,6 @@ class Renderable extends BaseRenderable {
   parent = null;
   childrenPrimarySortDirty = true;
   childrenSortedByPrimaryAxis = [];
-  _newChildren = [];
   onLifecyclePass = null;
   renderBefore;
   renderAfter;
@@ -11087,7 +11360,6 @@ class Renderable extends BaseRenderable {
     }
     obj.parent = this;
   }
-  _forceLayoutUpdateFor = null;
   add(obj, index) {
     if (!obj) {
       return -1;
@@ -11121,7 +11393,6 @@ class Renderable extends BaseRenderable {
         this.propagateLiveCount(renderable._liveCount);
       }
     }
-    this._newChildren.push(renderable);
     const childLayoutNode = renderable.getLayoutNode();
     const insertedIndex = this._childrenInLayoutOrder.length;
     this._childrenInLayoutOrder.push(renderable);
@@ -11174,11 +11445,9 @@ class Renderable extends BaseRenderable {
         this.propagateLiveCount(renderable._liveCount);
       }
     }
-    this._newChildren.push(renderable);
     this.childrenPrimarySortDirty = true;
     const anchorIndex = this._childrenInLayoutOrder.indexOf(anchor);
     const insertedIndex = Math.max(0, Math.min(anchorIndex, this._childrenInLayoutOrder.length));
-    this._forceLayoutUpdateFor = this._childrenInLayoutOrder.slice(insertedIndex);
     this._childrenInLayoutOrder.splice(insertedIndex, 0, renderable);
     this.yogaNode.insertChild(renderable.getLayoutNode(), insertedIndex);
     this.requestRender();
@@ -11212,16 +11481,6 @@ class Renderable extends BaseRenderable {
         if (zIndexIndex !== -1) {
           this._childrenInZIndexOrder.splice(zIndexIndex, 1);
         }
-        if (this._forceLayoutUpdateFor) {
-          const forceIndex = this._forceLayoutUpdateFor.findIndex((obj2) => obj2.id === id);
-          if (forceIndex !== -1) {
-            this._forceLayoutUpdateFor?.splice(forceIndex, 1);
-          }
-        }
-        const newChildIndex = this._newChildren.findIndex((obj2) => obj2.id === id);
-        if (newChildIndex !== -1) {
-          this._newChildren?.splice(newChildIndex, 1);
-        }
         this.childrenPrimarySortDirty = true;
       }
     }
@@ -11239,18 +11498,6 @@ class Renderable extends BaseRenderable {
     this.onUpdate(deltaTime);
     this.updateFromLayout();
     renderList.push({ action: "render", renderable: this });
-    if (this._newChildren.length > 0) {
-      for (const child of this._newChildren) {
-        child.updateFromLayout();
-      }
-      this._newChildren = [];
-    }
-    if (this._forceLayoutUpdateFor) {
-      for (const child of this._forceLayoutUpdateFor) {
-        child.updateFromLayout();
-      }
-      this._forceLayoutUpdateFor = null;
-    }
     this.ensureZIndexSorted();
     const shouldPushScissor = this._overflow !== "visible" && this.width > 0 && this.height > 0;
     if (shouldPushScissor) {
@@ -11263,7 +11510,12 @@ class Renderable extends BaseRenderable {
         height: scissorRect.height
       });
     }
-    for (const child of this._getChildren()) {
+    const visibleChildren = this._getVisibleChildren();
+    for (const child of this._childrenInZIndexOrder) {
+      if (!visibleChildren.includes(child.num)) {
+        child.updateFromLayout();
+        continue;
+      }
       child.updateLayout(deltaTime, renderList);
     }
     if (shouldPushScissor) {
@@ -11288,8 +11540,8 @@ class Renderable extends BaseRenderable {
       buffer.drawFrameBuffer(this.x, this.y, this.frameBuffer);
     }
   }
-  _getChildren() {
-    return this._childrenInZIndexOrder;
+  _getVisibleChildren() {
+    return this._childrenInZIndexOrder.map((child) => child.num);
   }
   onUpdate(deltaTime) {}
   getScissorRect() {
@@ -11886,7 +12138,7 @@ class TerminalConsole extends EventEmitter8 {
   isVisible = false;
   isFocused = false;
   renderer;
-  stdinHandler;
+  keyHandler;
   options;
   _debugModeEnabled = false;
   frameBuffer = null;
@@ -11924,7 +12176,7 @@ class TerminalConsole extends EventEmitter8 {
     super();
     this.renderer = renderer;
     this.options = { ...DEFAULT_CONSOLE_OPTIONS, ...options };
-    this.stdinHandler = this.handleStdin.bind(this);
+    this.keyHandler = this.handleKeyPress.bind(this);
     this._debugModeEnabled = this.options.startInDebugMode;
     terminalConsoleCache.setCollectCallerInfo(this._debugModeEnabled);
     this._rgbaInfo = parseColor(this.options.colorInfo);
@@ -12003,75 +12255,65 @@ class TerminalConsole extends EventEmitter8 {
     }
     this.currentLineIndex = Math.max(0, Math.min(this.currentLineIndex, this.consoleHeight - 1));
   }
-  handleStdin(data) {
-    const key = data.toString();
+  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);
-    switch (key) {
-      case "\x1B":
-        this.blur();
-        break;
-      case "\x1B[1;2A":
-        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;
-        }
-        break;
-      case "\x1B[1;2B":
-        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;
-        }
-        break;
-      case "\x1B[A":
-        if (this.currentLineIndex > 0) {
-          this.currentLineIndex--;
-          needsRedraw = true;
-        } else if (this.scrollTopIndex > 0) {
-          this.scrollTopIndex--;
-          this.isScrolledToBottom = false;
-          needsRedraw = true;
-        }
-        break;
-      case "\x1B[B":
-        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;
-        }
-        break;
-      case "\x10":
-        const prevIndex = (currentPositionIndex - 1 + this._positions.length) % this._positions.length;
-        this.options.position = this._positions[prevIndex];
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "\x0F":
-        const nextIndex = (currentPositionIndex + 1) % this._positions.length;
-        this.options.position = this._positions[nextIndex];
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "+":
-        this.options.sizePercent = Math.min(100, this.options.sizePercent + 5);
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "-":
-        this.options.sizePercent = Math.max(10, this.options.sizePercent - 5);
-        this.resize(this.renderer.terminalWidth, this.renderer.terminalHeight);
-        break;
-      case "\x13":
-        this.saveLogsToFile();
-        break;
+    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) {
       this.markNeedsRerender();
@@ -12080,13 +12322,13 @@ class TerminalConsole extends EventEmitter8 {
   attachStdin() {
     if (this.isFocused)
       return;
-    process.stdin.on("data", this.stdinHandler);
+    this.renderer.keyInput.on("keypress", this.keyHandler);
     this.isFocused = true;
   }
   detachStdin() {
     if (!this.isFocused)
       return;
-    process.stdin.off("data", this.stdinHandler);
+    this.renderer.keyInput.off("keypress", this.keyHandler);
     this.isFocused = false;
   }
   formatTimestamp(date) {
@@ -12662,6 +12904,9 @@ class CliRenderer extends EventEmitter9 {
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
+  _paletteDetector = null;
+  _cachedPalette = null;
+  _paletteDetectionPromise = null;
   handleError = ((error) => {
     console.error(error);
     if (this._openConsoleOnError) {
@@ -13409,6 +13654,12 @@ Captured output:
     if (this.memorySnapshotTimer) {
       clearInterval(this.memorySnapshotTimer);
     }
+    if (this._paletteDetector) {
+      this._paletteDetector.cleanup();
+      this._paletteDetector = null;
+    }
+    this._paletteDetectionPromise = null;
+    this._cachedPalette = null;
     if (this._isDestroyed)
       return;
     this._isDestroyed = true;
@@ -13661,9 +13912,43 @@ Captured output:
       }
     }
   }
+  get paletteDetectionStatus() {
+    if (this._cachedPalette)
+      return "cached";
+    if (this._paletteDetectionPromise)
+      return "detecting";
+    return "idle";
+  }
+  clearPaletteCache() {
+    this._cachedPalette = null;
+  }
+  async getPalette(options) {
+    if (this._controlState === "explicit_suspended" /* EXPLICIT_SUSPENDED */) {
+      throw new Error("Cannot detect palette while renderer is suspended");
+    }
+    const requestedSize = options?.size ?? 16;
+    if (this._cachedPalette && this._cachedPalette.palette.length !== requestedSize) {
+      this._cachedPalette = null;
+    }
+    if (this._cachedPalette) {
+      return this._cachedPalette;
+    }
+    if (this._paletteDetectionPromise) {
+      return this._paletteDetectionPromise;
+    }
+    if (!this._paletteDetector) {
+      this._paletteDetector = createTerminalPalette(this.stdin, this.stdout, this.writeOut.bind(this));
+    }
+    this._paletteDetectionPromise = this._paletteDetector.detect(options).then((result) => {
+      this._cachedPalette = result;
+      this._paletteDetectionPromise = null;
+      return result;
+    });
+    return this._paletteDetectionPromise;
+  }
 }
 
-export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, StdinBuffer, 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, 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, TextBuffer, LogLevel2 as LogLevel, setRenderLibPath, resolveRenderLib, OptimizedBuffer, h, isVNode, maybeMakeRenderable, wrapWithDelegates, instantiate, delegate, isValidPercentage, LayoutEvents, RenderableEvents, isRenderable, BaseRenderable, Renderable, RootRenderable, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
+export { __toESM, __commonJS, __export, __require, Edge, Gutter, exports_src, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, ANSI, StdinBuffer, 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, 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, capture, ConsolePosition, TerminalConsole, getObjectsInViewport, MouseEvent, MouseButton, createCliRenderer, CliRenderEvents, RendererControlState, CliRenderer };
 
-//# debugId=A88F8272C607FC3964756E2164756E21
-//# sourceMappingURL=index-n8nbvvhk.js.map
+//# debugId=ADDED20480B66A0A64756E2164756E21
+//# sourceMappingURL=index-7bav3fax.js.map