vterm.js 0.3.1 → 0.5.0

package/dist/index.mjs

@@ -0,0 +1,2501 @@
+//#region src/screen.ts
+/** Frozen sentinel for unwritten cells — never mutate, copy-on-write in writeChar(). */
+const EMPTY_CELL = Object.freeze({
+	char: "",
+	fg: null,
+	bg: null,
+	bold: false,
+	faint: false,
+	italic: false,
+	underline: "none",
+	underlineColor: null,
+	overline: false,
+	strikethrough: false,
+	inverse: false,
+	hidden: false,
+	blink: false,
+	wide: false,
+	url: null
+});
+function emptyCell() {
+	return { ...EMPTY_CELL };
+}
+const ANSI_16 = [
+	{
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 128,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 128,
+		b: 0
+	},
+	{
+		r: 128,
+		g: 128,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 0,
+		b: 128
+	},
+	{
+		r: 128,
+		g: 0,
+		b: 128
+	},
+	{
+		r: 0,
+		g: 128,
+		b: 128
+	},
+	{
+		r: 192,
+		g: 192,
+		b: 192
+	},
+	{
+		r: 128,
+		g: 128,
+		b: 128
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 0
+	},
+	{
+		r: 0,
+		g: 0,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 0,
+		b: 255
+	},
+	{
+		r: 0,
+		g: 255,
+		b: 255
+	},
+	{
+		r: 255,
+		g: 255,
+		b: 255
+	}
+];
+function buildPalette256() {
+	const palette = [...ANSI_16];
+	const levels = [
+		0,
+		95,
+		135,
+		175,
+		215,
+		255
+	];
+	for (let r = 0; r < 6; r++) for (let g = 0; g < 6; g++) for (let b = 0; b < 6; b++) palette.push({
+		r: levels[r],
+		g: levels[g],
+		b: levels[b]
+	});
+	for (let i = 0; i < 24; i++) {
+		const v = 8 + i * 10;
+		palette.push({
+			r: v,
+			g: v,
+			b: v
+		});
+	}
+	return palette;
+}
+/**
+* Parse an X11-style color spec: "rgb:RR/GG/BB", "rgb:RRRR/GGGG/BBBB",
+* "#RRGGBB", "#RGB". Returns null if unparseable.
+*/
+function parseColorSpec(spec) {
+	const s = spec.trim();
+	const rgbMatch = /^rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})$/.exec(s);
+	if (rgbMatch) {
+		const scale = (hex) => {
+			const v = parseInt(hex, 16);
+			const max = Math.pow(16, hex.length) - 1;
+			return Math.round(v * 255 / max);
+		};
+		return {
+			r: scale(rgbMatch[1]),
+			g: scale(rgbMatch[2]),
+			b: scale(rgbMatch[3])
+		};
+	}
+	const hex6 = /^#([0-9a-fA-F]{6})$/.exec(s);
+	if (hex6) {
+		const v = hex6[1];
+		return {
+			r: parseInt(v.substring(0, 2), 16),
+			g: parseInt(v.substring(2, 4), 16),
+			b: parseInt(v.substring(4, 6), 16)
+		};
+	}
+	const hex3 = /^#([0-9a-fA-F]{3})$/.exec(s);
+	if (hex3) {
+		const v = hex3[1];
+		const expand = (ch) => parseInt(ch + ch, 16);
+		return {
+			r: expand(v[0]),
+			g: expand(v[1]),
+			b: expand(v[2])
+		};
+	}
+	return null;
+}
+/** Format a color as X11 "rgb:RRRR/GGGG/BBBB" (16-bit per channel, standard xterm reply). */
+function formatColorResponse(c) {
+	const scale = (v) => {
+		return Math.round(v * 65535 / 255).toString(16).padStart(4, "0");
+	};
+	return `rgb:${scale(c.r)}/${scale(c.g)}/${scale(c.b)}`;
+}
+const DEC_SPECIAL_GRAPHICS = {
+	j: "┘",
+	k: "┐",
+	l: "┌",
+	m: "└",
+	n: "┼",
+	q: "─",
+	t: "├",
+	u: "┤",
+	v: "┴",
+	w: "┬",
+	x: "│",
+	a: "▒",
+	f: "°",
+	g: "±",
+	"~": "·",
+	y: "≤",
+	z: "≥",
+	"{": "π",
+	"|": "≠",
+	"}": "£"
+};
+function isWide(codePoint) {
+	return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 8986 && codePoint <= 8987 || codePoint >= 9748 && codePoint <= 9749 || codePoint >= 9800 && codePoint <= 9811 || codePoint === 9855 || codePoint === 9875 || codePoint === 9889 || codePoint === 9934 || codePoint === 9940 || codePoint === 9989 || codePoint === 10024 || codePoint === 10060 || codePoint === 10062 || codePoint >= 10067 && codePoint <= 10069 || codePoint >= 10133 && codePoint <= 10135 || codePoint === 10160 || codePoint === 10175 || codePoint >= 11904 && codePoint <= 12350 || codePoint >= 12353 && codePoint <= 13247 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42191 || codePoint >= 43360 && codePoint <= 43388 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65131 || codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint === 126980 || codePoint === 127183 || codePoint >= 127344 && codePoint <= 127345 || codePoint >= 127358 && codePoint <= 127359 || codePoint === 127374 || codePoint >= 127377 && codePoint <= 127386 || codePoint >= 127462 && codePoint <= 127487 || codePoint >= 127488 && codePoint <= 127490 || codePoint >= 127744 && codePoint <= 129535 || codePoint >= 129536 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 196605 || codePoint >= 196608 && codePoint <= 262141;
+}
+function isCombining(cp) {
+	return cp >= 768 && cp <= 879 || cp >= 1155 && cp <= 1161 || cp >= 1425 && cp <= 1469 || cp === 1471 || cp >= 1473 && cp <= 1474 || cp >= 1476 && cp <= 1477 || cp === 1479 || cp >= 1552 && cp <= 1562 || cp >= 1611 && cp <= 1631 || cp === 1648 || cp >= 1750 && cp <= 1756 || cp >= 1759 && cp <= 1764 || cp >= 1767 && cp <= 1768 || cp >= 1770 && cp <= 1773 || cp >= 1840 && cp <= 1866 || cp >= 2304 && cp <= 2307 || cp >= 2362 && cp <= 2383 || cp >= 2385 && cp <= 2391 || cp >= 2402 && cp <= 2403 || cp === 3633 || cp >= 3636 && cp <= 3642 || cp >= 3655 && cp <= 3662 || cp >= 6832 && cp <= 6911 || cp >= 7616 && cp <= 7679 || cp >= 8400 && cp <= 8447 || cp >= 65024 && cp <= 65039 || cp >= 917760 && cp <= 917999;
+}
+function isRegionalIndicator(cp) {
+	return cp >= 127462 && cp <= 127487;
+}
+function isZWJ(cp) {
+	return cp === 8205;
+}
+function isVS16(cp) {
+	return cp === 65039;
+}
+function isEmojiModifier(cp) {
+	return cp >= 127995 && cp <= 127999;
+}
+function createScreen(options = {}) {
+	let cols = options.cols ?? 80;
+	let rows = options.rows ?? 24;
+	const scrollbackLimit = options.scrollbackLimit ?? 1e3;
+	const onResponse = options.onResponse;
+	let mainGrid = makeGrid(cols, rows);
+	let altGrid = makeGrid(cols, rows);
+	let grid = mainGrid;
+	let scrollback = [];
+	let curX = 0;
+	let curY = 0;
+	let curVisible = true;
+	let cursorShape = "block";
+	let cursorBlinking = true;
+	let savedState = {
+		curX: 0,
+		curY: 0,
+		attrs: resetAttrs(),
+		originMode: false,
+		autoWrap: true,
+		charsetG0: false
+	};
+	let savedCurX = 0;
+	let savedCurY = 0;
+	let attrs = resetAttrs();
+	let title = "";
+	let useAltScreen = false;
+	let bracketedPaste = false;
+	let applicationCursor = false;
+	let applicationKeypad = false;
+	let autoWrap = true;
+	let mouseTracking = false;
+	let mouseTrackingMode = 0;
+	let sgrMouse = false;
+	let focusTracking = false;
+	let originMode = false;
+	let insertMode = false;
+	let reverseVideo = false;
+	let syncOutput = false;
+	let kittyKeyboardFlags = 0;
+	let kittyKeyboardStack = [];
+	let hasKittyGraphics = false;
+	let scrollTop = 0;
+	let scrollBottom = rows - 1;
+	let leftRightMarginMode = false;
+	let leftMargin = 0;
+	let rightMargin = cols - 1;
+	let colorSchemeReporting = false;
+	let decColumnMode = false;
+	let altScrollMode = false;
+	let utf8MouseMode = false;
+	let palette256 = buildPalette256();
+	let defaultFgColor = null;
+	let defaultBgColor = null;
+	let cursorColor = null;
+	const specialColors = /* @__PURE__ */ new Map();
+	let pointerFgColor = null;
+	let pointerBgColor = null;
+	let highlightBgColor = null;
+	let highlightFgColor = null;
+	const colorStack = [];
+	function cloneColor(c) {
+		return c ? { ...c } : null;
+	}
+	function snapshotColorState() {
+		return {
+			palette256: palette256.map((c) => ({ ...c })),
+			defaultFgColor: cloneColor(defaultFgColor),
+			defaultBgColor: cloneColor(defaultBgColor),
+			cursorColor: cloneColor(cursorColor),
+			specialColors: [...specialColors].map(([idx, color]) => [idx, { ...color }]),
+			pointerFgColor: cloneColor(pointerFgColor),
+			pointerBgColor: cloneColor(pointerBgColor),
+			highlightBgColor: cloneColor(highlightBgColor),
+			highlightFgColor: cloneColor(highlightFgColor)
+		};
+	}
+	function restoreColorState(snapshot) {
+		palette256 = snapshot.palette256.map((c) => ({ ...c }));
+		defaultFgColor = cloneColor(snapshot.defaultFgColor);
+		defaultBgColor = cloneColor(snapshot.defaultBgColor);
+		cursorColor = cloneColor(snapshot.cursorColor);
+		specialColors.clear();
+		for (const [idx, color] of snapshot.specialColors) specialColors.set(idx, { ...color });
+		pointerFgColor = cloneColor(snapshot.pointerFgColor);
+		pointerBgColor = cloneColor(snapshot.pointerBgColor);
+		highlightBgColor = cloneColor(snapshot.highlightBgColor);
+		highlightFgColor = cloneColor(snapshot.highlightFgColor);
+	}
+	let tabStops = defaultTabStops(cols);
+	function defaultTabStops(c) {
+		const s = /* @__PURE__ */ new Set();
+		for (let i = 8; i < c; i += 8) s.add(i);
+		return s;
+	}
+	function nextTabStop(x) {
+		for (let i = x + 1; i < cols; i++) if (tabStops.has(i)) return i;
+		if (tabStops.size === 0) return x;
+		return cols - 1;
+	}
+	function prevTabStop(x) {
+		for (let i = x - 1; i > 0; i--) if (tabStops.has(i)) return i;
+		return 0;
+	}
+	let textScale = 1;
+	const CELL_W_PX = 8;
+	const CELL_H_PX = 17;
+	const FONT_ASCENT_PX = 14;
+	let fontSize = 12;
+	let fontWindowSize = 12;
+	let locale = "en_US.UTF-8";
+	let advancedClipboard = "";
+	let viewportOffset = 0;
+	let charsetG0 = false;
+	let clipboard = "";
+	let cwd = "";
+	let notifications = [];
+	let semanticZones = [];
+	let hasSixel = false;
+	let sixelImages = [];
+	let mainSoftWrapped = new Array(rows).fill(false);
+	let altSoftWrapped = new Array(rows).fill(false);
+	let softWrapped = mainSoftWrapped;
+	let lastChar = "";
+	let pendingRegionalIndicator = null;
+	let afterZWJ = false;
+	let parserState = "ground";
+	let escBuf = "";
+	let oscBuf = "";
+	let dcsBuf = "";
+	let dcsStartRow = 0;
+	let dcsStartCol = 0;
+	let apcBuf = "";
+	const decoder = new TextDecoder();
+	function makeGrid(c, r) {
+		const g = [];
+		for (let row = 0; row < r; row++) g.push(makeRow(c));
+		return g;
+	}
+	function makeRow(c) {
+		const row = [];
+		for (let col = 0; col < c; col++) row.push(EMPTY_CELL);
+		return row;
+	}
+	function resetAttrs() {
+		return {
+			fg: null,
+			bg: null,
+			bold: false,
+			faint: false,
+			italic: false,
+			underline: "none",
+			underlineColor: null,
+			overline: false,
+			strikethrough: false,
+			inverse: false,
+			hidden: false,
+			blink: false,
+			url: null
+		};
+	}
+	function clampCursor() {
+		if (curX < 0) curX = 0;
+		if (curX >= cols) curX = cols - 1;
+		if (curY < 0) curY = 0;
+		if (curY >= rows) curY = rows - 1;
+	}
+	function scrollUp(top, bottom) {
+		if (leftRightMarginMode && (leftMargin > 0 || rightMargin < cols - 1)) {
+			const lm = leftMargin;
+			const rm = rightMargin;
+			for (let r = top; r < bottom; r++) {
+				const srcRow = grid[r + 1];
+				const dstRow = grid[r];
+				for (let c = lm; c <= rm && c < cols; c++) dstRow[c] = srcRow[c];
+			}
+			const bottomRow = grid[bottom];
+			for (let c = lm; c <= rm && c < cols; c++) bottomRow[c] = EMPTY_CELL;
+		} else {
+			if (grid === mainGrid && top === 0) {
+				scrollback.push(grid[0]);
+				if (scrollback.length > scrollbackLimit * 2) scrollback.splice(0, scrollback.length - scrollbackLimit);
+			}
+			for (let i = top; i < bottom; i++) {
+				grid[i] = grid[i + 1];
+				softWrapped[i] = softWrapped[i + 1];
+			}
+			grid[bottom] = makeRow(cols);
+			softWrapped[bottom] = false;
+		}
+	}
+	function scrollDown(top, bottom) {
+		if (leftRightMarginMode && (leftMargin > 0 || rightMargin < cols - 1)) {
+			const lm = leftMargin;
+			const rm = rightMargin;
+			for (let r = bottom; r > top; r--) {
+				const srcRow = grid[r - 1];
+				const dstRow = grid[r];
+				for (let c = lm; c <= rm && c < cols; c++) dstRow[c] = srcRow[c];
+			}
+			const topRow = grid[top];
+			for (let c = lm; c <= rm && c < cols; c++) topRow[c] = EMPTY_CELL;
+		} else {
+			for (let i = bottom; i > top; i--) {
+				grid[i] = grid[i - 1];
+				softWrapped[i] = softWrapped[i - 1];
+			}
+			grid[top] = makeRow(cols);
+			softWrapped[top] = false;
+		}
+	}
+	function scrollViewport(delta) {
+		viewportOffset = Math.max(0, Math.min(scrollback.length, viewportOffset + delta));
+	}
+	/** Find the previous non-spacer cell (the cell before curX, skipping wide-char spacers) */
+	function getPrevCell() {
+		if (curX === 0 && curY === 0) return null;
+		let prevCol = curX - 1;
+		let prevRow = curY;
+		if (prevCol < 0) {
+			prevRow--;
+			if (prevRow < 0) return null;
+			prevCol = cols - 1;
+		}
+		const row = grid[prevRow];
+		let cell = row[prevCol];
+		if (cell !== EMPTY_CELL && cell.char === "" && prevCol > 0) {
+			prevCol--;
+			cell = row[prevCol];
+		}
+		if (cell === EMPTY_CELL) return null;
+		return {
+			cell,
+			col: prevCol
+		};
+	}
+	/** Widen a cell to 2 columns, adding a spacer cell after it */
+	function widenCell(row, col, cell) {
+		cell.wide = true;
+		if (col + 1 < cols) {
+			let spacer = row[col + 1];
+			if (spacer === EMPTY_CELL) {
+				spacer = { ...EMPTY_CELL };
+				row[col + 1] = spacer;
+			}
+			spacer.char = "";
+			spacer.fg = null;
+			spacer.bg = null;
+			spacer.bold = false;
+			spacer.faint = false;
+			spacer.italic = false;
+			spacer.underline = "none";
+			spacer.underlineColor = null;
+			spacer.overline = false;
+			spacer.strikethrough = false;
+			spacer.inverse = false;
+			spacer.hidden = false;
+			spacer.blink = false;
+			spacer.wide = false;
+			spacer.url = null;
+		}
+	}
+	function writeChar(ch) {
+		if (charsetG0 && ch.length === 1) {
+			const mapped = DEC_SPECIAL_GRAPHICS[ch];
+			if (mapped) ch = mapped;
+		}
+		const codePoint = ch.codePointAt(0) ?? 0;
+		if (isVS16(codePoint)) {
+			const prev = getPrevCell();
+			if (prev && !prev.cell.wide) {
+				prev.cell.char += ch;
+				const row = grid[curY === 0 && curX === 0 ? 0 : curY];
+				widenCell(row, prev.col, prev.cell);
+				curX = prev.col + 2;
+				if (curX >= cols) curX = cols - 1;
+			}
+			return;
+		}
+		if (isCombining(codePoint) && !isVS16(codePoint)) {
+			const prev = getPrevCell();
+			if (prev) prev.cell.char += ch;
+			return;
+		}
+		if (isEmojiModifier(codePoint)) {
+			const prev = getPrevCell();
+			if (prev) prev.cell.char += ch;
+			return;
+		}
+		if (isZWJ(codePoint)) {
+			const prev = getPrevCell();
+			if (prev) {
+				prev.cell.char += ch;
+				afterZWJ = true;
+			}
+			return;
+		}
+		if (afterZWJ) {
+			afterZWJ = false;
+			const prev = getPrevCell();
+			if (prev) {
+				prev.cell.char += ch;
+				return;
+			}
+		}
+		if (isRegionalIndicator(codePoint)) if (pendingRegionalIndicator !== null) {
+			const flag = pendingRegionalIndicator + ch;
+			pendingRegionalIndicator = null;
+			writeCharCore(flag, true);
+			return;
+		} else {
+			pendingRegionalIndicator = ch;
+			return;
+		}
+		if (pendingRegionalIndicator !== null) {
+			const ri = pendingRegionalIndicator;
+			pendingRegionalIndicator = null;
+			writeCharCore(ri, true);
+		}
+		const wide = isWide(codePoint);
+		writeCharCore(ch, wide);
+	}
+	function writeCharCore(ch, wide) {
+		if (cols <= 0 || rows <= 0) return;
+		const charWidth = wide ? 2 : 1;
+		const wrapBoundary = leftRightMarginMode ? rightMargin + 1 : cols;
+		const wrapReturn = leftRightMarginMode ? leftMargin : 0;
+		if (curX + charWidth > wrapBoundary) if (autoWrap) {
+			softWrapped[curY] = true;
+			curX = wrapReturn;
+			curY++;
+			if (curY > scrollBottom) {
+				curY = scrollBottom;
+				scrollUp(scrollTop, scrollBottom);
+			}
+		} else curX = wrapBoundary - charWidth;
+		if (insertMode) {
+			const row = grid[curY];
+			const insertEnd = leftRightMarginMode ? rightMargin + 1 : cols;
+			for (let i = 0; i < charWidth; i++) {
+				row.splice(insertEnd - 1, 1);
+				row.splice(curX, 0, EMPTY_CELL);
+			}
+		}
+		const row = grid[curY];
+		let cell = row[curX];
+		if (cell === EMPTY_CELL) {
+			cell = { ...EMPTY_CELL };
+			row[curX] = cell;
+		}
+		cell.char = ch;
+		cell.fg = attrs.fg ? { ...attrs.fg } : null;
+		cell.bg = attrs.bg ? { ...attrs.bg } : null;
+		cell.bold = attrs.bold;
+		cell.faint = attrs.faint;
+		cell.italic = attrs.italic;
+		cell.underline = attrs.underline;
+		cell.underlineColor = attrs.underlineColor ? { ...attrs.underlineColor } : null;
+		cell.overline = attrs.overline;
+		cell.strikethrough = attrs.strikethrough;
+		cell.inverse = attrs.inverse;
+		cell.hidden = attrs.hidden;
+		cell.blink = attrs.blink;
+		cell.wide = wide;
+		cell.url = attrs.url;
+		if (wide) widenCell(row, curX, cell);
+		curX += charWidth;
+		lastChar = ch;
+	}
+	function handleCSI(params, intermediates, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (intermediates === " ") {
+			if (finalByte === "q") switch (parts[0] ?? 0) {
+				case 0:
+				case 1:
+					cursorShape = "block";
+					cursorBlinking = true;
+					break;
+				case 2:
+					cursorShape = "block";
+					cursorBlinking = false;
+					break;
+				case 3:
+					cursorShape = "underline";
+					cursorBlinking = true;
+					break;
+				case 4:
+					cursorShape = "underline";
+					cursorBlinking = false;
+					break;
+				case 5:
+					cursorShape = "bar";
+					cursorBlinking = true;
+					break;
+				case 6:
+					cursorShape = "bar";
+					cursorBlinking = false;
+					break;
+			}
+			else if (finalByte === "@") handleShiftLeft(Math.max(parts[0] ?? 1, 1));
+			else if (finalByte === "A") handleShiftRight(Math.max(parts[0] ?? 1, 1));
+			return;
+		}
+		if (intermediates === "!") {
+			if (finalByte === "p") softReset();
+			return;
+		}
+		if (intermediates === "$") {
+			const normalizeRect = (top, left, bottom, right) => {
+				return {
+					t: Math.max(1, top) - 1,
+					l: Math.max(1, left) - 1,
+					b: (bottom <= 0 ? rows : Math.min(bottom, rows)) - 1,
+					r: (right <= 0 ? cols : Math.min(right, cols)) - 1
+				};
+			};
+			if (finalByte === "x") {
+				const charCode = parts[0] ?? 32;
+				if (charCode < 32 || charCode > 126) return;
+				const { t, l, b, r } = normalizeRect(parts[1] ?? 1, parts[2] ?? 1, parts[3] ?? rows, parts[4] ?? cols);
+				for (let row = t; row <= b && row < rows; row++) for (let col = l; col <= r && col < cols; col++) {
+					const cell = emptyCell();
+					cell.char = String.fromCharCode(charCode);
+					grid[row][col] = cell;
+				}
+			} else if (finalByte === "z" || finalByte === "{") {
+				const { t, l, b, r } = normalizeRect(parts[0] ?? 1, parts[1] ?? 1, parts[2] ?? rows, parts[3] ?? cols);
+				for (let row = t; row <= b && row < rows; row++) for (let col = l; col <= r && col < cols; col++) grid[row][col] = emptyCell();
+			} else if (finalByte === "v") {
+				const src = normalizeRect(parts[0] ?? 1, parts[1] ?? 1, parts[2] ?? rows, parts[3] ?? cols);
+				const dstTop = Math.max(1, parts[5] ?? 1) - 1;
+				const dstLeft = Math.max(1, parts[6] ?? 1) - 1;
+				const h = src.b - src.t + 1;
+				const w = src.r - src.l + 1;
+				const snapshot = [];
+				for (let row = 0; row < h; row++) {
+					const line = [];
+					for (let col = 0; col < w; col++) {
+						const srcCell = grid[src.t + row]?.[src.l + col] ?? EMPTY_CELL;
+						line.push(srcCell === EMPTY_CELL ? EMPTY_CELL : { ...srcCell });
+					}
+					snapshot.push(line);
+				}
+				for (let row = 0; row < h; row++) {
+					const dr = dstTop + row;
+					if (dr < 0 || dr >= rows) continue;
+					for (let col = 0; col < w; col++) {
+						const dc = dstLeft + col;
+						if (dc < 0 || dc >= cols) continue;
+						grid[dr][dc] = snapshot[row][col];
+					}
+				}
+			} else if (finalByte === "r" || finalByte === "t") {
+				const { t, l, b, r } = normalizeRect(parts[0] ?? 1, parts[1] ?? 1, parts[2] ?? rows, parts[3] ?? cols);
+				const sgrParts = parts.slice(4);
+				const reverse = finalByte === "t";
+				for (let row = t; row <= b && row < rows; row++) for (let col = l; col <= r && col < cols; col++) {
+					let cell = grid[row][col];
+					if (cell === EMPTY_CELL) {
+						cell = { ...EMPTY_CELL };
+						grid[row][col] = cell;
+					}
+					applyRectAttrs(cell, sgrParts, reverse);
+				}
+			}
+			return;
+		}
+		if (intermediates === "*") {
+			if (finalByte === "y") {
+				const pid = parts[0] ?? 0;
+				const tArg = parts[2] ?? 1;
+				const lArg = parts[3] ?? 1;
+				const bArg = parts[4] ?? rows;
+				const rArg = parts[5] ?? cols;
+				const t = Math.max(1, tArg) - 1;
+				const l = Math.max(1, lArg) - 1;
+				const b = Math.min(bArg, rows) - 1;
+				const r = Math.min(rArg, cols) - 1;
+				let sum = 0;
+				for (let row = t; row <= b && row < rows; row++) for (let col = l; col <= r && col < cols; col++) {
+					const cell = grid[row]?.[col];
+					if (cell?.char) {
+						const cp = cell.char.codePointAt(0) ?? 0;
+						sum = sum + cp & 65535;
+					}
+				}
+				const hex = sum.toString(16).toUpperCase().padStart(4, "0");
+				if (onResponse) onResponse(`\x1bP${pid}!~${hex}\x1b\\`);
+			} else if (finalByte === "x") {}
+			return;
+		}
+		if (intermediates === "'") {
+			if (finalByte === "}") handleInsertColumn(Math.max(parts[0] ?? 1, 1));
+			else if (finalByte === "~") handleDeleteColumn(Math.max(parts[0] ?? 1, 1));
+			return;
+		}
+		switch (finalByte) {
+			case "A":
+				curY -= Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "B":
+				curY += Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "C":
+				curX += Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "D":
+				curX -= Math.max(parts[0] ?? 1, 1);
+				clampCursor();
+				break;
+			case "E":
+				curY += Math.max(parts[0] ?? 1, 1);
+				curX = 0;
+				clampCursor();
+				break;
+			case "F":
+				curY -= Math.max(parts[0] ?? 1, 1);
+				curX = 0;
+				clampCursor();
+				break;
+			case "G":
+			case "`":
+				curX = (parts[0] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "g":
+				if ((parts[0] ?? 0) === 3) tabStops.clear();
+				else tabStops.delete(curX);
+				break;
+			case "I": {
+				const count = Math.max(parts[0] ?? 1, 1);
+				for (let t = 0; t < count; t++) curX = nextTabStop(curX);
+				clampCursor();
+				break;
+			}
+			case "Z": {
+				const count = Math.max(parts[0] ?? 1, 1);
+				for (let t = 0; t < count; t++) curX = prevTabStop(curX);
+				clampCursor();
+				break;
+			}
+			case "t": {
+				const op = parts[0] ?? 0;
+				if (!onResponse) break;
+				const CELL_H = 16;
+				const CELL_W = 8;
+				switch (op) {
+					case 14:
+						onResponse(`\x1b[4;${rows * CELL_H};${cols * CELL_W}t`);
+						break;
+					case 16:
+						onResponse(`\x1b[6;${CELL_H};${CELL_W}t`);
+						break;
+					case 18:
+						onResponse(`\x1b[8;${rows};${cols}t`);
+						break;
+					case 20:
+						onResponse(`\x1b]L${title}\x1b\\`);
+						break;
+					case 21:
+						onResponse(`\x1b]l${title}\x1b\\`);
+						break;
+				}
+				break;
+			}
+			case "H":
+			case "f":
+				if (originMode) {
+					curY = scrollTop + (parts[0] ?? 1) - 1;
+					curX = (parts[1] ?? 1) - 1;
+					if (curY < scrollTop) curY = scrollTop;
+					if (curY > scrollBottom) curY = scrollBottom;
+					if (curX < 0) curX = 0;
+					if (curX >= cols) curX = cols - 1;
+				} else {
+					curY = (parts[0] ?? 1) - 1;
+					curX = (parts[1] ?? 1) - 1;
+					clampCursor();
+				}
+				break;
+			case "J":
+				handleEraseDisplay(parts[0] ?? 0);
+				break;
+			case "K":
+				handleEraseLine(parts[0] ?? 0);
+				break;
+			case "L":
+				handleInsertLines(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "M":
+				handleDeleteLines(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "P":
+				handleDeleteChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "@":
+				handleInsertChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "X":
+				handleEraseChars(Math.max(parts[0] ?? 1, 1));
+				break;
+			case "S":
+				for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) scrollUp(scrollTop, scrollBottom);
+				break;
+			case "T":
+				for (let i = 0; i < Math.max(parts[0] ?? 1, 1); i++) scrollDown(scrollTop, scrollBottom);
+				break;
+			case "b":
+				if (lastChar) {
+					const count = Math.max(parts[0] ?? 1, 1);
+					for (let i = 0; i < count; i++) writeChar(lastChar);
+				}
+				break;
+			case "d":
+				curY = (parts[0] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "m":
+				handleSGR(params);
+				break;
+			case "r":
+				scrollTop = (parts[0] ?? 1) - 1;
+				scrollBottom = (parts[1] ?? rows) - 1;
+				if (scrollTop < 0) scrollTop = 0;
+				if (scrollBottom >= rows) scrollBottom = rows - 1;
+				if (scrollTop > scrollBottom) {
+					scrollTop = 0;
+					scrollBottom = rows - 1;
+				}
+				curX = 0;
+				curY = originMode ? scrollTop : 0;
+				break;
+			case "n":
+				if (onResponse) {
+					if (parts[0] === 5) onResponse("\x1B[0n");
+					else if (parts[0] === 6) onResponse(`\x1b[${curY + 1};${curX + 1}R`);
+				}
+				break;
+			case "c":
+				if (onResponse) {
+					if (params === "" || params === "0") onResponse("\x1B[?62;4c");
+				}
+				break;
+			case "h":
+				for (const code of parts) if (code === 4) insertMode = true;
+				break;
+			case "l":
+				for (const code of parts) if (code === 4) insertMode = false;
+				break;
+			case "s":
+				if (leftRightMarginMode && intermediates === "") {
+					const pl = parts[0] ?? 0;
+					const pr = parts[1] ?? 0;
+					leftMargin = pl > 0 ? pl - 1 : 0;
+					rightMargin = pr > 0 ? pr - 1 : cols - 1;
+					if (leftMargin >= rightMargin) {
+						leftMargin = 0;
+						rightMargin = cols - 1;
+					}
+					if (leftMargin >= cols) leftMargin = 0;
+					if (rightMargin >= cols) rightMargin = cols - 1;
+					curX = originMode ? leftMargin : 0;
+					curY = originMode ? scrollTop : 0;
+				} else {
+					savedCurX = curX;
+					savedCurY = curY;
+				}
+				break;
+			case "u":
+				curX = savedCurX;
+				curY = savedCurY;
+				clampCursor();
+				break;
+			default: break;
+		}
+	}
+	function handleCSIGt(params, _intermediates, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (finalByte === "c") {
+			if (onResponse) {
+				if (params === "" || params === "0") onResponse("\x1B[>1;100;0c");
+			}
+		} else if (finalByte === "q") {
+			if (onResponse) {
+				if (params === "" || params === "0") onResponse("\x1BP>|vterm.js 0.1.0\x1B\\");
+			}
+		} else if (finalByte === "u") {
+			kittyKeyboardStack.push(kittyKeyboardFlags);
+			kittyKeyboardFlags = parts[0] ?? 0;
+		}
+	}
+	function handleCSILt(_params, _intermediates, finalByte) {
+		if (finalByte === "u") kittyKeyboardFlags = kittyKeyboardStack.pop() ?? 0;
+	}
+	function handleCSIEq(params, _intermediates, finalByte) {
+		if (finalByte === "c") {
+			if (onResponse) {
+				if (params === "" || params === "0") onResponse("\x1BP!|00000000\x1B\\");
+			}
+		}
+	}
+	function handleCSIPrivate(params, intermediates, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (finalByte === "u") {
+			if (onResponse) onResponse(`\x1b[?${kittyKeyboardFlags}u`);
+			return;
+		}
+		if (intermediates === "$" && finalByte === "p") {
+			if (onResponse) {
+				const mode = parts[0] ?? 0;
+				let value = 0;
+				switch (mode) {
+					case 1:
+						value = applicationCursor ? 1 : 2;
+						break;
+					case 6:
+						value = originMode ? 1 : 2;
+						break;
+					case 7:
+						value = autoWrap ? 1 : 2;
+						break;
+					case 25:
+						value = curVisible ? 1 : 2;
+						break;
+					case 47:
+					case 1047:
+					case 1049:
+						value = useAltScreen ? 1 : 2;
+						break;
+					case 66:
+						value = applicationKeypad ? 1 : 2;
+						break;
+					case 1e3:
+					case 1002:
+					case 1003:
+						value = mouseTracking ? 1 : 2;
+						break;
+					case 1004:
+						value = focusTracking ? 1 : 2;
+						break;
+					case 1006:
+						value = sgrMouse ? 1 : 2;
+						break;
+					case 2004:
+						value = bracketedPaste ? 1 : 2;
+						break;
+					case 2026:
+						value = syncOutput ? 1 : 2;
+						break;
+					case 69:
+						value = leftRightMarginMode ? 1 : 2;
+						break;
+					case 2031:
+						value = colorSchemeReporting ? 1 : 2;
+						break;
+					case 5:
+						value = reverseVideo ? 1 : 2;
+						break;
+					case 4:
+						value = insertMode ? 1 : 2;
+						break;
+					case 3:
+						value = decColumnMode ? 1 : 2;
+						break;
+					case 1005:
+						value = utf8MouseMode ? 1 : 2;
+						break;
+					case 1007:
+						value = altScrollMode ? 1 : 2;
+						break;
+					case 1048:
+						value = 2;
+						break;
+				}
+				onResponse(`\x1b[?${mode};${value}$y`);
+			}
+			return;
+		}
+		if (finalByte === "n") {
+			if (onResponse) {
+				const ps = parts[0] ?? 0;
+				if (ps === 6) onResponse(`\x1b[?${curY + 1};${curX + 1}n`);
+				else if (ps === 997) onResponse("\x1B[?997;1n");
+			}
+			return;
+		}
+		if (finalByte === "J") {
+			handleEraseDisplay(parts[0] ?? 0);
+			return;
+		}
+		if (finalByte === "K") {
+			handleEraseLine(parts[0] ?? 0);
+			return;
+		}
+		const set = finalByte === "h";
+		for (const code of parts) switch (code) {
+			case 1:
+				applicationCursor = set;
+				break;
+			case 4:
+				insertMode = set;
+				break;
+			case 5:
+				reverseVideo = set;
+				break;
+			case 6:
+				originMode = set;
+				break;
+			case 7:
+				autoWrap = set;
+				break;
+			case 25:
+				curVisible = set;
+				break;
+			case 47:
+			case 1047:
+				if (set && !useAltScreen) {
+					useAltScreen = true;
+					grid = altGrid;
+					softWrapped = altSoftWrapped;
+				} else if (!set && useAltScreen) {
+					useAltScreen = false;
+					grid = mainGrid;
+					softWrapped = mainSoftWrapped;
+				}
+				break;
+			case 66:
+				applicationKeypad = set;
+				break;
+			case 9:
+			case 1e3:
+			case 1002:
+			case 1003:
+			case 1015:
+			case 1016:
+				mouseTracking = set;
+				mouseTrackingMode = set ? code : 0;
+				break;
+			case 1004:
+				focusTracking = set;
+				break;
+			case 1006:
+				sgrMouse = set;
+				break;
+			case 1049:
+				if (set && !useAltScreen) {
+					savedCurX = curX;
+					savedCurY = curY;
+					useAltScreen = true;
+					altGrid = makeGrid(cols, rows);
+					altSoftWrapped = new Array(rows).fill(false);
+					grid = altGrid;
+					softWrapped = altSoftWrapped;
+					curX = 0;
+					curY = 0;
+				} else if (!set && useAltScreen) {
+					useAltScreen = false;
+					grid = mainGrid;
+					softWrapped = mainSoftWrapped;
+					curX = savedCurX;
+					curY = savedCurY;
+					clampCursor();
+				}
+				break;
+			case 69:
+				leftRightMarginMode = set;
+				if (!set) {
+					leftMargin = 0;
+					rightMargin = cols - 1;
+				}
+				break;
+			case 2004:
+				bracketedPaste = set;
+				break;
+			case 2026:
+				syncOutput = set;
+				break;
+			case 2031:
+				colorSchemeReporting = set;
+				break;
+			case 3:
+				decColumnMode = set;
+				for (let row = 0; row < rows; row++) eraseCells(row, 0, row, cols - 1);
+				curX = 0;
+				curY = 0;
+				break;
+			case 1005:
+				utf8MouseMode = set;
+				break;
+			case 1007:
+				altScrollMode = set;
+				break;
+			case 1048:
+				if (set) {
+					savedCurX = curX;
+					savedCurY = curY;
+				} else {
+					curX = savedCurX;
+					curY = savedCurY;
+					clampCursor();
+				}
+				break;
+		}
+	}
+	function handleEraseDisplay(mode) {
+		switch (mode) {
+			case 0:
+				eraseCells(curY, curX, curY, cols - 1);
+				for (let row = curY + 1; row < rows; row++) eraseCells(row, 0, row, cols - 1);
+				break;
+			case 1:
+				for (let row = 0; row < curY; row++) eraseCells(row, 0, row, cols - 1);
+				eraseCells(curY, 0, curY, curX);
+				break;
+			case 2:
+			case 3:
+				for (let row = 0; row < rows; row++) eraseCells(row, 0, row, cols - 1);
+				if (mode === 3) scrollback.length = 0;
+				break;
+		}
+	}
+	function handleEraseLine(mode) {
+		const eraseRight = leftRightMarginMode ? rightMargin : cols - 1;
+		const eraseLeft = leftRightMarginMode ? leftMargin : 0;
+		switch (mode) {
+			case 0:
+				eraseCells(curY, curX, curY, eraseRight);
+				break;
+			case 1:
+				eraseCells(curY, eraseLeft, curY, curX);
+				break;
+			case 2:
+				eraseCells(curY, eraseLeft, curY, eraseRight);
+				break;
+		}
+	}
+	function eraseCells(row, startCol, _endRow, endCol) {
+		const r = grid[row];
+		if (!r) return;
+		for (let col = startCol; col <= endCol && col < cols; col++) {
+			const cell = emptyCell();
+			if (attrs.bg) cell.bg = { ...attrs.bg };
+			r[col] = cell;
+		}
+	}
+	function handleInsertLines(count) {
+		if (curY < scrollTop || curY > scrollBottom) return;
+		for (let i = 0; i < count; i++) scrollDown(curY, scrollBottom);
+	}
+	function handleDeleteLines(count) {
+		if (curY < scrollTop || curY > scrollBottom) return;
+		for (let i = 0; i < count; i++) scrollUp(curY, scrollBottom);
+	}
+	function handleDeleteChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		if (leftRightMarginMode && (leftMargin > 0 || rightMargin < cols - 1)) {
+			for (let i = 0; i < count; i++) if (curX <= rightMargin) {
+				row.splice(curX, 1);
+				row.splice(rightMargin, 0, emptyCell());
+			}
+		} else for (let i = 0; i < count; i++) if (curX < cols) {
+			row.splice(curX, 1);
+			row.push(emptyCell());
+		}
+	}
+	function handleInsertChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		if (leftRightMarginMode && (leftMargin > 0 || rightMargin < cols - 1)) for (let i = 0; i < count; i++) {
+			row.splice(rightMargin, 1);
+			row.splice(curX, 0, emptyCell());
+		}
+		else for (let i = 0; i < count; i++) {
+			row.splice(curX, 0, emptyCell());
+			row.pop();
+		}
+	}
+	function handleEraseChars(count) {
+		const row = grid[curY];
+		if (!row) return;
+		for (let i = 0; i < count && curX + i < cols; i++) row[curX + i] = emptyCell();
+	}
+	/** Bounds of the active scroll/margin rectangle (inclusive). */
+	function activeRect() {
+		return {
+			top: scrollTop,
+			bottom: scrollBottom,
+			left: leftRightMarginMode ? leftMargin : 0,
+			right: leftRightMarginMode ? rightMargin : cols - 1
+		};
+	}
+	function handleShiftLeft(count) {
+		const { top, left, bottom, right } = activeRect();
+		for (let row = top; row <= bottom; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			for (let col = left; col <= right; col++) {
+				const src = col + count;
+				r[col] = src <= right ? r[src] : emptyCell();
+			}
+		}
+	}
+	function handleShiftRight(count) {
+		const { top, left, bottom, right } = activeRect();
+		for (let row = top; row <= bottom; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			for (let col = right; col >= left; col--) {
+				const src = col - count;
+				r[col] = src >= left ? r[src] : emptyCell();
+			}
+		}
+	}
+	function handleInsertColumn(count) {
+		const { top, left, bottom, right } = activeRect();
+		if (curX < left || curX > right) return;
+		for (let row = top; row <= bottom; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			for (let col = right; col >= curX + count; col--) r[col] = r[col - count];
+			for (let col = curX; col < curX + count && col <= right; col++) r[col] = emptyCell();
+		}
+	}
+	function handleDeleteColumn(count) {
+		const { top, left, bottom, right } = activeRect();
+		if (curX < left || curX > right) return;
+		for (let row = top; row <= bottom; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			for (let col = curX; col + count <= right; col++) r[col] = r[col + count];
+			for (let col = right - count + 1; col <= right && col >= 0; col++) r[col] = emptyCell();
+		}
+	}
+	/**
+	* Apply (or reverse-toggle) a list of SGR attribute codes to a single cell.
+	* Used by DECCARA (set) and DECRARA (toggle). Only attributes that DECCARA/DECRARA
+	* operate on are handled: bold (1/22), underline (4/24), blink (5/25), inverse (7/27).
+	*/
+	function applyRectAttrs(cell, sgrParts, reverse) {
+		for (const p of sgrParts) switch (p) {
+			case 0:
+				if (reverse) {
+					cell.bold = !cell.bold;
+					cell.underline = cell.underline === "none" ? "single" : "none";
+					cell.blink = !cell.blink;
+					cell.inverse = !cell.inverse;
+				} else {
+					cell.bold = false;
+					cell.underline = "none";
+					cell.blink = false;
+					cell.inverse = false;
+				}
+				break;
+			case 1:
+				cell.bold = reverse ? !cell.bold : true;
+				break;
+			case 4:
+				if (reverse) cell.underline = cell.underline === "none" ? "single" : "none";
+				else cell.underline = "single";
+				break;
+			case 5:
+				cell.blink = reverse ? !cell.blink : true;
+				break;
+			case 7:
+				cell.inverse = reverse ? !cell.inverse : true;
+				break;
+			case 22:
+				cell.bold = false;
+				break;
+			case 24:
+				cell.underline = "none";
+				break;
+			case 25:
+				cell.blink = false;
+				break;
+			case 27:
+				cell.inverse = false;
+				break;
+		}
+	}
+	function handleSGR(rawParams) {
+		const segments = rawParams.split(";");
+		const params = [];
+		const subParams = /* @__PURE__ */ new Map();
+		for (const seg of segments) if (seg.includes(":")) {
+			const subs = seg.split(":").map((s) => s === "" ? 0 : parseInt(s, 10));
+			subParams.set(params.length, subs);
+			params.push(subs[0]);
+		} else params.push(seg === "" ? 0 : parseInt(seg, 10));
+		if (params.length === 0 || params.length === 1 && params[0] === 0) {
+			attrs = resetAttrs();
+			return;
+		}
+		let i = 0;
+		while (i < params.length) {
+			const code = params[i];
+			switch (code) {
+				case 0:
+					attrs = resetAttrs();
+					break;
+				case 1:
+					attrs.bold = true;
+					break;
+				case 2:
+					attrs.faint = true;
+					break;
+				case 3:
+					attrs.italic = true;
+					break;
+				case 4: {
+					const subs = subParams.get(i);
+					if (subs && subs.length > 1) switch (subs[1]) {
+						case 0:
+							attrs.underline = "none";
+							break;
+						case 1:
+							attrs.underline = "single";
+							break;
+						case 2:
+							attrs.underline = "double";
+							break;
+						case 3:
+							attrs.underline = "curly";
+							break;
+						case 4:
+							attrs.underline = "dotted";
+							break;
+						case 5:
+							attrs.underline = "dashed";
+							break;
+						default:
+							attrs.underline = "single";
+							break;
+					}
+					else attrs.underline = "single";
+					break;
+				}
+				case 5:
+					attrs.blink = true;
+					break;
+				case 6:
+					attrs.blink = true;
+					break;
+				case 7:
+					attrs.inverse = true;
+					break;
+				case 8:
+					attrs.hidden = true;
+					break;
+				case 9:
+					attrs.strikethrough = true;
+					break;
+				case 21:
+					attrs.underline = "double";
+					break;
+				case 22:
+					attrs.bold = false;
+					attrs.faint = false;
+					break;
+				case 23:
+					attrs.italic = false;
+					break;
+				case 24:
+					attrs.underline = "none";
+					break;
+				case 25:
+					attrs.blink = false;
+					break;
+				case 27:
+					attrs.inverse = false;
+					break;
+				case 28:
+					attrs.hidden = false;
+					break;
+				case 29:
+					attrs.strikethrough = false;
+					break;
+				case 30:
+				case 31:
+				case 32:
+				case 33:
+				case 34:
+				case 35:
+				case 36:
+				case 37:
+					attrs.fg = { ...palette256[code - 30] };
+					break;
+				case 38: {
+					const subs = subParams.get(i);
+					if (subs && subs.length >= 3) {
+						const result = parseExtendedColorFromSubs(subs);
+						if (result) attrs.fg = result;
+					} else {
+						const result = parseExtendedColor(params, i);
+						if (result) {
+							attrs.fg = result.color;
+							i = result.nextIndex - 1;
+						}
+					}
+					break;
+				}
+				case 39:
+					attrs.fg = null;
+					break;
+				case 40:
+				case 41:
+				case 42:
+				case 43:
+				case 44:
+				case 45:
+				case 46:
+				case 47:
+					attrs.bg = { ...palette256[code - 40] };
+					break;
+				case 48: {
+					const subs = subParams.get(i);
+					if (subs && subs.length >= 3) {
+						const result = parseExtendedColorFromSubs(subs);
+						if (result) attrs.bg = result;
+					} else {
+						const result = parseExtendedColor(params, i);
+						if (result) {
+							attrs.bg = result.color;
+							i = result.nextIndex - 1;
+						}
+					}
+					break;
+				}
+				case 49:
+					attrs.bg = null;
+					break;
+				case 53:
+					attrs.overline = true;
+					break;
+				case 55:
+					attrs.overline = false;
+					break;
+				case 58: {
+					const subs = subParams.get(i);
+					if (subs && subs.length >= 3) {
+						const result = parseExtendedColorFromSubs(subs);
+						if (result) attrs.underlineColor = result;
+					} else {
+						const result = parseExtendedColor(params, i);
+						if (result) {
+							attrs.underlineColor = result.color;
+							i = result.nextIndex - 1;
+						}
+					}
+					break;
+				}
+				case 59:
+					attrs.underlineColor = null;
+					break;
+				case 90:
+				case 91:
+				case 92:
+				case 93:
+				case 94:
+				case 95:
+				case 96:
+				case 97:
+					attrs.fg = { ...palette256[code - 90 + 8] };
+					break;
+				case 100:
+				case 101:
+				case 102:
+				case 103:
+				case 104:
+				case 105:
+				case 106:
+				case 107:
+					attrs.bg = { ...palette256[code - 100 + 8] };
+					break;
+			}
+			i++;
+		}
+	}
+	function parseExtendedColor(params, startIndex) {
+		if (startIndex + 1 >= params.length) return null;
+		const type = params[startIndex + 1];
+		if (type === 5 && startIndex + 2 < params.length) {
+			const idx = params[startIndex + 2];
+			return {
+				color: { ...palette256[idx] ?? {
+					r: 0,
+					g: 0,
+					b: 0
+				} },
+				nextIndex: startIndex + 3
+			};
+		} else if (type === 2 && startIndex + 4 < params.length) return {
+			color: {
+				r: params[startIndex + 2],
+				g: params[startIndex + 3],
+				b: params[startIndex + 4]
+			},
+			nextIndex: startIndex + 5
+		};
+		return null;
+	}
+	/** Parse extended color from colon sub-parameters (e.g., 38:2:R:G:B or 38:5:N) */
+	function parseExtendedColorFromSubs(subs) {
+		if (subs.length < 3) return null;
+		const type = subs[1];
+		if (type === 5 && subs.length >= 3) {
+			const idx = subs[2];
+			return { ...palette256[idx] ?? {
+				r: 0,
+				g: 0,
+				b: 0
+			} };
+		} else if (type === 2) {
+			if (subs.length >= 5) {
+				if (subs.length >= 6) return {
+					r: subs[3],
+					g: subs[4],
+					b: subs[5]
+				};
+				return {
+					r: subs[2],
+					g: subs[3],
+					b: subs[4]
+				};
+			} else if (subs.length >= 4) return {
+				r: subs[2],
+				g: subs[3],
+				b: 0
+			};
+		}
+		return null;
+	}
+	function handleOSC(oscString) {
+		const semicolonIdx = oscString.indexOf(";");
+		const code = semicolonIdx === -1 ? parseInt(oscString, 10) : parseInt(oscString.substring(0, semicolonIdx), 10);
+		if (isNaN(code)) return;
+		const value = semicolonIdx === -1 ? "" : oscString.substring(semicolonIdx + 1);
+		switch (code) {
+			case 0:
+			case 2:
+				title = value;
+				break;
+			case 133:
+				switch (value.charAt(0)) {
+					case "A":
+						semanticZones.push({
+							type: "prompt",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "B":
+						semanticZones.push({
+							type: "command",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "C":
+						semanticZones.push({
+							type: "output",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "D": break;
+				}
+				break;
+			case 1: break;
+			case 7:
+				cwd = value;
+				break;
+			case 8: {
+				const secondSemicolon = value.indexOf(";");
+				if (secondSemicolon !== -1) {
+					const url = value.substring(secondSemicolon + 1);
+					attrs.url = url || null;
+				}
+				break;
+			}
+			case 4: {
+				const fields = value.split(";");
+				for (let fi = 0; fi + 1 < fields.length; fi += 2) {
+					const idx = parseInt(fields[fi], 10);
+					const spec = fields[fi + 1];
+					if (isNaN(idx) || idx < 0 || idx > 255) continue;
+					if (spec === "?") {
+						const c = palette256[idx];
+						if (c && onResponse) onResponse(`\x1b]4;${idx};${formatColorResponse(c)}\x1b\\`);
+					} else {
+						const c = parseColorSpec(spec);
+						if (c) palette256[idx] = c;
+					}
+				}
+				break;
+			}
+			case 5: {
+				const fields = value.split(";");
+				for (let fi = 0; fi + 1 < fields.length; fi += 2) {
+					const idx = parseInt(fields[fi], 10);
+					const spec = fields[fi + 1];
+					if (isNaN(idx) || idx < 0 || idx > 4) continue;
+					if (spec === "?") {
+						const c = specialColors.get(idx);
+						if (onResponse) onResponse(`\x1b]5;${idx};${c ? formatColorResponse(c) : "rgb:0000/0000/0000"}\x1b\\`);
+					} else {
+						const c = parseColorSpec(spec);
+						if (c) specialColors.set(idx, c);
+					}
+				}
+				break;
+			}
+			case 10:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]10;${formatColorResponse(defaultFgColor ?? {
+						r: 255,
+						g: 255,
+						b: 255
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) defaultFgColor = c;
+				}
+				break;
+			case 11:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]11;${formatColorResponse(defaultBgColor ?? {
+						r: 0,
+						g: 0,
+						b: 0
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) defaultBgColor = c;
+				}
+				break;
+			case 12:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]12;${formatColorResponse(cursorColor ?? defaultFgColor ?? {
+						r: 255,
+						g: 255,
+						b: 255
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) cursorColor = c;
+				}
+				break;
+			case 13:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]13;${formatColorResponse(pointerFgColor ?? defaultFgColor ?? {
+						r: 255,
+						g: 255,
+						b: 255
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) pointerFgColor = c;
+				}
+				break;
+			case 14:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]14;${formatColorResponse(pointerBgColor ?? defaultBgColor ?? {
+						r: 0,
+						g: 0,
+						b: 0
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) pointerBgColor = c;
+				}
+				break;
+			case 17:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]17;${formatColorResponse(highlightBgColor ?? defaultFgColor ?? {
+						r: 255,
+						g: 255,
+						b: 255
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) highlightBgColor = c;
+				}
+				break;
+			case 19:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]19;${formatColorResponse(highlightFgColor ?? defaultBgColor ?? {
+						r: 0,
+						g: 0,
+						b: 0
+					})}\x1b\\`);
+				} else {
+					const c = parseColorSpec(value);
+					if (c) highlightFgColor = c;
+				}
+				break;
+			case 21: {
+				const pairs = value.split(";").filter((p) => p.length > 0);
+				const response = [];
+				for (const pair of pairs) {
+					const eq = pair.indexOf("=");
+					if (eq === -1) continue;
+					const key = pair.substring(0, eq).trim();
+					const val = pair.substring(eq + 1).trim();
+					const isQuery = val === "?";
+					const paletteMatch = /^color(\d+)$/.exec(key);
+					if (paletteMatch) {
+						const idx = parseInt(paletteMatch[1], 10);
+						if (idx < 0 || idx > 255) continue;
+						if (isQuery) {
+							const c = palette256[idx];
+							if (c) response.push(`${key}=${formatColorResponse(c)}`);
+						} else if (val === "") {
+							const fresh = buildPalette256();
+							palette256[idx] = fresh[idx];
+						} else {
+							const c = parseColorSpec(val);
+							if (c) palette256[idx] = c;
+						}
+					} else if (key === "foreground") if (isQuery) {
+						const c = defaultFgColor ?? {
+							r: 255,
+							g: 255,
+							b: 255
+						};
+						response.push(`${key}=${formatColorResponse(c)}`);
+					} else if (val === "") defaultFgColor = null;
+					else {
+						const c = parseColorSpec(val);
+						if (c) defaultFgColor = c;
+					}
+					else if (key === "background") if (isQuery) {
+						const c = defaultBgColor ?? {
+							r: 0,
+							g: 0,
+							b: 0
+						};
+						response.push(`${key}=${formatColorResponse(c)}`);
+					} else if (val === "") defaultBgColor = null;
+					else {
+						const c = parseColorSpec(val);
+						if (c) defaultBgColor = c;
+					}
+					else if (key === "cursor") if (isQuery) {
+						const c = cursorColor ?? defaultFgColor ?? {
+							r: 255,
+							g: 255,
+							b: 255
+						};
+						response.push(`${key}=${formatColorResponse(c)}`);
+					} else if (val === "") cursorColor = null;
+					else {
+						const c = parseColorSpec(val);
+						if (c) cursorColor = c;
+					}
+					else if (key === "selection_background") if (isQuery) {
+						const c = highlightBgColor ?? defaultFgColor ?? {
+							r: 255,
+							g: 255,
+							b: 255
+						};
+						response.push(`${key}=${formatColorResponse(c)}`);
+					} else highlightBgColor = val === "" ? null : parseColorSpec(val);
+					else if (key === "selection_foreground") if (isQuery) {
+						const c = highlightFgColor ?? defaultBgColor ?? {
+							r: 0,
+							g: 0,
+							b: 0
+						};
+						response.push(`${key}=${formatColorResponse(c)}`);
+					} else highlightFgColor = val === "" ? null : parseColorSpec(val);
+				}
+				if (response.length > 0 && onResponse) onResponse(`\x1b]21;${response.join(";")}\x1b\\`);
+				break;
+			}
+			case 104:
+				if (value === "") palette256 = buildPalette256();
+				else {
+					const fresh = buildPalette256();
+					for (const tok of value.split(";")) {
+						const idx = parseInt(tok, 10);
+						if (!isNaN(idx) && idx >= 0 && idx < 256) palette256[idx] = fresh[idx];
+					}
+				}
+				break;
+			case 105:
+				if (value === "") specialColors.clear();
+				else for (const tok of value.split(";")) {
+					const idx = parseInt(tok, 10);
+					if (!isNaN(idx) && idx >= 0 && idx <= 4) specialColors.delete(idx);
+				}
+				break;
+			case 110:
+				defaultFgColor = null;
+				break;
+			case 111:
+				defaultBgColor = null;
+				break;
+			case 112:
+				cursorColor = null;
+				break;
+			case 113:
+				pointerFgColor = null;
+				break;
+			case 114:
+				pointerBgColor = null;
+				break;
+			case 117:
+				highlightBgColor = null;
+				break;
+			case 119:
+				highlightFgColor = null;
+				break;
+			case 52: {
+				const clipSemi = value.indexOf(";");
+				if (clipSemi !== -1) {
+					const data = value.substring(clipSemi + 1);
+					if (data === "?") {
+						if (onResponse) onResponse(`\x1b]52;c;${btoa(clipboard)}\x1b\\`);
+					} else {
+						try {
+							clipboard = atob(data);
+						} catch {
+							clipboard = "";
+						}
+						if (onResponse) onResponse(`\x1b]52;c;${data}\x1b\\`);
+					}
+				}
+				break;
+			}
+			case 9:
+				notifications.push(value);
+				break;
+			case 633:
+				switch (value.charAt(0)) {
+					case "A":
+						semanticZones.push({
+							type: "prompt",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "B":
+						semanticZones.push({
+							type: "command",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "C":
+						semanticZones.push({
+							type: "output",
+							startRow: curY,
+							startCol: curX
+						});
+						break;
+					case "D": break;
+				}
+				break;
+			case 66:
+				if (value === "?" && onResponse) onResponse(`\x1b]66;s=${textScale}\x1b\\`);
+				else {
+					const kvPairs = value.split(";");
+					for (const pair of kvPairs) {
+						const [k, v] = pair.split("=");
+						if (k === "s" && v !== void 0) {
+							const n = parseInt(v, 10);
+							if (!isNaN(n) && n > 0) textScale = n;
+						}
+					}
+				}
+				break;
+			case 701:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]701;${locale}\x1b\\`);
+				} else if (value !== "") locale = value;
+				break;
+			case 702:
+				if (onResponse) onResponse("\x1B]702;vterm.js;vterm;0;2\x1B\\");
+				break;
+			case 720: {
+				const n = parseInt(value, 10);
+				scrollViewport(!isNaN(n) && n > 0 ? n : 1);
+				break;
+			}
+			case 721: {
+				const n = parseInt(value, 10);
+				scrollViewport(-(!isNaN(n) && n > 0 ? n : 1));
+				break;
+			}
+			case 776:
+				if (onResponse) onResponse(`\x1b]776;${CELL_W_PX};${CELL_H_PX};${FONT_ASCENT_PX}\x1b\\`);
+				break;
+			case 7770:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]7770;${fontSize}\x1b\\`);
+				} else if (value === "") fontSize = 12;
+				else {
+					const n = parseInt(value, 10);
+					if (!isNaN(n) && n > 0) fontSize = n;
+				}
+				break;
+			case 7777:
+				if (value === "?") {
+					if (onResponse) onResponse(`\x1b]7777;${fontWindowSize}\x1b\\`);
+				} else if (value === "") fontWindowSize = 12;
+				else {
+					const n = parseInt(value, 10);
+					if (!isNaN(n) && n > 0) fontWindowSize = n;
+				}
+				break;
+			case 30001:
+				colorStack.push(snapshotColorState());
+				break;
+			case 30101: {
+				const snapshot = colorStack.pop();
+				if (snapshot) restoreColorState(snapshot);
+				break;
+			}
+			case 5522:
+				if (value === "?" && onResponse) onResponse(`\x1b]5522;${btoa(advancedClipboard)}\x1b\\`);
+				else try {
+					advancedClipboard = atob(value);
+				} catch {
+					advancedClipboard = "";
+				}
+				break;
+			case 1337:
+				if (value === "ReportCellSize" && onResponse) onResponse("\x1B]1337;ReportCellSize=16;8\x1B\\");
+				else if (value === "RequestCapabilities" && onResponse) onResponse("\x1B]1337;Capabilities=\x1B\\");
+				break;
+		}
+	}
+	function handleDCS(data) {
+		const match = data.match(/^(\d*(?:;\d*)*)q(.*)$/s);
+		if (match) {
+			hasSixel = true;
+			sixelImages.push({
+				data: match[2],
+				row: dcsStartRow,
+				col: dcsStartCol
+			});
+			return;
+		}
+		if (data.startsWith("$q") && onResponse) {
+			if (data.substring(2) === "\"p") onResponse("\x1BP1$r62;1\"p\x1B\\");
+			else onResponse("\x1BP0$r\x1B\\");
+			return;
+		}
+		if (data.startsWith("+q") && onResponse) {
+			if (data.substring(2) === "544e") onResponse(`\x1bP1+r544e=${Array.from(new TextEncoder().encode("vterm")).map((b) => b.toString(16).padStart(2, "0")).join("")}\x1b\\`);
+			else onResponse("\x1BP0+r\x1B\\");
+			return;
+		}
+	}
+	function handleAPC(data) {
+		if (!data.startsWith("G")) return;
+		hasKittyGraphics = true;
+		const semicolonIdx = data.indexOf(";");
+		const kvPart = semicolonIdx >= 0 ? data.substring(1, semicolonIdx) : data.substring(1);
+		const params = {};
+		for (const pair of kvPart.split(",")) {
+			const eqIdx = pair.indexOf("=");
+			if (eqIdx >= 0) params[pair.substring(0, eqIdx)] = pair.substring(eqIdx + 1);
+		}
+		if (params.a === "q" && onResponse) onResponse(`\x1b_Gi=${params.i ?? "0"};OK\x1b\\`);
+	}
+	function softReset() {
+		insertMode = false;
+		originMode = false;
+		autoWrap = true;
+		curVisible = true;
+		kittyKeyboardFlags = 0;
+		kittyKeyboardStack = [];
+		cursorShape = "block";
+		cursorBlinking = true;
+		applicationCursor = false;
+		applicationKeypad = false;
+		reverseVideo = false;
+		decColumnMode = false;
+		altScrollMode = false;
+		utf8MouseMode = false;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		leftRightMarginMode = false;
+		leftMargin = 0;
+		rightMargin = cols - 1;
+		attrs = resetAttrs();
+		charsetG0 = false;
+		curX = 0;
+		curY = 0;
+	}
+	function fullReset() {
+		mainGrid = makeGrid(cols, rows);
+		altGrid = makeGrid(cols, rows);
+		grid = mainGrid;
+		scrollback = [];
+		curX = 0;
+		curY = 0;
+		curVisible = true;
+		cursorShape = "block";
+		cursorBlinking = true;
+		savedCurX = 0;
+		savedCurY = 0;
+		savedState = {
+			curX: 0,
+			curY: 0,
+			attrs: resetAttrs(),
+			originMode: false,
+			autoWrap: true,
+			charsetG0: false
+		};
+		attrs = resetAttrs();
+		title = "";
+		useAltScreen = false;
+		bracketedPaste = false;
+		applicationCursor = false;
+		applicationKeypad = false;
+		autoWrap = true;
+		mouseTracking = false;
+		mouseTrackingMode = 0;
+		sgrMouse = false;
+		focusTracking = false;
+		originMode = false;
+		insertMode = false;
+		reverseVideo = false;
+		syncOutput = false;
+		kittyKeyboardFlags = 0;
+		kittyKeyboardStack = [];
+		hasKittyGraphics = false;
+		hasSixel = false;
+		sixelImages = [];
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		leftRightMarginMode = false;
+		leftMargin = 0;
+		rightMargin = cols - 1;
+		colorSchemeReporting = false;
+		decColumnMode = false;
+		altScrollMode = false;
+		utf8MouseMode = false;
+		textScale = 1;
+		fontSize = 12;
+		fontWindowSize = 12;
+		locale = "en_US.UTF-8";
+		advancedClipboard = "";
+		viewportOffset = 0;
+		charsetG0 = false;
+		clipboard = "";
+		cwd = "";
+		notifications = [];
+		palette256 = buildPalette256();
+		defaultFgColor = null;
+		defaultBgColor = null;
+		cursorColor = null;
+		specialColors.clear();
+		pointerFgColor = null;
+		pointerBgColor = null;
+		highlightBgColor = null;
+		highlightFgColor = null;
+		colorStack.length = 0;
+		tabStops = defaultTabStops(cols);
+		lastChar = "";
+		pendingRegionalIndicator = null;
+		afterZWJ = false;
+		parserState = "ground";
+		escBuf = "";
+		oscBuf = "";
+		apcBuf = "";
+		semanticZones = [];
+		mainSoftWrapped = new Array(rows).fill(false);
+		altSoftWrapped = new Array(rows).fill(false);
+		softWrapped = mainSoftWrapped;
+	}
+	function process(data) {
+		const text = decoder.decode(data, { stream: true });
+		for (let i = 0; i < text.length; i++) {
+			const ch = text[i];
+			const code = text.charCodeAt(i);
+			switch (parserState) {
+				case "ground":
+					if (code === 27) {
+						parserState = "escape";
+						escBuf = "";
+					} else if (code === 7) {} else if (code === 8) {
+						if (curX > 0) curX--;
+					} else if (code === 9) curX = nextTabStop(curX);
+					else if (code === 10 || code === 11 || code === 12) {
+						softWrapped[curY] = false;
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+					} else if (code === 13) curX = 0;
+					else if (code >= 32) {
+						let char = ch;
+						if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
+							const nextCode = text.charCodeAt(i + 1);
+							if (nextCode >= 56320 && nextCode <= 57343) {
+								char = ch + text[i + 1];
+								i++;
+							}
+						}
+						writeChar(char);
+					}
+					break;
+				case "escape":
+					if (ch === "[") {
+						parserState = "csi";
+						escBuf = "";
+					} else if (ch === "]") {
+						parserState = "osc";
+						oscBuf = "";
+					} else if (ch === "P") {
+						parserState = "dcs";
+						escBuf = "";
+						dcsBuf = "";
+						dcsStartRow = curY;
+						dcsStartCol = curX;
+					} else if (ch === "c") {
+						fullReset();
+						parserState = "ground";
+					} else if (ch === "D") {
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "M") {
+						curY--;
+						if (curY < scrollTop) {
+							curY = scrollTop;
+							scrollDown(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "7") {
+						savedState = {
+							curX,
+							curY,
+							attrs: {
+								...attrs,
+								fg: attrs.fg ? { ...attrs.fg } : null,
+								bg: attrs.bg ? { ...attrs.bg } : null,
+								underlineColor: attrs.underlineColor ? { ...attrs.underlineColor } : null
+							},
+							originMode,
+							autoWrap,
+							charsetG0
+						};
+						parserState = "ground";
+					} else if (ch === "8") {
+						curX = savedState.curX;
+						curY = savedState.curY;
+						attrs = {
+							...savedState.attrs,
+							fg: savedState.attrs.fg ? { ...savedState.attrs.fg } : null,
+							bg: savedState.attrs.bg ? { ...savedState.attrs.bg } : null,
+							underlineColor: savedState.attrs.underlineColor ? { ...savedState.attrs.underlineColor } : null
+						};
+						originMode = savedState.originMode;
+						autoWrap = savedState.autoWrap;
+						charsetG0 = savedState.charsetG0;
+						clampCursor();
+						parserState = "ground";
+					} else if (ch === "E") {
+						curX = 0;
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "H") {
+						tabStops.add(curX);
+						parserState = "ground";
+					} else if (ch === "#") parserState = "escape_hash";
+					else if (ch === "(") parserState = "escape_charset";
+					else if (ch === ")") parserState = "escape_charset";
+					else if (ch === "=") {
+						applicationKeypad = true;
+						parserState = "ground";
+					} else if (ch === ">") {
+						applicationKeypad = false;
+						parserState = "ground";
+					} else if (ch === "_") {
+						parserState = "apc";
+						apcBuf = "";
+					} else parserState = "ground";
+					break;
+				case "escape_charset":
+					if (ch === "0") charsetG0 = true;
+					else charsetG0 = false;
+					parserState = "ground";
+					break;
+				case "escape_hash":
+					if (ch === "8") {
+						for (let r = 0; r < rows; r++) {
+							const row = grid[r];
+							for (let c = 0; c < cols; c++) {
+								const cell = emptyCell();
+								cell.char = "E";
+								row[c] = cell;
+							}
+							softWrapped[r] = false;
+						}
+						curX = 0;
+						curY = 0;
+					}
+					parserState = "ground";
+					break;
+				case "csi":
+					if (code >= 64 && code <= 126) {
+						let paramPart = escBuf;
+						let intermediatePart = "";
+						let j = paramPart.length - 1;
+						while (j >= 0) {
+							const c = paramPart.charCodeAt(j);
+							if (c >= 32 && c <= 47) j--;
+							else break;
+						}
+						if (j < paramPart.length - 1) {
+							intermediatePart = paramPart.substring(j + 1);
+							paramPart = paramPart.substring(0, j + 1);
+						}
+						if (paramPart.startsWith("?")) handleCSIPrivate(paramPart.substring(1), intermediatePart, ch);
+						else if (paramPart.startsWith(">")) handleCSIGt(paramPart.substring(1), intermediatePart, ch);
+						else if (paramPart.startsWith("<")) handleCSILt(paramPart.substring(1), intermediatePart, ch);
+						else if (paramPart.startsWith("=")) handleCSIEq(paramPart.substring(1), intermediatePart, ch);
+						else handleCSI(paramPart, intermediatePart, ch);
+						parserState = "ground";
+					} else if (escBuf.length >= 256) parserState = "ground";
+					else escBuf += ch;
+					break;
+				case "osc":
+					if (code === 7) {
+						handleOSC(oscBuf);
+						parserState = "ground";
+					} else if (code === 27) parserState = "osc_st";
+					else if (oscBuf.length >= 4096) parserState = "ground";
+					else oscBuf += ch;
+					break;
+				case "osc_st":
+					if (ch === "\\") handleOSC(oscBuf);
+					parserState = "ground";
+					break;
+				case "dcs":
+					if (code === 27) parserState = "dcs_st";
+					else if (code === 7) {
+						handleDCS(dcsBuf);
+						parserState = "ground";
+					} else dcsBuf += ch;
+					break;
+				case "dcs_st":
+					if (ch === "\\") handleDCS(dcsBuf);
+					parserState = "ground";
+					break;
+				case "dcs_passthrough":
+					if (code === 27) parserState = "dcs_st";
+					break;
+				case "apc":
+					if (code === 27) parserState = "apc_st";
+					else if (code === 7) {
+						handleAPC(apcBuf);
+						parserState = "ground";
+					} else apcBuf += ch;
+					break;
+				case "apc_st":
+					if (ch === "\\") handleAPC(apcBuf);
+					parserState = "ground";
+					break;
+			}
+		}
+	}
+	/**
+	* Reconstruct logical lines from a grid, joining rows that were soft-wrapped.
+	* Returns an array of logical lines, each being an array of ScreenCells (may be longer than cols).
+	*/
+	function getLogicalLines(srcGrid, srcSoftWrapped, srcRows) {
+		const logical = [];
+		let currentLine = [];
+		for (let r = 0; r < srcRows; r++) {
+			const row = srcGrid[r];
+			if (!row) continue;
+			for (let c = 0; c < row.length; c++) currentLine.push(row[c]);
+			if (srcSoftWrapped[r]) continue;
+			logical.push(currentLine);
+			currentLine = [];
+		}
+		if (currentLine.length > 0) logical.push(currentLine);
+		return logical;
+	}
+	/**
+	* Re-wrap logical lines to a new column width, producing grid rows and soft-wrap flags.
+	*/
+	function rewrapLines(logicalLines, newCols) {
+		const outRows = [];
+		const outWrapped = [];
+		for (const line of logicalLines) {
+			let lineLen = line.length;
+			while (lineLen > 0) {
+				const cell = line[lineLen - 1];
+				if (cell === EMPTY_CELL || cell.char === "" && !cell.wide) lineLen--;
+				else break;
+			}
+			if (lineLen === 0) {
+				outRows.push(makeRow(newCols));
+				outWrapped.push(false);
+				continue;
+			}
+			let pos = 0;
+			while (pos < lineLen) {
+				const row = makeRow(newCols);
+				let col = 0;
+				while (col < newCols && pos < lineLen) {
+					const cell = line[pos];
+					if (cell.wide && col + 2 > newCols) break;
+					row[col] = cell === EMPTY_CELL ? EMPTY_CELL : { ...cell };
+					col++;
+					pos++;
+				}
+				const moreContent = pos < lineLen;
+				outRows.push(row);
+				outWrapped.push(moreContent);
+			}
+		}
+		return {
+			rows: outRows,
+			wrapped: outWrapped
+		};
+	}
+	/**
+	* Trim trailing empty rows from reflowed result, so they don't push content off the top
+	* when we take the last newRows rows.
+	*/
+	function trimTrailingEmptyRows(result) {
+		while (result.rows.length > 1) if (result.rows[result.rows.length - 1].every((cell) => cell === EMPTY_CELL || cell.char === "" && !cell.wide) && !result.wrapped[result.rows.length - 2]) {
+			result.rows.pop();
+			result.wrapped.pop();
+		} else break;
+	}
+	function resize(newCols, newRows) {
+		const mainResult = rewrapLines(getLogicalLines(mainGrid, mainSoftWrapped, rows), newCols);
+		trimTrailingEmptyRows(mainResult);
+		const altResult = rewrapLines(getLogicalLines(altGrid, altSoftWrapped, rows), newCols);
+		trimTrailingEmptyRows(altResult);
+		const newMain = makeGrid(newCols, newRows);
+		const newMainWrapped = new Array(newRows).fill(false);
+		const mainStartRow = Math.max(0, mainResult.rows.length - newRows);
+		for (let r = 0; r < newRows && mainStartRow + r < mainResult.rows.length; r++) {
+			newMain[r] = mainResult.rows[mainStartRow + r];
+			newMainWrapped[r] = mainResult.wrapped[mainStartRow + r];
+		}
+		const newAlt = makeGrid(newCols, newRows);
+		const newAltWrapped = new Array(newRows).fill(false);
+		const altStartRow = Math.max(0, altResult.rows.length - newRows);
+		for (let r = 0; r < newRows && altStartRow + r < altResult.rows.length; r++) {
+			newAlt[r] = altResult.rows[altStartRow + r];
+			newAltWrapped[r] = altResult.wrapped[altStartRow + r];
+		}
+		mainGrid = newMain;
+		altGrid = newAlt;
+		mainSoftWrapped = newMainWrapped;
+		altSoftWrapped = newAltWrapped;
+		grid = useAltScreen ? altGrid : mainGrid;
+		softWrapped = useAltScreen ? altSoftWrapped : mainSoftWrapped;
+		const oldCols = cols;
+		cols = newCols;
+		rows = newRows;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		leftMargin = 0;
+		rightMargin = cols - 1;
+		if (newCols > oldCols) for (let i = Math.max(8, Math.ceil(oldCols / 8) * 8); i < newCols; i += 8) tabStops.add(i);
+		clampCursor();
+	}
+	function getCell(row, col) {
+		const r = grid[row];
+		if (!r || col >= cols) return emptyCell();
+		return { ...r[col] };
+	}
+	function getLine(row) {
+		const r = grid[row];
+		if (!r) return makeRow(cols);
+		return r.map((cell) => ({ ...cell }));
+	}
+	function getText() {
+		const lines = [];
+		for (let r = 0; r < rows; r++) lines.push(rowToString(grid[r]));
+		return lines.join("\n");
+	}
+	function rowToString(row) {
+		let line = "";
+		for (let i = 0; i < row.length; i++) {
+			const cell = row[i];
+			if (cell.wide) line += cell.char;
+			else if (cell.char === "") {
+				if (i > 0 && row[i - 1]?.wide) continue;
+				line += " ";
+			} else line += cell.char;
+		}
+		return line.replace(/\s+$/, "");
+	}
+	function getTextRange(startRow, startCol, endRow, endCol) {
+		const parts = [];
+		for (let row = startRow; row <= endRow; row++) {
+			const r = grid[row];
+			if (!r) continue;
+			const colStart = row === startRow ? startCol : 0;
+			const colEnd = row === endRow ? endCol : cols;
+			let line = "";
+			for (let col = colStart; col < colEnd; col++) {
+				const cell = r[col];
+				if (!cell) continue;
+				if (cell.char === "" && col > 0 && r[col - 1]?.wide) continue;
+				line += cell.char || " ";
+			}
+			parts.push(line.replace(/\s+$/, ""));
+		}
+		return parts.join("\n");
+	}
+	function getMode(mode) {
+		switch (mode) {
+			case "altScreen": return useAltScreen;
+			case "cursorVisible": return curVisible;
+			case "bracketedPaste": return bracketedPaste;
+			case "applicationCursor": return applicationCursor;
+			case "applicationKeypad": return applicationKeypad;
+			case "autoWrap": return autoWrap;
+			case "mouseTracking": return mouseTracking;
+			case "focusTracking": return focusTracking;
+			case "originMode": return originMode;
+			case "insertMode": return insertMode;
+			case "reverseVideo": return reverseVideo;
+			case "syncOutput": return syncOutput;
+			case "sgrMouse": return sgrMouse;
+			case "pixelMouse": return mouseTrackingMode === 1016;
+			case "leftRightMargin": return leftRightMarginMode;
+			case "colorSchemeReporting": return colorSchemeReporting;
+			case "kittyKeyboard": return kittyKeyboardFlags > 0;
+			case "kittyGraphics": return hasKittyGraphics;
+			case "sixel": return hasSixel;
+			default: return false;
+		}
+	}
+	return {
+		get cols() {
+			return cols;
+		},
+		get rows() {
+			return rows;
+		},
+		process,
+		resize,
+		reset: fullReset,
+		getCell,
+		getLine,
+		getText,
+		getTextRange,
+		getCursorPosition: () => ({
+			x: curX,
+			y: curY
+		}),
+		getCursorVisible: () => curVisible,
+		getCursorShape: () => cursorShape,
+		getCursorBlinking: () => cursorBlinking,
+		getTitle: () => title,
+		getMode,
+		getClipboard: () => clipboard,
+		getCwd: () => cwd,
+		getNotifications: () => [...notifications],
+		getScrollbackLength: () => scrollback.length,
+		getViewportOffset: () => viewportOffset,
+		scrollViewport,
+		getSemanticZones: () => semanticZones.map((z) => ({ ...z })),
+		getSixelImages: () => sixelImages.map((img) => ({ ...img }))
+	};
+}
+//#endregion
+export { createScreen as createVtermScreen };