@opentui/core 0.1.28 → 0.1.30

package/lib/hast-styled-text.d.ts

@@ -1,5 +1,5 @@
 import { StyledText } from "./styled-text";
-import { SyntaxStyle } from "./syntax-style";
+import { SyntaxStyle } from "../syntax-style";
 export interface HASTText {
     type: "text";
     value: string;
@@ -13,6 +13,5 @@ export interface HASTElement {
     children: HASTNode[];
 }
 export type HASTNode = HASTText | HASTElement;
-export { SyntaxStyle } from "./syntax-style";
-export type { StyleDefinition } from "./syntax-style";
+export type { StyleDefinition } from "../syntax-style";
 export declare function hastToStyledText(hast: HASTNode, syntaxStyle: SyntaxStyle): StyledText;

package/lib/index.d.ts

@@ -12,5 +12,4 @@ export * from "./selection";
 export * from "./env";
 export * from "./tree-sitter-styled-text";
 export * from "./tree-sitter";
-export * from "./syntax-style";
 export * from "./data-paths";

package/lib/keymapping.d.ts

@@ -0,0 +1,10 @@
+export interface KeyBinding<Action extends string = string> {
+    name: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+    action: Action;
+}
+export declare function mergeKeyBindings<Action extends string>(defaults: KeyBinding<Action>[], custom: KeyBinding<Action>[]): KeyBinding<Action>[];
+export declare function getKeyBindingKey<Action extends string>(binding: KeyBinding<Action>): string;
+export declare function buildKeyBindingsMap<Action extends string>(bindings: KeyBinding<Action>[]): Map<string, Action>;

package/lib/objects-in-viewport.d.ts

@@ -6,5 +6,19 @@ interface ViewportObject {
     height: number;
     zIndex: number;
 }
+/**
+ * Returns objects that overlap with the viewport bounds.
+ *
+ * @param viewport - The viewport bounds to check against
+ * @param objects - Array of objects MUST be sorted by position (y for column, x for row direction)
+ * @param direction - Primary scroll direction: "column" (vertical) or "row" (horizontal)
+ * @param padding - Extra padding around viewport to include nearby objects
+ * @param minTriggerSize - Minimum array size to use binary search optimization
+ * @returns Array of visible objects sorted by zIndex
+ *
+ * @remarks
+ * Objects must be pre-sorted by their start position (y for column direction, x for row direction).
+ * Unsorted input will produce incorrect results.
+ */
 export declare function getObjectsInViewport<T extends ViewportObject>(viewport: ViewportBounds, objects: T[], direction?: "row" | "column", padding?: number, minTriggerSize?: number): T[];
 export {};

package/lib/tree-sitter/index.d.ts

@@ -1,9 +1,7 @@
 import { TreeSitterClient } from "./client";
 export * from "./client";
 export * from "../tree-sitter-styled-text";
-export * from "../syntax-style";
 export * from "./types";
-export * from "../syntax-style";
 export * from "./resolve-ft";
 export type { UpdateOptions } from "./assets/update";
 export { updateAssets } from "./assets/update";

package/lib/tree-sitter-styled-text.d.ts

@@ -1,6 +1,6 @@
 import type { TextChunk } from "../text-buffer";
 import { StyledText } from "./styled-text";
-import { SyntaxStyle } from "./syntax-style";
+import { SyntaxStyle } from "../syntax-style";
 import { TreeSitterClient } from "./tree-sitter/client";
 import type { SimpleHighlight } from "./tree-sitter/types";
 export declare function treeSitterToTextChunks(content: string, highlights: SimpleHighlight[], syntaxStyle: SyntaxStyle): TextChunk[];

package/lib/yoga.options.d.ts

@@ -14,18 +14,18 @@ export type OverflowString = "visible" | "hidden" | "scroll";
 export type PositionTypeString = "static" | "relative" | "absolute";
 export type UnitString = "undefined" | "point" | "percent" | "auto";
 export type WrapString = "no-wrap" | "wrap" | "wrap-reverse";
-export declare function parseAlign(value: string): Align;
+export declare function parseAlign(value: string | null | undefined): Align;
 export declare function parseBoxSizing(value: string): BoxSizing;
 export declare function parseDimension(value: string): Dimension;
 export declare function parseDirection(value: string): Direction;
 export declare function parseDisplay(value: string): Display;
 export declare function parseEdge(value: string): Edge;
-export declare function parseFlexDirection(value: string): FlexDirection;
+export declare function parseFlexDirection(value: string | null | undefined): FlexDirection;
 export declare function parseGutter(value: string): Gutter;
-export declare function parseJustify(value: string): Justify;
+export declare function parseJustify(value: string | null | undefined): Justify;
 export declare function parseLogLevel(value: string): LogLevel;
 export declare function parseMeasureMode(value: string): MeasureMode;
-export declare function parseOverflow(value: string): Overflow;
-export declare function parsePositionType(value: string): PositionType;
+export declare function parseOverflow(value: string | null | undefined): Overflow;
+export declare function parsePositionType(value: string | null | undefined): PositionType;
 export declare function parseUnit(value: string): Unit;
-export declare function parseWrap(value: string): Wrap;
+export declare function parseWrap(value: string | null | undefined): Wrap;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -35,6 +35,7 @@
     }
   },
   "dependencies": {
+    "bun-ffi-structs": "^0.1.0",
     "jimp": "1.6.0",
     "yoga-layout": "3.2.1"
   },
