vt100.js 0.3.0 → 0.7.0

package/README.md

@@ -6,15 +6,17 @@ Part of the [vterm](https://github.com/beorn/vterm) monorepo.
 
 ## Features
 
-- Full VT100/ANSI escape sequence parsing
-- SGR attributes (bold, italic, underline styles, colors, strikethrough, etc.)
-- 16-color, 256-color, and 24-bit truecolor support
-- Cursor movement, save/restore (DECSC/DECRC)
-- Screen modes (alternate screen, auto-wrap, origin mode, etc.)
+- Strict DEC VT100 (1978) emulation — monochrome display
+- SGR attributes: bold, underline (boolean), blink, inverse
+- Cursor movement (CUP, CUU, CUD, CUF, CUB, CHA, CNL, CPL, HVP, VPA)
+- Cursor save/restore (DECSC/DECRC)
+- Erase display/line (ED/EL)
 - Scroll regions (DECSTBM) with content preservation
+- Scroll up/down (SU/SD)
 - Scrollback buffer with configurable limit
-- Insert/delete characters and lines
-- Wide character support (CJK, emoji)
+- Screen modes (auto-wrap, origin mode, cursor visibility)
+- DEC special graphics charset
+- DA1/DSR/CPR device responses
 - Zero dependencies — works in Bun, Node.js, and browsers
 
 ## Install
@@ -70,16 +72,13 @@ console.log(screen.getCursorPosition()) // { x: 18, y: 0 }
 ```typescript
 interface ScreenCell {
   char: string
-  fg: CellColor | null // { r, g, b }
-  bg: CellColor | null
+  fg: CellColor | null // always null (VT100 is monochrome)
+  bg: CellColor | null // always null (VT100 is monochrome)
   bold: boolean
-  faint: boolean
-  italic: boolean
-  underline: "none" | "single" | "double" | "curly" | "dotted" | "dashed"
-  strikethrough: boolean
+  underline: boolean
+  blink: boolean
   inverse: boolean
   hidden: boolean
-  wide: boolean
 }
 ```
 

package/dist/index.d.mts

@@ -0,0 +1,60 @@
+//#region src/screen.d.ts
+/**
+ * Pure TypeScript VT100 terminal emulator.
+ *
+ * Strict DEC VT100 (1978) implementation: monochrome display, cursor movement,
+ * scroll regions, auto-wrap, origin mode, DEC special graphics charset.
+ * SGR supports bold, underline, blink, and reverse — NO colors (VT100 is
+ * monochrome). No insert mode, no insert/delete chars/lines — those are
+ * VT102/VT220 features.
+ *
+ * Zero dependencies. For colors and VT220 features, use vt220.js.
+ * For truecolor, 256 colors, and wide chars, use vterm.js.
+ */
+interface CellColor {
+  r: number;
+  g: number;
+  b: number;
+}
+interface ScreenCell {
+  char: string;
+  fg: CellColor | null;
+  bg: CellColor | null;
+  bold: boolean;
+  underline: boolean;
+  blink: boolean;
+  inverse: boolean;
+  hidden: boolean;
+}
+interface ScreenOptions {
+  cols: number;
+  rows: number;
+  scrollbackLimit?: number;
+  /** Callback for DA1/DSR responses — write these back to the PTY */
+  onResponse?: (data: string) => void;
+}
+interface Screen {
+  readonly cols: number;
+  readonly rows: number;
+  process(data: Uint8Array): void;
+  resize(cols: number, rows: number): void;
+  reset(): void;
+  getCell(row: number, col: number): ScreenCell;
+  getLine(row: number): ScreenCell[];
+  getScrollbackLine(row: number): ScreenCell[];
+  getText(): string;
+  getTextRange(startRow: number, startCol: number, endRow: number, endCol: number): string;
+  getCursorPosition(): {
+    x: number;
+    y: number;
+  };
+  getCursorVisible(): boolean;
+  getTitle(): string;
+  getMode(mode: string): boolean;
+  getScrollbackLength(): number;
+  getViewportOffset(): number;
+  scrollViewport(delta: number): void;
+}
+declare function createScreen(opts: ScreenOptions): Screen;
+//#endregion
+export { type CellColor, type ScreenCell, type Screen as Vt100Screen, type ScreenOptions as Vt100ScreenOptions, createScreen as createVt100Screen };

package/dist/index.mjs

@@ -0,0 +1,570 @@
+//#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,
+	underline: false,
+	blink: false,
+	inverse: false,
+	hidden: false
+});
+function emptyCell() {
+	return { ...EMPTY_CELL };
+}
+function createScreen(opts) {
+	let cols = opts.cols;
+	let rows = opts.rows;
+	const scrollbackLimit = opts.scrollbackLimit ?? 1e3;
+	const onResponse = opts.onResponse;
+	let grid = makeGrid(cols, rows);
+	let scrollback = [];
+	let curX = 0;
+	let curY = 0;
+	let curVisible = true;
+	let savedCurX = 0;
+	let savedCurY = 0;
+	let savedState = {
+		curX: 0,
+		curY: 0,
+		attrs: resetAttrs(),
+		originMode: false,
+		autoWrap: true
+	};
+	let attrs = resetAttrs();
+	let title = "";
+	let applicationCursor = false;
+	let applicationKeypad = false;
+	let autoWrap = true;
+	let originMode = false;
+	let reverseVideo = false;
+	let scrollTop = 0;
+	let scrollBottom = rows - 1;
+	let viewportOffset = 0;
+	let parserState = "ground";
+	let escBuf = "";
+	let oscBuf = "";
+	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,
+			underline: false,
+			blink: false,
+			inverse: false,
+			hidden: false
+		};
+	}
+	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 (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];
+		grid[bottom] = makeRow(cols);
+	}
+	function scrollDown(top, bottom) {
+		for (let i = bottom; i > top; i--) grid[i] = grid[i - 1];
+		grid[top] = makeRow(cols);
+	}
+	function writeChar(ch) {
+		if (curX >= cols) if (autoWrap) {
+			curX = 0;
+			curY++;
+			if (curY > scrollBottom) {
+				curY = scrollBottom;
+				scrollUp(scrollTop, scrollBottom);
+			}
+		} else curX = cols - 1;
+		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.underline = attrs.underline;
+		cell.blink = attrs.blink;
+		cell.inverse = attrs.inverse;
+		cell.hidden = attrs.hidden;
+		curX++;
+	}
+	function handleCSI(params, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		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":
+				curX = (parts[0] ?? 1) - 1;
+				clampCursor();
+				break;
+			case "H":
+			case "f":
+				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 "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 "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[?1;2c");
+				}
+				break;
+			case "s":
+				savedCurX = curX;
+				savedCurY = curY;
+				break;
+			case "u":
+				curX = savedCurX;
+				curY = savedCurY;
+				clampCursor();
+				break;
+			default: break;
+		}
+	}
+	function handleCSIPrivate(params, finalByte) {
+		const parts = params.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		const set = finalByte === "h";
+		for (const code of parts) switch (code) {
+			case 1:
+				applicationCursor = set;
+				break;
+			case 5:
+				reverseVideo = set;
+				break;
+			case 6:
+				originMode = set;
+				break;
+			case 7:
+				autoWrap = set;
+				break;
+			case 25:
+				curVisible = set;
+				break;
+			case 66:
+				applicationKeypad = set;
+				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) {
+		switch (mode) {
+			case 0:
+				eraseCells(curY, curX, curY, cols - 1);
+				break;
+			case 1:
+				eraseCells(curY, 0, curY, curX);
+				break;
+			case 2:
+				eraseCells(curY, 0, curY, cols - 1);
+				break;
+		}
+	}
+	function eraseCells(row, startCol, _endRow, endCol) {
+		const r = grid[row];
+		if (!r) return;
+		for (let col = startCol; col <= endCol && col < cols; col++) r[col] = emptyCell();
+	}
+	function handleSGR(rawParams) {
+		const params = rawParams.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+		if (params.length === 0 || params.length === 1 && params[0] === 0) {
+			attrs = resetAttrs();
+			return;
+		}
+		let i = 0;
+		while (i < params.length) {
+			switch (params[i]) {
+				case 0:
+					attrs = resetAttrs();
+					break;
+				case 1:
+					attrs.bold = true;
+					break;
+				case 4:
+					attrs.underline = true;
+					break;
+				case 5:
+					attrs.blink = true;
+					break;
+				case 7:
+					attrs.inverse = true;
+					break;
+				case 22:
+					attrs.bold = false;
+					break;
+				case 24:
+					attrs.underline = false;
+					break;
+				case 25:
+					attrs.blink = false;
+					break;
+				case 27:
+					attrs.inverse = false;
+					break;
+				case 38:
+				case 48:
+					if (i + 1 < params.length && params[i + 1] === 2) i += 4;
+					else if (i + 1 < params.length && params[i + 1] === 5) i += 2;
+					break;
+			}
+			i++;
+		}
+	}
+	function handleOSC(oscString) {
+		const semicolonIdx = oscString.indexOf(";");
+		if (semicolonIdx === -1) return;
+		const code = parseInt(oscString.substring(0, semicolonIdx), 10);
+		const value = oscString.substring(semicolonIdx + 1);
+		switch (code) {
+			case 0:
+			case 2:
+				title = value;
+				break;
+			case 1: break;
+		}
+	}
+	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 = Math.min((Math.floor(curX / 8) + 1) * 8, cols - 1);
+					else if (code === 10 || code === 11 || code === 12) {
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+					} else if (code === 13) curX = 0;
+					else if (code >= 32) writeChar(ch);
+					break;
+				case "escape":
+					if (ch === "[") {
+						parserState = "csi";
+						escBuf = "";
+					} else if (ch === "]") {
+						parserState = "osc";
+						oscBuf = "";
+					} else if (ch === "P") {
+						parserState = "dcs";
+						escBuf = "";
+					} else if (ch === "c") fullReset();
+					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
+							},
+							originMode,
+							autoWrap
+						};
+						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
+						};
+						originMode = savedState.originMode;
+						autoWrap = savedState.autoWrap;
+						clampCursor();
+						parserState = "ground";
+					} else if (ch === "E") {
+						curX = 0;
+						curY++;
+						if (curY > scrollBottom) {
+							curY = scrollBottom;
+							scrollUp(scrollTop, scrollBottom);
+						}
+						parserState = "ground";
+					} else if (ch === "=") {
+						applicationKeypad = true;
+						parserState = "ground";
+					} else if (ch === ">") {
+						applicationKeypad = false;
+						parserState = "ground";
+					} else parserState = "ground";
+					break;
+				case "csi":
+					if (code >= 64 && code <= 126) {
+						if (escBuf.startsWith("?")) handleCSIPrivate(escBuf.substring(1), ch);
+						else handleCSI(escBuf, 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 = "oscString";
+					else if (oscBuf.length >= 4096) parserState = "ground";
+					else oscBuf += ch;
+					break;
+				case "oscString":
+					if (ch === "\\") handleOSC(oscBuf);
+					parserState = "ground";
+					break;
+				case "dcs":
+					if (code === 27) parserState = "oscString";
+					break;
+			}
+		}
+	}
+	function fullReset() {
+		grid = makeGrid(cols, rows);
+		scrollback = [];
+		curX = 0;
+		curY = 0;
+		curVisible = true;
+		savedCurX = 0;
+		savedCurY = 0;
+		savedState = {
+			curX: 0,
+			curY: 0,
+			attrs: resetAttrs(),
+			originMode: false,
+			autoWrap: true
+		};
+		attrs = resetAttrs();
+		title = "";
+		applicationCursor = false;
+		applicationKeypad = false;
+		autoWrap = true;
+		originMode = false;
+		reverseVideo = false;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		viewportOffset = 0;
+		parserState = "ground";
+		escBuf = "";
+		oscBuf = "";
+	}
+	function resize(newCols, newRows) {
+		const newGrid = makeGrid(newCols, newRows);
+		copyGrid(grid, newGrid, Math.min(cols, newCols), Math.min(rows, newRows));
+		grid = newGrid;
+		cols = newCols;
+		rows = newRows;
+		scrollTop = 0;
+		scrollBottom = rows - 1;
+		clampCursor();
+	}
+	function copyGrid(src, dst, copyCols, copyRows) {
+		for (let row = 0; row < copyRows; row++) for (let col = 0; col < copyCols; col++) {
+			const srcCell = src[row]?.[col];
+			if (srcCell) dst[row][col] = { ...srcCell };
+		}
+	}
+	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 getScrollbackLine(row) {
+		const r = scrollback[row];
+		if (!r) return makeRow(cols);
+		return r.map((cell) => ({ ...cell }));
+	}
+	function getText() {
+		const lines = [];
+		for (const row of scrollback) lines.push(rowToString(row));
+		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.char === "") 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;
+				line += cell.char || " ";
+			}
+			parts.push(line.replace(/\s+$/, ""));
+		}
+		return parts.join("\n");
+	}
+	function getMode(mode) {
+		switch (mode) {
+			case "cursorVisible": return curVisible;
+			case "applicationCursor": return applicationCursor;
+			case "applicationKeypad": return applicationKeypad;
+			case "autoWrap": return autoWrap;
+			case "originMode": return originMode;
+			case "reverseVideo": return reverseVideo;
+			default: return false;
+		}
+	}
+	return {
+		get cols() {
+			return cols;
+		},
+		get rows() {
+			return rows;
+		},
+		process,
+		resize,
+		reset: fullReset,
+		getCell,
+		getLine,
+		getScrollbackLine,
+		getText,
+		getTextRange,
+		getCursorPosition: () => ({
+			x: curX,
+			y: curY
+		}),
+		getCursorVisible: () => curVisible,
+		getTitle: () => title,
+		getMode,
+		getScrollbackLength: () => scrollback.length,
+		getViewportOffset: () => viewportOffset,
+		scrollViewport: (delta) => {
+			viewportOffset = Math.max(0, Math.min(scrollback.length, viewportOffset + delta));
+		}
+	};
+}
+//#endregion
+export { createScreen as createVt100Screen };