@xincli/opentui-core 0.4.6 → 0.4.7

package/renderables/Markdown.d.ts

@@ -0,0 +1,255 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { type RenderContext } from "../types.js";
+import { SyntaxStyle } from "../syntax-style.js";
+import type { BorderStyle } from "../lib/border.js";
+import { RGBA, type ColorInput } from "../lib/RGBA.js";
+import { type MarkedToken, type Token, type Tokens } from "marked";
+import { type TextTableColumnFitter, type TextTableColumnWidthMode, type TextTableContent } from "./TextTable.js";
+import type { TreeSitterClient } from "../lib/tree-sitter/index.js";
+import { type ParseState } from "./markdown-parser.js";
+import type { OptimizedBuffer } from "../buffer.js";
+export type MarkdownTableStyle = "grid" | "columns";
+export interface MarkdownTableOptions {
+    /**
+     * Visual style preset for markdown tables.
+     * - "grid": boxed table with visible borders.
+     * - "columns": borderless columns optimized for separated block output.
+     *
+     * Defaults to "columns" in `internalBlockMode: "top-level"`, otherwise "grid".
+     */
+    style?: MarkdownTableStyle;
+    /**
+     * Strategy for sizing table columns.
+     * - "content": columns fit to intrinsic content width.
+     * - "full": columns expand to fill available width.
+     */
+    widthMode?: TextTableColumnWidthMode;
+    /**
+     * Column fitting method when shrinking constrained tables.
+     */
+    columnFitter?: TextTableColumnFitter;
+    /**
+     * Wrapping strategy for table cell content.
+     */
+    wrapMode?: "none" | "char" | "word";
+    /**
+     * Padding applied on all sides of each table cell.
+     */
+    cellPadding?: number;
+    /**
+     * Horizontal padding applied on the left and right of each table cell.
+     */
+    cellPaddingX?: number;
+    /**
+     * Vertical padding applied above and below each table cell.
+     */
+    cellPaddingY?: number;
+    /**
+     * Enables/disables table border rendering.
+     */
+    borders?: boolean;
+    /**
+     * Overrides outer border visibility. Defaults to `borders`.
+     */
+    outerBorder?: boolean;
+    /**
+     * Border style for markdown tables.
+     */
+    borderStyle?: BorderStyle;
+    /**
+     * Border color for markdown tables. Defaults to conceal style color.
+     */
+    borderColor?: ColorInput;
+    /**
+     * Enables/disables selection support on markdown tables.
+     */
+    selectable?: boolean;
+}
+export interface MarkdownOptions extends RenderableOptions<MarkdownRenderable> {
+    content?: string;
+    syntaxStyle: SyntaxStyle;
+    fg?: ColorInput;
+    bg?: ColorInput;
+    /** Controls concealment for markdown syntax markers in markdown text blocks. */
+    conceal?: boolean;
+    /** Controls concealment inside fenced code blocks rendered by CodeRenderable. */
+    concealCode?: boolean;
+    treeSitterClient?: TreeSitterClient;
+    /**
+     * Enable streaming mode for incremental content updates.
+     *
+     * Semantics:
+     * - The trailing markdown block stays unstable while streaming is enabled.
+     * - Tables render all rows produced by the markdown parser (including trailing rows).
+     * - Incomplete table rows are normalized by the parser and rendered with empty cells
+     *   where data is missing.
+     *
+     * Expectations:
+     * - Keep this true while chunks are still being appended.
+     * - Set this to false once streaming is complete to finalize trailing token parsing.
+     */
+    streaming?: boolean;
+    /**
+     * Options for internally rendered markdown tables.
+     */
+    tableOptions?: MarkdownTableOptions;
+    /**
+     * Custom node renderer. Return a Renderable to override default rendering,
+     * or undefined/null to use default rendering.
+     */
+    renderNode?: (token: Token, context: RenderNodeContext) => Renderable | undefined | null;
+    /**
+     * Internal only.
+     * - "coalesced": combine ordinary markdown into larger render blocks.
+     * - "top-level": preserve top-level markdown blocks as separate render blocks.
+     */
+    internalBlockMode?: "coalesced" | "top-level";
+}
+export interface RenderNodeContext {
+    syntaxStyle: SyntaxStyle;
+    conceal: boolean;
+    concealCode: boolean;
+    treeSitterClient?: TreeSitterClient;
+    /** Creates default renderable for this token */
+    defaultRender: () => Renderable | null;
+}
+export type MarkdownCodeBlockRenderer = (token: Tokens.Code, context: RenderNodeContext) => Renderable | undefined | null;
+export type MarkdownCodeBlockRendererMap = ReadonlyMap<string, MarkdownCodeBlockRenderer> | Readonly<Record<string, MarkdownCodeBlockRenderer>>;
+export declare function createMarkdownCodeBlockRenderer(renderers: MarkdownCodeBlockRendererMap): MarkdownOptions["renderNode"];
+interface TableContentCache {
+    content: TextTableContent;
+    cellKeys: Uint32Array[];
+}
+export interface BlockState {
+    token: MarkedToken;
+    tokenRaw: string;
+    marginTop?: number;
+    renderable: Renderable;
+    tableContentCache?: TableContentCache;
+    tracksInterBlockMargin?: boolean;
+    /** Whether built-in reconciliation can update this renderable without replacing it. */
+    canUpdateInPlace: boolean;
+}
+export type { ParseState };
+export declare class MarkdownRenderable extends Renderable {
+    private _content;
+    private _syntaxStyle;
+    private _fg?;
+    private _bg?;
+    private _conceal;
+    private _concealCode;
+    private _treeSitterClient?;
+    private _tableOptions?;
+    private _renderNode?;
+    private _internalBlockMode;
+    _parseState: ParseState | null;
+    private _streaming;
+    _blockStates: BlockState[];
+    _stableBlockCount: number;
+    private _styleDirty;
+    private _linkifyMarkdownChunks;
+    protected _contentDefaultOptions: {
+        content: string;
+        conceal: true;
+        concealCode: false;
+        streaming: false;
+        internalBlockMode: "coalesced";
+    };
+    constructor(ctx: RenderContext, options: MarkdownOptions);
+    get content(): string;
+    set content(value: string);
+    get syntaxStyle(): SyntaxStyle;
+    set syntaxStyle(value: SyntaxStyle);
+    get fg(): RGBA | undefined;
+    set fg(value: ColorInput | undefined);
+    get bg(): RGBA | undefined;
+    set bg(value: ColorInput | undefined);
+    get conceal(): boolean;
+    set conceal(value: boolean);
+    get concealCode(): boolean;
+    set concealCode(value: boolean);
+    get streaming(): boolean;
+    set streaming(value: boolean);
+    get tableOptions(): MarkdownTableOptions | undefined;
+    set tableOptions(value: MarkdownTableOptions | undefined);
+    get renderNode(): MarkdownOptions["renderNode"] | undefined;
+    set renderNode(value: MarkdownOptions["renderNode"] | undefined);
+    get internalBlockMode(): "coalesced" | "top-level";
+    set internalBlockMode(value: "coalesced" | "top-level");
+    private getStyle;
+    private createChunk;
+    private createDefaultChunk;
+    private createInitialStyledText;
+    private renderInlineContent;
+    private renderInlineToken;
+    private renderInlineTokenWithStyle;
+    private applyMargins;
+    private createMarkdownCodeRenderable;
+    private getBlockquoteContent;
+    private getBlockquoteBorderColor;
+    private createBlockquoteRenderable;
+    private createListRenderable;
+    private getListItemInputs;
+    private applyListRenderable;
+    private createListItemRenderable;
+    private applyListItemRenderable;
+    private applyListItemChildren;
+    private getRenderableListItemTokens;
+    private applyListChildRenderable;
+    private destroyListItemChildrenAfter;
+    private applyListItemMarker;
+    private createListChildRenderable;
+    private createHorizontalRuleRenderable;
+    private createCodeRenderable;
+    private applyMarkdownCodeRenderable;
+    private applyBlockquoteRenderable;
+    private applyCodeBlockRenderable;
+    private shouldRenderSeparately;
+    private getInterBlockMargin;
+    private applyInterBlockMargin;
+    private createMarkdownBlockToken;
+    private normalizeMarkdownBlockRaw;
+    private normalizeScrollbackMarkdownBlockRaw;
+    private isCodeBlockOnlyRenderer;
+    private buildRenderableTokens;
+    private buildTopLevelRenderBlocks;
+    private shouldAddTopLevelMargin;
+    private isSeparatedTopLevelBlock;
+    private getTableRowsToRender;
+    private hashString;
+    private hashTableToken;
+    private getTableCellKey;
+    private createTableDataCellChunks;
+    private createTableHeaderCellChunks;
+    private buildTableContentCache;
+    private resolveTableStyle;
+    private usesBorderlessColumnSpacing;
+    private resolveTableRenderableOptions;
+    private applyTableRenderableOptions;
+    private applyTableOptionsToBlocks;
+    private createTextTableRenderable;
+    private createTableBlock;
+    private getStableBlockCount;
+    private syncTopLevelBlockState;
+    private getTopLevelBlockRaw;
+    private createTopLevelDefaultRenderable;
+    private createTopLevelRenderable;
+    private createDefaultRenderable;
+    private createCustomRenderable;
+    private createTopLevelCustomRenderable;
+    private renderCustomNode;
+    private destroyUnusedDefaultRenderable;
+    private updateBlockRenderable;
+    private updateTopLevelBlocks;
+    private canUpdateBlockRenderable;
+    private updateBlocks;
+    private clearBlockStates;
+    /**
+     * Re-render existing blocks without rebuilding the parse state or block structure.
+     * Used when only style/conceal changes - much faster than full rebuild.
+     */
+    private rerenderBlocks;
+    clearCache(): void;
+    refreshStyles(): void;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+}

