berry-agent 0.1.0-alpha.1

package/dist/channels/service.js

@@ -0,0 +1,169 @@
+/**
+ * channels 件聚合工厂（L4 宿主固定件——02 篇席 10；批 10a 通道核）。
+ *
+ * 组合四件：SessionChannels（多会话注册/焦点/重画）+ CommandRegistry（命令面）
+ * + UiCore（七原语分发核）+ AskQueue（提问队列）。后端（UiBackend）经
+ * addBackend 注入——TUI 实装批接线 pi-tui、webui 件同面接入；核零 pi-tui
+ * import（件分两面定形——07 §4.1 channels 纵切批注记）。
+ *
+ * host 装配序（批 12）：createChannels → addBackend(tui) → registerSession/
+ * focus（TUI 启动会话策略——07 §5）→ conversation 侧 per-run sink 汇入 emit。
+ */
+import { BaseError } from '../contracts/index.js';
+import { CommandRegistry } from './commands.js';
+import { AskQueue } from './ask-queue.js';
+import { UiCore } from './ui-core.js';
+import { SessionChannels } from './registry.js';
+/** 通道核工厂（投影类型 TProjection 由装配侧钉——不 import session 的边表执法） */
+export function createChannels(opts = {}) {
+    const backends = [];
+    // 插件域后端集合（03 §2.7 分域律——U3 批 U3-3）：upsert/撞名/disposer 全只
+    // 在本域内匹配，宿主域结构性不可及。插件实装形 = UiBackend<never>——投影
+    // 泛型宿主装配钉入，插件后端走信封驱动呈现、不参与投影重画（03 §2.2
+    // registerUiBackend 定形注记；SDK/webui 后端同形先例）
+    const pluginBackends = [];
+    // 全量扇出视图（宿主域在前、插件域在后——注册序内稳定）：插件域 never 形
+    // 经方法双变结构兼容并入 TProjection 序列（onRepaint 等均方法语法声明）；
+    // UiCore 持 never 形以保自身非泛型——边界处 as（单域时代同洞）
+    const allBackends = () => [...backends, ...pluginBackends];
+    const backendsForCore = () => allBackends();
+    const askQueue = new AskQueue();
+    const uiCore = new UiCore(backendsForCore, askQueue, opts.onApprovalAlways);
+    const commands = new CommandRegistry();
+    const registry = new SessionChannels(opts.fetchProjection, (sessionId, projection) => {
+        // repaint 扇出：带上该会话当前 widget 槽值（07 §4.3 单槽重放）——双域合流
+        const widget = uiCore.widgetOf(sessionId);
+        for (const b of allBackends())
+            b.onRepaint?.(sessionId, projection, widget);
+    });
+    // 件 8 /history 注册面（07 §4.1 条款：history() 注入在场即注册、缺席不注册
+    // 不虚报——真源 = 聚焦会话 → 拉全量 durable 正文投影 → 扇出后端 openHistory；
+    // 生产数据源接线归批 12 host 装配）
+    if (opts.history !== undefined) {
+        const fetchHistory = opts.history;
+        commands.register('history', async () => {
+            const sessionId = registry.focusedId;
+            if (sessionId === null)
+                return; // 焦点空悬——无回看对象（静默返回不虚报）
+            const messages = await fetchHistory(sessionId);
+            for (const b of allBackends())
+                b.openHistory?.(sessionId, messages);
+        }, '全屏回看会话历史');
+    }
+    // /memory 注册面（06 §7 形态定形注①——memory 注入在场即注册、缺席不注册
+    // 不虚报；同 /history 注册面律）：管理面是全局面无会话归属，扇出后端
+    // openMemory（零参——材料后端自持）；全体 falsy（后端不支持或件缺席）时
+    // notify 降级提示（warn 档——不静默假装已开）；无观众后端时静默返回
+    // （notify 扇出无人接帧——与焦点空悬同族的不虚报位）
+    if (opts.memory !== undefined) {
+        commands.register('memory', async () => {
+            let opened = false;
+            for (const b of allBackends()) {
+                if (b.openMemory?.() === true)
+                    opened = true; // 任一后端已开即成功（先开胜出）
+            }
+            if (!opened) {
+                // notify 非阻塞不分会话呈现位（service.notify 同律——uiCore 直扇出）
+                uiCore.notify('当前通道不支持记忆管理面（或 memory 件未装载）', { level: 'warn' });
+            }
+        }, '记忆管理面（冻结/忘掉/恢复/导出）');
+    }
+    return {
+        commands,
+        addBackend(backend) {
+            backends.push(backend);
+        },
+        removeBackend(id) {
+            const index = backends.findIndex((b) => b.id === id);
+            if (index !== -1)
+                backends.splice(index, 1);
+        },
+        registerPluginBackend(backend) {
+            // 分域律执法（03 §2.7）：撞宿主域 id 顶替拒——比保留 id 名单更根治
+            // （名单漏一项即穿，分域无此面；07 §4 宿主后端恒在场条款承载）
+            if (backends.some((b) => b.id === backend.id)) {
+                throw new BaseError('CHANNEL_BACKEND_RESERVED', `后端 id「${backend.id}」是宿主域后端——插件结构性不可顶替（03 §2.7 分域律；07 §4 宿主后端恒在场），请换 id 注册`);
+            }
+            // 插件域内按 id 后写胜出（upsert 原位顶替——扇出序稳定不移尾；同
+            // registerCommand 换装哲学：同 id 顶替 = 显式换装后端正道）
+            const index = pluginBackends.findIndex((b) => b.id === backend.id);
+            if (index === -1)
+                pluginBackends.push(backend);
+            else
+                pluginBackends[index] = backend;
+            // disposer 三律②：仅当仍是本后端时摘除（indexOf 身份闸——同 id 后写
+            // 顶替后旧 disposer 调用为无操作）
+            return () => {
+                const at = pluginBackends.indexOf(backend);
+                if (at !== -1)
+                    pluginBackends.splice(at, 1);
+            };
+        },
+        listPluginBackendIds() {
+            return pluginBackends.map((b) => b.id);
+        },
+        registerSession(sessionId) {
+            registry.registerSession(sessionId);
+        },
+        unregisterSession(sessionId) {
+            registry.unregisterSession(sessionId);
+            uiCore.closeSession(sessionId);
+        },
+        hasSession(sessionId) {
+            return registry.has(sessionId);
+        },
+        focus(sessionId) {
+            return registry.focus(sessionId);
+        },
+        isFocused(sessionId) {
+            return registry.isFocused(sessionId);
+        },
+        get focusedId() {
+            return registry.focusedId;
+        },
+        emit(env) {
+            const focused = registry.isFocused(env.sessionId);
+            // 信封路由双域合流扇出（聚焦全渲染/非聚焦摘要行——形态归后端）
+            for (const b of allBackends())
+                b.onEnvelope?.(env, focused);
+        },
+        notify(sessionId, message, notifyOpts) {
+            // notify 非阻塞不分会话呈现位——sessionId 位保留给呈现侧路由（后端自决）
+            void sessionId;
+            uiCore.notify(message, notifyOpts);
+        },
+        confirm(sessionId, message, askOpts) {
+            return uiCore.confirm(sessionId, message, askOpts);
+        },
+        select(sessionId, message, choices, askOpts) {
+            return uiCore.select(sessionId, message, choices, askOpts);
+        },
+        input(sessionId, message, askOpts) {
+            return uiCore.input(sessionId, message, askOpts);
+        },
+        askApproval(sessionId, request, askOpts) {
+            return uiCore.askApproval(sessionId, request, askOpts);
+        },
+        setStatus(sessionId, status) {
+            uiCore.setStatus(sessionId, status);
+        },
+        setWidget(sessionId, node) {
+            uiCore.setWidget(sessionId, node);
+        },
+        hasAudience() {
+            return uiCore.hasAudience();
+        },
+        pendingAsks(sessionId) {
+            return uiCore.pending(sessionId);
+        },
+        registerCommand(name, handler, description) {
+            return commands.register(name, handler, description);
+        },
+        dispatchCommand(input, sessionId) {
+            return commands.dispatch(input, sessionId);
+        },
+        listCommands() {
+            return commands.list();
+        },
+    };
+}

