@tuidom/elements 0.1.0

package/dist/editorpart/editorPartElement.js

@@ -0,0 +1,285 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import { TUIElement } from "@tuidom/core/dom/tuiElement";
+import { SashElement } from "../sash/sashElement.js";
+/** Минимальная ширина группы в колонках — узже таб-стрип и код нечитаемы. */
+export const MIN_GROUP_MAIN_COLS = 20;
+/** Минимальная высота группы в рядах — таб-стрип + пара строк кода. */
+export const MIN_GROUP_MAIN_ROWS = 5;
+/**
+ * Полоса групп редакторов по одной оси (аналог grid-вью `EditorPart` VS Code,
+ * сведённого к одному ряду/колонке): N вью групп + N−1 сашей между ними.
+ * Пропорции — нормированные веса, переживают ресайз терминала; политику весов
+ * при сплите/схлопывании задаёт владелец (`EditorPartComponent`) через
+ * {@link setViews}. Саши лежат ПОВЕРХ граничной ячейки (пуш последними —
+ * hit-test): в columns — поверх первой колонки следующей группы, в rows —
+ * поверх ПОСЛЕДНЕЙ строки предыдущей: первая строка нижней группы это её
+ * табы, и наложение отняло бы у них мышь, а нижняя строка редактора менее
+ * ценна. Каждый саш укладывается явно в каждом layout.
+ *
+ * Деградация «не влезаем»: контейнер уже, чем N×минимум, — display-only равное
+ * деление без мутации весов; при возврате размера пропорции восстанавливаются.
+ * Отказ в НОВОМ сплите при нехватке места — {@link canFit}, решает владелец.
+ */
+export class EditorPartElement extends TUIElement {
+    views = [];
+    /** Нормированные доли групп; длина всегда равна `views.length`. */
+    weightsValue = [];
+    sashes = [];
+    orientationValue = "columns";
+    maximizedIndexValue = null;
+    /** Основные размеры групп из последнего layout — база для drag-математики. */
+    lastSizes = [];
+    /**
+     * Смена весов действием пользователя (drag саша, nudge/even команды) — для
+     * персиста. Плейн-колбэк (TUIDom без DI); НЕ вызывается из performLayout.
+     */
+    onDidChangeWeights;
+    /** Ось полосы. Смена сохраняет веса (US-19: тумблер не теряет пропорций). */
+    get orientation() {
+        return this.orientationValue;
+    }
+    set orientation(value) {
+        if (this.orientationValue === value)
+            return;
+        this.orientationValue = value;
+        this.rebuildSashes();
+        this.markDirty();
+    }
+    /** Нормированные доли групп (копия). */
+    get weights() {
+        return [...this.weightsValue];
+    }
+    /** Индекс максимизированной группы, либо `null` (обычная полоса). */
+    get maximizedIndex() {
+        return this.maximizedIndexValue;
+    }
+    set maximizedIndex(value) {
+        const clamped = value !== null && value >= 0 && value < this.views.length ? value : null;
+        if (this.maximizedIndexValue === clamped)
+            return;
+        this.maximizedIndexValue = clamped;
+        this.syncChildren();
+        this.markDirty();
+    }
+    /**
+     * Задаёт состав полосы и доли. Политика долей — у владельца (сплит делит
+     * долю активной группы пополам, join отдаёт долю соседу и т.п.); элемент
+     * лишь нормирует. Пустые/невалидные веса → равные доли. Максимизация
+     * сбрасывается: состав сменился, старый индекс — про другую полосу.
+     */
+    setViews(views, weights) {
+        this.views = [...views];
+        const raw = weights !== undefined && weights.length === views.length ? [...weights] : [];
+        this.weightsValue = this.normalizeWeights(raw);
+        this.maximizedIndexValue = null;
+        this.rebuildSashes();
+        this.markDirty();
+    }
+    /** Выравнивает доли (Reset Editor Group Sizes). */
+    evenWeights() {
+        if (this.views.length === 0)
+            return;
+        this.weightsValue = this.normalizeWeights([]);
+        this.markDirty();
+        this.onDidChangeWeights?.();
+    }
+    /**
+     * Задаёт доли программно (рестор персиста). Невалидные/чужой длины веса
+     * нормализуются в равные; событие не файрится — это не действие пользователя.
+     */
+    setWeights(weights) {
+        this.weightsValue = this.normalizeWeights([...weights]);
+        this.markDirty();
+    }
+    /**
+     * Меняет основной размер группы `index` на `deltaCells` ячеек за счёт соседа
+     * справа/снизу (последняя группа растёт за счёт соседа слева/сверху) —
+     * increase/decreaseEditorWidth/Height. Кламп по минимуму обеих.
+     */
+    nudgeWeight(index, deltaCells) {
+        if (this.views.length < 2 || index < 0 || index >= this.views.length)
+            return;
+        const neighbor = index < this.views.length - 1 ? index + 1 : index - 1;
+        const sizes = this.currentSizes();
+        if (sizes === null)
+            return;
+        const min = this.minMainSize();
+        const pair = sizes[index] + sizes[neighbor];
+        const target = Math.max(min, Math.min(sizes[index] + deltaCells, pair - min));
+        sizes[index] = target;
+        sizes[neighbor] = pair - target;
+        this.weightsValue = this.normalizeWeights(sizes);
+        this.markDirty();
+        this.onDidChangeWeights?.();
+    }
+    /** Влезет ли полоса из `count` групп в текущий основной размер. */
+    canFit(count) {
+        const main = this.mainAxisSize();
+        // До первого layout судить не по чему — не отказываем (рестор решает сам).
+        if (main <= 0)
+            return true;
+        return count * this.minMainSize() <= main;
+    }
+    inspectState() {
+        return {
+            orientation: this.orientationValue,
+            weights: this.weightsValue.map((w) => Number(w.toFixed(4))),
+            maximizedIndex: this.maximizedIndexValue,
+            groupCount: this.views.length,
+        };
+    }
+    /** Основной размер полосы по текущей оси (из последнего layout). */
+    mainAxisSize() {
+        return this.orientationValue === "columns" ? this.layoutSize.width : this.layoutSize.height;
+    }
+    minMainSize() {
+        return this.orientationValue === "columns" ? MIN_GROUP_MAIN_COLS : MIN_GROUP_MAIN_ROWS;
+    }
+    /** Текущие основные размеры групп; `null` до первого layout. */
+    currentSizes() {
+        if (this.lastSizes.length !== this.views.length)
+            return null;
+        return [...this.lastSizes];
+    }
+    /** Нормирует произвольные положительные величины в доли; пусто/мусор → равные. */
+    normalizeWeights(raw) {
+        const count = this.views.length;
+        if (count === 0)
+            return [];
+        const positive = raw.length === count && raw.every((w) => Number.isFinite(w) && w > 0);
+        if (!positive)
+            return new Array(count).fill(1 / count);
+        const total = raw.reduce((sum, w) => sum + w, 0);
+        return raw.map((w) => w / total);
+    }
+    /** Пересоздаёт N−1 сашей под текущие состав и ось; вешает drag-обработчики. */
+    rebuildSashes() {
+        const sashOrientation = this.orientationValue === "columns" ? "vertical" : "horizontal";
+        this.sashes = this.views.slice(1).map((_, i) => {
+            const sash = new SashElement(sashOrientation);
+            sash.onDrag = (boundaryScreen) => {
+                this.handleSashDrag(i, boundaryScreen);
+            };
+            return sash;
+        });
+        this.syncChildren();
+    }
+    /** Дети: вью групп, затем саши (поверх границ — hit-test); максимизация прячет прочее. */
+    syncChildren() {
+        const maximized = this.maximizedIndexValue;
+        for (const [i, view] of this.views.entries()) {
+            view.hidden = maximized !== null && i !== maximized;
+        }
+        for (const sash of this.sashes) {
+            sash.hidden = maximized !== null;
+        }
+        this.setChildren([...this.views, ...this.sashes]);
+    }
+    /**
+     * Drag саша `index` (граница групп index/index+1): абсолютная координата →
+     * новый размер левой/верхней группы, кламп по минимуму пары, веса — из
+     * фактических размеров. Веса остальных групп не трогаются.
+     */
+    handleSashDrag(index, boundaryScreen) {
+        const sizes = this.currentSizes();
+        if (sizes === null)
+            return;
+        const origin = this.orientationValue === "columns" ? this.globalPosition.x : this.globalPosition.y;
+        let offset = 0;
+        for (let i = 0; i < index; i++)
+            offset += sizes[i];
+        const min = this.minMainSize();
+        const pair = sizes[index] + sizes[index + 1];
+        // В rows саш лежит на последней строке верхней группы (не на первой
+        // нижней) — курсор на строке Y означает размер верхней Y+1.
+        const inset = this.orientationValue === "rows" ? 1 : 0;
+        const target = Math.max(min, Math.min(boundaryScreen - origin - offset + inset, pair - min));
+        sizes[index] = target;
+        sizes[index + 1] = pair - target;
+        this.weightsValue = this.normalizeWeights(sizes);
+        this.markDirty();
+        this.onDidChangeWeights?.();
+    }
+    /**
+     * Целочисленные основные размеры из долей: floor + остатки самым большим
+     * дробным частям (сумма всегда равна `mainSize`), затем min-клампы за счёт
+     * самых широких. Полоса уже N×минимума — display-only равное деление, веса
+     * не мутируются (US-25: пропорции восстановятся при возврате размера).
+     */
+    computeSizes(mainSize) {
+        const count = this.views.length;
+        /* v8 ignore start -- performLayout не зовёт с пустой полосой */
+        if (count === 0)
+            return [];
+        /* v8 ignore stop */
+        const min = this.minMainSize();
+        if (mainSize < count * min) {
+            return this.distributeEvenly(mainSize, count);
+        }
+        const raw = this.weightsValue.map((w) => w * mainSize);
+        const sizes = raw.map((r) => Math.floor(r));
+        let remainder = mainSize - sizes.reduce((sum, s) => sum + s, 0);
+        const byFraction = raw.map((r, i) => ({ i, frac: r - Math.floor(r) })).sort((a, b) => b.frac - a.frac);
+        for (const { i } of byFraction) {
+            if (remainder <= 0)
+                break;
+            sizes[i]++;
+            remainder--;
+        }
+        // Min-клампы: добираем дефицит у самых больших (влезаем по проверке выше).
+        for (let i = 0; i < count; i++) {
+            while (sizes[i] < min) {
+                const largest = sizes.indexOf(Math.max(...sizes));
+                /* v8 ignore start -- защитный выход: mainSize >= count*min гарантирует донора */
+                if (largest === i || sizes[largest] <= min)
+                    break;
+                /* v8 ignore stop */
+                sizes[largest]--;
+                sizes[i]++;
+            }
+        }
+        return sizes;
+    }
+    distributeEvenly(mainSize, count) {
+        const base = Math.floor(mainSize / count);
+        const sizes = new Array(count).fill(base);
+        for (let i = 0; i < mainSize - base * count; i++)
+            sizes[i]++;
+        return sizes;
+    }
+    performLayout(constraints) {
+        const containerSize = super.performLayout(constraints);
+        if (this.views.length === 0) {
+            this.lastSizes = [];
+            return containerSize;
+        }
+        const maximized = this.maximizedIndexValue;
+        if (maximized !== null) {
+            // Максимизированная группа занимает всё; остальные скрыты (hidden в
+            // syncChildren), их layout не трогаем — размеры вернутся с полосой.
+            this.layoutChild(this.views[maximized], 0, 0, BoxConstraints.tight(containerSize));
+            return containerSize;
+        }
+        const columns = this.orientationValue === "columns";
+        const mainSize = columns ? containerSize.width : containerSize.height;
+        const sizes = this.computeSizes(mainSize);
+        this.lastSizes = [...sizes];
+        let offset = 0;
+        for (const [i, view] of this.views.entries()) {
+            const size = columns ? new Size(sizes[i], containerSize.height) : new Size(containerSize.width, sizes[i]);
+            this.layoutChild(view, columns ? offset : 0, columns ? 0 : offset, BoxConstraints.tight(size));
+            offset += sizes[i];
+            // Саш i на границе групп i/i+1: в columns — поверх первой колонки
+            // следующей группы, в rows — поверх последней строки предыдущей
+            // (первая строка нижней это её табы). Явная укладка каждый layout:
+            // ленивый layoutSize со старым боксом ломает hit-test (контракт
+            // WorkbenchLayoutElement).
+            if (i < this.sashes.length) {
+                const sashSize = columns ? new Size(1, containerSize.height) : new Size(containerSize.width, 1);
+                const sashMain = columns ? offset : Math.max(0, offset - 1);
+                this.layoutChild(this.sashes[i], columns ? sashMain : 0, columns ? 0 : sashMain, BoxConstraints.tight(sashSize));
+            }
+        }
+        return containerSize;
+    }
+}

