@fairyhunter13/opentui-core 0.1.91 → 0.1.94

package/renderables/Diff.d.ts

@@ -0,0 +1,142 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import type { RenderContext } from "../types.js";
+import { type LineColorConfig } from "./LineNumberRenderable.js";
+import { RGBA } from "../lib/RGBA.js";
+import { SyntaxStyle } from "../syntax-style.js";
+import type { TreeSitterClient } from "../lib/tree-sitter/index.js";
+import type { MouseEvent } from "../renderer.js";
+export interface DiffRenderableOptions extends RenderableOptions<DiffRenderable> {
+    diff?: string;
+    syncScroll?: boolean;
+    view?: "unified" | "split";
+    fg?: string | RGBA;
+    filetype?: string;
+    syntaxStyle?: SyntaxStyle;
+    wrapMode?: "word" | "char" | "none";
+    conceal?: boolean;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    treeSitterClient?: TreeSitterClient;
+    showLineNumbers?: boolean;
+    lineNumberFg?: string | RGBA;
+    lineNumberBg?: string | RGBA;
+    addedBg?: string | RGBA;
+    removedBg?: string | RGBA;
+    contextBg?: string | RGBA;
+    addedContentBg?: string | RGBA;
+    removedContentBg?: string | RGBA;
+    contextContentBg?: string | RGBA;
+    addedSignColor?: string | RGBA;
+    removedSignColor?: string | RGBA;
+    addedLineNumberBg?: string | RGBA;
+    removedLineNumberBg?: string | RGBA;
+}
+export declare class DiffRenderable extends Renderable {
+    private _diff;
+    private _syncScroll;
+    private _view;
+    private _parsedDiff;
+    private _parseError;
+    private _fg?;
+    private _filetype?;
+    private _syntaxStyle?;
+    private _wrapMode?;
+    private _conceal;
+    private _selectionBg?;
+    private _selectionFg?;
+    private _treeSitterClient?;
+    private _showLineNumbers;
+    private _lineNumberFg;
+    private _lineNumberBg;
+    private _addedBg;
+    private _removedBg;
+    private _contextBg;
+    private _addedContentBg;
+    private _removedContentBg;
+    private _contextContentBg;
+    private _addedSignColor;
+    private _removedSignColor;
+    private _addedLineNumberBg;
+    private _removedLineNumberBg;
+    private leftSide;
+    private rightSide;
+    private leftSideAdded;
+    private rightSideAdded;
+    private leftCodeRenderable;
+    private rightCodeRenderable;
+    private pendingRebuild;
+    private _lastWidth;
+    private errorTextRenderable;
+    private errorCodeRenderable;
+    private _waitingForHighlight;
+    private _lineInfoChangeHandler;
+    constructor(ctx: RenderContext, options: DiffRenderableOptions);
+    private parseDiff;
+    private buildView;
+    protected onMouseEvent(event: MouseEvent): void;
+    private isInsideSide;
+    protected onResize(width: number, height: number): void;
+    private requestRebuild;
+    private rebuildView;
+    private handleLineInfoChange;
+    private attachLineInfoListeners;
+    private detachLineInfoListeners;
+    destroyRecursively(): void;
+    private buildErrorView;
+    private createOrUpdateCodeRenderable;
+    private createOrUpdateSide;
+    private buildUnifiedView;
+    private buildSplitView;
+    get diff(): string;
+    set diff(value: string);
+    get syncScroll(): boolean;
+    set syncScroll(value: boolean);
+    get view(): "unified" | "split";
+    set view(value: "unified" | "split");
+    get filetype(): string | undefined;
+    set filetype(value: string | undefined);
+    get syntaxStyle(): SyntaxStyle | undefined;
+    set syntaxStyle(value: SyntaxStyle | undefined);
+    get wrapMode(): "word" | "char" | "none" | undefined;
+    set wrapMode(value: "word" | "char" | "none" | undefined);
+    get showLineNumbers(): boolean;
+    set showLineNumbers(value: boolean);
+    get addedBg(): RGBA;
+    set addedBg(value: string | RGBA);
+    get removedBg(): RGBA;
+    set removedBg(value: string | RGBA);
+    get contextBg(): RGBA;
+    set contextBg(value: string | RGBA);
+    get addedSignColor(): RGBA;
+    set addedSignColor(value: string | RGBA);
+    get removedSignColor(): RGBA;
+    set removedSignColor(value: string | RGBA);
+    get addedLineNumberBg(): RGBA;
+    set addedLineNumberBg(value: string | RGBA);
+    get removedLineNumberBg(): RGBA;
+    set removedLineNumberBg(value: string | RGBA);
+    get lineNumberFg(): RGBA;
+    set lineNumberFg(value: string | RGBA);
+    get lineNumberBg(): RGBA;
+    set lineNumberBg(value: string | RGBA);
+    get addedContentBg(): RGBA | null;
+    set addedContentBg(value: string | RGBA | null);
+    get removedContentBg(): RGBA | null;
+    set removedContentBg(value: string | RGBA | null);
+    get contextContentBg(): RGBA | null;
+    set contextContentBg(value: string | RGBA | null);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: string | RGBA | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: string | RGBA | undefined);
+    get conceal(): boolean;
+    set conceal(value: boolean);
+    get fg(): RGBA | undefined;
+    set fg(value: string | RGBA | undefined);
+    setLineColor(line: number, color: string | RGBA | LineColorConfig): void;
+    clearLineColor(line: number): void;
+    setLineColors(lineColors: Map<number, string | RGBA | LineColorConfig>): void;
+    clearAllLineColors(): void;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
+}