package/renderables/ScrollBar.d.ts

@@ -0,0 +1,77 @@
+import type { OptimizedBuffer } from "../buffer.js";
+import { RGBA, type ColorInput } from "../lib/index.js";
+import type { KeyEvent } from "../lib/KeyHandler.js";
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { SliderRenderable, type SliderOptions } from "./Slider.js";
+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: KeyEvent): 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,128 @@
+import { type KeyEvent } from "../lib/index.js";
+import { type ScrollAcceleration } from "../lib/scroll-acceleration.js";
+import type { BaseRenderable, Renderable, RenderableOptions } from "../Renderable.js";
+import type { MouseEvent } from "../renderer.js";
+import type { RenderContext } from "../types.js";
+import { BoxRenderable, type BoxOptions } from "./Box.js";
+import type { VNode } from "./composition/vnode.js";
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar.js";
+declare class ContentRenderable extends BoxRenderable {
+    private viewport;
+    private _viewportCulling;
+    constructor(ctx: RenderContext, viewport: BoxRenderable, viewportCulling: boolean, options: RenderableOptions<BoxRenderable>);
+    get viewportCulling(): boolean;
+    set viewportCulling(value: boolean);
+    protected _hasVisibleChildFilter(): boolean;
+    protected _getVisibleChildren(): number[];
+}
+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">;
+    stickyScroll?: boolean;
+    stickyStart?: "bottom" | "top" | "left" | "right";
+    scrollX?: boolean;
+    scrollY?: boolean;
+    scrollAcceleration?: ScrollAcceleration;
+    viewportCulling?: boolean;
+}
+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;
+    private scrollAccumulatorX;
+    private scrollAccumulatorY;
+    private _stickyScroll;
+    private _stickyScrollTop;
+    private _stickyScrollBottom;
+    private _stickyScrollLeft;
+    private _stickyScrollRight;
+    private _stickyStart?;
+    private _hasManualScroll;
+    private _isApplyingStickyScroll;
+    private scrollAccel;
+    get stickyScroll(): boolean;
+    set stickyScroll(value: boolean);
+    get stickyStart(): "bottom" | "top" | "left" | "right" | undefined;
+    set stickyStart(value: "bottom" | "top" | "left" | "right" | undefined);
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    private updateStickyState;
+    private syncManualScrollState;
+    private applyStickyStart;
+    constructor(ctx: RenderContext, options: ScrollBoxOptions);
+    protected onUpdate(deltaTime: number): void;
+    scrollBy(delta: number | {
+        x: number;
+        y: number;
+    }, unit?: ScrollUnit): void;
+    scrollChildIntoView(childId: string): void;
+    scrollTo(position: number | {
+        x: number;
+        y: number;
+    }): void;
+    private isAtStickyPosition;
+    private isAtStickyReengagePoint;
+    add(obj: Renderable | VNode<any, any[]>, index?: number): number;
+    insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number;
+    remove(child: BaseRenderable): void;
+    getChildren(): Renderable[];
+    getRenderable(id: string): Renderable | undefined;
+    protected onMouseEvent(event: MouseEvent): void;
+    handleKeyPress(key: KeyEvent): boolean;
+    private resetScrollAccumulators;
+    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 padding(value: number | `${number}%` | null | undefined);
+    set paddingX(value: number | `${number}%` | null | undefined);
+    set paddingY(value: number | `${number}%` | null | undefined);
+    set paddingTop(value: number | `${number}%` | null | undefined);
+    set paddingRight(value: number | `${number}%` | null | undefined);
+    set paddingBottom(value: number | `${number}%` | null | undefined);
+    set paddingLeft(value: number | `${number}%` | null | undefined);
+    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"]);
+    get scrollAcceleration(): ScrollAcceleration;
+    set scrollAcceleration(value: ScrollAcceleration);
+    get viewportCulling(): boolean;
+    set viewportCulling(value: boolean);
+    protected destroySelf(): void;
+}
+export {};

