@cascadetui/core 0.1.5 → 0.1.6

package/Renderable.d.ts

@@ -173,6 +173,9 @@ export declare abstract class Renderable extends BaseRenderable {
     onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
     shouldStartSelection(x: number, y: number): boolean;
+    selectWord(_x: number, _y: number): boolean;
+    selectLine(_x: number, _y: number): boolean;
+    updateSelectionWordSnap(_x: number, _y: number): boolean;
     focus(): void;
     blur(): void;
     get focused(): boolean;
@@ -254,6 +257,7 @@ export declare abstract class Renderable extends BaseRenderable {
      */
     protected onResize(width: number, height: number): void;
     private replaceParent;
+    private assertCanAdoptChild;
     add(obj: Renderable | VNode<any, any[]> | unknown, index?: number): number;
     insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number;
     getRenderable(id: string): Renderable | undefined;

package/{index-jx194wn1.js → index-rj3f00a6.js}

@@ -6112,15 +6112,16 @@ class StdinBuffer extends EventEmitter2 {
       this.timeout = null;
     }
     let str;
-    if (Buffer.isBuffer(data)) {
-      if (data.length === 1 && data[0] > 127) {
-        const byte = data[0] - 128;
+    if (typeof data === "string") {
+      str = data;
+    } else {
+      const chunk = this.toBuffer(data);
+      if (chunk.length === 1 && chunk[0] > 127) {
+        const byte = chunk[0] - 128;
         str = "\x1B" + String.fromCharCode(byte);
       } else {
-        str = data.toString();
+        str = chunk.toString();
       }
-    } else {
-      str = data;
     }
     if (str.length === 0 && this.buffer.length === 0) {
       this.emit("data", "");
@@ -6210,6 +6211,15 @@ class StdinBuffer extends EventEmitter2 {
   destroy() {
     this.clear();
   }
+  toBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
 }
 
 // src/lib/yoga.options.ts
@@ -6515,7 +6525,16 @@ class MouseParser {
     this.mouseButtonsPressed.clear();
   }
   decodeInput(data) {
-    return data.toString();
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data.toString();
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString();
+    }
+    return Buffer.from(data).toString();
   }
   parseMouseEvent(data) {
     const str = this.decodeInput(data);
@@ -13449,6 +13468,15 @@ class Renderable extends BaseRenderable {
   shouldStartSelection(x, y) {
     return false;
   }
+  selectWord(_x, _y) {
+    return false;
+  }
+  selectLine(_x, _y) {
+    return false;
+  }
+  updateSelectionWordSnap(_x, _y) {
+    return false;
+  }
   focus() {
     if (this._isDestroyed || this._focused || !this._focusable)
       return;
@@ -13517,13 +13545,23 @@ class Renderable extends BaseRenderable {
     this.parent?.propagateLiveCount(delta);
   }
   findDescendantById(id) {
-    for (const child of this._childrenInLayoutOrder) {
-      if (child.id === id)
-        return child;
-      if (isRenderable(child)) {
-        const found = child.findDescendantById(id);
-        if (found)
-          return found;
+    const visited = new Set;
+    const stack = [...this._childrenInLayoutOrder];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (visited.has(current)) {
+        continue;
+      }
+      visited.add(current);
+      if (current.id === id) {
+        return current;
+      }
+      const children = current.getChildren();
+      for (let i = children.length - 1;i >= 0; i -= 1) {
+        const child = children[i];
+        if (isRenderable(child)) {
+          stack.push(child);
+        }
       }
     }
     return;
@@ -14046,6 +14084,23 @@ class Renderable extends BaseRenderable {
     }
     obj.parent = this;
   }
+  assertCanAdoptChild(renderable) {
+    if (renderable === this) {
+      throw new Error(`Invalid render tree operation: '${this.id}' cannot contain itself`);
+    }
+    let current = this;
+    const visited = new Set;
+    while (current) {
+      if (visited.has(current)) {
+        throw new Error(`Invalid render tree operation: parent chain cycle detected near '${current.id}'`);
+      }
+      visited.add(current);
+      if (current === renderable) {
+        throw new Error(`Invalid render tree operation: adding '${renderable.id}' to '${this.id}' would create a cycle`);
+      }
+      current = current.parent;
+    }
+  }
   add(obj, index) {
     if (!obj) {
       return -1;
@@ -14060,6 +14115,7 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
+    this.assertCanAdoptChild(renderable);
     const anchorRenderable = index !== undefined ? this._childrenInLayoutOrder[index] : undefined;
     if (anchorRenderable) {
       return this.insertBefore(renderable, anchorRenderable);
@@ -14105,6 +14161,7 @@ class Renderable extends BaseRenderable {
       }
       return -1;
     }
+    this.assertCanAdoptChild(renderable);
     if (!isRenderable(anchor)) {
       throw new Error("Anchor must be a Renderable");
     }
@@ -14308,6 +14365,9 @@ class Renderable extends BaseRenderable {
   }
   destroySelf() {}
   processMouseEvent(event) {
+    if (!event.tryVisit(this)) {
+      return;
+    }
     this._mouseListener?.call(this, event);
     this._mouseListeners[event.type]?.call(this, event);
     this.onMouseEvent(event);
@@ -16024,6 +16084,12 @@ registerEnvVar({
   type: "boolean",
   default: false
 });
+registerEnvVar({
+  name: "CASCADE_LOG_CRASH_REPORTS",
+  description: "Log detailed crash reports to the console when a crash is captured.",
+  type: "boolean",
+  default: false
+});
 var DEFAULT_FORWARDED_ENV_KEYS = [
   "TMUX",
   "TERM",
@@ -16080,8 +16146,10 @@ class MouseEvent {
   scroll;
   target;
   isDragging;
+  clickCount;
   _propagationStopped = false;
   _defaultPrevented = false;
+  _visitedRenderableNums = new Set;
   get propagationStopped() {
     return this._propagationStopped;
   }
@@ -16098,6 +16166,7 @@ class MouseEvent {
     this.scroll = attributes.scroll;
     this.source = attributes.source;
     this.isDragging = attributes.isDragging;
+    this.clickCount = attributes.clickCount ?? 1;
   }
   stopPropagation() {
     this._propagationStopped = true;
@@ -16105,6 +16174,13 @@ class MouseEvent {
   preventDefault() {
     this._defaultPrevented = true;
   }
+  tryVisit(renderable) {
+    if (this._visitedRenderableNums.has(renderable.num)) {
+      return false;
+    }
+    this._visitedRenderableNums.add(renderable.num);
+    return true;
+  }
 }
 var MouseButton;
 ((MouseButton2) => {
@@ -16169,6 +16245,7 @@ var CliRenderEvents;
 ((CliRenderEvents2) => {
   CliRenderEvents2["DEBUG_OVERLAY_TOGGLE"] = "debugOverlay:toggle";
   CliRenderEvents2["DESTROY"] = "destroy";
+  CliRenderEvents2["CRASH"] = "crash";
 })(CliRenderEvents ||= {});
 var RendererControlState;
 ((RendererControlState2) => {
@@ -16282,9 +16359,12 @@ class CliRenderer extends EventEmitter9 {
   _hasPointer = false;
   _lastPointerModifiers = { shift: false, alt: false, ctrl: false };
   _currentMousePointerStyle = undefined;
+  _lastClick = null;
+  clickCountThresholdMs = 400;
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
+  _logCrashReportsToConsole = env.CASCADE_LOG_CRASH_REPORTS;
   _paletteDetector = null;
   _cachedPalette = null;
   _paletteDetectionPromise = null;
@@ -16295,11 +16375,23 @@ class CliRenderer extends EventEmitter9 {
   idleResolvers = [];
   _debugInputs = [];
   _debugModeEnabled = env.CASCADE_DEBUG;
-  handleError = ((error) => {
-    console.error(error);
+  recentRuntimeEvents = [];
+  crashReports = [];
+  maxRecentRuntimeEvents = 200;
+  maxCrashReports = 20;
+  handleProcessCrash = (reason, source) => {
+    const report = this.reportCrash(reason, source);
+    console.error(reason);
     if (this._openConsoleOnError) {
       this.console.show();
+      console.log(`[crash:${report.source}] ${report.message}`);
     }
+  };
+  uncaughtExceptionHandler = ((error) => {
+    this.handleProcessCrash(error, "uncaughtException");
+  }).bind(this);
+  unhandledRejectionHandler = ((reason) => {
+    this.handleProcessCrash(reason, "unhandledRejection");
   }).bind(this);
   dumpOutputCache(optionalMessage = "") {
     const cachedLogs = this.console.getCachedLogs();
@@ -16401,8 +16493,8 @@ Captured output:
     }
     process.on("SIGWINCH", this.sigwinchHandler);
     process.on("warning", this.warningHandler);
-    process.on("uncaughtException", this.handleError);
-    process.on("unhandledRejection", this.handleError);
+    process.on("uncaughtException", this.uncaughtExceptionHandler);
+    process.on("unhandledRejection", this.unhandledRejectionHandler);
     process.on("beforeExit", this.exitHandler);
     const kittyConfig = config.useKittyKeyboard ?? {};
     const useKittyForParsing = kittyConfig !== null;
@@ -16432,6 +16524,7 @@ Captured output:
     this._console = new TerminalConsole(this, consoleOptions);
     this.useConsole = config.useConsole ?? true;
     this._openConsoleOnError = config.openConsoleOnError ?? true;
+    this._logCrashReportsToConsole = config.logCrashReportsToConsole ?? env.CASCADE_LOG_CRASH_REPORTS;
     this._onDestroy = config.onDestroy;
     global.requestAnimationFrame = (callback) => {
       const id = CliRenderer.animationFrameId++;
@@ -16773,10 +16866,11 @@ Captured output:
     this.queryPixelResolution();
   }
   stdinListener = ((data) => {
-    if (this._useMouse && this.handleMouseData(data)) {
+    const chunk = this.normalizeInputChunk(data);
+    if (this._useMouse && this.handleMouseData(chunk)) {
       return;
     }
-    this._stdinBuffer.process(data);
+    this._stdinBuffer.process(chunk);
   }).bind(this);
   addInputHandler(handler) {
     this.inputHandlers.push(handler);
@@ -16853,6 +16947,10 @@ Captured output:
     this.stdin.setEncoding("utf8");
     this.stdin.on("data", this.stdinListener);
     this._stdinBuffer.on("data", (sequence) => {
+      this.recordRuntimeEvent("input:data", {
+        sequence: sequence.length > 120 ? `${sequence.slice(0, 120)}...` : sequence,
+        length: sequence.length
+      });
       if (this._debugModeEnabled) {
         this._debugInputs.push({
           timestamp: new Date().toISOString(),
@@ -16866,6 +16964,9 @@ Captured output:
       }
     });
     this._stdinBuffer.on("paste", (data) => {
+      this.recordRuntimeEvent("input:paste", {
+        length: data.length
+      });
       this._keyHandler.processPaste(data);
     });
   }
@@ -16874,7 +16975,12 @@ Captured output:
     target.processMouseEvent(event);
     if (this.autoFocus && event.type === "down" && event.button === 0 /* LEFT */ && !event.defaultPrevented) {
       let current = target;
+      const visited = new Set;
       while (current) {
+        if (visited.has(current)) {
+          break;
+        }
+        visited.add(current);
         if (current.focusable) {
           current.focus();
           break;
@@ -16903,6 +17009,18 @@ Captured output:
       }
       mouseEvent.y -= this.renderOffset;
     }
+    const clickCount = this.resolveClickCount(mouseEvent);
+    const mouseEventWithClickCount = { ...mouseEvent, clickCount };
+    this.recordRuntimeEvent("input:mouse", {
+      type: mouseEvent.type,
+      x: mouseEvent.x,
+      y: mouseEvent.y,
+      button: mouseEvent.button,
+      clickCount,
+      ctrl: mouseEvent.modifiers.ctrl,
+      alt: mouseEvent.modifiers.alt,
+      shift: mouseEvent.modifiers.shift
+    });
     this._latestPointer.x = mouseEvent.x;
     this._latestPointer.y = mouseEvent.y;
     this._hasPointer = true;
@@ -16910,7 +17028,7 @@ Captured output:
     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 event2 = new MouseEvent(null, mouseEventWithClickCount);
         const handled = this._console.handleMouse(event2);
         if (handled)
           return true;
@@ -16922,7 +17040,7 @@ Captured output:
       const fallbackTarget = this._currentFocusedRenderable && !this._currentFocusedRenderable.isDestroyed && this._currentFocusedRenderable.focused ? this._currentFocusedRenderable : null;
       const scrollTarget = maybeRenderable2 ?? fallbackTarget;
       if (scrollTarget) {
-        const event2 = new MouseEvent(scrollTarget, mouseEvent);
+        const event2 = new MouseEvent(scrollTarget, mouseEventWithClickCount);
         scrollTarget.processMouseEvent(event2);
       }
       return true;
@@ -16935,21 +17053,21 @@ Captured output:
       const canStartSelection = Boolean(maybeRenderable && maybeRenderable.selectable && !maybeRenderable.isDestroyed && maybeRenderable.shouldStartSelection(mouseEvent.x, mouseEvent.y));
       if (canStartSelection && maybeRenderable) {
         this.startSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
-        this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+        this.dispatchMouseEvent(maybeRenderable, mouseEventWithClickCount);
         return true;
       }
     }
     if (mouseEvent.type === "drag" && this.currentSelection?.isDragging) {
       this.updateSelection(maybeRenderable, mouseEvent.x, mouseEvent.y);
       if (maybeRenderable) {
-        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEventWithClickCount, isDragging: true });
         maybeRenderable.processMouseEvent(event2);
       }
       return true;
     }
     if (mouseEvent.type === "up" && this.currentSelection?.isDragging) {
       if (maybeRenderable) {
-        const event2 = new MouseEvent(maybeRenderable, { ...mouseEvent, isDragging: true });
+        const event2 = new MouseEvent(maybeRenderable, { ...mouseEventWithClickCount, isDragging: true });
         maybeRenderable.processMouseEvent(event2);
       }
       this.finishSelection();
@@ -16964,13 +17082,13 @@ Captured output:
     }
     if (!sameElement && (mouseEvent.type === "drag" || mouseEvent.type === "move")) {
       if (this.lastOverRenderable && this.lastOverRenderable !== this.capturedRenderable) {
-        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEvent, type: "out" });
+        const event2 = new MouseEvent(this.lastOverRenderable, { ...mouseEventWithClickCount, type: "out" });
         this.lastOverRenderable.processMouseEvent(event2);
       }
       this.lastOverRenderable = maybeRenderable;
       if (maybeRenderable) {
         const event2 = new MouseEvent(maybeRenderable, {
-          ...mouseEvent,
+          ...mouseEventWithClickCount,
           type: "over",
           source: this.capturedRenderable
         });
@@ -16978,17 +17096,17 @@ Captured output:
       }
     }
     if (this.capturedRenderable && mouseEvent.type !== "up") {
-      const event2 = new MouseEvent(this.capturedRenderable, mouseEvent);
+      const event2 = new MouseEvent(this.capturedRenderable, mouseEventWithClickCount);
       this.capturedRenderable.processMouseEvent(event2);
       return true;
     }
     if (this.capturedRenderable && mouseEvent.type === "up") {
-      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
+      const event2 = new MouseEvent(this.capturedRenderable, { ...mouseEventWithClickCount, type: "drag-end" });
       this.capturedRenderable.processMouseEvent(event2);
-      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
+      this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEventWithClickCount));
       if (maybeRenderable) {
         const event3 = new MouseEvent(maybeRenderable, {
-          ...mouseEvent,
+          ...mouseEventWithClickCount,
           type: "drop",
           source: this.capturedRenderable
         });
@@ -17006,7 +17124,7 @@ Captured output:
       } else {
         this.setCapturedRenderable(undefined);
       }
-      event = this.dispatchMouseEvent(maybeRenderable, mouseEvent);
+      event = this.dispatchMouseEvent(maybeRenderable, mouseEventWithClickCount);
     } else {
       this.setCapturedRenderable(undefined);
       this.lastOverRenderable = undefined;
@@ -17176,6 +17294,115 @@ Captured output:
   copyToClipboardOSC52(text, target) {
     return this.clipboard.copyToClipboardOSC52(text, target);
   }
+  normalizeInputChunk(data) {
+    if (typeof data === "string") {
+      return data;
+    }
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (data instanceof Uint8Array) {
+      return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+  }
+  resolveClickCount(mouseEvent) {
+    if (mouseEvent.type !== "down" || mouseEvent.button > 2 /* RIGHT */) {
+      return 1;
+    }
+    const now = Date.now();
+    const previous = this._lastClick;
+    const isConsecutive = previous && previous.button === mouseEvent.button && previous.x === mouseEvent.x && previous.y === mouseEvent.y && now - previous.timestamp <= this.clickCountThresholdMs;
+    const count = isConsecutive ? previous.count + 1 : 1;
+    this._lastClick = {
+      x: mouseEvent.x,
+      y: mouseEvent.y,
+      button: mouseEvent.button,
+      timestamp: now,
+      count
+    };
+    return count;
+  }
+  normalizeCrashError(reason) {
+    if (reason instanceof Error) {
+      return {
+        message: reason.message || reason.name || "Unknown error",
+        stack: reason.stack
+      };
+    }
+    if (typeof reason === "string") {
+      return { message: reason };
+    }
+    try {
+      return { message: JSON.stringify(reason) };
+    } catch {
+      return { message: String(reason) };
+    }
+  }
+  recordRuntimeEvent(type, payload) {
+    this.recentRuntimeEvents.push({
+      timestamp: new Date().toISOString(),
+      type,
+      payload
+    });
+    if (this.recentRuntimeEvents.length > this.maxRecentRuntimeEvents) {
+      this.recentRuntimeEvents.shift();
+    }
+  }
+  reportCrash(reason, source = "manual", extra) {
+    const error = this.normalizeCrashError(reason);
+    const report = {
+      timestamp: new Date().toISOString(),
+      source,
+      message: error.message,
+      stack: error.stack,
+      recentEvents: [...this.recentRuntimeEvents]
+    };
+    if (extra && Object.keys(extra).length > 0) {
+      report.recentEvents.push({
+        timestamp: report.timestamp,
+        type: "crash:context",
+        payload: extra
+      });
+    }
+    this.crashReports.push(report);
+    if (this.crashReports.length > this.maxCrashReports) {
+      this.crashReports.shift();
+    }
+    if (this._logCrashReportsToConsole) {
+      console.error(this.formatCrashReportForConsole(report));
+    }
+    this.emit("crash" /* CRASH */, report);
+    return report;
+  }
+  formatCrashReportForConsole(report) {
+    const lines = [];
+    lines.push("[Cascade Crash Report]");
+    lines.push(`timestamp=${report.timestamp}`);
+    lines.push(`source=${report.source}`);
+    lines.push(`message=${report.message}`);
+    if (report.stack) {
+      lines.push("stack:");
+      lines.push(report.stack);
+    }
+    if (report.recentEvents.length > 0) {
+      lines.push(`recentEvents(${report.recentEvents.length}):`);
+      for (const entry of report.recentEvents) {
+        lines.push(`${entry.timestamp} ${entry.type} ${JSON.stringify(entry.payload)}`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  getCrashReports() {
+    return [...this.crashReports];
+  }
+  getRecentRuntimeEvents() {
+    return [...this.recentRuntimeEvents];
+  }
+  clearCrashReports() {
+    this.crashReports = [];
+  }
   copyToSystemClipboard(text) {
     return this.clipboard.copyToSystemClipboard(text);
   }
@@ -17379,8 +17606,8 @@ Captured output:
     this._destroyFinalized = true;
     this._destroyPending = false;
     process.removeListener("SIGWINCH", this.sigwinchHandler);
-    process.removeListener("uncaughtException", this.handleError);
-    process.removeListener("unhandledRejection", this.handleError);
+    process.removeListener("uncaughtException", this.uncaughtExceptionHandler);
+    process.removeListener("unhandledRejection", this.unhandledRejectionHandler);
     process.removeListener("warning", this.warningHandler);
     process.removeListener("beforeExit", this.exitHandler);
     capture.removeListener("write", this.captureCallback);
@@ -17482,6 +17709,7 @@ Captured output:
         try {
           await frameCallback(deltaTime);
         } catch (error) {
+          this.reportCrash(error, "frame-callback");
           console.error("Error in frame callback:", error);
         }
       }
@@ -17515,6 +17743,9 @@ Captured output:
           this.renderTimeout = null;
         }
       }
+    } catch (error) {
+      this.reportCrash(error, "render-loop");
+      console.error("Error in render loop:", error);
     } finally {
       this.rendering = false;
       if (this._destroyPending) {
@@ -17591,6 +17822,30 @@ Captured output:
     }
     this.selectionContainers = [];
   }
+  selectWord(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.selectWord(x, y))
+        return;
+      current = current.parent;
+    }
+  }
+  selectLine(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.selectLine(x, y))
+        return;
+      current = current.parent;
+    }
+  }
+  updateSelectionWordSnap(x, y) {
+    let current = this.resolveSelectionMethodTarget(x, y);
+    while (current) {
+      if (current.updateSelectionWordSnap(x, y))
+        return;
+      current = current.parent;
+    }
+  }
   startSelection(renderable, x, y) {
     if (!renderable.selectable)
       return;
@@ -17636,7 +17891,11 @@ Captured output:
   }
   isWithinContainer(renderable, container) {
     let current = renderable;
+    const visited = new Set;
     while (current) {
+      if (visited.has(current))
+        return false;
+      visited.add(current);
       if (current === container)
         return true;
       current = current.parent;
@@ -17650,6 +17909,24 @@ Captured output:
       this.notifySelectablesOfSelectionChange();
     }
   }
+  resolveSelectionMethodTarget(x, y) {
+    const maybeRenderableId = this.hitTest(x, y);
+    let current = Renderable.renderablesByNumber.get(maybeRenderableId) ?? null;
+    while (current) {
+      if (current.selectable && !current.isDestroyed) {
+        return current;
+      }
+      current = current.parent;
+    }
+    const candidates = [...Renderable.renderablesByNumber.values()];
+    for (let i = candidates.length - 1;i >= 0; i -= 1) {
+      const candidate = candidates[i];
+      if (candidate.selectable && !candidate.isDestroyed && x >= candidate.x && x < candidate.x + candidate.width && y >= candidate.y && y < candidate.y + candidate.height) {
+        return candidate;
+      }
+    }
+    return null;
+  }
   notifySelectablesOfSelectionChange() {
     const selectedRenderables = [];
     const touchedRenderables = [];
@@ -17719,5 +17996,5 @@ Captured output:
 
 export { __toESM, __commonJS, __export, __require, Edge, Gutter, MeasureMode, exports_src, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, nonAlphanumericKeys, parseKeypress, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, RGBA, hexToRgb, rgbToHex, hsvToRgb, parseColor, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, createTextAttributes, attributesWithLink, getLinkId, 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, link, t, hastToStyledText, LinearScrollAccel, MacOSScrollAccel, StdinBuffer, parseAlign, parseAlignItems, 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, SpanInfoStruct, 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=0377C87661B220C664756E2164756E21
-//# sourceMappingURL=index-jx194wn1.js.map
+//# debugId=F994E7E6202035C864756E2164756E21
+//# sourceMappingURL=index-rj3f00a6.js.map