@textui/terminal 0.1.0

package/dist/input.js

@@ -0,0 +1,357 @@
+/**
+ * Input decoding.
+ *
+ * A terminal delivers keys as bytes that may arrive split across reads, so the
+ * decoder is a small state machine over a carry buffer rather than a parser
+ * over whole strings. When a sequence is incomplete it stays in the buffer and
+ * waits, which is what stops a fast paste from being read as a burst of keys.
+ */
+const ESC = '\x1b';
+function key(name, partial = {}) {
+    return {
+        type: 'key',
+        name,
+        ctrl: false,
+        alt: false,
+        shift: false,
+        meta: false,
+        raw: partial.raw ?? name,
+        handled: false,
+        ...partial,
+    };
+}
+/** CSI final byte to key name, for the `ESC [ A` family. */
+const CSI_LETTERS = {
+    A: 'up', B: 'down', C: 'right', D: 'left',
+    E: 'center', F: 'end', H: 'home',
+    P: 'f1', Q: 'f2', R: 'f3', S: 'f4',
+    Z: 'tab', // shift+tab arrives as CSI Z
+};
+/** `ESC [ <n> ~` numbers. */
+const CSI_NUMBERS = {
+    1: 'home', 2: 'insert', 3: 'delete', 4: 'end', 5: 'pageup', 6: 'pagedown',
+    7: 'home', 8: 'end',
+    11: 'f1', 12: 'f2', 13: 'f3', 14: 'f4', 15: 'f5',
+    17: 'f6', 18: 'f7', 19: 'f8', 20: 'f9', 21: 'f10',
+    23: 'f11', 24: 'f12',
+};
+/** xterm modifier parameter: 1 + bitmask. */
+function modifiers(param) {
+    const bits = (param ?? 1) - 1;
+    return {
+        shift: (bits & 1) !== 0,
+        alt: (bits & 2) !== 0,
+        ctrl: (bits & 4) !== 0,
+        meta: (bits & 8) !== 0,
+    };
+}
+const CTRL_NAMES = {
+    0x00: 'space', // ctrl+space
+    0x08: 'backspace',
+    0x09: 'tab',
+    0x0a: 'enter',
+    0x0d: 'enter',
+    0x1b: 'escape',
+    0x7f: 'backspace',
+};
+export class InputDecoder {
+    emit;
+    options;
+    carry = '';
+    pasting = false;
+    pasteBuffer = '';
+    escapeTimer = null;
+    constructor(emit, options = {}) {
+        this.emit = emit;
+        this.options = options;
+    }
+    /** Feed raw input. Emits zero or more events. */
+    feed(chunk) {
+        this.clearEscapeTimer();
+        this.carry += chunk;
+        for (;;) {
+            const consumed = this.step();
+            if (consumed === 0)
+                break;
+        }
+        // A lone ESC is ambiguous until either more bytes arrive or time passes.
+        if (this.carry === ESC) {
+            this.escapeTimer = setTimeout(() => {
+                if (this.carry === ESC) {
+                    this.carry = '';
+                    this.emit(key('escape', { raw: ESC }));
+                }
+            }, this.options.escapeTimeoutMs ?? 30);
+            this.escapeTimer.unref?.();
+        }
+    }
+    clearEscapeTimer() {
+        if (this.escapeTimer) {
+            clearTimeout(this.escapeTimer);
+            this.escapeTimer = null;
+        }
+    }
+    /** Consume one event's worth of bytes. Returns how many were used. */
+    step() {
+        if (this.carry === '')
+            return 0;
+        if (this.pasting)
+            return this.stepPaste();
+        const first = this.carry[0];
+        if (first !== ESC)
+            return this.stepPlain();
+        if (this.carry.length === 1)
+            return 0; // wait for more
+        const second = this.carry[1];
+        if (second === '[')
+            return this.stepCsi();
+        if (second === 'O')
+            return this.stepSs3();
+        // ESC followed by a printable character is alt+that.
+        if (second !== ESC) {
+            const cp = this.carry.codePointAt(1);
+            const char = String.fromCodePoint(cp);
+            const raw = ESC + char;
+            this.carry = this.carry.slice(raw.length);
+            /*
+             * A control byte after ESC is alt+that key - and only *also* ctrl when
+             * the byte has no name of its own.
+             *
+             * `alt+enter` arrives as ESC then 0x0d, and 0x0d is the enter key, not
+             * ctrl+m: reporting `ctrl` beside it filed the stroke as
+             * `ctrl+alt+enter`, which is not what anybody binds and not what the
+             * same key produces without the ESC. `stepPlain` has always had this
+             * rule - `ctrl: cp === 0x00` - and this path did not, so `alt+tab`,
+             * `alt+backspace` and `alt+enter` were all unreachable.
+             *
+             * 0x00 keeps it, because that one really is ctrl+space.
+             */
+            // 0x7f as well as 0x20 and below: that is the backspace most terminals
+            // send, and `stepPlain` has always counted it as a control. Leaving it
+            // out here made `alt+backspace` a key named "\x7f".
+            const control = cp < 0x20 || cp === 0x7f;
+            const named = control ? CTRL_NAMES[cp] : undefined;
+            this.emit(control
+                ? key(named ?? String.fromCharCode(cp + 96), {
+                    alt: true,
+                    ...(named === undefined || cp === 0x00 ? { ctrl: true } : {}),
+                    raw,
+                })
+                : key(char, { char, alt: true, raw, shift: char !== char.toLowerCase() }));
+            return raw.length;
+        }
+        // Two escapes: report the first as the escape key.
+        this.carry = this.carry.slice(1);
+        this.emit(key('escape', { raw: ESC }));
+        return 1;
+    }
+    stepPlain() {
+        const cp = this.carry.codePointAt(0);
+        const char = String.fromCodePoint(cp);
+        if (cp < 0x20 || cp === 0x7f) {
+            this.carry = this.carry.slice(char.length);
+            const named = CTRL_NAMES[cp];
+            if (named) {
+                /*
+                 * 0x0a is `ctrl+enter`; 0x0d is enter.
+                 *
+                 * Both were named `enter` with no modifier, which made them the same
+                 * key - and that is what a composer sees when it offers "enter sends,
+                 * ctrl+enter is a newline" and the newline never comes. In raw mode
+                 * the Return key sends CR: the kernel's CR-to-NL translation is off,
+                 * so a bare LF is not Return, it is ctrl+Return (or ctrl+j, which is
+                 * the same byte and therefore the same key - there is no encoding in
+                 * which those two differ).
+                 *
+                 * Pasted newlines do not come through here: a bracketed paste is
+                 * buffered whole by `stepPaste` and emitted as a paste event.
+                 *
+                 * 0x00 keeps its ctrl for the same reason it always had it: that byte
+                 * really is ctrl+space.
+                 */
+                this.emit(key(named, { raw: char, ctrl: cp === 0x00 || cp === 0x0a }));
+            }
+            else {
+                // 0x01..0x1a are ctrl+a .. ctrl+z
+                const letter = String.fromCharCode(cp + 96);
+                this.emit(key(letter, { ctrl: true, raw: char }));
+            }
+            return char.length;
+        }
+        this.carry = this.carry.slice(char.length);
+        // Space is the one printable with a name, because it is the one printable
+        // people bind to. `KeyName` has always listed it and `Button`, `Checkbox`,
+        // `Switch` and `Select` have always tested for it - and none of them ever
+        // saw it, because a terminal sends 0x20 and this named it `' '`. The
+        // harness synthesised `'space'`, so every one of those tests passed while
+        // nothing worked. `char` stays `' '`, so typing one still types one.
+        const name = cp === 0x20 ? 'space' : char;
+        this.emit(key(name, { char, raw: char, shift: char !== char.toLowerCase() && char.toLowerCase() !== char.toUpperCase() }));
+        return char.length;
+    }
+    stepPaste() {
+        const end = this.carry.indexOf(`${ESC}[201~`);
+        if (end === -1) {
+            this.pasteBuffer += this.carry;
+            const used = this.carry.length;
+            this.carry = '';
+            return used;
+        }
+        this.pasteBuffer += this.carry.slice(0, end);
+        const used = end + 6;
+        this.carry = this.carry.slice(used);
+        this.pasting = false;
+        const text = this.pasteBuffer;
+        this.pasteBuffer = '';
+        this.emit({ type: 'paste', text, handled: false });
+        return used;
+    }
+    /** `ESC O P` - the application-cursor form of F1..F4 and the arrows. */
+    stepSs3() {
+        if (this.carry.length < 3)
+            return 0;
+        const final = this.carry[2];
+        const raw = this.carry.slice(0, 3);
+        this.carry = this.carry.slice(3);
+        const name = CSI_LETTERS[final];
+        if (name)
+            this.emit(key(name, { raw }));
+        return 3;
+    }
+    stepCsi() {
+        // Find the final byte: the first in the range @ to ~ after the parameters.
+        let i = 2;
+        while (i < this.carry.length) {
+            const code = this.carry.charCodeAt(i);
+            if (code >= 0x40 && code <= 0x7e)
+                break;
+            i++;
+        }
+        if (i >= this.carry.length)
+            return 0; // incomplete
+        const final = this.carry[i];
+        const body = this.carry.slice(2, i);
+        const raw = this.carry.slice(0, i + 1);
+        // Bracketed paste start.
+        if (body === '200' && final === '~') {
+            this.carry = this.carry.slice(i + 1);
+            this.pasting = true;
+            this.pasteBuffer = '';
+            return raw.length;
+        }
+        // SGR mouse: CSI < b ; x ; y M|m
+        if (body.startsWith('<') && (final === 'M' || final === 'm')) {
+            this.carry = this.carry.slice(i + 1);
+            const event = decodeSgrMouse(body.slice(1), final);
+            if (event)
+                this.emit(event);
+            return raw.length;
+        }
+        // Terminal focus in/out.
+        if (final === 'I' || final === 'O') {
+            this.carry = this.carry.slice(i + 1);
+            this.emit({ type: 'terminal-focus', focused: final === 'I' });
+            return raw.length;
+        }
+        this.carry = this.carry.slice(i + 1);
+        const params = body.split(';').map((p) => (p === '' ? undefined : Number.parseInt(p, 10)));
+        // Kitty keyboard: CSI codepoint ; modifiers u
+        if (final === 'u') {
+            const cp = params[0];
+            if (cp !== undefined) {
+                const mods = modifiers(params[1]);
+                const char = cp >= 0x20 ? String.fromCodePoint(cp) : undefined;
+                const named = CTRL_NAMES[cp];
+                this.emit(key(named ?? char ?? String(cp), { ...mods, char, raw }));
+            }
+            return raw.length;
+        }
+        if (final === '~') {
+            /*
+             * xterm's `modifyOtherKeys`: CSI 27 ; modifiers ; codepoint ~
+             *
+             * The *other* way a terminal can say `ctrl+enter`, and the one that was
+             * going straight in the bin: 27 is not in `CSI_NUMBERS`, so
+             * `CSI 27;5;13~` matched nothing, fell through every branch and the key
+             * did nothing at all - not "arrived as plain enter", nothing.
+             *
+             * It carries the same information as the kitty form with the parameters
+             * the other way round, so it decodes through the same rules. Terminals
+             * that will not do the kitty protocol often do this one, which makes it
+             * the difference between `ctrl+enter` existing and not.
+             */
+            if (params[0] === 27 && params[2] !== undefined) {
+                const cp = params[2];
+                const char = cp >= 0x20 ? String.fromCodePoint(cp) : undefined;
+                this.emit(key(CTRL_NAMES[cp] ?? char ?? String(cp), {
+                    ...modifiers(params[1]),
+                    char,
+                    raw,
+                }));
+                return raw.length;
+            }
+            const name = CSI_NUMBERS[params[0] ?? 0];
+            if (name)
+                this.emit(key(name, { ...modifiers(params[1]), raw }));
+            return raw.length;
+        }
+        const name = CSI_LETTERS[final];
+        if (name) {
+            if (final === 'Z') {
+                this.emit(key('tab', { shift: true, raw }));
+            }
+            else {
+                // CSI 1 ; mod A
+                this.emit(key(name, { ...modifiers(params[1]), raw }));
+            }
+        }
+        return raw.length;
+    }
+    /** Drop any half-read sequence. After releasing the terminal. */
+    reset() {
+        this.clearEscapeTimer();
+        this.carry = '';
+        this.pasting = false;
+        this.pasteBuffer = '';
+    }
+}
+function decodeSgrMouse(body, final) {
+    const parts = body.split(';').map((p) => Number.parseInt(p, 10));
+    if (parts.length < 3)
+        return null;
+    const [rawButton, col, row] = parts;
+    if (!Number.isFinite(rawButton) || !Number.isFinite(col) || !Number.isFinite(row))
+        return null;
+    const shift = (rawButton & 4) !== 0;
+    const alt = (rawButton & 8) !== 0;
+    const ctrl = (rawButton & 16) !== 0;
+    const motion = (rawButton & 32) !== 0;
+    const wheel = (rawButton & 64) !== 0;
+    const code = rawButton & 3;
+    const base = {
+        type: 'mouse',
+        x: col - 1,
+        y: row - 1,
+        ctrl, alt, shift,
+        handled: false,
+    };
+    if (wheel) {
+        return { ...base, action: 'wheel', button: 'none', wheel: code === 0 ? -1 : 1 };
+    }
+    const button = code === 0 ? 'left' : code === 1 ? 'middle' : code === 2 ? 'right' : 'none';
+    if (motion) {
+        return {
+            ...base,
+            action: button === 'none' ? 'move' : 'drag',
+            button: button,
+        };
+    }
+    return {
+        ...base,
+        action: final === 'M' ? 'down' : 'up',
+        button: button,
+    };
+}
+export function createDecoder(emit, options) {
+    return new InputDecoder(emit, options);
+}