package/dist/inputbox/inputElement.d.ts

@@ -0,0 +1,34 @@
+import { BoxConstraints, Size } from "@tuidom/core/common/geometryPromitives";
+import type { TUIEventBase } from "@tuidom/core/dom/events/tuiEventBase";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+import { InputState } from "./inputState.js";
+/**
+ * Single-line text input widget.
+ *
+ * By default rendered without a border — just a plain editable text line.
+ * Set `showBorder = true` to get a Unicode box-drawing frame around it.
+ * The border colour changes between focused (#007FD4) and unfocused (#3C3C3C).
+ *
+ * Usage:
+ *   const input = new InputElement();
+ *   input.placeholder = "Search…";
+ *   input.onChange = value => console.log(value);
+ */
+export declare class InputElement extends TUIElement {
+    readonly inputState: InputState;
+    placeholder: string | undefined;
+    showBorder: boolean;
+    onChange: ((value: string) => void) | undefined;
+    private scrollX;
+    constructor(inputState?: InputState);
+    /** Наблюдаемость для инспектора/e2e: текст, курсор, выделение, плейсхолдер. */
+    inspectState(): Record<string, unknown>;
+    getMinIntrinsicWidth(_height: number): number;
+    getMinIntrinsicHeight(_width: number): number;
+    getMaxIntrinsicHeight(_width: number): number;
+    protected performLayout(constraints: BoxConstraints): Size;
+    render(context: RenderContext): void;
+    private renderTextWithSelection;
+    private renderBorder;
+    protected performDefaultAction(event: TUIEventBase): void;
+}

