@opentui/core 0.0.0-20250930-6541ec7f → 0.0.0-20250930-d50102aa

package/lib/data-paths.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "events";
+export interface DataPaths {
+    globalConfigPath: string;
+    globalConfigFile: string;
+    localConfigFile: string;
+    globalDataPath: string;
+}
+export interface DataPathsEvents {
+    "paths:changed": [paths: DataPaths];
+}
+export declare class DataPathsManager extends EventEmitter<DataPathsEvents> {
+    private _appName;
+    private _globalConfigPath?;
+    private _globalConfigFile?;
+    private _localConfigFile?;
+    private _globalDataPath?;
+    constructor();
+    get appName(): string;
+    set appName(value: string);
+    get globalConfigPath(): string;
+    get globalConfigFile(): string;
+    get localConfigFile(): string;
+    get globalDataPath(): string;
+    toObject(): DataPaths;
+}
+export declare function getDataPaths(): DataPathsManager;

package/lib/debounce.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Debounce controller that manages debounce instances for a specific scope
+ */
+export declare class DebounceController {
+    private scopeId;
+    constructor(scopeId: string | number);
+    /**
+     * Debounces the provided function with the given ID
+     *
+     * @param id Unique identifier within this scope
+     * @param ms Milliseconds to wait before executing
+     * @param fn Function to execute
+     */
+    debounce<R>(id: string | number, ms: number, fn: () => Promise<R>): Promise<R>;
+    /**
+     * Clear a specific debounce timer in this scope
+     *
+     * @param id The debounce ID to clear
+     */
+    clearDebounce(id: string | number): void;
+    /**
+     * Clear all debounce timers in this scope
+     */
+    clear(): void;
+}
+/**
+ * Creates a new debounce controller for a specific scope
+ *
+ * @param scopeId Unique identifier for this debounce scope
+ * @returns A DebounceController for the specified scope
+ */
+export declare function createDebounce(scopeId: string | number): DebounceController;
+/**
+ * Clears all debounce timers for a specific scope
+ *
+ * @param scopeId The scope identifier
+ */
+export declare function clearDebounceScope(scopeId: string | number): void;
+/**
+ * Clears all active debounce timers across all scopes
+ */
+export declare function clearAllDebounces(): void;

package/lib/env.d.ts

@@ -36,6 +36,7 @@ export interface EnvVarConfig {
 }
 export declare const envRegistry: Record<string, EnvVarConfig>;
 export declare function registerEnvVar(config: EnvVarConfig): void;
+export declare function clearEnvCache(): void;
 export declare function generateEnvMarkdown(): string;
 export declare function generateEnvColored(): string;
-export declare const env: Record<string, string | number | boolean>;
+export declare const env: Record<string, any>;

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

@@ -1,5 +1,5 @@
-import { RGBA } from "./RGBA";
 import { StyledText } from "./styled-text";