package/dist/node.d.ts

@@ -0,0 +1,99 @@
+import type { AcquiredState, CapabilityOverrides, Disposable, InputEvent, Size, TerminalAdapter, TerminalCapabilities, TerminalSessionOptions } from '@textui/core';
+/**
+ * The Node TTY adapter.
+ *
+ * Ownership is the whole point of this file. `acquire` records exactly what it
+ * turned on and `release` undoes exactly that - so an application that owns
+ * the terminal gets a clean alternate screen, and one embedded in a host that
+ * already set raw mode does not tear the host's state down on the way out.
+ *
+ * A terminal left in raw mode with the cursor hidden is a broken shell, so
+ * release also runs on exit and on a fatal signal, not only on a tidy stop.
+ */
+/**
+ * What this adapter needs from a stream, rather than which stream it is.
+ *
+ * `process.stdin` and `process.stdout` satisfy these, so nothing changes for
+ * a caller - but the published types stop naming Node's stream interfaces,
+ * which come from a package this one does not depend on. It compiled here
+ * only because those types happened to be installed at the root; a consumer
+ * without them got `Cannot find namespace` out of a package that advertises
+ * no dependencies.
+ *
+ * Saying it structurally also makes the requirement legible - "something with
+ * `setRawMode` and `columns`" is a contract, where "Node's stream" is a shrug
+ * - and makes it true of the runtimes whose streams are not Node's. Bun and
+ * Deno satisfy these by shape rather than by luck.
+ */
+export interface TerminalInput {
+    isTTY?: boolean;
+    /** True while the terminal is delivering keys rather than lines. */
+    isRaw?: boolean;
+    setRawMode?(raw: boolean): void;
+    setEncoding(encoding: 'utf8'): void;
+    on(event: 'data', listener: (chunk: string) => void): void;
+    off(event: 'data', listener: (chunk: string) => void): void;
+    pause(): void;
+    resume(): void;
+}
+export interface TerminalOutput {
+    isTTY?: boolean;
+    columns?: number;
+    rows?: number;
+    write(data: string): void;
+    on(event: 'resize', listener: () => void): void;
+    off(event: 'resize', listener: () => void): void;
+}
+/** The three this adapter installs handlers for. */
+export type TerminalSignal = 'SIGINT' | 'SIGTERM' | 'SIGHUP';
+export interface NodeAdapterOptions {
+    stdin?: TerminalInput;
+    stdout?: TerminalOutput;
+    env?: Record<string, string | undefined>;
+    capabilities?: CapabilityOverrides;
+    /** Install exit and signal handlers that release the terminal. */
+    installExitHandlers?: boolean;
+    escapeTimeoutMs?: number;
+}
+export declare class NodeTerminalAdapter implements TerminalAdapter {
+    private options;
+    readonly id = "node";
+    private stdin;
+    private stdout;
+    private env;
+    private overrides;
+    private caps;
+    private state;
+    private decoder;
+    private inputListeners;
+    private resizeListeners;
+    private pending;
+    private onStdinData;
+    private handleResize;
+    private exitHandler;
+    private signalHandler;
+    constructor(options?: NodeAdapterOptions);
+    private detect;
+    get acquired(): AcquiredState | null;
+    size(): Size;
+    capabilities(): TerminalCapabilities;
+    setCapabilityOverrides(overrides: CapabilityOverrides): void;
+    environment(): Record<string, string>;
+    acquire(options: TerminalSessionOptions): AcquiredState;
+    /**
+     * Undo exactly what was acquired, in reverse. Anything this adapter did not
+     * turn on is left alone - that is what makes an embedded session safe.
+     */
+    release(): void;
+    write(data: string): void;
+    flush(): void;
+    onInput(fn: (event: InputEvent) => void): Disposable;
+    onResize(fn: (size: Size) => void): Disposable;
+    writeClipboard(text: string): void;
+    setTitle(title: string): void;
+    private installExitHandlers;
+    private removeExitHandlers;
+    dispose(): void;
+}
+export declare function createNodeTerminal(options?: NodeAdapterOptions): NodeTerminalAdapter;
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"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"}