package/renderables/EditBufferRenderable.d.ts

@@ -0,0 +1,162 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { Selection, type LocalSelectionBounds } from "../lib/selection.js";
+import { EditBuffer, type LogicalCursor } from "../edit-buffer.js";
+import { EditorView, type VisualCursor } from "../editor-view.js";
+import { RGBA } from "../lib/RGBA.js";
+import type { RenderContext, Highlight, CursorStyleOptions, LineInfoProvider, LineInfo } from "../types.js";
+import type { OptimizedBuffer } from "../buffer.js";
+import type { SyntaxStyle } from "../syntax-style.js";
+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;
+    scrollSpeed?: number;
+    showCursor?: boolean;
+    cursorColor?: string | RGBA;
+    cursorStyle?: CursorStyleOptions;
+    syntaxStyle?: SyntaxStyle;
+    tabIndicator?: string | number;
+    tabIndicatorColor?: string | RGBA;
+    onCursorChange?: (event: CursorChangeEvent) => void;
+    onContentChange?: (event: ContentChangeEvent) => void;
+}
+export declare abstract class EditBufferRenderable extends Renderable implements LineInfoProvider {
+    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 _cursorStyle: CursorStyleOptions;
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected _tabIndicator?: string | number;
+    protected _tabIndicatorColor?: RGBA;
+    private _cursorChangeListener;
+    private _contentChangeListener;
+    private _autoScrollVelocity;
+    private _autoScrollAccumulator;
+    private _scrollSpeed;
+    private _keyboardSelectionActive;
+    readonly editBuffer: EditBuffer;
+    readonly editorView: EditorView;
+    protected _defaultOptions: {
+        textColor: RGBA;
+        backgroundColor: string;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        scrollMargin: number;
+        scrollSpeed: number;
+        showCursor: true;
+        cursorColor: RGBA;
+        cursorStyle: {
+            style: "block";
+            blinking: true;
+        };
+        tabIndicator: undefined;
+        tabIndicatorColor: undefined;
+    };
+    constructor(ctx: RenderContext, options: EditBufferOptions);
+    get lineInfo(): LineInfo;
+    private setupEventListeners;
+    get lineCount(): number;
+    get virtualLineCount(): number;
+    get scrollY(): number;
+    get plainText(): string;
+    get logicalCursor(): LogicalCursor;
+    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);
+    get cursorStyle(): CursorStyleOptions;
+    set cursorStyle(style: CursorStyleOptions);
+    get tabIndicator(): string | number | undefined;
+    set tabIndicator(value: string | number | undefined);
+    get tabIndicatorColor(): RGBA | undefined;
+    set tabIndicatorColor(value: RGBA | string | undefined);
+    get scrollSpeed(): number;
+    set scrollSpeed(value: number);
+    protected onMouseEvent(event: any): void;
+    protected handleScroll(event: any): void;
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    protected onUpdate(deltaTime: number): void;
+    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>;
+    /**
+     * Set text and completely reset the buffer state (clears history, resets add_buffer).
+     * Use this for initial text setting or when you want a clean slate.
+     */
+    setText(text: string): void;
+    /**
+     * Replace text while preserving undo history (creates an undo point).
+     * Use this when you want the setText operation to be undoable.
+     */
+    replaceText(text: string): void;
+    clear(): void;
+    deleteRange(startLine: number, startCol: number, endLine: number, endCol: number): void;
+    insertText(text: string): void;
+    getTextRange(startOffset: number, endOffset: number): string;
+    getTextRangeByCoords(startRow: number, startCol: number, endRow: number, endCol: number): string;
+    protected updateSelectionForMovement(shiftPressed: boolean, isBeforeMovement: boolean): void;
+}

