@opentui/core 0.0.0-20250908-4906ddad

package/renderables/TabSelect.d.ts

@@ -0,0 +1,86 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import { type ColorInput } from "../lib/RGBA";
+import type { ParsedKey } from "../lib/parse.keypress";
+import type { RenderContext } from "../types";
+export interface TabSelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export interface TabSelectRenderableOptions extends Omit<RenderableOptions<TabSelectRenderable>, "height"> {
+    height?: number;
+    options?: TabSelectOption[];
+    tabWidth?: number;
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollArrows?: boolean;
+    showDescription?: boolean;
+    showUnderline?: boolean;
+    wrapSelection?: boolean;
+}
+export declare enum TabSelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class TabSelectRenderable extends Renderable {
+    protected focusable: boolean;
+    private _options;
+    private selectedIndex;
+    private scrollOffset;
+    private _tabWidth;
+    private maxVisibleTabs;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _selectedBackgroundColor;
+    private _selectedTextColor;
+    private _selectedDescriptionColor;
+    private _showScrollArrows;
+    private _showDescription;
+    private _showUnderline;
+    private _wrapSelection;
+    constructor(ctx: RenderContext, options: TabSelectRenderableOptions);
+    private calculateDynamicHeight;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private truncateText;
+    private renderScrollArrowsToFrameBuffer;
+    setOptions(options: TabSelectOption[]): void;
+    getSelectedOption(): TabSelectOption | null;
+    getSelectedIndex(): number;
+    moveLeft(): void;
+    moveRight(): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    setTabWidth(tabWidth: number): void;
+    getTabWidth(): number;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    get options(): TabSelectOption[];
+    set options(options: TabSelectOption[]);
+    set backgroundColor(color: ColorInput);
+    set textColor(color: ColorInput);
+    set focusedBackgroundColor(color: ColorInput);
+    set focusedTextColor(color: ColorInput);
+    set selectedBackgroundColor(color: ColorInput);
+    set selectedTextColor(color: ColorInput);
+    set selectedDescriptionColor(color: ColorInput);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get showUnderline(): boolean;
+    set showUnderline(show: boolean);
+    get showScrollArrows(): boolean;
+    set showScrollArrows(show: boolean);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    get tabWidth(): number;
+    set tabWidth(tabWidth: number);
+}

package/renderables/Text.d.ts

@@ -0,0 +1,72 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
+import { StyledText } from "../lib/styled-text";
+import { type TextChunk } from "../text-buffer";
+import { RGBA } from "../lib/RGBA";
+import { type RenderContext } from "../types";
+import type { OptimizedBuffer } from "../buffer";
+export interface TextOptions extends RenderableOptions<TextRenderable> {
+    content?: StyledText | string;
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+}
+export declare class TextRenderable extends Renderable {
+    selectable: boolean;
+    private _text;
+    private _defaultFg;
+    private _defaultBg;
+    private _defaultAttributes;
+    private _selectionBg;
+    private _selectionFg;
+    private lastLocalSelection;
+    private textBuffer;
+    private _lineInfo;
+    protected _defaultOptions: {
+        content: string;
+        fg: RGBA;
+        bg: RGBA;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+    };
+    constructor(ctx: RenderContext, options: TextOptions);
+    private updateTextBuffer;
+    private clearChunks;
+    get content(): StyledText;
+    get plainText(): string;
+    get textLength(): number;
+    get chunks(): TextChunk[];
+    set content(value: StyledText | string);
+    get fg(): RGBA;
+    set fg(value: RGBA | string | undefined);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: RGBA | string | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: RGBA | string | undefined);
+    get bg(): RGBA;
+    set bg(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    protected onResize(width: number, height: number): void;
+    private updateLocalSelection;
+    private updateTextInfo;
+    private setupMeasureFunc;
+    insertChunk(chunk: TextChunk, index?: number): void;
+    removeChunk(chunk: TextChunk): void;
+    replaceChunk(chunk: TextChunk, oldChunk: TextChunk): void;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    destroy(): void;
+}

