@askdkc/dsh-cli 0.11.3

package/lib/types/ink/terminal.js

@@ -0,0 +1,436 @@
+import { coerce } from 'semver';
+import { appendFileSync } from 'node:fs';
+import { env } from '../utils/env.js';
+import { gte } from '../utils/semver.js';
+import { CURSOR_HOME, cursorMove, cursorTo, ERASE_SCREEN, eraseLines, SGR_RESET, } from './termio/csi.js';
+import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js';
+import { link } from './termio/osc.js';
+/**
+ * Checks if the terminal supports OSC 9;4 progress reporting.
+ * Supported terminals:
+ * - ConEmu (Windows) - all versions
+ * - Ghostty 1.2.0+
+ * - iTerm2 3.6.6+
+ *
+ * Note: Windows Terminal interprets OSC 9;4 as notifications, not progress.
+ * @returns true when the terminal supports OSC 9;4 progress reporting.
+ */
+export function isProgressReportingAvailable() {
+    // Only available if we have a TTY (not piped)
+    if (!process.stdout.isTTY) {
+        return false;
+    }
+    // Explicitly exclude Windows Terminal, which interprets OSC 9;4 as
+    // notifications rather than progress indicators
+    if (process.env.WT_SESSION) {
+        return false;
+    }
+    // ConEmu supports OSC 9;4 for progress (all versions)
+    if (process.env.ConEmuANSI ||
+        process.env.ConEmuPID ||
+        process.env.ConEmuTask) {
+        return true;
+    }
+    const version = coerce(process.env.TERM_PROGRAM_VERSION);
+    if (!version) {
+        return false;
+    }
+    // Ghostty 1.2.0+ supports OSC 9;4 for progress
+    // https://ghostty.org/docs/install/release-notes/1-2-0
+    if (process.env.TERM_PROGRAM === 'ghostty') {
+        return gte(version.version, '1.2.0');
+    }
+    // iTerm2 3.6.6+ supports OSC 9;4 for progress
+    // https://iterm2.com/downloads.html
+    if (process.env.TERM_PROGRAM === 'iTerm.app') {
+        return gte(version.version, '3.6.6');
+    }
+    return false;
+}
+/**
+ * True when running inside a JetBrains IDE terminal (JediTerm). The IDE
+ * injects `TERMINAL_EMULATOR=JetBrains-JediTerm` into the pty environment of
+ * its local terminal sessions and sets no TERM_PROGRAM, so this is the only
+ * reliable local-JediTerm marker; it is also not forwarded over SSH by
+ * default (sshd only sends TERM), matching the local-terminal scope of the
+ * behaviors it gates.
+ *
+ * JediTerm's emulation diverges from xterm.js in exactly the places the
+ * renderer cares about (DEC 2026 support, DECSTBM semantics), so it is
+ * detected explicitly rather than left to TERM/TERM_PROGRAM fallbacks.
+ * @returns true when the process runs in a JetBrains IDE terminal.
+ */
+export function isJetBrainsIdeTerminal() {
+    return process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm';
+}
+/**
+ * Detects zellij, which multiplexes the outer terminal instead of emulating
+ * it. Capability probes therefore describe the *outer* terminal — zellij even
+ * forwards KITTY_WINDOW_ID into the pane, so kitty detection matches — while
+ * zellij's own grid decides how control sequences actually apply.
+ * @returns true when the process runs inside a zellij pane.
+ */
+export function isZellij() {
+    return !!process.env.ZELLIJ;
+}
+/**
+ * Checks if the terminal supports DEC mode 2026 (synchronized output).
+ * When supported, BSU/ESU sequences prevent visible flicker during redraws.
+ * @returns true when the terminal supports DEC 2026.
+ */
+export function isSynchronizedOutputSupported() {
+    // tmux parses and proxies every byte but doesn't implement DEC 2026.
+    // BSU/ESU pass through to the outer terminal but tmux has already
+    // broken atomicity by chunking. Skip to save 16 bytes/frame + parser work.
+    if (process.env.TMUX)
+        return false;
+    const termProgram = process.env.TERM_PROGRAM;
+    const term = process.env.TERM;
+    // Modern terminals with known DEC 2026 support
+    if (termProgram === 'iTerm.app' ||
+        termProgram === 'WezTerm' ||
+        termProgram === 'WarpTerminal' ||
+        termProgram === 'ghostty' ||
+        termProgram === 'contour' ||
+        termProgram === 'vscode' ||
+        termProgram === 'alacritty') {
+        return true;
+    }
+    // JetBrains IDE terminals (JediTerm) implement DEC 2026 synchronized
+    // output; TERM_PROGRAM is unset there (only TERMINAL_EMULATOR is), so the
+    // env list above never matches. Frames wrapped in BSU/ESU land atomically
+    // in JediTerm's reworked block renderer — the same guarantee VS Code gets
+    // via TERM_PROGRAM=vscode — which keeps its partial-update reflow from
+    // scrambling continuously-updated screens.
+    if (isJetBrainsIdeTerminal())
+        return true;
+    // kitty sets TERM=xterm-kitty or KITTY_WINDOW_ID
+    if (term?.includes('kitty') || process.env.KITTY_WINDOW_ID)
+        return true;
+    // Ghostty may set TERM=xterm-ghostty without TERM_PROGRAM
+    if (term === 'xterm-ghostty')
+        return true;
+    // foot sets TERM=foot or TERM=foot-extra
+    if (term?.startsWith('foot'))
+        return true;
+    // Alacritty may set TERM containing 'alacritty'
+    if (term?.includes('alacritty'))
+        return true;
+    // Zed uses the alacritty_terminal crate which supports DEC 2026
+    if (process.env.ZED_TERM)
+        return true;
+    // Windows Terminal
+    if (process.env.WT_SESSION)
+        return true;
+    // VTE-based terminals (GNOME Terminal, Tilix, etc.) since VTE 0.68
+    const vteVersion = process.env.VTE_VERSION;
+    if (vteVersion) {
+        const version = parseInt(vteVersion, 10);
+        if (version >= 6800)
+            return true;
+    }
+    return false;
+}
+// -- XTVERSION-detected terminal name (populated async at startup) --
+//
+// TERM_PROGRAM is not forwarded over SSH by default, so env-based detection
+// fails when dsh-tui runs remotely inside a VS Code integrated terminal.
+// XTVERSION (CSI > 0 q → DCS > | name ST) goes through the pty — the query
+// reaches the *client* terminal and the reply comes back through stdin.
+// App.tsx fires the query when raw mode enables; setXtversionName() is called
+// from the response handler. Readers should treat undefined as "not yet known"
+// and fall back to env-var detection.
+let xtversionName;
+/**
+ * Record the XTVERSION response. Called once from App.tsx when the reply
+ * arrives on stdin. No-op if already set (defend against re-probe).
+ * @param name - the terminal name reported by the XTVERSION reply.
+ */
+export function setXtversionName(name) {
+    if (xtversionName === undefined)
+        xtversionName = name;
+}
+/**
+ * True if running in an xterm.js-based terminal (VS Code, Cursor, Windsurf
+ * integrated terminals). Combines TERM_PROGRAM env check (fast, sync, but
+ * not forwarded over SSH) with the XTVERSION probe result (async, survives
+ * SSH — query/reply goes through the pty). Early calls may miss the probe
+ * reply — call lazily (e.g. in an event handler) if SSH detection matters.
+ * @returns true when the terminal is xterm.js-based.
+ */
+export function isXtermJs() {
+    if (process.env.TERM_PROGRAM === 'vscode')
+        return true;
+    return xtversionName?.startsWith('xterm.js') ?? false;
+}
+/**
+ * True when the terminal can be safely probed with DECRQM
+ * (`CSI ? <mode> $ p`).
+ *
+ * DECRQM carries a `$` intermediate byte before its final `p`. A conforming
+ * parser consumes the whole sequence and either answers with DECRPM or stays
+ * silent, so callers have historically treated an unanswered probe as
+ * "unsupported" and sent it unconditionally. macOS Terminal.app breaks that
+ * assumption: it does not implement DECRQM *and* its CSI parser gives up at
+ * the `$`, printing the trailing `p` to the screen as literal text. Every
+ * probe therefore leaks a visible `p` at the cursor.
+ *
+ * Terminal.app reports `TERM=xterm-256color`, so TERM sniffing cannot tell it
+ * apart from a real xterm — `TERM_PROGRAM=Apple_Terminal` is the only marker.
+ * It is not forwarded over SSH, which matches the scope of the bug: the leak
+ * only happens when the sequence reaches Terminal.app's own parser, and a
+ * remote session is parsed by whatever terminal is actually attached.
+ *
+ * Kept as an exclusion rather than an allowlist so unknown terminals keep the
+ * (correct, spec-conforming) probe and only the known-broken one opts out.
+ * Same failure mode as the extended-keys allowlist below: assuming terminals
+ * silently ignore unknown CSI is not safe in practice.
+ * @returns true when it is safe to send a DECRQM probe.
+ */
+export function supportsDecrqmProbe() {
+    return process.env.TERM_PROGRAM !== 'Apple_Terminal';
+}
+// Terminals known to correctly implement the Kitty keyboard protocol
+// (CSI >1u) and/or xterm modifyOtherKeys (CSI >4;2m) for ctrl+shift+<letter>
+// disambiguation. We previously enabled unconditionally (#23350), assuming
+// terminals silently ignore unknown CSI — but some terminals honor the enable
+// and emit codepoints our input parser doesn't handle (notably over SSH and
+// in xterm.js-based terminals like VS Code). tmux is allowlisted because it
+// accepts modifyOtherKeys and doesn't forward the kitty sequence to the outer
+// terminal.
+// env.terminal is lowercased (utils/env.ts) and falls back to TERM when
+// TERM_PROGRAM is unset — kitty doesn't set TERM_PROGRAM, so its TERM
+// (xterm-kitty) is listed too. Warp sets TERM_PROGRAM=WarpTerminal and
+// implements the kitty keyboard protocol (issue #110).
+const EXTENDED_KEYS_TERMINALS = [
+    'iterm.app',
+    'kitty',
+    'xterm-kitty',
+    'wezterm',
+    'ghostty',
+    'tmux',
+    'warpterminal',
+    'windows-terminal',
+];
+/**
+ * True if this terminal correctly handles extended key reporting
+ * (Kitty keyboard protocol + xterm modifyOtherKeys).
+ * WT_SESSION catches Windows Terminal regardless of TERM_PROGRAM (which WT
+ * doesn't set and SSH doesn't forward) — its modifyOtherKeys implementation
+ * covers navigation keys. It does NOT cover Enter (microsoft/terminal#530);
+ * Shift+Enter on native Windows needs win32-input-mode instead — see
+ * supportsWin32InputMode (issue #147).
+ * @returns true when the terminal is on the extended-keys allowlist.
+ */
+export function supportsExtendedKeys() {
+    if (process.env.WT_SESSION)
+        return true;
+    return EXTENDED_KEYS_TERMINALS.includes(env.terminal ?? '');
+}
+/**
+ * True when win32-input-mode (DECSET 9001, `CSI ? 9001 h`) should drive
+ * keyboard input. This is a ConPTY feature — both Windows Terminal and
+ * classic conhost switch into it when the app emits the sequence. In this
+ * mode every key arrives as a full INPUT_RECORD
+ * (`CSI Vk;Sc;Uc;Kd;Cs;Rc _`), the only encoding that
+ * preserves Enter's Shift/Ctrl bits on Windows (issue #147). It replaces
+ * the kitty/modifyOtherKeys push — callers must treat them as mutually
+ * exclusive. Non-ConPTY Windows terminals (mintty via winpty) ignore the
+ * unknown private mode and fall back to classic VT input unchanged.
+ *
+ * Embedded xterm.js hosts may identify as `TERM_PROGRAM=vscode` while using
+ * the xterm.js engine version as TERM_PROGRAM_VERSION (Termy 1.4.1 reports
+ * 6.0.0). They do not provide native ConPTY's input-mode contract: enabling
+ * 9001 can reduce arrows/mouse sequences to their trailing A-D/M bytes and
+ * interfere with IME commits (issue #215). Native VS Code reports its own
+ * 1.x application version and retains win32-input-mode support.
+ * @returns true on native Windows (never in WSL — platform is linux there).
+ */
+export function supportsWin32InputMode(platform = process.platform, termProgram = process.env.TERM_PROGRAM, termProgramVersion = process.env.TERM_PROGRAM_VERSION) {
+    if (platform !== 'win32')
+        return false;
+    const version = coerce(termProgramVersion);
+    const isEmbeddedXtermJs = termProgram === 'vscode' && version !== null && version.major >= 5;
+    return !isEmbeddedXtermJs;
+}
+/**
+ * True if the terminal scrolls the viewport when it receives cursor-up
+ * sequences that reach above the visible area. On Windows, conhost's
+ * SetConsoleCursorPosition follows the cursor into scrollback
+ * (microsoft/terminal#14774), yanking users to the top of their buffer
+ * mid-stream. WT_SESSION catches WSL-in-Windows-Terminal where platform
+ * is linux but output still routes through conhost.
+ * @returns true when the cursor-up viewport-yank bug applies.
+ */
+export function hasCursorUpViewportYankBug() {
+    return process.platform === 'win32' || !!process.env.WT_SESSION;
+}
+/**
+ * Whether synchronized output (DEC 2026) is available, computed once at
+ * module load — terminal capabilities don't change mid-session. Exported
+ * so callers can pass a sync-skip hint gated to specific modes.
+ */
+export const SYNC_OUTPUT_SUPPORTED = isSynchronizedOutputSupported();
+/**
+ * Whether the DECSTBM hardware-scroll optimization may be used to paint
+ * ScrollBox scrolls. Called once per frame — the same env reads as the
+ * SYNC_OUTPUT_SUPPORTED gate, so the extra cost is a single comparison.
+ *
+ * JediTerm is explicitly excluded even though it implements DEC 2026: its
+ * scroll-region (DECSTBM) + CSI S/T handling deviates from xterm and, when
+ * driven per-frame by a diffing renderer, corrupts the screen progressively
+ * as content scrolls (the "JetBrains terminal slowly garbles" bug class).
+ * The diff engine falls back to repainting the shifted rows cell-by-cell,
+ * which every terminal renders identically. Disable DECSTBM on JetBrains terminals.
+ *
+ * zellij is excluded for the same class of reason. Its `CSI T`
+ * (grid.rs rotate_scroll_region_up) shifts rows only while the cursor sits
+ * inside the scroll region, and its `CSI r` does not home the cursor outside
+ * origin mode — but the renderer parks the cursor on the last screen row,
+ * below every ScrollBox. The shift is silently dropped while the diff assumes
+ * it happened, so stale rows survive every scroll-up frame (tearing, leftover
+ * transcript lines). Only DECSTBM is withdrawn: zellij does implement DEC
+ * 2026, so BSU/ESU stay on and frames remain atomic.
+ * @returns true when DECSTBM scroll optimization is safe on this terminal.
+ */
+export function isDecstbmSafe() {
+    return SYNC_OUTPUT_SUPPORTED && !isJetBrainsIdeTerminal() && !isZellij();
+}
+/**
+ * Render forensics: when DSH_TUI_RENDER_LOG names a file path, every painted
+ * frame's raw ANSI bytes append to it (one JSON-escaped line per frame,
+ * prefixed with a timestamp header). Real-terminal rendering corruption
+ * (missing rows, stale attributes) cannot be reproduced in headless xterm
+ * harnesses — this captures the exact byte stream the terminal received so
+ * the corrupt frame can be diffed against the expected screen. Opt-in and
+ * zero-cost when unset: the env read happens once at module load.
+ */
+const RENDER_LOG_PATH = process.env.DSH_TUI_RENDER_LOG ?? '';
+function dumpFrame(buffer) {
+    if (RENDER_LOG_PATH === '')
+        return;
+    try {
+        appendFileSync(RENDER_LOG_PATH, `\n===== frame ${new Date().toISOString()} (${buffer.length} bytes) =====\n${JSON.stringify(buffer)}\n`);
+    }
+    catch {
+        // Forensics must never break rendering: an unwritable log path (bad
+        // directory, permissions) drops the dump, not the frame.
+    }
+}
+/**
+ * Write a frame diff to the terminal as a single buffered write. Wraps
+ * the output in BSU/ESU synchronized-update markers unless skipSyncMarkers
+ * is set. No-op when the diff contains no patches.
+ * @param terminal - the terminal to write to.
+ * @param diff - the frame diff patches to render.
+ * @param skipSyncMarkers - when true, omit the BSU/ESU wrapping.
+ */
+/**
+ * Serialize a frame diff into a single ANSI string (BSU/ESU-wrapped unless
+ * skipSyncMarkers is set). Empty string when the diff has no patches.
+ * Extracted from writeDiffToTerminal so shutdown paths can write the last
+ * frame synchronously (issue #522: an async frame write racing the
+ * synchronous EXIT_ALT_SCREEN lands on the MAIN screen after the alt
+ * screen is gone, leaving misplaced residue).
+ */
+export function serializeDiff(terminal, diff, skipSyncMarkers = false) {
+    // No output if there are no patches
+    if (diff.length === 0) {
+        return '';
+    }
+    // BSU/ESU wrapping is opt-out to keep main-screen behavior unchanged.
+    // Callers pass skipSyncMarkers=true when the terminal doesn't support
+    // DEC 2026 (e.g. tmux) AND the cost matters (high-frequency alt-screen).
+    const useSync = !skipSyncMarkers;
+    // Buffer all writes into a single string to avoid multiple write calls.
+    // SGR_RESET + link('') head every frame: the diff engine computes style
+    // and hyperlink transitions from a frame-start baseline of none — normally
+    // guaranteed by the previous frame's tail resets, but a truncated frame
+    // (interrupted write, dropped PTY bytes) leaves the terminal stuck with a
+    // colored SGR / an open hyperlink. Every erase, hardware scroll, and LF
+    // scroll fills blank cells with the CURRENT background (BCE), so one stuck
+    // red background floods whole regions (issue #10). ~12 bytes per frame
+    // turn the baseline assumption into a per-frame guarantee; on healthy
+    // frames both sequences are idempotent no-ops.
+    let buffer = (useSync ? BSU : '') + SGR_RESET + link('');
+    for (const patch of diff) {
+        switch (patch.type) {
+            case 'stdout':
+                buffer += patch.content;
+                break;
+            case 'clear':
+                if (patch.count > 0) {
+                    buffer += eraseLines(patch.count);
+                }
+                break;
+            case 'clearTerminal':
+                // Hard clear of screen + scrollback. MUST run OUTSIDE the BSU/ESU
+                // sync block: Windows Terminal snaps the viewport back to the top
+                // when 2J/3J execute inside a synchronized-update block
+                // — the reason the scrollUp-based "soft" clear
+                // existed at all. Close the block, clear, reopen. Everything stays
+                // in the SAME write, so the terminal processes it with no
+                // intermediate paint. The hard clear actually removes the UI's
+                // scrollback snapshots (the duplicated whale-logo class of bugs);
+                // the old soft clear (CSI n S) PUSHED the live viewport into the
+                // scrollback instead, depositing a fresh full-UI copy per reset.
+                // Screen-only hard clear: 2J + home, NO 3J. Erasing the scrollback
+                // here destroyed the user's entire visible history on every settle
+                // shrink (the "context lost / cannot scroll" reports) — the inline
+                // transcript IS the scrollback; wiping it to avoid duplicate
+                // snapshots is never an acceptable trade. 2J clears the screen for
+                // the repaint while everything above the viewport survives.
+                // Executed OUTSIDE the DEC 2026 sync block (split begin/end): WT
+                // yanks the viewport to top when 2J runs inside a synchronized
+                // update.
+                buffer +=
+                    (useSync ? ESU : '') +
+                        SGR_RESET +
+                        ERASE_SCREEN +
+                        CURSOR_HOME +
+                        (useSync ? BSU : '');
+                break;
+            case 'cursorHide':
+                buffer += HIDE_CURSOR;
+                break;
+            case 'cursorShow':
+                buffer += SHOW_CURSOR;
+                break;
+            case 'cursorMove':
+                buffer += cursorMove(patch.x, patch.y);
+                break;
+            case 'cursorTo':
+                buffer += cursorTo(patch.col);
+                break;
+            case 'carriageReturn':
+                buffer += '\r';
+                break;
+            case 'hyperlink':
+                buffer += link(patch.uri);
+                break;
+            case 'styleStr':
+                buffer += patch.str;
+                break;
+        }
+    }
+    // Add synchronized update end and flush buffer
+    if (useSync)
+        buffer += ESU;
+    dumpFrame(buffer);
+    return buffer;
+}
+/**
+ * Write a frame diff to the terminal as a single buffered write. Wraps
+ * the output in BSU/ESU synchronized-update markers unless skipSyncMarkers
+ * is set. No-op when the diff contains no patches.
+ * @param terminal - the terminal to write to.
+ * @param diff - the frame diff patches to render.
+ * @param skipSyncMarkers - when true, omit the BSU/ESU wrapping.
+ */
+export function writeDiffToTerminal(terminal, diff, skipSyncMarkers = false) {
+    const buffer = serializeDiff(terminal, diff, skipSyncMarkers);
+    if (buffer === '') {
+        return;
+    }
+    terminal.stdout.write(buffer);
+}