+import { SyntaxStyle } from "./syntax-style";
 export interface HASTText {
     type: "text";
     value: string;
@@ -13,26 +13,6 @@ export interface HASTElement {
     children: HASTNode[];
 }
 export type HASTNode = HASTText | HASTElement;
-export interface StyleDefinition {
-    fg?: RGBA;
-    bg?: RGBA;
-    bold?: boolean;
-    italic?: boolean;
-    underline?: boolean;
-    dim?: boolean;
-}
-interface MergedStyle {
-    fg?: RGBA;
-    bg?: RGBA;
-    attributes: number;
-}
-export declare class SyntaxStyle {
-    private styles;
-    private mergedStyleCache;
-    constructor(styles: Record<string, StyleDefinition>);
-    mergeStyles(...styleNames: string[]): MergedStyle;
-    clearCache(): void;
-    getCacheSize(): number;
-}
+export { SyntaxStyle } from "./syntax-style";
+export type { StyleDefinition } from "./syntax-style";
 export declare function hastToStyledText(hast: HASTNode, syntaxStyle: SyntaxStyle): StyledText;
-export {};

package/lib/index.d.ts

@@ -9,3 +9,7 @@ export * from "./yoga.options";
 export * from "./parse.mouse";
 export * from "./selection";
 export * from "./env";
+export * from "./tree-sitter-styled-text";
+export * from "./tree-sitter";
+export * from "./syntax-style";
+export * from "./data-paths";

package/lib/queue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generic processing queue that handles asynchronous job processing
+ */
+export declare class ProcessQueue<T> {
+    private processor;
+    private queue;
+    private processing;
+    private autoProcess;
+    constructor(processor: (item: T) => Promise<void> | void, autoProcess?: boolean);
+    enqueue(item: T): void;
+    private processQueue;
+    clear(): void;
+    isProcessing(): boolean;
+    size(): number;
+}

package/lib/singleton.d.ts

@@ -3,3 +3,5 @@
  * persists across Bun hot reloads, and is type-safe.
  */
 export declare function singleton<T>(key: string, factory: () => T): T;
+export declare function destroySingleton(key: string): void;
+export declare function hasSingleton(key: string): boolean;

package/lib/styled-text.d.ts

@@ -1,4 +1,3 @@
-import type { TextRenderable } from "../renderables/Text";
 import type { TextChunk } from "../text-buffer";
 import { type ColorInput } from "./RGBA";
 declare const BrandedStyledText: unique symbol;
@@ -18,21 +17,7 @@ export declare function isStyledText(obj: any): obj is StyledText;
 export declare class StyledText {
     [BrandedStyledText]: boolean;
     chunks: TextChunk[];
-    textRenderable?: TextRenderable;
     constructor(chunks: TextChunk[]);
-    mount(textRenderable: TextRenderable): void;
-    /**
-     * @deprecated: Use textRenderable.insertChunk instead
-     */
-    insert(chunk: TextChunk, index?: number): StyledText;
-    /**
-     * @deprecated: Use textRenderable.removeChunk instead
-     */
-    remove(chunk: TextChunk): StyledText;
-    /**
-     * @deprecated: Use textRenderable.replaceChunk instead
-     */
-    replace(chunk: TextChunk, oldChunk: TextChunk): StyledText;
 }
 export declare function stringToStyledText(content: string): StyledText;
 export type StylableInput = string | number | boolean | TextChunk;

package/lib/syntax-style.d.ts

@@ -0,0 +1,36 @@
+import { RGBA, type ColorInput } from "./RGBA";
+export interface StyleDefinition {
+    fg?: RGBA;
+    bg?: RGBA;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+}
+export interface MergedStyle {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+}
+export interface ThemeTokenStyle {
+    scope: string[];
+    style: {
+        foreground?: ColorInput;
+        background?: ColorInput;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        dim?: boolean;
+    };
+}
+export declare function convertThemeToStyles(theme: ThemeTokenStyle[]): Record<string, StyleDefinition>;
+export declare class SyntaxStyle {
+    private styles;
+    private mergedStyleCache;
+    constructor(styles: Record<string, StyleDefinition>);
+    static fromTheme(theme: ThemeTokenStyle[]): SyntaxStyle;
+    mergeStyles(...styleNames: string[]): MergedStyle;
+    getStyle(name: string): StyleDefinition | undefined;
+    clearCache(): void;
+    getCacheSize(): number;
+}

package/lib/tree-sitter/assets/update.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env bun
+export interface UpdateOptions {
+    /** Path to parsers-config.json */
+    configPath: string;
+    /** Directory where .wasm and .scm files will be downloaded */
+    assetsDir: string;
+    /** Path where the generated TypeScript file will be written */
+    outputPath: string;
+}
+declare function main(options?: Partial<UpdateOptions>): Promise<void>;
+export { main as updateAssets };

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

@@ -0,0 +1,42 @@
+import { EventEmitter } from "events";
+import type { TreeSitterClientOptions, TreeSitterClientEvents, BufferState, FiletypeParserOptions, Edit, PerformanceStats, SimpleHighlight } from "./types";
+export declare function addDefaultParsers(parsers: FiletypeParserOptions[]): void;
+export declare class TreeSitterClient extends EventEmitter<TreeSitterClientEvents> {
+    private initialized;
+    private worker;
+    private buffers;
+    private initializePromise;
+    private initializeResolvers;
+    private messageCallbacks;
+    private messageIdCounter;
+    private editQueues;
+    private debouncer;
+    private options;
+    constructor(options: TreeSitterClientOptions);
+    private emitError;
+    private emitWarning;
+    private startWorker;
+    private stopWorker;
+    private handleReset;
+    initialize(): Promise<void>;
+    private registerDefaultParsers;
+    addFiletypeParser(filetypeParser: FiletypeParserOptions): void;
+    getPerformance(): Promise<PerformanceStats>;
+    highlightOnce(content: string, filetype: string): Promise<{
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }>;
+    private handleWorkerMessage;
+    preloadParser(filetype: string): Promise<boolean>;
+    createBuffer(id: number, content: string, filetype: string, version?: number, autoInitialize?: boolean): Promise<boolean>;
+    updateBuffer(id: number, edits: Edit[], newContent: string, version: number): Promise<void>;
+    private processEdit;
+    removeBuffer(bufferId: number): Promise<void>;
+    destroy(): Promise<void>;
+    resetBuffer(bufferId: number, version: number, content: string): Promise<void>;
+    getBuffer(bufferId: number): BufferState | undefined;
+    getAllBuffers(): BufferState[];
+    isInitialized(): boolean;
+    setDataPath(dataPath: string): Promise<void>;
+}

package/lib/tree-sitter/default-parsers.d.ts

@@ -0,0 +1,2 @@
+import type { FiletypeParserOptions } from "./types";
+export declare function getParsers(): FiletypeParserOptions[];

package/lib/tree-sitter/download-utils.d.ts

@@ -0,0 +1,21 @@
+export interface DownloadResult {
+    content?: ArrayBuffer;
+    filePath?: string;
+    error?: string;
+}
+export declare class DownloadUtils {
+    private static hashUrl;
+    /**
+     * Download a file from URL or load from local path, with caching support
+     */
+    static downloadOrLoad(source: string, cacheDir: string, cacheSubdir: string, fileExtension: string, useHashForCache?: boolean, filetype?: string): Promise<DownloadResult>;
+    /**
+     * Download and save a file to a specific target path
+     */
+    static downloadToPath(source: string, targetPath: string): Promise<DownloadResult>;
+    /**
+     * Fetch multiple highlight queries and concatenate them
+     */
+    static fetchHighlightQueries(sources: string[], cacheDir: string, filetype: string): Promise<string>;
+    private static fetchHighlightQuery;
+}

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

@@ -0,0 +1,10 @@
+import { TreeSitterClient } from "./client";
+export * from "./client";
+export * from "../tree-sitter-styled-text";
+export * from "../syntax-style";
+export * from "./types";
+export * from "../syntax-style";
+export * from "./resolve-ft";
+export type { UpdateOptions } from "./assets/update";
+export { updateAssets } from "./assets/update";
+export declare function getTreeSitterClient(): TreeSitterClient;

package/lib/tree-sitter/parser.worker.d.ts

@@ -0,0 +1 @@
+export default __filename;

package/lib/tree-sitter/resolve-ft.d.ts

@@ -0,0 +1,2 @@
+export declare function extToFiletype(extension: string): string | undefined;
+export declare function pathToFiletype(path: string): string | undefined;

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

@@ -0,0 +1,64 @@
+export interface HighlightRange {
+    startCol: number;
+    endCol: number;
+    group: string;
+}
+export interface HighlightResponse {
+    line: number;
+    highlights: HighlightRange[];
+    droppedHighlights: HighlightRange[];
+}
+export type SimpleHighlight = [number, number, string];
+export interface FiletypeParserOptions {
+    filetype: string;
+    queries: {
+        highlights: string[];
+    };
+    wasm: string;
+}
+export interface BufferState {
+    id: number;
+    version: number;
+    content: string;
+    filetype: string;
+    hasParser: boolean;
+}
+export interface ParsedBuffer extends BufferState {
+    hasParser: true;
+}
+export interface TreeSitterClientEvents {
+    "highlights:response": [bufferId: number, version: number, highlights: HighlightResponse[]];
+    "buffer:initialized": [bufferId: number, hasParser: boolean];
+    "buffer:disposed": [bufferId: number];
+    "worker:log": [logType: "log" | "error", message: string];
+    error: [error: string, bufferId?: number];
+    warning: [warning: string, bufferId?: number];
+}
+export interface TreeSitterClientOptions {
+    dataPath: string;
+    workerPath?: string | URL;
+    initTimeout?: number;
+}
+export interface Edit {
+    startIndex: number;
+    oldEndIndex: number;
+    newEndIndex: number;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    oldEndPosition: {
+        row: number;
+        column: number;
+    };
+    newEndPosition: {
+        row: number;
+        column: number;
+    };
+}
+export interface PerformanceStats {
+    averageParseTime: number;
+    parseTimes: number[];
+    averageQueryTime: number;
+    queryTimes: number[];
+}

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

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

package/lib/validate-dir-name.d.ts

@@ -0,0 +1 @@
+export declare function isValidDirectoryName(name: string): boolean;

package/package.json

@@ -4,7 +4,7 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.0.0-20250930-6541ec7f",
+  "version": "0.0.0-20250930-d50102aa",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
@@ -27,6 +27,11 @@
       "import": "./testing.js",
       "require": "./testing.js",
       "types": "./testing.d.ts"
+    },
+    "./parser.worker": {
+      "import": "./parser.worker.js",
+      "require": "./parser.worker.js",
+      "types": "./parser.worker.d.ts"
     }
   },
   "devDependencies": {
@@ -40,11 +45,11 @@
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.0.0-20250930-6541ec7f",
-    "@opentui/core-darwin-arm64": "0.0.0-20250930-6541ec7f",
-    "@opentui/core-linux-x64": "0.0.0-20250930-6541ec7f",
-    "@opentui/core-linux-arm64": "0.0.0-20250930-6541ec7f",
-    "@opentui/core-win32-x64": "0.0.0-20250930-6541ec7f",
-    "@opentui/core-win32-arm64": "0.0.0-20250930-6541ec7f"
+    "@opentui/core-darwin-x64": "0.0.0-20250930-d50102aa",
+    "@opentui/core-darwin-arm64": "0.0.0-20250930-d50102aa",
+    "@opentui/core-linux-x64": "0.0.0-20250930-d50102aa",
+    "@opentui/core-linux-arm64": "0.0.0-20250930-d50102aa",
+    "@opentui/core-win32-x64": "0.0.0-20250930-d50102aa",
+    "@opentui/core-win32-arm64": "0.0.0-20250930-d50102aa"
   }
 }

