@armadra/agent 0.0.0-stage → 0.3.0

package/dist/tui/ansi.js

@@ -0,0 +1,420 @@
+/**
+ * ANSI 与列宽工具（设计 §12.1、§12.2）。[B4]
+ *
+ * - 列宽按字素簇（grapheme）计：东亚宽字符与 emoji 占 2 列，组合字符 / 零宽字符占 0 列，
+ *   控制字符占 0 列；CSI / OSC / APC / DCS 等转义序列不占列。
+ * - 宽度表自写（零依赖）：东亚宽 / 全角区段 + Unicode 属性转义（`\p{Emoji_Presentation}` 等）。
+ * - 所有截断 / 切片在保留 SGR 样式的同时，于末尾补 `\x1b[0m`，保证「每行末尾重置样式」。
+ */
+export const SGR_RESET = "\x1b[0m";
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+/** 东亚宽（W）与全角（F）区段，含常见 emoji 区块；按起点升序，二分查找。 */
+const WIDE_RANGES = [
+    [0x1100, 0x115f],
+    [0x231a, 0x231b],
+    [0x2329, 0x232a],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+    [0x2e80, 0x303e],
+    [0x3041, 0x33ff],
+    [0x3400, 0x4dbf],
+    [0x4e00, 0x9fff],
+    [0xa000, 0xa4cf],
+    [0xa960, 0xa97f],
+    [0xac00, 0xd7a3],
+    [0xf900, 0xfaff],
+    [0xfe10, 0xfe19],
+    [0xfe30, 0xfe6f],
+    [0xff00, 0xff60],
+    [0xffe0, 0xffe6],
+    [0x16fe0, 0x16fe4],
+    [0x17000, 0x18aff],
+    [0x1b000, 0x1b2ff],
+    [0x1f004, 0x1f004],
+    [0x1f0cf, 0x1f0cf],
+    [0x1f18e, 0x1f18e],
+    [0x1f191, 0x1f19a],
+    [0x1f1e6, 0x1f1ff],
+    [0x1f200, 0x1f202],
+    [0x1f210, 0x1f23b],
+    [0x1f240, 0x1f248],
+    [0x1f250, 0x1f251],
+    [0x1f260, 0x1f265],
+    [0x1f300, 0x1f64f],
+    [0x1f680, 0x1f6ff],
+    [0x1f7e0, 0x1f7eb],
+    [0x1f90c, 0x1f9ff],
+    [0x1fa70, 0x1faff],
+    [0x20000, 0x2fffd],
+    [0x30000, 0x3fffd],
+];
+function inWideTable(cp) {
+    let lo = 0;
+    let hi = WIDE_RANGES.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const range = WIDE_RANGES[mid];
+        if (cp < range[0])
+            hi = mid - 1;
+        else if (cp > range[1])
+            lo = mid + 1;
+        else
+            return true;
+    }
+    return false;
+}
+const ZERO_WIDTH_RE = /^[\p{Mn}\p{Me}\p{Cf}]$/u;
+const EMOJI_PRESENTATION_RE = /^\p{Emoji_Presentation}$/u;
+const PICTOGRAPHIC_RE = /^\p{Extended_Pictographic}$/u;
+/** 单个码点的列宽（0 / 1 / 2）。 */
+export function codePointWidth(cp) {
+    if (cp < 0x20 || (cp >= 0x7f && cp < 0xa0))
+        return 0;
+    if (cp < 0x300)
+        return 1;
+    const ch = String.fromCodePoint(cp);
+    if (ZERO_WIDTH_RE.test(ch))
+        return 0;
+    if (inWideTable(cp) || EMOJI_PRESENTATION_RE.test(ch))
+        return 2;
+    return 1;
+}
+/** 一个字素簇的列宽：首码点决定基础宽度；VS16（U+FE0F）把文本型 emoji 升为 2 列。 */
+export function graphemeWidth(grapheme) {
+    const first = grapheme.codePointAt(0);
+    if (first === undefined)
+        return 0;
+    if (grapheme.length === 1)
+        return codePointWidth(first);
+    const base = codePointWidth(first);
+    if (base === 0) {
+        // 孤立的组合字符：取后续码点中第一个非零宽者
+        for (const ch of grapheme) {
+            const w = codePointWidth(ch.codePointAt(0));
+            if (w > 0)
+                return w;
+        }
+        return 0;
+    }
+    if (base === 1 && grapheme.includes("\uFE0F")) {
+        const firstChar = String.fromCodePoint(first);
+        if (PICTOGRAPHIC_RE.test(firstChar))
+            return 2;
+    }
+    return base;
+}
+/** 从 i 起的转义序列长度；不是转义序列返回 0。未终止的序列吃到字符串末尾。 */
+export function escapeLengthAt(s, i) {
+    if (s.charCodeAt(i) !== 0x1b)
+        return 0;
+    const next = s[i + 1];
+    if (next === undefined)
+        return 1;
+    if (next === "[") {
+        let j = i + 2;
+        while (j < s.length) {
+            const c = s.charCodeAt(j);
+            if (c >= 0x40 && c <= 0x7e)
+                return j - i + 1;
+            j++;
+        }
+        return s.length - i;
+    }
+    if (next === "]" || next === "_" || next === "P" || next === "^" || next === "X") {
+        let j = i + 2;
+        while (j < s.length) {
+            const c = s.charCodeAt(j);
+            if (c === 0x07)
+                return j - i + 1;
+            if (c === 0x1b && s[j + 1] === "\\")
+                return j - i + 2;
+            j++;
+        }
+        return s.length - i;
+    }
+    return 2;
+}
+export function stripAnsi(s) {
+    if (!s.includes("\x1b"))
+        return s;
+    let out = "";
+    let i = 0;
+    while (i < s.length) {
+        const esc = escapeLengthAt(s, i);
+        if (esc > 0) {
+            i += esc;
+            continue;
+        }
+        out += s[i];
+        i++;
+    }
+    return out;
+}
+function isPlainAscii(s) {
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return false;
+    }
+    return true;
+}
+/** 字符串（不含转义序列）的列宽。 */
+function textWidth(text) {
+    if (isPlainAscii(text))
+        return text.length;
+    let width = 0;
+    for (const { segment } of segmenter.segment(text))
+        width += graphemeWidth(segment);
+    return width;
+}
+/** 可见列宽：跳过 ANSI 转义序列，按字素簇计宽。 */
+export function visibleWidth(s) {
+    if (isPlainAscii(s))
+        return s.length;
+    return textWidth(stripAnsi(s));
+}
+function* pieces(s) {
+    let i = 0;
+    while (i < s.length) {
+        const esc = escapeLengthAt(s, i);
+        if (esc > 0) {
+            yield { text: s.slice(i, i + esc), width: 0, escape: true };
+            i += esc;
+            continue;
+        }
+        let j = i;
+        while (j < s.length && s.charCodeAt(j) !== 0x1b)
+            j++;
+        const run = s.slice(i, j);
+        if (isPlainAscii(run)) {
+            for (const ch of run)
+                yield { text: ch, width: 1, escape: false };
+        }
+        else {
+            for (const { segment } of segmenter.segment(run)) {
+                yield { text: segment, width: graphemeWidth(segment), escape: false };
+            }
+        }
+        i = j;
+    }
+}
+function isSgr(seq) {
+    return seq.startsWith("\x1b[") && seq.endsWith("m");
+}
+function isSgrReset(seq) {
+    return seq === "\x1b[0m" || seq === "\x1b[m";
+}
+/** 跟踪当前生效的 SGR 序列（遇到重置清空）。 */
+class SgrState {
+    codes = [];
+    apply(seq) {
+        if (!isSgr(seq))
+            return;
+        if (isSgrReset(seq))
+            this.codes = [];
+        else
+            this.codes.push(seq);
+    }
+    get active() {
+        return this.codes.join("");
+    }
+    get any() {
+        return this.codes.length > 0;
+    }
+}
+/** 截断到不超过 width 列；超出时以 ellipsis 结尾；含样式时末尾补重置。 */
+export function truncateToWidth(s, width, ellipsis = "…") {
+    if (width <= 0)
+        return "";
+    if (visibleWidth(s) <= width)
+        return s;
+    const ellWidth = visibleWidth(ellipsis);
+    const budget = ellWidth > width ? width : width - ellWidth;
+    let out = "";
+    let used = 0;
+    let styled = false;
+    for (const piece of pieces(s)) {
+        if (piece.escape) {
+            out += piece.text;
+            if (isSgr(piece.text))
+                styled = true;
+            continue;
+        }
+        if (used + piece.width > budget)
+            break;
+        out += piece.text;
+        used += piece.width;
+    }
+    if (ellWidth <= width)
+        out += ellipsis;
+    return styled ? out + SGR_RESET : out;
+}
+/**
+ * 取 [start, end) 列区间。开头补上 start 处生效的 SGR，末尾补重置；
+ * 被边界切开的宽字符用空格代替，保证结果恰好占 end - start 列（不足时按原内容）。
+ */
+export function sliceByColumn(s, start, end) {
+    if (end <= start)
+        return "";
+    const state = new SgrState();
+    let out = "";
+    let col = 0;
+    let started = false;
+    let styled = false;
+    for (const piece of pieces(s)) {
+        if (piece.escape) {
+            if (!started && (col < start || isSgr(piece.text)))
+                state.apply(piece.text);
+            else if (col < end) {
+                out += piece.text;
+                if (isSgr(piece.text))
+                    styled = true;
+            }
+            continue;
+        }
+        const next = col + piece.width;
+        if (next <= start) {
+            col = next;
+            continue;
+        }
+        if (col >= end)
+            break;
+        if (!started) {
+            started = true;
+            if (state.any) {
+                out = state.active + out;
+                styled = true;
+            }
+        }
+        if (col < start || next > end) {
+            // 宽字符跨边界：只保留落在区间内的列，用空格填充
+            const inside = Math.min(next, end) - Math.max(col, start);
+            out += " ".repeat(inside);
+        }
+        else {
+            out += piece.text;
+        }
+        col = next;
+    }
+    return styled ? out + SGR_RESET : out;
+}
+/** 右侧补空格到 width 列（已超出则原样返回）。 */
+export function padToWidth(s, width) {
+    const w = visibleWidth(s);
+    return w >= width ? s : s + " ".repeat(width - w);
+}
+/** 自动换行：按空白断词，超长词按字素断开；样式跨行延续（行尾重置、下一行开头恢复）。 */
+export function wrapTextWithAnsi(text, width) {
+    if (width <= 0)
+        return [""];
+    const result = [];
+    const state = new SgrState();
+    for (const logical of text.split("\n")) {
+        wrapLogicalLine(logical, width, state, result);
+    }
+    return result;
+}
+function wrapLogicalLine(line, width, state, out) {
+    let current = state.active;
+    let currentWidth = 0;
+    let styledLine = state.any;
+    let pendingSpace = "";
+    let pendingSpaceWidth = 0;
+    let word = [];
+    let wordWidth = 0;
+    const flushLine = () => {
+        out.push(styledLine ? current + SGR_RESET : current);
+        current = state.active;
+        currentWidth = 0;
+        styledLine = state.any;
+    };
+    const appendPiece = (piece) => {
+        if (piece.escape) {
+            state.apply(piece.text);
+            if (isSgr(piece.text))
+                styledLine = true;
+        }
+        current += piece.text;
+        currentWidth += piece.width;
+    };
+    const flushWord = () => {
+        if (word.length === 0)
+            return;
+        // 放不下且整词不超过一行：换行再放；超过一行的长词直接在当前行开始硬断
+        const fits = currentWidth + pendingSpaceWidth + wordWidth <= width;
+        if (currentWidth > 0 && !fits && wordWidth <= width) {
+            flushLine();
+            pendingSpace = "";
+            pendingSpaceWidth = 0;
+        }
+        if (currentWidth > 0 || pendingSpaceWidth > 0) {
+            if (currentWidth + pendingSpaceWidth <= width) {
+                current += pendingSpace;
+                currentWidth += pendingSpaceWidth;
+            }
+        }
+        pendingSpace = "";
+        pendingSpaceWidth = 0;
+        for (const piece of word) {
+            if (!piece.escape && currentWidth + piece.width > width && currentWidth > 0)
+                flushLine();
+            appendPiece(piece);
+        }
+        word = [];
+        wordWidth = 0;
+    };
+    for (const piece of pieces(line)) {
+        if (piece.escape) {
+            word.push(piece);
+            continue;
+        }
+        if (piece.text === " ") {
+            flushWord();
+            pendingSpace += " ";
+            pendingSpaceWidth += 1;
+            continue;
+        }
+        if (piece.width === 2) {
+            // 宽字符（中日韩、emoji）之间都可断行
+            flushWord();
+            word.push(piece);
+            wordWidth = 2;
+            flushWord();
+            continue;
+        }
+        word.push(piece);
+        wordWidth += piece.width;
+    }
+    flushWord();
+    flushLine();
+}