@@ -54,11 +55,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.28",
-    "@opentui/core-darwin-arm64": "0.1.28",
-    "@opentui/core-linux-x64": "0.1.28",
-    "@opentui/core-linux-arm64": "0.1.28",
-    "@opentui/core-win32-x64": "0.1.28",
-    "@opentui/core-win32-arm64": "0.1.28"
+    "@opentui/core-darwin-x64": "0.1.30",
+    "@opentui/core-darwin-arm64": "0.1.30",
+    "@opentui/core-linux-x64": "0.1.30",
+    "@opentui/core-linux-arm64": "0.1.30",
+    "@opentui/core-win32-x64": "0.1.30",
+    "@opentui/core-win32-arm64": "0.1.30"
   }
 }

package/renderables/Code.d.ts

@@ -1,5 +1,5 @@
 import { type RenderContext } from "../types";
-import { SyntaxStyle } from "../lib/syntax-style";
+import { SyntaxStyle } from "../syntax-style";
 import { TreeSitterClient } from "../lib/tree-sitter";
 import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable";
 export interface CodeOptions extends TextBufferOptions {

package/renderables/EditBufferRenderable.d.ts

@@ -0,0 +1,113 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection, type LocalSelectionBounds } from "../lib/selection";
+import { EditBuffer, type CursorPosition } from "../edit-buffer";
+import { EditorView, type VisualCursor } from "../editor-view";
+import { RGBA } from "../lib/RGBA";
+import { type RenderContext, type Highlight } from "../types";
+import type { OptimizedBuffer } from "../buffer";
+import type { SyntaxStyle } from "../syntax-style";
+export interface CursorChangeEvent {
+    line: number;
+    visualColumn: number;
+}
+export interface ContentChangeEvent {
+}
+export interface EditBufferOptions extends RenderableOptions<EditBufferRenderable> {
+    textColor?: string | RGBA;
+    backgroundColor?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrapMode?: "none" | "char" | "word";
+    scrollMargin?: number;
+    showCursor?: boolean;
+    cursorColor?: string | RGBA;
+    syntaxStyle?: SyntaxStyle;
+    onCursorChange?: (event: CursorChangeEvent) => void;
+    onContentChange?: (event: ContentChangeEvent) => void;
+}
+export declare abstract class EditBufferRenderable extends Renderable {
+    protected _focusable: boolean;
+    selectable: boolean;
+    protected _textColor: RGBA;
+    protected _backgroundColor: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrapMode: "none" | "char" | "word";
+    protected _scrollMargin: number;
+    protected _showCursor: boolean;
+    protected _cursorColor: RGBA;
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    private _cursorChangeListener;
+    private _contentChangeListener;
+    editBuffer: EditBuffer;
+    editorView: EditorView;
+    protected _defaultOptions: {
+        textColor: RGBA;
+        backgroundColor: string;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        scrollMargin: number;
+        showCursor: true;
+        cursorColor: RGBA;
+    };
+    constructor(ctx: RenderContext, options: EditBufferOptions);
+    private setupEventListeners;
+    get plainText(): string;
+    get cursor(): CursorPosition;
+    get visualCursor(): VisualCursor;
+    get cursorOffset(): number;
+    set cursorOffset(offset: number);
+    get textColor(): RGBA;
+    set textColor(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 backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get showCursor(): boolean;
+    set showCursor(value: boolean);
+    get cursorColor(): RGBA;
+    set cursorColor(value: RGBA | string);
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    private setupMeasureFunc;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected renderCursor(buffer: OptimizedBuffer): void;
+    focus(): void;
+    blur(): void;
+    protected onRemove(): void;
+    destroy(): void;
+    set onCursorChange(handler: ((event: CursorChangeEvent) => void) | undefined);
+    get onCursorChange(): ((event: CursorChangeEvent) => void) | undefined;
+    set onContentChange(handler: ((event: ContentChangeEvent) => void) | undefined);
+    get onContentChange(): ((event: ContentChangeEvent) => void) | undefined;
+    get syntaxStyle(): SyntaxStyle | null;
+    set syntaxStyle(style: SyntaxStyle | null);
+    addHighlight(lineIdx: number, highlight: Highlight): void;
+    addHighlightByCharRange(highlight: Highlight): void;
+    removeHighlightsByRef(hlRef: number): void;
+    clearLineHighlights(lineIdx: number): void;
+    clearAllHighlights(): void;
+    getLineHighlights(lineIdx: number): Array<Highlight>;
+}

package/renderables/Text.d.ts

@@ -22,9 +22,6 @@ export declare class TextRenderable extends TextBufferRenderable {
     get chunks(): TextChunk[];
     get textNode(): RootTextNodeRenderable;
     set content(value: StyledText | string);
-    insertChunk(chunk: TextChunk, index?: number): void;
-    removeChunkByObject(chunk: TextChunk): void;
-    replaceChunkByObject(chunk: TextChunk, oldChunk: TextChunk): void;
     private updateTextFromNodes;
     add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
     remove(id: string): void;

package/renderables/TextBufferRenderable.d.ts

@@ -1,6 +1,7 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
 import { Selection, type LocalSelectionBounds } from "../lib/selection";
-import { TextBuffer, type TextChunk } from "../text-buffer";
+import { TextBuffer } from "../text-buffer";
+import { TextBufferView } from "../text-buffer-view";
 import { RGBA } from "../lib/RGBA";
 import { type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
@@ -12,8 +13,7 @@ export interface TextBufferOptions extends RenderableOptions<TextBufferRenderabl
     selectionFg?: string | RGBA;
     selectable?: boolean;
     attributes?: number;
-    wrap?: boolean;
-    wrapMode?: "char" | "word";
+    wrapMode?: "none" | "char" | "word";
 }
 export declare abstract class TextBufferRenderable extends Renderable {
     selectable: boolean;
@@ -22,10 +22,10 @@ export declare abstract class TextBufferRenderable extends Renderable {
     protected _defaultAttributes: number;
     protected _selectionBg: RGBA | undefined;
     protected _selectionFg: RGBA | undefined;
-    protected _wrap: boolean;
-    protected _wrapMode: "char" | "word";
+    protected _wrapMode: "none" | "char" | "word";
     protected lastLocalSelection: LocalSelectionBounds | null;
     protected textBuffer: TextBuffer;
+    protected textBufferView: TextBufferView;
     protected _lineInfo: LineInfo;
     protected _defaultOptions: {
         fg: RGBA;
@@ -34,8 +34,7 @@ export declare abstract class TextBufferRenderable extends Renderable {
         selectionFg: undefined;
         selectable: true;
         attributes: number;
-        wrap: true;
-        wrapMode: "char" | "word";
+        wrapMode: "none" | "char" | "word";
     };
     constructor(ctx: RenderContext, options: TextBufferOptions);
     get plainText(): string;
@@ -50,10 +49,8 @@ export declare abstract class TextBufferRenderable extends Renderable {
     set bg(value: RGBA | string | undefined);
     get attributes(): number;
     set attributes(value: number);
-    get wrap(): boolean;
-    set wrap(value: boolean);
-    get wrapMode(): "char" | "word";
-    set wrapMode(value: "char" | "word");
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
     protected onResize(width: number, height: number): void;
     protected refreshLocalSelection(): boolean;
     private updateLocalSelection;
@@ -61,9 +58,6 @@ export declare abstract class TextBufferRenderable extends Renderable {
     private updateLineInfo;
     private updateWrapWidth;
     private setupMeasureFunc;
-    insertChunk(chunk: TextChunk, index?: number): void;
-    removeChunk(index: number): void;
-    replaceChunk(index: number, chunk: TextChunk): void;
     shouldStartSelection(x: number, y: number): boolean;
     onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;

package/renderables/Textarea.d.ts

@@ -0,0 +1,87 @@
+import { type RenderContext } from "../types";
+import { EditBufferRenderable, type EditBufferOptions } from "./EditBufferRenderable";
+import type { KeyEvent } from "../lib/KeyHandler";
+import { RGBA, type ColorInput } from "../lib/RGBA";
+import { type KeyBinding as BaseKeyBinding } from "../lib/keymapping";
+export type TextareaAction = "move-left" | "move-right" | "move-up" | "move-down" | "select-left" | "select-right" | "select-up" | "select-down" | "line-home" | "line-end" | "select-line-home" | "select-line-end" | "buffer-home" | "buffer-end" | "delete-line" | "delete-to-line-end" | "backspace" | "delete" | "newline" | "undo" | "redo" | "word-forward" | "word-backward" | "select-word-forward" | "select-word-backward" | "delete-word-forward" | "delete-word-backward";
+export type KeyBinding = BaseKeyBinding<TextareaAction>;
+export interface TextareaOptions extends EditBufferOptions {
+    value?: string;
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    placeholder?: string | null;
+    placeholderColor?: ColorInput;
+    keyBindings?: KeyBinding[];
+}
+export declare class TextareaRenderable extends EditBufferRenderable {
+    private _placeholder;
+    private _unfocusedBackgroundColor;
+    private _unfocusedTextColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _placeholderColor;
+    private _keyBindingsMap;
+    private _actionHandlers;
+    private static readonly defaults;
+    constructor(ctx: RenderContext, options: TextareaOptions);
+    private buildActionHandlers;
+    handlePaste(text: string): void;
+    handleKeyPress(key: KeyEvent | string): boolean;
+    get value(): string;
+    set value(value: string);
+    private updateValue;
+    private updateColors;
+    insertChar(char: string): void;
+    insertText(text: string): void;
+    deleteChar(): boolean;
+    deleteCharBackward(): boolean;
+    private deleteSelectedText;
+    newLine(): boolean;
+    deleteLine(): boolean;
+    moveCursorLeft(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorRight(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorUp(options?: {
+        select?: boolean;
+    }): boolean;
+    moveCursorDown(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLine(line: number): void;
+    gotoLineHome(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoLineEnd(options?: {
+        select?: boolean;
+    }): boolean;
+    gotoBufferHome(): boolean;
+    gotoBufferEnd(): boolean;
+    deleteToLineEnd(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    moveWordForward(options?: {
+        select?: boolean;
+    }): boolean;
+    moveWordBackward(options?: {
+        select?: boolean;
+    }): boolean;
+    deleteWordForward(): boolean;
+    deleteWordBackward(): boolean;
+    private handleShiftSelection;
+    focus(): void;
+    blur(): void;
+    get placeholder(): string | null;
+    set placeholder(value: string | null);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get textColor(): RGBA;
+    set textColor(value: RGBA | string | undefined);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set placeholderColor(value: ColorInput);
+}

package/renderables/index.d.ts

@@ -14,3 +14,4 @@ export * from "./TabSelect";
 export * from "./Text";
 export * from "./TextBufferRenderable";
 export * from "./TextNode";
+export * from "./Textarea";

package/renderer.d.ts

@@ -255,8 +255,12 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     get hasSelection(): boolean;
     getSelectionContainer(): Renderable | null;
     clearSelection(): void;
-    private startSelection;
-    private updateSelection;
+    /**
+     * Start a new selection at the given coordinates.
+     * Used by both mouse and keyboard selection.
+     */
+    startSelection(renderable: Renderable, x: number, y: number): void;
+    updateSelection(currentRenderable: Renderable | undefined, x: number, y: number): void;
     requestSelectionUpdate(): void;
     private isWithinContainer;
     private finishSelection;

package/{lib/syntax-style.d.ts → syntax-style.d.ts}

@@ -1,4 +1,6 @@
-import { RGBA, type ColorInput } from "./RGBA";
+import { RGBA, type ColorInput } from "./lib/RGBA";
+import { type RenderLib } from "./zig";
+import { type Pointer } from "bun:ffi";
 export interface StyleDefinition {
     fg?: RGBA;
     bg?: RGBA;
@@ -25,12 +27,26 @@ export interface ThemeTokenStyle {
 }
 export declare function convertThemeToStyles(theme: ThemeTokenStyle[]): Record<string, StyleDefinition>;
 export declare class SyntaxStyle {
-    private styles;
-    private mergedStyleCache;
-    constructor(styles: Record<string, StyleDefinition>);
+    private lib;
+    private stylePtr;
+    private _destroyed;
+    private nameCache;
+    private styleDefs;
+    private mergedCache;
+    constructor(lib: RenderLib, ptr: Pointer);
+    static create(): SyntaxStyle;
     static fromTheme(theme: ThemeTokenStyle[]): SyntaxStyle;
-    mergeStyles(...styleNames: string[]): MergedStyle;
+    static fromStyles(styles: Record<string, StyleDefinition>): SyntaxStyle;
+    private guard;
+    registerStyle(name: string, style: StyleDefinition): number;
+    resolveStyleId(name: string): number | null;
+    getStyleId(name: string): number | null;
+    get ptr(): Pointer;
+    getStyleCount(): number;
+    clearNameCache(): void;
     getStyle(name: string): StyleDefinition | undefined;
+    mergeStyles(...styleNames: string[]): MergedStyle;
     clearCache(): void;
     getCacheSize(): number;
+    destroy(): void;
 }

package/testing/mock-keys.d.ts

@@ -52,17 +52,52 @@ export declare const KeyCodes: {
     readonly ALT_A: "\u001Ba";
     readonly ALT_B: "\u001Bb";
     readonly ALT_C: "\u001Bc";
+    readonly ALT_D: "\u001Bd";
+    readonly ALT_E: "\u001Be";
+    readonly ALT_F: "\u001Bf";
+    readonly ALT_G: "\u001Bg";
+    readonly ALT_H: "\u001Bh";
+    readonly ALT_I: "\u001Bi";
+    readonly ALT_J: "\u001Bj";
+    readonly ALT_K: "\u001Bk";
+    readonly ALT_L: "\u001Bl";
+    readonly ALT_M: "\u001Bm";
+    readonly ALT_N: "\u001Bn";
+    readonly ALT_O: "\u001Bo";
+    readonly ALT_P: "\u001Bp";
+    readonly ALT_Q: "\u001Bq";
+    readonly ALT_R: "\u001Br";
+    readonly ALT_S: "\u001Bs";
+    readonly ALT_T: "\u001Bt";
+    readonly ALT_U: "\u001Bu";
+    readonly ALT_V: "\u001Bv";
+    readonly ALT_W: "\u001Bw";
+    readonly ALT_X: "\u001Bx";
+    readonly ALT_Y: "\u001By";
+    readonly ALT_Z: "\u001Bz";
+    readonly ALT_LEFT: "\u001B\u001B[D";
+    readonly ALT_RIGHT: "\u001B\u001B[C";
+    readonly ALT_UP: "\u001B\u001B[A";
+    readonly ALT_DOWN: "\u001B\u001B[B";
 };
 export type KeyInput = string | keyof typeof KeyCodes;
 export declare function createMockKeys(renderer: CliRenderer): {
     pressKeys: (keys: KeyInput[], delayMs?: number) => Promise<void>;
-    pressKey: (key: KeyInput) => void;
+    pressKey: (key: KeyInput, modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+    }) => void;
     typeText: (text: string, delayMs?: number) => Promise<void>;
     pressEnter: () => void;
     pressEscape: () => void;
     pressTab: () => void;
     pressBackspace: () => void;
-    pressArrow: (direction: "up" | "down" | "left" | "right") => void;
+    pressArrow: (direction: "up" | "down" | "left" | "right", modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+    }) => void;
     pressCtrlC: () => void;
     pasteBracketedText: (text: string) => Promise<void>;
 };

package/testing.js

@@ -3,7 +3,7 @@ import {
   ANSI,
   CliRenderer,
   resolveRenderLib
-} from "./index-phjxdb6g.js";
+} from "./index-0qmm1k4p.js";
 
 // src/testing/mock-keys.ts
 var KeyCodes = {
@@ -59,7 +59,34 @@ var KeyCodes = {
   CTRL_Z: "\x1A",
   ALT_A: "\x1Ba",
   ALT_B: "\x1Bb",
-  ALT_C: "\x1Bc"
+  ALT_C: "\x1Bc",
+  ALT_D: "\x1Bd",
+  ALT_E: "\x1Be",
+  ALT_F: "\x1Bf",
+  ALT_G: "\x1Bg",
+  ALT_H: "\x1Bh",
+  ALT_I: "\x1Bi",
+  ALT_J: "\x1Bj",
+  ALT_K: "\x1Bk",
+  ALT_L: "\x1Bl",
+  ALT_M: "\x1Bm",
+  ALT_N: "\x1Bn",
+  ALT_O: "\x1Bo",
+  ALT_P: "\x1Bp",
+  ALT_Q: "\x1Bq",
+  ALT_R: "\x1Br",
+  ALT_S: "\x1Bs",
+  ALT_T: "\x1Bt",
+  ALT_U: "\x1Bu",
+  ALT_V: "\x1Bv",
+  ALT_W: "\x1Bw",
+  ALT_X: "\x1Bx",
+  ALT_Y: "\x1By",
+  ALT_Z: "\x1Bz",
+  ALT_LEFT: "\x1B\x1B[D",
+  ALT_RIGHT: "\x1B\x1B[C",
+  ALT_UP: "\x1B\x1B[A",
+  ALT_DOWN: "\x1B\x1B[B"
 };
 function createMockKeys(renderer) {
   const pressKeys = async (keys, delayMs = 0) => {
@@ -83,7 +110,7 @@ function createMockKeys(renderer) {
       }
     }
   };
-  const pressKey = (key) => {
+  const pressKey = (key, modifiers) => {
     let keyCode;
     if (typeof key === "string") {
       if (key in KeyCodes) {
@@ -97,6 +124,25 @@ function createMockKeys(renderer) {
         throw new Error(`Unknown key: ${key}`);
       }
     }
+    if (modifiers) {
+      if (keyCode.startsWith("\x1B[") && keyCode.length > 2) {
+        const modifier = 1 + (modifiers.shift ? 1 : 0) + (modifiers.meta ? 2 : 0) + (modifiers.ctrl ? 4 : 0);
+        if (modifier > 1) {
+          const ending = keyCode.slice(-1);
+          keyCode = `\x1B[1;${modifier}${ending}`;
+        }
+      } else if (keyCode.length === 1 && !modifiers.ctrl) {
+        let char = keyCode;
+        if (modifiers.shift && char >= "a" && char <= "z") {
+          char = char.toUpperCase();
+        }
+        if (modifiers.meta) {
+          keyCode = `\x1B${char}`;
+        } else {
+          keyCode = char;
+        }
+      }
+    }
     renderer.stdin.emit("data", Buffer.from(keyCode));
   };
   const typeText = async (text, delayMs = 0) => {
@@ -115,14 +161,14 @@ function createMockKeys(renderer) {
   const pressBackspace = () => {
     pressKey(KeyCodes.BACKSPACE);
   };
-  const pressArrow = (direction) => {
+  const pressArrow = (direction, modifiers) => {
     const keyMap = {
       up: KeyCodes.ARROW_UP,
       down: KeyCodes.ARROW_DOWN,
       left: KeyCodes.ARROW_LEFT,
       right: KeyCodes.ARROW_RIGHT
     };
-    pressKey(keyMap[direction]);
+    pressKey(keyMap[direction], modifiers);
   };
   const pressCtrlC = () => {
     pressKey(KeyCodes.CTRL_C);
@@ -364,5 +410,5 @@ export {
   KeyCodes
 };
 
-//# debugId=6748818851F0715164756E2164756E21
+//# debugId=4F737E7B09ACF94364756E2164756E21
 //# sourceMappingURL=testing.js.map