@opentuah/core 0.1.95 → 0.1.96

package/index.js

@@ -155,7 +155,7 @@ import {
   white,
   wrapWithDelegates,
   yellow
-} from "./index-2fr3e57d.js";
+} from "./index-yc0yx782.js";
 // src/text-buffer-view.ts
 class TextBufferView {
   lib;
@@ -4162,6 +4162,23 @@ class LineNumberRenderable extends Renderable {
     this._inlineHighlights.clear();
     this.requestRender();
   }
+  highlightLines(startLine, endLine, color) {
+    for (let i = startLine;i <= endLine; i++) {
+      this.parseLineColor(i, color);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
+  clearHighlightLines(startLine, endLine) {
+    for (let i = startLine;i <= endLine; i++) {
+      this._lineColorsGutter.delete(i);
+      this._lineColorsContent.delete(i);
+    }
+    if (this.gutter) {
+      this.gutter.setLineColors(this._lineColorsGutter, this._lineColorsContent);
+    }
+  }
 }
 
 // ../../node_modules/.bun/diff@8.0.2/node_modules/diff/libesm/diff/base.js
@@ -6119,6 +6136,30 @@ class DiffRenderable extends Renderable {
       this.rebuildView();
     }
   }
+  setLineColor(line, color) {
+    this.leftSide?.setLineColor(line, color);
+    this.rightSide?.setLineColor(line, color);
+  }
+  clearLineColor(line) {
+    this.leftSide?.clearLineColor(line);
+    this.rightSide?.clearLineColor(line);
+  }
+  setLineColors(lineColors) {
+    this.leftSide?.setLineColors(lineColors);
+    this.rightSide?.setLineColors(lineColors);
+  }
+  clearAllLineColors() {
+    this.leftSide?.clearAllLineColors();
+    this.rightSide?.clearAllLineColors();
+  }
+  highlightLines(startLine, endLine, color) {
+    this.leftSide?.highlightLines(startLine, endLine, color);
+    this.rightSide?.highlightLines(startLine, endLine, color);
+  }
+  clearHighlightLines(startLine, endLine) {
+    this.leftSide?.clearHighlightLines(startLine, endLine);
+    this.rightSide?.clearHighlightLines(startLine, endLine);
+  }
 }
 // src/renderables/EditBufferRenderable.ts
 class EditBufferRenderable extends Renderable {
@@ -6550,13 +6591,11 @@ class EditBufferRenderable extends Renderable {
     const cursorX = this.x + visualCursor.visualCol + 1;
     const cursorY = this.y + visualCursor.visualRow + 1;
     this._ctx.setCursorPosition(cursorX, cursorY, true);
-    this._ctx.setCursorColor(this._cursorColor);
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
   }
   focus() {
     super.focus();
-    this._ctx.setCursorStyle(this._cursorStyle.style, this._cursorStyle.blinking);
-    this._ctx.setCursorColor(this._cursorColor);
+    this._ctx.setCursorStyle({ ...this._cursorStyle, color: this._cursorColor });
     this.requestRender();
   }
   blur() {
@@ -7147,9 +7186,10 @@ class TextareaRenderable extends EditBufferRenderable {
     return this._placeholder;
   }
   set placeholder(value) {
-    if (this._placeholder !== value) {
-      this._placeholder = value;
-      this.applyPlaceholder(value);
+    const normalizedValue = value ?? null;
+    if (this._placeholder !== normalizedValue) {
+      this._placeholder = normalizedValue;
+      this.applyPlaceholder(normalizedValue);
       this.requestRender();
     }
   }
@@ -8765,8 +8805,7 @@ class MarkdownRenderable extends Renderable {
   set streaming(value) {
     if (this._streaming !== value) {
       this._streaming = value;
-      this.updateBlocks();
-      this.requestRender();
+      this.clearCache();
     }
   }
   getStyle(group) {
@@ -10199,13 +10238,13 @@ class ScrollBoxRenderable extends BoxRenderable {
     if (this.scrollTop <= 0) {
       this._stickyScrollTop = true;
       this._stickyScrollBottom = false;
-      if (this._stickyStart === "top" || this._stickyStart === "bottom" && maxScrollTop === 0) {
+      if (!this._isApplyingStickyScroll && (this._stickyStart === "top" || this._stickyStart === "bottom" && maxScrollTop === 0)) {
         this._hasManualScroll = false;
       }
     } else if (this.scrollTop >= maxScrollTop) {
       this._stickyScrollTop = false;
       this._stickyScrollBottom = true;
-      if (this._stickyStart === "bottom") {
+      if (!this._isApplyingStickyScroll && this._stickyStart === "bottom") {
         this._hasManualScroll = false;
       }
     } else {
@@ -10215,13 +10254,13 @@ class ScrollBoxRenderable extends BoxRenderable {
     if (this.scrollLeft <= 0) {
       this._stickyScrollLeft = true;
       this._stickyScrollRight = false;
-      if (this._stickyStart === "left" || this._stickyStart === "right" && maxScrollLeft === 0) {
+      if (!this._isApplyingStickyScroll && (this._stickyStart === "left" || this._stickyStart === "right" && maxScrollLeft === 0)) {
         this._hasManualScroll = false;
       }
     } else if (this.scrollLeft >= maxScrollLeft) {
       this._stickyScrollLeft = false;
       this._stickyScrollRight = true;
-      if (this._stickyStart === "right") {
+      if (!this._isApplyingStickyScroll && this._stickyStart === "right") {
         this._hasManualScroll = false;
       }
     } else {
@@ -10230,30 +10269,34 @@ class ScrollBoxRenderable extends BoxRenderable {
     }
   }
   applyStickyStart(stickyStart) {
+    const wasApplyingStickyScroll = this._isApplyingStickyScroll;
     this._isApplyingStickyScroll = true;
-    switch (stickyStart) {
-      case "top":
-        this._stickyScrollTop = true;
-        this._stickyScrollBottom = false;
-        this.verticalScrollBar.scrollPosition = 0;
-        break;
-      case "bottom":
-        this._stickyScrollTop = false;
-        this._stickyScrollBottom = true;
-        this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height);
-        break;
-      case "left":
-        this._stickyScrollLeft = true;
-        this._stickyScrollRight = false;
-        this.horizontalScrollBar.scrollPosition = 0;
-        break;
-      case "right":
-        this._stickyScrollLeft = false;
-        this._stickyScrollRight = true;
-        this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width);
-        break;
+    try {
+      switch (stickyStart) {
+        case "top":
+          this._stickyScrollTop = true;
+          this._stickyScrollBottom = false;
+          this.verticalScrollBar.scrollPosition = 0;
+          break;
+        case "bottom":
+          this._stickyScrollTop = false;
+          this._stickyScrollBottom = true;
+          this.verticalScrollBar.scrollPosition = Math.max(0, this.scrollHeight - this.viewport.height);
+          break;
+        case "left":
+          this._stickyScrollLeft = true;
+          this._stickyScrollRight = false;
+          this.horizontalScrollBar.scrollPosition = 0;
+          break;
+        case "right":
+          this._stickyScrollLeft = false;
+          this._stickyScrollRight = true;
+          this.horizontalScrollBar.scrollPosition = Math.max(0, this.scrollWidth - this.viewport.width);
+          break;
+      }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
-    this._isApplyingStickyScroll = false;
   }
   constructor(ctx, {
     wrapperOptions,
@@ -10593,29 +10636,32 @@ class ScrollBoxRenderable extends BoxRenderable {
   recalculateBarProps() {
     const wasApplyingStickyScroll = this._isApplyingStickyScroll;
     this._isApplyingStickyScroll = true;
-    this.verticalScrollBar.scrollSize = this.content.height;
-    this.verticalScrollBar.viewportSize = this.viewport.height;
-    this.horizontalScrollBar.scrollSize = this.content.width;
-    this.horizontalScrollBar.viewportSize = this.viewport.width;
-    if (this._stickyScroll) {
-      const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
-      const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
-      if (this._stickyStart && !this._hasManualScroll) {
-        this.applyStickyStart(this._stickyStart);
-      } else {
-        if (this._stickyScrollTop) {
-          this.scrollTop = 0;
-        } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
-          this.scrollTop = newMaxScrollTop;
-        }
-        if (this._stickyScrollLeft) {
-          this.scrollLeft = 0;
-        } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
-          this.scrollLeft = newMaxScrollLeft;
+    try {
+      this.verticalScrollBar.scrollSize = this.content.height;
+      this.verticalScrollBar.viewportSize = this.viewport.height;
+      this.horizontalScrollBar.scrollSize = this.content.width;
+      this.horizontalScrollBar.viewportSize = this.viewport.width;
+      if (this._stickyScroll) {
+        const newMaxScrollTop = Math.max(0, this.scrollHeight - this.viewport.height);
+        const newMaxScrollLeft = Math.max(0, this.scrollWidth - this.viewport.width);
+        if (this._stickyStart && !this._hasManualScroll) {
+          this.applyStickyStart(this._stickyStart);
+        } else {
+          if (this._stickyScrollTop) {
+            this.scrollTop = 0;
+          } else if (this._stickyScrollBottom && newMaxScrollTop > 0) {
+            this.scrollTop = newMaxScrollTop;
+          }
+          if (this._stickyScrollLeft) {
+            this.scrollLeft = 0;
+          } else if (this._stickyScrollRight && newMaxScrollLeft > 0) {
+            this.scrollLeft = newMaxScrollLeft;
+          }
         }
       }
+    } finally {
+      this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
-    this._isApplyingStickyScroll = wasApplyingStickyScroll;
     process.nextTick(() => {
       this.requestRender();
     });
@@ -11046,6 +11092,839 @@ class SelectRenderable extends Renderable {
     }
   }
 }
+// src/renderables/TextTable.ts
+var MEASURE_HEIGHT = 1e4;
+
+class TextTableRenderable extends Renderable {
+  _content;
+  _wrapMode;
+  _columnWidthMode;
+  _cellPadding;
+  _showBorders;
+  _border;
+  _outerBorder;
+  _hasExplicitOuterBorder;
+  _borderStyle;
+  _borderColor;
+  _borderBackgroundColor;
+  _backgroundColor;
+  _defaultFg;
+  _defaultBg;
+  _defaultAttributes;
+  _selectionBg;
+  _selectionFg;
+  _lastLocalSelection = null;
+  _cells = [];
+  _prevCellContent = [];
+  _rowCount = 0;
+  _columnCount = 0;
+  _layout = this.createEmptyLayout();
+  _layoutDirty = true;
+  _rasterDirty = true;
+  _cachedMeasureLayout = null;
+  _cachedMeasureWidth = undefined;
+  _defaultOptions = {
+    content: [],
+    wrapMode: "none",
+    columnWidthMode: "content",
+    cellPadding: 0,
+    showBorders: true,
+    border: true,
+    outerBorder: true,
+    selectable: true,
+    selectionBg: undefined,
+    selectionFg: undefined,
+    borderStyle: "single",
+    borderColor: "#FFFFFF",
+    borderBackgroundColor: "transparent",
+    backgroundColor: "transparent",
+    fg: "#FFFFFF",
+    bg: "transparent",
+    attributes: 0
+  };
+  constructor(ctx, options = {}) {
+    super(ctx, { ...options, buffered: true });
+    this._content = options.content ?? this._defaultOptions.content;
+    this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
+    this._columnWidthMode = options.columnWidthMode ?? this._defaultOptions.columnWidthMode;
+    this._cellPadding = this.resolveCellPadding(options.cellPadding);
+    this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
+    this._border = options.border ?? this._defaultOptions.border;
+    this._hasExplicitOuterBorder = options.outerBorder !== undefined;
+    this._outerBorder = options.outerBorder ?? this._border;
+    this.selectable = options.selectable ?? this._defaultOptions.selectable;
+    this._selectionBg = options.selectionBg ? parseColor(options.selectionBg) : undefined;
+    this._selectionFg = options.selectionFg ? parseColor(options.selectionFg) : undefined;
+    this._borderStyle = parseBorderStyle(options.borderStyle, this._defaultOptions.borderStyle);
+    this._borderColor = parseColor(options.borderColor ?? this._defaultOptions.borderColor);
+    this._borderBackgroundColor = parseColor(options.borderBackgroundColor ?? this._defaultOptions.borderBackgroundColor);
+    this._backgroundColor = parseColor(options.backgroundColor ?? this._defaultOptions.backgroundColor);
+    this._defaultFg = parseColor(options.fg ?? this._defaultOptions.fg);
+    this._defaultBg = parseColor(options.bg ?? this._defaultOptions.bg);
+    this._defaultAttributes = options.attributes ?? this._defaultOptions.attributes;
+    this.setupMeasureFunc();
+    this.rebuildCells();
+  }
+  get content() {
+    return this._content;
+  }
+  set content(value) {
+    this._content = value ?? [];
+    this.rebuildCells();
+  }
+  get wrapMode() {
+    return this._wrapMode;
+  }
+  set wrapMode(value) {
+    if (this._wrapMode === value)
+      return;
+    this._wrapMode = value;
+    for (const row of this._cells) {
+      for (const cell of row) {
+        cell.textBufferView.setWrapMode(value);
+      }
+    }
+    this.invalidateLayoutAndRaster();
+  }
+  get columnWidthMode() {
+    return this._columnWidthMode;
+  }
+  set columnWidthMode(value) {
+    if (this._columnWidthMode === value)
+      return;
+    this._columnWidthMode = value;
+    this.invalidateLayoutAndRaster();
+  }
+  get cellPadding() {
+    return this._cellPadding;
+  }
+  set cellPadding(value) {
+    const next = this.resolveCellPadding(value);
+    if (this._cellPadding === next)
+      return;
+    this._cellPadding = next;
+    this.invalidateLayoutAndRaster();
+  }
+  get showBorders() {
+    return this._showBorders;
+  }
+  set showBorders(value) {
+    if (this._showBorders === value)
+      return;
+    this._showBorders = value;
+    this.invalidateRasterOnly();
+  }
+  get outerBorder() {
+    return this._outerBorder;
+  }
+  set outerBorder(value) {
+    if (this._outerBorder === value)
+      return;
+    this._hasExplicitOuterBorder = true;
+    this._outerBorder = value;
+    this.invalidateLayoutAndRaster();
+  }
+  get border() {
+    return this._border;
+  }
+  set border(value) {
+    if (this._border === value)
+      return;
+    this._border = value;
+    if (!this._hasExplicitOuterBorder) {
+      this._outerBorder = value;
+    }
+    this.invalidateLayoutAndRaster();
+  }
+  get borderStyle() {
+    return this._borderStyle;
+  }
+  set borderStyle(value) {
+    const next = parseBorderStyle(value, this._defaultOptions.borderStyle);
+    if (this._borderStyle === next)
+      return;
+    this._borderStyle = next;
+    this.invalidateRasterOnly();
+  }
+  get borderColor() {
+    return this._borderColor;
+  }
+  set borderColor(value) {
+    const next = parseColor(value);
+    if (this._borderColor === next)
+      return;
+    this._borderColor = next;
+    this.invalidateRasterOnly();
+  }
+  shouldStartSelection(x2, y2) {
+    if (!this.selectable)
+      return false;
+    this.ensureLayoutReady();
+    const localX = x2 - this.x;
+    const localY = y2 - this.y;
+    return this.getCellAtLocalPosition(localX, localY) !== null;
+  }
+  onSelectionChanged(selection) {
+    this.ensureLayoutReady();
+    const previousLocalSelection = this._lastLocalSelection;
+    const localSelection = convertGlobalToLocalSelection(selection, this.x, this.y);
+    this._lastLocalSelection = localSelection;
+    const dirtyRows = this.getDirtySelectionRowRange(previousLocalSelection, localSelection);
+    if (!localSelection?.isActive) {
+      this.resetCellSelections();
+    } else {
+      this.applySelectionToCells(localSelection, selection?.isStart ?? false);
+    }
+    if (dirtyRows !== null) {
+      this.redrawSelectionRows(dirtyRows.firstRow, dirtyRows.lastRow);
+    }
+    return this.hasSelection();
+  }
+  hasSelection() {
+    for (const row of this._cells) {
+      for (const cell of row) {
+        if (cell.textBufferView.hasSelection()) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  getSelection() {
+    for (const row of this._cells) {
+      for (const cell of row) {
+        const selection = cell.textBufferView.getSelection();
+        if (selection) {
+          return selection;
+        }
+      }
+    }
+    return null;
+  }
+  getSelectedText() {
+    const selectedRows = [];
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      const rowSelections = [];
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell || !cell.textBufferView.hasSelection())
+          continue;
+        const selectedText = cell.textBufferView.getSelectedText();
+        if (selectedText.length > 0) {
+          rowSelections.push(selectedText);
+        }
+      }
+      if (rowSelections.length > 0) {
+        selectedRows.push(rowSelections.join("\t"));
+      }
+    }
+    return selectedRows.join(`
+`);
+  }
+  onResize(width, height) {
+    this.invalidateLayoutAndRaster(false);
+    super.onResize(width, height);
+  }
+  renderSelf(buffer) {
+    if (!this.visible || this.isDestroyed)
+      return;
+    if (this._layoutDirty) {
+      this.rebuildLayoutForCurrentWidth();
+    }
+    if (!this._rasterDirty)
+      return;
+    buffer.clear(this._backgroundColor);
+    if (this._rowCount === 0 || this._columnCount === 0) {
+      this._rasterDirty = false;
+      return;
+    }
+    this.drawBorders(buffer);
+    this.drawCells(buffer);
+    this._rasterDirty = false;
+  }
+  destroySelf() {
+    this.destroyCells();
+    super.destroySelf();
+  }
+  setupMeasureFunc() {
+    const measureFunc = (width, widthMode, height, heightMode) => {
+      const hasWidthConstraint = widthMode !== MeasureMode.Undefined && Number.isFinite(width);
+      const rawWidthConstraint = hasWidthConstraint ? Math.max(1, Math.floor(width)) : undefined;
+      const widthConstraint = this.resolveLayoutWidthConstraint(rawWidthConstraint);
+      const measuredLayout = this.computeLayout(widthConstraint);
+      this._cachedMeasureLayout = measuredLayout;
+      this._cachedMeasureWidth = widthConstraint;
+      let measuredWidth = measuredLayout.tableWidth > 0 ? measuredLayout.tableWidth : 1;
+      let measuredHeight = measuredLayout.tableHeight > 0 ? measuredLayout.tableHeight : 1;
+      if (widthMode === MeasureMode.AtMost && rawWidthConstraint !== undefined && this._positionType !== "absolute") {
+        measuredWidth = Math.min(rawWidthConstraint, measuredWidth);
+      }
+      if (heightMode === MeasureMode.AtMost && Number.isFinite(height) && this._positionType !== "absolute") {
+        measuredHeight = Math.min(Math.max(1, Math.floor(height)), measuredHeight);
+      }
+      return {
+        width: measuredWidth,
+        height: measuredHeight
+      };
+    };
+    this.yogaNode.setMeasureFunc(measureFunc);
+  }
+  rebuildCells() {
+    const newRowCount = this._content.length;
+    const newColumnCount = this._content.reduce((max, row) => Math.max(max, row.length), 0);
+    if (this._cells.length === 0) {
+      this._rowCount = newRowCount;
+      this._columnCount = newColumnCount;
+      this._cells = [];
+      this._prevCellContent = [];
+      for (let rowIdx = 0;rowIdx < newRowCount; rowIdx++) {
+        const row = this._content[rowIdx] ?? [];
+        const rowCells = [];
+        const rowRefs = [];
+        for (let colIdx = 0;colIdx < newColumnCount; colIdx++) {
+          const cellContent = row[colIdx];
+          rowCells.push(this.createCell(cellContent));
+          rowRefs.push(cellContent);
+        }
+        this._cells.push(rowCells);
+        this._prevCellContent.push(rowRefs);
+      }
+      this.invalidateLayoutAndRaster();
+      return;
+    }
+    this.updateCellsDiff(newRowCount, newColumnCount);
+    this.invalidateLayoutAndRaster();
+  }
+  updateCellsDiff(newRowCount, newColumnCount) {
+    const oldRowCount = this._rowCount;
+    const oldColumnCount = this._columnCount;
+    const keepRows = Math.min(oldRowCount, newRowCount);
+    const keepCols = Math.min(oldColumnCount, newColumnCount);
+    for (let rowIdx = 0;rowIdx < keepRows; rowIdx++) {
+      const newRow = this._content[rowIdx] ?? [];
+      const cellRow = this._cells[rowIdx];
+      const refRow = this._prevCellContent[rowIdx];
+      for (let colIdx = 0;colIdx < keepCols; colIdx++) {
+        const cellContent = newRow[colIdx];
+        if (cellContent === refRow[colIdx])
+          continue;
+        const oldCell = cellRow[colIdx];
+        oldCell.textBufferView.destroy();
+        oldCell.textBuffer.destroy();
+        oldCell.syntaxStyle.destroy();
+        cellRow[colIdx] = this.createCell(cellContent);
+        refRow[colIdx] = cellContent;
+      }
+      if (newColumnCount > oldColumnCount) {
+        for (let colIdx = oldColumnCount;colIdx < newColumnCount; colIdx++) {
+          const cellContent = newRow[colIdx];
+          cellRow.push(this.createCell(cellContent));
+          refRow.push(cellContent);
+        }
+      } else if (newColumnCount < oldColumnCount) {
+        for (let colIdx = newColumnCount;colIdx < oldColumnCount; colIdx++) {
+          const cell = cellRow[colIdx];
+          cell.textBufferView.destroy();
+          cell.textBuffer.destroy();
+          cell.syntaxStyle.destroy();
+        }
+        cellRow.length = newColumnCount;
+        refRow.length = newColumnCount;
+      }
+    }
+    if (newRowCount > oldRowCount) {
+      for (let rowIdx = oldRowCount;rowIdx < newRowCount; rowIdx++) {
+        const newRow = this._content[rowIdx] ?? [];
+        const rowCells = [];
+        const rowRefs = [];
+        for (let colIdx = 0;colIdx < newColumnCount; colIdx++) {
+          const cellContent = newRow[colIdx];
+          rowCells.push(this.createCell(cellContent));
+          rowRefs.push(cellContent);
+        }
+        this._cells.push(rowCells);
+        this._prevCellContent.push(rowRefs);
+      }
+    } else if (newRowCount < oldRowCount) {
+      for (let rowIdx = newRowCount;rowIdx < oldRowCount; rowIdx++) {
+        const row = this._cells[rowIdx];
+        for (const cell of row) {
+          cell.textBufferView.destroy();
+          cell.textBuffer.destroy();
+          cell.syntaxStyle.destroy();
+        }
+      }
+      this._cells.length = newRowCount;
+      this._prevCellContent.length = newRowCount;
+    }
+    this._rowCount = newRowCount;
+    this._columnCount = newColumnCount;
+  }
+  createCell(content) {
+    const styledText = this.toStyledText(content);
+    const textBuffer = TextBuffer.create(this._ctx.widthMethod);
+    const syntaxStyle = SyntaxStyle.create();
+    textBuffer.setDefaultFg(this._defaultFg);
+    textBuffer.setDefaultBg(this._defaultBg);
+    textBuffer.setDefaultAttributes(this._defaultAttributes);
+    textBuffer.setSyntaxStyle(syntaxStyle);
+    textBuffer.setStyledText(styledText);
+    const textBufferView = TextBufferView.create(textBuffer);
+    textBufferView.setWrapMode(this._wrapMode);
+    return { textBuffer, textBufferView, syntaxStyle };
+  }
+  toStyledText(content) {
+    if (Array.isArray(content)) {
+      return new StyledText(content);
+    }
+    if (content === null || content === undefined) {
+      return stringToStyledText("");
+    }
+    return stringToStyledText(String(content));
+  }
+  destroyCells() {
+    for (const row of this._cells) {
+      for (const cell of row) {
+        cell.textBufferView.destroy();
+        cell.textBuffer.destroy();
+        cell.syntaxStyle.destroy();
+      }
+    }
+    this._cells = [];
+    this._prevCellContent = [];
+    this._rowCount = 0;
+    this._columnCount = 0;
+    this._layout = this.createEmptyLayout();
+  }
+  rebuildLayoutForCurrentWidth() {
+    const maxTableWidth = this.resolveLayoutWidthConstraint(this.width);
+    let layout;
+    if (this._cachedMeasureLayout !== null && this._cachedMeasureWidth === maxTableWidth) {
+      layout = this._cachedMeasureLayout;
+    } else {
+      layout = this.computeLayout(maxTableWidth);
+    }
+    this._cachedMeasureLayout = null;
+    this._cachedMeasureWidth = undefined;
+    this._layout = layout;
+    this.applyLayoutToViews(layout);
+    this._layoutDirty = false;
+    if (this._lastLocalSelection?.isActive) {
+      this.applySelectionToCells(this._lastLocalSelection, true);
+    }
+  }
+  computeLayout(maxTableWidth) {
+    if (this._rowCount === 0 || this._columnCount === 0) {
+      return this.createEmptyLayout();
+    }
+    const borderLayout = this.resolveBorderLayout();
+    const columnWidths = this.computeColumnWidths(maxTableWidth, borderLayout);
+    const rowHeights = this.computeRowHeights(columnWidths);
+    const columnOffsets = this.computeOffsets(columnWidths, borderLayout.left, borderLayout.right, borderLayout.innerVertical);
+    const rowOffsets = this.computeOffsets(rowHeights, borderLayout.top, borderLayout.bottom, borderLayout.innerHorizontal);
+    return {
+      columnWidths,
+      rowHeights,
+      columnOffsets,
+      rowOffsets,
+      columnOffsetsI32: new Int32Array(columnOffsets),
+      rowOffsetsI32: new Int32Array(rowOffsets),
+      tableWidth: (columnOffsets[columnOffsets.length - 1] ?? 0) + 1,
+      tableHeight: (rowOffsets[rowOffsets.length - 1] ?? 0) + 1
+    };
+  }
+  computeColumnWidths(maxTableWidth, borderLayout) {
+    const horizontalPadding = this.getHorizontalCellPadding();
+    const intrinsicWidths = new Array(this._columnCount).fill(1 + horizontalPadding);
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell)
+          continue;
+        const measure = cell.textBufferView.measureForDimensions(0, MEASURE_HEIGHT);
+        const measuredWidth = Math.max(1, measure?.maxWidth ?? 0) + horizontalPadding;
+        intrinsicWidths[colIdx] = Math.max(intrinsicWidths[colIdx], measuredWidth);
+      }
+    }
+    if (maxTableWidth === undefined || !Number.isFinite(maxTableWidth) || maxTableWidth <= 0) {
+      return intrinsicWidths;
+    }
+    const maxContentWidth = Math.max(1, Math.floor(maxTableWidth) - this.getVerticalBorderCount(borderLayout));
+    const currentWidth = intrinsicWidths.reduce((sum, width) => sum + width, 0);
+    if (currentWidth === maxContentWidth) {
+      return intrinsicWidths;
+    }
+    if (currentWidth < maxContentWidth) {
+      if (this._columnWidthMode === "fill") {
+        return this.expandColumnWidths(intrinsicWidths, maxContentWidth);
+      }
+      return intrinsicWidths;
+    }
+    if (this._wrapMode === "none") {
+      return intrinsicWidths;
+    }
+    return this.fitColumnWidths(intrinsicWidths, maxContentWidth);
+  }
+  expandColumnWidths(widths, targetContentWidth) {
+    const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
+    const totalBaseWidth = baseWidths.reduce((sum, width) => sum + width, 0);
+    if (totalBaseWidth >= targetContentWidth) {
+      return baseWidths;
+    }
+    const expanded = [...baseWidths];
+    const columns = expanded.length;
+    const extraWidth = targetContentWidth - totalBaseWidth;
+    const sharedWidth = Math.floor(extraWidth / columns);
+    const remainder = extraWidth % columns;
+    for (let idx = 0;idx < columns; idx++) {
+      expanded[idx] += sharedWidth;
+      if (idx < remainder) {
+        expanded[idx] += 1;
+      }
+    }
+    return expanded;
+  }
+  fitColumnWidths(widths, targetContentWidth) {
+    const minWidth = 1 + this.getHorizontalCellPadding();
+    const hardMinWidths = new Array(widths.length).fill(minWidth);
+    const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
+    const preferredMinWidths = baseWidths.map((width) => Math.min(width, minWidth + 1));
+    const preferredMinTotal = preferredMinWidths.reduce((sum, width) => sum + width, 0);
+    const floorWidths = preferredMinTotal <= targetContentWidth ? preferredMinWidths : hardMinWidths;
+    const floorTotal = floorWidths.reduce((sum, width) => sum + width, 0);
+    const clampedTarget = Math.max(floorTotal, targetContentWidth);
+    const totalBaseWidth = baseWidths.reduce((sum, width) => sum + width, 0);
+    if (totalBaseWidth <= clampedTarget) {
+      return baseWidths;
+    }
+    const shrinkable = baseWidths.map((width, idx) => width - floorWidths[idx]);
+    const totalShrinkable = shrinkable.reduce((sum, value) => sum + value, 0);
+    if (totalShrinkable <= 0) {
+      return [...floorWidths];
+    }
+    const targetShrink = totalBaseWidth - clampedTarget;
+    const integerShrink = new Array(baseWidths.length).fill(0);
+    const fractions = new Array(baseWidths.length).fill(0);
+    let usedShrink = 0;
+    for (let idx = 0;idx < baseWidths.length; idx++) {
+      if (shrinkable[idx] <= 0)
+        continue;
+      const exact = shrinkable[idx] / totalShrinkable * targetShrink;
+      const whole = Math.min(shrinkable[idx], Math.floor(exact));
+      integerShrink[idx] = whole;
+      fractions[idx] = exact - whole;
+      usedShrink += whole;
+    }
+    let remainingShrink = targetShrink - usedShrink;
+    while (remainingShrink > 0) {
+      let bestIdx = -1;
+      let bestFraction = -1;
+      for (let idx = 0;idx < baseWidths.length; idx++) {
+        if (shrinkable[idx] - integerShrink[idx] <= 0)
+          continue;
+        if (fractions[idx] > bestFraction) {
+          bestFraction = fractions[idx];
+          bestIdx = idx;
+        }
+      }
+      if (bestIdx === -1)
+        break;
+      integerShrink[bestIdx] += 1;
+      fractions[bestIdx] = 0;
+      remainingShrink -= 1;
+    }
+    return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - integerShrink[idx]));
+  }
+  computeRowHeights(columnWidths) {
+    const horizontalPadding = this.getHorizontalCellPadding();
+    const verticalPadding = this.getVerticalCellPadding();
+    const rowHeights = new Array(this._rowCount).fill(1 + verticalPadding);
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell)
+          continue;
+        const width = Math.max(1, (columnWidths[colIdx] ?? 1) - horizontalPadding);
+        const measure = cell.textBufferView.measureForDimensions(width, MEASURE_HEIGHT);
+        const lineCount = Math.max(1, measure?.lineCount ?? 1);
+        rowHeights[rowIdx] = Math.max(rowHeights[rowIdx], lineCount + verticalPadding);
+      }
+    }
+    return rowHeights;
+  }
+  computeOffsets(parts, startBoundary, endBoundary, includeInnerBoundaries) {
+    const offsets = [startBoundary ? 0 : -1];
+    let cursor = offsets[0] ?? 0;
+    for (let idx = 0;idx < parts.length; idx++) {
+      const size = parts[idx] ?? 1;
+      const hasBoundaryAfter = idx < parts.length - 1 ? includeInnerBoundaries : endBoundary;
+      cursor += size + (hasBoundaryAfter ? 1 : 0);
+      offsets.push(cursor);
+    }
+    return offsets;
+  }
+  applyLayoutToViews(layout) {
+    const horizontalPadding = this.getHorizontalCellPadding();
+    const verticalPadding = this.getVerticalCellPadding();
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell)
+          continue;
+        const colWidth = layout.columnWidths[colIdx] ?? 1;
+        const rowHeight = layout.rowHeights[rowIdx] ?? 1;
+        const contentWidth = Math.max(1, colWidth - horizontalPadding);
+        const contentHeight = Math.max(1, rowHeight - verticalPadding);
+        if (this._wrapMode === "none") {
+          cell.textBufferView.setWrapWidth(null);
+        } else {
+          cell.textBufferView.setWrapWidth(contentWidth);
+        }
+        cell.textBufferView.setViewport(0, 0, contentWidth, contentHeight);
+      }
+    }
+  }
+  resolveBorderLayout() {
+    return {
+      left: this._outerBorder,
+      right: this._outerBorder,
+      top: this._outerBorder,
+      bottom: this._outerBorder,
+      innerVertical: this._border && this._columnCount > 1,
+      innerHorizontal: this._border && this._rowCount > 1
+    };
+  }
+  getVerticalBorderCount(borderLayout) {
+    return (borderLayout.left ? 1 : 0) + (borderLayout.right ? 1 : 0) + (borderLayout.innerVertical ? Math.max(0, this._columnCount - 1) : 0);
+  }
+  getHorizontalBorderCount(borderLayout) {
+    return (borderLayout.top ? 1 : 0) + (borderLayout.bottom ? 1 : 0) + (borderLayout.innerHorizontal ? Math.max(0, this._rowCount - 1) : 0);
+  }
+  drawBorders(buffer) {
+    if (!this._showBorders) {
+      return;
+    }
+    const borderLayout = this.resolveBorderLayout();
+    if (this.getVerticalBorderCount(borderLayout) === 0 && this.getHorizontalBorderCount(borderLayout) === 0) {
+      return;
+    }
+    buffer.drawGrid({
+      borderChars: BorderCharArrays[this._borderStyle],
+      borderFg: this._borderColor,
+      borderBg: this._borderBackgroundColor,
+      columnOffsets: this._layout.columnOffsetsI32,
+      rowOffsets: this._layout.rowOffsetsI32,
+      drawInner: this._border,
+      drawOuter: this._outerBorder
+    });
+  }
+  drawCells(buffer) {
+    this.drawCellRange(buffer, 0, this._rowCount - 1);
+  }
+  drawCellRange(buffer, firstRow, lastRow) {
+    const colOffsets = this._layout.columnOffsets;
+    const rowOffsets = this._layout.rowOffsets;
+    const cellPadding = this._cellPadding;
+    for (let rowIdx = firstRow;rowIdx <= lastRow; rowIdx++) {
+      const cellY = (rowOffsets[rowIdx] ?? 0) + 1 + cellPadding;
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell)
+          continue;
+        buffer.drawTextBuffer(cell.textBufferView, (colOffsets[colIdx] ?? 0) + 1 + cellPadding, cellY);
+      }
+    }
+  }
+  redrawSelectionRows(firstRow, lastRow) {
+    if (firstRow > lastRow)
+      return;
+    if (this._backgroundColor.a < 1) {
+      this.invalidateRasterOnly();
+      return;
+    }
+    const buffer = this.frameBuffer;
+    if (!buffer)
+      return;
+    this.clearCellRange(buffer, firstRow, lastRow);
+    this.drawCellRange(buffer, firstRow, lastRow);
+    this.requestRender();
+  }
+  clearCellRange(buffer, firstRow, lastRow) {
+    const colWidths = this._layout.columnWidths;
+    const rowHeights = this._layout.rowHeights;
+    const colOffsets = this._layout.columnOffsets;
+    const rowOffsets = this._layout.rowOffsets;
+    for (let rowIdx = firstRow;rowIdx <= lastRow; rowIdx++) {
+      const cellY = (rowOffsets[rowIdx] ?? 0) + 1;
+      const rowHeight = rowHeights[rowIdx] ?? 1;
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cellX = (colOffsets[colIdx] ?? 0) + 1;
+        const colWidth = colWidths[colIdx] ?? 1;
+        buffer.fillRect(cellX, cellY, colWidth, rowHeight, this._backgroundColor);
+      }
+    }
+  }
+  ensureLayoutReady() {
+    if (!this._layoutDirty)
+      return;
+    this.rebuildLayoutForCurrentWidth();
+  }
+  getCellAtLocalPosition(localX, localY) {
+    if (this._rowCount === 0 || this._columnCount === 0)
+      return null;
+    if (localX < 0 || localY < 0 || localX >= this._layout.tableWidth || localY >= this._layout.tableHeight) {
+      return null;
+    }
+    let rowIdx = -1;
+    for (let idx = 0;idx < this._rowCount; idx++) {
+      const top = (this._layout.rowOffsets[idx] ?? 0) + 1;
+      const bottom = top + (this._layout.rowHeights[idx] ?? 1) - 1;
+      if (localY >= top && localY <= bottom) {
+        rowIdx = idx;
+        break;
+      }
+    }
+    if (rowIdx < 0)
+      return null;
+    let colIdx = -1;
+    for (let idx = 0;idx < this._columnCount; idx++) {
+      const left = (this._layout.columnOffsets[idx] ?? 0) + 1;
+      const right = left + (this._layout.columnWidths[idx] ?? 1) - 1;
+      if (localX >= left && localX <= right) {
+        colIdx = idx;
+        break;
+      }
+    }
+    if (colIdx < 0)
+      return null;
+    return { rowIdx, colIdx };
+  }
+  applySelectionToCells(localSelection, isStart) {
+    const minSelY = Math.min(localSelection.anchorY, localSelection.focusY);
+    const maxSelY = Math.max(localSelection.anchorY, localSelection.focusY);
+    const firstRow = this.findRowForLocalY(minSelY);
+    const lastRow = this.findRowForLocalY(maxSelY);
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      if (rowIdx < firstRow || rowIdx > lastRow) {
+        this.resetRowSelection(rowIdx);
+        continue;
+      }
+      const cellTop = (this._layout.rowOffsets[rowIdx] ?? 0) + 1 + this._cellPadding;
+      for (let colIdx = 0;colIdx < this._columnCount; colIdx++) {
+        const cell = this._cells[rowIdx]?.[colIdx];
+        if (!cell)
+          continue;
+        const cellLeft = (this._layout.columnOffsets[colIdx] ?? 0) + 1 + this._cellPadding;
+        const anchorX = localSelection.anchorX - cellLeft;
+        const anchorY = localSelection.anchorY - cellTop;
+        const focusX = localSelection.focusX - cellLeft;
+        const focusY = localSelection.focusY - cellTop;
+        if (isStart) {
+          cell.textBufferView.setLocalSelection(anchorX, anchorY, focusX, focusY, this._selectionBg, this._selectionFg);
+        } else {
+          cell.textBufferView.updateLocalSelection(anchorX, anchorY, focusX, focusY, this._selectionBg, this._selectionFg);
+        }
+      }
+    }
+  }
+  findRowForLocalY(localY) {
+    if (this._rowCount === 0)
+      return 0;
+    if (localY < 0)
+      return 0;
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      const rowStart = (this._layout.rowOffsets[rowIdx] ?? 0) + 1;
+      const rowEnd = rowStart + (this._layout.rowHeights[rowIdx] ?? 1) - 1;
+      if (localY <= rowEnd)
+        return rowIdx;
+    }
+    return this._rowCount - 1;
+  }
+  getSelectionRowRange(selection) {
+    if (!selection?.isActive || this._rowCount === 0)
+      return null;
+    const minSelY = Math.min(selection.anchorY, selection.focusY);
+    const maxSelY = Math.max(selection.anchorY, selection.focusY);
+    return {
+      firstRow: this.findRowForLocalY(minSelY),
+      lastRow: this.findRowForLocalY(maxSelY)
+    };
+  }
+  getDirtySelectionRowRange(previousSelection, currentSelection) {
+    const previousRange = this.getSelectionRowRange(previousSelection);
+    const currentRange = this.getSelectionRowRange(currentSelection);
+    if (previousRange === null)
+      return currentRange;
+    if (currentRange === null)
+      return previousRange;
+    return {
+      firstRow: Math.min(previousRange.firstRow, currentRange.firstRow),
+      lastRow: Math.max(previousRange.lastRow, currentRange.lastRow)
+    };
+  }
+  resetRowSelection(rowIdx) {
+    const row = this._cells[rowIdx];
+    if (!row)
+      return;
+    for (const cell of row) {
+      if (!cell.textBufferView.hasSelection())
+        continue;
+      cell.textBufferView.resetLocalSelection();
+    }
+  }
+  resetCellSelections() {
+    for (let rowIdx = 0;rowIdx < this._rowCount; rowIdx++) {
+      this.resetRowSelection(rowIdx);
+    }
+  }
+  createEmptyLayout() {
+    return {
+      columnWidths: [],
+      rowHeights: [],
+      columnOffsets: [0],
+      rowOffsets: [0],
+      columnOffsetsI32: new Int32Array([0]),
+      rowOffsetsI32: new Int32Array([0]),
+      tableWidth: 0,
+      tableHeight: 0
+    };
+  }
+  resolveLayoutWidthConstraint(width) {
+    if (width === undefined || !Number.isFinite(width) || width <= 0) {
+      return;
+    }
+    if (this._wrapMode !== "none" || this._columnWidthMode === "fill") {
+      return Math.max(1, Math.floor(width));
+    }
+    return;
+  }
+  getHorizontalCellPadding() {
+    return this._cellPadding * 2;
+  }
+  getVerticalCellPadding() {
+    return this._cellPadding * 2;
+  }
+  resolveCellPadding(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+      return this._defaultOptions.cellPadding;
+    }
+    return Math.max(0, Math.floor(value));
+  }
+  invalidateLayoutAndRaster(markYogaDirty = true) {
+    this._layoutDirty = true;
+    this._rasterDirty = true;
+    this._cachedMeasureLayout = null;
+    this._cachedMeasureWidth = undefined;
+    if (markYogaDirty) {
+      this.yogaNode.markDirty();
+    }
+    this.requestRender();
+  }
+  invalidateRasterOnly() {
+    this._rasterDirty = true;
+    this.requestRender();
+  }
+}
 // src/renderables/TabSelect.ts
 var defaultTabSelectKeybindings = [
   { name: "left", action: "move-left" },
@@ -11615,6 +12494,7 @@ export {
   TreeSitterClient,
   Timeline,
   TextareaRenderable,
+  TextTableRenderable,
   TextRenderable,
   TextNodeRenderable,
   TextBufferView,
@@ -11695,5 +12575,5 @@ export {
   ASCIIFont
 };
 
-//# debugId=BB0EDE58447BBE9564756E2164756E21
+//# debugId=FEAD097E3158A1E664756E2164756E21
 //# sourceMappingURL=index.js.map