package/dist/tui/component.d.ts

@@ -0,0 +1,38 @@
+/**
+ * TUI 组件模型契约（设计 §12.1、§12.7）。[B0] 契约文件，组件库实现归 B4。
+ *
+ * 补全与偏差：
+ * - 设计的 `Theme` 写作 `bg(...)` 与 `bold/dim/italic/underline(s)`，此处展开为完整签名。
+ * - `SemanticColor` 取 §12.7 的 11 个语义色名。
+ * - 补全 `CURSOR_MARKER` 常量与 `isFocusable()` 判别函数（B4 的 tui.ts 与 B7 都要用）。
+ */
+/** APC 序列；获焦组件在光标处输出它，TUI 据此摆硬件光标并在输出前剔除。 */
+export declare const CURSOR_MARKER = "\u001B_ama:c\u0007";
+export interface Component {
+    /** 每行可见宽 ≤ width；每行末尾重置样式。 */
+    render(width: number): string[];
+    /** 焦点组件收原始键数据。 */
+    handleInput?(data: string): void;
+    /** 主题 / 状态变化时清缓存。 */
+    invalidate(): void;
+}
+export interface Focusable {
+    focused: boolean;
+}
+export declare function isFocusable(component: Component): component is Component & Focusable;
+export type SemanticColor = "text" | "dim" | "accent" | "success" | "warning" | "error" | "user" | "assistant" | "tool" | "border" | "code";
+/** 0 = 无色（NO_COLOR）；16_777_216 = truecolor。 */
+export type ColorDepth = 0 | 16 | 256 | 16_777_216;
+export interface ThemeCapabilities {
+    colors: ColorDepth;
+}
+export interface Theme {
+    readonly name: string;
+    fg(color: SemanticColor, text: string): string;
+    bg(color: SemanticColor, text: string): string;
+    bold(text: string): string;
+    dim(text: string): string;
+    italic(text: string): string;
+    underline(text: string): string;
+    readonly caps: ThemeCapabilities;
+}