package/dist/channels/tui/autocomplete/autocomplete.js

@@ -0,0 +1,42 @@
+import { firstTokenRange, tokenAtCursor } from './token.js';
+/** 三源合一补全器 */
+export class CombinedAutocompleteProvider {
+    sources;
+    constructor(sources = {}) {
+        this.sources = sources;
+    }
+    /** 取补全（无 token / 无对应源 / 源空 → null——弹层不显） */
+    getCompletions(context) {
+        const line = context.lines[context.cursorLine] ?? '';
+        const token = tokenAtCursor(line, context.cursorCol);
+        if (token === null || token.text === '')
+            return null; // 无 token 段——不补
+        // 路由一：@ 前缀（任意位置——命令参数段内也可 mention 文件）
+        if (token.text.startsWith('@')) {
+            return this.collect(this.sources.mentions?.(token.text.slice(1)), token.start, token.end);
+        }
+        // 命令段判据只在首逻辑行（多行输入的斜杠命令 = 首行起手式）
+        if (context.cursorLine !== 0)
+            return null;
+        const first = firstTokenRange(line);
+        if (first === null)
+            return null; // 行首无 token（光标 token 不在行首矛盾——防御位）
+        if (token.start === first.start) {
+            // 路由二：光标就在首 token 内且 / 前缀——命令名段
+            if (!token.text.startsWith('/'))
+                return null; // 首 token 非命令——普通文本不补
+            return this.collect(this.sources.commands?.(token.text.slice(1)), token.start, token.end);
+        }
+        // 路由三：首 token 是已终结命令（/xxx）——光标 token 属参数段
+        const firstText = line.slice(first.start, first.end);
+        if (!firstText.startsWith('/'))
+            return null; // 行首非命令——后续 token 也不补
+        return this.collect(this.sources.commandArguments?.(firstText.slice(1), token.text), token.start, token.end);
+    }
+    /** 源结果收口（空源 / 空条目统一 null） */
+    collect(items, replaceStart, replaceEnd) {
+        if (items === undefined || items.length === 0)
+            return null;
+        return { items, replaceStart, replaceEnd };
+    }
+}

