@travisennis/acai 0.0.6 → 0.0.8

package/dist/terminal/keys.js

@@ -0,0 +1,546 @@
+/** biome-ignore-all lint/suspicious/noControlCharactersInRegex: handle terminal ansii codes */
+/** biome-ignore-all lint/style/useNamingConvention: will fix later */
+/**
+ * Kitty keyboard protocol key sequence helpers.
+ *
+ * The Kitty keyboard protocol sends enhanced escape sequences in the format:
+ *   \x1b[<codepoint>;<modifier>u
+ *
+ * Modifier bits (before adding 1 for transmission):
+ *   - Shift: 1 (value 2)
+ *   - Alt: 2 (value 3)
+ *   - Ctrl: 4 (value 5)
+ *   - Super: 8 (value 9)
+ *   - Hyper: 16
+ *   - Meta: 32
+ *   - Caps_Lock: 64
+ *   - Num_Lock: 128
+ *
+ * See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+ *
+ * NOTE: Some terminals (e.g., Ghostty on Linux) include lock key states
+ * (Caps Lock, Num Lock) in the modifier field. We mask these out when
+ * checking for key combinations since they shouldn't affect behavior.
+ */
+// Common codepoints
+const CODEPOINTS = {
+    // Letters (lowercase ASCII)
+    a: 97,
+    c: 99,
+    d: 100,
+    e: 101,
+    g: 103,
+    k: 107,
+    l: 108,
+    o: 111,
+    p: 112,
+    t: 116,
+    u: 117,
+    w: 119,
+    z: 122,
+    // Special keys
+    escape: 27,
+    tab: 9,
+    enter: 13,
+    backspace: 127,
+};
+// Lock key bits to ignore when matching (Caps Lock + Num Lock)
+const LOCK_MASK = 64 + 128; // 192
+// Modifier bits (before adding 1)
+const MODIFIERS = {
+    shift: 1,
+    alt: 2,
+    ctrl: 4,
+    super: 8,
+};
+/**
+ * Build a Kitty keyboard protocol sequence for a key with modifier.
+ */
+function kittySequence(codepoint, modifier) {
+    return `\x1b[${codepoint};${modifier + 1}u`;
+}
+/**
+ * Parse a Kitty keyboard protocol sequence.
+ * Handles formats:
+ *   - \x1b[<codepoint>u (no modifier)
+ *   - \x1b[<codepoint>;<modifier>u (with modifier)
+ *   - \x1b[1;<modifier>A/B/C/D (arrow keys with modifier)
+ *
+ * Returns null if not a valid Kitty sequence.
+ */
+// Virtual codepoints for functional keys (negative to avoid conflicts)
+const FUNCTIONAL_CODEPOINTS = {
+    delete: -10,
+    insert: -11,
+    pageUp: -12,
+    pageDown: -13,
+    home: -14,
+    end: -15,
+};
+function parseKittySequence(data) {
+    // Match CSI u format: \x1b[<num>u or \x1b[<num>;<mod>u
+    const csiUMatch = data.match(/^\x1b\[(\d+)(?:;(\d+))?u$/);
+    if (csiUMatch?.[1]) {
+        const codepoint = Number.parseInt(csiUMatch[1], 10);
+        const modValue = csiUMatch[2] ? Number.parseInt(csiUMatch[2], 10) : 1;
+        return { codepoint, modifier: modValue - 1 };
+    }
+    // Match arrow keys with modifier: \x1b[1;<mod>A/B/C/D
+    const arrowMatch = data.match(/^\x1b\[1;(\d+)([ABCD])$/);
+    if (arrowMatch?.[1] && arrowMatch?.[2]) {
+        const modValue = Number.parseInt(arrowMatch[1], 10);
+        // Map arrow letters to virtual codepoints for easier matching
+        const arrowCodes = { A: -1, B: -2, C: -3, D: -4 };
+        const codepoint = arrowCodes[arrowMatch[2]];
+        return { codepoint, modifier: modValue - 1 };
+    }
+    // Match functional keys with ~ terminator: \x1b[<num>~ or \x1b[<num>;<mod>~
+    // DELETE=3, INSERT=2, PAGEUP=5, PAGEDOWN=6, etc.
+    const funcMatch = data.match(/^\x1b\[(\d+)(?:;(\d+))?~$/);
+    if (funcMatch?.[1]) {
+        const keyNum = Number.parseInt(funcMatch[1], 10);
+        const modValue = funcMatch[2] ? Number.parseInt(funcMatch[2], 10) : 1;
+        // Map functional key numbers to virtual codepoints
+        const funcCodes = {
+            2: FUNCTIONAL_CODEPOINTS.insert,
+            3: FUNCTIONAL_CODEPOINTS.delete,
+            5: FUNCTIONAL_CODEPOINTS.pageUp,
+            6: FUNCTIONAL_CODEPOINTS.pageDown,
+            7: FUNCTIONAL_CODEPOINTS.home, // Alternative home
+            8: FUNCTIONAL_CODEPOINTS.end, // Alternative end
+        };
+        const codepoint = funcCodes[keyNum];
+        if (codepoint !== undefined) {
+            return { codepoint, modifier: modValue - 1 };
+        }
+    }
+    // Match Home/End with modifier: \x1b[1;<mod>H/F
+    const homeEndMatch = data.match(/^\x1b\[1;(\d+)([HF])$/);
+    if (homeEndMatch?.[1]) {
+        const modValue = Number.parseInt(homeEndMatch[1], 10);
+        const codepoint = homeEndMatch[2] === "H"
+            ? FUNCTIONAL_CODEPOINTS.home
+            : FUNCTIONAL_CODEPOINTS.end;
+        return { codepoint, modifier: modValue - 1 };
+    }
+    return null;
+}
+/**
+ * Check if a Kitty sequence matches the expected codepoint and modifier,
+ * ignoring lock key bits (Caps Lock, Num Lock).
+ */
+function matchesKittySequence(data, expectedCodepoint, expectedModifier) {
+    const parsed = parseKittySequence(data);
+    if (!parsed)
+        return false;
+    // Mask out lock bits from both sides for comparison
+    const actualMod = parsed.modifier & ~LOCK_MASK;
+    const expectedMod = expectedModifier & ~LOCK_MASK;
+    return parsed.codepoint === expectedCodepoint && actualMod === expectedMod;
+}
+// Pre-built sequences for common key combinations
+const Keys = {
+    // Ctrl+<letter> combinations
+    CTRL_A: kittySequence(CODEPOINTS.a, MODIFIERS.ctrl),
+    CTRL_C: kittySequence(CODEPOINTS.c, MODIFIERS.ctrl),
+    CTRL_D: kittySequence(CODEPOINTS.d, MODIFIERS.ctrl),
+    CTRL_E: kittySequence(CODEPOINTS.e, MODIFIERS.ctrl),
+    CTRL_G: kittySequence(CODEPOINTS.g, MODIFIERS.ctrl),
+    CTRL_K: kittySequence(CODEPOINTS.k, MODIFIERS.ctrl),
+    CTRL_L: kittySequence(CODEPOINTS.l, MODIFIERS.ctrl),
+    CTRL_O: kittySequence(CODEPOINTS.o, MODIFIERS.ctrl),
+    CTRL_P: kittySequence(CODEPOINTS.p, MODIFIERS.ctrl),
+    CTRL_T: kittySequence(CODEPOINTS.t, MODIFIERS.ctrl),
+    CTRL_U: kittySequence(CODEPOINTS.u, MODIFIERS.ctrl),
+    CTRL_W: kittySequence(CODEPOINTS.w, MODIFIERS.ctrl),
+    CTRL_Z: kittySequence(CODEPOINTS.z, MODIFIERS.ctrl),
+    // Enter combinations
+    SHIFT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.shift),
+    ALT_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.alt),
+    CTRL_ENTER: kittySequence(CODEPOINTS.enter, MODIFIERS.ctrl),
+    // Tab combinations
+    SHIFT_TAB: kittySequence(CODEPOINTS.tab, MODIFIERS.shift),
+    // Backspace combinations
+    ALT_BACKSPACE: kittySequence(CODEPOINTS.backspace, MODIFIERS.alt),
+};
+/**
+ * Check if input matches a Kitty protocol Ctrl+<key> sequence.
+ * Ignores lock key bits (Caps Lock, Num Lock).
+ * @param data - The input data to check
+ * @param key - Single lowercase letter (e.g., 'c' for Ctrl+C)
+ */
+export function isKittyCtrl(data, key) {
+    if (key.length !== 1)
+        return false;
+    const codepoint = key.charCodeAt(0);
+    // Check exact match first (fast path)
+    if (data === kittySequence(codepoint, MODIFIERS.ctrl))
+        return true;
+    // Check with lock bits masked out
+    return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
+}
+/**
+ * Check if input matches a Kitty protocol key sequence with specific modifier.
+ * Ignores lock key bits (Caps Lock, Num Lock).
+ * @param data - The input data to check
+ * @param codepoint - ASCII codepoint of the key
+ * @param modifier - Modifier value (use MODIFIERS constants)
+ */
+export function isKittyKey(data, codepoint, modifier) {
+    // Check exact match first (fast path)
+    if (data === kittySequence(codepoint, modifier))
+        return true;
+    // Check with lock bits masked out
+    return matchesKittySequence(data, codepoint, modifier);
+}
+// Raw control character codes
+const RAW = {
+    CTRL_A: "\x01",
+    CTRL_C: "\x03",
+    CTRL_D: "\x04",
+    CTRL_E: "\x05",
+    CTRL_G: "\x07",
+    CTRL_K: "\x0b",
+    CTRL_L: "\x0c",
+    CTRL_O: "\x0f",
+    CTRL_P: "\x10",
+    CTRL_T: "\x14",
+    CTRL_U: "\x15",
+    CTRL_W: "\x17",
+    CTRL_Z: "\x1a",
+    ALT_BACKSPACE: "\x1b\x7f",
+    SHIFT_TAB: "\x1b[Z",
+};
+/**
+ * Check if input matches Ctrl+A (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlA(data) {
+    return (data === RAW.CTRL_A ||
+        data === Keys.CTRL_A ||
+        matchesKittySequence(data, CODEPOINTS.a, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+C (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlC(data) {
+    return (data === RAW.CTRL_C ||
+        data === Keys.CTRL_C ||
+        matchesKittySequence(data, CODEPOINTS.c, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+D (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlD(data) {
+    return (data === RAW.CTRL_D ||
+        data === Keys.CTRL_D ||
+        matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+E (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlE(data) {
+    return (data === RAW.CTRL_E ||
+        data === Keys.CTRL_E ||
+        matchesKittySequence(data, CODEPOINTS.e, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+G (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlG(data) {
+    return (data === RAW.CTRL_G ||
+        data === Keys.CTRL_G ||
+        matchesKittySequence(data, CODEPOINTS.g, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+K (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ * Also checks if first byte is 0x0b for compatibility with terminals
+ * that may send trailing bytes.
+ */
+export function isCtrlK(data) {
+    return (data === RAW.CTRL_K ||
+        (data.length > 0 && data.charCodeAt(0) === 0x0b) || // compatibility with terminals that may send trailing bytes
+        data === Keys.CTRL_K ||
+        matchesKittySequence(data, CODEPOINTS.k, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+L (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlL(data) {
+    return (data === RAW.CTRL_L ||
+        data === Keys.CTRL_L ||
+        matchesKittySequence(data, CODEPOINTS.l, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+O (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlO(data) {
+    return (data === RAW.CTRL_O ||
+        data === Keys.CTRL_O ||
+        matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Shift+Ctrl+O (Kitty protocol only).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlO(data) {
+    return matchesKittySequence(data, CODEPOINTS.o, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+/**
+ * Check if input matches Ctrl+P (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlP(data) {
+    return (data === RAW.CTRL_P ||
+        data === Keys.CTRL_P ||
+        matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Shift+Ctrl+P (Kitty protocol only).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlP(data) {
+    return matchesKittySequence(data, CODEPOINTS.p, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+/**
+ * Check if input matches Shift+Ctrl+D (Kitty protocol only, for debug).
+ * Ignores lock key bits.
+ */
+export function isShiftCtrlD(data) {
+    return matchesKittySequence(data, CODEPOINTS.d, MODIFIERS.shift + MODIFIERS.ctrl);
+}
+/**
+ * Check if input matches Ctrl+T (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlT(data) {
+    return (data === RAW.CTRL_T ||
+        data === Keys.CTRL_T ||
+        matchesKittySequence(data, CODEPOINTS.t, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+U (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlU(data) {
+    return (data === RAW.CTRL_U ||
+        data === Keys.CTRL_U ||
+        matchesKittySequence(data, CODEPOINTS.u, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+W (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlW(data) {
+    return (data === RAW.CTRL_W ||
+        data === Keys.CTRL_W ||
+        matchesKittySequence(data, CODEPOINTS.w, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+Z (raw byte or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isCtrlZ(data) {
+    return (data === RAW.CTRL_Z ||
+        data === Keys.CTRL_Z ||
+        matchesKittySequence(data, CODEPOINTS.z, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Alt+Backspace (legacy or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isAltBackspace(data) {
+    return (data === RAW.ALT_BACKSPACE ||
+        data === Keys.ALT_BACKSPACE ||
+        matchesKittySequence(data, CODEPOINTS.backspace, MODIFIERS.alt));
+}
+/**
+ * Check if input matches Shift+Tab (legacy or Kitty protocol).
+ * Ignores lock key bits.
+ */
+export function isShiftTab(data) {
+    return (data === RAW.SHIFT_TAB ||
+        data === Keys.SHIFT_TAB ||
+        data === "\x1b[1;2Z" || // shift+tab with modifier
+        matchesKittySequence(data, CODEPOINTS.tab, MODIFIERS.shift));
+}
+/**
+ * Check if input matches the Escape key (raw byte or Kitty protocol).
+ * Raw: \x1b (single byte)
+ * Kitty: \x1b[27u (codepoint 27 = escape)
+ * Ignores lock key bits.
+ */
+export function isEscape(data) {
+    return (data === "\x1b" ||
+        data === `\x1b[${CODEPOINTS.escape}u` ||
+        matchesKittySequence(data, CODEPOINTS.escape, 0));
+}
+// Arrow key virtual codepoints (negative to avoid conflicts with real codepoints)
+const ARROW_CODEPOINTS = {
+    up: -1,
+    down: -2,
+    right: -3,
+    left: -4,
+};
+/**
+ * Check if input matches Arrow Up key.
+ * Handles both legacy (\x1b[A) and Kitty protocol with modifiers.
+ */
+export function isArrowUp(data) {
+    return (data === "\x1b[A" || matchesKittySequence(data, ARROW_CODEPOINTS.up, 0));
+}
+/**
+ * Check if input matches Arrow Down key.
+ * Handles both legacy (\x1b[B) and Kitty protocol with modifiers.
+ */
+export function isArrowDown(data) {
+    return (data === "\x1b[B" || matchesKittySequence(data, ARROW_CODEPOINTS.down, 0));
+}
+/**
+ * Check if input matches Arrow Right key.
+ * Handles both legacy (\x1b[C) and Kitty protocol with modifiers.
+ */
+export function isArrowRight(data) {
+    return (data === "\x1b[C" || matchesKittySequence(data, ARROW_CODEPOINTS.right, 0));
+}
+/**
+ * Check if input matches Arrow Left key.
+ * Handles both legacy (\x1b[D) and Kitty protocol with modifiers.
+ */
+export function isArrowLeft(data) {
+    return (data === "\x1b[D" || matchesKittySequence(data, ARROW_CODEPOINTS.left, 0));
+}
+/**
+ * Check if input matches plain Tab key (no modifiers).
+ * Handles both legacy (\t) and Kitty protocol.
+ */
+export function isTab(data) {
+    return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
+}
+/**
+ * Check if input matches plain Enter/Return key (no modifiers).
+ * Handles both legacy (\r) and Kitty protocol.
+ */
+export function isEnter(data) {
+    return data === "\r" || matchesKittySequence(data, CODEPOINTS.enter, 0);
+}
+/**
+ * Check if input matches plain Backspace key (no modifiers).
+ * Handles both legacy (\x7f, \x08) and Kitty protocol.
+ */
+export function isBackspace(data) {
+    return (data === "\x7f" ||
+        data === "\x08" ||
+        matchesKittySequence(data, CODEPOINTS.backspace, 0));
+}
+/**
+ * Check if input matches Shift+Enter.
+ * Ignores lock key bits.
+ */
+export function isShiftEnter(data) {
+    return (data === Keys.SHIFT_ENTER ||
+        matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.shift));
+}
+/**
+ * Check if input matches Alt+Enter.
+ * Ignores lock key bits.
+ */
+export function isAltEnter(data) {
+    return (data === Keys.ALT_ENTER ||
+        data === "\x1b\r" ||
+        matchesKittySequence(data, CODEPOINTS.enter, MODIFIERS.alt));
+}
+/**
+ * Check if input matches Option/Alt+Left (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isAltLeft(data) {
+    return (data === "\x1b[1;3D" ||
+        data === "\x1bb" ||
+        matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.alt));
+}
+/**
+ * Check if input matches Option/Alt+Right (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isAltRight(data) {
+    return (data === "\x1b[1;3C" ||
+        data === "\x1bf" ||
+        matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.alt));
+}
+/**
+ * Check if input matches Ctrl+Left (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isCtrlLeft(data) {
+    return (data === "\x1b[1;5D" ||
+        matchesKittySequence(data, ARROW_CODEPOINTS.left, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Ctrl+Right (word navigation).
+ * Handles multiple formats including Kitty protocol.
+ */
+export function isCtrlRight(data) {
+    return (data === "\x1b[1;5C" ||
+        matchesKittySequence(data, ARROW_CODEPOINTS.right, MODIFIERS.ctrl));
+}
+/**
+ * Check if input matches Home key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isHome(data) {
+    return (data === "\x1b[H" ||
+        data === "\x1b[1~" ||
+        data === "\x1b[7~" ||
+        matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.home, 0));
+}
+/**
+ * Check if input matches End key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isEnd(data) {
+    return (data === "\x1b[F" ||
+        data === "\x1b[4~" ||
+        data === "\x1b[8~" ||
+        matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.end, 0));
+}
+/**
+ * Check if input matches Delete key (forward delete).
+ * Handles legacy format and Kitty protocol with lock key modifiers.
+ */
+export function isDelete(data) {
+    return (data === "\x1b[3~" ||
+        matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.delete, 0));
+}
+/**
+ * Check if input matches Page Up key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isPageUp(data) {
+    return (data === "\x1b[5~" ||
+        matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageUp, 0));
+}
+/**
+ * Check if input matches Page Down key.
+ * Handles legacy formats and Kitty protocol with lock key modifiers.
+ */
+export function isPageDown(data) {
+    return (data === "\x1b[6~" ||
+        matchesKittySequence(data, FUNCTIONAL_CODEPOINTS.pageDown, 0));
+}
+/**
+ * Check if key data represents navigation key (arrows, Tab, Shift+Tab).
+ */
+export function isNavigationKey(keyData) {
+    return (isArrowUp(keyData) ||
+        isArrowDown(keyData) ||
+        isTab(keyData) ||
+        isShiftTab(keyData));
+}

package/dist/terminal/segmenter.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Shared Intl.Segmenter singleton for grapheme segmentation.
+ * Used for proper Unicode iteration (handles emojis, combining characters, etc.)
+ */
+export declare function getSegmenter(): Intl.Segmenter;
+//# sourceMappingURL=segmenter.d.ts.map

package/dist/terminal/segmenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["../../source/terminal/segmenter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,wBAAgB,YAAY,IAAI,IAAI,CAAC,SAAS,CAK7C"}

package/dist/terminal/segmenter.js

@@ -0,0 +1,11 @@
+/**
+ * Shared Intl.Segmenter singleton for grapheme segmentation.
+ * Used for proper Unicode iteration (handles emojis, combining characters, etc.)
+ */
+let segmenter = null;
+export function getSegmenter() {
+    if (!segmenter) {
+        segmenter = new Intl.Segmenter();
+    }
+    return segmenter;
+}

package/dist/terminal/select-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-prompt.d.ts","sourceRoot":"","sources":["../../source/terminal/select-prompt.ts"],"names":[],"mappings":";AACA;;;GAGG;AA6BH,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AACD,KAAK,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAQpD,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC;CAC5B;AAED,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAgGD,wBAAsB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,EACxC,OAAkB,EAClB,OAAO,EACP,OAAW,EACX,QAAY,EACZ,MAAM,EACN,QAA2D,GAC5D,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgN/B"}
+{"version":3,"file":"select-prompt.d.ts","sourceRoot":"","sources":["../../source/terminal/select-prompt.ts"],"names":[],"mappings":";AACA;;;GAGG;AAyBH,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AACD,KAAK,MAAM,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAQpD,UAAU,UAAU;IAClB,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC;CAC5B;AAED,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAgGD,wBAAsB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,EACxC,OAAkB,EAClB,OAAO,EACP,OAAW,EACX,QAAY,EACZ,MAAM,EACN,QAA2D,GAC5D,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgN/B"}

package/dist/terminal/select-prompt.js

@@ -3,19 +3,7 @@
  * Standalone select prompt (inquirer-like)
  * - TypeScript version
  */
-const Keys = {
-    up: "\x1b[A",
-    down: "\x1b[B",
-    home: "\x1b[H",
-    homeAlt: "\x1b[1~",
-    end: "\x1b[F",
-    endAlt: "\x1b[4~",
-    ctrlC: "\u0003",
-    enter: "\r",
-    newline: "\n",
-    backspace: "\x7f",
-    backspaceAlt: "\b",
-};
+import { isArrowDown, isArrowUp, isBackspace, isCtrlC, isEnd, isEnter, isHome, } from "./keys.js";
 const ANSI = {
     hideCursor: "\x1b[?25l",
     showCursor: "\x1b[?25h",
@@ -189,7 +177,7 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
             signal.addEventListener("abort", abortHandler);
         }
         function onData(key) {
-            if (key === Keys.ctrlC) {
+            if (isCtrlC(key)) {
                 cleanup();
                 stdout.write("\n");
                 const err = new Error("Cancelled");
@@ -197,34 +185,34 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
                 reject(err);
                 return;
             }
-            if (key === Keys.enter || key === Keys.newline) {
+            if (isEnter(key)) {
                 cleanup();
                 const chosen = filteredChoices[pointer];
                 stdout.write("\n");
                 resolve(chosen.value);
                 return;
             }
-            if (key === Keys.up) {
+            if (isArrowUp(key)) {
                 move(-1);
                 return;
             }
-            if (key === Keys.down) {
+            if (isArrowDown(key)) {
                 move(1);
                 return;
             }
-            if (key === Keys.home || key === Keys.homeAlt) {
+            if (isHome(key)) {
                 pointer = findFirstEnabledIndex(filteredChoices);
                 pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
                 renderToScreen();
                 return;
             }
-            if (key === Keys.end || key === Keys.endAlt) {
+            if (isEnd(key)) {
                 pointer = findLastEnabledIndex(filteredChoices);
                 pageStart = updatePageStart(pointer, pageSize, filteredChoices.length);
                 renderToScreen();
                 return;
             }
-            if (key === Keys.backspace || key === Keys.backspaceAlt) {
+            if (isBackspace(key)) {
                 if (searchBuffer.length > 0) {
                     searchBuffer = searchBuffer.slice(0, -1);
                     if (searchBuffer.length === 0) {
@@ -269,7 +257,7 @@ export async function select({ message = "Select", choices, initial = 0, pageSiz
     });
 }
 if (import.meta.url === `file://${process.argv[1]}`) {
-    (async () => {
+    void (async () => {
         try {
             const res = await select({
                 message: "Pick a fruit",

package/dist/terminal/string-width.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string-width.d.ts","sourceRoot":"","sources":["../../source/terminal/string-width.ts"],"names":[],"mappings":"AAGA,UAAU,kBAAkB;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAwCD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CA0CR"}
+{"version":3,"file":"string-width.d.ts","sourceRoot":"","sources":["../../source/terminal/string-width.ts"],"names":[],"mappings":"AAIA,UAAU,kBAAkB;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AA8CD,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAuDR"}