package/dist/tui/component.js

@@ -0,0 +1,13 @@
+/**
+ * TUI 组件模型契约（设计 §12.1、§12.7）。[B0] 契约文件，组件库实现归 B4。
+ *
+ * 补全与偏差：
+ * - 设计的 `Theme` 写作 `bg(...)` 与 `bold/dim/italic/underline(s)`，此处展开为完整签名。
+ * - `SemanticColor` 取 §12.7 的 11 个语义色名。
+ * - 补全 `CURSOR_MARKER` 常量与 `isFocusable()` 判别函数（B4 的 tui.ts 与 B7 都要用）。
+ */
+/** APC 序列；获焦组件在光标处输出它，TUI 据此摆硬件光标并在输出前剔除。 */
+export const CURSOR_MARKER = "\x1b_ama:c\x07";
+export function isFocusable(component) {
+    return typeof component.focused === "boolean";
+}

package/dist/tui/components/box.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 边框 / 内边距容器（设计 §12.1）。[B4]
+ *
+ * 子组件按内宽渲染后加圆角边框（可选标题，嵌在上边框）与内边距；宽度不足 4 列时退化为只加内边距。
+ * 焦点与键输入透传给子组件，所以可以直接把 `Box(SelectList)` 交给 `showOverlay`。
+ */
+import { type Component, type Theme } from "../component.js";
+export interface BoxOptions {
+    border?: boolean;
+    paddingX?: number;
+    paddingY?: number;
+    title?: string;
+    theme?: Theme;
+}
+export declare class Box implements Component {
+    readonly child: Component;
+    private readonly options;
+    constructor(child: Component, options?: BoxOptions);
+    /** 焦点与输入透传给子组件（覆盖层里常用 Box 包一层）。 */
+    get focused(): boolean;
+    set focused(value: boolean);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    private topBorder;
+    invalidate(): void;
+}

