@aitty/browser 0.1.0

package/dist/browser.d.ts

@@ -0,0 +1,6 @@
+import { BrowserTerminalBridge, BrowserTerminalRenderer, BrowserTerminalStyleOverride, BrowserTerminalStyleTracker } from "./frontend/browser-terminal-renderer.js";
+import { TerminalInputCallbacks, TerminalKeyResolver, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey } from "./frontend/terminal-input-policies.js";
+import { BinaryWriteTarget, BufferedTerminalWriter, FrameScheduler, MountAittyContainerOptions, MountAittyOptions, MountTerminalDependencies, MountTerminalElements, MountedTerminalApp, TerminalConnectionState, TerminalLoadingPresentation, TerminalOutputState, TerminalScrollAdapter, TerminalScrollAdapterContext, TerminalScrollAdapterFactory, TerminalScrollMetrics, TerminalScrollOptions, TerminalSessionPresentationState, TerminalStatusListener, TerminalStatusSnapshot, TerminalTheme, TerminalTransport, TransportCloseEvent, TransportHandlers, createBufferedTerminalWriter, defineAittyTerminalElement, mountAitty, mountTerminalApp } from "./frontend/terminal-app.js";
+import { AittyTheme, AittyThemeSource, AittyThemeSubscription } from "./theme-source.js";
+import { AnsiStyleTracker, createAnsiStyleTracker } from "./frontend/ansi-style-tracker.js";
+export { type AittyTheme, type AittyThemeSource, type AittyThemeSubscription, type AnsiStyleTracker, type BinaryWriteTarget, type BrowserTerminalBridge, BrowserTerminalRenderer, type BrowserTerminalStyleOverride, type BrowserTerminalStyleTracker, type BufferedTerminalWriter, type FrameScheduler, type MountAittyContainerOptions, type MountAittyOptions, type MountTerminalDependencies, type MountTerminalElements, type MountedTerminalApp, type TerminalConnectionState, type TerminalInputCallbacks, type TerminalKeyResolver, type TerminalLoadingPresentation, type TerminalOutputState, type TerminalScrollAdapter, type TerminalScrollAdapterContext, type TerminalScrollAdapterFactory, type TerminalScrollMetrics, type TerminalScrollOptions, type TerminalSessionPresentationState, type TerminalStatusListener, type TerminalStatusSnapshot, type TerminalTheme, type TerminalTransport, type TransportCloseEvent, type TransportHandlers, createAnsiStyleTracker, createBufferedTerminalWriter, defineAittyTerminalElement, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey, mountAitty, mountTerminalApp };

package/dist/browser.js

@@ -0,0 +1,5 @@
+import { createAnsiStyleTracker } from "./frontend/ansi-style-tracker.js";
+import { BrowserTerminalRenderer } from "./frontend/browser-terminal-renderer.js";
+import { installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey } from "./frontend/terminal-input-policies.js";
+import { createBufferedTerminalWriter, defineAittyTerminalElement, mountAitty, mountTerminalApp } from "./frontend/terminal-app.js";
+export { BrowserTerminalRenderer, createAnsiStyleTracker, createBufferedTerminalWriter, defineAittyTerminalElement, installTerminalInputPolicies, isBrowserSafeShortcut, isCompositionKeyDown, isContainedTerminalNavigationKey, mountAitty, mountTerminalApp };

package/dist/frontend/ansi-sequences.d.ts

@@ -0,0 +1,5 @@
+//#region src/frontend/ansi-sequences.d.ts
+declare function parseCsiParams(paramBuffer: string): number[];
+declare function nextAltScreenState(currentState: boolean, privateMarker: string, paramBuffer: string, finalByte: string): boolean;
+//#endregion
+export { nextAltScreenState, parseCsiParams };

package/dist/frontend/ansi-sequences.js

@@ -0,0 +1,17 @@
+//#region src/frontend/ansi-sequences.ts
+const ALT_SCREEN_PARAMS = new Set([
+	47,
+	1047,
+	1049
+]);
+function parseCsiParams(paramBuffer) {
+	if (!paramBuffer) return [];
+	return paramBuffer.split(/[;:]/).map((value) => Number(value)).filter((value) => !Number.isNaN(value));
+}
+function nextAltScreenState(currentState, privateMarker, paramBuffer, finalByte) {
+	if (privateMarker !== "?" || finalByte !== "h" && finalByte !== "l") return currentState;
+	if (!parseCsiParams(paramBuffer).some((value) => ALT_SCREEN_PARAMS.has(value))) return currentState;
+	return finalByte === "h";
+}
+//#endregion
+export { nextAltScreenState, parseCsiParams };

