@textui/terminal 0.1.0

package/dist/svg.d.ts

@@ -0,0 +1,74 @@
+import type { CellBuffer, Color, ColorDepth } from '@textui/core';
+/**
+ * A frame, as a picture.
+ *
+ * `captureBuffer` writes a frame you can `cat`. This writes one you can put in
+ * a README, and the difference matters more than it sounds: an `.ans` file is
+ * only a screenshot on a terminal, so the place a terminal application most
+ * needs to show what it looks like - a repository page, a docs site, a pull
+ * request - is the one place it cannot.
+ *
+ * The output is one self-contained SVG with no external anything: no font file,
+ * no stylesheet, no script. That is what lets it survive GitHub, which serves
+ * markdown images from a sanitising proxy that fetches nothing on the page's
+ * behalf.
+ *
+ * It is also **text**, which is the part worth having. A committed SVG diffs:
+ * a change that moves a column or recolours a token shows up as a changed line
+ * in review, so a screenshot in the docs can be checked by CI rather than
+ * re-taken by hand and trusted.
+ */
+export interface SvgOptions {
+    /**
+     * Cell size in pixels. The defaults are close to a 13px monospace face at a
+     * normal line height, which is what makes the picture look like a terminal
+     * rather than like text that happens to be in a grid.
+     */
+    cellWidth?: number;
+    cellHeight?: number;
+    fontSize?: number;
+    /**
+     * The font stack. No web font by default and none recommended: a font that
+     * has to be fetched is a font that is missing exactly where this file is
+     * most useful, and a missing monospace font takes the column alignment with
+     * it.
+     */
+    fontFamily?: string;
+    /**
+     * Where the baseline sits inside the cell, as a fraction of its height.
+     *
+     * A number rather than `dominant-baseline`, which renderers disagree about
+     * enough that the text lands a pixel or two off between two viewers of the
+     * same file.
+     */
+    baseline?: number;
+    /** Space around the grid, in pixels. */
+    padding?: number;
+    /** Corner radius on the backdrop. Zero is a square edge. */
+    radius?: number;
+    /**
+     * What a cell left at the terminal's own colours becomes.
+     *
+     * A terminal has no answer for this - "default" means whatever the emulator
+     * is configured with - so a picture has to choose, and the honest choice is
+     * the caller's. These are what the theme would call `background` and `text`.
+     *
+     * Passing `default` here is the one thing that cannot work, and a theme can
+     * hand it over without meaning to: `mono` is *made* of `default`, so
+     * `theme.colors.canvas` and `theme.colors.text` are both it. Either one is
+     * replaced with the exporter's own, because a picture with no ink is a
+     * rectangle.
+     */
+    background?: Color;
+    foreground?: Color;
+    /**
+     * Reduce colour first, to show what a shallower terminal would have shown.
+     * Left off, nothing is reduced: an SVG has no colour limit of its own, so
+     * downsampling by default would be inventing a constraint.
+     */
+    colorDepth?: ColorDepth;
+    /** An accessible name, emitted as `<title>`. */
+    title?: string;
+}
+export declare function bufferToSvg(buffer: CellBuffer, options?: SvgOptions): string;
+//# sourceMappingURL=svg.d.ts.map

package/dist/svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../src/svg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAMlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;OAYG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;;OAIG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA0BD,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,UAAe,GAAG,MAAM,CAmFhF"}

package/dist/svg.js