package/dist/node.js

@@ -0,0 +1,233 @@
+import { toDisposable } from '@textui/core';
+import * as ansi from './ansi.js';
+import { applyOverrides, detectCapabilities, describeEnvironment } from './capabilities.js';
+import { createDecoder } from './input.js';
+const NOTHING_ACQUIRED = {
+    altScreen: false, mouse: false, wheel: false, focusEvents: false,
+    paste: false, cursorHidden: false, enhancedKeys: false, rawMode: false,
+    titleSet: false,
+};
+export class NodeTerminalAdapter {
+    options;
+    id = 'node';
+    stdin;
+    stdout;
+    env;
+    overrides;
+    caps;
+    state = null;
+    decoder = null;
+    inputListeners = new Set();
+    resizeListeners = new Set();
+    pending = [];
+    onStdinData = (chunk) => {
+        this.decoder?.feed(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+    };
+    handleResize = () => {
+        const size = this.size();
+        for (const fn of [...this.resizeListeners])
+            fn(size);
+    };
+    exitHandler = null;
+    signalHandler = null;
+    constructor(options = {}) {
+        this.options = options;
+        this.stdin = options.stdin ?? process.stdin;
+        this.stdout = options.stdout ?? process.stdout;
+        this.env = options.env ?? process.env;
+        this.overrides = options.capabilities ?? {};
+        this.caps = this.detect();
+    }
+    detect() {
+        return applyOverrides(detectCapabilities({
+            env: this.env,
+            isTTY: Boolean(this.stdout.isTTY),
+            columns: this.stdout.columns,
+            rows: this.stdout.rows,
+            platform: process.platform,
+        }), this.overrides);
+    }
+    get acquired() {
+        return this.state;
+    }
+    size() {
+        return {
+            width: this.stdout.columns ?? 80,
+            height: this.stdout.rows ?? 24,
+        };
+    }
+    capabilities() {
+        return this.caps;
+    }
+    setCapabilityOverrides(overrides) {
+        this.overrides = { ...this.overrides, ...overrides };
+        this.caps = this.detect();
+    }
+    environment() {
+        return describeEnvironment({
+            env: this.env,
+            isTTY: Boolean(this.stdout.isTTY),
+            columns: this.stdout.columns,
+            rows: this.stdout.rows,
+        });
+    }
+    acquire(options) {
+        if (this.state)
+            return this.state;
+        const caps = this.caps;
+        const managed = options.managed ?? true;
+        const state = { ...NOTHING_ACQUIRED };
+        const out = [];
+        if (this.stdin.isTTY && typeof this.stdin.setRawMode === 'function' && !this.stdin.isRaw) {
+            this.stdin.setRawMode(true);
+            state.rawMode = true;
+        }
+        if (managed && (options.altScreen ?? true) && caps.altScreen) {
+            out.push(ansi.altScreenEnter, ansi.eraseScreen, ansi.cursorHome);
+            state.altScreen = true;
+        }
+        if ((options.hideCursor ?? true) && caps.cursor) {
+            out.push(ansi.cursorHide);
+            state.cursorHidden = true;
+        }
+        if ((options.mouse ?? false) && caps.mouse) {
+            out.push((options.wheel ?? true) ? ansi.mouseOn : ansi.mouseButtonsOn);
+            state.mouse = true;
+            state.wheel = options.wheel ?? true;
+        }
+        if ((options.focusEvents ?? false) && caps.focusEvents) {
+            out.push(ansi.focusEventsOn);
+            state.focusEvents = true;
+        }
+        if ((options.paste ?? true) && caps.paste) {
+            out.push(ansi.bracketedPasteOn);
+            state.paste = true;
+        }
+        if ((options.enhancedKeys ?? false) && caps.kittyKeyboard) {
+            out.push(ansi.kittyKeyboardPush);
+            state.enhancedKeys = true;
+        }
+        if (options.title && caps.title) {
+            out.push(ansi.setTitle(options.title));
+            state.titleSet = true;
+        }
+        this.stdout.write(out.join(''));
+        this.decoder = createDecoder((event) => {
+            for (const fn of [...this.inputListeners])
+                fn(event);
+        }, { escapeTimeoutMs: this.options.escapeTimeoutMs });
+        this.stdin.setEncoding('utf8');
+        this.stdin.on('data', this.onStdinData);
+        this.stdin.resume();
+        this.stdout.on('resize', this.handleResize);
+        if (this.options.installExitHandlers ?? true)
+            this.installExitHandlers();
+        this.state = state;
+        return state;
+    }
+    /**
+     * Undo exactly what was acquired, in reverse. Anything this adapter did not
+     * turn on is left alone - that is what makes an embedded session safe.
+     */
+    release() {
+        const state = this.state;
+        if (!state)
+            return;
+        this.state = null;
+        const out = [];
+        if (state.enhancedKeys)
+            out.push(ansi.kittyKeyboardPop);
+        if (state.paste)
+            out.push(ansi.bracketedPasteOff);
+        if (state.focusEvents)
+            out.push(ansi.focusEventsOff);
+        if (state.mouse)
+            out.push(state.wheel ? ansi.mouseOff : ansi.mouseButtonsOff);
+        if (state.altScreen)
+            out.push(ansi.altScreenLeave);
+        if (state.cursorHidden)
+            out.push(ansi.cursorShow);
+        out.push(ansi.reset);
+        try {
+            this.stdout.write(out.join(''));
+        }
+        catch {
+            // The stream may already be closed during an abrupt exit.
+        }
+        this.stdin.off('data', this.onStdinData);
+        this.stdout.off('resize', this.handleResize);
+        this.decoder?.reset();
+        this.decoder = null;
+        if (state.rawMode && this.stdin.isTTY && typeof this.stdin.setRawMode === 'function') {
+            try {
+                this.stdin.setRawMode(false);
+            }
+            catch {
+                /* best effort */
+            }
+        }
+        this.stdin.pause();
+        this.removeExitHandlers();
+    }
+    write(data) {
+        if (data === '')
+            return;
+        this.pending.push(data);
+    }
+    flush() {
+        if (this.pending.length === 0)
+            return;
+        const data = this.pending.join('');
+        this.pending = [];
+        this.stdout.write(data);
+    }
+    onInput(fn) {
+        this.inputListeners.add(fn);
+        return toDisposable(() => this.inputListeners.delete(fn));
+    }
+    onResize(fn) {
+        this.resizeListeners.add(fn);
+        return toDisposable(() => this.resizeListeners.delete(fn));
+    }
+    writeClipboard(text) {
+        if (!this.caps.clipboard)
+            return;
+        this.stdout.write(ansi.clipboardWrite(text));
+    }
+    setTitle(title) {
+        if (!this.caps.title)
+            return;
+        this.stdout.write(ansi.setTitle(title));
+    }
+    installExitHandlers() {
+        this.exitHandler = () => this.release();
+        process.on('exit', this.exitHandler);
+        this.signalHandler = (signal) => {
+            this.release();
+            process.exit(signal === 'SIGINT' ? 130 : 143);
+        };
+        process.on('SIGINT', this.signalHandler);
+        process.on('SIGTERM', this.signalHandler);
+        process.on('SIGHUP', this.signalHandler);
+    }
+    removeExitHandlers() {
+        if (this.exitHandler) {
+            process.off('exit', this.exitHandler);
+            this.exitHandler = null;
+        }
+        if (this.signalHandler) {
+            process.off('SIGINT', this.signalHandler);
+            process.off('SIGTERM', this.signalHandler);
+            process.off('SIGHUP', this.signalHandler);
+            this.signalHandler = null;
+        }
+    }
+    dispose() {
+        this.release();
+        this.inputListeners.clear();
+        this.resizeListeners.clear();
+    }
+}
+export function createNodeTerminal(options) {
+    return new NodeTerminalAdapter(options);
+}