package/lib/types/ink/termio/ansi.d.ts

@@ -0,0 +1,75 @@
+/**
+ * ANSI Control Characters and Escape Sequence Introducers
+ *
+ * Based on ECMA-48 / ANSI X3.64 standards.
+ */
+/**
+ * C0 (7-bit) control characters
+ */
+export declare const C0: {
+    readonly NUL: 0;
+    readonly SOH: 1;
+    readonly STX: 2;
+    readonly ETX: 3;
+    readonly EOT: 4;
+    readonly ENQ: 5;
+    readonly ACK: 6;
+    readonly BEL: 7;
+    readonly BS: 8;
+    readonly HT: 9;
+    readonly LF: 10;
+    readonly VT: 11;
+    readonly FF: 12;
+    readonly CR: 13;
+    readonly SO: 14;
+    readonly SI: 15;
+    readonly DLE: 16;
+    readonly DC1: 17;
+    readonly DC2: 18;
+    readonly DC3: 19;
+    readonly DC4: 20;
+    readonly NAK: 21;
+    readonly SYN: 22;
+    readonly ETB: 23;
+    readonly CAN: 24;
+    readonly EM: 25;
+    readonly SUB: 26;
+    readonly ESC: 27;
+    readonly FS: 28;
+    readonly GS: 29;
+    readonly RS: 30;
+    readonly US: 31;
+    readonly DEL: 127;
+};
+/** ESC control character (0x1B), the introducer of every escape sequence. */
+export declare const ESC = "\u001B";
+/** BEL control character (0x07), the common OSC sequence terminator. */
+export declare const BEL = "\u0007";
+/** Parameter separator used inside CSI and OSC sequences. */
+export declare const SEP = ";";
+/**
+ * Escape sequence type introducers (byte after ESC)
+ */
+export declare const ESC_TYPE: {
+    readonly CSI: 91;
+    readonly OSC: 93;
+    readonly DCS: 80;
+    readonly APC: 95;
+    readonly PM: 94;
+    readonly SOS: 88;
+    readonly ST: 92;
+};
+/**
+ * Check if a byte is a C0 control character.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the C0 range (0x00-0x1F) or is DEL (0x7F).
+ */
+export declare function isC0(byte: number): boolean;
+/**
+ * Check if a byte is an ESC sequence final byte (0-9, :, ;, <, =, >, ?, @ through ~).
+ * ESC sequences have a wider final byte range than CSI.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the final-byte range (0x30-0x7E).
+ */
+export declare function isEscFinal(byte: number): boolean;
+//# sourceMappingURL=ansi.d.ts.map

