@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/create-terminal-C2oiWFJU.js

@@ -0,0 +1,1434 @@
+import { charCellWidth, segmentedGraphemes } from "./hyperlink-Bn02UXJb.js";
+import { parseAnsiSgr } from "./sgr-BmzxEjAO.js";
+
+//#region src/core/render-plane.ts
+const TERMINAL_RENDER_PLANES = [
+	"default",
+	"transcript",
+	"chrome",
+	"overlay"
+];
+
+//#endregion
+//#region src/core/buffer/buffer.ts
+const DEFAULT_STYLE = Object.freeze({});
+const styleCache = new WeakMap();
+const blankCellCache = new WeakMap();
+const continuationCellCache = new WeakMap();
+const cellCacheWidth1 = new WeakMap();
+const cellCacheWidth2 = new WeakMap();
+const MAX_CACHED_CELLS_PER_STYLE = 128;
+function normalizeStyle(style) {
+	if (!style) return DEFAULT_STYLE;
+	if (Object.isFrozen(style)) return style;
+	const cached = styleCache.get(style);
+	if (cached) return cached;
+	const frozen = Object.freeze({ ...style });
+	styleCache.set(style, frozen);
+	return frozen;
+}
+function getOrCreateCellCache(map, style) {
+	const cached = map.get(style);
+	if (cached) return cached;
+	const next = new Map();
+	map.set(style, next);
+	return next;
+}
+function createCell(ch, style, widthProvider) {
+	if (ch === " ") return createBlankCell(style);
+	const normalizedStyle = normalizeStyle(style);
+	const width = charCellWidth(ch, widthProvider);
+	const map = width === 2 ? getOrCreateCellCache(cellCacheWidth2, normalizedStyle) : getOrCreateCellCache(cellCacheWidth1, normalizedStyle);
+	const cached = map.get(ch);
+	if (cached) return cached;
+	const cell = {
+		ch,
+		width,
+		style: normalizedStyle
+	};
+	map.set(ch, cell);
+	if (map.size > MAX_CACHED_CELLS_PER_STYLE) map.clear();
+	return cell;
+}
+function createBlankCell(style) {
+	const normalizedStyle = normalizeStyle(style);
+	const cached = blankCellCache.get(normalizedStyle);
+	if (cached) return cached;
+	const cell = Object.freeze({
+		ch: " ",
+		width: 1,
+		style: normalizedStyle
+	});
+	blankCellCache.set(normalizedStyle, cell);
+	return cell;
+}
+function createContinuationCell(style) {
+	const normalizedStyle = normalizeStyle(style);
+	const cached = continuationCellCache.get(normalizedStyle);
+	if (cached) return cached;
+	const cell = Object.freeze({
+		ch: "",
+		width: 1,
+		continuation: true,
+		style: normalizedStyle
+	});
+	continuationCellCache.set(normalizedStyle, cell);
+	return cell;
+}
+function createGridBuffer(cols, rows, options = {}) {
+	const safeCols = Math.max(0, Math.floor(cols));
+	const safeRows = Math.max(0, Math.floor(rows));
+	const blank = createBlankCell();
+	const grid = Array.from({ length: safeRows }, () => Array.from({ length: safeCols }, () => blank));
+	return {
+		cols: safeCols,
+		rows: safeRows,
+		grid,
+		gridStart: 0,
+		dirtyBits: new Uint8Array(safeRows),
+		dirtyCount: safeRows || 0,
+		dirtyMin: safeRows ? 0 : Number.POSITIVE_INFINITY,
+		dirtyMax: safeRows ? safeRows - 1 : -1,
+		dirtyAll: safeRows > 0,
+		cursorX: 0,
+		cursorY: 0,
+		cursorVisible: true,
+		cursorStyle: DEFAULT_STYLE,
+		scrollback: [],
+		scrollbackLimit: 1e3,
+		rowPool: [],
+		soaFingerprints: null,
+		fingerprintFn: null,
+		widthProvider: options.widthProvider ?? "default"
+	};
+}
+function clamp(n, min, max) {
+	return Math.max(min, Math.min(max, n));
+}
+/**
+* Register a fingerprint function on the buffer. This enables SoA fingerprint
+* pre-computation: cell writes will update fingerprints inline, and the renderer
+* can read them via getRowFingerprints() instead of per-cell hash computation.
+*/
+function setFingerprintFn(buffer, fn) {
+	buffer.fingerprintFn = fn;
+	const len = buffer.rows * buffer.cols;
+	if (!len) {
+		buffer.soaFingerprints = null;
+		return;
+	}
+	buffer.soaFingerprints = new Uint32Array(len);
+	for (let y = 0; y < buffer.rows; y++) {
+		const row = getBufferRow(buffer, y);
+		const physY = physicalRowIndex(buffer, y);
+		const base = physY * buffer.cols;
+		for (let x = 0; x < buffer.cols; x++) {
+			const cell = row[x];
+			buffer.soaFingerprints[base + x] = fn(cell.ch, cell.style);
+		}
+	}
+}
+/**
+* Get pre-computed fingerprints for a logical row as a TypedArray slice.
+* Returns null if fingerprinting is not enabled on this buffer.
+*/
+function getRowFingerprints(buffer, y) {
+	if (!buffer.soaFingerprints) return null;
+	const physY = physicalRowIndex(buffer, y);
+	const base = physY * buffer.cols;
+	return buffer.soaFingerprints.subarray(base, base + buffer.cols);
+}
+/** Update the SoA fingerprint for a single cell (called inline from putCell/fillRect). */
+function updateCellFingerprint(buffer, physY, x, ch, style) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	buffer.soaFingerprints[physY * buffer.cols + x] = buffer.fingerprintFn(ch, style);
+}
+/** Update SoA fingerprints for a range of cells in a physical row. */
+function updateRangeFingerprint(buffer, physY, x0, x1, ch, style) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	const fp = buffer.fingerprintFn(ch, style);
+	const base = physY * buffer.cols;
+	for (let x = x0; x < x1; x++) buffer.soaFingerprints[base + x] = fp;
+}
+function physicalRowIndex(buffer, y) {
+	return (buffer.gridStart + y) % buffer.rows;
+}
+function getBufferRow(buffer, y) {
+	return buffer.grid[physicalRowIndex(buffer, y)];
+}
+function getBufferCell(buffer, x, y) {
+	return getBufferRow(buffer, y)[x];
+}
+function markAllDirty(buffer) {
+	if (buffer.rows <= 0) return;
+	buffer.dirtyAll = true;
+	buffer.dirtyCount = buffer.rows;
+	buffer.dirtyMin = 0;
+	buffer.dirtyMax = buffer.rows - 1;
+}
+function markDirty(buffer, y) {
+	if (buffer.dirtyAll) return;
+	if (y < 0 || y >= buffer.rows) return;
+	if (buffer.dirtyBits[y]) return;
+	buffer.dirtyBits[y] = 1;
+	buffer.dirtyCount++;
+	if (y < buffer.dirtyMin) buffer.dirtyMin = y;
+	if (y > buffer.dirtyMax) buffer.dirtyMax = y;
+}
+function clearCellRange(row, startX, endXExclusive) {
+	const blank = createBlankCell();
+	for (let x = startX; x < endXExclusive; x++) row[x] = blank;
+}
+function clearWideIfOverwriting(row, x) {
+	const cell = row[x];
+	if (!cell) return;
+	if (cell.continuation) {
+		if (x - 1 >= 0) row[x - 1] = createBlankCell();
+		row[x] = createBlankCell();
+		return;
+	}
+	if (cell.width === 2) {
+		row[x] = createBlankCell();
+		if (x + 1 < row.length) row[x + 1] = createBlankCell();
+	}
+}
+function putCell(buffer, x, y, ch, style) {
+	if (y < 0 || y >= buffer.rows) return;
+	if (x < 0 || x >= buffer.cols) return;
+	const row = getBufferRow(buffer, y);
+	const width = charCellWidth(ch, buffer.widthProvider);
+	const previous = row[x];
+	const next = width === 2 && x + 1 < buffer.cols ? row[x + 1] : void 0;
+	const previousWideOverlap = Boolean(previous?.continuation || previous?.width === 2 || next?.continuation || next?.width === 2);
+	clearWideIfOverwriting(row, x);
+	if (width === 2 && x + 1 < buffer.cols) clearWideIfOverwriting(row, x + 1);
+	if (width === 2 && x + 1 >= buffer.cols) {
+		const blank = createBlankCell();
+		row[x] = blank;
+		if (buffer.soaFingerprints) if (previousWideOverlap) recomputeFingerprintsForRows(buffer, y, y + 1);
+		else {
+			const physY = physicalRowIndex(buffer, y);
+			updateCellFingerprint(buffer, physY, x, blank.ch, blank.style);
+		}
+		markDirty(buffer, y);
+		return;
+	}
+	const cell = createCell(ch, style, buffer.widthProvider);
+	row[x] = cell;
+	if (width === 2 && x + 1 < buffer.cols) row[x + 1] = createContinuationCell(style);
+	if (buffer.soaFingerprints) if (previousWideOverlap) recomputeFingerprintsForRows(buffer, y, y + 1);
+	else {
+		const physY = physicalRowIndex(buffer, y);
+		updateCellFingerprint(buffer, physY, x, cell.ch, cell.style);
+		if (width === 2 && x + 1 < buffer.cols) updateCellFingerprint(buffer, physY, x + 1, "", cell.style);
+	}
+	markDirty(buffer, y);
+}
+function fillRect(buffer, x, y, w, h, ch = " ", style) {
+	if (w <= 0 || h <= 0 || buffer.cols === 0 || buffer.rows === 0) return;
+	const x0 = clamp(Math.floor(x), 0, buffer.cols);
+	const y0 = clamp(Math.floor(y), 0, buffer.rows);
+	const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
+	const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+	if (x1 <= x0 || y1 <= y0) return;
+	const width = charCellWidth(ch, buffer.widthProvider);
+	if (width === 1) {
+		const fillCell$1 = createCell(ch, style, buffer.widthProvider);
+		const blank$1 = createBlankCell();
+		for (let yy = y0; yy < y1; yy++) {
+			const row = getBufferRow(buffer, yy);
+			const clearsLeftWideBase = Boolean(row[x0]?.continuation);
+			const clearsRightContinuation = Boolean(x1 < buffer.cols && row[x1]?.continuation);
+			if (clearsLeftWideBase) clearWideIfOverwriting(row, x0);
+			row.fill(fillCell$1, x0, x1);
+			if (clearsRightContinuation) row[x1] = blank$1;
+			if (buffer.soaFingerprints) if (clearsLeftWideBase || clearsRightContinuation) recomputeFingerprintsForRows(buffer, yy, yy + 1);
+			else {
+				const physY = physicalRowIndex(buffer, yy);
+				updateRangeFingerprint(buffer, physY, x0, x1, fillCell$1.ch, fillCell$1.style);
+			}
+			markDirty(buffer, yy);
+		}
+		return;
+	}
+	const fillCell = createCell(ch, style, buffer.widthProvider);
+	const continuationCell = createContinuationCell(style);
+	const blank = createBlankCell();
+	for (let yy = y0; yy < y1; yy++) {
+		const row = getBufferRow(buffer, yy);
+		for (let xx = x0; xx < x1;) {
+			clearWideIfOverwriting(row, xx);
+			if (xx + 1 >= x1 || xx + 1 >= buffer.cols) {
+				row[xx] = blank;
+				xx += 1;
+				continue;
+			}
+			clearWideIfOverwriting(row, xx + 1);
+			row[xx] = fillCell;
+			row[xx + 1] = continuationCell;
+			xx += 2;
+		}
+		recomputeFingerprintsForRows(buffer, yy, yy + 1);
+		markDirty(buffer, yy);
+	}
+}
+function clearRect(buffer, x, y, w, h) {
+	if (buffer.cols === 0 || buffer.rows === 0) return;
+	if (x == null || y == null || w == null || h == null) {
+		const blank = createBlankCell();
+		for (let yy = 0; yy < buffer.rows; yy++) {
+			const row = getBufferRow(buffer, yy);
+			row.length = buffer.cols;
+			for (let xx = 0; xx < buffer.cols; xx++) row[xx] = blank;
+		}
+		recomputeFingerprintsForRows(buffer, 0, buffer.rows);
+		markAllDirty(buffer);
+		buffer.cursorX = 0;
+		buffer.cursorY = 0;
+		return;
+	}
+	if (w <= 0 || h <= 0) return;
+	const x0 = clamp(Math.floor(x), 0, buffer.cols);
+	const y0 = clamp(Math.floor(y), 0, buffer.rows);
+	const x1 = clamp(Math.floor(x + w), 0, buffer.cols);
+	const y1 = clamp(Math.floor(y + h), 0, buffer.rows);
+	if (x1 <= x0 || y1 <= y0) return;
+	for (let yy = y0; yy < y1; yy++) {
+		const row = getBufferRow(buffer, yy);
+		if (row[x0]?.continuation) clearWideIfOverwriting(row, x0);
+		clearCellRange(row, x0, x1);
+		if (x1 < buffer.cols && row[x1]?.continuation) row[x1] = createBlankCell();
+		recomputeFingerprintsForRows(buffer, yy, yy + 1);
+		markDirty(buffer, yy);
+	}
+}
+function takePooledRow(buffer) {
+	const row = buffer.rowPool.pop();
+	return row ?? null;
+}
+function blankRow(buffer) {
+	const pooled = takePooledRow(buffer);
+	if (!pooled) return Array.from({ length: buffer.cols }, () => createBlankCell());
+	pooled.length = buffer.cols;
+	const blank = createBlankCell();
+	for (let x = 0; x < buffer.cols; x++) pooled[x] = blank;
+	return pooled;
+}
+function recomputeFingerprintsForRows(buffer, startY, endY) {
+	if (!buffer.soaFingerprints || !buffer.fingerprintFn) return;
+	for (let y = startY; y < endY; y++) {
+		const row = getBufferRow(buffer, y);
+		const physY = physicalRowIndex(buffer, y);
+		const base = physY * buffer.cols;
+		for (let x = 0; x < buffer.cols; x++) {
+			const cell = row[x];
+			buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+		}
+	}
+}
+function recomputeAllVisibleFingerprints(buffer) {
+	recomputeFingerprintsForRows(buffer, 0, buffer.rows);
+}
+function scrollBuffer(buffer, lines) {
+	const raw = Math.trunc(lines);
+	if (raw === 0 || buffer.rows === 0) return;
+	const abs = Math.min(Math.abs(raw), buffer.rows);
+	const n = raw > 0 ? abs : -abs;
+	if (n > 0) for (let i = 0; i < n; i++) {
+		const removedIdx = buffer.gridStart;
+		const removed = buffer.grid[removedIdx];
+		if (buffer.scrollbackLimit > 0) {
+			buffer.scrollback.push(removed);
+			if (buffer.scrollback.length > buffer.scrollbackLimit) {
+				const excess = buffer.scrollback.length - buffer.scrollbackLimit;
+				const dropped = buffer.scrollback.splice(0, excess);
+				buffer.rowPool.push(...dropped);
+			}
+		} else buffer.rowPool.push(removed);
+		buffer.gridStart = (buffer.gridStart + 1) % buffer.rows;
+		const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
+		buffer.grid[bottomIdx] = blankRow(buffer);
+	}
+	else for (let i = 0; i < -n; i++) {
+		const bottomIdx = (buffer.gridStart + buffer.rows - 1) % buffer.rows;
+		const removed = buffer.grid[bottomIdx];
+		buffer.rowPool.push(removed);
+		buffer.gridStart = (buffer.gridStart - 1 + buffer.rows) % buffer.rows;
+		buffer.grid[buffer.gridStart] = blankRow(buffer);
+	}
+	const inserted = Math.abs(n);
+	if (inserted >= buffer.rows) recomputeAllVisibleFingerprints(buffer);
+	else if (n > 0) recomputeFingerprintsForRows(buffer, buffer.rows - inserted, buffer.rows);
+	else recomputeFingerprintsForRows(buffer, 0, inserted);
+	markAllDirty(buffer);
+	buffer.cursorY = clamp(buffer.cursorY - n, 0, Math.max(0, buffer.rows - 1));
+}
+function scrollBufferRegion(buffer, startY, endY, lines) {
+	const n = Math.trunc(lines);
+	if (n === 0 || buffer.rows === 0) return [];
+	const start = clamp(Math.floor(startY), 0, buffer.rows);
+	const end = clamp(Math.floor(endY), 0, buffer.rows);
+	const height = end - start;
+	if (height <= 0) return [];
+	const absDelta = Math.abs(n);
+	const insertedRows = [];
+	const replaceRegionWithBlankRows = () => {
+		for (let y = start; y < end; y++) {
+			const physY = physicalRowIndex(buffer, y);
+			buffer.rowPool.push(buffer.grid[physY]);
+			buffer.grid[physY] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+	};
+	if (absDelta >= height) {
+		replaceRegionWithBlankRows();
+		recomputeFingerprintsForRows(buffer, start, end);
+		if (buffer.cursorY >= start && buffer.cursorY < end) buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+		return insertedRows;
+	}
+	const regionRows = [];
+	for (let y = start; y < end; y++) regionRows.push(getBufferRow(buffer, y));
+	const nextRows = Array.from({ length: height }, () => []);
+	if (n > 0) {
+		const movedCount = height - n;
+		for (let i = 0; i < movedCount; i++) nextRows[i] = regionRows[i + n];
+		for (let i = 0; i < n; i++) {
+			buffer.rowPool.push(regionRows[i]);
+			const y = end - n + i;
+			nextRows[movedCount + i] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+	} else {
+		const insertedCount = -n;
+		const movedCount = height - insertedCount;
+		for (let i = 0; i < insertedCount; i++) {
+			buffer.rowPool.push(regionRows[height - insertedCount + i]);
+			const y = start + i;
+			nextRows[i] = blankRow(buffer);
+			markDirty(buffer, y);
+			insertedRows.push(y);
+		}
+		for (let i = 0; i < movedCount; i++) nextRows[insertedCount + i] = regionRows[i];
+	}
+	for (let i = 0; i < height; i++) {
+		const physY = physicalRowIndex(buffer, start + i);
+		buffer.grid[physY] = nextRows[i];
+	}
+	recomputeFingerprintsForRows(buffer, start, end);
+	if (buffer.cursorY >= start && buffer.cursorY < end) buffer.cursorY = clamp(buffer.cursorY - n, start, Math.max(start, end - 1));
+	return insertedRows;
+}
+function resizeBuffer(buffer, cols, rows) {
+	const nextCols = Math.max(0, Math.floor(cols));
+	const nextRows = Math.max(0, Math.floor(rows));
+	if (nextCols === buffer.cols && nextRows === buffer.rows) return;
+	const blank = createBlankCell();
+	const nextGrid = Array.from({ length: nextRows }, () => Array.from({ length: nextCols }, () => blank));
+	const copyRows = Math.min(buffer.rows, nextRows);
+	const copyCols = Math.min(buffer.cols, nextCols);
+	for (let y = 0; y < copyRows; y++) {
+		const src = getBufferRow(buffer, y);
+		const dst = nextGrid[y];
+		for (let x = 0; x < copyCols; x++) dst[x] = src[x];
+	}
+	if (nextCols > 0) for (let y = 0; y < nextGrid.length; y++) {
+		const row = nextGrid[y];
+		for (let x = 0; x < nextCols; x++) {
+			const cell = row[x];
+			if (cell.continuation) {
+				if (x === 0 || row[x - 1]?.width !== 2 || row[x - 1]?.continuation) row[x] = blank;
+				continue;
+			}
+			if (cell.width === 2 && (x + 1 >= nextCols || !row[x + 1]?.continuation)) row[x] = blank;
+		}
+	}
+	for (let y = 0; y < buffer.rows; y++) buffer.rowPool.push(getBufferRow(buffer, y));
+	buffer.grid = nextGrid;
+	buffer.gridStart = 0;
+	buffer.cols = nextCols;
+	buffer.rows = nextRows;
+	buffer.dirtyBits = new Uint8Array(nextRows);
+	buffer.dirtyCount = nextRows || 0;
+	buffer.dirtyMin = nextRows ? 0 : Number.POSITIVE_INFINITY;
+	buffer.dirtyMax = nextRows ? nextRows - 1 : -1;
+	buffer.dirtyAll = nextRows > 0;
+	buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
+	buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
+	if (buffer.fingerprintFn) {
+		const len = nextRows * nextCols;
+		if (len > 0) {
+			buffer.soaFingerprints = new Uint32Array(len);
+			for (let y = 0; y < nextRows; y++) {
+				const row = nextGrid[y];
+				const base = y * nextCols;
+				for (let x = 0; x < nextCols; x++) {
+					const cell = row[x];
+					buffer.soaFingerprints[base + x] = buffer.fingerprintFn(cell.ch, cell.style);
+				}
+			}
+		} else buffer.soaFingerprints = null;
+	}
+}
+function snapshotText(buffer) {
+	const out = [];
+	for (let y = 0; y < buffer.rows; y++) {
+		const row = getBufferRow(buffer, y);
+		out.push(row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
+	}
+	return out;
+}
+
+//#endregion
+//#region src/core/terminal/emitter.ts
+const emitterListeners = new WeakMap();
+var Emitter = class {
+	constructor() {
+		emitterListeners.set(this, new Map());
+	}
+	getListeners() {
+		return emitterListeners.get(this);
+	}
+	on(event, cb) {
+		const listeners = this.getListeners();
+		let set = listeners.get(event);
+		if (!set) {
+			set = new Set();
+			listeners.set(event, set);
+		}
+		set.add(cb);
+		return () => {
+			set.delete(cb);
+			if (set.size === 0) listeners.delete(event);
+		};
+	}
+	emit(event, payload) {
+		const set = this.getListeners().get(event);
+		if (!set) return;
+		for (const cb of set) cb(payload);
+	}
+	clear() {
+		this.getListeners().clear();
+	}
+};
+
+//#endregion
+//#region src/core/terminal/create-terminal.ts
+function isControlChar(ch) {
+	return ch === "\n" || ch === "\r" || ch === "	";
+}
+function mergePlanes(prev, next) {
+	if (!prev?.length) return next?.length ? [...next] : null;
+	if (!next?.length) return prev;
+	const merged = new Set(prev);
+	for (const plane of next) merged.add(plane);
+	return Array.from(merged);
+}
+const TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals");
+function createCoverage(cols, rows) {
+	return Array.from({ length: rows }, () => new Uint8Array(cols));
+}
+function resizeCoverage(prev, cols, rows) {
+	const next = createCoverage(cols, rows);
+	const copyRows = Math.min(prev.length, rows);
+	for (let y = 0; y < copyRows; y++) {
+		const src = prev[y];
+		const dst = next[y];
+		dst.set(src.subarray(0, Math.min(src.length, cols)));
+	}
+	return next;
+}
+function setBufferClean(buffer) {
+	buffer.dirtyBits.fill(0);
+	buffer.dirtyCount = 0;
+	buffer.dirtyMin = Number.POSITIVE_INFINITY;
+	buffer.dirtyMax = -1;
+	buffer.dirtyAll = false;
+}
+function createPlaneState(cols, rows, widthProvider) {
+	const buffer = createGridBuffer(cols, rows, { widthProvider });
+	setBufferClean(buffer);
+	buffer.cursorVisible = false;
+	return {
+		buffer,
+		coverage: createCoverage(cols, rows)
+	};
+}
+function collectAndClearDirtyRows(buffer) {
+	if (buffer.rows === 0) return [];
+	if (buffer.dirtyAll) {
+		buffer.dirtyAll = false;
+		buffer.dirtyBits.fill(0);
+		buffer.dirtyCount = 0;
+		buffer.dirtyMin = Number.POSITIVE_INFINITY;
+		buffer.dirtyMax = -1;
+		return null;
+	}
+	if (buffer.dirtyCount === 0) return [];
+	const out = [];
+	const start = Math.max(0, buffer.dirtyMin);
+	const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+	for (let y = start; y <= end; y++) if (buffer.dirtyBits[y]) {
+		buffer.dirtyBits[y] = 0;
+		out.push(y);
+		if (out.length === buffer.dirtyCount) break;
+	}
+	buffer.dirtyCount = 0;
+	buffer.dirtyMin = Number.POSITIVE_INFINITY;
+	buffer.dirtyMax = -1;
+	return out;
+}
+function peekDirtyRows(buffer) {
+	if (buffer.rows === 0) return [];
+	if (buffer.dirtyAll) return null;
+	if (buffer.dirtyCount === 0) return [];
+	const out = [];
+	const start = Math.max(0, buffer.dirtyMin);
+	const end = Math.min(buffer.rows - 1, buffer.dirtyMax);
+	for (let y = start; y <= end; y++) if (buffer.dirtyBits[y]) {
+		out.push(y);
+		if (out.length === buffer.dirtyCount) break;
+	}
+	return out;
+}
+function clearPlaneCoverageRow(state, y) {
+	if (y < 0 || y >= state.buffer.rows) return;
+	const row = getBufferRow(state.buffer, y);
+	const blank = createBlankCell();
+	row.length = state.buffer.cols;
+	for (let x = 0; x < state.buffer.cols; x++) row[x] = blank;
+	state.coverage[y]?.fill(0);
+	markDirty(state.buffer, y);
+}
+function markPlaneCoverageRange(state, x0, y0, x1, y1, value) {
+	for (let y = y0; y < y1; y++) {
+		const row = state.coverage[y];
+		if (!row) continue;
+		row.fill(value, x0, x1);
+	}
+}
+function markPlaneCoverageForPut(state, x, y, ch, prevCell) {
+	const row = state.coverage[y];
+	if (!row) return;
+	if (prevCell?.continuation && x > 0) row[x - 1] = 1;
+	if (prevCell?.width === 2 && x + 1 < row.length) row[x + 1] = 1;
+	row[x] = 1;
+	if (ch !== " " && x + 1 < row.length) {
+		const next = getBufferCell(state.buffer, x, y);
+		if (next.width === 2) row[x + 1] = 1;
+	}
+}
+function scrollPlaneCoverage(state, lines) {
+	const n = Math.trunc(lines);
+	if (n === 0 || state.coverage.length === 0) return;
+	const rows = state.coverage.length;
+	const cols = state.buffer.cols;
+	if (Math.abs(n) >= rows) {
+		for (const row of state.coverage) row.fill(0);
+		return;
+	}
+	if (n > 0) {
+		state.coverage.splice(0, n);
+		for (let i = 0; i < n; i++) state.coverage.push(new Uint8Array(cols));
+		return;
+	}
+	state.coverage.splice(rows + n, -n);
+	for (let i = 0; i < -n; i++) state.coverage.unshift(new Uint8Array(cols));
+}
+function scrollPlaneCoverageRegion(state, startY, endY, lines) {
+	const n = Math.trunc(lines);
+	if (n === 0 || state.coverage.length === 0) return;
+	const start = Math.max(0, Math.min(state.coverage.length, Math.floor(startY)));
+	const end = Math.max(0, Math.min(state.coverage.length, Math.floor(endY)));
+	const height = end - start;
+	if (height <= 0) return;
+	const cols = state.buffer.cols;
+	if (Math.abs(n) >= height) {
+		for (let y = start; y < end; y++) state.coverage[y] = new Uint8Array(cols);
+		return;
+	}
+	const region = state.coverage.slice(start, end);
+	const next = Array.from({ length: height }, () => new Uint8Array(0));
+	if (n > 0) {
+		const movedCount = height - n;
+		for (let i = 0; i < movedCount; i++) next[i] = region[i + n];
+		for (let i = 0; i < n; i++) next[movedCount + i] = new Uint8Array(cols);
+	} else {
+		const insertedCount = -n;
+		const movedCount = height - insertedCount;
+		for (let i = 0; i < insertedCount; i++) next[i] = new Uint8Array(cols);
+		for (let i = 0; i < movedCount; i++) next[insertedCount + i] = region[i];
+	}
+	for (let i = 0; i < height; i++) state.coverage[start + i] = next[i];
+}
+function resizePlaneState(state, cols, rows) {
+	resizeBuffer(state.buffer, cols, rows);
+	state.coverage = resizeCoverage(state.coverage, state.buffer.cols, state.buffer.rows);
+}
+function normalizeDirtyRows(rows, totalRows) {
+	if (rows === null) return null;
+	if (rows.length === 0) return rows;
+	const out = [];
+	for (const y of rows) {
+		const yy = Math.floor(y);
+		if (yy < 0 || yy >= totalRows) continue;
+		if (out[out.length - 1] === yy) continue;
+		out.push(yy);
+	}
+	return out;
+}
+function getPlaneTerminal(terminal, plane) {
+	const internals = terminal[TERMINAL_PLANE_INTERNALS];
+	return internals?.getPlaneTerminal(plane) ?? terminal;
+}
+function resetPlaneRowsForRender(terminal, plane, dirtyRows) {
+	const internals = terminal[TERMINAL_PLANE_INTERNALS];
+	internals?.resetRowsForRender(plane, dirtyRows);
+}
+function scrollPlaneRows(terminal, plane, startY, endY, lines) {
+	const internals = terminal[TERMINAL_PLANE_INTERNALS];
+	internals?.scrollRows(plane, startY, endY, lines);
+}
+function createTerminal(opts) {
+	const widthProvider = opts.widthProvider ?? "default";
+	const emitter = new Emitter();
+	const compositeBuffer = createGridBuffer(opts.cols, opts.rows, { widthProvider });
+	const planeStates = new Map();
+	let disposed = false;
+	let batchingDepth = 0;
+	let pendingCommit = false;
+	let pendingCommitAllPlanes = false;
+	let pendingCommitPlanes = null;
+	const pendingPlaneScrollOps = new Map();
+	const planeTerminals = new Map();
+	let base;
+	compositeBuffer.cursorVisible = false;
+	function assertNotDisposed() {
+		if (disposed) throw new Error("Terminal is disposed");
+	}
+	function getPlaneState(plane) {
+		let state = planeStates.get(plane);
+		if (!state) {
+			state = createPlaneState(compositeBuffer.cols, compositeBuffer.rows, widthProvider);
+			planeStates.set(plane, state);
+		}
+		return state;
+	}
+	function setCursorForPlane(plane, x, y, visible = true) {
+		const state = getPlaneState(plane);
+		state.buffer.cursorX = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+		state.buffer.cursorY = Math.max(0, Math.min(state.buffer.rows ? state.buffer.rows - 1 : 0, Math.floor(y)));
+		state.buffer.cursorVisible = visible;
+		markDirty(state.buffer, state.buffer.cursorY);
+	}
+	function putForPlane(plane, x, y, ch, style) {
+		const state = getPlaneState(plane);
+		if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols) return;
+		const prevCell = getBufferCell(state.buffer, x, y);
+		putCell(state.buffer, x, y, ch, style);
+		markPlaneCoverageForPut(state, x, y, ch, prevCell);
+	}
+	function writeAtForPlane(plane, text, x, y, style) {
+		const state = getPlaneState(plane);
+		let cx = x;
+		let cy = y;
+		if (state.buffer.cols === 0 || state.buffer.rows === 0) return {
+			x: cx,
+			y: cy
+		};
+		const writeChar = (ch) => {
+			if (isControlChar(ch)) {
+				if (ch === "\n") {
+					cx = 0;
+					cy += 1;
+					if (cy >= state.buffer.rows) {
+						scrollBuffer(state.buffer, 1);
+						scrollPlaneCoverage(state, 1);
+						cy = state.buffer.rows - 1;
+					}
+				} else if (ch === "\r") cx = 0;
+				else if (ch === "	") {
+					const tabSize = 4;
+					const next = Math.min(state.buffer.cols, cx + (tabSize - cx % tabSize));
+					for (; cx < next; cx++) putForPlane(plane, cx, cy, " ", style);
+				}
+				return true;
+			}
+			if (cy < 0 || cy >= state.buffer.rows) return false;
+			if (cx >= state.buffer.cols) {
+				cx = 0;
+				cy += 1;
+			}
+			if (cy >= state.buffer.rows) {
+				scrollBuffer(state.buffer, 1);
+				scrollPlaneCoverage(state, 1);
+				cy = state.buffer.rows - 1;
+			}
+			putForPlane(plane, cx, cy, ch, style);
+			const width = ch === " " ? 1 : getBufferCell(state.buffer, cx, cy).width || 1;
+			cx += width;
+			return true;
+		};
+		const segments = segmentedGraphemes(text);
+		if (segments) {
+			for (const seg of segments) if (!writeChar(seg.segment)) break;
+			return {
+				x: cx,
+				y: cy
+			};
+		}
+		let i = 0;
+		for (; i < text.length; i++) {
+			const code = text.charCodeAt(i);
+			if (code > 127) break;
+			if (!writeChar(text[i])) return {
+				x: cx,
+				y: cy
+			};
+		}
+		if (i < text.length) {
+			const rest = text.slice(i);
+			const restSegments = segmentedGraphemes(rest);
+			if (restSegments) {
+				for (const seg of restSegments) if (!writeChar(seg.segment)) break;
+			} else for (const ch of rest) if (!writeChar(ch)) break;
+		}
+		return {
+			x: cx,
+			y: cy
+		};
+	}
+	function clearForPlane(plane, x, y, w, h) {
+		const state = getPlaneState(plane);
+		clearRect(state.buffer, x, y, w, h);
+		if (x == null || y == null || w == null || h == null) {
+			for (const row of state.coverage) row.fill(1);
+			return;
+		}
+		if (w <= 0 || h <= 0) return;
+		const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+		const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
+		const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
+		const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+		if (x1 <= x0 || y1 <= y0) return;
+		markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+	}
+	function fillForPlane(plane, x, y, w, h, ch, style) {
+		const state = getPlaneState(plane);
+		fillRect(state.buffer, x, y, w, h, ch ?? " ", style);
+		if (w <= 0 || h <= 0 || state.buffer.cols === 0 || state.buffer.rows === 0) return;
+		const x0 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x)));
+		const y0 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y)));
+		const x1 = Math.max(0, Math.min(state.buffer.cols, Math.floor(x + w)));
+		const y1 = Math.max(0, Math.min(state.buffer.rows, Math.floor(y + h)));
+		if (x1 <= x0 || y1 <= y0) return;
+		markPlaneCoverageRange(state, x0, y0, x1, y1, 1);
+	}
+	function scrollForPlane(plane, lines) {
+		const state = getPlaneState(plane);
+		scrollBuffer(state.buffer, lines);
+		scrollPlaneCoverage(state, lines);
+	}
+	function normalizeScrollOperation(startY, endY, delta, totalRows) {
+		const start = Math.max(0, Math.min(totalRows, Math.floor(startY)));
+		const end = Math.max(0, Math.min(totalRows, Math.floor(endY)));
+		const height = end - start;
+		const lines = Math.trunc(delta);
+		if (height <= 0 || lines === 0 || Math.abs(lines) >= height) return null;
+		return {
+			startY: start,
+			endY: end,
+			delta: lines
+		};
+	}
+	function recordPendingScrollOp(plane, op) {
+		const list = pendingPlaneScrollOps.get(plane) ?? [];
+		const last = list[list.length - 1];
+		if (last && last.startY === op.startY && last.endY === op.endY && Math.sign(last.delta) === Math.sign(op.delta)) {
+			const next = normalizeScrollOperation(op.startY, op.endY, last.delta + op.delta, compositeBuffer.rows);
+			if (next) list[list.length - 1] = next;
+			else list.push(op);
+		} else list.push(op);
+		pendingPlaneScrollOps.set(plane, list);
+	}
+	function takePendingScrollOps(planes) {
+		const planesToTake = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+		const out = [];
+		for (const plane of planesToTake) {
+			const ops = pendingPlaneScrollOps.get(plane);
+			if (!ops?.length) continue;
+			pendingPlaneScrollOps.delete(plane);
+			for (const op of ops) out.push({
+				plane,
+				...op
+			});
+		}
+		return out.length ? out : null;
+	}
+	function higherPlanesFor(plane) {
+		const planeIndex = TERMINAL_RENDER_PLANES.indexOf(plane);
+		if (planeIndex < 0) return [];
+		return TERMINAL_RENDER_PLANES.slice(planeIndex + 1);
+	}
+	function higherPlaneCoverageKind(plane, y) {
+		const higherPlanes = higherPlanesFor(plane);
+		if (!higherPlanes.length || y < 0 || y >= compositeBuffer.rows) return 0;
+		let covered = 0;
+		for (let x = 0; x < compositeBuffer.cols; x++) {
+			let cellCovered = false;
+			for (const higherPlane of higherPlanes) {
+				const state = planeStates.get(higherPlane);
+				if (state?.coverage[y]?.[x]) {
+					cellCovered = true;
+					break;
+				}
+			}
+			if (cellCovered) covered++;
+		}
+		if (covered === 0) return 0;
+		if (covered >= compositeBuffer.cols) return 2;
+		return 1;
+	}
+	function addAffectedRows(out, op) {
+		for (let y = op.startY; y < op.endY; y++) out.add(y);
+	}
+	function areDisjointSorted(ops) {
+		for (let i = 1; i < ops.length; i++) if (ops[i - 1].endY > ops[i].startY) return false;
+		return true;
+	}
+	function groupedPendingScrollOps(pendingOps) {
+		const grouped = new Map();
+		for (const pending of pendingOps) {
+			const list = grouped.get(pending.plane) ?? [];
+			list.push({
+				startY: pending.startY,
+				endY: pending.endY,
+				delta: pending.delta
+			});
+			grouped.set(pending.plane, list);
+		}
+		return grouped;
+	}
+	function prepareCompositeScrollOps(pendingOps) {
+		if (!pendingOps?.length) return {
+			scrollOperations: null,
+			extraDirtyRows: []
+		};
+		const scrollOperations = [];
+		const extraDirtyRows = new Set();
+		const grouped = groupedPendingScrollOps(pendingOps);
+		for (const [plane, ops] of grouped) {
+			const sorted = [...ops].sort((a, b) => a.startY - b.startY || a.endY - b.endY);
+			if (!areDisjointSorted(sorted)) {
+				for (const op of ops) addAffectedRows(extraDirtyRows, op);
+				continue;
+			}
+			for (const op of sorted) {
+				const blockedRows = new Set();
+				const partiallyBlockedRows = new Set();
+				for (let y = op.startY; y < op.endY; y++) {
+					const coverageKind = higherPlaneCoverageKind(plane, y);
+					if (coverageKind === 0) continue;
+					blockedRows.add(y);
+					if (coverageKind === 1) partiallyBlockedRows.add(y);
+				}
+				if (!blockedRows.size) {
+					scrollOperations.push({
+						startY: op.startY,
+						endY: op.endY,
+						delta: op.delta
+					});
+					continue;
+				}
+				const absDelta = Math.abs(op.delta);
+				for (let y = op.startY; y < op.endY; y++) if (partiallyBlockedRows.has(y)) extraDirtyRows.add(y);
+				let bandStart = -1;
+				const flushBand = (bandEnd) => {
+					if (bandStart < 0 || bandEnd <= bandStart) return;
+					const bandHeight = bandEnd - bandStart;
+					if (absDelta >= bandHeight) {
+						for (let y = bandStart; y < bandEnd; y++) extraDirtyRows.add(y);
+						bandStart = -1;
+						return;
+					}
+					scrollOperations.push({
+						startY: bandStart,
+						endY: bandEnd,
+						delta: op.delta
+					});
+					if (op.delta > 0) for (let y = bandEnd - absDelta; y < bandEnd; y++) extraDirtyRows.add(y);
+					else for (let y = bandStart; y < bandStart + absDelta; y++) extraDirtyRows.add(y);
+					bandStart = -1;
+				};
+				for (let y = op.startY; y < op.endY; y++) {
+					if (blockedRows.has(y)) {
+						flushBand(y);
+						continue;
+					}
+					if (bandStart < 0) bandStart = y;
+				}
+				flushBand(op.endY);
+			}
+		}
+		return {
+			scrollOperations: scrollOperations.length ? scrollOperations : null,
+			extraDirtyRows: Array.from(extraDirtyRows).sort((a, b) => a - b)
+		};
+	}
+	function dirtyRowsCoverRange(rows, startY, endY) {
+		if (rows === null) return true;
+		if (!rows.length) return false;
+		let idx = 0;
+		while (idx < rows.length && (rows[idx] ?? -1) < startY) idx++;
+		for (let y = startY; y < endY; y++) {
+			if (rows[idx] !== y) return false;
+			idx++;
+		}
+		return true;
+	}
+	function dropScrollOpsCoveredByDirtyRows(ops, dirtyRows) {
+		if (!ops?.length) return null;
+		const next = ops.filter((op) => !dirtyRowsCoverRange(dirtyRows, op.startY, op.endY));
+		return next.length ? next : null;
+	}
+	function scrollRowsForPlane(plane, startY, endY, lines) {
+		const state = getPlaneState(plane);
+		const op = normalizeScrollOperation(startY, endY, lines, state.buffer.rows);
+		if (!op) return;
+		scrollBufferRegion(state.buffer, op.startY, op.endY, op.delta);
+		scrollPlaneCoverageRegion(state, op.startY, op.endY, op.delta);
+		recordPendingScrollOp(plane, op);
+	}
+	function composeRows(rows, planes = TERMINAL_RENDER_PLANES) {
+		const blank = createBlankCell();
+		const fpFn = compositeBuffer.fingerprintFn;
+		const fpArr = compositeBuffer.soaFingerprints;
+		const rowList = rows ?? Array.from({ length: compositeBuffer.rows }, (_, index) => index);
+		for (const y of rowList) {
+			if (y < 0 || y >= compositeBuffer.rows) continue;
+			const dst = getBufferRow(compositeBuffer, y);
+			dst.length = compositeBuffer.cols;
+			for (let x = 0; x < compositeBuffer.cols; x++) dst[x] = blank;
+			for (const plane of planes) {
+				const state = planeStates.get(plane);
+				if (!state) continue;
+				const src = getBufferRow(state.buffer, y);
+				const coverage = state.coverage[y];
+				if (!coverage) continue;
+				for (let x = 0; x < compositeBuffer.cols; x++) if (coverage[x]) dst[x] = src[x];
+			}
+			const cols = compositeBuffer.cols;
+			for (let x = 0; x < cols; x++) {
+				const cell = dst[x];
+				if (cell.width === 2 && !cell.continuation) {
+					if (x + 1 >= cols || !dst[x + 1].continuation) dst[x] = blank;
+				} else if (cell.continuation) {
+					if (x === 0 || dst[x - 1].width !== 2 || dst[x - 1].continuation) dst[x] = blank;
+				}
+			}
+			if (fpFn && fpArr) {
+				const physY = (compositeBuffer.gridStart + y) % compositeBuffer.rows;
+				const base$1 = physY * cols;
+				for (let x = 0; x < cols; x++) {
+					const cell = dst[x];
+					fpArr[base$1 + x] = fpFn(cell.ch, cell.style);
+				}
+			}
+			markDirty(compositeBuffer, y);
+		}
+	}
+	function syncCompositeCursor() {
+		const prevVisible = compositeBuffer.cursorVisible;
+		const prevY = compositeBuffer.cursorY;
+		let nextPlane = null;
+		for (const plane of [
+			"overlay",
+			"chrome",
+			"transcript",
+			"default"
+		]) {
+			const state = planeStates.get(plane);
+			if (state?.buffer.cursorVisible) {
+				nextPlane = state;
+				break;
+			}
+		}
+		compositeBuffer.cursorVisible = Boolean(nextPlane);
+		compositeBuffer.cursorX = nextPlane?.buffer.cursorX ?? 0;
+		compositeBuffer.cursorY = nextPlane?.buffer.cursorY ?? 0;
+		if (prevVisible) markDirty(compositeBuffer, prevY);
+		if (compositeBuffer.cursorVisible) markDirty(compositeBuffer, compositeBuffer.cursorY);
+	}
+	function syncCompositeForRead(planes) {
+		const planesToCompose = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+		let composeAllRows = false;
+		const dirtyRows = new Set();
+		for (const plane of planesToCompose) {
+			const state = planeStates.get(plane);
+			if (!state) continue;
+			const rows = peekDirtyRows(state.buffer);
+			if (rows === null) {
+				composeAllRows = true;
+				break;
+			}
+			for (const y of rows) dirtyRows.add(y);
+		}
+		if (composeAllRows || dirtyRows.size > 0) composeRows(composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b), planesToCompose);
+		syncCompositeCursor();
+	}
+	function readRowForPlanes(y, planes) {
+		assertNotDisposed();
+		if (y < 0 || y >= compositeBuffer.rows) throw new RangeError("Row out of bounds");
+		composeRows([y], planes?.length ? planes : TERMINAL_RENDER_PLANES);
+		return getBufferRow(compositeBuffer, y);
+	}
+	function pendingDirtyRowsForPlanes(planes) {
+		const planesToCheck = planes?.length ? planes : TERMINAL_RENDER_PLANES;
+		let full = false;
+		const rows = new Set();
+		for (const plane of planesToCheck) {
+			const state = planeStates.get(plane);
+			if (!state) continue;
+			const dirty = peekDirtyRows(state.buffer);
+			if (dirty === null) {
+				full = true;
+				break;
+			}
+			for (const y of dirty) rows.add(y);
+		}
+		if (full) return null;
+		return Array.from(rows).sort((a, b) => a - b);
+	}
+	function createPlaneTerminalApi(plane) {
+		const existing = planeTerminals.get(plane);
+		if (existing) return existing;
+		const api = {
+			resize(cols, rows) {
+				assertNotDisposed();
+				base.resize(cols, rows);
+			},
+			clear(x, y, w, h) {
+				assertNotDisposed();
+				clearForPlane(plane, x, y, w, h);
+			},
+			write(text, opts$1) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				const x = opts$1?.x;
+				const y = opts$1?.y;
+				const style = opts$1?.style;
+				if (x == null || y == null) {
+					const next = writeAtForPlane(plane, text, state.buffer.cursorX, state.buffer.cursorY, style ?? state.buffer.cursorStyle);
+					state.buffer.cursorX = next.x;
+					state.buffer.cursorY = next.y;
+				} else writeAtForPlane(plane, text, x, y, style);
+			},
+			writeAnsi(text, opts$1) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				const x = opts$1?.x;
+				const y = opts$1?.y;
+				const positionedWrite = x != null && y != null;
+				let cx = positionedWrite ? x : state.buffer.cursorX;
+				let cy = positionedWrite ? y : state.buffer.cursorY;
+				let style = positionedWrite ? {} : state.buffer.cursorStyle;
+				for (const seg of parseAnsiSgr(text, style)) {
+					const next = writeAtForPlane(plane, seg.text, cx, cy, seg.style);
+					cx = next.x;
+					cy = next.y;
+					style = seg.style;
+				}
+				if (!positionedWrite) {
+					state.buffer.cursorX = cx;
+					state.buffer.cursorY = cy;
+					state.buffer.cursorStyle = style;
+				}
+			},
+			put(x, y, ch, style) {
+				assertNotDisposed();
+				putForPlane(plane, x, y, ch, style);
+			},
+			fill(x, y, w, h, ch, style) {
+				assertNotDisposed();
+				fillForPlane(plane, x, y, w, h, ch, style);
+			},
+			scroll(lines) {
+				assertNotDisposed();
+				scrollForPlane(plane, lines);
+			},
+			setCursor(x, y, visible) {
+				assertNotDisposed();
+				setCursorForPlane(plane, x, y, visible);
+			},
+			batch(fn) {
+				assertNotDisposed();
+				return base.batch(fn);
+			},
+			commit(meta) {
+				assertNotDisposed();
+				return base.commit({
+					planes: meta?.planes ?? [plane],
+					sync: meta?.sync
+				});
+			},
+			on(event, cb) {
+				assertNotDisposed();
+				return base.on(event, cb);
+			},
+			dispose() {
+				base.dispose();
+			},
+			size() {
+				assertNotDisposed();
+				return base.size();
+			},
+			snapshot() {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				return {
+					cols: state.buffer.cols,
+					rows: state.buffer.rows,
+					lines: snapshotText(state.buffer)
+				};
+			},
+			getCell(x, y) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols) throw new RangeError("Cell out of bounds");
+				return getBufferCell(state.buffer, x, y);
+			},
+			getRow(y) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				if (y < 0 || y >= state.buffer.rows) throw new RangeError("Row out of bounds");
+				return getBufferRow(state.buffer, y);
+			},
+			setScrollbackLimit(limit) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
+				if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) state.buffer.scrollback.splice(0, state.buffer.scrollback.length - state.buffer.scrollbackLimit);
+			},
+			getScrollbackLines(count) {
+				assertNotDisposed();
+				const state = getPlaneState(plane);
+				const all = state.buffer.scrollback.map((row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
+				if (count == null) return all;
+				return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+			},
+			setFingerprintFn(fn) {
+				assertNotDisposed();
+				base.setFingerprintFn(fn);
+			},
+			getRowFingerprints(y) {
+				assertNotDisposed();
+				return base.getRowFingerprints(y);
+			}
+		};
+		planeTerminals.set(plane, api);
+		return api;
+	}
+	base = {
+		resize(cols, rows) {
+			assertNotDisposed();
+			const prevCols = compositeBuffer.cols;
+			const prevRows = compositeBuffer.rows;
+			resizeBuffer(compositeBuffer, cols, rows);
+			for (const state of planeStates.values()) resizePlaneState(state, cols, rows);
+			if (compositeBuffer.cols !== prevCols || compositeBuffer.rows !== prevRows) emitter.emit("resize", {
+				cols: compositeBuffer.cols,
+				rows: compositeBuffer.rows
+			});
+		},
+		clear(x, y, w, h) {
+			assertNotDisposed();
+			clearForPlane("default", x, y, w, h);
+		},
+		write(text, opts$1) {
+			assertNotDisposed();
+			createPlaneTerminalApi("default").write(text, opts$1);
+		},
+		writeAnsi(text, opts$1) {
+			assertNotDisposed();
+			createPlaneTerminalApi("default").writeAnsi(text, opts$1);
+		},
+		put(x, y, ch, style) {
+			assertNotDisposed();
+			putForPlane("default", x, y, ch, style);
+		},
+		fill(x, y, w, h, ch, style) {
+			assertNotDisposed();
+			fillForPlane("default", x, y, w, h, ch, style);
+		},
+		scroll(lines) {
+			assertNotDisposed();
+			scrollForPlane("default", lines);
+		},
+		setCursor(x, y, visible = true) {
+			assertNotDisposed();
+			setCursorForPlane("default", x, y, visible);
+		},
+		batch(fn) {
+			assertNotDisposed();
+			batchingDepth++;
+			try {
+				return fn();
+			} finally {
+				batchingDepth--;
+				if (batchingDepth === 0 && pendingCommit) {
+					pendingCommit = false;
+					const planes = pendingCommitAllPlanes ? null : pendingCommitPlanes;
+					pendingCommitAllPlanes = false;
+					pendingCommitPlanes = null;
+					base.commit({ planes });
+				}
+			}
+		},
+		commit(meta) {
+			assertNotDisposed();
+			if (batchingDepth > 0) {
+				pendingCommit = true;
+				if (!meta?.planes?.length) {
+					pendingCommitAllPlanes = true;
+					pendingCommitPlanes = null;
+				} else if (!pendingCommitAllPlanes) pendingCommitPlanes = mergePlanes(pendingCommitPlanes, meta.planes);
+				return pendingDirtyRowsForPlanes(meta?.planes ?? null);
+			}
+			const planesToCompose = meta?.planes?.length ? meta.planes : TERMINAL_RENDER_PLANES;
+			const pendingScrollOps = takePendingScrollOps(planesToCompose);
+			const preparedScroll = prepareCompositeScrollOps(pendingScrollOps);
+			let scrollOperations = preparedScroll.scrollOperations;
+			let composeAllRows = false;
+			const dirtyRows = new Set();
+			for (const plane of planesToCompose) {
+				const state = planeStates.get(plane);
+				if (!state) continue;
+				const rows = collectAndClearDirtyRows(state.buffer);
+				if (rows === null) {
+					composeAllRows = true;
+					break;
+				}
+				for (const y of rows) dirtyRows.add(y);
+			}
+			for (const y of preparedScroll.extraDirtyRows) dirtyRows.add(y);
+			const normalizedDirtyRows = composeAllRows ? null : Array.from(dirtyRows).sort((a, b) => a - b);
+			scrollOperations = dropScrollOpsCoveredByDirtyRows(scrollOperations, normalizedDirtyRows);
+			if (scrollOperations) for (const op of scrollOperations) scrollBufferRegion(compositeBuffer, op.startY, op.endY, op.delta);
+			if (normalizedDirtyRows !== null && normalizedDirtyRows.length === 0) {
+				const pendingCompositeRows = collectAndClearDirtyRows(compositeBuffer);
+				if (pendingCompositeRows !== null && pendingCompositeRows.length === 0) return pendingCompositeRows;
+				emitter.emit("commit", {
+					dirtyRows: pendingCompositeRows,
+					planes: meta?.planes ?? null,
+					sync: meta?.sync,
+					scrollOperations
+				});
+				return pendingCompositeRows;
+			}
+			composeRows(normalizedDirtyRows);
+			if (normalizedDirtyRows === null) markAllDirty(compositeBuffer);
+			syncCompositeCursor();
+			const committedRows = collectAndClearDirtyRows(compositeBuffer);
+			if (committedRows !== null && committedRows.length === 0) return committedRows;
+			emitter.emit("commit", {
+				dirtyRows: committedRows,
+				planes: meta?.planes ?? null,
+				sync: meta?.sync,
+				scrollOperations
+			});
+			return committedRows;
+		},
+		on(event, cb) {
+			assertNotDisposed();
+			return emitter.on(event, cb);
+		},
+		dispose() {
+			disposed = true;
+			emitter.clear();
+		},
+		size() {
+			assertNotDisposed();
+			return {
+				cols: compositeBuffer.cols,
+				rows: compositeBuffer.rows
+			};
+		},
+		snapshot() {
+			assertNotDisposed();
+			if (batchingDepth === 0) syncCompositeForRead();
+			const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+			return {
+				cols: source.cols,
+				rows: source.rows,
+				lines: snapshotText(source)
+			};
+		},
+		getCell(x, y) {
+			assertNotDisposed();
+			if (batchingDepth === 0) syncCompositeForRead();
+			const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+			if (y < 0 || y >= source.rows || x < 0 || x >= source.cols) throw new RangeError("Cell out of bounds");
+			return getBufferCell(source, x, y);
+		},
+		getRow(y) {
+			assertNotDisposed();
+			if (batchingDepth === 0) syncCompositeForRead();
+			const source = batchingDepth > 0 ? getPlaneState("default").buffer : compositeBuffer;
+			if (y < 0 || y >= source.rows) throw new RangeError("Row out of bounds");
+			return getBufferRow(source, y);
+		},
+		setScrollbackLimit(limit) {
+			assertNotDisposed();
+			const state = getPlaneState("default");
+			state.buffer.scrollbackLimit = Math.max(0, Math.floor(limit));
+			if (state.buffer.scrollback.length > state.buffer.scrollbackLimit) state.buffer.scrollback.splice(0, state.buffer.scrollback.length - state.buffer.scrollbackLimit);
+		},
+		getScrollbackLines(count) {
+			assertNotDisposed();
+			const state = getPlaneState("default");
+			const all = state.buffer.scrollback.map((row) => row.map((cell) => cell.continuation ? " " : cell.ch || " ").join(""));
+			if (count == null) return all;
+			return all.slice(Math.max(0, all.length - Math.max(0, Math.floor(count))));
+		},
+		setFingerprintFn(fn) {
+			assertNotDisposed();
+			setFingerprintFn(compositeBuffer, fn);
+		},
+		getRowFingerprints(y) {
+			assertNotDisposed();
+			return getRowFingerprints(compositeBuffer, y);
+		}
+	};
+	base[TERMINAL_PLANE_INTERNALS] = {
+		getPlaneTerminal: createPlaneTerminalApi,
+		readRowForPlanes,
+		resetRowsForRender(plane, dirtyRows) {
+			const state = getPlaneState(plane);
+			const rows = normalizeDirtyRows(dirtyRows, state.buffer.rows);
+			if (rows === null) {
+				for (let y = 0; y < state.buffer.rows; y++) clearPlaneCoverageRow(state, y);
+				return;
+			}
+			for (const y of rows) clearPlaneCoverageRow(state, y);
+		},
+		getRowCoverageKind(plane, y) {
+			const state = getPlaneState(plane);
+			if (y < 0 || y >= state.coverage.length) return 0;
+			const row = state.coverage[y];
+			if (!row?.length) return 0;
+			let covered = 0;
+			for (let x = 0; x < row.length; x++) if (row[x]) covered++;
+			if (covered === 0) return 0;
+			if (covered >= row.length) return 2;
+			return 1;
+		},
+		scrollRows(plane, startY, endY, lines) {
+			scrollRowsForPlane(plane, startY, endY, lines);
+		}
+	};
+	return base;
+}
+
+//#endregion
+export { TERMINAL_RENDER_PLANES, createTerminal, getPlaneTerminal, resetPlaneRowsForRender, scrollPlaneRows };