package/dist/channels/tui/autocomplete/file-mentions.js

@@ -0,0 +1,106 @@
+/**
+ * @ 文件段补全源（07 §4.1 补全三合一第三源——mentions 源的实机行走件）。
+ *
+ * 语义承 berry 蓝本 getFileSuggestions 的 v1 子集：
+ * - **目录列举 + 前缀过滤**（非模糊行走——fuzzy 全库发现随 fd 批挂账，
+ *   `BERRY_AGENT_FD_PATH` 环境变量是其消费点、本批不触）；
+ * - 路径段解析：`src/ap` → 列 `src` 滤 `ap`；尾 `/` = 列该目录；相对段
+ *   对 basePath（装配注入 cwd）、`~/` 展开家目录、`/` 起绝对位列举；
+ * - `.git` 跳过（版本库内脏）；符号链指目录归类为目录（label 尾 `/`
+ *   续深——断链/不可及跳过）；
+ * - 排序：目录优先、再 label 字典序；条目帽防大目录全量；
+ * - **引号形**（provider 协议条款）：路径含空白或前缀已引号 → replacement
+ *   以 `@"…"` 包裹防尾空格击穿（tokenAtCursor 引号感知整 token 的续补位）。
+ *
+ * 件内零缓存（同一目录反复列举随实机批定 cache 策略）；同步 IO——
+ * mentions 源协议面是同步（单目录列举毫秒级，弹层窗口 10 行消费帽内）。
+ */
+import { readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import * as path from 'node:path';
+/** 条目帽缺省（源侧规模锁——弹层自身另有窗口滚动帽） */
+const DEFAULT_MAX_ITEMS = 50;
+/** 引号前缀解析（`"my f` / `"my file.txt"` → 内文；`~/` 形原样） */
+function parseQuotedPrefix(query) {
+    const head = query[0];
+    if (head === '"' || head === "'") {
+        let inner = query.slice(1);
+        if (inner.endsWith(head))
+            inner = inner.slice(0, -1); // 已敲闭引号——内文为准
+        return { rawPrefix: inner, isQuoted: true };
+    }
+    return { rawPrefix: query, isQuoted: false };
+}
+/** @ 文件段补全源：`mentions` 源协议面的实机适配（注入 autocomplete.mentions） */
+export class FileMentionSource {
+    basePath;
+    maxItems;
+    constructor(options) {
+        this.basePath = options.basePath;
+        this.maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    }
+    /** 源适配面（query = 去 @ 前缀的 token 内文——可能带引号头） */
+    get = (query) => {
+        const { rawPrefix, isQuoted } = parseQuotedPrefix(query);
+        // '~' 裸形与 '~/' 同为家目录根列举（filePart 空）
+        const isHomeRoot = rawPrefix === '~' || rawPrefix === '~/';
+        const slash = rawPrefix.lastIndexOf('/');
+        const dirPart = isHomeRoot ? '~/' : slash >= 0 ? rawPrefix.slice(0, slash + 1) : '';
+        const filePart = isHomeRoot ? '' : slash >= 0 ? rawPrefix.slice(slash + 1) : rawPrefix;
+        const searchDir = this.resolveSearchDir(dirPart);
+        if (searchDir === null)
+            return []; // 不可解析形态
+        let entries;
+        try {
+            entries = readdirSync(searchDir, { withFileTypes: true });
+        }
+        catch {
+            return []; // 缺目录 / 不可及——空集（补全静默退场）
+        }
+        const lowerPrefix = filePart.toLowerCase();
+        const items = [];
+        for (const entry of entries) {
+            if (entry.name === '.git')
+                continue; // 版本库内脏
+            if (!entry.name.toLowerCase().startsWith(lowerPrefix))
+                continue;
+            // 目录归类：符号链补一次 stat（断链/竞态不可及——跳过）
+            let isDirectory = entry.isDirectory();
+            if (!isDirectory && entry.isSymbolicLink()) {
+                try {
+                    isDirectory = statSync(path.join(searchDir, entry.name)).isDirectory();
+                }
+                catch {
+                    continue;
+                }
+            }
+            // replacement 保用户敲的 dirPart 形（~/ 与绝对形原样续接）
+            const pathValue = `${dirPart}${entry.name}${isDirectory ? '/' : ''}`;
+            items.push({
+                label: `${entry.name}${isDirectory ? '/' : ''}`,
+                replacement: `@${isQuoted || /\s/.test(pathValue) ? `"${pathValue}"` : pathValue}`,
+            });
+        }
+        // 目录优先、再 label 字典序（承 berry 排序语义）
+        items.sort((a, b) => {
+            const aDir = a.label.endsWith('/');
+            const bDir = b.label.endsWith('/');
+            if (aDir !== bDir)
+                return aDir ? -1 : 1;
+            return a.label.localeCompare(b.label);
+        });
+        return items.slice(0, this.maxItems);
+    };
+    /** 列举目录解析（相对段对 basePath；~/ 家目录；/ 起绝对位） */
+    resolveSearchDir(dirPart) {
+        if (dirPart === '' || dirPart === './')
+            return path.resolve(this.basePath, dirPart);
+        if (dirPart === '~/')
+            return homedir();
+        if (dirPart.startsWith('~/'))
+            return path.resolve(homedir(), dirPart.slice(2));
+        if (dirPart.startsWith('/'))
+            return path.resolve(dirPart);
+        return path.resolve(this.basePath, dirPart);
+    }
+}

package/dist/channels/tui/autocomplete/popup.js

@@ -0,0 +1,148 @@
+import { ansiColor } from '../../engine/index.js';
+import { ACCENT_INDEX } from '../theme.js';
+import { prefixDisplayWidth } from '../editor/visual-lines.js';
+/** 弹层可见条目帽（超出窗口滚动跟随高亮） */
+const MAX_VISIBLE_ITEMS = 10;
+/** 高亮行样式（整行反色——与 SelectPanel 同视觉语言） */
+const ACTIVE_STYLE = Object.freeze({ inverse: true });
+/** 补充说明段样式（dim） */
+const DETAIL_STYLE = Object.freeze({ dim: true });
+/** 无候选提示样式（accent——theme 单源） */
+const EMPTY_STYLE = Object.freeze({ fg: ansiColor(ACCENT_INDEX) });
+/** 弹层件：provider 只读消费 + 模型代换原语调用 */
+export class AutocompletePopup {
+    result = null;
+    activeIndex = 0;
+    windowStart = 0;
+    provider;
+    model;
+    constructor(provider, model) {
+        this.provider = provider;
+        this.model = model;
+    }
+    /** 弹层在场态（无补全不显） */
+    get visible() {
+        return this.result !== null;
+    }
+    /** 高亮下标（测试观测面） */
+    get activeItemIndex() {
+        return this.activeIndex;
+    }
+    /** 重取补全（每次输入变更后装配调——无补全自然隐藏） */
+    refresh() {
+        const cursor = this.model.getCursor();
+        this.result = this.provider.getCompletions({
+            lines: this.model.getLines(),
+            cursorLine: cursor.line,
+            cursorCol: cursor.col,
+        });
+        this.activeIndex = 0;
+        this.windowStart = 0;
+    }
+    /** 量高：可见条目数（不可见 = 0——浮层不占布局） */
+    measure(width) {
+        void width;
+        const count = this.result?.items.length ?? 0;
+        return Math.min(count, MAX_VISIBLE_ITEMS);
+    }
+    /** 落位：铺底空格 → 可见窗条目行（高亮反色 + 说明右对齐） */
+    render(buffer, region) {
+        if (this.result === null)
+            return;
+        // 铺底空格（写格覆盖——未写格会透出主树文字）
+        for (let r = 0; r < region.height; r++) {
+            for (let c = 0; c < region.width; c++) {
+                buffer.setCell(region.row + r, region.col + c, ' ');
+            }
+        }
+        const items = this.result.items;
+        if (items.length === 0) {
+            buffer.writeText(region.row, region.col, '无匹配', EMPTY_STYLE);
+            return;
+        }
+        const end = Math.min(items.length, this.windowStart + MAX_VISIBLE_ITEMS);
+        for (let i = this.windowStart; i < end; i++) {
+            const row = region.row + (i - this.windowStart);
+            const item = items[i];
+            const active = i === this.activeIndex;
+            const prefix = active ? '❯ ' : '  ';
+            buffer.writeText(row, region.col, `${prefix}${item.label}`, active ? ACTIVE_STYLE : undefined);
+            if (item.detail !== undefined && item.detail.length > 0) {
+                // 右对齐按显示宽（CJK 段宽 ≠ 码位数）
+                const detailCols = prefixDisplayWidth(item.detail, item.detail.length);
+                buffer.writeText(row, region.col + region.width - detailCols, item.detail, DETAIL_STYLE);
+            }
+        }
+    }
+    /** 事件分发（弹层可见才有意义）：↑/↓ / enter / tab / escape，其余穿透 */
+    handleEvent(event) {
+        if (this.result === null)
+            return false; // 不在场不挡键
+        if (event.kind !== 'key')
+            return false; // 文本 / IME / 粘贴穿透回输入件
+        if (event.phase === 'release')
+            return false;
+        if (event.ctrl || event.alt || event.shift || event.meta)
+            return false; // 修饰组合穿透（编辑键面）
+        if (event.key === 'up') {
+            this.moveActive(-1);
+            return true;
+        }
+        if (event.key === 'down') {
+            this.moveActive(1);
+            return true;
+        }
+        if (event.key === 'enter' || event.key === 'tab') {
+            // 全量输入穿透律（2026-09-13 真模型五轮实测定罪修复）：当前 token 已是
+            // 高亮项 replacement 全文时，enter 的「应用」是无净代换的空动作——吞键
+            // 会把完整输入的斜杠命令逼成「先应用再提交」双 enter 形（且第二次输入
+            // 与残留拼接进模型）。此处 enter 穿透回编辑器走提交语义；tab 专职填充
+            // 无提交歧义、恒应用（键面分离）。
+            if (event.key === 'enter' && this.selectionAlreadyTyped())
+                return false;
+            this.applySelection();
+            return true;
+        }
+        if (event.key === 'escape') {
+            this.result = null; // 关本轮（后续输入再 refresh 重开）
+            return true;
+        }
+        return false; // 其余键穿透（backspace / 字符等继续编辑——弹层随下次 refresh 重算）
+    }
+    /** 高亮循环移动 + 窗口跟随（10 行帽外的条目滚动入窗） */
+    moveActive(delta) {
+        const count = this.result?.items.length ?? 0;
+        if (count === 0)
+            return;
+        this.activeIndex = (this.activeIndex + delta + count) % count;
+        if (this.activeIndex < this.windowStart)
+            this.windowStart = this.activeIndex;
+        if (this.activeIndex >= this.windowStart + MAX_VISIBLE_ITEMS) {
+            this.windowStart = this.activeIndex - MAX_VISIBLE_ITEMS + 1;
+        }
+    }
+    /** 应用选中项：整 token 代换（模型原语——光标落代换尾） */
+    applySelection() {
+        const result = this.result;
+        if (result === null || result.items.length === 0)
+            return;
+        const item = result.items[this.activeIndex];
+        this.result = null; // 应用即隐（先隐后代换——代换的 notify 可能再触发 refresh 重开，属新轮）
+        const cursor = this.model.getCursor();
+        this.model.replaceToken(cursor.line, result.replaceStart, result.replaceEnd, item.replacement);
+    }
+    /**
+     * 全量输入判定：光标 token 现文本 === 高亮项 replacement 全文（弹层可见期
+     * 间输入变更必经 refresh 重开——本判定取值恒新鲜，无陈旧区间风险）。
+     */
+    selectionAlreadyTyped() {
+        const result = this.result;
+        if (result === null || result.items.length === 0)
+            return false;
+        const item = result.items[this.activeIndex];
+        const line = this.model.getLines()[this.model.getCursor().line];
+        if (line === undefined)
+            return false;
+        return line.slice(result.replaceStart, result.replaceEnd) === item.replacement;
+    }
+}

package/dist/channels/tui/autocomplete/provider.js

@@ -0,0 +1,7 @@
+/**
+ * 补全协议件（07 §4.1 引擎节件 6（组件与呈现装配件））：多行坐标协议 + 候选条目 + 取补全接口。
+ *
+ * 多行坐标协议（承 berry @-mention 协议签名）：上下文带 lines/cursorLine/
+ * cursorCol——按多行输入件坐标定位光标 token，弹层与源都只认本协议。
+ */
+export {};

package/dist/channels/tui/autocomplete/token.js

@@ -0,0 +1,68 @@
+/**
+ * token 判据件（07 §4.1 引擎节件 6（组件与呈现装配件） 补全段）：光标 token 提取（引号感知）
+ * 与行首 token 区间。
+ *
+ * 引号感知：token 边界 = 最近的**未引用空白**——从行首正向扫描推进引号
+ * 开闭态（引号内空白不断 token——@"my file" 形整段为一个 token）；引号
+ * 字符本身属 token（代换区间含引号）。
+ * 已知边界：未闭合引号一路吸到引号头（输入中间态本就未闭合，可接受）。
+ */
+/** 光标前 token 提取（col === 0 或紧邻空白 → null） */
+export function tokenAtCursor(line, col) {
+    if (col <= 0 || col > line.length)
+        return null;
+    // 正向扫描（引号态须从行首推进——反向扫遇空白先于遇引号头，无法判定
+    // 该空白是否被右侧引号包住）
+    let start = 0;
+    let quote = null;
+    for (let i = 0; i < col; i++) {
+        const ch = line[i];
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null; // 引号闭
+            continue; // 引号内字符（含空白）不断 token
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch; // 引号开
+            continue;
+        }
+        if (ch === ' ' || ch === '\t')
+            start = i + 1; // 未引用空白——token 边界
+    }
+    const text = line.slice(start, col);
+    if (text === '')
+        return null; // 紧邻空白——无 token
+    return { start, end: col, text };
+}
+/** 行首 token 区间（引号感知；空白行 / 空串 → null） */
+export function firstTokenRange(line) {
+    if (line === '')
+        return null;
+    let start = 0;
+    // 跳过行首空白（首 token 起点后移）
+    while (start < line.length && (line[start] === ' ' || line[start] === '\t'))
+        start++;
+    if (start >= line.length)
+        return null; // 全空白行
+    // 扫到未引用空白为终（与 tokenAtCursor 同边界判据）
+    let end = start;
+    let quote = null;
+    for (let i = start; i < line.length; i++) {
+        const ch = line[i];
+        if (quote !== null) {
+            if (ch === quote)
+                quote = null;
+            end = i + 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            end = i + 1;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t')
+            break;
+        end = i + 1;
+    }
+    return { start, end };
+}