package/lib/types/ink/termio/ansi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansi.d.ts","sourceRoot":"","sources":["../../../../src/ink/termio/ansi.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCL,CAAA;AAIV,6EAA6E;AAC7E,eAAO,MAAM,GAAG,WAAS,CAAA;AAEzB,wEAAwE;AACxE,eAAO,MAAM,GAAG,WAAS,CAAA;AAEzB,6DAA6D;AAC7D,eAAO,MAAM,GAAG,MAAM,CAAA;AAEtB;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;CAQX,CAAA;AAEV;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEhD"}

package/lib/types/ink/termio/ansi.js

@@ -0,0 +1,79 @@
+/**
+ * ANSI Control Characters and Escape Sequence Introducers
+ *
+ * Based on ECMA-48 / ANSI X3.64 standards.
+ */
+/**
+ * C0 (7-bit) control characters
+ */
+export const C0 = {
+    NUL: 0x00,
+    SOH: 0x01,
+    STX: 0x02,
+    ETX: 0x03,
+    EOT: 0x04,
+    ENQ: 0x05,
+    ACK: 0x06,
+    BEL: 0x07,
+    BS: 0x08,
+    HT: 0x09,
+    LF: 0x0a,
+    VT: 0x0b,
+    FF: 0x0c,
+    CR: 0x0d,
+    SO: 0x0e,
+    SI: 0x0f,
+    DLE: 0x10,
+    DC1: 0x11,
+    DC2: 0x12,
+    DC3: 0x13,
+    DC4: 0x14,
+    NAK: 0x15,
+    SYN: 0x16,
+    ETB: 0x17,
+    CAN: 0x18,
+    EM: 0x19,
+    SUB: 0x1a,
+    ESC: 0x1b,
+    FS: 0x1c,
+    GS: 0x1d,
+    RS: 0x1e,
+    US: 0x1f,
+    DEL: 0x7f,
+};
+// String constants for output generation
+/** ESC control character (0x1B), the introducer of every escape sequence. */
+export const ESC = '\x1b';
+/** BEL control character (0x07), the common OSC sequence terminator. */
+export const BEL = '\x07';
+/** Parameter separator used inside CSI and OSC sequences. */
+export const SEP = ';';
+/**
+ * Escape sequence type introducers (byte after ESC)
+ */
+export const ESC_TYPE = {
+    CSI: 0x5b, // [ - Control Sequence Introducer
+    OSC: 0x5d, // ] - Operating System Command
+    DCS: 0x50, // P - Device Control String
+    APC: 0x5f, // _ - Application Program Command
+    PM: 0x5e, // ^ - Privacy Message
+    SOS: 0x58, // X - Start of String
+    ST: 0x5c, // \ - String Terminator
+};
+/**
+ * Check if a byte is a C0 control character.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the C0 range (0x00-0x1F) or is DEL (0x7F).
+ */
+export function isC0(byte) {
+    return byte < 0x20 || byte === 0x7f;
+}
+/**
+ * Check if a byte is an ESC sequence final byte (0-9, :, ;, <, =, >, ?, @ through ~).
+ * ESC sequences have a wider final byte range than CSI.
+ * @param byte - the byte value to check.
+ * @returns true when the byte is in the final-byte range (0x30-0x7E).
+ */
+export function isEscFinal(byte) {
+    return byte >= 0x30 && byte <= 0x7e;
+}