package/parser.worker.d.ts

@@ -0,0 +1 @@
+export * from "./lib/tree-sitter/parser.worker";

package/parser.worker.js

@@ -0,0 +1,5 @@
+// @bun
+import"./index-cc14z67g.js";
+
+//# debugId=5819917521D6E01464756E2164756E21
+//# sourceMappingURL=parser.worker.js.map

package/parser.worker.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "5819917521D6E01464756E2164756E21",
+  "names": []
+}

package/renderables/Code.d.ts

@@ -0,0 +1,31 @@
+import { type RenderContext } from "../types";
+import { SyntaxStyle } from "../lib/syntax-style";
+import { TreeSitterClient } from "../lib/tree-sitter";
+import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable";
+export interface CodeOptions extends TextBufferOptions {
+    content?: string;
+    filetype?: string;
+    syntaxStyle: SyntaxStyle;
+    treeSitterClient?: TreeSitterClient;
+}
+export declare class CodeRenderable extends TextBufferRenderable {
+    private _content;
+    private _filetype?;
+    private _syntaxStyle;
+    private _isHighlighting;
+    private _treeSitterClient;
+    private _pendingRehighlight;
+    protected _contentDefaultOptions: {
+        content: string;
+    };
+    constructor(ctx: RenderContext, options: CodeOptions);
+    get content(): string;
+    set content(value: string);
+    get filetype(): string | undefined;
+    set filetype(value: string);
+    get syntaxStyle(): SyntaxStyle;
+    set syntaxStyle(value: SyntaxStyle);
+    private updateContent;
+    private fallback;
+    private createFallbackStyledText;
+}

