@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/src/foundation/pi-tui-runtime-adapter/adapter.d.ts

@@ -1,39 +0,0 @@
-import type { PiTuiComponentPort, PiTuiInputListener, PiTuiOverlayHandle, PiTuiOverlayOptions, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiStopOptions, PiTuiViewport } from "./contracts.js";
-export type PiTuiRuntimeErrorStage = "construction" | "start" | "input-drain" | "restoration";
-export declare class PiTuiRuntimeError extends Error {
-    readonly stage: PiTuiRuntimeErrorStage;
-    constructor(stage: PiTuiRuntimeErrorStage, cause: unknown);
-}
-export declare class PiTuiRuntimeAdapter {
-    #private;
-    constructor(options: PiTuiRuntimeAdapterOptions);
-    get state(): PiTuiRuntimeState;
-    get active(): boolean;
-    get mode(): "regular" | "fullscreen";
-    get fullRedraws(): number;
-    viewport(): PiTuiViewport;
-    scrollState(id?: string): PiTuiScrollState;
-    scrollBy(lines: number, id?: string): void;
-    scrollToTop(id?: string): void;
-    scrollToBottom(id?: string): void;
-    start(): void;
-    setFocus(component: PiTuiComponentPort | null): void;
-    showOverlay(component: PiTuiComponentPort, options?: PiTuiOverlayOptions): PiTuiOverlayHandle;
-    hasOverlay(): boolean;
-    /**
-     * Writes a terminal control sequence. Used to enable and disable mouse
-     * reporting while an A1-owned application is presented, and for nothing else:
-     * the transparent and pinned paths never call it.
-     */
-    writeControl(data: string): void;
-    addInputListener(listener: PiTuiInputListener): () => void;
-    switchMode(mode: "regular" | "fullscreen"): boolean;
-    setHardwareCursor(enabled: boolean): void;
-    getHardwareCursor(): boolean;
-    setTitle(title: string): void;
-    invalidate(): void;
-    requestRender(force?: boolean): void;
-    renderNow(force?: boolean): void;
-    stop(options?: PiTuiStopOptions): Promise<void>;
-    dispose(options?: PiTuiStopOptions): Promise<void>;
-}

package/dist/src/foundation/pi-tui-runtime-adapter/adapter.js