package/dist/inputbox/inputElement.js

@@ -0,0 +1,207 @@
+import { DisplayLine } from "@tuidom/core/common/displayLine";
+import { BoxConstraints, Point, Rect, Size } from "@tuidom/core/common/geometryPromitives";
+import { TUIKeyboardEvent } from "@tuidom/core/dom/events/tuiKeyboardEvent";
+import { RenderContext, TUIElement } from "@tuidom/core/dom/tuiElement";
+import { InputState } from "./inputState.js";
+/**
+ * Single-line text input widget.
+ *
+ * By default rendered without a border — just a plain editable text line.
+ * Set `showBorder = true` to get a Unicode box-drawing frame around it.
+ * The border colour changes between focused (#007FD4) and unfocused (#3C3C3C).
+ *
+ * Usage:
+ *   const input = new InputElement();
+ *   input.placeholder = "Search…";
+ *   input.onChange = value => console.log(value);
+ */
+export class InputElement extends TUIElement {
+    inputState;
+    placeholder = undefined;
+    showBorder = false;
+    onChange = undefined;
+    scrollX = 0;
+    constructor(inputState) {
+        super();
+        this.inputState = inputState ?? new InputState();
+        this.focusable = true;
+        // Цвета — токены темы (Н3); рамка в фокусе перекрашивается тем, что
+        // ядро ставит focus-состояние и перерезолвит стиль (render дёргается).
+        this.style = { fg: "input.foreground", bg: "input.background" };
+    }
+    /** Наблюдаемость для инспектора/e2e: текст, курсор, выделение, плейсхолдер. */
+    inspectState() {
+        return {
+            value: this.inputState.value,
+            cursorOffset: this.inputState.cursorOffset,
+            hasSelection: this.inputState.hasSelection,
+            showsPlaceholder: this.inputState.value.length === 0 && this.placeholder !== undefined,
+        };
+    }
+    // ─── Layout ─────────────────────────────────────────────────────────────
+    getMinIntrinsicWidth(_height) {
+        return this.showBorder ? 5 : 3;
+    }
+    getMinIntrinsicHeight(_width) {
+        return this.showBorder ? 3 : 1;
+    }
+    getMaxIntrinsicHeight(_width) {
+        return this.showBorder ? 3 : 1;
+    }
+    performLayout(constraints) {
+        const height = this.getMaxIntrinsicHeight(0);
+        const width = Number.isFinite(constraints.maxWidth) ? constraints.maxWidth : Math.max(constraints.minWidth, 20);
+        return super.performLayout(BoxConstraints.tight(constraints.constrain(new Size(width, height))));
+    }
+    // ─── Render ─────────────────────────────────────────────────────────────
+    render(context) {
+        const w = this.layoutSize.width;
+        const h = this.layoutSize.height;
+        const text = this.inputState.text;
+        const cursorOffset = this.inputState.cursorOffset;
+        const focused = this.isFocused;
+        const contentXStart = this.showBorder ? 1 : 0;
+        const contentY = this.showBorder ? 1 : 0;
+        const contentWidth = w - (this.showBorder ? 2 : 0);
+        if (contentWidth <= 0)
+            return;
+        // Update horizontal scroll to keep cursor visible
+        const dl = new DisplayLine(text);
+        const cursorCol = dl.offsetToColumn(cursorOffset);
+        if (cursorCol < this.scrollX) {
+            this.scrollX = cursorCol;
+        }
+        else if (cursorCol >= this.scrollX + contentWidth) {
+            this.scrollX = cursorCol - contentWidth + 1;
+        }
+        // Draw border
+        if (this.showBorder) {
+            this.renderBorder(context, w, h, focused);
+        }
+        const { fg, bg } = this.resolvedStyle;
+        // Fill content row background
+        for (let x = contentXStart; x < contentXStart + contentWidth; x++) {
+            context.setCell(x, contentY, { char: " ", fg, bg });
+        }
+        // Content area clip (screen-space coordinates)
+        const contentClip = new Rect(new Point(this.globalPosition.x + contentXStart, this.globalPosition.y + contentY), new Size(contentWidth, 1));
+        const textContext = context.withClip(contentClip);
+        // Draw text or placeholder
+        if (text.length === 0 && this.placeholder !== undefined) {
+            textContext.drawText(contentXStart, contentY, this.placeholder, {
+                fg: this.styleVar("input.placeholderForeground"),
+                bg,
+            });
+        }
+        else if (this.inputState.hasSelection) {
+            this.renderTextWithSelection(textContext, dl, text, contentXStart, contentY);
+        }
+        else {
+            textContext.drawText(contentXStart - this.scrollX, contentY, text, { fg, bg });
+        }
+        // Hardware cursor
+        if (focused) {
+            const cursorX = contentXStart + (cursorCol - this.scrollX);
+            /* v8 ignore start -- scrollX was just adjusted above to keep cursorCol within [scrollX, scrollX+contentWidth), so cursorX is always in bounds here; the false side is unreachable */
+            if (cursorX >= contentXStart && cursorX < contentXStart + contentWidth) {
+                context.setCursorPosition(cursorX, contentY);
+            }
+            /* v8 ignore stop */
+        }
+    }
+    renderTextWithSelection(context, dl, text, contentXStart, contentY) {
+        const selStart = this.inputState.selectionStart;
+        const selEnd = this.inputState.selectionEnd;
+        const before = text.slice(0, selStart);
+        const selected = text.slice(selStart, selEnd);
+        const after = text.slice(selEnd);
+        const selStartCol = dl.offsetToColumn(selStart);
+        const selEndCol = dl.offsetToColumn(selEnd);
+        const { fg, bg } = this.resolvedStyle;
+        if (before.length > 0) {
+            context.drawText(contentXStart - this.scrollX, contentY, before, { fg, bg });
+        }
+        /* v8 ignore start -- this branch only runs when inputState.hasSelection (selStart !== selEnd), so the slice is always non-empty; the false side is unreachable */
+        if (selected.length > 0) {
+            context.drawText(contentXStart + selStartCol - this.scrollX, contentY, selected, {
+                fg,
+                bg: this.styleVar("input.selectionBackground"),
+            });
+        }
+        /* v8 ignore stop */
+        // Fill selection background for empty tail columns up to selEndCol (handles wide chars)
+        for (let col = selStartCol; col < selEndCol; col++) {
+            const x = contentXStart + col - this.scrollX;
+            // Overwrite only cells that didn't get text (will be spaces from background fill)
+            // drawText already covered the chars, this handles any residual slots
+            void x;
+        }
+        if (after.length > 0) {
+            context.drawText(contentXStart + selEndCol - this.scrollX, contentY, after, { fg, bg });
+        }
+    }
+    renderBorder(context, w, h, focused) {
+        const borderFg = this.styleVar(focused ? "focusBorder" : "input.border");
+        context.drawBox(0, 0, w, h, { fg: borderFg, bg: this.resolvedStyle.bg });
+    }
+    // ─── Input ──────────────────────────────────────────────────────────────
+    performDefaultAction(event) {
+        if (event.type === "paste") {
+            // Single-line field: flatten any newlines from the pasted block into spaces.
+            const text = event.text.replace(/\n/g, " ");
+            if (text !== "") {
+                event.preventDefault();
+                this.inputState.insert(text);
+                this.onChange?.(this.inputState.value);
+                this.markDirty();
+            }
+            return;
+        }
+        if (event.type !== "keydown") {
+            // Non-keydown events (notably mousedown) fall through to the base
+            // handler, which focuses a tabbable element — so a click focuses the
+            // field. Without this, the input could only be focused programmatically.
+            super.performDefaultAction(event);
+            return;
+        }
+        const keyEvent = event;
+        if (keyEvent.key === "Backspace") {
+            event.preventDefault();
+            this.inputState.deleteLeft();
+            this.onChange?.(this.inputState.value);
+            this.markDirty();
+        }
+        else if (keyEvent.key === "Delete") {
+            event.preventDefault();
+            this.inputState.deleteRight();
+            this.onChange?.(this.inputState.value);
+            this.markDirty();
+        }
+        else if (keyEvent.key === "ArrowLeft") {
+            event.preventDefault();
+            this.inputState.moveCursorLeft();
+            this.markDirty();
+        }
+        else if (keyEvent.key === "ArrowRight") {
+            event.preventDefault();
+            this.inputState.moveCursorRight();
+            this.markDirty();
+        }
+        else if (keyEvent.key === "Home") {
+            event.preventDefault();
+            this.inputState.moveCursorToStart();
+            this.markDirty();
+        }
+        else if (keyEvent.key === "End") {
+            event.preventDefault();
+            this.inputState.moveCursorToEnd();
+            this.markDirty();
+        }
+        else if (keyEvent.key.length === 1 && !keyEvent.ctrlKey && !keyEvent.altKey) {
+            event.preventDefault();
+            this.inputState.insert(keyEvent.key);
+            this.onChange?.(this.inputState.value);
+            this.markDirty();
+        }
+    }
+}