package/dist/frontend/ansi-style-tracker.d.ts

@@ -0,0 +1,37 @@
+//#region src/frontend/ansi-style-tracker.d.ts
+type NullableStyle = {
+  bg: string | null;
+  fg: string | null;
+};
+type StyleCell = (NullableStyle & {
+  displayStart?: number;
+  hidden?: boolean;
+  width?: number;
+}) | null;
+type CursorPosition = {
+  col: number;
+  row: number;
+};
+type AnsiStyleBridge = {
+  getCursor(): CursorPosition;
+  usingAltScreen(): boolean;
+};
+type AnsiStyleTracker = {
+  append(chunk: Uint8Array): void;
+  consumeRenderHints(): {
+    clearScreen: boolean;
+    styleChanged: boolean;
+  };
+  getGridOverride(row: number, col: number): StyleCell;
+  getScrollbackOverride(offset: number, col: number): StyleCell;
+  isAltScreenActive(): boolean;
+  reset(nextCols?: number, nextRows?: number): void;
+  resize(nextCols: number, nextRows: number): void;
+  syncFromBridge(bridge: AnsiStyleBridge | null | undefined): void;
+};
+declare function createAnsiStyleTracker(options?: {
+  cols?: number;
+  rows?: number;
+}): AnsiStyleTracker;
+//#endregion
+export { AnsiStyleBridge, AnsiStyleTracker, createAnsiStyleTracker };

package/dist/frontend/ansi-style-tracker.js