package/renderables/Select.d.ts

@@ -0,0 +1,122 @@
+import { OptimizedBuffer } from "../buffer.js";
+import { fonts } from "../lib/ascii.font.js";
+import type { KeyEvent } from "../lib/KeyHandler.js";
+import { type ColorInput } from "../lib/RGBA.js";
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { type KeyBinding as BaseKeyBinding } from "../lib/keybinding.internal.js";
+type KeyAliasMap = Record<string, string>;
+export interface SelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export type SelectAction = "move-up" | "move-down" | "move-up-fast" | "move-down-fast" | "select-current";
+export type SelectKeyBinding = BaseKeyBinding<SelectAction>;
+export interface SelectRenderableOptions extends RenderableOptions<SelectRenderable> {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    options?: SelectOption[];
+    selectedIndex?: number;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    descriptionColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollIndicator?: boolean;
+    wrapSelection?: boolean;
+    showDescription?: boolean;
+    showSelectionIndicator?: boolean;
+    font?: keyof typeof fonts;
+    itemSpacing?: number;
+    fastScrollStep?: number;
+    keyBindings?: SelectKeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+}
+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 _showSelectionIndicator;
+    private _font?;
+    private _itemSpacing;
+    private linesPerItem;
+    private fontHeight;
+    private _fastScrollStep;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    protected _defaultOptions: {
+        backgroundColor: string;
+        textColor: string;
+        focusedBackgroundColor: string;
+        focusedTextColor: string;
+        selectedBackgroundColor: string;
+        selectedTextColor: string;
+        selectedIndex: number;
+        descriptionColor: string;
+        selectedDescriptionColor: string;
+        showScrollIndicator: false;
+        wrapSelection: false;
+        showDescription: true;
+        showSelectionIndicator: true;
+        itemSpacing: number;
+        fastScrollStep: number;
+    };
+    constructor(ctx: RenderContext, options: SelectRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private renderScrollIndicatorToFrameBuffer;
+    get options(): SelectOption[];
+    set options(options: SelectOption[]);
+    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: KeyEvent): boolean;
+    get showScrollIndicator(): boolean;
+    set showScrollIndicator(show: boolean);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get showSelectionIndicator(): boolean;
+    set showSelectionIndicator(show: boolean | null | undefined);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    set backgroundColor(value: ColorInput);
+    set textColor(value: ColorInput);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set selectedBackgroundColor(value: ColorInput);
+    set selectedTextColor(value: ColorInput);
+    set descriptionColor(value: ColorInput);
+    set selectedDescriptionColor(value: ColorInput);
+    set font(font: keyof typeof fonts);
+    set itemSpacing(spacing: number);
+    set fastScrollStep(step: number);
+    set keyBindings(bindings: SelectKeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+    set selectedIndex(value: number);
+}
+export {};

package/renderables/Slider.d.ts

@@ -0,0 +1,47 @@
+import { type RenderableOptions, Renderable } from "../Renderable.js";
+import { type RenderContext } from "../types.js";
+import { type ColorInput, RGBA } from "../lib/RGBA.js";
+import { OptimizedBuffer } from "../buffer.js";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    value?: number;
+    min?: number;
+    max?: number;
+    viewPortSize?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (value: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _value;
+    private _min;
+    private _max;
+    private _viewPortSize;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get value(): number;
+    set value(newValue: number);
+    get min(): number;
+    set min(newMin: number);
+    get max(): number;
+    set max(newMax: number);
+    set viewPortSize(size: number);
+    get viewPortSize(): number;
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private calculateDragOffsetVirtual;
+    private setupMouseHandling;
+    private updateValueFromMouseDirect;
+    private updateValueFromMouseWithOffset;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private renderHorizontal;
+    private renderVertical;
+    private getVirtualThumbSize;
+    private getVirtualThumbStart;
+}