@@ -0,0 +1,235 @@
+import { ATTR_BOLD, ATTR_DIM, ATTR_HIDDEN, ATTR_INVERSE, ATTR_ITALIC, ATTR_STRIKE, ATTR_UNDERLINE, COLOR_DEFAULT, downsample, mix, packColor, toHex, } from '@textui/core';
+const DEFAULTS = {
+    cellWidth: 8,
+    cellHeight: 17,
+    fontSize: 13,
+    fontFamily: "ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'DejaVu Sans Mono', monospace",
+    baseline: 0.78,
+    padding: 10,
+    radius: 6,
+    background: '#0d1117',
+    foreground: '#c9d1d9',
+};
+export function bufferToSvg(buffer, options = {}) {
+    const cw = options.cellWidth ?? DEFAULTS.cellWidth;
+    const ch = options.cellHeight ?? DEFAULTS.cellHeight;
+    const fontSize = options.fontSize ?? DEFAULTS.fontSize;
+    const fontFamily = options.fontFamily ?? DEFAULTS.fontFamily;
+    const baseline = options.baseline ?? DEFAULTS.baseline;
+    const pad = options.padding ?? DEFAULTS.padding;
+    const radius = options.radius ?? DEFAULTS.radius;
+    const depth = options.colorDepth;
+    const width = buffer.width * cw + pad * 2;
+    const height = buffer.height * ch + pad * 2;
+    // Packed, so `inverse` and `dim` are worked out in the same space as every
+    // other colour rather than as a special case per attribute. `Color` rather
+    // than a hex string because that is what a theme holds: `theme.colors.canvas`
+    // goes straight in.
+    const paperPacked = given(options.background, DEFAULTS.background);
+    const inkPacked = given(options.foreground, DEFAULTS.foreground);
+    const paper = toHex(paperPacked);
+    const reduce = (c) => (depth === undefined ? c : downsample(c, depth));
+    const out = [];
+    out.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" `
+        + `viewBox="0 0 ${width} ${height}" font-family="${escape(fontFamily)}" `
+        + `font-size="${fontSize}px">`);
+    if (options.title !== undefined)
+        out.push(`<title>${escape(options.title)}</title>`);
+    out.push(`<rect width="${width}" height="${height}"`
+        + `${radius > 0 ? ` rx="${radius}"` : ''} fill="${paper}"/>`);
+    for (let y = 0; y < buffer.height; y++) {
+        // Backgrounds first and for the whole row, because a glyph drawn over a
+        // rect emitted later would be painted out: SVG has no z-index, only
+        // document order.
+        for (const run of backgroundRuns(buffer, y, paperPacked, inkPacked, reduce)) {
+            out.push(`<rect x="${pad + run.x * cw}" y="${pad + y * ch}" `
+                + `width="${run.columns * cw}" height="${ch}" fill="${toHex(run.fg)}"/>`);
+        }
+    }
+    const textY = (y) => Math.round(pad + y * ch + ch * baseline);
+    for (let y = 0; y < buffer.height; y++) {
+        for (const run of glyphRuns(buffer, y, paperPacked, inkPacked, reduce)) {
+            const decoration = [
+                (run.attrs & ATTR_UNDERLINE) !== 0 ? 'underline' : '',
+                (run.attrs & ATTR_STRIKE) !== 0 ? 'line-through' : '',
+            ].filter(Boolean).join(' ');
+            out.push(`<text x="${pad + run.x * cw}" y="${textY(y)}" fill="${toHex(run.fg)}"`
+                + ((run.attrs & ATTR_BOLD) !== 0 ? ' font-weight="bold"' : '')
+                + ((run.attrs & ATTR_ITALIC) !== 0 ? ' font-style="italic"' : '')
+                + (decoration !== '' ? ` text-decoration="${decoration}"` : '')
+                // The run is told how wide it is, in columns, so the grid holds even
+                // where the reader's monospace font has a different advance width from
+                // the one `cellWidth` was picked for.
+                //
+                // Which of the two adjustments only matters when the font is already
+                // wrong - where the run's natural width is the right one, both are no
+                // ops - and then the two kinds of run want opposite things. Letters
+                // want `spacing`: looser tracking is readable and squashed letterforms
+                // are not. A bar or a border wants `spacingAndGlyphs`: spacing a run of
+                // blocks apart is how a solid bar comes out striped and a box's sides
+                // stop meeting its corners, and a block stretched to its cell is still
+                // a block.
+                + ` textLength="${run.columns * cw}"`
+                + ` lengthAdjust="${run.graphic ? 'spacingAndGlyphs' : 'spacing'}"`
+                // Leading spaces inside a run are part of the picture, and the default
+                // is to collapse them.
+                + ` xml:space="preserve">${escape(run.text)}</text>`);
+        }
+    }
+    out.push('</svg>');
+    return out.join('\n');
+}
+/**
+ * A colour the picture can actually use.
+ *
+ * `toHex` has nothing to return for `default` and returns black, so a `default`
+ * that reaches the file makes paper and ink the same colour and the whole
+ * frame disappears into the backdrop. That is not a colour the caller chose; it
+ * is the caller having no colour to give, which is what the fallback is for.
+ */
+function given(color, fallback) {
+    const packed = packColor(color ?? fallback);
+    return packed === COLOR_DEFAULT ? packColor(fallback) : packed;
+}
+/**
+ * The colours a cell actually paints with.
+ *
+ * `inverse` is resolved here rather than at either end: it swaps the pair, and
+ * a cell that inverts while leaving one side at the terminal default is
+ * swapping *that* default in - which is only knowable once both have been
+ * filled in. Doing it later would invert a colour against itself.
+ */
+function colorsOf(fg, bg, attrs, paper, ink) {
+    let front = fg === COLOR_DEFAULT ? ink : fg;
+    let back = bg === COLOR_DEFAULT ? paper : bg;
+    if ((attrs & ATTR_INVERSE) !== 0)
+        [front, back] = [back, front];
+    // Dim is a reduced intensity, which on a picture is a colour part of the way
+    // to the one behind it - there is no "half as bright" for an arbitrary hex.
+    if ((attrs & ATTR_DIM) !== 0)
+        front = mix(front, back, 0.5);
+    return { fg: front, bg: back };
+}
+/** Background rects for one row, coalesced, skipping the paper colour. */
+function backgroundRuns(buffer, y, paper, ink, reduce) {
+    const runs = [];
+    let open = null;
+    for (let x = 0; x < buffer.width; x++) {
+        const cell = buffer.get(x, y);
+        // A continuation cell has no colours of its own - it is the right half of
+        // the glyph before it, and that cell's run already covers this column.
+        if (cell?.continuation === true) {
+            if (open)
+                open.columns += 1;
+            continue;
+        }
+        // Reduced first, resolved after. A shallower terminal shrinks the palette
+        // it was *given*; a cell left at the terminal's own colour has nothing to
+        // shrink and still comes out as the emulator's. The other order asks
+        // `downsample` for the nearest palette entry to paper and ink, and at depth
+        // zero it hands back `default` again - which is how a picture ends up as
+        // one black rectangle.
+        const back = cell
+            ? colorsOf(reduce(packColor(cell.fg)), reduce(packColor(cell.bg)), cell.attrs, paper, ink).bg
+            : paper;
+        // Nothing to draw where the cell is the same colour as the backdrop, which
+        // is most of most screens.
+        if (back === paper) {
+            open = null;
+            continue;
+        }
+        if (open && open.fg === back && open.x + open.columns === x) {
+            open.columns += 1;
+            continue;
+        }
+        open = { x, columns: 1, text: '', fg: back, attrs: 0, graphic: false };
+        runs.push(open);
+    }
+    return runs;
+}
+/**
+ * Whether a cell is drawn with the drawing characters rather than with letters.
+ *
+ * The split is where a monospace font stops being certain to have the glyph.
+ * Below U+2000 is text - ASCII, Latin, the punctuation any font ships with -
+ * and above it is the box drawing, the block elements, the braille the charts
+ * are made of, the arrows and the geometric shapes. A font that lacks those
+ * substitutes another one for them, and a substitute is under no obligation to
+ * use the same advance width, which is the whole reason a run must not span
+ * both: `textLength` corrects a run as a unit, so one wrong-width glyph in a
+ * run of letters pushes every letter after it off the grid.
+ *
+ * The `mono` theme is where this shows, because it is where it is worst. Every
+ * other theme colours its bars and its borders differently from its text, and
+ * a colour change already ends a run - so the split was there by accident.
+ * Give a whole screen one colour and each row coalesces into a single run of
+ * letters and blocks together, corrected as one.
+ */
+function isGraphic(char) {
+    return (char.codePointAt(0) ?? 0x20) >= 0x2000;
+}
+/** Text runs for one row, coalesced by colour, attributes, and kind. */
+function glyphRuns(buffer, y, paper, ink, reduce) {
+    const runs = [];
+    let open = null;
+    for (let x = 0; x < buffer.width; x++) {
+        const cell = buffer.get(x, y);
+        if (cell?.continuation === true) {
+            if (open)
+                open.columns += 1;
+            continue;
+        }
+        if (!cell) {
+            open = null;
+            continue;
+        }
+        const { fg: front } = colorsOf(reduce(packColor(cell.fg)), reduce(packColor(cell.bg)), cell.attrs, paper, ink);
+        // `hidden` is a cell whose glyph is not drawn - a masked field. Its
+        // background still is, which is why this is here and not in `colorsOf`.
+        const char = (cell.attrs & ATTR_HIDDEN) !== 0 ? ' ' : cell.char;
+        const graphic = isGraphic(char);
+        // Only the attributes that change how a glyph is drawn. `blink` is not one
+        // of them: a still frame cannot blink, and an SMIL animation would make
+        // the file un-diffable for a flourish nobody asked for.
+        const attrs = cell.attrs & (ATTR_BOLD | ATTR_ITALIC | ATTR_UNDERLINE | ATTR_STRIKE);
+        if (open && open.fg === front && open.attrs === attrs && open.graphic === graphic
+            && open.x + open.columns === x) {
+            open.text += char;
+            open.columns += 1;
+            continue;
+        }
+        open = { x, columns: 1, text: char, fg: front, attrs, graphic };
+        runs.push(open);
+    }
+    // The row's own trailing blanks. They coalesce onto the last run because
+    // they share its colour, and then every row in the file carries spaces out
+    // to the right edge - bytes for nothing, and a `textLength` claiming columns
+    // the text does not occupy.
+    //
+    // Only the tail, and only where nothing is drawn through it: a blank in the
+    // middle of a row is between two things, and an underlined one is a line.
+    const last = runs[runs.length - 1];
+    if (last && (last.attrs & (ATTR_UNDERLINE | ATTR_STRIKE)) === 0) {
+        const trimmed = last.text.replace(/\s+$/, '');
+        last.columns -= last.text.length - trimmed.length;
+        last.text = trimmed;
+    }
+    // A run of blank cells paints nothing - unless it was underlined or struck
+    // through, where the line is the whole point.
+    return runs.filter((run) => run.text.trim() !== ''
+        || (run.attrs & (ATTR_UNDERLINE | ATTR_STRIKE)) !== 0);
+}
+/**
+ * The five XML entities, and no more than that.
+ *
+ * A frame can hold anything somebody typed, and an unescaped `<` in a filename
+ * is the difference between a picture and a file no parser will open.
+ */
+function escape(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}