package/dist/inputbox/inputState.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Pure state model for a single-line text input.
+ * Tracks the text and cursor position (as a grapheme-aware offset).
+ * No UI dependencies.
+ */
+export declare class InputState {
+    private textValue;
+    private cursorOffsetValue;
+    private anchorOffset;
+    private undoStack;
+    private redoStack;
+    private lastEditKind;
+    get text(): string;
+    get cursorOffset(): number;
+    get value(): string;
+    set value(v: string);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): void;
+    redo(): void;
+    private snapshot;
+    private restore;
+    /** Push a snapshot of the current state and invalidate the redo stack. */
+    private pushUndo;
+    /** Start a brand-new undo group: snapshot now, and don't coalesce the next edit into it. */
+    private breakUndo;
+    /** Record an edit that may coalesce with the previous one when it is of the same kind. */
+    private recordEdit;
+    get hasSelection(): boolean;
+    get selectionStart(): number;
+    get selectionEnd(): number;
+    get selectedText(): string;
+    clearSelection(): void;
+    selectAll(): void;
+    selectLeft(): void;
+    selectRight(): void;
+    selectToStart(): void;
+    selectToEnd(): void;
+    selectWordLeft(): void;
+    selectWordRight(): void;
+    private deleteSelection;
+    /** Insert text at the current cursor position (replaces selection if any). */
+    insert(chars: string): void;
+    /** Delete the grapheme cluster immediately to the left of the cursor (Backspace). */
+    deleteLeft(): void;
+    /** Delete the grapheme cluster immediately to the right of the cursor (Delete key). */
+    deleteRight(): void;
+    /** Move cursor one grapheme to the left (ArrowLeft). */
+    moveCursorLeft(): void;
+    /** Move cursor one grapheme to the right (ArrowRight). */
+    moveCursorRight(): void;
+    /** Move cursor to the beginning of the line (Home). */
+    moveCursorToStart(): void;
+    /** Move cursor to the end of the line (End). */
+    moveCursorToEnd(): void;
+    /** Move cursor to the start of the previous word (Ctrl+ArrowLeft). */
+    moveCursorWordLeft(): void;
+    /** Move cursor to the end of the next word (Ctrl+ArrowRight). */
+    moveCursorWordRight(): void;
+    /** Delete from cursor to the previous word boundary (Ctrl+Backspace). */
+    deleteWordLeft(): void;
+    /** Delete from cursor to the next word boundary (Ctrl+Delete). */
+    deleteWordRight(): void;
+    private moveCursorLeftRaw;
+    private moveCursorRightRaw;
+    private wordBoundaryLeft;
+    private wordBoundaryRight;
+    private static isWordChar;
+}