@opentui/core 0.1.14 → 0.1.15

package/lib/selection.d.ts

@@ -1,11 +1,15 @@
-import { Renderable } from "..";
-import type { SelectionState } from "../types";
+import { Renderable, type ViewportBounds } from "..";
 import { fonts } from "./ascii.font";
 export declare class Selection {
     private _anchor;
-    private _focus;
+    private _originalFocus;
+    private _normalizedAnchor;
+    private _normalizedFocus;
     private _selectedRenderables;
-    constructor(anchor: {
+    private _touchedRenderables;
+    private _isActive;
+    private _isSelecting;
+    constructor(anchorRenderable: Renderable, anchor: {
         x: number;
         y: number;
     }, focus: {
@@ -20,51 +24,40 @@ export declare class Selection {
         x: number;
         y: number;
     };
-    get bounds(): {
-        startX: number;
-        startY: number;
-        endX: number;
-        endY: number;
-    };
+    set focus(value: {
+        x: number;
+        y: number;
+    });
+    private _updateNormalizedSelection;
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    get isSelecting(): boolean;
+    set isSelecting(value: boolean);
+    get bounds(): ViewportBounds;
     updateSelectedRenderables(selectedRenderables: Renderable[]): void;
+    get selectedRenderables(): Renderable[];
+    updateTouchedRenderables(touchedRenderables: Renderable[]): void;
+    get touchedRenderables(): Renderable[];
     getSelectedText(): string;
 }
-export declare class TextSelectionHelper {
-    private getX;
-    private getY;
-    private getTextLength;
-    private getLineInfo?;
-    private localSelection;
-    private cachedGlobalSelection;
-    constructor(getX: () => number, getY: () => number, getTextLength: () => number, getLineInfo?: (() => {
-        lineStarts: number[];
-        lineWidths: number[];
-    }) | undefined);
-    hasSelection(): boolean;
-    getSelection(): {
-        start: number;
-        end: number;
-    } | null;
-    reevaluateSelection(width: number, height?: number): boolean;
-    shouldStartSelection(x: number, y: number, width: number, height: number): boolean;
-    onSelectionChanged(selection: SelectionState | null, width: number, height?: number): boolean;
-    private calculateSingleLineSelection;
-    private calculateMultiLineSelection;
+export interface LocalSelectionBounds {
+    anchorX: number;
+    anchorY: number;
+    focusX: number;
+    focusY: number;
+    isActive: boolean;
 }
+export declare function convertGlobalToLocalSelection(globalSelection: Selection | null, localX: number, localY: number): LocalSelectionBounds | null;
 export declare class ASCIIFontSelectionHelper {
-    private getX;
-    private getY;
     private getText;
     private getFont;
     private localSelection;
-    private cachedGlobalSelection;
-    constructor(getX: () => number, getY: () => number, getText: () => string, getFont: () => keyof typeof fonts);
+    constructor(getText: () => string, getFont: () => keyof typeof fonts);
     hasSelection(): boolean;
     getSelection(): {
         start: number;
         end: number;
     } | null;
-    shouldStartSelection(x: number, y: number, width: number, height: number): boolean;
-    onSelectionChanged(selection: SelectionState | null, width: number, height: number): boolean;
-    reevaluateSelection(width: number, height: number): boolean;
+    shouldStartSelection(localX: number, localY: number, width: number, height: number): boolean;
+    onLocalSelectionChanged(localSelection: LocalSelectionBounds | null, width: number, height: number): boolean;
 }

package/lib/styled-text.d.ts

@@ -14,11 +14,8 @@ export interface StyleAttrs {
 }
 export declare class StyledText {
     readonly chunks: TextChunk[];
-    private _plainText;
     constructor(chunks: TextChunk[]);
-    toString(): string;
     private static _createInstance;
-    private static _chunksToPlainText;
     insert(chunk: TextChunk, index?: number): StyledText;
     remove(chunk: TextChunk): StyledText;
     replace(chunk: TextChunk, oldChunk: TextChunk): StyledText;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -38,11 +38,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.14",
-    "@opentui/core-darwin-arm64": "0.1.14",
-    "@opentui/core-linux-x64": "0.1.14",
-    "@opentui/core-linux-arm64": "0.1.14",
-    "@opentui/core-win32-x64": "0.1.14",
-    "@opentui/core-win32-arm64": "0.1.14"
+    "@opentui/core-darwin-x64": "0.1.15",
+    "@opentui/core-darwin-arm64": "0.1.15",
+    "@opentui/core-linux-x64": "0.1.15",
+    "@opentui/core-linux-arm64": "0.1.15",
+    "@opentui/core-win32-x64": "0.1.15",
+    "@opentui/core-win32-arm64": "0.1.15"
   }
 }

package/renderables/ASCIIFont.d.ts

@@ -1,8 +1,9 @@
 import type { RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
 import { type fonts, type ASCIIFontName } from "../lib/ascii.font";
 import { RGBA } from "../lib/RGBA";
 import { FrameBufferRenderable } from "./FrameBuffer";
-import type { RenderContext, SelectionState } from "../types";
+import type { RenderContext } from "../types";
 export interface ASCIIFontOptions extends RenderableOptions<ASCIIFontRenderable> {
     text?: string;
     font?: ASCIIFontName;
@@ -20,6 +21,7 @@ export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     private _bg;
     private _selectionBg;
     private _selectionFg;
+    private lastLocalSelection;
     private selectionHelper;
     constructor(ctx: RenderContext, options: ASCIIFontOptions);
     get text(): string;
@@ -32,7 +34,7 @@ export declare class ASCIIFontRenderable extends FrameBufferRenderable {
     set bg(value: RGBA | string);
     private updateDimensions;
     shouldStartSelection(x: number, y: number): boolean;
-    onSelectionChanged(selection: SelectionState | null): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
     hasSelection(): boolean;
     protected onResize(width: number, height: number): void;

package/renderables/ScrollBar.d.ts

@@ -0,0 +1,77 @@
+import type { OptimizedBuffer } from "../buffer";
+import { RGBA, type ColorInput } from "../lib";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+import { SliderRenderable, type SliderOptions } from "./Slider";
+export interface ScrollBarOptions extends RenderableOptions<ScrollBarRenderable> {
+    orientation: "vertical" | "horizontal";
+    showArrows?: boolean;
+    arrowOptions?: Omit<ArrowOptions, "direction">;
+    trackOptions?: Partial<SliderOptions>;
+    onChange?: (position: number) => void;
+}
+export type ScrollUnit = "absolute" | "viewport" | "content" | "step";
+export declare class ScrollBarRenderable extends Renderable {
+    readonly slider: SliderRenderable;
+    readonly startArrow: ArrowRenderable;
+    readonly endArrow: ArrowRenderable;
+    readonly orientation: "vertical" | "horizontal";
+    protected focusable: boolean;
+    private _scrollSize;
+    private _scrollPosition;
+    private _viewportSize;
+    private _showArrows;
+    private _manualVisibility;
+    private _onChange;
+    scrollStep: number | undefined | null;
+    get visible(): boolean;
+    set visible(value: boolean);
+    resetVisibilityControl(): void;
+    get scrollSize(): number;
+    get scrollPosition(): number;
+    get viewportSize(): number;
+    set scrollSize(value: number);
+    set scrollPosition(value: number);
+    set viewportSize(value: number);
+    get showArrows(): boolean;
+    set showArrows(value: boolean);
+    constructor(ctx: RenderContext, { trackOptions, arrowOptions, orientation, showArrows, ...options }: ScrollBarOptions);
+    set arrowOptions(options: ScrollBarOptions["arrowOptions"]);
+    set trackOptions(options: ScrollBarOptions["trackOptions"]);
+    private updateSliderFromScrollState;
+    scrollBy(delta: number, unit?: ScrollUnit): void;
+    private recalculateVisibility;
+    handleKeyPress(key: ParsedKey | string): boolean;
+}
+export interface ArrowOptions extends RenderableOptions<ArrowRenderable> {
+    direction: "up" | "down" | "left" | "right";
+    foregroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+    attributes?: number;
+    arrowChars?: {
+        up?: string;
+        down?: string;
+        left?: string;
+        right?: string;
+    };
+}
+export declare class ArrowRenderable extends Renderable {
+    private _direction;
+    private _foregroundColor;
+    private _backgroundColor;
+    private _attributes;
+    private _arrowChars;
+    constructor(ctx: RenderContext, options: ArrowOptions);
+    get direction(): "up" | "down" | "left" | "right";
+    set direction(value: "up" | "down" | "left" | "right");
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get attributes(): number;
+    set attributes(value: number);
+    set arrowChars(value: ArrowOptions["arrowChars"]);
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private getArrowChar;
+}

package/renderables/ScrollBox.d.ts

@@ -0,0 +1,82 @@
+import { type ParsedKey } from "../lib";
+import type { Renderable, RenderableOptions } from "../Renderable";
+import type { MouseEvent } from "../renderer";
+import type { RenderContext } from "../types";
+import { BoxRenderable, type BoxOptions } from "./Box";
+import type { VNode } from "./composition/vnode";
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar";
+declare class ContentRenderable extends BoxRenderable {
+    private viewport;
+    constructor(ctx: RenderContext, viewport: BoxRenderable, options: RenderableOptions<BoxRenderable>);
+    protected _getChildren(): Renderable[];
+}
+export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {
+    rootOptions?: BoxOptions;
+    wrapperOptions?: BoxOptions;
+    viewportOptions?: BoxOptions;
+    contentOptions?: BoxOptions;
+    scrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    verticalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    horizontalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+}
+export declare class ScrollBoxRenderable extends BoxRenderable {
+    static idCounter: number;
+    private internalId;
+    readonly wrapper: BoxRenderable;
+    readonly viewport: BoxRenderable;
+    readonly content: ContentRenderable;
+    readonly horizontalScrollBar: ScrollBarRenderable;
+    readonly verticalScrollBar: ScrollBarRenderable;
+    protected focusable: boolean;
+    private selectionListener?;
+    private autoScrollMouseX;
+    private autoScrollMouseY;
+    private readonly autoScrollThresholdVertical;
+    private readonly autoScrollThresholdHorizontal;
+    private readonly autoScrollSpeedSlow;
+    private readonly autoScrollSpeedMedium;
+    private readonly autoScrollSpeedFast;
+    private isAutoScrolling;
+    private cachedAutoScrollSpeed;
+    private autoScrollAccumulatorX;
+    private autoScrollAccumulatorY;
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    constructor(ctx: RenderContext, { wrapperOptions, viewportOptions, contentOptions, rootOptions, scrollbarOptions, verticalScrollbarOptions, horizontalScrollbarOptions, ...options }: ScrollBoxOptions);
+    protected onUpdate(deltaTime: number): void;
+    scrollBy(delta: number | {
+        x: number;
+        y: number;
+    }, unit?: ScrollUnit): void;
+    scrollTo(position: number | {
+        x: number;
+        y: number;
+    }): void;
+    add(obj: Renderable | VNode<any, any[]>, index?: number): number;
+    remove(id: string): void;
+    getChildren(): Renderable[];
+    protected onMouseEvent(event: MouseEvent): void;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    startAutoScroll(mouseX: number, mouseY: number): void;
+    updateAutoScroll(mouseX: number, mouseY: number): void;
+    stopAutoScroll(): void;
+    private hasOtherLiveReasons;
+    private handleAutoScroll;
+    private getAutoScrollDirectionX;
+    private getAutoScrollDirectionY;
+    private getAutoScrollSpeed;
+    private recalculateBarProps;
+    set rootOptions(options: ScrollBoxOptions["rootOptions"]);
+    set wrapperOptions(options: ScrollBoxOptions["wrapperOptions"]);
+    set viewportOptions(options: ScrollBoxOptions["viewportOptions"]);
+    set contentOptions(options: ScrollBoxOptions["contentOptions"]);
+    set scrollbarOptions(options: ScrollBoxOptions["scrollbarOptions"]);
+    set verticalScrollbarOptions(options: ScrollBoxOptions["verticalScrollbarOptions"]);
+    set horizontalScrollbarOptions(options: ScrollBoxOptions["horizontalScrollbarOptions"]);
+    protected destroySelf(): void;
+}
+export {};

package/renderables/Slider.d.ts

@@ -0,0 +1,31 @@
+import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    thumbSize?: number;
+    thumbPosition?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (position: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _thumbSize;
+    private _thumbPosition;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get thumbSize(): number;
+    set thumbSize(value: number);
+    get thumbPosition(): number;
+    set thumbPosition(value: number);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private setupMouseHandling;
+    private updatePositionFromMouse;
+    private getThumbPosition;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+}

package/renderables/Text.d.ts

@@ -1,7 +1,8 @@
 import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
 import { StyledText } from "../lib/styled-text";
 import { RGBA } from "../lib/RGBA";
-import { type SelectionState, type RenderContext } from "../types";
+import { type RenderContext } from "../types";
 import type { OptimizedBuffer } from "../buffer";
 export interface TextOptions extends RenderableOptions<TextRenderable> {
     content?: StyledText | string;
@@ -20,9 +21,8 @@ export declare class TextRenderable extends Renderable {
     private _defaultAttributes;
     private _selectionBg;
     private _selectionFg;
-    private selectionHelper;
+    private lastLocalSelection;
     private textBuffer;
-    private _plainText;
     private _lineInfo;
     protected _defaultOptions: {
         content: string;
@@ -47,13 +47,17 @@ export declare class TextRenderable extends Renderable {
     get attributes(): number;
     set attributes(value: number);
     protected onResize(width: number, height: number): void;
-    private syncSelectionToTextBuffer;
+    private updateLocalSelection;
     private updateTextInfo;
     private setupMeasureFunc;
     shouldStartSelection(x: number, y: number): boolean;
-    onSelectionChanged(selection: SelectionState | null): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
     getSelectedText(): string;
     hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
     private updateTextBuffer;
     protected renderSelf(buffer: OptimizedBuffer): void;
     destroy(): void;

package/renderables/index.d.ts

@@ -5,6 +5,8 @@ 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

@@ -43,12 +43,14 @@ export declare class MouseEvent {
     };
     readonly scroll?: ScrollInfo;
     readonly target: Renderable | null;
-    private _defaultPrevented;
-    get defaultPrevented(): boolean;
+    readonly isSelecting?: boolean;
+    private _propagationStopped;
+    get propagationStopped(): boolean;
     constructor(target: Renderable | null, attributes: RawMouseEvent & {
         source?: Renderable;
+        isSelecting?: boolean;
     });
-    preventDefault(): void;
+    stopPropagation(): void;
 }
 export declare enum MouseButton {
     LEFT = 0,
@@ -116,7 +118,6 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     private lastOverRenderableNum;
     private lastOverRenderable?;
     private currentSelection;
-    private selectionState;
     private selectionContainers;
     private _splitHeight;
     private renderOffset;
@@ -214,12 +215,14 @@ export declare class CliRenderer extends EventEmitter implements RenderContext {
     resetStats(): void;
     setGatherStats(enabled: boolean): void;
     getSelection(): Selection | null;
+    get hasSelection(): boolean;
     getSelectionContainer(): Renderable | null;
-    hasSelection(): boolean;
     clearSelection(): void;
     private startSelection;
     private updateSelection;
+    requestSelectionUpdate(): void;
     private isWithinContainer;
     private finishSelection;
     private notifySelectablesOfSelectionChange;
+    private walkSelectableRenderables;
 }

package/text-buffer.d.ts

@@ -14,18 +14,11 @@ export interface TextChunk {
 export declare class TextBuffer {
     private lib;
     private bufferPtr;
-    private buffer;
     private _length;
     private _capacity;
     private _lineInfo?;
-    constructor(lib: RenderLib, ptr: Pointer, buffer: {
-        char: Uint32Array;
-        fg: Float32Array;
-        bg: Float32Array;
-        attributes: Uint16Array;
-    }, capacity: number);
+    constructor(lib: RenderLib, ptr: Pointer, capacity: number);
     static create(capacity: number | undefined, widthMethod: WidthMethod): TextBuffer;
-    private syncBuffersAfterResize;
     setStyledText(text: StyledText): void;
     setDefaultFg(fg: RGBA | null): void;
     setDefaultBg(bg: RGBA | null): void;
@@ -34,13 +27,19 @@ export declare class TextBuffer {
     get length(): number;
     get capacity(): number;
     get ptr(): Pointer;
+    getSelectedText(): string;
     get lineInfo(): {
         lineStarts: number[];
         lineWidths: number[];
     };
-    toString(): string;
-    concat(other: TextBuffer): TextBuffer;
     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;
     destroy(): void;
 }

package/types.d.ts

@@ -1,4 +1,6 @@
 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;
@@ -18,7 +20,18 @@ export declare enum DebugOverlayCorner {
     bottomRight = 3
 }
 export type WidthMethod = "wcwidth" | "unicode";
-export interface RenderContext {
+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;
@@ -30,16 +43,14 @@ export interface RenderContext {
     capabilities: any | null;
     requestLive: () => void;
     dropLive: () => void;
+    hasSelection: boolean;
+    getSelection: () => Selection | null;
+    requestSelectionUpdate: () => void;
 }
-export interface SelectionState {
-    anchor: {
-        x: number;
-        y: number;
-    };
-    focus: {
-        x: number;
-        y: number;
-    };
-    isActive: boolean;
-    isSelecting: boolean;
+export type Timeout = ReturnType<typeof setTimeout> | undefined;
+export interface ViewportBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
 }

package/zig.d.ts

@@ -35,16 +35,12 @@ export interface RenderLib {
     bufferGetId: (buffer: Pointer) => string;
     bufferDrawText: (buffer: Pointer, text: string, x: number, y: number, color: RGBA, bgColor?: RGBA, attributes?: number) => void;
     bufferSetCellWithAlphaBlending: (buffer: Pointer, x: number, y: number, char: string, color: RGBA, bgColor: RGBA, attributes?: number) => void;
+    bufferSetCell: (buffer: Pointer, x: number, y: number, char: string, color: RGBA, bgColor: RGBA, attributes?: number) => void;
     bufferFillRect: (buffer: Pointer, x: number, y: number, width: number, height: number, color: RGBA) => void;
     bufferDrawSuperSampleBuffer: (buffer: Pointer, x: number, y: number, pixelDataPtr: Pointer, pixelDataLength: number, format: "bgra8unorm" | "rgba8unorm", alignedBytesPerRow: number) => void;
     bufferDrawPackedBuffer: (buffer: Pointer, dataPtr: Pointer, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number) => void;
     bufferDrawBox: (buffer: Pointer, x: number, y: number, width: number, height: number, borderChars: Uint32Array, packedOptions: number, borderColor: RGBA, backgroundColor: RGBA, title: string | null) => void;
-    bufferResize: (buffer: Pointer, width: number, height: number) => {
-        char: Uint32Array;
-        fg: Float32Array;
-        bg: Float32Array;
-        attributes: Uint8Array;
-    };
+    bufferResize: (buffer: Pointer, width: number, height: number) => void;
     resizeRenderer: (renderer: Pointer, width: number, height: number) => void;
     setCursorPosition: (renderer: Pointer, x: number, y: number, visible: boolean) => void;
     setCursorStyle: (renderer: Pointer, style: CursorStyle, blinking: boolean) => void;
@@ -65,21 +61,13 @@ export interface RenderLib {
     createTextBuffer: (capacity: number, widthMethod: WidthMethod) => TextBuffer;
     destroyTextBuffer: (buffer: Pointer) => void;
     textBufferGetCharPtr: (buffer: Pointer) => Pointer;
-    textBufferGetFgPtr: (buffer: Pointer) => Pointer;
-    textBufferGetBgPtr: (buffer: Pointer) => Pointer;
-    textBufferGetAttributesPtr: (buffer: Pointer) => Pointer;
     textBufferGetLength: (buffer: Pointer) => number;
-    textBufferSetCell: (buffer: Pointer, index: number, char: number, fg: Float32Array, bg: Float32Array, attr: number) => void;
-    textBufferConcat: (buffer1: Pointer, buffer2: Pointer) => TextBuffer;
-    textBufferResize: (buffer: Pointer, newLength: number) => {
-        char: Uint32Array;
-        fg: Float32Array;
-        bg: Float32Array;
-        attributes: Uint16Array;
-    };
+    textBufferResize: (buffer: Pointer, newLength: number) => void;
     textBufferReset: (buffer: Pointer) => void;
     textBufferSetSelection: (buffer: Pointer, start: number, end: number, bgColor: RGBA | null, fgColor: RGBA | null) => void;
     textBufferResetSelection: (buffer: Pointer) => void;
+    textBufferSetLocalSelection: (buffer: Pointer, anchorX: number, anchorY: number, focusX: number, focusY: number, bgColor: RGBA | null, fgColor: RGBA | null) => boolean;
+    textBufferResetLocalSelection: (buffer: Pointer) => void;
     textBufferSetDefaultFg: (buffer: Pointer, fg: RGBA | null) => void;
     textBufferSetDefaultBg: (buffer: Pointer, bg: RGBA | null) => void;
     textBufferSetDefaultAttributes: (buffer: Pointer, attributes: number | null) => void;
@@ -87,16 +75,18 @@ export interface RenderLib {
     textBufferWriteChunk: (buffer: Pointer, textBytes: Uint8Array, fg: RGBA | null, bg: RGBA | null, attributes: number | null) => number;
     textBufferGetCapacity: (buffer: Pointer) => number;
     textBufferFinalizeLineInfo: (buffer: Pointer) => void;
+    textBufferGetLineCount: (buffer: Pointer) => number;
+    textBufferGetLineInfoDirect: (buffer: Pointer, lineStartsPtr: Pointer, lineWidthsPtr: Pointer) => void;
     textBufferGetLineInfo: (buffer: Pointer) => {
         lineStarts: number[];
         lineWidths: number[];
     };
-    getTextBufferArrays: (buffer: Pointer, size: number) => {
-        char: Uint32Array;
-        fg: Float32Array;
-        bg: Float32Array;
-        attributes: Uint16Array;
-    };
+    textBufferGetSelection: (buffer: Pointer) => {
+        start: number;
+        end: number;
+    } | null;
+    getSelectedTextBytes: (buffer: Pointer, maxLength: number) => Uint8Array | null;
+    readonly decoder: TextDecoder;
     bufferDrawTextBuffer: (buffer: Pointer, textBuffer: Pointer, x: number, y: number, clipRect?: {
         x: number;
         y: number;