package/renderables/composition/VRenderable.d.ts

@@ -0,0 +1,16 @@
+import { Renderable, type RenderableOptions } from "../../Renderable";
+import type { OptimizedBuffer } from "../../buffer";
+import type { RenderContext } from "../../types";
+export interface VRenderableOptions extends RenderableOptions<VRenderable> {
+    render?: (this: VRenderable | VRenderableOptions, buffer: OptimizedBuffer, deltaTime: number, renderable: VRenderable) => void;
+}
+/**
+ * A generic renderable that accepts a custom render function as a prop.
+ * This allows functional constructs to specify custom rendering behavior
+ * without needing to subclass Renderable.
+ */
+export declare class VRenderable extends Renderable {
+    private options;
+    constructor(ctx: RenderContext, options: VRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+}

package/renderables/composition/constructs.d.ts

@@ -0,0 +1,12 @@
+import { ASCIIFontRenderable, BoxRenderable, InputRenderable, SelectRenderable, TabSelectRenderable, TextRenderable, VRenderable, type ASCIIFontOptions, type BoxOptions, type TextOptions, type VRenderableOptions, type InputRenderableOptions, type SelectRenderableOptions, type TabSelectRenderableOptions, FrameBufferRenderable, type FrameBufferOptions } from "../";
+import { type VChild, type ProxiedVNode } from "./vnode";
+export declare function Generic(props?: VRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof VRenderable>;
+export declare function Box(props?: BoxOptions, ...children: VChild[]): ProxiedVNode<typeof BoxRenderable>;
+export declare function Text(props?: TextOptions & {
+    content?: any;
+}, ...children: VChild[]): ProxiedVNode<typeof TextRenderable>;
+export declare function ASCIIFont(props?: ASCIIFontOptions, ...children: VChild[]): ProxiedVNode<typeof ASCIIFontRenderable>;
+export declare function Input(props?: InputRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof InputRenderable>;
+export declare function Select(props?: SelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof SelectRenderable>;
+export declare function TabSelect(props?: TabSelectRenderableOptions, ...children: VChild[]): ProxiedVNode<typeof TabSelectRenderable>;
+export declare function FrameBuffer(props: FrameBufferOptions, ...children: VChild[]): ProxiedVNode<typeof FrameBufferRenderable>;

package/renderables/composition/vnode.d.ts

@@ -0,0 +1,46 @@
+import { Renderable, type RenderableOptions } from "../../Renderable";
+import type { RenderContext } from "../../types";
+export type VChild = VNode | Renderable | VChild[] | null | undefined | false;
+export interface PendingCall {
+    method: string;
+    args: any[];
+    isProperty?: boolean;
+}
+declare const BrandedVNode: unique symbol;
+export interface VNode<P = any, C = VChild[]> {
+    [BrandedVNode]: true;
+    type: Construct<P>;
+    props?: P;
+    children?: C;
+    __delegateMap?: Record<string, string>;
+    __pendingCalls?: PendingCall[];
+}
+export type ProxiedVNode<TCtor extends RenderableConstructor<any>> = VNode<TCtor extends RenderableConstructor<infer P> ? P : any> & {
+    [K in keyof InstanceType<TCtor>]: InstanceType<TCtor>[K] extends (...args: infer Args) => any ? (...args: Args) => ProxiedVNode<TCtor> : InstanceType<TCtor>[K];
+};
+export interface RenderableConstructor<P extends RenderableOptions<any> = RenderableOptions<any>> {
+    new (ctx: RenderContext, options: P): Renderable;
+}
+export type FunctionalConstruct<P = any> = (props: P, children?: VChild[]) => VNode;
+export type Construct<P = any> = RenderableConstructor<P extends RenderableOptions<any> ? P : never> | FunctionalConstruct<P>;
+export declare function h<TCtor extends RenderableConstructor<any>>(type: TCtor, props?: TCtor extends RenderableConstructor<infer P> ? P : never, ...children: VChild[]): ProxiedVNode<TCtor>;
+export declare function h<P>(type: FunctionalConstruct<P>, props?: P, ...children: VChild[]): VNode<P>;
+export declare function h<P>(type: Construct<P>, props?: P, ...children: VChild[]): VNode<P> | ProxiedVNode<any>;
+export declare function isVNode(node: any): node is VNode;
+export declare function maybeMakeRenderable(ctx: RenderContext, node: Renderable | VNode<any, any[]>): Renderable | null;
+export declare function wrapWithDelegates<T extends InstanceType<RenderableConstructor>>(instance: T, delegateMap: Record<string, string> | undefined): T;
+export type InstantiateFn<NodeType extends VNode | Renderable> = Renderable & {
+    __node?: NodeType;
+};
+export declare function instantiate<NodeType extends VNode | Renderable>(ctx: RenderContext, node: NodeType): InstantiateFn<NodeType>;
+export type DelegateMap<T> = Partial<Record<keyof T, string>>;
+export type ValidateShape<Given, AllowedKeys> = {
+    [K in keyof Given]: K extends keyof AllowedKeys ? NonNullable<Given[K]> : never;
+};
+type InferNode<T> = T extends InstantiateFn<infer U> ? U : never;
+export declare function delegate<Factory extends InstantiateFn<any>, InnerNode extends InferNode<Factory>, TargetMap extends Record<keyof InnerNode, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: Factory): Renderable;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, TargetMap extends Record<keyof InstanceType<ConstructorType>, string>, const Mapping extends Partial<TargetMap>>(mapping: ValidateShape<Mapping, TargetMap>, vnode: ProxiedVNode<ConstructorType>): ProxiedVNode<ConstructorType>;
+export declare function delegate<ConstructorType extends RenderableConstructor<any>, const Mapping extends DelegateMap<InstanceType<ConstructorType>>>(mapping: ValidateShape<Mapping, string>, vnode: VNode & {
+    type: ConstructorType;
+}): VNode;
+export {};

package/renderables/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./Box";
+export * from "./FrameBuffer";
+export * from "./Text";
+export * from "./ASCIIFont";
+export * from "./Input";
+export * from "./Select";
+export * from "./TabSelect";
+export * from "./ScrollBox";
+export * from "./ScrollBar";
+export * from "./composition/constructs";
+export * from "./composition/vnode";
+export * from "./composition/VRenderable";

package/renderer.d.ts

@@ -0,0 +1,232 @@
+import { Renderable, RootRenderable } from "./Renderable";
+import { type CursorStyle, DebugOverlayCorner, type RenderContext, type WidthMethod } from "./types";
+import { RGBA, type ColorInput } from "./lib/RGBA";
+import type { Pointer } from "bun:ffi";
+import { OptimizedBuffer } from "./buffer";
+import { type RenderLib } from "./zig";
+import { TerminalConsole, type ConsoleOptions } from "./console";
+import { type MouseEventType, type RawMouseEvent, type ScrollInfo } from "./lib/parse.mouse";
+import { Selection } from "./lib/selection";
+import { EventEmitter } from "events";
+export interface CliRendererConfig {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    exitOnCtrlC?: boolean;
+    debounceDelay?: number;
+    targetFps?: number;
+    memorySnapshotInterval?: number;
+    useThread?: boolean;
+    gatherStats?: boolean;
+    maxStatSamples?: number;
+    consoleOptions?: ConsoleOptions;
+    postProcessFns?: ((buffer: OptimizedBuffer, deltaTime: number) => void)[];
+    enableMouseMovement?: boolean;
+    useMouse?: boolean;
+    useAlternateScreen?: boolean;
+    useConsole?: boolean;
+    experimental_splitHeight?: number;
+}
+export type PixelResolution = {
+    width: number;
+    height: number;
+};
+export declare class MouseEvent {
+    readonly type: MouseEventType;
+    readonly button: number;
+    readonly x: number;
+    readonly y: number;
+    readonly source?: Renderable;
+    readonly modifiers: {
+        shift: boolean;
+        alt: boolean;
+        ctrl: boolean;
+    };
+    readonly scroll?: ScrollInfo;
+    readonly target: Renderable | null;
+    readonly isSelecting?: boolean;
+    private _propagationStopped;
+    private _defaultPrevented;
+    get propagationStopped(): boolean;
+    get defaultPrevented(): boolean;
+    constructor(target: Renderable | null, attributes: RawMouseEvent & {
+        source?: Renderable;
+        isSelecting?: boolean;
+    });
+    stopPropagation(): void;
+    preventDefault(): void;
+}
+export declare enum MouseButton {
+    LEFT = 0,
+    MIDDLE = 1,
+    RIGHT = 2,
+    WHEEL_UP = 4,
+    WHEEL_DOWN = 5
+}
+export declare function createCliRenderer(config?: CliRendererConfig): Promise<CliRenderer>;
+export declare enum CliRenderEvents {
+    DEBUG_OVERLAY_TOGGLE = "debugOverlay:toggle"
+}
+export declare class CliRenderer extends EventEmitter implements RenderContext {
+    private static animationFrameId;
+    private lib;
+    rendererPtr: Pointer;
+    private stdin;
+    private stdout;
+    private exitOnCtrlC;
+    private isDestroyed;
+    nextRenderBuffer: OptimizedBuffer;
+    currentRenderBuffer: OptimizedBuffer;
+    private _isRunning;
+    private targetFps;
+    private memorySnapshotInterval;
+    private memorySnapshotTimer;
+    private lastMemorySnapshot;
+    readonly root: RootRenderable;
+    width: number;
+    height: number;
+    private _useThread;
+    private gatherStats;
+    private frameTimes;
+    private maxStatSamples;
+    private postProcessFns;
+    private backgroundColor;
+    private waitingForPixelResolution;
+    private rendering;
+    private renderingNative;
+    private renderTimeout;
+    private lastTime;
+    private frameCount;
+    private lastFpsTime;
+    private currentFps;
+    private targetFrameTime;
+    private immediateRerenderRequested;
+    private updateScheduled;
+    private liveRequestCounter;
+    private controlState;
+    private frameCallbacks;
+    private renderStats;
+    debugOverlay: {
+        enabled: boolean;
+        corner: DebugOverlayCorner;
+    };
+    private _console;
+    private _resolution;
+    private animationRequest;
+    private resizeTimeoutId;
+    private resizeDebounceDelay;
+    private enableMouseMovement;
+    private _useMouse;
+    private _useAlternateScreen;
+    private capturedRenderable?;
+    private lastOverRenderableNum;
+    private lastOverRenderable?;
+    private currentSelection;
+    private selectionContainers;
+    private _splitHeight;
+    private renderOffset;
+    private _terminalWidth;
+    private _terminalHeight;
+    private _terminalIsSetup;
+    private realStdoutWrite;
+    private captureCallback;
+    private _useConsole;
+    private mouseParser;
+    private sigwinchHandler;
+    private _capabilities;
+    private _latestPointer;
+    constructor(lib: RenderLib, rendererPtr: Pointer, stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, width: number, height: number, config?: CliRendererConfig);
+    addToHitGrid(x: number, y: number, width: number, height: number, id: number): void;
+    get widthMethod(): WidthMethod;
+    private writeOut;
+    requestRender(): void;
+    get useConsole(): boolean;
+    set useConsole(value: boolean);
+    get isRunning(): boolean;
+    get resolution(): PixelResolution | null;
+    get console(): TerminalConsole;
+    get terminalWidth(): number;
+    get terminalHeight(): number;
+    get useThread(): boolean;
+    get useMouse(): boolean;
+    set useMouse(useMouse: boolean);
+    get experimental_splitHeight(): number;
+    get liveRequestCount(): number;
+    get currentControlState(): string;
+    get capabilities(): any | null;
+    set experimental_splitHeight(splitHeight: number);
+    private interceptStdoutWrite;
+    private disableStdoutInterception;
+    private flushStdoutCache;
+    private enableMouse;
+    private disableMouse;
+    enableKittyKeyboard(flags?: number): void;
+    disableKittyKeyboard(): void;
+    set useThread(useThread: boolean);
+    setupTerminal(): Promise<void>;
+    private handleMouseData;
+    private takeMemorySnapshot;
+    private startMemorySnapshotTimer;
+    setMemorySnapshotInterval(interval: number): void;
+    private handleResize;
+    private queryPixelResolution;
+    private processResize;
+    setBackgroundColor(color: ColorInput): void;
+    toggleDebugOverlay(): void;
+    configureDebugOverlay(options: {
+        enabled?: boolean;
+        corner?: DebugOverlayCorner;
+    }): void;
+    clearTerminal(): void;
+    setTerminalTitle(title: string): void;
+    dumpHitGrid(): void;
+    dumpBuffers(timestamp?: number): void;
+    dumpStdoutBuffer(timestamp?: number): void;
+    static setCursorPosition(renderer: CliRenderer, x: number, y: number, visible?: boolean): void;
+    static setCursorStyle(renderer: CliRenderer, style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    static setCursorColor(renderer: CliRenderer, color: RGBA): void;
+    setCursorPosition(x: number, y: number, visible?: boolean): void;
+    setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    setCursorColor(color: RGBA): void;
+    addPostProcessFn(processFn: (buffer: OptimizedBuffer, deltaTime: number) => void): void;
+    removePostProcessFn(processFn: (buffer: OptimizedBuffer, deltaTime: number) => void): void;
+    clearPostProcessFns(): void;
+    setFrameCallback(callback: (deltaTime: number) => Promise<void>): void;
+    removeFrameCallback(callback: (deltaTime: number) => Promise<void>): void;
+    clearFrameCallbacks(): void;
+    requestLive(): void;
+    dropLive(): void;
+    start(): void;
+    auto(): void;
+    private internalStart;
+    pause(): void;
+    private internalPause;
+    stop(): void;
+    private internalStop;
+    destroy(): void;
+    private startRenderLoop;
+    private loop;
+    intermediateRender(): void;
+    private renderNative;
+    private collectStatSample;
+    getStats(): {
+        fps: number;
+        frameCount: number;
+        frameTimes: number[];
+        averageFrameTime: number;
+        minFrameTime: number;
+        maxFrameTime: number;
+    };
+    resetStats(): void;
+    setGatherStats(enabled: boolean): void;
+    getSelection(): Selection | null;
+    get hasSelection(): boolean;
+    getSelectionContainer(): Renderable | null;
+    clearSelection(): void;
+    private startSelection;
+    private updateSelection;
+    requestSelectionUpdate(): void;
+    private isWithinContainer;
+    private finishSelection;
+    private notifySelectablesOfSelectionChange;
+    private walkSelectableRenderables;
+}

package/singleton.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ensures a value is initialized once per process,
+ * persists across Bun hot reloads, and is type-safe.
+ */
+export declare function singleton<T>(key: string, factory: () => T): T;

package/text-buffer.d.ts

@@ -0,0 +1,52 @@
+import type { StyledText } from "./lib/styled-text";
+import { RGBA } from "./lib/RGBA";
+import { type RenderLib } from "./zig";
+import { type Pointer } from "bun:ffi";
+import { type WidthMethod } from "./types";
+export interface TextChunk {
+    __isChunk: true;
+    text: Uint8Array;
+    plainText: string;
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes?: number;
+}
+export declare class TextBuffer {
+    private lib;
+    private bufferPtr;
+    private _length;
+    private _capacity;
+    private _lineInfo?;
+    constructor(lib: RenderLib, ptr: Pointer, capacity: number);
+    static create(capacity: number | undefined, widthMethod: WidthMethod): TextBuffer;
+    setStyledText(text: StyledText): void;
+    setDefaultFg(fg: RGBA | null): void;
+    setDefaultBg(bg: RGBA | null): void;
+    setDefaultAttributes(attributes: number | null): void;
+    resetDefaults(): void;
+    get length(): number;
+    get capacity(): number;
+    get ptr(): Pointer;
+    getSelectedText(): string;
+    getPlainText(): string;
+    get lineInfo(): {
+        lineStarts: number[];
+        lineWidths: number[];
+    };
+    setSelection(start: number, end: number, bgColor?: RGBA, fgColor?: RGBA): void;
+    resetSelection(): void;
+    setLocalSelection(anchorX: number, anchorY: number, focusX: number, focusY: number, bgColor?: RGBA, fgColor?: RGBA): boolean;
+    resetLocalSelection(): void;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    hasSelection(): boolean;
+    insertChunkGroup(index: number, text: string, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    insertEncodedChunkGroup(index: number, textBytes: Uint8Array, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    removeChunkGroup(index: number): void;
+    replaceChunkGroup(index: number, text: string, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    replaceEncodedChunkGroup(index: number, textBytes: Uint8Array, fg?: RGBA, bg?: RGBA, attributes?: number): void;
+    get chunkGroupCount(): number;
+    destroy(): void;
+}

package/types.d.ts

@@ -0,0 +1,56 @@
+import type { RGBA } from "./lib/RGBA";
+import type { EventEmitter } from "events";
+import type { Selection } from "./lib/selection";
+export declare const TextAttributes: {
+    NONE: number;
+    BOLD: number;
+    DIM: number;
+    ITALIC: number;
+    UNDERLINE: number;
+    BLINK: number;
+    INVERSE: number;
+    HIDDEN: number;
+    STRIKETHROUGH: number;
+};
+export type CursorStyle = "block" | "line" | "underline";
+export declare enum DebugOverlayCorner {
+    topLeft = 0,
+    topRight = 1,
+    bottomLeft = 2,
+    bottomRight = 3
+}
+export type WidthMethod = "wcwidth" | "unicode";
+export interface RendererEvents {
+    resize: (width: number, height: number) => void;
+    key: (data: Buffer) => void;
+    "memory:snapshot": (snapshot: {
+        heapUsed: number;
+        heapTotal: number;
+        arrayBuffers: number;
+    }) => void;
+    selection: (selection: Selection) => void;
+    "debugOverlay:toggle": (enabled: boolean) => void;
+}
+export interface RenderContext extends EventEmitter {
+    addToHitGrid: (x: number, y: number, width: number, height: number, id: number) => void;
+    width: number;
+    height: number;
+    requestRender: () => void;
+    setCursorPosition: (x: number, y: number, visible: boolean) => void;
+    setCursorStyle: (style: CursorStyle, blinking: boolean) => void;
+    setCursorColor: (color: RGBA) => void;
+    widthMethod: WidthMethod;
+    capabilities: any | null;
+    requestLive: () => void;
+    dropLive: () => void;
+    hasSelection: boolean;
+    getSelection: () => Selection | null;
+    requestSelectionUpdate: () => void;
+}
+export type Timeout = ReturnType<typeof setTimeout> | undefined;
+export interface ViewportBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

package/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function createTextAttributes({ bold, italic, underline, dim, blink, inverse, hidden, strikethrough, }?: {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+    blink?: boolean;
+    inverse?: boolean;
+    hidden?: boolean;
+    strikethrough?: boolean;
+}): number;