@termaxjs/web-core 0.1.1

package/dist/parser/VtEngine.js

@@ -0,0 +1,1206 @@
+import { CellFlags, } from '../types.js';
+/**
+ * Returns true if the character is a wide (double-width) East Asian character.
+ * Covers CJK Unified Ideographs, Hangul, fullwidth forms, and common wide symbols.
+ */
+function isWideChar(char) {
+    const cp = char.codePointAt(0);
+    if (cp === undefined)
+        return false;
+    return (
+    // CJK Unified Ideographs
+    (cp >= 0x4E00 && cp <= 0x9FFF) ||
+        // CJK Unified Ideographs Extension A
+        (cp >= 0x3400 && cp <= 0x4DBF) ||
+        // CJK Compatibility Ideographs
+        (cp >= 0xF900 && cp <= 0xFAFF) ||
+        // CJK Unified Ideographs Extension B-F (Supplementary)
+        (cp >= 0x20000 && cp <= 0x2FA2D) ||
+        // Hangul Syllables
+        (cp >= 0xAC00 && cp <= 0xD7AF) ||
+        // Fullwidth Latin, Fullwidth symbols
+        (cp >= 0xFF01 && cp <= 0xFF60) ||
+        (cp >= 0xFFE0 && cp <= 0xFFE6) ||
+        // CJK Symbols and Punctuation
+        (cp >= 0x3000 && cp <= 0x303F) ||
+        // Hiragana and Katakana
+        (cp >= 0x3040 && cp <= 0x30FF) ||
+        // Katakana Phonetic Extensions
+        (cp >= 0x31F0 && cp <= 0x31FF) ||
+        // Enclosed CJK Letters and Months
+        (cp >= 0x3200 && cp <= 0x32FF) ||
+        // CJK Compatibility
+        (cp >= 0x3300 && cp <= 0x33FF) ||
+        // Bopomofo
+        (cp >= 0x3100 && cp <= 0x312F) ||
+        // CJK Radicals Supplement
+        (cp >= 0x2E80 && cp <= 0x2EFF) ||
+        // Kangxi Radicals
+        (cp >= 0x2F00 && cp <= 0x2FDF) ||
+        // Emoticons and pictographs (verified against unicode-width)
+        (cp >= 0x1F300 && cp <= 0x1F64F) ||
+        (cp >= 0x1F680 && cp <= 0x1F6DF) ||
+        cp === 0x2705 || cp === 0x274C || cp === 0x2B50 || cp === 0x26A1 ||
+        cp === 0x1FA70 || cp === 0x1F9FF ||
+        // Angle brackets used in CJK text
+        (cp >= 0x2329 && cp <= 0x232A));
+}
+/**
+ * Zero-width characters (combining marks, joiners, variation selectors,
+ * tags). Verified against unicode-width; kept in sync with the Rust core.
+ * The engines skip these rather than combining glyphs (documented limit).
+ */
+function isZeroWidthChar(char) {
+    const cp = char.codePointAt(0);
+    if (cp === undefined)
+        return false;
+    return ((cp >= 0x0300 && cp <= 0x036F) ||
+        (cp >= 0x1AB0 && cp <= 0x1AFF) ||
+        (cp >= 0x1DC0 && cp <= 0x1DFF) ||
+        (cp >= 0x20D0 && cp <= 0x20E3) ||
+        (cp >= 0xFE00 && cp <= 0xFE0F) ||
+        (cp >= 0xFE20 && cp <= 0xFE2F) ||
+        (cp >= 0x200B && cp <= 0x200F) ||
+        (cp >= 0xE0000 && cp <= 0xE0FFF) ||
+        cp === 0x00AD || cp === 0x2060 || cp === 0x061C ||
+        (cp >= 0x2066 && cp <= 0x2069) ||
+        (cp >= 0x3099 && cp <= 0x309A) ||
+        (cp >= 0xFF9E && cp <= 0xFF9F));
+}
+export class VtEngine {
+    cols;
+    rows;
+    maxScrollback = 10000;
+    lines = [];
+    scrollback = [];
+    viewportY = 0; // 0 to scrollback.length
+    // Alternate screen buffer
+    isAltBuffer = false;
+    normalLines = [];
+    normalScrollback = [];
+    normalCursor = {
+        col: 0,
+        row: 0,
+        visible: true,
+        blinking: true,
+        shape: 'block',
+    };
+    altLines = [];
+    altCursor = {
+        col: 0,
+        row: 0,
+        visible: true,
+        blinking: true,
+        shape: 'block',
+    };
+    // Mouse & Focus modes
+    tabStops = Array.from({ length: 500 }, (_, i) => i % 8 === 0);
+    savedFlags = CellFlags.EMPTY;
+    savedFg = { type: 'default' };
+    savedBg = { type: 'default' };
+    saveCursor() {
+        this.savedCursor = { ...this.cursor };
+        this.savedFlags = this.currentFlags;
+        this.savedFg = { ...this.currentFg };
+        this.savedBg = { ...this.currentBg };
+    }
+    restoreCursor() {
+        this.cursor.col = Math.min(this.cols - 1, this.savedCursor.col);
+        this.cursor.row = Math.min(this.rows - 1, this.savedCursor.row);
+        this.currentFlags = this.savedFlags;
+        this.currentFg = { ...this.savedFg };
+        this.currentBg = { ...this.savedBg };
+    }
+    scrollDown(count = 1) {
+        for (let k = 0; k < count; k++) {
+            this.lines.splice(this.scrollBottom, 1);
+            this.lines.splice(this.scrollTop, 0, this.createEmptyLine());
+        }
+        for (let r = this.scrollTop; r <= this.scrollBottom; r++) {
+            this.dirtyRowSet.add(r);
+        }
+    }
+    mouseMode = {
+        x10: false,
+        button: false,
+        any: false,
+        sgr: false,
+    };
+    focusReporting = false;
+    bracketedPasteMode = false;
+    synchronizedOutput = false;
+    cursorShape = 'block';
+    cursorBlinking = true;
+    autowrap = true;
+    originMode = false;
+    // Autowrap-pending: cursor is at the right margin but has not yet wrapped.
+    // The next printable character triggers the wrap.
+    wrapPending = false;
+    // Last printed character for REP (CSI b)
+    lastPrintedChar = '';
+    // Hyperlink state
+    currentHyperlink;
+    cursor = {
+        col: 0,
+        row: 0,
+        visible: true,
+        blinking: true,
+        shape: 'block',
+    };
+    savedCursor = { col: 0, row: 0 };
+    scrollTop = 0;
+    scrollBottom = 23;
+    currentFg = { type: 'default' };
+    currentBg = { type: 'default' };
+    currentFlags = CellFlags.EMPTY;
+    currentUnderlineColor;
+    dirtyRowSet = new Set();
+    events;
+    // Parser state
+    state = 'GROUND';
+    csiParams = '';
+    oscBuffer = '';
+    // Streaming UTF-8 decoder: a multibyte character may straddle two writes.
+    utf8Decoder = new TextDecoder();
+    constructor(cols = 80, rows = 24, events = {}) {
+        this.cols = Math.max(1, cols);
+        this.rows = Math.max(1, rows);
+        this.scrollBottom = this.rows - 1;
+        this.events = events;
+        this.initGrid();
+    }
+    flushDiff() {
+        const dirtyRows = [];
+        for (const r of this.dirtyRowSet) {
+            if (r < this.lines.length) {
+                dirtyRows.push({
+                    row: r,
+                    cells: [...this.lines[r]],
+                });
+            }
+        }
+        this.dirtyRowSet.clear();
+        return {
+            cols: this.cols,
+            rows: this.rows,
+            cursor: {
+                ...this.cursor,
+                shape: this.cursorShape,
+                blinking: this.cursorBlinking,
+            },
+            dirtyRows,
+        };
+    }
+    feed(input) {
+        this.parse(input);
+        return this.flushDiff();
+    }
+    resize(cols, rows) {
+        const oldCols = this.cols;
+        const oldRows = this.rows;
+        const newCols = Math.max(1, cols);
+        const newRows = Math.max(1, rows);
+        if (newCols === oldCols && newRows === oldRows) {
+            return this.flushDiff();
+        }
+        this.cols = newCols;
+        this.rows = newRows;
+        this.scrollTop = 0;
+        this.scrollBottom = this.rows - 1;
+        // Resize existing lines to match newCols
+        const nextLines = [];
+        for (let r = 0; r < this.lines.length; r++) {
+            const line = this.lines[r];
+            if (line.length < newCols) {
+                const padded = [...line];
+                for (let c = line.length; c < newCols; c++) {
+                    padded.push({
+                        char: ' ',
+                        width: 1,
+                        flags: CellFlags.EMPTY,
+                        fg: { type: 'default' },
+                        bg: { type: 'default' },
+                    });
+                }
+                nextLines.push(padded);
+            }
+            else {
+                nextLines.push(line.slice(0, newCols));
+            }
+        }
+        if (newRows > nextLines.length) {
+            while (nextLines.length < newRows) {
+                nextLines.push(this.createEmptyLine());
+            }
+        }
+        else if (newRows < nextLines.length) {
+            const excess = nextLines.length - newRows;
+            for (let i = 0; i < excess; i++) {
+                const topRow = nextLines.shift();
+                if (topRow && !this.isAltBuffer) {
+                    this.scrollback.push(topRow);
+                    if (this.scrollback.length > this.maxScrollback) {
+                        this.scrollback.shift();
+                    }
+                }
+            }
+        }
+        this.lines = nextLines;
+        this.cursor.col = Math.min(this.cols - 1, this.cursor.col);
+        this.cursor.row = Math.min(this.rows - 1, this.cursor.row);
+        this.viewportY = this.scrollback.length;
+        for (let r = 0; r < this.rows; r++) {
+            this.dirtyRowSet.add(r);
+        }
+        return this.flushDiff();
+    }
+    scrollLines(delta) {
+        if (this.isAltBuffer)
+            return; // Alt buffer has no scrollback
+        const prev = this.viewportY;
+        this.viewportY = Math.max(0, Math.min(this.scrollback.length, this.viewportY + delta));
+        if (prev !== this.viewportY) {
+            for (let r = 0; r < this.rows; r++)
+                this.dirtyRowSet.add(r);
+        }
+    }
+    scrollToBottom() {
+        this.scrollLines(this.scrollback.length - this.viewportY);
+    }
+    scrollToTop() {
+        this.scrollLines(-this.viewportY);
+    }
+    scrollToLine(line) {
+        const target = Math.max(0, Math.min(this.scrollback.length, line));
+        this.scrollLines(target - this.viewportY);
+    }
+    getVisibleLines() {
+        const visible = [];
+        for (let r = 0; r < this.rows; r++) {
+            const idx = this.viewportY + r;
+            if (idx < this.scrollback.length) {
+                visible.push(this.scrollback[idx]);
+            }
+            else {
+                const gridIdx = idx - this.scrollback.length;
+                if (gridIdx < this.lines.length) {
+                    visible.push(this.lines[gridIdx]);
+                }
+                else {
+                    visible.push(this.createEmptyLine());
+                }
+            }
+        }
+        return visible;
+    }
+    initGrid() {
+        this.lines = [];
+        for (let r = 0; r < this.rows; r++) {
+            this.lines.push(this.createEmptyLine());
+            this.dirtyRowSet.add(r);
+        }
+    }
+    createEmptyLine() {
+        const line = new Array(this.cols);
+        for (let c = 0; c < this.cols; c++) {
+            line[c] = {
+                char: ' ',
+                width: 1,
+                flags: CellFlags.EMPTY,
+                fg: { type: 'default' },
+                bg: { type: 'default' },
+            };
+        }
+        return line;
+    }
+    parse(input) {
+        const text = typeof input === 'string' ? input : this.utf8Decoder.decode(input, { stream: true });
+        for (const char of text) {
+            const code = char.codePointAt(0) ?? 0;
+            switch (this.state) {
+                case 'GROUND':
+                    if (char === '\x1b') {
+                        this.state = 'ESC';
+                    }
+                    else if (char === '\r') {
+                        this.cursor.col = 0;
+                        this.wrapPending = false;
+                    }
+                    else if (char === '\n') {
+                        this.lineFeed();
+                    }
+                    else if (char === '\b') {
+                        this.wrapPending = false;
+                        this.cursor.col = Math.max(0, this.cursor.col - 1);
+                    }
+                    else if (char === '\t') {
+                        if (this.wrapPending)
+                            this.wrapPending = false;
+                        // Use custom tab stops set via HTS (ESC H)
+                        let nextStop = this.cols - 1;
+                        for (let t = this.cursor.col + 1; t < this.tabStops.length && t < this.cols; t++) {
+                            if (this.tabStops[t]) {
+                                nextStop = t;
+                                break;
+                            }
+                        }
+                        this.cursor.col = Math.min(this.cols - 1, nextStop);
+                    }
+                    else if (char === '\x07') {
+                        this.events.onBell?.();
+                    }
+                    else if (code >= 32 && code !== 127) {
+                        this.printChar(char);
+                    }
+                    break;
+                case 'ESC':
+                    if (char === '[') {
+                        this.state = 'CSI';
+                        this.csiParams = '';
+                    }
+                    else if (char === ']') {
+                        this.state = 'OSC';
+                        this.oscBuffer = '';
+                    }
+                    else if (char === '7') {
+                        this.saveCursor();
+                        this.state = 'GROUND';
+                    }
+                    else if (char === '8') {
+                        this.restoreCursor();
+                        this.state = 'GROUND';
+                    }
+                    else if (char === 'D') {
+                        // IND - Index (move down, scroll if at bottom)
+                        this.lineFeed();
+                        this.state = 'GROUND';
+                    }
+                    else if (char === 'M') {
+                        // RI - Reverse Index (move up, scroll down if at top)
+                        if (this.cursor.row === this.scrollTop) {
+                            this.scrollDown(1);
+                        }
+                        else if (this.cursor.row > 0) {
+                            this.cursor.row--;
+                        }
+                        this.state = 'GROUND';
+                    }
+                    else if (char === 'E') {
+                        // NEL - Next Line
+                        this.cursor.col = 0;
+                        this.lineFeed();
+                        this.state = 'GROUND';
+                    }
+                    else if (char === 'H') {
+                        // HTS - Horizontal Tab Set
+                        const col = this.cursor.col;
+                        if (col < this.tabStops.length) {
+                            this.tabStops[col] = true;
+                        }
+                        this.state = 'GROUND';
+                    }
+                    else if (char === 'c') {
+                        this.reset();
+                        this.state = 'GROUND';
+                    }
+                    else {
+                        this.events.onUnhandledSequence?.(`\\x1b${char}`);
+                        this.state = 'GROUND';
+                    }
+                    break;
+                case 'CSI':
+                    if ((code >= 48 && code <= 57) || char === ';' || char === ':' || char === '?' || char === ' ' || char === '>') {
+                        this.csiParams += char;
+                    }
+                    else {
+                        this.handleCsi(char);
+                        this.state = 'GROUND';
+                    }
+                    break;
+                case 'OSC':
+                    if (char === '\x07') {
+                        this.handleOsc(this.oscBuffer);
+                        this.state = 'GROUND';
+                    }
+                    else if (char === '\x1b') {
+                        this.state = 'OSC_ESC';
+                    }
+                    else {
+                        this.oscBuffer += char;
+                    }
+                    break;
+                case 'OSC_ESC':
+                    if (char === '\\') {
+                        this.handleOsc(this.oscBuffer);
+                        this.state = 'GROUND';
+                    }
+                    else {
+                        this.state = 'GROUND';
+                    }
+                    break;
+            }
+        }
+    }
+    printChar(char) {
+        // Zero-width marks are skipped (not combined), mirroring the Rust core
+        // which drops zero-width chars to keep grid math sane.
+        if (isZeroWidthChar(char))
+            return;
+        const wide = isWideChar(char);
+        const charWidth = wide ? 2 : 1;
+        // Deferred autowrap: if wrapPending, the NEXT printable char triggers the wrap
+        if (this.wrapPending) {
+            this.wrapPending = false;
+            if (this.autowrap) {
+                this.cursor.col = 0;
+                this.lineFeed();
+            }
+            else {
+                this.cursor.col = this.cols - 1;
+            }
+        }
+        // Wide char at last column: wrap first
+        if (wide && this.cursor.col >= this.cols - 1) {
+            // Fill current cell with space, then wrap
+            if (this.cursor.col < this.cols) {
+                const r = this.cursor.row;
+                this.lines[r][this.cursor.col] = {
+                    char: ' ',
+                    width: 1,
+                    flags: CellFlags.EMPTY,
+                    fg: { type: 'default' },
+                    bg: { type: 'default' },
+                };
+                this.dirtyRowSet.add(r);
+            }
+            this.cursor.col = 0;
+            this.lineFeed();
+        }
+        const r = this.cursor.row;
+        const c = this.cursor.col;
+        if (r < this.lines.length && c < this.cols) {
+            this.lines[r][c] = {
+                char,
+                width: charWidth,
+                flags: this.currentFlags,
+                fg: { ...this.currentFg },
+                bg: { ...this.currentBg },
+                hyperlink: this.currentHyperlink,
+                underlineColor: this.currentUnderlineColor,
+            };
+            // For wide chars, the second cell is a zero-width continuation
+            if (wide && c + 1 < this.cols) {
+                this.lines[r][c + 1] = {
+                    char: '',
+                    width: 0,
+                    flags: this.currentFlags,
+                    fg: { ...this.currentFg },
+                    bg: { ...this.currentBg },
+                };
+            }
+            this.dirtyRowSet.add(r);
+        }
+        this.lastPrintedChar = char;
+        this.cursor.col += charWidth;
+        // If cursor is now at or past the right margin, enter wrap-pending state
+        if (this.cursor.col >= this.cols) {
+            this.cursor.col = this.cols - 1;
+            this.wrapPending = true;
+        }
+    }
+    lineFeed() {
+        if (this.cursor.row === this.scrollBottom) {
+            // Cursor is at the bottom of the scroll region: scroll up within the region
+            this.scrollUp(1);
+        }
+        else if (this.cursor.row >= this.rows - 1) {
+            // Cursor is at the absolute bottom of the screen: do nothing (clamped)
+        }
+        else if (this.cursor.row > this.scrollBottom) {
+            // Cursor is below the scroll region: just move down, no scrolling
+            this.cursor.row++;
+        }
+        else {
+            // Cursor is within or above the scroll region: just move down
+            this.cursor.row++;
+        }
+    }
+    scrollUp(count) {
+        for (let k = 0; k < count; k++) {
+            const removed = this.lines.splice(this.scrollTop, 1)[0];
+            if (removed && !this.isAltBuffer) {
+                this.scrollback.push(removed);
+                if (this.scrollback.length > this.maxScrollback) {
+                    this.scrollback.shift();
+                }
+            }
+            this.lines.splice(this.scrollBottom, 0, this.createEmptyLine());
+        }
+        for (let r = this.scrollTop; r <= this.scrollBottom; r++) {
+            this.dirtyRowSet.add(r);
+        }
+    }
+    handleCsi(finalChar) {
+        const isPrivate = this.csiParams.startsWith('?');
+        const paramClean = this.csiParams.replace(/^[?]/, '').trim();
+        const args = paramClean
+            ? paramClean.split(/[;:]/).map((v) => parseInt(v, 10) || 0)
+            : [];
+        switch (finalChar) {
+            case '@': // ICH - Insert Character
+                {
+                    const count = args[0] || 1;
+                    const r = this.cursor.row;
+                    const c = this.cursor.col;
+                    if (r < this.lines.length) {
+                        const line = this.lines[r];
+                        const emptyCells = [];
+                        for (let i = 0; i < count; i++) {
+                            emptyCells.push({
+                                char: ' ',
+                                width: 1,
+                                flags: this.currentFlags,
+                                fg: { ...this.currentFg },
+                                bg: { ...this.currentBg },
+                            });
+                        }
+                        line.splice(c, 0, ...emptyCells);
+                        line.length = this.cols;
+                        this.dirtyRowSet.add(r);
+                    }
+                }
+                break;
+            case 'P': // DCH - Delete Character
+                {
+                    const count = args[0] || 1;
+                    const r = this.cursor.row;
+                    const c = this.cursor.col;
+                    if (r < this.lines.length) {
+                        const line = this.lines[r];
+                        line.splice(c, count);
+                        while (line.length < this.cols) {
+                            line.push({
+                                char: ' ',
+                                width: 1,
+                                flags: CellFlags.EMPTY,
+                                fg: { type: 'default' },
+                                bg: { type: 'default' },
+                            });
+                        }
+                        this.dirtyRowSet.add(r);
+                    }
+                }
+                break;
+            case 'X': // ECH - Erase Character
+                {
+                    const count = args[0] || 1;
+                    const r = this.cursor.row;
+                    const c = this.cursor.col;
+                    if (r < this.lines.length) {
+                        const line = this.lines[r];
+                        const end = Math.min(this.cols, c + count);
+                        for (let col = c; col < end; col++) {
+                            line[col] = {
+                                char: ' ',
+                                width: 1,
+                                flags: this.currentFlags,
+                                fg: { ...this.currentFg },
+                                bg: { ...this.currentBg },
+                            };
+                        }
+                        this.dirtyRowSet.add(r);
+                    }
+                }
+                break;
+            case 'L': // IL - Insert Line
+                {
+                    const count = args[0] || 1;
+                    const curRow = this.cursor.row;
+                    if (curRow >= this.scrollTop && curRow <= this.scrollBottom) {
+                        for (let k = 0; k < count; k++) {
+                            this.lines.splice(this.scrollBottom, 1);
+                            this.lines.splice(curRow, 0, this.createEmptyLine());
+                        }
+                        for (let r = curRow; r <= this.scrollBottom; r++) {
+                            this.dirtyRowSet.add(r);
+                        }
+                    }
+                }
+                break;
+            case 'M': // DL - Delete Line
+                {
+                    const count = args[0] || 1;
+                    const curRow = this.cursor.row;
+                    if (curRow >= this.scrollTop && curRow <= this.scrollBottom) {
+                        for (let k = 0; k < count; k++) {
+                            this.lines.splice(curRow, 1);
+                            this.lines.splice(this.scrollBottom, 0, this.createEmptyLine());
+                        }
+                        for (let r = curRow; r <= this.scrollBottom; r++) {
+                            this.dirtyRowSet.add(r);
+                        }
+                    }
+                }
+                break;
+            case 'S': // SU - Scroll Up
+                {
+                    const count = args[0] || 1;
+                    this.scrollUp(count);
+                }
+                break;
+            case 'T': // SD - Scroll Down
+                {
+                    const count = args[0] || 1;
+                    this.scrollDown(count);
+                }
+                break;
+            case 's': // Save Cursor
+                this.saveCursor();
+                break;
+            case 'u': // Restore Cursor
+                this.restoreCursor();
+                this.wrapPending = false;
+                break;
+            case 'n': // DSR - Device Status Report
+                {
+                    const code = args[0] || 0;
+                    if (code === 5) {
+                        this.events.onPtyWrite?.('\x1b[0n');
+                    }
+                    else if (code === 6) {
+                        const row = this.cursor.row + 1;
+                        const col = this.cursor.col + 1;
+                        this.events.onPtyWrite?.(`\x1b[${row};${col}R`);
+                    }
+                }
+                break;
+            case 'c': // DA - Device Attributes
+                {
+                    if (isPrivate || this.csiParams.startsWith('>')) {
+                        this.events.onPtyWrite?.('\x1b[>0;10;1c');
+                    }
+                    else {
+                        this.events.onPtyWrite?.('\x1b[?1;2c');
+                    }
+                }
+                break;
+            case 'm': // SGR
+                this.handleSgr(args);
+                break;
+            case 'H': // CUP
+            case 'f':
+                {
+                    const row = (args[0] || 1) - 1;
+                    const col = (args[1] || 1) - 1;
+                    if (this.originMode) {
+                        this.cursor.row = Math.min(this.scrollBottom, this.scrollTop + Math.max(0, row));
+                    }
+                    else {
+                        this.cursor.row = Math.max(0, Math.min(this.rows - 1, row));
+                    }
+                    this.cursor.col = Math.max(0, Math.min(this.cols - 1, col));
+                    this.wrapPending = false;
+                }
+                break;
+            case 'A': // CUU
+                {
+                    const top = this.originMode ? this.scrollTop : 0;
+                    this.cursor.row = Math.max(top, this.cursor.row - (args[0] || 1));
+                    this.wrapPending = false;
+                }
+                break;
+            case 'B': // CUD
+                {
+                    const bottom = this.originMode ? this.scrollBottom : this.rows - 1;
+                    this.cursor.row = Math.min(bottom, this.cursor.row + (args[0] || 1));
+                    this.wrapPending = false;
+                }
+                break;
+            case 'C': // CUF
+                this.cursor.col = Math.min(this.cols - 1, this.cursor.col + (args[0] || 1));
+                this.wrapPending = false;
+                break;
+            case 'D': // CUB
+                this.cursor.col = Math.max(0, this.cursor.col - (args[0] || 1));
+                this.wrapPending = false;
+                break;
+            case 'E': // CNL - Cursor Next Line
+                this.cursor.row = Math.min(this.rows - 1, this.cursor.row + (args[0] || 1));
+                this.cursor.col = 0;
+                this.wrapPending = false;
+                break;
+            case 'F': // CPL - Cursor Previous Line
+                this.cursor.row = Math.max(0, this.cursor.row - (args[0] || 1));
+                this.cursor.col = 0;
+                this.wrapPending = false;
+                break;
+            case 'G': // CHA
+                this.cursor.col = Math.max(0, Math.min(this.cols - 1, (args[0] || 1) - 1));
+                this.wrapPending = false;
+                break;
+            case 'I': // CHT - Cursor Horizontal Tab
+                {
+                    let count = args[0] || 1;
+                    let col = this.cursor.col;
+                    for (let t = 0; t < count; t++) {
+                        let found = false;
+                        for (let c = col + 1; c < this.cols; c++) {
+                            if (c < this.tabStops.length && this.tabStops[c]) {
+                                col = c;
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (!found) {
+                            col = this.cols - 1;
+                            break;
+                        }
+                    }
+                    this.cursor.col = col;
+                    this.wrapPending = false;
+                }
+                break;
+            case 'Z': // CBT - Cursor Backward Tab
+                {
+                    let count = args[0] || 1;
+                    let col = this.cursor.col;
+                    for (let t = 0; t < count; t++) {
+                        let found = false;
+                        for (let c = col - 1; c >= 0; c--) {
+                            if (c < this.tabStops.length && this.tabStops[c]) {
+                                col = c;
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (!found) {
+                            col = 0;
+                            break;
+                        }
+                    }
+                    this.cursor.col = col;
+                    this.wrapPending = false;
+                }
+                break;
+            case 'b': // REP - Repeat last printed character
+                {
+                    const count = args[0] || 1;
+                    if (this.lastPrintedChar) {
+                        for (let k = 0; k < count; k++) {
+                            this.printChar(this.lastPrintedChar);
+                        }
+                    }
+                }
+                break;
+            case 'd': // VPA
+                this.cursor.row = Math.max(0, Math.min(this.rows - 1, (args[0] || 1) - 1));
+                this.wrapPending = false;
+                break;
+            case 'J': // ED
+                {
+                    const mode = args[0] || 0;
+                    if (mode === 0) {
+                        this.clearLineRange(this.cursor.row, this.cursor.col, this.cols - 1);
+                        for (let r = this.cursor.row + 1; r < this.rows; r++) {
+                            this.clearLine(r);
+                        }
+                    }
+                    else if (mode === 1) {
+                        for (let r = 0; r < this.cursor.row; r++) {
+                            this.clearLine(r);
+                        }
+                        this.clearLineRange(this.cursor.row, 0, this.cursor.col);
+                    }
+                    else if (mode === 2 || mode === 3) {
+                        for (let r = 0; r < this.rows; r++) {
+                            this.clearLine(r);
+                        }
+                        if (mode === 3 && !this.isAltBuffer)
+                            this.scrollback = [];
+                    }
+                }
+                break;
+            case 'K': // EL
+                {
+                    const mode = args[0] || 0;
+                    if (mode === 0) {
+                        this.clearLineRange(this.cursor.row, this.cursor.col, this.cols - 1);
+                    }
+                    else if (mode === 1) {
+                        this.clearLineRange(this.cursor.row, 0, this.cursor.col);
+                    }
+                    else if (mode === 2) {
+                        this.clearLine(this.cursor.row);
+                    }
+                }
+                break;
+            case 'r': // DECSTBM
+                {
+                    const top = (args[0] || 1) - 1;
+                    const bottom = (args[1] || this.rows) - 1;
+                    if (top < bottom && bottom < this.rows) {
+                        this.scrollTop = top;
+                        this.scrollBottom = bottom;
+                    }
+                    else {
+                        this.scrollTop = 0;
+                        this.scrollBottom = this.rows - 1;
+                    }
+                    this.cursor.row = 0;
+                    this.cursor.col = 0;
+                }
+                break;
+            case 'q': // DECSCUSR (Set Cursor Style)
+                {
+                    const n = args[0] || 0;
+                    if (n === 0 || n === 1) {
+                        this.cursorShape = 'block';
+                        this.cursorBlinking = true;
+                    }
+                    else if (n === 2) {
+                        this.cursorShape = 'block';
+                        this.cursorBlinking = false;
+                    }
+                    else if (n === 3) {
+                        this.cursorShape = 'underline';
+                        this.cursorBlinking = true;
+                    }
+                    else if (n === 4) {
+                        this.cursorShape = 'underline';
+                        this.cursorBlinking = false;
+                    }
+                    else if (n === 5) {
+                        this.cursorShape = 'bar';
+                        this.cursorBlinking = true;
+                    }
+                    else if (n === 6) {
+                        this.cursorShape = 'bar';
+                        this.cursorBlinking = false;
+                    }
+                }
+                break;
+            case 'g': // TBC - Tab Clear
+                {
+                    const mode = args[0] || 0;
+                    if (mode === 0) {
+                        // Clear tab stop at current position
+                        if (this.cursor.col < this.tabStops.length) {
+                            this.tabStops[this.cursor.col] = false;
+                        }
+                    }
+                    else if (mode === 3) {
+                        // Clear all tab stops
+                        this.tabStops.fill(false);
+                    }
+                }
+                break;
+            case 'h': // Set Mode
+                if (isPrivate) {
+                    if (args.includes(25))
+                        this.cursor.visible = true;
+                    if (args.includes(6))
+                        this.originMode = true;
+                    if (args.includes(7))
+                        this.autowrap = true;
+                    // Alternate Screen Buffer (1049, 1047, 47)
+                    if (args.includes(1049) || args.includes(1047) || args.includes(47)) {
+                        this.enterAltBuffer();
+                    }
+                    // Mouse modes
+                    if (args.includes(1000))
+                        this.mouseMode.x10 = true;
+                    if (args.includes(1002))
+                        this.mouseMode.button = true;
+                    if (args.includes(1003))
+                        this.mouseMode.any = true;
+                    if (args.includes(1006))
+                        this.mouseMode.sgr = true;
+                    // Focus reporting
+                    if (args.includes(1004))
+                        this.focusReporting = true;
+                    // Bracketed paste (2004)
+                    if (args.includes(2004))
+                        this.bracketedPasteMode = true;
+                    // Synchronized output (2026)
+                    if (args.includes(2026)) {
+                        this.synchronizedOutput = true;
+                        this.events.onSyncOutput?.(true);
+                    }
+                }
+                break;
+            case 'l': // Reset Mode
+                if (isPrivate) {
+                    if (args.includes(25))
+                        this.cursor.visible = false;
+                    if (args.includes(6))
+                        this.originMode = false;
+                    if (args.includes(7))
+                        this.autowrap = false;
+                    // Alternate Screen Buffer (1049, 1047, 47)
+                    if (args.includes(1049) || args.includes(1047) || args.includes(47)) {
+                        this.exitAltBuffer();
+                    }
+                    // Mouse modes
+                    if (args.includes(1000))
+                        this.mouseMode.x10 = false;
+                    if (args.includes(1002))
+                        this.mouseMode.button = false;
+                    if (args.includes(1003))
+                        this.mouseMode.any = false;
+                    if (args.includes(1006))
+                        this.mouseMode.sgr = false;
+                    // Focus reporting
+                    if (args.includes(1004))
+                        this.focusReporting = false;
+                    // Bracketed paste (2004)
+                    if (args.includes(2004))
+                        this.bracketedPasteMode = false;
+                    // Synchronized output (2026)
+                    if (args.includes(2026)) {
+                        this.synchronizedOutput = false;
+                        for (let r = 0; r < this.rows; r++)
+                            this.dirtyRowSet.add(r);
+                        this.events.onSyncOutput?.(false);
+                    }
+                }
+                break;
+            default:
+                this.events.onUnhandledSequence?.(`\x1b[${this.csiParams}${finalChar}`);
+                break;
+        }
+    }
+    enterAltBuffer() {
+        if (this.isAltBuffer)
+            return;
+        this.isAltBuffer = true;
+        this.normalLines = this.lines;
+        this.normalScrollback = this.scrollback;
+        this.normalCursor = { ...this.cursor };
+        this.altLines = [];
+        for (let r = 0; r < this.rows; r++) {
+            this.altLines.push(this.createEmptyLine());
+        }
+        this.lines = this.altLines;
+        this.scrollback = [];
+        this.viewportY = 0;
+        this.cursor = { ...this.altCursor };
+        for (let r = 0; r < this.rows; r++) {
+            this.dirtyRowSet.add(r);
+        }
+    }
+    exitAltBuffer() {
+        if (!this.isAltBuffer)
+            return;
+        this.isAltBuffer = false;
+        this.altCursor = { ...this.cursor };
+        this.lines = this.normalLines;
+        this.scrollback = this.normalScrollback;
+        this.cursor = { ...this.normalCursor };
+        this.viewportY = this.scrollback.length;
+        for (let r = 0; r < this.rows; r++) {
+            this.dirtyRowSet.add(r);
+        }
+    }
+    handleSgr(args) {
+        if (args.length === 0)
+            args = [0];
+        let i = 0;
+        while (i < args.length) {
+            const code = args[i++];
+            if (code === 0) {
+                this.currentFlags = CellFlags.EMPTY;
+                this.currentFg = { type: 'default' };
+                this.currentBg = { type: 'default' };
+                this.currentUnderlineColor = undefined;
+            }
+            else if (code === 1)
+                this.currentFlags |= CellFlags.BOLD;
+            else if (code === 2)
+                this.currentFlags |= CellFlags.DIM;
+            else if (code === 3)
+                this.currentFlags |= CellFlags.ITALIC;
+            else if (code === 4) {
+                // Check sub-parameters for 4:x undercurl styles if followed by subcodes
+                if (args[i] === 3) {
+                    this.currentFlags |= CellFlags.UNDERCURL;
+                    i++;
+                }
+                else if (args[i] === 4) {
+                    this.currentFlags |= CellFlags.UNDERLINE_DOTTED;
+                    i++;
+                }
+                else if (args[i] === 5) {
+                    this.currentFlags |= CellFlags.UNDERLINE_DASHED;
+                    i++;
+                }
+                else {
+                    this.currentFlags |= CellFlags.UNDERLINE;
+                }
+            }
+            else if (code === 5)
+                this.currentFlags |= CellFlags.BLINK;
+            else if (code === 7)
+                this.currentFlags |= CellFlags.INVERSE;
+            else if (code === 8)
+                this.currentFlags |= CellFlags.HIDDEN;
+            else if (code === 9)
+                this.currentFlags |= CellFlags.STRIKETHROUGH;
+            else if (code === 22)
+                this.currentFlags &= ~(CellFlags.BOLD | CellFlags.DIM);
+            else if (code === 23)
+                this.currentFlags &= ~CellFlags.ITALIC;
+            else if (code === 24) {
+                this.currentFlags &= ~(CellFlags.UNDERLINE | CellFlags.UNDERCURL | CellFlags.UNDERLINE_DOTTED | CellFlags.UNDERLINE_DASHED);
+            }
+            else if (code === 25)
+                this.currentFlags &= ~CellFlags.BLINK;
+            else if (code === 27)
+                this.currentFlags &= ~CellFlags.INVERSE;
+            else if (code === 28)
+                this.currentFlags &= ~CellFlags.HIDDEN;
+            else if (code === 29)
+                this.currentFlags &= ~CellFlags.STRIKETHROUGH;
+            else if (code >= 30 && code <= 37) {
+                this.currentFg = { type: 'indexed', index: code - 30 };
+            }
+            else if (code === 38) {
+                if (args[i] === 5) {
+                    this.currentFg = { type: 'indexed', index: args[i + 1] };
+                    i += 2;
+                }
+                else if (args[i] === 2) {
+                    this.currentFg = { type: 'rgb', r: args[i + 1], g: args[i + 2], b: args[i + 3] };
+                    i += 4;
+                }
+            }
+            else if (code === 39) {
+                this.currentFg = { type: 'default' };
+            }
+            else if (code >= 40 && code <= 47) {
+                this.currentBg = { type: 'indexed', index: code - 40 };
+            }
+            else if (code === 48) {
+                if (args[i] === 5) {
+                    this.currentBg = { type: 'indexed', index: args[i + 1] };
+                    i += 2;
+                }
+                else if (args[i] === 2) {
+                    this.currentBg = { type: 'rgb', r: args[i + 1], g: args[i + 2], b: args[i + 3] };
+                    i += 4;
+                }
+            }
+            else if (code === 49) {
+                this.currentBg = { type: 'default' };
+            }
+            else if (code === 58) {
+                // Underline color: 58;2;r;g;b or 58;5;idx
+                if (args[i] === 5) {
+                    this.currentUnderlineColor = { type: 'indexed', index: args[i + 1] };
+                    i += 2;
+                }
+                else if (args[i] === 2) {
+                    this.currentUnderlineColor = { type: 'rgb', r: args[i + 1], g: args[i + 2], b: args[i + 3] };
+                    i += 4;
+                }
+            }
+            else if (code === 59) {
+                this.currentUnderlineColor = undefined;
+            }
+            else if (code >= 90 && code <= 97) {
+                this.currentFg = { type: 'indexed', index: code - 90 + 8 };
+            }
+            else if (code >= 100 && code <= 107) {
+                this.currentBg = { type: 'indexed', index: code - 100 + 8 };
+            }
+        }
+    }
+    handleOsc(buffer) {
+        const semiIdx = buffer.indexOf(';');
+        if (semiIdx === -1)
+            return;
+        const ident = parseInt(buffer.slice(0, semiIdx), 10);
+        const content = buffer.slice(semiIdx + 1);
+        this.events.onOsc?.(ident, content);
+        if (ident === 0 || ident === 2) {
+            this.events.onTitle?.(content);
+        }
+        else if (ident === 7) {
+            let url = content;
+            if (url.startsWith('file://'))
+                url = url.slice(7);
+            const slash = url.indexOf('/');
+            if (slash !== -1 && !url.startsWith('/'))
+                url = url.slice(slash);
+            this.events.onCwd?.(decodeURIComponent(url));
+        }
+        else if (ident === 52) {
+            const secondSemi = content.indexOf(';');
+            const encoded = secondSemi !== -1 ? content.slice(secondSemi + 1) : content;
+            if (encoded && encoded !== '?') {
+                try {
+                    const decoded = typeof atob === 'function'
+                        ? atob(encoded)
+                        : typeof globalThis.Buffer !== 'undefined'
+                            ? globalThis.Buffer.from(encoded, 'base64').toString('utf8')
+                            : encoded;
+                    this.events.onClipboard?.(decoded);
+                }
+                catch {
+                    // ignore malformed base64
+                }
+            }
+        }
+        else if (ident === 8) {
+            // OSC 8 Hyperlink: ]8;params;url
+            const secondSemi = content.indexOf(';');
+            if (secondSemi !== -1) {
+                const url = content.slice(secondSemi + 1);
+                this.currentHyperlink = url.length > 0 ? url : undefined;
+            }
+            else {
+                this.currentHyperlink = content.length > 0 ? content : undefined;
+            }
+        }
+    }
+    clearLine(row) {
+        if (row < this.lines.length) {
+            this.lines[row] = this.createEmptyLine();
+            this.dirtyRowSet.add(row);
+        }
+    }
+    clearLineRange(row, startCol, endCol) {
+        if (row < this.lines.length) {
+            for (let c = Math.max(0, startCol); c <= Math.min(this.cols - 1, endCol); c++) {
+                this.lines[row][c] = {
+                    char: ' ',
+                    width: 1,
+                    flags: CellFlags.EMPTY,
+                    fg: { type: 'default' },
+                    bg: { type: 'default' },
+                };
+            }
+            this.dirtyRowSet.add(row);
+        }
+    }
+    reset() {
+        this.currentFlags = CellFlags.EMPTY;
+        this.currentFg = { type: 'default' };
+        this.currentBg = { type: 'default' };
+        this.currentUnderlineColor = undefined;
+        this.currentHyperlink = undefined;
+        this.wrapPending = false;
+        this.autowrap = true;
+        this.originMode = false;
+        this.lastPrintedChar = '';
+        this.cursor.col = 0;
+        this.cursor.row = 0;
+        this.cursor.visible = true;
+        this.scrollback = [];
+        this.viewportY = 0;
+        this.isAltBuffer = false;
+        this.mouseMode = { x10: false, button: false, any: false, sgr: false };
+        this.focusReporting = false;
+        this.initGrid();
+    }
+}
+//# sourceMappingURL=VtEngine.js.map