@@ -0,0 +1,435 @@
+import { nextAltScreenState, parseCsiParams } from "./ansi-sequences.js";
+import { cellWidthForCodePoint } from "./cell-width.js";
+//#region src/frontend/ansi-style-tracker.ts
+const ESC = "\x1B";
+function createBlankRow(cols) {
+	return Array.from({ length: cols }, () => null);
+}
+function cloneRow(row) {
+	return row.map((cell) => {
+		if (!cell) return null;
+		return {
+			bg: cell.bg ?? null,
+			displayStart: cell.displayStart,
+			fg: cell.fg ?? null,
+			hidden: cell.hidden,
+			width: cell.width
+		};
+	});
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function createBuffer(cols, rows) {
+	return {
+		cursor: {
+			col: 0,
+			displayCol: 0,
+			row: 0
+		},
+		rows: Array.from({ length: rows }, () => createBlankRow(cols)),
+		savedCursor: {
+			col: 0,
+			displayCol: 0,
+			row: 0
+		},
+		scrollback: []
+	};
+}
+function makeRgbCss(red, green, blue) {
+	return `rgb(${clamp(red, 0, 255)}, ${clamp(green, 0, 255)}, ${clamp(blue, 0, 255)})`;
+}
+function isPlainCharacter(character) {
+	return character >= " " && character !== "";
+}
+function createAnsiStyleTracker(options = {}) {
+	let cols = Math.max(1, options.cols ?? 80);
+	let rows = Math.max(1, options.rows ?? 24);
+	let mainBuffer = createBuffer(cols, rows);
+	let altBuffer = createBuffer(cols, rows);
+	let currentStyle = {
+		bg: null,
+		fg: null
+	};
+	let parserState = "text";
+	let csiPrivate = "";
+	let csiParams = "";
+	let decoder = new TextDecoder();
+	let useAltBuffer = false;
+	let renderHints = {
+		clearScreen: false,
+		styleChanged: false
+	};
+	const activeBuffer = () => useAltBuffer ? altBuffer : mainBuffer;
+	const clampCursor = (cursor) => {
+		cursor.row = clamp(cursor.row, 0, rows - 1);
+		cursor.col = clamp(cursor.col, 0, cols - 1);
+		cursor.displayCol = clamp(cursor.displayCol, 0, cols - 1);
+	};
+	const cellDisplayStart = (row, col) => row[col]?.displayStart ?? col;
+	const cellWidth = (row, col) => row[col]?.width ?? 1;
+	const makeCellState = (style, sourceCol, displayStart, width, hidden = false) => {
+		if (!hidden && style.fg === null && style.bg === null && displayStart === sourceCol && width === 1) return null;
+		return {
+			bg: style.bg,
+			displayStart,
+			fg: style.fg,
+			hidden,
+			width
+		};
+	};
+	const markCellHidden = (row, col) => {
+		const cell = row[col];
+		row[col] = {
+			bg: cell?.bg ?? null,
+			displayStart: cellDisplayStart(row, col),
+			fg: cell?.fg ?? null,
+			hidden: true,
+			width: cellWidth(row, col)
+		};
+	};
+	const hideCellsCoveredByDisplayRange = (row, displayStart, width, sourceCol) => {
+		const displayEnd = displayStart + width;
+		for (let col = 0; col < cols; col += 1) {
+			if (col === sourceCol) continue;
+			const cellStart = cellDisplayStart(row, col);
+			const cellEnd = cellStart + cellWidth(row, col);
+			if (cellStart < displayEnd && cellEnd > displayStart) markCellHidden(row, col);
+		}
+	};
+	const storeCellAtCursor = (width) => {
+		const buffer = activeBuffer();
+		const row = buffer.rows[buffer.cursor.row];
+		if (!row) return;
+		const displayStart = buffer.cursor.displayCol;
+		hideCellsCoveredByDisplayRange(row, displayStart, width, buffer.cursor.col);
+		row[buffer.cursor.col] = makeCellState(currentStyle, buffer.cursor.col, displayStart, width);
+	};
+	const scrollActiveBuffer = () => {
+		const buffer = activeBuffer();
+		const droppedRow = buffer.rows.shift() ?? createBlankRow(cols);
+		buffer.rows.push(createBlankRow(cols));
+		if (!useAltBuffer) mainBuffer.scrollback.unshift(cloneRow(droppedRow));
+	};
+	const moveCursorTo = (buffer, row, col) => {
+		buffer.cursor.row = clamp(row, 0, rows - 1);
+		buffer.cursor.col = clamp(col, 0, cols - 1);
+		buffer.cursor.displayCol = cellDisplayStart(buffer.rows[buffer.cursor.row] ?? [], buffer.cursor.col);
+	};
+	const advanceCursor = (width) => {
+		const buffer = activeBuffer();
+		if (buffer.cursor.col < cols - 1) {
+			buffer.cursor.col += 1;
+			buffer.cursor.displayCol = clamp(buffer.cursor.displayCol + width, 0, cols - 1);
+			return;
+		}
+		buffer.cursor.col = 0;
+		buffer.cursor.displayCol = 0;
+		if (buffer.cursor.row < rows - 1) {
+			buffer.cursor.row += 1;
+			return;
+		}
+		scrollActiveBuffer();
+	};
+	const clearRowRange = (rowIndex, startCol, endCol) => {
+		const row = activeBuffer().rows[rowIndex];
+		if (!row) return;
+		for (let index = startCol; index <= endCol; index += 1) row[index] = null;
+	};
+	const clearScreen = () => {
+		const buffer = activeBuffer();
+		buffer.rows = Array.from({ length: rows }, () => createBlankRow(cols));
+		renderHints.clearScreen = true;
+	};
+	const resetTerminalState = () => {
+		mainBuffer = createBuffer(cols, rows);
+		altBuffer = createBuffer(cols, rows);
+		currentStyle = {
+			bg: null,
+			fg: null
+		};
+		useAltBuffer = false;
+		renderHints.clearScreen = true;
+	};
+	const resizeRows = (buffer, nextRows) => {
+		if (nextRows === buffer.rows.length) return;
+		if (nextRows > buffer.rows.length) {
+			const missing = nextRows - buffer.rows.length;
+			buffer.rows = [...buffer.rows, ...Array.from({ length: missing }, () => createBlankRow(cols))];
+			return;
+		}
+		const removeCount = buffer.rows.length - nextRows;
+		const removedRows = buffer.rows.splice(0, removeCount);
+		if (buffer === mainBuffer) for (const row of removedRows) mainBuffer.scrollback.unshift(cloneRow(row));
+		moveCursorTo(buffer, Math.max(0, buffer.cursor.row - removeCount), buffer.cursor.col);
+	};
+	const resizeCols = (buffer, nextCols) => {
+		buffer.rows = buffer.rows.map((row) => {
+			if (nextCols === row.length) return row;
+			if (nextCols > row.length) return [...row, ...Array.from({ length: nextCols - row.length }, () => null)];
+			return row.slice(0, nextCols);
+		});
+		buffer.cursor.col = clamp(buffer.cursor.col, 0, nextCols - 1);
+		buffer.cursor.displayCol = clamp(buffer.cursor.displayCol, 0, nextCols - 1);
+		buffer.savedCursor.col = clamp(buffer.savedCursor.col, 0, nextCols - 1);
+		buffer.savedCursor.displayCol = clamp(buffer.savedCursor.displayCol, 0, nextCols - 1);
+	};
+	const setAltBuffer = (nextState) => {
+		if (nextState === useAltBuffer) return;
+		if (nextState) {
+			mainBuffer.savedCursor = { ...mainBuffer.cursor };
+			altBuffer = createBuffer(cols, rows);
+			useAltBuffer = true;
+			return;
+		}
+		useAltBuffer = false;
+		mainBuffer.cursor = { ...mainBuffer.savedCursor };
+	};
+	const handleSgr = (params) => {
+		const values = params.length === 0 ? [0] : params;
+		renderHints.styleChanged = true;
+		for (let index = 0; index < values.length; index += 1) {
+			const value = values[index] ?? 0;
+			if (value === 0) {
+				currentStyle = {
+					bg: null,
+					fg: null
+				};
+				continue;
+			}
+			if (value === 39 || value >= 30 && value <= 37 || value >= 90 && value <= 97) {
+				currentStyle.fg = null;
+				continue;
+			}
+			if (value === 49 || value >= 40 && value <= 47 || value >= 100 && value <= 107) {
+				currentStyle.bg = null;
+				continue;
+			}
+			if (value === 38 || value === 48) {
+				const target = value === 38 ? "fg" : "bg";
+				const mode = values[index + 1];
+				if (mode === 2 && index + 4 < values.length) {
+					currentStyle[target] = makeRgbCss(values[index + 2], values[index + 3], values[index + 4]);
+					index += 4;
+					continue;
+				}
+				if (mode === 5 && index + 2 < values.length) {
+					currentStyle[target] = null;
+					index += 2;
+				}
+			}
+		}
+	};
+	const handleEraseDisplay = (mode) => {
+		const buffer = activeBuffer();
+		if (mode === 2) {
+			clearScreen();
+			return;
+		}
+		if (mode === 0) {
+			clearRowRange(buffer.cursor.row, buffer.cursor.col, cols - 1);
+			for (let row = buffer.cursor.row + 1; row < rows; row += 1) clearRowRange(row, 0, cols - 1);
+			return;
+		}
+		if (mode === 1) {
+			for (let row = 0; row < buffer.cursor.row; row += 1) clearRowRange(row, 0, cols - 1);
+			clearRowRange(buffer.cursor.row, 0, buffer.cursor.col);
+		}
+	};
+	const handleEraseLine = (mode) => {
+		const cursor = activeBuffer().cursor;
+		if (mode === 2) {
+			clearRowRange(cursor.row, 0, cols - 1);
+			return;
+		}
+		if (mode === 1) {
+			clearRowRange(cursor.row, 0, cursor.col);
+			return;
+		}
+		clearRowRange(cursor.row, cursor.col, cols - 1);
+	};
+	const handleCsi = (finalByte) => {
+		const params = parseCsiParams(csiParams);
+		const buffer = activeBuffer();
+		setAltBuffer(nextAltScreenState(useAltBuffer, csiPrivate, csiParams, finalByte));
+		switch (finalByte) {
+			case "A":
+				moveCursorTo(buffer, buffer.cursor.row - Math.max(1, params[0] ?? 1), buffer.cursor.col);
+				break;
+			case "B":
+				moveCursorTo(buffer, buffer.cursor.row + Math.max(1, params[0] ?? 1), buffer.cursor.col);
+				break;
+			case "C":
+				moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col + Math.max(1, params[0] ?? 1));
+				break;
+			case "D":
+				moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col - Math.max(1, params[0] ?? 1));
+				break;
+			case "G":
+				moveCursorTo(buffer, buffer.cursor.row, (params[0] ?? 1) - 1);
+				break;
+			case "H":
+			case "f":
+				moveCursorTo(buffer, (params[0] ?? 1) - 1, (params[1] ?? 1) - 1);
+				break;
+			case "J":
+				handleEraseDisplay(params[0] ?? 0);
+				break;
+			case "K":
+				handleEraseLine(params[0] ?? 0);
+				break;
+			case "m":
+				handleSgr(params);
+				break;
+			case "s":
+				buffer.savedCursor = { ...buffer.cursor };
+				break;
+			case "u":
+				buffer.cursor = { ...buffer.savedCursor };
+				break;
+			default: break;
+		}
+	};
+	const writeCharacter = (character) => {
+		const width = cellWidthForCodePoint(character.codePointAt(0) ?? 32);
+		storeCellAtCursor(width);
+		advanceCursor(width);
+	};
+	const processTextCharacter = (character) => {
+		const buffer = activeBuffer();
+		if (character === ESC) {
+			parserState = "escape";
+			return;
+		}
+		if (character === "\b") {
+			moveCursorTo(buffer, buffer.cursor.row, buffer.cursor.col - 1);
+			return;
+		}
+		if (character === "\n") {
+			if (buffer.cursor.row < rows - 1) buffer.cursor.row += 1;
+			else scrollActiveBuffer();
+			return;
+		}
+		if (character === "\r") {
+			buffer.cursor.col = 0;
+			buffer.cursor.displayCol = 0;
+			return;
+		}
+		if (character === "	") {
+			const nextTabStop = (Math.floor(buffer.cursor.displayCol / 8) + 1) * 8;
+			moveCursorTo(buffer, buffer.cursor.row, nextTabStop);
+			return;
+		}
+		if (!isPlainCharacter(character)) return;
+		writeCharacter(character);
+	};
+	const appendText = (text) => {
+		for (const character of text) {
+			if (parserState === "escape") {
+				if (character === "[") {
+					parserState = "csi";
+					csiPrivate = "";
+					csiParams = "";
+					continue;
+				}
+				if (character === "]") {
+					parserState = "osc";
+					continue;
+				}
+				if (character === "7") activeBuffer().savedCursor = { ...activeBuffer().cursor };
+				else if (character === "8") activeBuffer().cursor = { ...activeBuffer().savedCursor };
+				else if (character === "c") resetTerminalState();
+				parserState = "text";
+				continue;
+			}
+			if (parserState === "csi") {
+				if ((character === "?" || character === ">" || character === "!") && csiParams.length === 0) {
+					csiPrivate = character;
+					continue;
+				}
+				if (character >= "0" && character <= "9" || character === ";" || character === ":") {
+					csiParams += character;
+					continue;
+				}
+				if (character >= "@" && character <= "~") {
+					handleCsi(character);
+					parserState = "text";
+				}
+				continue;
+			}
+			if (parserState === "osc") {
+				if (character === "\x07") {
+					parserState = "text";
+					continue;
+				}
+				if (character === ESC) parserState = "osc_escape";
+				continue;
+			}
+			if (parserState === "osc_escape") {
+				parserState = character === "\\" ? "text" : "osc";
+				continue;
+			}
+			processTextCharacter(character);
+		}
+	};
+	return {
+		append(chunk) {
+			appendText(decoder.decode(chunk, { stream: true }));
+		},
+		getGridOverride(row, col) {
+			return activeBuffer().rows[row]?.[col] ?? null;
+		},
+		getScrollbackOverride(offset, col) {
+			return mainBuffer.scrollback[offset]?.[col] ?? null;
+		},
+		isAltScreenActive() {
+			return useAltBuffer;
+		},
+		reset(nextCols = cols, nextRows = rows) {
+			cols = Math.max(1, nextCols);
+			rows = Math.max(1, nextRows);
+			mainBuffer = createBuffer(cols, rows);
+			altBuffer = createBuffer(cols, rows);
+			currentStyle = {
+				bg: null,
+				fg: null
+			};
+			parserState = "text";
+			renderHints.clearScreen = false;
+			csiPrivate = "";
+			csiParams = "";
+			decoder = new TextDecoder();
+			useAltBuffer = false;
+		},
+		resize(nextCols, nextRows) {
+			cols = Math.max(1, nextCols);
+			rows = Math.max(1, nextRows);
+			resizeCols(mainBuffer, cols);
+			resizeCols(altBuffer, cols);
+			resizeRows(mainBuffer, rows);
+			resizeRows(altBuffer, rows);
+			clampCursor(mainBuffer.cursor);
+			clampCursor(mainBuffer.savedCursor);
+			clampCursor(altBuffer.cursor);
+			clampCursor(altBuffer.savedCursor);
+		},
+		syncFromBridge(bridge) {
+			if (!bridge) return;
+			useAltBuffer = bridge.usingAltScreen();
+			const cursor = bridge.getCursor();
+			const buffer = activeBuffer();
+			buffer.cursor.row = clamp(cursor.row, 0, rows - 1);
+			buffer.cursor.col = clamp(cursor.col, 0, cols - 1);
+		},
+		consumeRenderHints() {
+			const nextHints = renderHints;
+			renderHints = {
+				clearScreen: false,
+				styleChanged: false
+			};
+			return nextHints;
+		}
+	};
+}
+//#endregion
+export { createAnsiStyleTracker };