package/dist/tui/components/box.js

@@ -0,0 +1,65 @@
+/**
+ * 边框 / 内边距容器（设计 §12.1）。[B4]
+ *
+ * 子组件按内宽渲染后加圆角边框（可选标题，嵌在上边框）与内边距；宽度不足 4 列时退化为只加内边距。
+ * 焦点与键输入透传给子组件，所以可以直接把 `Box(SelectList)` 交给 `showOverlay`。
+ */
+import { isFocusable } from "../component.js";
+import { padToWidth, truncateToWidth, visibleWidth } from "../ansi.js";
+export class Box {
+    child;
+    options;
+    constructor(child, options = {}) {
+        this.child = child;
+        this.options = options;
+    }
+    /** 焦点与输入透传给子组件（覆盖层里常用 Box 包一层）。 */
+    get focused() {
+        return isFocusable(this.child) ? this.child.focused : false;
+    }
+    set focused(value) {
+        if (isFocusable(this.child))
+            this.child.focused = value;
+    }
+    handleInput(data) {
+        this.child.handleInput?.(data);
+    }
+    render(width) {
+        const border = this.options.border !== false && width >= 4;
+        const padX = this.options.paddingX ?? 1;
+        const padY = this.options.paddingY ?? 0;
+        const frame = border ? 2 : 0;
+        const inner = Math.max(1, width - frame - padX * 2);
+        const body = this.child.render(inner);
+        const color = (s) => this.options.theme ? this.options.theme.fg("border", s) : s;
+        const pad = " ".repeat(padX);
+        const contentWidth = Math.max(0, width - frame);
+        const rows = [];
+        const emptyRow = " ".repeat(contentWidth);
+        for (let i = 0; i < padY; i++)
+            rows.push(emptyRow);
+        for (const line of body) {
+            rows.push(padToWidth(pad + truncateToWidth(line, inner), contentWidth));
+        }
+        for (let i = 0; i < padY; i++)
+            rows.push(emptyRow);
+        if (!border)
+            return rows;
+        const lines = [this.topBorder(width, color)];
+        for (const row of rows)
+            lines.push(color("│") + row + color("│"));
+        lines.push(color("╰" + "─".repeat(width - 2) + "╯"));
+        return lines;
+    }
+    topBorder(width, color) {
+        const title = this.options.title;
+        if (title === undefined || title === "")
+            return color("╭" + "─".repeat(width - 2) + "╮");
+        const label = truncateToWidth(` ${title} `, width - 4);
+        const rest = Math.max(0, width - 3 - visibleWidth(label));
+        return color("╭─") + label + color("─".repeat(rest) + "╮");
+    }
+    invalidate() {
+        this.child.invalidate();
+    }
+}