package/renderables/Text.d.ts

@@ -1,96 +1,39 @@
-import { BaseRenderable, Renderable, type RenderableOptions } from "../Renderable";
-import { Selection } from "../lib/selection";
+import { BaseRenderable } from "../Renderable";
 import { StyledText } from "../lib/styled-text";
 import { type TextChunk } from "../text-buffer";
 import { RGBA } from "../lib/RGBA";
 import { type RenderContext } from "../types";
-import type { OptimizedBuffer } from "../buffer";
 import { RootTextNodeRenderable, TextNodeRenderable } from "./TextNode";
-export interface TextOptions extends RenderableOptions<TextRenderable> {
+import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable";
+export interface TextOptions extends TextBufferOptions {
     content?: StyledText | string;
-    fg?: string | RGBA;
-    bg?: string | RGBA;
-    selectionBg?: string | RGBA;
-    selectionFg?: string | RGBA;
-    selectable?: boolean;
-    attributes?: number;
-    wrap?: boolean;
-    wrapMode?: "char" | "word";
 }
-export declare class TextRenderable extends Renderable {
-    selectable: boolean;
+export declare class TextRenderable extends TextBufferRenderable {
     private _text;
     private _hasManualStyledText;
-    private _defaultFg;
-    private _defaultBg;
-    private _defaultAttributes;
-    private _selectionBg;
-    private _selectionFg;
-    private _wrap;
-    private _wrapMode;
-    private lastLocalSelection;
-    private textBuffer;
-    private _lineInfo;
     protected rootTextNode: RootTextNodeRenderable;
-    protected _defaultOptions: {
+    protected _contentDefaultOptions: {
         content: string;
-        fg: RGBA;
-        bg: RGBA;
-        selectionBg: undefined;
-        selectionFg: undefined;
-        selectable: true;
-        attributes: number;
-        wrap: true;
-        wrapMode: "char" | "word";
     };
     constructor(ctx: RenderContext, options: TextOptions);
     private updateTextBuffer;
     private clearChunks;
     get content(): StyledText;
-    get plainText(): string;
-    get textLength(): number;
     get chunks(): TextChunk[];
     get textNode(): RootTextNodeRenderable;
     set content(value: StyledText | string);
-    get fg(): RGBA;
-    set fg(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 bg(): RGBA;
-    set bg(value: RGBA | string | undefined);
-    get attributes(): number;
-    set attributes(value: number);
-    get wrap(): boolean;
-    set wrap(value: boolean);
-    get wrapMode(): "char" | "word";
-    set wrapMode(value: "char" | "word");
-    protected onResize(width: number, height: number): void;
-    private updateLocalSelection;
-    private updateTextInfo;
-    private updateLineInfo;
-    private updateWrapWidth;
-    private setupMeasureFunc;
     insertChunk(chunk: TextChunk, index?: number): void;
-    removeChunk(chunk: TextChunk): void;
-    replaceChunk(chunk: TextChunk, oldChunk: TextChunk): void;
+    removeChunkByObject(chunk: TextChunk): void;
+    replaceChunkByObject(chunk: TextChunk, oldChunk: TextChunk): void;
     private updateTextFromNodes;
     add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
     remove(id: string): void;
     insertBefore(obj: BaseRenderable | any, anchor?: TextNodeRenderable): number;
     getTextChildren(): BaseRenderable[];
     clear(): void;
-    shouldStartSelection(x: number, y: number): boolean;
-    onSelectionChanged(selection: Selection | null): boolean;
-    getSelectedText(): string;
-    hasSelection(): boolean;
-    getSelection(): {
-        start: number;
-        end: number;
-    } | null;
     onLifecyclePass: () => void;
-    render(buffer: OptimizedBuffer, deltaTime: number): void;
-    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
     destroy(): void;
 }

package/renderables/TextBufferRenderable.d.ts

@@ -0,0 +1,81 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection, type LocalSelectionBounds } from "../lib/selection";
+import { TextBuffer, type TextChunk } from "../text-buffer";
+import { RGBA } from "../lib/RGBA";
+import { type RenderContext } from "../types";
+import type { OptimizedBuffer } from "../buffer";
+import type { LineInfo } from "../zig";
+export interface TextBufferOptions extends RenderableOptions<TextBufferRenderable> {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrap?: boolean;
+    wrapMode?: "char" | "word";
+}
+export declare abstract class TextBufferRenderable extends Renderable {
+    selectable: boolean;
+    protected _defaultFg: RGBA;
+    protected _defaultBg: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrap: boolean;
+    protected _wrapMode: "char" | "word";
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected textBuffer: TextBuffer;
+    protected _lineInfo: LineInfo;
+    protected _defaultOptions: {
+        fg: RGBA;
+        bg: RGBA;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrap: true;
+        wrapMode: "char" | "word";
+    };
+    constructor(ctx: RenderContext, options: TextBufferOptions);
+    get plainText(): string;
+    get textLength(): number;
+    get fg(): RGBA;
+    set fg(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 bg(): RGBA;
+    set bg(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrap(): boolean;
+    set wrap(value: boolean);
+    get wrapMode(): "char" | "word";
+    set wrapMode(value: "char" | "word");
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    protected updateTextInfo(): void;
+    private updateLineInfo;
+    private updateWrapWidth;
+    private setupMeasureFunc;
+    insertChunk(chunk: TextChunk, index?: number): void;
+    removeChunk(index: number): void;
+    replaceChunk(index: number, chunk: TextChunk): void;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    destroy(): void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
+}