@nbtca/prompt 1.4.2 → 1.5.1

package/dist/core/text.js

@@ -1,95 +1,182 @@
-/** Codepoints that occupy zero terminal columns: combining modifiers that
- * merge into the glyph immediately before them, rather than rendering as
- * their own character (zero-width joiner, variation selectors). Emoji
- * sequences like a ZWJ family emoji or "❤️" (heart + VS-16) render as one
- * glyph — counting the modifier itself would overcount by a full column. */
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const MARK_RE = /^\p{Mark}$/u;
+const EMOJI_PRESENTATION_RE = /\p{Emoji_Presentation}/u;
+const REGIONAL_INDICATOR_RE = /\p{Regional_Indicator}/u;
+function graphemes(value) {
+    return Array.from(GRAPHEME_SEGMENTER.segment(value), ({ segment }) => segment);
+}
 function isZeroWidth(cp) {
-    return cp === 0x200D // zero-width joiner
-        || cp === 0xFE0E // variation selector-15 (text presentation)
-        || cp === 0xFE0F; // variation selector-16 (emoji presentation)
+    return (cp === 0x200d || // zero-width joiner
+        cp === 0xfe0e || // variation selector-15 (text presentation)
+        cp === 0xfe0f); // variation selector-16 (emoji presentation)
 }