package/dist/virtual.d.ts

@@ -0,0 +1,65 @@
+import type { AcquiredState, CapabilityOverrides, Disposable, InputEvent, Size, TerminalAdapter, TerminalCapabilities, TerminalSessionOptions } from '@textui/core';
+/**
+ * A terminal with no terminal behind it.
+ *
+ * The same adapter serves three cases that turn out to be one case: the test
+ * harness, an application embedded in a host that owns the real tty, and a
+ * browser-hosted terminal such as xterm.js where output goes to a callback
+ * rather than a file descriptor.
+ *
+ * Because it is embedded by default, `acquire` records nothing it did not do -
+ * and it does nothing to anyone's terminal.
+ */
+export interface VirtualAdapterOptions {
+    width?: number;
+    height?: number;
+    capabilities?: CapabilityOverrides;
+    /** Where encoded output goes. Omit to only accumulate it. */
+    onWrite?(data: string): void;
+    /** Keep every chunk written, for assertions. */
+    record?: boolean;
+    /** True when this adapter owns terminal setup. Defaults to false. */
+    managed?: boolean;
+}
+export declare class VirtualTerminalAdapter implements TerminalAdapter {
+    private options;
+    readonly id = "virtual";
+    private caps;
+    private state;
+    private currentSize;
+    private pending;
+    private written;
+    private inputListeners;
+    private resizeListeners;
+    private decoder;
+    private title;
+    private clipboard;
+    constructor(options?: VirtualAdapterOptions);
+    get acquired(): AcquiredState | null;
+    size(): Size;
+    capabilities(): TerminalCapabilities;
+    setCapabilityOverrides(overrides: CapabilityOverrides): void;
+    acquire(options: TerminalSessionOptions): AcquiredState;
+    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;
+    /** Feed raw bytes, exactly as a terminal would deliver them. */
+    feed(data: string): void;
+    /** Deliver an already-decoded event. */
+    send(event: InputEvent): void;
+    resize(width: number, height: number): void;
+    /** Everything written since the last `clearOutput`. */
+    output(): string;
+    chunks(): string[];
+    clearOutput(): void;
+    currentTitle(): string | null;
+    clipboardContents(): string | null;
+    private dispatch;
+    dispose(): void;
+}
+export declare function createVirtualTerminal(options?: VirtualAdapterOptions): VirtualTerminalAdapter;
+//# sourceMappingURL=virtual.d.ts.map