package/renderables/FrameBuffer.d.ts

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

package/renderables/Input.d.ts

@@ -0,0 +1,67 @@
+import type { PasteEvent } from "../lib/KeyHandler.js";
+import type { RenderContext } from "../types.js";
+import { TextareaRenderable, type TextareaOptions, type TextareaAction, type KeyBinding as TextareaKeyBinding } from "./Textarea.js";
+export type InputAction = TextareaAction;
+export type InputKeyBinding = TextareaKeyBinding;
+export interface InputRenderableOptions extends Omit<TextareaOptions, "height" | "minHeight" | "maxHeight" | "initialValue"> {
+    /** Initial text value (newlines are stripped) */
+    value?: string;
+    /** Maximum number of characters allowed */
+    maxLength?: number;
+    /** Placeholder text (Input only supports string, not StyledText) */
+    placeholder?: string;
+}
+export declare enum InputRenderableEvents {
+    INPUT = "input",
+    CHANGE = "change",
+    ENTER = "enter"
+}
+/**
+ * InputRenderable - A single-line text input component.
+ *
+ * Extends TextareaRenderable with single-line constraints:
+ * - Height is always 1
+ * - No text wrapping
+ * - Newlines are stripped from input
+ * - Enter key submits instead of inserting newline
+ *
+ * Inherits all keybindings from TextareaRenderable.
+ */
+export declare class InputRenderable extends TextareaRenderable {
+    private _maxLength;
+    private _lastCommittedValue;
+    private static readonly defaultOptions;
+    constructor(ctx: RenderContext, options: InputRenderableOptions);
+    /**
+     * Prevent newlines in single-line input
+     */
+    newLine(): boolean;
+    /**
+     * Handle paste - strip newlines and enforce maxLength
+     */
+    handlePaste(event: PasteEvent): void;
+    /**
+     * Insert text - strip newlines and enforce maxLength
+     */
+    insertText(text: string): void;
+    get value(): string;
+    set value(value: string);
+    focus(): void;
+    blur(): void;
+    submit(): boolean;
+    deleteCharBackward(): boolean;
+    deleteChar(): boolean;
+    deleteLine(): boolean;
+    deleteWordBackward(): boolean;
+    deleteWordForward(): boolean;
+    deleteToLineStart(): boolean;
+    deleteToLineEnd(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    deleteCharacter(direction: "backward" | "forward"): void;
+    set maxLength(maxLength: number);
+    get maxLength(): number;
+    set placeholder(placeholder: string);
+    get placeholder(): string;
+    set initialValue(value: string);
+}

package/renderables/LineNumberRenderable.d.ts

@@ -0,0 +1,74 @@
+import { Renderable, type RenderableOptions } from "../Renderable.js";
+import { OptimizedBuffer } from "../buffer.js";
+import type { RenderContext, LineInfoProvider } from "../types.js";
+import { RGBA } from "../lib/RGBA.js";
+export interface LineSign {
+    before?: string;
+    beforeColor?: string | RGBA;
+    after?: string;
+    afterColor?: string | RGBA;
+}
+export interface LineColorConfig {
+    gutter?: string | RGBA;
+    content?: string | RGBA;
+}
+export interface LineNumberOptions extends RenderableOptions<LineNumberRenderable> {
+    target?: Renderable & LineInfoProvider;
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    minWidth?: number;
+    paddingRight?: number;
+    lineColors?: Map<number, string | RGBA | LineColorConfig>;
+    lineSigns?: Map<number, LineSign>;
+    lineNumberOffset?: number;
+    hideLineNumbers?: Set<number>;
+    lineNumbers?: Map<number, number>;
+    showLineNumbers?: boolean;
+}
+export declare class LineNumberRenderable extends Renderable {
+    private gutter;
+    private target;
+    private _lineColorsGutter;
+    private _lineColorsContent;
+    private _lineSigns;
+    private _fg;
+    private _bg;
+    private _minWidth;
+    private _paddingRight;
+    private _lineNumberOffset;
+    private _hideLineNumbers;
+    private _lineNumbers;
+    private _isDestroying;
+    private handleLineInfoChange;
+    private parseLineColor;
+    constructor(ctx: RenderContext, options: LineNumberOptions);
+    private setTarget;
+    add(child: Renderable): number;
+    remove(id: string): void;
+    destroyRecursively(): void;
+    clearTarget(): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    set showLineNumbers(value: boolean);
+    get showLineNumbers(): boolean;
+    setLineColor(line: number, color: string | RGBA | LineColorConfig): void;
+    clearLineColor(line: number): void;
+    clearAllLineColors(): void;
+    setLineColors(lineColors: Map<number, string | RGBA | LineColorConfig>): void;
+    getLineColors(): {
+        gutter: Map<number, RGBA>;
+        content: Map<number, RGBA>;
+    };
+    setLineSign(line: number, sign: LineSign): void;
+    clearLineSign(line: number): void;
+    clearAllLineSigns(): void;
+    setLineSigns(lineSigns: Map<number, LineSign>): void;
+    getLineSigns(): Map<number, LineSign>;
+    set lineNumberOffset(value: number);
+    get lineNumberOffset(): number;
+    setHideLineNumbers(hideLineNumbers: Set<number>): void;
+    getHideLineNumbers(): Set<number>;
+    setLineNumbers(lineNumbers: Map<number, number>): void;
+    getLineNumbers(): Map<number, number>;
+    highlightLines(startLine: number, endLine: number, color: string | RGBA | LineColorConfig): void;
+    clearHighlightLines(startLine: number, endLine: number): void;
+}

package/renderables/Markdown.d.ts

@@ -0,0 +1,173 @@
+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 type { ColorInput } from "../lib/RGBA.js";
+import { type MarkedToken, type Token } 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 interface MarkdownTableOptions {
+    /**
+     * 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;
+    /**
+     * 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;
+    /** 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;
+}
+export interface RenderNodeContext {
+    syntaxStyle: SyntaxStyle;
+    conceal: boolean;
+    concealCode: boolean;
+    treeSitterClient?: TreeSitterClient;
+    /** Creates default renderable for this token */
+    defaultRender: () => Renderable | null;
+}
+interface TableContentCache {
+    content: TextTableContent;
+    cellKeys: Uint32Array[];
+}
+export interface BlockState {
+    token: MarkedToken;
+    tokenRaw: string;
+    renderable: Renderable;
+    tableContentCache?: TableContentCache;
+}
+export type { ParseState };
+export declare class MarkdownRenderable extends Renderable {
+    private _content;
+    private _syntaxStyle;
+    private _conceal;
+    private _concealCode;
+    private _treeSitterClient?;
+    private _tableOptions?;
+    private _renderNode?;
+    _parseState: ParseState | null;
+    private _streaming;
+    _blockStates: BlockState[];
+    private _styleDirty;
+    private _linkifyMarkdownChunks;
+    protected _contentDefaultOptions: {
+        content: string;
+        conceal: true;
+        concealCode: false;
+        streaming: false;
+    };
+    constructor(ctx: RenderContext, options: MarkdownOptions);
+    get content(): string;
+    set content(value: string);
+    get syntaxStyle(): SyntaxStyle;
+    set syntaxStyle(value: SyntaxStyle);
+    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);
+    private getStyle;
+    private createChunk;
+    private createDefaultChunk;
+    private renderInlineContent;
+    private renderInlineToken;
+    private renderInlineTokenWithStyle;
+    private createMarkdownCodeRenderable;
+    private createCodeRenderable;
+    private applyMarkdownCodeRenderable;
+    private applyCodeBlockRenderable;
+    private shouldRenderSeparately;
+    private getInterBlockMargin;
+    private createMarkdownBlockToken;
+    private normalizeMarkdownBlockRaw;
+    private buildRenderableTokens;
+    private getTableRowsToRender;
+    private hashString;
+    private hashTableToken;
+    private getTableCellKey;
+    private createTableDataCellChunks;
+    private createTableHeaderCellChunks;
+    private buildTableContentCache;
+    private resolveTableRenderableOptions;
+    private applyTableRenderableOptions;
+    private applyTableOptionsToBlocks;
+    private createTextTableRenderable;
+    private createTableBlock;
+    private createDefaultRenderable;
+    private updateBlockRenderable;
+    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;
+}