-/** Width of a single Unicode character: 2 for CJK/fullwidth/emoji, 1 otherwise. */
-function charWidth(ch) {
+function codePointWidth(ch) {
     const cp = ch.codePointAt(0) ?? 0;
-    return ((cp >= 0x1100 && cp <= 0x115F) ||
-        (cp >= 0x2E80 && cp <= 0x303F) ||
-        (cp >= 0x3040 && cp <= 0x33FF) ||
-        (cp >= 0x3400 && cp <= 0x4DBF) ||
-        (cp >= 0x4E00 && cp <= 0x9FFF) ||
-        (cp >= 0xAC00 && cp <= 0xD7AF) ||
-        (cp >= 0xF900 && cp <= 0xFAFF) ||
-        (cp >= 0xFE30 && cp <= 0xFE4F) ||
-        (cp >= 0xFF00 && cp <= 0xFF60) ||
-        (cp >= 0xFFE0 && cp <= 0xFFE6) ||
-        (cp >= 0x20000 && cp <= 0x2A6DF) ||
-        (cp >= 0x2A700 && cp <= 0x2CEAF) ||
-        (cp >= 0x2CEB0 && cp <= 0x2EBEF) ||
-        (cp >= 0x30000 && cp <= 0x323AF) ||
-        // Emoji blocks render as double-width terminal glyphs.
-        (cp >= 0x1F300 && cp <= 0x1FAFF)) ? 2 : 1;
-}
-/** Strip ANSI escape sequences from a string. */
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
+    if (isZeroWidth(cp) || MARK_RE.test(ch) || cp < 0x20 || (cp >= 0x7f && cp <= 0x9f))
+        return 0;
+    return (cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303f) ||
+        (cp >= 0x3040 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xac00 && cp <= 0xd7af) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x20000 && cp <= 0x2a6df) ||
+        (cp >= 0x2a700 && cp <= 0x2ceaf) ||
+        (cp >= 0x2ceb0 && cp <= 0x2ebef) ||
+        (cp >= 0x30000 && cp <= 0x323af) ||
+        (cp >= 0x1f300 && cp <= 0x1faff)
+        ? 2
+        : 1;
+}
+function graphemeWidth(grapheme) {
+    if (grapheme.includes('\ufe0f') ||
+        grapheme.includes('\u20e3') ||
+        EMOJI_PRESENTATION_RE.test(grapheme) ||
+        REGIONAL_INDICATOR_RE.test(grapheme)) {
+        return 2;
+    }
+    let width = 0;
+    for (const ch of grapheme)
+        width = Math.max(width, codePointWidth(ch));
+    return width;
+}
+const TERMINAL_ESCAPE_RE = /(?:\u001B\]|\u009D)[\s\S]*?(?:\u0007|\u001B\\|\u009C|$)|(?:\u001B[P_X^]|[\u0090\u0098\u009E\u009F])[\s\S]*?(?:\u001B\\|\u009C|$)|(?:\u001B\[|\u009B)[0-?]*[ -/]*[@-~]|\u001B[ -/]*[@-~]/g;
+const SGR_RE = /^(?:\u001B\[|\u009B)[0-9;]*m$/;
+const OSC8_RE = /^(?:\u001B\]|\u009D)8;[^;]*;([\s\S]*?)(?:\u0007|\u001B\\|\u009C)$/;
+const OSC8_CLOSE = '\u001B]8;;\u0007';
 export function stripAnsi(str) {
-    return str.replace(ANSI_RE, '');
+    return str.replace(TERMINAL_ESCAPE_RE, '');
+}
+const CONTROL_RE = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+export function sanitizeTerminalText(str) {
+    return str.replace(/\r\n?/g, '\n').replace(TERMINAL_ESCAPE_RE, '').replace(CONTROL_RE, '');
+}
+export function sanitizeTerminalLine(str) {
+    return sanitizeTerminalText(str).replace(/\s+/gu, ' ').trim();
 }
-/** Total visual width of a string (CJK/emoji count as 2, zero-width
- * modifiers count as 0, ANSI codes ignored). */
 export function visualWidth(str) {
     const plain = stripAnsi(str);
     let w = 0;
-    for (const ch of plain) {
-        const cp = ch.codePointAt(0) ?? 0;
-        if (isZeroWidth(cp))
-            continue;
-        w += charWidth(ch);
-    }
+    for (const grapheme of graphemes(plain))
+        w += graphemeWidth(grapheme);
     return w;
 }
-/** Pad string to target visual width with trailing spaces. */
 export function padEndV(str, width) {
     const pad = width - visualWidth(str);
     return pad > 0 ? str + ' '.repeat(pad) : str;
 }
-/** Truncate to visual width limit, appending '...' if cut. */
 export function truncate(str, maxWidth) {
     if (visualWidth(str) <= maxWidth)
         return str;
+    if (maxWidth <= 0)
+        return '';
+    const marker = maxWidth >= 3 ? '...' : '.'.repeat(maxWidth);
+    const available = maxWidth - visualWidth(marker);
     let w = 0;
-    let i = 0;
-    for (const ch of str) {
-        const cp = ch.codePointAt(0) ?? 0;
-        const cw = isZeroWidth(cp) ? 0 : charWidth(ch);
-        if (w + cw > maxWidth - 3)
+    let value = '';
+    for (const grapheme of graphemes(str)) {
+        const cw = graphemeWidth(grapheme);
+        if (w + cw > available)
             break;
         w += cw;
-        i += ch.length;
+        value += grapheme;
+    }
+    return value + marker;
+}
+export function truncateStart(str, maxWidth, marker = '...') {
+    if (visualWidth(str) <= maxWidth)
+        return str;
+    if (maxWidth <= 0)
+        return '';
+    let fittedMarker = '';
+    let markerWidth = 0;
+    for (const segment of graphemes(marker)) {
+        const segmentWidth = graphemeWidth(segment);
+        if (markerWidth + segmentWidth > maxWidth)
+            break;
+        fittedMarker += segment;
+        markerWidth += segmentWidth;
     }
-    return str.slice(0, i) + '...';
+    const available = Math.max(0, maxWidth - visualWidth(fittedMarker));
+    const segments = graphemes(str);
+    let value = '';
+    let width = 0;
+    for (let index = segments.length - 1; index >= 0; index -= 1) {
+        const segment = segments[index];
+        if (segment === undefined)
+            continue;
+        const segmentWidth = graphemeWidth(segment);
+        if (width + segmentWidth > available)
+            break;
+        value = segment + value;
+        width += segmentWidth;
+    }
+    return fittedMarker + value;
+}
+function osc8State(sequence) {
+    const match = OSC8_RE.exec(sequence);
+    if (!match)
+        return undefined;
+    return match[1] ? sequence : null;
 }
 function tokenizeForWrapping(str) {
     const tokens = [];
-    let index = 0;
-    while (index < str.length) {
-        const ansi = /^\x1b\[[0-9;]*m/.exec(str.slice(index));
-        if (ansi) {
-            tokens.push({ raw: ansi[0], width: 0, whitespace: false, sgr: true });
-            index += ansi[0].length;
-            continue;
+    const pushText = (value) => {
+        for (const grapheme of graphemes(value)) {
+            tokens.push({
+                raw: grapheme,
+                width: graphemeWidth(grapheme),
+                whitespace: /\s/u.test(grapheme),
+                sgr: false,
+            });
         }
-        const cp = str.codePointAt(index) ?? 0;
-        const raw = String.fromCodePoint(cp);
+    };
+    let index = 0;
+    for (const match of str.matchAll(TERMINAL_ESCAPE_RE)) {
+        const start = match.index;
+        pushText(str.slice(index, start));
+        const raw = match[0];
+        const osc8 = osc8State(raw);
         tokens.push({
             raw,
-            width: isZeroWidth(cp) ? 0 : charWidth(raw),
-            whitespace: /\s/u.test(raw),
-            sgr: false,
+            width: 0,
+            whitespace: false,
+            sgr: SGR_RE.test(raw),
+            ...(osc8 === undefined ? {} : { osc8 }),
         });
-        index += raw.length;
+        index = start + match[0].length;
     }
+    pushText(str.slice(index));
     return tokens;
 }
+export function clipAnsiToVisualWidth(str, maxWidth) {
+    const limit = Math.max(0, Math.floor(maxWidth));
+    if (visualWidth(str) <= limit)
+        return str;
+    const tokens = tokenizeForWrapping(str);
+    const output = [];
+    let width = 0;
+    let activeOsc8 = null;
+    for (const token of tokens) {
+        if (token.sgr || token.width === 0) {
+            output.push(token.raw);
+            if (token.osc8 !== undefined)
+                activeOsc8 = token.osc8;
+            continue;
+        }
+        if (width + token.width > limit)
+            break;
+        output.push(token.raw);
+        width += token.width;
+    }
+    if (activeOsc8)
+        output.push(OSC8_CLOSE);
+    return output.join('');
+}
 function advanceSgr(active, tokens, start, end) {
     let next = active;
     for (let index = start; index < end; index += 1) {
@@ -106,12 +193,24 @@ function advanceSgr(active, tokens, start, end) {
     }
     return next;
 }
-function renderWrappedSegment(tokens, start, end, prefix) {
-    const body = tokens.slice(start, end).map((token) => token.raw).join('');
-    const styled = prefix + body;
-    return prefix || tokens.slice(start, end).some((token) => token.sgr)
-        ? `${styled}\x1b[0m`
-        : styled;
+function advanceOsc8(active, tokens, start, end) {
+    let next = active;
+    for (let index = start; index < end; index += 1) {
+        const token = tokens[index];
+        if (token?.osc8 !== undefined)
+            next = token.osc8;
+    }
+    return next;
+}
+function renderWrappedSegment(tokens, start, end, activeSgr, activeOsc8) {
+    const body = tokens
+        .slice(start, end)
+        .map((token) => token.raw)
+        .join('');
+    const styled = `${activeOsc8 ?? ''}${activeSgr}${body}`;
+    const withReset = activeSgr || tokens.slice(start, end).some((token) => token.sgr) ? `${styled}\x1b[0m` : styled;
+    const osc8AtEnd = advanceOsc8(activeOsc8, tokens, start, end);
+    return osc8AtEnd ? `${withReset}${OSC8_CLOSE}` : withReset;
 }
 export function wrapAnsiToVisualWidth(str, maxWidth) {
     const widthLimit = Math.max(1, Math.floor(maxWidth));
@@ -120,6 +219,7 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
     const tokens = tokenizeForWrapping(str);
     const lines = [];
     let activeSgr = '';
+    let activeOsc8 = null;
     let start = 0;
     while (start < tokens.length) {
         let width = 0;
@@ -143,7 +243,7 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
             index += 1;
         }
         if (index >= tokens.length) {
-            lines.push(renderWrappedSegment(tokens, start, tokens.length, activeSgr));
+            lines.push(renderWrappedSegment(tokens, start, tokens.length, activeSgr, activeOsc8));
             break;
         }
         const overflow = tokens[index];
@@ -160,9 +260,26 @@ export function wrapAnsiToVisualWidth(str, maxWidth) {
             end = Math.max(index, start + 1);
             next = end;
         }
-        lines.push(renderWrappedSegment(tokens, start, end, activeSgr));
+        lines.push(renderWrappedSegment(tokens, start, end, activeSgr, activeOsc8));
         activeSgr = advanceSgr(activeSgr, tokens, start, next);
+        activeOsc8 = advanceOsc8(activeOsc8, tokens, start, next);
         start = next;
     }
     return lines.length > 0 ? lines : [''];
 }
+export function wrapAnsiWithIndent(str, maxWidth, preferredIndent = '') {
+    const width = Number.isFinite(maxWidth)
+        ? Math.max(1, Math.floor(maxWidth))
+        : Number.POSITIVE_INFINITY;
+    const indentWidth = visualWidth(preferredIndent);
+    const contentWidth = visualWidth(str);
+    let indent = indentWidth >= width || (contentWidth > width - indentWidth && contentWidth <= width)
+        ? ''
+        : preferredIndent;
+    let lines = wrapAnsiToVisualWidth(str, Math.max(1, width - visualWidth(indent)));
+    if (indent && lines.some((line) => visualWidth(indent + line) > width)) {
+        indent = '';
+        lines = wrapAnsiToVisualWidth(str, width);
+    }
+    return lines.map((line) => `${indent}${line}`);
+}

package/dist/core/theme.js

@@ -1,21 +1,11 @@
 import chalk from 'chalk';
 import gradient from 'gradient-string';
 import { pickIcon } from './icons.js';
-// The one gradient the brand uses anywhere it appears -- the startup logo,
-// and (in text form) the persistent header wordmark. Defined once here so
-// both stay the same three stops instead of drifting apart.
 export const brandGradient = gradient([
     { color: '#124689', pos: 0 },
     { color: '#0ea5e9', pos: 0.55 },
     { color: '#06b6d4', pos: 1 },
 ]);
-/** The brand wordmark treatment: bold text painted in `brandGradient`,
- * falling back to plain text under NO_COLOR (gradient-string doesn't
- * auto-respect it the way chalk's own colors do). Currently used by the
- * header's persistent "nbtca" mark (`app/chrome.ts`) -- named here, not
- * left as a one-off local helper, so any future chrome element that wants
- * "the brand gradient, as a wordmark" has a single place to reuse instead
- * of re-deriving the NO_COLOR/bold/gradient combination again. */
 export function brandMark(s) {
     if (process.env['NO_COLOR'])
         return s;
@@ -49,11 +39,6 @@ export const glyph = {
     dot: () => pickIcon('●', '*'),
     updown: () => pickIcon('↑↓', 'up/down'),
     enter: () => pickIcon('⏎', 'enter'),
-    // Two-level "how full" bar cell (Home's day-progress, Schedule's
-    // term-progress) — a single source of truth so every such bar in the
-    // app reads as the same visual language. Not the same vocabulary as
-    // calendar-heatmap's 5-level intensity scale, which is a deliberately
-    // finer-grained density visualization, not a binary fill/empty bar.
     barFilled: () => pickIcon('█', '#'),
     barEmpty: () => pickIcon('░', '-'),
 };
@@ -65,19 +50,6 @@ export const type = {
     label: (s) => chalk.white(s),
     body: (s) => s,
     hint: (s) => chalk.dim(s),
-    /** The one thing on this screen your eye should land on: the app's own
-     * name, the tab you're on, the row a menu's cursor sits on, the class
-     * that's happening right now. `heading` marks a section as structure;
-     * `active` marks a single point as attention — never both on the same
-     * element, and never more than one or two `active` uses per screen, or
-     * the signal stops meaning anything. Brand color (#0ea5e9) precisely
-     * because there is exactly one brand-worthy thing to say on each of
-     * these screens, and this is where it belongs. */
     active: (s) => chalk.bold(c.brand(s)),
-    /** The grid cursor's own visual signal: a solid brand-colored background
-     * block, deliberately distinct from `active` (bold text on the default
-     * background) so "this is today" and "this is where your cursor is" never
-     * share one visual language, even when the cursor lands on today's own
-     * column. */
     cursor: (s) => chalk.bgHex('#0ea5e9').black(s),
 };

package/dist/core/transitions.js

@@ -1,15 +1,15 @@
 import { clearScreen } from './ui.js';
 import { typeReveal } from './motion.js';
 import { glyph, type, space } from './theme.js';
-import { screenWidth } from './components/screen.js';
 import { pickIcon } from './icons.js';
 export function breadcrumb(label) {
     return `nbtca ${pickIcon('›', '>')} ${label}`;
 }
 export function buildScreenHeaderLines(crumb) {
+    const width = Math.min(process.stdout.columns || 80, 64);
     return [
         space.indent + type.heading(crumb),
-        space.indent + type.hint(glyph.rule().repeat(screenWidth())),
+        space.indent + type.hint(glyph.rule().repeat(width)),
         '',
     ];
 }

package/dist/core/ui.js

@@ -1,29 +1,31 @@
 import { success, error, warning, info } from './components/messages.js';
 import { startSpinner } from './components/spinner.js';
 import chalk from 'chalk';
-import { pickIcon } from './icons.js';
 import { t } from '../i18n/index.js';
+import { sanitizeTerminalLine } from './text.js';
 export { success, error, warning, info };
-export function printDivider() {
-    const terminalWidth = process.stdout.columns || 80;
-    const dividerChar = pickIcon('─', '-');
-    console.log(chalk.dim(dividerChar.repeat(Math.min(terminalWidth, 80))));
-}
 export function clearScreen() {
     if (process.stdout.isTTY) {
         console.clear();
     }
 }
-export function printNewLine(count = 1) {
-    for (let i = 0; i < count; i++) {
-        console.log();
-    }
-}
 export function createSpinner(msg) {
     return startSpinner(msg);
 }
+function errorMessage(errorValue) {
+    if (errorValue instanceof Error)
+        return errorValue.message;
+    if (typeof errorValue === 'string')
+        return errorValue;
+    if (typeof errorValue === 'number' ||
+        typeof errorValue === 'boolean' ||
+        typeof errorValue === 'bigint') {
+        return String(errorValue);
+    }
+    return '';
+}
 export function handleGracefulExit(err) {
-    const message = err instanceof Error ? err.message : String(err ?? '');
+    const message = sanitizeTerminalLine(errorMessage(err));
     if (message.includes('SIGINT') || message.includes('User force closed')) {
         console.log();
         console.log(chalk.dim(t().common.goodbye));
@@ -33,7 +35,7 @@ export function handleGracefulExit(err) {
         console.error(message);
     }
     else {
-        console.error('Error occurred:', err);
+        console.error('An unexpected error occurred.');
     }
     process.exit(1);
 }

package/dist/core/vim-keys.js

@@ -1,36 +1,173 @@
-/**
- * Vim keybindings support
- * Intercepts raw data events and replaces vim keys with terminal escape sequences
- * before readline processes them. This avoids patching the keypress layer which
- * breaks in Node.js v25+ (emitKeys generator crash).
- */
-// Maps single-byte vim keys to terminal escape sequences (ranger-style hjkl)
 const VIM_TO_SEQ = {
-    j: Buffer.from('\u001b[B'), // down arrow
-    k: Buffer.from('\u001b[A'), // up arrow
-    l: Buffer.from('\r'), // enter/confirm (ranger: open/enter)
-    g: Buffer.from('\u001b[H'), // home (first item)
-    G: Buffer.from('\u001b[F'), // end (last item)
-    q: Buffer.from('\u0003'), // quit
+    j: Buffer.from('\u001b[B'),
+    k: Buffer.from('\u001b[A'),
+    l: Buffer.from('\r'),
+    g: Buffer.from('\u001b[H'),
+    G: Buffer.from('\u001b[F'),
 };
 let vimActive = true;
 export function setVimKeysActive(active) {
     vimActive = active;
 }
+function vimKeysAreActive() {
+    return vimActive;
+}
+function utf8Length(chunk, start) {
+    const first = chunk[start] ?? 0;
+    const length = first <= 0x7f
+        ? 1
+        : first >= 0xc2 && first <= 0xdf
+            ? 2
+            : first >= 0xe0 && first <= 0xef
+                ? 3
+                : first >= 0xf0 && first <= 0xf4
+                    ? 4
+                    : 1;
+    if (start + length > chunk.length)
+        return null;
+    for (let index = start + 1; index < start + length; index += 1) {
+        const byte = chunk[index] ?? 0;
+        if (byte < 0x80 || byte > 0xbf)
+            return 1;
+    }
+    return length;
+}
+function escapeLength(chunk, start) {
+    const introducer = chunk[start + 1];
+    if (introducer === undefined)
+        return null;
+    if (introducer === 0x1b || introducer <= 0x1f || introducer === 0x7f)
+        return 1;
+    if (introducer === 0x5b || introducer === 0x4f) {
+        for (let index = start + 2; index < chunk.length; index += 1) {
+            const byte = chunk[index] ?? 0;
+            if (byte >= 0x40 && byte <= 0x7e)
+                return index - start + 1;
+            if (byte < 0x20 || byte > 0x3f)
+                return 1;
+        }
+        return null;
+    }
+    if ([0x5d, 0x50, 0x5e, 0x5f].includes(introducer)) {
+        for (let index = start + 2; index < chunk.length; index += 1) {
+            if (chunk[index] === 0x07)
+                return index - start + 1;
+            if (chunk[index] === 0x1b && chunk[index + 1] === 0x5c)
+                return index - start + 2;
+        }
+        return null;
+    }
+    const length = utf8Length(chunk, start + 1);
+    return length === null ? null : length + 1;
+}
+function keyLength(chunk, start) {
+    return chunk[start] === 0x1b ? escapeLength(chunk, start) : utf8Length(chunk, start);
+}
+function concatBuffers(chunks) {
+    const size = chunks.reduce((total, chunk) => total + chunk.length, 0);
+    const result = Buffer.allocUnsafe(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        for (const byte of chunk) {
+            result[offset] = byte;
+            offset += 1;
+        }
+    }
+    return result;
+}
+class KeyByteFramer {
+    pending = Buffer.alloc(0);
+    get hasPending() {
+        return this.pending.length > 0;
+    }
+    write(chunk) {
+        this.pending = this.pending.length === 0 ? chunk : concatBuffers([this.pending, chunk]);
+        return this.drain(false);
+    }
+    flush() {
+        return this.drain(true);
+    }
+    takePending() {
+        const pending = this.pending;
+        this.pending = Buffer.alloc(0);
+        return pending;
+    }
+    drain(flush) {
+        const keys = [];
+        let offset = 0;
+        while (offset < this.pending.length) {
+            const length = keyLength(this.pending, offset);
+            if (length === null) {
+                if (flush) {
+                    keys.push(this.pending.subarray(offset));
+                    offset = this.pending.length;
+                }
+                break;
+            }
+            keys.push(this.pending.subarray(offset, offset + length));
+            offset += length;
+        }
+        this.pending = this.pending.subarray(offset);
+        return keys;
+    }
+}
 export function enableVimKeys() {
     const stdin = process.stdin;
     if (!stdin.isTTY)
         return;
     const originalEmit = stdin.emit.bind(stdin);
-    stdin.emit = function (event, ...args) {
-        if (event === 'data' && vimActive) {
+    const framer = new KeyByteFramer();
+    let flushTimer;
+    const clearFlush = () => {
+        if (flushTimer === undefined)
+            return;
+        clearTimeout(flushTimer);
+        flushTimer = undefined;
+    };
+    const emitKeys = (keys) => {
+        let emitted = false;
+        for (let index = 0; index < keys.length; index += 1) {
+            if (!vimKeysAreActive()) {
+                emitted = originalEmit('data', concatBuffers(keys.slice(index))) || emitted;
+                return emitted;
+            }
+            const key = keys[index];
+            if (key === undefined)
+                continue;
+            const sequence = key.length === 1 ? VIM_TO_SEQ[String.fromCharCode(key[0] ?? 0)] : undefined;
+            emitted = originalEmit('data', sequence ?? key) || emitted;
+        }
+        return emitted;
+    };
+    const scheduleFlush = () => {
+        if (!framer.hasPending)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = undefined;
+            if (!vimKeysAreActive()) {
+                originalEmit('data', framer.takePending());
+                return;
+            }
+            emitKeys(framer.flush());
+        }, 20);
+    };
+    const translatedEmit = (event, ...args) => {
+        if (event === 'data') {
             const chunk = args[0];
-            if (Buffer.isBuffer(chunk) && chunk.length === 1) {
-                const seq = VIM_TO_SEQ[String.fromCharCode(chunk[0])];
-                if (seq)
-                    return originalEmit('data', seq);
+            if (Buffer.isBuffer(chunk)) {
+                clearFlush();
+                if (!vimKeysAreActive()) {
+                    const pending = framer.takePending();
+                    return pending.length === 0
+                        ? originalEmit(event, ...args)
+                        : originalEmit('data', concatBuffers([pending, chunk]));
+                }
+                const emitted = emitKeys(framer.write(chunk));
+                scheduleFlush();
+                return emitted;
             }
         }
         return originalEmit(event, ...args);
     };
+    stdin.emit = translatedEmit;
 }

package/dist/features/about.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { APP_INFO, URLS } from '../config/data.js';
+import { note } from '../core/components/note.js';
+import { pickIcon } from '../core/icons.js';
+import { padEndV } from '../core/text.js';
+import { t } from '../i18n/index.js';
+export function showAbout() {
+    const trans = t();
+    const row = (label, value) => `${chalk.dim(padEndV(label, 12))}${value}`;
+    const link = (label, url) => row(label, chalk.cyan(url));
+    const content = [
+        row(trans.about.project, APP_INFO.name),
+        row(trans.about.version, `v${APP_INFO.version}`),
+        row(trans.about.description, trans.about.descriptionText),
+        '',
+        link(trans.about.github, APP_INFO.repository),
+        link(trans.about.website, URLS.homepage),
+        link(trans.about.email, URLS.email),
+        '',
+        row(trans.about.license, `MIT  ${pickIcon('·', '|')}  ${trans.about.author}: m1ngsama`),
+    ].join('\n');
+    note(content, trans.about.title);
+}