package/dist/virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.d.ts","sourceRoot":"","sources":["../src/virtual.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EAAE,mBAAmB,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,EAChE,eAAe,EAAE,oBAAoB,EAAE,sBAAsB,EAC9D,MAAM,cAAc,CAAC;AAItB;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,6DAA6D;IAC7D,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gDAAgD;IAChD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAQD,qBAAa,sBAAuB,YAAW,eAAe;IAchD,OAAO,CAAC,OAAO;IAb3B,QAAQ,CAAC,EAAE,aAAa;IAExB,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,WAAW,CAAO;IAC1B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,cAAc,CAA0C;IAChE,OAAO,CAAC,eAAe,CAAmC;IAC1D,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,SAAS,CAAuB;gBAEpB,OAAO,GAAE,qBAA0B;IASvD,IAAI,QAAQ,IAAI,aAAa,GAAG,IAAI,CAEnC;IAED,IAAI,IAAI,IAAI;IAIZ,YAAY,IAAI,oBAAoB;IAIpC,sBAAsB,CAAC,SAAS,EAAE,mBAAmB,GAAG,IAAI;IAI5D,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,aAAa;IAgBvD,OAAO,IAAI,IAAI;IAKf,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKzB,KAAK,IAAI,IAAI;IAQb,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,UAAU;IAKpD,QAAQ,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,GAAG,UAAU;IAK9C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIlC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM7B,gEAAgE;IAChE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIxB,wCAAwC;IACxC,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAI7B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAM3C,uDAAuD;IACvD,MAAM,IAAI,MAAM;IAIhB,MAAM,IAAI,MAAM,EAAE;IAIlB,WAAW,IAAI,IAAI;IAInB,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B,iBAAiB,IAAI,MAAM,GAAG,IAAI;IAIlC,OAAO,CAAC,QAAQ;IAQhB,OAAO,IAAI,IAAI;CAKhB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,sBAAsB,CAE7F"}

