@opentui/core 0.1.0

package/post/filters.d.ts

@@ -0,0 +1,105 @@
+import type { OptimizedBuffer } from "../buffer";
+/**
+ * Applies a scanline effect by darkening every nth row.
+ */
+export declare function applyScanlines(buffer: OptimizedBuffer, strength?: number, step?: number): void;
+/**
+ * Converts the buffer colors to grayscale.
+ */
+export declare function applyGrayscale(buffer: OptimizedBuffer): void;
+/**
+ * Applies a sepia tone to the buffer.
+ */
+export declare function applySepia(buffer: OptimizedBuffer): void;
+/**
+ * Inverts the colors in the buffer.
+ */
+export declare function applyInvert(buffer: OptimizedBuffer): void;
+/**
+ * Adds random noise to the buffer colors.
+ */
+export declare function applyNoise(buffer: OptimizedBuffer, strength?: number): void;
+/**
+ * Applies a simplified chromatic aberration effect.
+ */
+export declare function applyChromaticAberration(buffer: OptimizedBuffer, strength?: number): void;
+/**
+ * Converts the buffer to ASCII art based on background brightness.
+ */
+export declare function applyAsciiArt(buffer: OptimizedBuffer, ramp?: string): void;
+export declare class DistortionEffect {
+    glitchChancePerSecond: number;
+    maxGlitchLines: number;
+    minGlitchDuration: number;
+    maxGlitchDuration: number;
+    maxShiftAmount: number;
+    shiftFlipRatio: number;
+    colorGlitchChance: number;
+    private lastGlitchTime;
+    private glitchDuration;
+    private activeGlitches;
+    constructor(options?: Partial<DistortionEffect>);
+    /**
+     * Applies the animated distortion/glitch effect to the buffer.
+     */
+    apply(buffer: OptimizedBuffer, deltaTime: number): void;
+}
+/**
+ * Applies a vignette effect by darkening the corners, optimized with precomputation.
+ */
+export declare class VignetteEffect {
+    private _strength;
+    private precomputedBaseAttenuation;
+    private cachedWidth;
+    private cachedHeight;
+    constructor(strength?: number);
+    set strength(newStrength: number);
+    get strength(): number;
+    private _computeFactors;
+    /**
+     * Applies the vignette effect using precomputed base attenuation and current strength.
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Adjusts the overall brightness of the buffer.
+ */
+export declare class BrightnessEffect {
+    private _brightness;
+    constructor(brightness?: number);
+    set brightness(newBrightness: number);
+    get brightness(): number;
+    /**
+     * Applies the brightness adjustment to the buffer.
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Applies a simple box blur. (Expensive and may look bad with text).
+ */
+export declare class BlurEffect {
+    private _radius;
+    constructor(radius?: number);
+    set radius(newRadius: number);
+    get radius(): number;
+    /**
+     * Applies an optimized separable box blur using a moving average (sliding window).
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Applies a bloom effect based on bright areas (Simplified).
+ */
+export declare class BloomEffect {
+    private _threshold;
+    private _strength;
+    private _radius;
+    constructor(threshold?: number, strength?: number, radius?: number);
+    set threshold(newThreshold: number);
+    get threshold(): number;
+    set strength(newStrength: number);
+    get strength(): number;
+    set radius(newRadius: number);
+    get radius(): number;
+    apply(buffer: OptimizedBuffer): void;
+}

package/renderables/ASCIIFont.d.ts

@@ -0,0 +1,40 @@
+import type { RenderableOptions } from "../Renderable";
+import { RGBA, type SelectionState } from "../types";
+import { type fonts } from "../lib/ascii.font";
+import { FrameBufferRenderable } from "./FrameBuffer";
+export interface ASCIIFontOptions extends RenderableOptions {
+    text: string;
+    font?: "tiny" | "block" | "shade" | "slick";
+    fg?: RGBA | RGBA[];
+    bg?: RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+}
+export declare class ASCIIFontRenderable extends FrameBufferRenderable {
+    selectable: boolean;
+    private _text;
+    private _font;
+    private _fg;
+    private _bg;
+    private _selectionBg;
+    private _selectionFg;
+    private selectionHelper;
+    constructor(id: string, options: ASCIIFontOptions);
+    get text(): string;
+    set text(value: string);
+    get font(): keyof typeof fonts;
+    set font(value: keyof typeof fonts);
+    get fg(): RGBA[];
+    set fg(value: RGBA | RGBA[] | string | string[]);
+    get bg(): RGBA;
+    set bg(value: RGBA | string);
+    private updateDimensions;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: SelectionState | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    protected onResize(width: number, height: number): void;
+    private renderFontToBuffer;
+    private renderSelectionHighlight;
+}

package/renderables/Box.d.ts

@@ -0,0 +1,45 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import type { OptimizedBuffer } from "../buffer";
+import { RGBA } from "../types";
+import { type BorderStyle, type BorderSides, type BorderCharacters, type BorderSidesConfig } from "../lib";
+import type { ColorInput } from "../types";
+export interface BoxOptions extends RenderableOptions {
+    bg?: string | RGBA;
+    borderStyle?: BorderStyle;
+    border?: boolean | BorderSides[];
+    borderColor?: string | RGBA;
+    customBorderChars?: BorderCharacters;
+    shouldFill?: boolean;
+    title?: string;
+    titleAlignment?: "left" | "center" | "right";
+    focusedBorderColor?: ColorInput;
+}
+export declare class BoxRenderable extends Renderable {
+    protected _bg: RGBA;
+    protected _border: boolean | BorderSides[];
+    protected _borderStyle: BorderStyle;
+    protected _borderColor: RGBA;
+    protected _focusedBorderColor: RGBA;
+    protected customBorderChars?: Uint32Array;
+    protected borderSides: BorderSidesConfig;
+    shouldFill: boolean;
+    protected _title?: string;
+    protected _titleAlignment: "left" | "center" | "right";
+    constructor(id: string, options: BoxOptions);
+    get bg(): RGBA;
+    set bg(value: RGBA | string | undefined);
+    get border(): boolean | BorderSides[];
+    set border(value: boolean | BorderSides[]);
+    get borderStyle(): BorderStyle;
+    set borderStyle(value: BorderStyle);
+    get borderColor(): RGBA;
+    set borderColor(value: RGBA | string);
+    get focusedBorderColor(): RGBA;
+    set focusedBorderColor(value: RGBA | string);
+    get title(): string | undefined;
+    set title(value: string | undefined);
+    get titleAlignment(): "left" | "center" | "right";
+    set titleAlignment(value: "left" | "center" | "right");
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private applyYogaBorders;
+}

package/renderables/FrameBuffer.d.ts

@@ -0,0 +1,15 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+export interface FrameBufferOptions extends RenderableOptions {
+    width: number;
+    height: number;
+    respectAlpha?: boolean;
+}
+export declare class FrameBufferRenderable extends Renderable {
+    frameBuffer: OptimizedBuffer;
+    protected respectAlpha: boolean;
+    constructor(id: string, options: FrameBufferOptions);
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+}

package/renderables/Group.d.ts

@@ -0,0 +1,4 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+export declare class GroupRenderable extends Renderable {
+    constructor(id: string, options: RenderableOptions);
+}

package/renderables/Input.d.ts

@@ -0,0 +1,52 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import type { ColorInput } from "../types";
+import type { ParsedKey } from "../lib/parse.keypress";
+export interface InputRenderableOptions extends RenderableOptions {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    placeholder?: string;
+    placeholderColor?: ColorInput;
+    cursorColor?: ColorInput;
+    maxLength?: number;
+    value?: string;
+}
+export declare enum InputRenderableEvents {
+    INPUT = "input",
+    CHANGE = "change",
+    ENTER = "enter"
+}
+export declare class InputRenderable extends Renderable {
+    protected focusable: boolean;
+    private value;
+    private cursorPosition;
+    private placeholder;
+    private backgroundColor;
+    private textColor;
+    private focusedBackgroundColor;
+    private focusedTextColor;
+    private placeholderColor;
+    private cursorColor;
+    private maxLength;
+    private lastCommittedValue;
+    constructor(id: string, options: InputRenderableOptions);
+    private updateCursorPosition;
+    focus(): void;
+    blur(): void;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    setValue(value: string): void;
+    getValue(): string;
+    getPlaceholder(): string;
+    setPlaceholder(placeholder: string): void;
+    getCursorPosition(): number;
+    setCursorPosition(position: number): void;
+    private insertText;
+    private deleteCharacter;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    getMaxLength(): number;
+    setMaxLength(maxLength: number): void;
+    protected destroySelf(): void;
+}

package/renderables/Select.d.ts

@@ -0,0 +1,74 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import type { ColorInput } from "../types";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { fonts } from "../lib/ascii.font";
+export interface SelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export interface SelectRenderableOptions extends RenderableOptions {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    options: SelectOption[];
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    descriptionColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollIndicator?: boolean;
+    wrapSelection?: boolean;
+    showDescription?: boolean;
+    font?: keyof typeof fonts;
+    itemSpacing?: number;
+    fastScrollStep?: number;
+}
+export declare enum SelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class SelectRenderable extends Renderable {
+    protected focusable: boolean;
+    private options;
+    private selectedIndex;
+    private scrollOffset;
+    private maxVisibleItems;
+    private backgroundColor;
+    private textColor;
+    private focusedBackgroundColor;
+    private focusedTextColor;
+    private selectedBackgroundColor;
+    private selectedTextColor;
+    private descriptionColor;
+    private selectedDescriptionColor;
+    private showScrollIndicator;
+    private wrapSelection;
+    private showDescription;
+    private font?;
+    private itemSpacing;
+    private linesPerItem;
+    private fontHeight;
+    private fastScrollStep;
+    constructor(id: string, options: SelectRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private renderScrollIndicatorToFrameBuffer;
+    setOptions(options: SelectOption[]): void;
+    getSelectedOption(): SelectOption | null;
+    getSelectedIndex(): number;
+    moveUp(steps?: number): void;
+    moveDown(steps?: number): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    getShowScrollIndicator(): boolean;
+    setShowScrollIndicator(show: boolean): void;
+    getShowDescription(): boolean;
+    setShowDescription(show: boolean): void;
+    getWrapSelection(): boolean;
+    setWrapSelection(wrap: boolean): void;
+}

package/renderables/TabSelect.d.ts

@@ -0,0 +1,74 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import type { ColorInput } from "../types";
+import type { ParsedKey } from "../lib/parse.keypress";
+export interface TabSelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export interface TabSelectRenderableOptions extends Omit<RenderableOptions, "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(id: string, 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;
+    setShowDescription(show: boolean): void;
+    getShowDescription(): boolean;
+    setShowUnderline(show: boolean): void;
+    getShowUnderline(): boolean;
+    setShowScrollArrows(show: boolean): void;
+    getShowScrollArrows(): boolean;
+    setWrapSelection(wrap: boolean): void;
+    getWrapSelection(): boolean;
+}

package/renderables/Text.d.ts

@@ -0,0 +1,46 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { StyledText } from "../lib/styled-text";
+import { RGBA, type SelectionState } from "../types";
+import type { OptimizedBuffer } from "../buffer";
+export interface TextOptions extends RenderableOptions {
+    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 selectionHelper;
+    private textBuffer;
+    private _plainText;
+    private _lineInfo;
+    constructor(id: string, options: TextOptions);
+    get content(): StyledText;
+    set content(value: StyledText | string);
+    get fg(): RGBA;
+    set fg(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 syncSelectionToTextBuffer;
+    private updateTextInfo;
+    private setupMeasureFunc;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: SelectionState | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    private updateTextBuffer;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    destroy(): void;
+}

package/renderables/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Box";
+export * from "./FrameBuffer";
+export * from "./Group";
+export * from "./Text";
+export * from "./ASCIIFont";
+export * from "./Input";
+export * from "./Select";
+export * from "./TabSelect";

package/renderer.d.ts

@@ -0,0 +1,208 @@
+import { Renderable, RootRenderable } from "./Renderable";
+import { type ColorInput, type CursorStyle, DebugOverlayCorner, RGBA } from "./types";
+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;
+    private _defaultPrevented;
+    get defaultPrevented(): boolean;
+    constructor(target: Renderable | null, attributes: RawMouseEvent & {
+        source?: Renderable;
+    });
+    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 {
+    private lib;
+    rendererPtr: Pointer;
+    private stdin;
+    private stdout;
+    private exitOnCtrlC;
+    private isDestroyed;
+    private isShuttingDown;
+    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 frameCallbacks;
+    private renderStats;
+    debugOverlay: {
+        enabled: boolean;
+        corner: DebugOverlayCorner;
+    };
+    private _console;
+    private _resolution;
+    private animationRequest;
+    private resizeTimeoutId;
+    private resizeDebounceDelay;
+    private renderContext;
+    private enableMouseMovement;
+    private _useMouse;
+    private _useAlternateScreen;
+    private capturedRenderable?;
+    private lastOverRenderableNum;
+    private lastOverRenderable?;
+    private currentSelection;
+    private selectionState;
+    private selectionContainers;
+    private _splitHeight;
+    private renderOffset;
+    private _terminalWidth;
+    private _terminalHeight;
+    private realStdoutWrite;
+    private captureCallback;
+    private _useConsole;
+    private mouseParser;
+    private sigwinchHandler;
+    constructor(lib: RenderLib, rendererPtr: Pointer, stdin: NodeJS.ReadStream, stdout: NodeJS.WriteStream, width: number, height: number, config?: CliRendererConfig);
+    private writeOut;
+    needsUpdate(): 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;
+    set experimental_splitHeight(splitHeight: number);
+    private interceptStdoutWrite;
+    private disableStdoutInterception;
+    private flushStdoutCache;
+    private enableMouse;
+    private disableMouse;
+    set useThread(useThread: boolean);
+    setTerminalSize(width: number, height: number): void;
+    private setupTerminal;
+    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;
+    dumpHitGrid(): void;
+    dumpBuffers(timestamp?: number): void;
+    dumpStdoutBuffer(timestamp?: number): void;
+    static setCursorPosition(x: number, y: number, visible?: boolean): void;
+    static setCursorStyle(style: CursorStyle, blinking?: boolean, color?: RGBA): void;
+    static setCursorColor(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;
+    start(): void;
+    pause(): void;
+    stop(): void;
+    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;
+    getSelectionContainer(): Renderable | null;
+    hasSelection(): boolean;
+    clearSelection(): void;
+    private startSelection;
+    private updateSelection;
+    private isWithinContainer;
+    private finishSelection;
+    private notifySelectablesOfSelectionChange;
+}