@@ -1,493 +0,0 @@
-import { HStack, ProcessTerminal, ScrollView, TuiAltScreen, TuiMainScreen, VStack, visibleWidth, } from "#pi-tui";
-export class PiTuiRuntimeError extends Error {
-    stage;
-    constructor(stage, cause) {
-        super(`Pi TUI runtime failed during ${stage}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
-        this.stage = stage;
-        this.name = "PiTuiRuntimeError";
-    }
-}
-class ComponentBridge {
-    port;
-    #focused = false;
-    constructor(port) {
-        this.port = port;
-    }
-    get focused() {
-        return this.#focused;
-    }
-    set focused(value) {
-        this.#focused = value;
-        this.port.setFocused?.(value);
-    }
-    get wantsKeyRelease() {
-        return this.port.wantsKeyRelease ?? false;
-    }
-    render(width) {
-        const lines = [...this.port.render(width)];
-        const overflow = lines.findIndex(line => visibleWidth(line) > width);
-        if (overflow >= 0) {
-            throw new RangeError(`Pi TUI component row ${overflow} exceeds available width ${width}`);
-        }
-        return lines;
-    }
-    handleInput(data) {
-        this.port.handleInput?.(data);
-    }
-    invalidate() {
-        this.port.invalidate();
-    }
-}
-class OverlayHandleBridge {
-    handle;
-    bridgeFor;
-    dispose;
-    #disposed = false;
-    constructor(handle, bridgeFor, dispose) {
-        this.handle = handle;
-        this.bridgeFor = bridgeFor;
-        this.dispose = dispose;
-    }
-    hide() {
-        if (this.#disposed)
-            return;
-        this.handle.hide();
-        this.#disposed = true;
-        this.dispose();
-    }
-    setHidden(hidden) {
-        if (!this.#disposed)
-            this.handle.setHidden(hidden);
-    }
-    isHidden() {
-        return this.#disposed || this.handle.isHidden();
-    }
-    focus() {
-        if (!this.#disposed)
-            this.handle.focus();
-    }
-    unfocus(options) {
-        if (this.#disposed)
-            return;
-        if (options === undefined) {
-            this.handle.unfocus();
-            return;
-        }
-        this.handle.unfocus({ target: this.bridgeFor(options.target) });
-    }
-    isFocused() {
-        return !this.#disposed && this.handle.isFocused();
-    }
-}
-export class PiTuiRuntimeAdapter {
-    #terminal;
-    #tui;
-    #root;
-    #layoutRoot;
-    #tuiOptions;
-    #logDirectory;
-    #rootBridge;
-    #bridges = new WeakMap();
-    #mountedComponents = new Set();
-    #scrollViews = new Map();
-    #overlayDisposers = new Set();
-    #inputListeners = new Map();
-    #state = "idle";
-    #stopPromise;
-    #rootDisposed = false;
-    constructor(options) {
-        this.#root = options.root;
-        this.#terminal = options.terminal ?? new ProcessTerminal();
-        this.#layoutRoot = options.layoutRoot;
-        this.#logDirectory = options.logDirectory;
-        this.#rootBridge = new ComponentBridge(options.root);
-        this.#bridges.set(options.root, this.#rootBridge);
-        this.#mountedComponents.add(options.root);
-        try {
-            const tuiOptions = {};
-            if (options.wheelScrollLines !== undefined)
-                tuiOptions.wheelScrollLines = options.wheelScrollLines;
-            if (options.mouse !== undefined)
-                tuiOptions.mouse = options.mouse;
-            if (options.openUrl !== undefined)
-                tuiOptions.openUrl = options.openUrl;
-            if (options.onRightClickPaste !== undefined)
-                tuiOptions.onRightClickPaste = options.onRightClickPaste;
-            this.#tuiOptions = tuiOptions;
-            this.#tui = this.#createTui(options.mode ?? "regular", options.hardwareCursor ?? false);
-            this.#mountTui(this.#tui);
-        }
-        catch (error) {
-            this.#state = "failed";
-            throw new PiTuiRuntimeError("construction", error);
-        }
-    }
-    get state() {
-        return this.#state;
-    }
-    get active() {
-        return this.#state === "running";
-    }
-    get mode() {
-        return this.#tui.mode;
-    }
-    get fullRedraws() {
-        return this.#tui.fullRedraws;
-    }
-    viewport() {
-        return {
-            columns: Math.max(1, this.#terminal.columns),
-            rows: Math.max(1, this.#terminal.rows),
-        };
-    }
-    scrollState(id) {
-        if (id === undefined) {
-            if (!(this.#tui instanceof TuiAltScreen)) {
-                throw new Error("Pi TUI application scrolling is available only in fullscreen mode");
-            }
-            return {
-                scrollTop: this.#tui.viewportTop,
-                viewportHeight: this.viewport().rows,
-                followingEnd: this.#tui.isFollowingOutput,
-                scrollbarVisible: false,
-            };
-        }
-        const scrollView = this.#requireScrollView(id);
-        return {
-            scrollTop: scrollView.scrollTop,
-            viewportHeight: scrollView.viewportHeight,
-            followingEnd: scrollView.isFollowingEnd,
-            scrollbarVisible: scrollView.isScrollbarVisible,
-        };
-    }
-    scrollBy(lines, id) {
-        this.#assertRunning("scroll");
-        if (id === undefined)
-            this.#requireFullscreen().scrollBy(lines);
-        else {
-            this.#requireScrollView(id).scrollBy(lines);
-            this.#tui.requestRender();
-        }
-    }
-    scrollToTop(id) {
-        this.#assertRunning("scroll");
-        if (id === undefined)
-            this.#requireFullscreen().scrollToTop();
-        else {
-            this.#requireScrollView(id).scrollToStart();
-            this.#tui.requestRender();
-        }
-    }
-    scrollToBottom(id) {
-        this.#assertRunning("scroll");
-        if (id === undefined)
-            this.#requireFullscreen().scrollToBottom();
-        else {
-            this.#requireScrollView(id).scrollToEnd();
-            this.#tui.requestRender();
-        }
-    }
-    start() {
-        if (this.#state === "running")
-            return;
-        if (this.#state !== "idle")
-            throw new PiTuiRuntimeError("start", new Error(`runtime cannot start from ${this.#state}`));
-        try {
-            this.#tui.setFocus(this.#rootBridge);
-            this.#tui.start();
-            this.#state = "running";
-        }
-        catch (error) {
-            this.#state = "failed";
-            this.#restoreAfterFailedStart();
-            this.#disposeRoot();
-            throw new PiTuiRuntimeError("start", error);
-        }
-    }
-    setFocus(component) {
-        this.#assertRunning("focus");
-        this.#tui.setFocus(this.#bridgeFor(component));
-    }
-    showOverlay(component, options) {
-        this.#assertRunning("overlay");
-        if (this.#bridges.has(component))
-            throw new TypeError("Pi TUI component is already mounted");
-        const bridge = new ComponentBridge(component);
-        this.#bridges.set(component, bridge);
-        let hidden = false;
-        const dispose = () => {
-            if (hidden)
-                return;
-            hidden = true;
-            this.#overlayDisposers.delete(dispose);
-            this.#bridges.delete(component);
-            component.dispose?.();
-        };
-        this.#overlayDisposers.add(dispose);
-        const handle = this.#tui.showOverlay(bridge, toOverlayOptions(options));
-        return new OverlayHandleBridge(handle, target => this.#bridgeFor(target), dispose);
-    }
-    hasOverlay() {
-        return this.#tui.hasOverlay();
-    }
-    /**
-     * Writes a terminal control sequence. Used to enable and disable mouse
-     * reporting while an A1-owned application is presented, and for nothing else:
-     * the transparent and pinned paths never call it.
-     */
-    writeControl(data) {
-        this.#assertRunning("control sequence");
-        this.#terminal.write(data);
-    }
-    addInputListener(listener) {
-        this.#assertRunning("input listener");
-        if (this.#inputListeners.has(listener))
-            throw new TypeError("Pi TUI input listener is already registered");
-        this.#inputListeners.set(listener, this.#tui.addInputListener(data => listener(data)));
-        return () => {
-            this.#inputListeners.get(listener)?.();
-            this.#inputListeners.delete(listener);
-        };
-    }
-    switchMode(mode) {
-        this.#assertRunning("mode switch");
-        if (mode === this.#tui.mode)
-            return true;
-        if (this.#tui.hasOverlay())
-            return false;
-        const previous = this.#tui;
-        const hardwareCursor = previous.getShowHardwareCursor();
-        const clearOnShrink = previous.getClearOnShrink();
-        try {
-            for (const remove of this.#inputListeners.values())
-                remove();
-            previous.stop({ preserveScreen: true });
-            previous.setFocus(null);
-            previous.clear();
-            if (previous instanceof TuiAltScreen)
-                previous.setLayoutRoot(undefined);
-            this.#scrollViews.clear();
-            const next = this.#createTui(mode, hardwareCursor);
-            next.setClearOnShrink(clearOnShrink);
-            this.#mountTui(next);
-            this.#tui = next;
-            for (const listener of this.#inputListeners.keys()) {
-                this.#inputListeners.set(listener, next.addInputListener(data => listener(data)));
-            }
-            next.setFocus(this.#rootBridge);
-            next.start();
-            return true;
-        }
-        catch (error) {
-            this.#state = "failed";
-            this.#bestEffortTerminalRestore();
-            throw new PiTuiRuntimeError("construction", error);
-        }
-    }
-    setHardwareCursor(enabled) {
-        this.#tui.setShowHardwareCursor(enabled);
-        if (this.active)
-            this.#tui.requestRender();
-    }
-    getHardwareCursor() {
-        return this.#tui.getShowHardwareCursor();
-    }
-    setTitle(title) {
-        this.#terminal.setTitle(title);
-    }
-    invalidate() {
-        this.#tui.invalidate();
-        if (this.active)
-            this.#tui.requestRender();
-    }
-    requestRender(force = false) {
-        if (this.active)
-            this.#tui.requestRender(force);
-    }
-    renderNow(force = false) {
-        this.#assertRunning("render");
-        this.#tui.renderNow(force);
-    }
-    stop(options = {}) {
-        if (this.#stopPromise)
-            return this.#stopPromise;
-        if (this.#state === "idle") {
-            this.#state = "stopped";
-            this.#disposeRoot();
-            return Promise.resolve();
-        }
-        if (this.#state === "stopped")
-            return Promise.resolve();
-        this.#stopPromise = this.#stop(options);
-        return this.#stopPromise;
-    }
-    async dispose(options = {}) {
-        await this.stop(options);
-    }
-    async #stop(options) {
-        this.#state = "stopping";
-        let failure;
-        if (options.drainInput !== false) {
-            try {
-                await this.#terminal.drainInput(options.drainMaxMs, options.drainIdleMs);
-            }
-            catch (error) {
-                failure = new PiTuiRuntimeError("input-drain", error);
-            }
-        }
-        try {
-            const stopOptions = options.preserveScreen === undefined ? undefined : { preserveScreen: options.preserveScreen };
-            this.#tui.stop(stopOptions);
-        }
-        catch (error) {
-            failure ??= new PiTuiRuntimeError("restoration", error);
-            this.#bestEffortTerminalRestore();
-        }
-        finally {
-            this.#disposeComponents();
-        }
-        this.#state = failure === undefined ? "stopped" : "failed";
-        if (failure)
-            throw failure;
-    }
-    #createTui(mode, hardwareCursor) {
-        return mode === "fullscreen"
-            ? new TuiAltScreen(this.#terminal, hardwareCursor, this.#logDirectory, this.#tuiOptions)
-            : new TuiMainScreen(this.#terminal, hardwareCursor, this.#logDirectory);
-    }
-    #mountTui(tui) {
-        tui.addChild(this.#rootBridge);
-        if (tui instanceof TuiAltScreen && this.#layoutRoot !== undefined) {
-            tui.setLayoutRoot(this.#buildLayout(this.#layoutRoot));
-        }
-    }
-    #bridgeFor(component) {
-        if (component === null)
-            return null;
-        const bridge = this.#bridges.get(component);
-        if (!bridge)
-            throw new TypeError("Pi TUI focus target is not mounted");
-        return bridge;
-    }
-    #mount(component) {
-        const existing = this.#bridges.get(component);
-        if (existing)
-            return existing;
-        const bridge = new ComponentBridge(component);
-        this.#bridges.set(component, bridge);
-        this.#mountedComponents.add(component);
-        return bridge;
-    }
-    #buildLayout(node) {
-        if (node.type === "component")
-            return this.#mount(node.component);
-        if (node.type === "scroll") {
-            if (this.#scrollViews.has(node.id))
-                throw new TypeError(`duplicate Pi TUI scroll layout id: ${node.id}`);
-            const options = {
-                ...(node.follow === undefined ? {} : { follow: node.follow }),
-                ...(node.primary === undefined ? {} : { primary: node.primary }),
-                ...(node.overscroll === undefined ? {} : { overscroll: node.overscroll }),
-                ...(node.scrollbar === undefined ? {} : { scrollbar: node.scrollbar }),
-                ...(node.scrollbarStyle === undefined ? {} : { scrollbarStyle: node.scrollbarStyle }),
-                ...(node.scrollbarHideDelayMs === undefined ? {} : { scrollbarHideDelayMs: node.scrollbarHideDelayMs }),
-            };
-            const scrollView = new ScrollView(this.#buildLayout(node.child), options);
-            this.#scrollViews.set(node.id, scrollView);
-            return scrollView;
-        }
-        const children = node.children.map(entry => ({
-            component: this.#buildLayout(entry.node),
-            ...(entry.basis === undefined ? {} : { basis: entry.basis }),
-            ...(entry.grow === undefined ? {} : { grow: entry.grow }),
-            ...(entry.shrink === undefined ? {} : { shrink: entry.shrink }),
-            ...(entry.minSize === undefined ? {} : { minSize: entry.minSize }),
-            ...(entry.maxSize === undefined ? {} : { maxSize: entry.maxSize }),
-            ...(entry.visible === undefined ? {} : { visible: (viewport) => entry.visible?.({ columns: viewport.width, rows: viewport.height }) ?? true }),
-        }));
-        const options = {
-            ...(node.gap === undefined ? {} : { gap: node.gap }),
-            ...(node.align === undefined ? {} : { align: node.align }),
-        };
-        return node.direction === "vertical" ? new VStack(children, options) : new HStack(children, options);
-    }
-    #requireFullscreen() {
-        if (!(this.#tui instanceof TuiAltScreen)) {
-            throw new Error("Pi TUI application scrolling is available only in fullscreen mode");
-        }
-        return this.#tui;
-    }
-    #requireScrollView(id) {
-        this.#requireFullscreen();
-        const scrollView = this.#scrollViews.get(id);
-        if (!scrollView)
-            throw new TypeError(`unknown Pi TUI scroll layout id: ${id}`);
-        return scrollView;
-    }
-    #assertRunning(operation) {
-        if (!this.active)
-            throw new Error(`Pi TUI ${operation} requires a running runtime`);
-    }
-    #restoreAfterFailedStart() {
-        try {
-            this.#tui.stop();
-        }
-        catch {
-            this.#bestEffortTerminalRestore();
-        }
-    }
-    #bestEffortTerminalRestore() {
-        try {
-            this.#terminal.showCursor();
-        }
-        catch { }
-        try {
-            this.#terminal.stop();
-        }
-        catch { }
-    }
-    #disposeRoot() {
-        if (this.#rootDisposed)
-            return;
-        this.#rootDisposed = true;
-        for (const component of this.#mountedComponents)
-            component.dispose?.();
-        this.#mountedComponents.clear();
-    }
-    #disposeComponents() {
-        for (const remove of this.#inputListeners.values())
-            remove();
-        this.#inputListeners.clear();
-        for (const dispose of [...this.#overlayDisposers])
-            dispose();
-        this.#disposeRoot();
-    }
-}
-function toOverlayOptions(options) {
-    if (options === undefined)
-        return undefined;
-    const mapped = {};
-    if (options.width !== undefined)
-        mapped.width = options.width;
-    if (options.minWidth !== undefined)
-        mapped.minWidth = options.minWidth;
-    if (options.maxHeight !== undefined)
-        mapped.maxHeight = options.maxHeight;
-    if (options.anchor !== undefined)
-        mapped.anchor = options.anchor;
-    if (options.offsetX !== undefined)
-        mapped.offsetX = options.offsetX;
-    if (options.offsetY !== undefined)
-        mapped.offsetY = options.offsetY;
-    if (options.row !== undefined)
-        mapped.row = options.row;
-    if (options.col !== undefined)
-        mapped.col = options.col;
-    if (options.margin !== undefined)
-        mapped.margin = options.margin;
-    if (options.visible !== undefined)
-        mapped.visible = options.visible;
-    if (options.nonCapturing !== undefined)
-        mapped.nonCapturing = options.nonCapturing;
-    return mapped;
-}

package/dist/src/foundation/pi-tui-runtime-adapter/conformance.d.ts

@@ -1,18 +0,0 @@
-export interface PiTuiRuntimeConformanceOptions {
-    readonly packageVersion: string;
-}
-export interface PiTuiRuntimeConformanceReport {
-    readonly packageName: "@earendil-works/pi-tui";
-    readonly packageVersion: string;
-    readonly mode: "regular" | "fullscreen";
-    readonly constructedModes: readonly ("regular" | "fullscreen")[];
-    readonly lifecycleRestored: boolean;
-    readonly inputRouted: boolean;
-    readonly overlayRouted: boolean;
-    readonly focusRouted: boolean;
-    readonly widthBounded: boolean;
-    readonly differentialRendering: boolean;
-    readonly resizeRedraw: boolean;
-    readonly terminalNativeSelection: boolean;
-}
-export declare function runPiTuiRuntimeConformance(options: PiTuiRuntimeConformanceOptions): Promise<PiTuiRuntimeConformanceReport>;

package/dist/src/foundation/pi-tui-runtime-adapter/conformance.js

@@ -1,145 +0,0 @@
-import { PiTuiRuntimeAdapter, PiTuiRuntimeError } from "./adapter.js";
-export async function runPiTuiRuntimeConformance(options) {
-    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(options.packageVersion)) {
-        throw new TypeError("Pi TUI conformance requires an exact package version from compatibility authority");
-    }
-    const terminal = new ConformanceTerminal();
-    const root = new ConformanceComponent(["stable row", "before"]);
-    const overlay = new ConformanceComponent(["overlay"]);
-    const runtime = new PiTuiRuntimeAdapter({ root, terminal, mouse: false });
-    try {
-        runtime.start();
-        runtime.renderNow(true);
-        root.lines = ["stable row", "after"];
-        const writesBeforeDifferential = terminal.writes.length;
-        runtime.renderNow();
-        const differentialFrame = terminal.writes.slice(writesBeforeDifferential).join("");
-        terminal.input("root-input");
-        runtime.renderNow();
-        const overlayHandle = runtime.showOverlay(overlay, { width: 12, anchor: "center" });
-        runtime.renderNow();
-        terminal.input("overlay-input");
-        runtime.renderNow();
-        const overlayRouted = overlay.inputs.includes("overlay-input") && !root.inputs.includes("overlay-input");
-        overlayHandle.hide();
-        const redrawsBeforeResize = runtime.fullRedraws;
-        terminal.resize(60, 10);
-        runtime.renderNow();
-        const resizeRedraw = runtime.fullRedraws > redrawsBeforeResize && runtime.viewport().columns === 60;
-        const fullscreenConstructed = runtime.switchMode("fullscreen");
-        runtime.renderNow(true);
-        const regularRestored = runtime.switchMode("regular");
-        runtime.renderNow(true);
-        await runtime.stop({ drainMaxMs: 1, drainIdleMs: 1 });
-        const emitted = terminal.writes.join("");
-        return {
-            packageName: "@earendil-works/pi-tui",
-            packageVersion: options.packageVersion,
-            mode: runtime.mode,
-            constructedModes: fullscreenConstructed && regularRestored ? ["regular", "fullscreen"] : ["regular"],
-            lifecycleRestored: terminal.startCount >= 1
-                && terminal.startCount === terminal.stopCount
-                && terminal.drainCount === 1
-                && (emitted.match(/\x1b\[\?1049h/g)?.length ?? 0) === (emitted.match(/\x1b\[\?1049l/g)?.length ?? 0)
-                && root.disposed,
-            inputRouted: root.inputs.includes("root-input"),
-            overlayRouted,
-            focusRouted: root.focusChanges.includes(true) && overlay.focusChanges.includes(true),
-            widthBounded: root.widths.every(width => width <= terminal.columns) && overlay.widths.every(width => width <= 12),
-            differentialRendering: differentialFrame.includes("after") && !differentialFrame.includes("stable row"),
-            resizeRedraw,
-            terminalNativeSelection: !emitted.includes("\x1b[?1000h") && !emitted.includes("\x1b[?1006h"),
-        };
-    }
-    catch (error) {
-        if (runtime.active)
-            await runtime.stop({ drainInput: false }).catch(() => { });
-        if (error instanceof PiTuiRuntimeError)
-            throw error;
-        throw new PiTuiRuntimeError("construction", error);
-    }
-}
-class ConformanceComponent {
-    lines;
-    inputs = [];
-    focusChanges = [];
-    widths = [];
-    disposed = false;
-    constructor(lines) {
-        this.lines = lines;
-    }
-    render(width) {
-        this.widths.push(width);
-        return this.lines;
-    }
-    setFocused(focused) {
-        this.focusChanges.push(focused);
-    }
-    handleInput(data) {
-        this.inputs.push(data);
-    }
-    invalidate() { }
-    dispose() {
-        this.disposed = true;
-    }
-}
-class ConformanceTerminal {
-    columns = 40;
-    rows = 6;
-    kittyProtocolActive = false;
-    writes = [];
-    startCount = 0;
-    stopCount = 0;
-    drainCount = 0;
-    #onInput;
-    #onResize;
-    start(onInput, onResize) {
-        this.startCount += 1;
-        this.#onInput = onInput;
-        this.#onResize = onResize;
-    }
-    stop() {
-        this.stopCount += 1;
-        this.#onInput = undefined;
-        this.#onResize = undefined;
-    }
-    async drainInput() {
-        this.drainCount += 1;
-    }
-    write(data) {
-        this.writes.push(data);
-    }
-    input(data) {
-        this.#onInput?.(data);
-    }
-    resize(columns, rows) {
-        this.columns = columns;
-        this.rows = rows;
-        this.#onResize?.();
-    }
-    moveBy(lines) {
-        if (lines !== 0)
-            this.write(`move:${lines}`);
-    }
-    hideCursor() {
-        this.write("\x1b[?25l");
-    }
-    showCursor() {
-        this.write("\x1b[?25h");
-    }
-    clearLine() {
-        this.write("\x1b[K");
-    }
-    clearFromCursor() {
-        this.write("\x1b[J");
-    }
-    clearScreen() {
-        this.write("\x1b[2J\x1b[H");
-    }
-    setTitle(title) {
-        this.write(`title:${title}`);
-    }
-    setProgress(active) {
-        this.write(`progress:${active}`);
-    }
-}