package/dist/frontend/browser-terminal-renderer.d.ts

@@ -0,0 +1,86 @@
+//#region src/frontend/browser-terminal-renderer.d.ts
+type TerminalCell = {
+  bg: number;
+  char: number;
+  fg: number;
+  flags: number;
+};
+type TerminalCursor = {
+  col: number;
+  row: number;
+  visible: boolean;
+};
+type BrowserTerminalBridge = {
+  bracketedPaste?(): boolean;
+  clearDirty(): void;
+  cursorKeysApp?(): boolean;
+  getCell(row: number, col: number): TerminalCell;
+  getCols(): number;
+  getCursor(): TerminalCursor;
+  getRows(): number;
+  getScrollbackCell(offset: number, col: number): TerminalCell;
+  getScrollbackCount(): number;
+  getScrollbackLineLen(offset: number): number;
+  init?(cols: number, rows: number): void;
+  isDirtyRow(row: number): boolean;
+  usingAltScreen(): boolean;
+};
+type BrowserTerminalStyleOverride = {
+  bg?: string | null;
+  fg?: string | null;
+  hidden?: boolean;
+} | null;
+type BrowserTerminalStyleTracker = {
+  getGridOverride(row: number, col: number): BrowserTerminalStyleOverride;
+  getScrollbackOverride(offset: number, col: number): BrowserTerminalStyleOverride;
+};
+type BrowserTerminalRenderOptions = {
+  force?: boolean;
+};
+type SnapshotRow = {
+  element: HTMLElement;
+  text: string;
+};
+type GetCell = (col: number) => TerminalCell;
+type GetOverride = (col: number) => BrowserTerminalStyleOverride;
+declare class BrowserTerminalRenderer {
+  private _altScreenMeaningfulScrollbackCount;
+  private _altScreenVisibleRowSnapshot;
+  private _lastAltScreenState;
+  private _renderedScrollbackCount;
+  private _restoreSnapshotCount;
+  private _scrollbackRowEls;
+  cols: number;
+  container: HTMLElement;
+  prevContainerBg: string;
+  prevCursorCol: number;
+  prevCursorRow: number;
+  prevCursorVisible: boolean;
+  prevRowBg: string[];
+  rowEls: HTMLElement[];
+  rows: number;
+  styleTracker: BrowserTerminalStyleTracker;
+  constructor(container: HTMLElement, styleTracker: BrowserTerminalStyleTracker);
+  _resolveFirstLiveGridRow(): HTMLElement | null;
+  _insertScrollbackFragment(fragment: DocumentFragment): void;
+  setup(cols: number, rows: number): void;
+  _buildRowContent(rowEl: HTMLElement, getCell: GetCell, getOverride: GetOverride, lineLen: number, cursorCol: number, rowIndex: number): void;
+  _buildScrollbackRowEl(bridge: BrowserTerminalBridge, offset: number): HTMLElement;
+  _captureVisibleRowSnapshot(): void;
+  _clearAltScreenRestoreSnapshot(): void;
+  _readGridRowText(bridge: BrowserTerminalBridge, row: number): string;
+  getVisibleRowTexts(bridge: BrowserTerminalBridge, {
+    trimPadding
+  }?: {
+    trimPadding?: boolean;
+  }): string[];
+  _readScrollbackRowText(bridge: BrowserTerminalBridge, offset: number): string;
+  _readLiveTranscriptRows(bridge: BrowserTerminalBridge, currentVisibleRows: string[]): string[];
+  _liveTranscriptContainsSnapshots(bridge: BrowserTerminalBridge, snapshots: SnapshotRow[], currentVisibleRows: string[]): boolean;
+  _getRestoredScrollbackSnapshots(bridge: BrowserTerminalBridge): SnapshotRow[];
+  _rebuildScrollback(bridge: BrowserTerminalBridge, restoredSnapshots: SnapshotRow[]): void;
+  syncScrollback(bridge: BrowserTerminalBridge, restoredSnapshots?: SnapshotRow[]): void;
+  render(bridge: BrowserTerminalBridge, options?: BrowserTerminalRenderOptions): void;
+}
+//#endregion
+export { BrowserTerminalBridge, BrowserTerminalRenderOptions, BrowserTerminalRenderer, BrowserTerminalStyleOverride, BrowserTerminalStyleTracker };