package/dist/tui/components/container.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 纵向容器（设计 §12.1）：子组件的行按顺序拼接；无布局引擎。[B4]
+ */
+import type { Component } from "../component.js";
+export declare class Container implements Component {
+    readonly children: Component[];
+    addChild(child: Component): void;
+    /** 插到 before 之前；before 不在容器内则追加到末尾。 */
+    insertBefore(child: Component, before: Component): void;
+    removeChild(child: Component): boolean;
+    clear(): void;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/tui/components/container.js

@@ -0,0 +1,39 @@
+/**
+ * 纵向容器（设计 §12.1）：子组件的行按顺序拼接；无布局引擎。[B4]
+ */
+export class Container {
+    children = [];
+    addChild(child) {
+        this.children.push(child);
+    }
+    /** 插到 before 之前；before 不在容器内则追加到末尾。 */
+    insertBefore(child, before) {
+        const index = this.children.indexOf(before);
+        if (index === -1)
+            this.children.push(child);
+        else
+            this.children.splice(index, 0, child);
+    }
+    removeChild(child) {
+        const index = this.children.indexOf(child);
+        if (index === -1)
+            return false;
+        this.children.splice(index, 1);
+        return true;
+    }
+    clear() {
+        this.children.length = 0;
+    }
+    render(width) {
+        const lines = [];
+        for (const child of this.children) {
+            for (const line of child.render(width))
+                lines.push(line);
+        }
+        return lines;
+    }
+    invalidate() {
+        for (const child of this.children)
+            child.invalidate();
+    }
+}

package/dist/tui/components/editor-buffer.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 编辑器文本缓冲（设计 §12.4）：行 / 光标 / 撤销栈（50 步）/ 单词导航 / 不可分割段。[B4]
+ *
+ * - 光标列是该行内的 UTF-16 下标，移动与删除按字素簇进行（emoji、组合字符不会被切开）。
+ * - 不可分割段（大粘贴折叠标记）由 `atomic` 回调按行给出区间：光标不会停在段内，
+ *   退格 / 删除 / 删词把整段一起删掉，单词导航把整段当作一个词。
+ * - 撤销：每次编辑前存快照；连续输入同类字符合并为一步；上限 50 步。
+ * - 不做选区（无鼠标、无 kill ring，§12.9）。
+ */
+export interface Position {
+    line: number;
+    col: number;
+}
+export type AtomicRanges = (line: string) => ReadonlyArray<readonly [number, number]>;
+export interface EditorBufferOptions {
+    undoLimit?: number;
+    atomic?: AtomicRanges;
+}
+export declare class EditorBuffer {
+    private lines;
+    private cur;
+    private undoStack;
+    private lastKind;
+    private readonly undoLimit;
+    private readonly atomic;
+    constructor(options?: EditorBufferOptions);
+    get cursor(): Position;
+    getLines(): readonly string[];
+    getText(): string;
+    isEmpty(): boolean;
+    get undoDepth(): number;
+    /** 替换全部文本，光标到末尾。recordUndo=false 时不进撤销栈（历史浏览、提交清空）。 */
+    setText(text: string, recordUndo?: boolean): void;
+    /** 清空并丢弃撤销历史。 */
+    reset(): void;
+    setCursor(pos: Position): void;
+    /** 插入文本（可含换行）。 */
+    insert(text: string): void;
+    newLine(): void;
+    backspace(): void;
+    deleteForward(): void;
+    moveLeft(): void;
+    moveRight(): void;
+    moveLineStart(): void;
+    moveLineEnd(): void;
+    moveWordLeft(): void;
+    moveWordRight(): void;
+    deleteWordBackward(): void;
+    deleteWordForward(): void;
+    deleteToLineStart(): void;
+    deleteToLineEnd(): void;
+    undo(): boolean;
+    /** 光标所在行内、光标前的文本（补全提供者用）。 */
+    textBeforeCursor(): string;
+    /** 把当前行 [from, cursor) 替换为 text（补全接受）。 */
+    replaceBeforeCursor(from: number, text: string): void;
+    private deleteRange;
+    private snapshot;
+    private atomicAt;
+    private snapOutOfAtomic;
+    /** 光标左侧的停靠点（字素簇或整段不可分割段）。 */
+    private prevStop;
+    private nextStop;
+    private classAt;
+    private wordStartBefore;
+    private wordEndAfter;
+}