package/dist/virtual.js

@@ -0,0 +1,137 @@
+import { FULL_CAPABILITIES, toDisposable } from '@textui/core';
+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 VirtualTerminalAdapter {
+    options;
+    id = 'virtual';
+    caps;
+    state = null;
+    currentSize;
+    pending = [];
+    written = [];
+    inputListeners = new Set();
+    resizeListeners = new Set();
+    decoder;
+    title = null;
+    clipboard = null;
+    constructor(options = {}) {
+        this.options = options;
+        this.currentSize = {
+            width: options.width ?? 80,
+            height: options.height ?? 24,
+        };
+        this.caps = { ...FULL_CAPABILITIES, ...options.capabilities };
+        this.decoder = createDecoder((event) => this.dispatch(event), { escapeTimeoutMs: 0 });
+    }
+    get acquired() {
+        return this.state;
+    }
+    size() {
+        return this.currentSize;
+    }
+    capabilities() {
+        return this.caps;
+    }
+    setCapabilityOverrides(overrides) {
+        this.caps = { ...this.caps, ...overrides };
+    }
+    acquire(options) {
+        const managed = options.managed ?? this.options.managed ?? false;
+        this.state = managed
+            ? {
+                ...NOTHING_ACQUIRED,
+                altScreen: (options.altScreen ?? true) && this.caps.altScreen,
+                mouse: (options.mouse ?? false) && this.caps.mouse,
+                wheel: (options.wheel ?? true) && this.caps.wheel,
+                focusEvents: (options.focusEvents ?? false) && this.caps.focusEvents,
+                paste: (options.paste ?? true) && this.caps.paste,
+                cursorHidden: (options.hideCursor ?? true) && this.caps.cursor,
+            }
+            : { ...NOTHING_ACQUIRED };
+        return this.state;
+    }
+    release() {
+        this.state = null;
+        this.decoder.reset();
+    }
+    write(data) {
+        if (data === '')
+            return;
+        this.pending.push(data);
+    }
+    flush() {
+        if (this.pending.length === 0)
+            return;
+        const data = this.pending.join('');
+        this.pending = [];
+        if (this.options.record !== false)
+            this.written.push(data);
+        this.options.onWrite?.(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) {
+        this.clipboard = text;
+    }
+    setTitle(title) {
+        this.title = title;
+    }
+    // ----------------------------------------------------------- test surface
+    /** Feed raw bytes, exactly as a terminal would deliver them. */
+    feed(data) {
+        this.decoder.feed(data);
+    }
+    /** Deliver an already-decoded event. */
+    send(event) {
+        this.dispatch(event);
+    }
+    resize(width, height) {
+        if (width === this.currentSize.width && height === this.currentSize.height)
+            return;
+        this.currentSize = { width, height };
+        for (const fn of [...this.resizeListeners])
+            fn(this.currentSize);
+    }
+    /** Everything written since the last `clearOutput`. */
+    output() {
+        return this.written.join('');
+    }
+    chunks() {
+        return [...this.written];
+    }
+    clearOutput() {
+        this.written = [];
+    }
+    currentTitle() {
+        return this.title;
+    }
+    clipboardContents() {
+        return this.clipboard;
+    }
+    dispatch(event) {
+        if (event.type === 'resize') {
+            this.resize(event.width, event.height);
+            return;
+        }
+        for (const fn of [...this.inputListeners])
+            fn(event);
+    }
+    dispose() {
+        this.release();
+        this.inputListeners.clear();
+        this.resizeListeners.clear();
+    }
+}
+export function createVirtualTerminal(options) {
+    return new VirtualTerminalAdapter(options);
+}

package/dist/writer.d.ts

@@ -0,0 +1,19 @@
+import type { Frame } from '@textui/core';
+import type { TerminalCapabilities } from '@textui/core';
+export declare function fgSequence(color: number, depth: TerminalCapabilities['colorDepth']): string;
+export declare function bgSequence(color: number, depth: TerminalCapabilities['colorDepth']): string;
+export declare const ATTR_ON: [number, number][];
+export declare class Writer {
+    private capabilities;
+    private state;
+    constructor(capabilities: TerminalCapabilities);
+    setCapabilities(capabilities: TerminalCapabilities): void;
+    /** Forget what we believe the terminal's state to be. After a resize. */
+    invalidate(): void;
+    /** Encode a frame. Returns an empty string when nothing changed. */
+    write(frame: Frame): string;
+    private encodeRun;
+    private encodeStyle;
+}
+export declare function createWriter(capabilities: TerminalCapabilities): Writer;
+//# sourceMappingURL=writer.d.ts.map

package/dist/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAO,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AA8BzD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,CAAC,YAAY,CAAC,GAAG,MAAM,CAU3F;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,CAAC,YAAY,CAAC,GAAG,MAAM,CAU3F;AAED,eAAO,MAAM,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EASrC,CAAC;AAMF,qBAAa,MAAM;IAGL,OAAO,CAAC,YAAY;IAFhC,OAAO,CAAC,KAAK,CAAgB;gBAET,YAAY,EAAE,oBAAoB;IAEtD,eAAe,CAAC,YAAY,EAAE,oBAAoB,GAAG,IAAI;IAKzD,yEAAyE;IACzE,UAAU,IAAI,IAAI;IAIlB,oEAAoE;IACpE,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IA8B3B,OAAO,CAAC,SAAS;IA0BjB,OAAO,CAAC,WAAW;CA6CpB;AAYD,wBAAgB,YAAY,CAAC,YAAY,EAAE,oBAAoB,GAAG,MAAM,CAEvE"}