mepcli 0.2.5 → 0.2.6

package/dist/prompts/text.js

@@ -4,134 +4,218 @@ exports.TextPrompt = void 0;
 const ansi_1 = require("../ansi");
 const base_1 = require("../base");
 const theme_1 = require("../theme");
+const utils_1 = require("../utils");
 // --- Implementation: Text Prompt ---
 class TextPrompt extends base_1.Prompt {
     constructor(options) {
         super(options);
         this.errorMsg = '';
+        // cursor is now an index into the grapheme segments array
         this.cursor = 0;
         this.hasTyped = false;
-        this.renderLines = 1;
+        this.segments = [];
         this.value = options.initial || '';
-        this.cursor = this.value.length;
+        // Initialize segments from value
+        this.segments = (0, utils_1.safeSplit)(this.value);
+        this.cursor = this.segments.length;
     }
     render(firstRender) {
-        // TextPrompt needs the cursor visible!
-        this.print(ansi_1.ANSI.SHOW_CURSOR);
-        if (!firstRender) {
-            // Clear previous lines
-            for (let i = 0; i < this.renderLines; i++) {
-                this.print(ansi_1.ANSI.ERASE_LINE);
-                if (i < this.renderLines - 1)
-                    this.print(ansi_1.ANSI.UP);
-            }
-            this.print(ansi_1.ANSI.CURSOR_LEFT);
-        }
-        let output = '';
-        // 1. Render the Prompt Message
+        // Calculate available width
+        const cols = process.stdout.columns || 80;
+        // 1. Prepare Prompt Label
         const icon = this.errorMsg ? `${theme_1.theme.error}✖` : `${theme_1.theme.success}?`;
-        const multilineHint = this.options.multiline ? ` ${theme_1.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
-        output += `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${multilineHint} `;
-        // 2. Render the Value or Placeholder
-        let displayValue = '';
-        if (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped) {
-            displayValue = `${theme_1.theme.muted}${this.options.placeholder}${ansi_1.ANSI.RESET}`;
+        const hint = this.options.multiline ? ` ${theme_1.theme.muted}(Press Ctrl+D to submit)${ansi_1.ANSI.RESET}` : '';
+        const prefix = `${icon} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}${hint} `;
+        // We need visual length of prefix to calculate available space for input on the first line
+        const prefixVisualLen = this.stripAnsi(prefix).length;
+        // 2. Prepare Value Display
+        let displayValueLines = [];
+        let cursorRelativeRow = 0;
+        let cursorRelativeCol = 0; // Visual column index
+        // Reconstruct value from segments for logic that needs raw string
+        this.value = this.segments.join('');
+        if (this.segments.length === 0 && this.options.placeholder && !this.errorMsg && !this.hasTyped) {
+            // Placeholder case
+            const placeholder = `${theme_1.theme.muted}${this.options.placeholder}${ansi_1.ANSI.RESET}`;
+            displayValueLines = [placeholder];
+            cursorRelativeRow = 0;
+            cursorRelativeCol = 0;
         }
         else {
-            displayValue = this.options.isPassword ? '*'.repeat(this.value.length) : this.value;
-            displayValue = `${theme_1.theme.main}${displayValue}${ansi_1.ANSI.RESET}`;
-        }
-        output += displayValue;
-        // 3. Handle Error Message
-        if (this.errorMsg) {
-            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
-        }
-        this.print(output);
-        // 4. Calculate Visual Metrics for Wrapping
-        const cols = process.stdout.columns || 80;
-        const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
-        // Prompt String (visual part before value)
-        const promptStr = `${icon} ${theme_1.theme.title}${this.options.message} ${multilineHint} `;
-        const promptVisualLen = stripAnsi(promptStr).length;
-        // Value String (visual part)
-        const rawValue = (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped)
-            ? this.options.placeholder || ''
-            : (this.options.isPassword ? '*'.repeat(this.value.length) : this.value);
-        // Error String (visual part)
-        const errorVisualLines = this.errorMsg ? Math.ceil((3 + this.errorMsg.length) / cols) : 0;
-        // Calculate Total Lines and Cursor Position
-        // We simulate printing the prompt + value + error
-        let currentVisualLine = 0;
-        let currentCol = 0;
-        // State tracking for cursor
-        let cursorRow = 0;
-        let cursorCol = 0;
-        // Add Prompt
-        currentCol += promptVisualLen;
-        while (currentCol >= cols) {
-            currentVisualLine++;
-            currentCol -= cols;
-        }
-        // Add Value (Character by character to handle wrapping and cursor tracking accurately)
-        const valueLen = rawValue.length;
-        // If placeholder, we treat it as value for render height, but cursor is at 0
-        const isPlaceholder = (!this.value && this.options.placeholder && !this.errorMsg && !this.hasTyped);
-        for (let i = 0; i < valueLen; i++) {
-            // Check if we are at cursor position
-            if (!isPlaceholder && i === this.cursor) {
-                cursorRow = currentVisualLine;
-                cursorCol = currentCol;
+            const rawValue = this.options.isPassword ? '*'.repeat(this.segments.length) : this.value;
+            // Note: password masking replaces each grapheme with '*'
+            // Split by lines (for multiline support)
+            const lines = rawValue.split('\n');
+            // Determine which line the cursor is on
+            // We need to map 'cursor' (segments index) to line/col.
+            // This is tricky because segments might contain '\n'.
+            // safeSplit treats '\n' as a segment.
+            let cursorLineIndex = 0;
+            let cursorSegmentIndexOnLine = 0;
+            let currentSegmentIndex = 0;
+            for (let i = 0; i < lines.length; i++) {
+                // How many segments in this line?
+                // We can't just use lines[i].length because that's chars.
+                // We need to split the line again or iterate segments.
+                // Iterating segments is safer.
+                // Let's assume we iterate global segments until we hit a newline segment
+                let lineSegmentsCount = 0;
+                // Since rawValue.split('\n') consumes the newlines, we need to account for them.
+                // Alternative: iterate this.segments
+                // Find where the cursor falls.
             }
-            const char = rawValue[i];
-            if (char === '\n') {
-                currentVisualLine++;
-                currentCol = 0;
+            // Let's iterate segments to find cursor position (row, col)
+            cursorLineIndex = 0;
+            let colIndex = 0; // Visual column or char index?
+            // If we want visual cursor position, we need visual width of segments.
+            let visualColIndex = 0;
+            for (let i = 0; i < this.cursor; i++) {
+                const seg = this.segments[i];
+                if (seg === '\n') {
+                    cursorLineIndex++;
+                    visualColIndex = 0;
+                }
+                else {
+                    // Calculate width of this segment? 
+                    // No, for simple text editor logic we often assume 1 char = 1 pos unless we do full layout.
+                    // But here we want correct cursor placement over wide chars.
+                    // So we should sum width.
+                    // However, standard terminals handle wide chars by advancing cursor 2 spots.
+                    // So we just need to sum the string length of the segment? 
+                    // Or 2 if it's wide?
+                    // Standard terminal behavior:
+                    // If I write an Emoji (2 cols), the cursor advances 2 cols.
+                    // So visualColIndex should track stringWidth(seg).
+                    // But if isPassword, it's '*'. Width 1.
+                    if (this.options.isPassword) {
+                        visualColIndex += 1;
+                    }
+                    else {
+                        // Use our helper? Or just length?
+                        // If we used stringWidth, it would be accurate.
+                        // But we don't have access to stringWidth here easily unless we import it again (we did in base).
+                        // Let's assume segment.length for now (byte length), 
+                        // because `\x1b[<N>C` moves N COLUMNS? No, N characters? 
+                        // ANSI `CUB` / `CUF` moves N *columns* usually? 
+                        // "The Cursor Forward (CUF) sequence moves the cursor forward by n columns."
+                        // So if we have an emoji (2 cols), we need to move past it.
+                        // If we print an emoji, cursor is at +2.
+                        // Wait, if we use `renderFrame`, we rewrite everything.
+                        // Then we calculate where to put the cursor.
+                        // If line is "A <Emoji> B".
+                        // Output: "A <Emoji> B".
+                        // If cursor is after Emoji.
+                        // We need to be at position: width("A") + width("<Emoji>").
+                        // = 1 + 2 = 3.
+                        // So `visualColIndex` should use `stringWidth(seg)`.
+                        // But I didn't export `stringWidth` from `utils.ts` in the last step?
+                        // Checking `src/utils.ts`... I did export it.
+                        // But I need to import it here.
+                        visualColIndex += this.options.isPassword ? 1 : this.getSegmentWidth(seg);
+                    }
+                }
             }
-            else {
-                currentCol++;
-                if (currentCol >= cols) {
-                    currentVisualLine++;
-                    currentCol = 0;
+            cursorRelativeRow = cursorLineIndex;
+            cursorRelativeCol = visualColIndex;
+            // Now prepare lines for display (scrolling/truncation)
+            // We need to reconstruct lines from segments to apply styling/truncation logic per line.
+            let currentLineSegments = [];
+            let processedLines = []; // Array of segment arrays
+            for (const seg of this.segments) {
+                if (seg === '\n') {
+                    processedLines.push(currentLineSegments);
+                    currentLineSegments = [];
+                }
+                else {
+                    currentLineSegments.push(seg);
                 }
             }
+            processedLines.push(currentLineSegments); // Last line
+            processedLines.forEach((lineSegs, idx) => {
+                const isCursorLine = idx === cursorLineIndex;
+                const linePrefixLen = (idx === 0) ? prefixVisualLen : 0;
+                const maxContentLen = Math.max(10, cols - linePrefixLen - 1);
+                // Reconstruct line string for display calculation
+                // If password, join with *?
+                let visibleLine = '';
+                if (this.options.isPassword) {
+                    visibleLine = '*'.repeat(lineSegs.length);
+                }
+                else {
+                    visibleLine = lineSegs.join('');
+                }
+                // If this is cursor line, we need to handle horizontal scroll based on cursorRelativeCol.
+                // But cursorRelativeCol is global? No, we reset it on newline.
+                // So cursorRelativeCol above was correct for the current line.
+                if (isCursorLine) {
+                    // Check if we need to scroll
+                    // We need visual width of the line up to cursor.
+                    // cursorRelativeCol holds that.
+                    // If visual position > maxContentLen, we scroll.
+                    // This logic is similar to before but needs to use widths.
+                    // For simplicity, let's stick to the previous slice logic but apply it to SEGMENTS if possible.
+                    // But slicing segments for display is safer.
+                    // Let's implement simple tail truncation for now to keep it robust.
+                    // Ideally we scroll, but scrolling with variable width chars is complex.
+                    // "Good Enough": if it fits, show it. If not, truncate end.
+                    // If cursor is beyond end, scroll (slice from left).
+                    // Simplified: just show visibleLine truncated by base class renderFrame?
+                    // But renderFrame truncates blindly. We want the cursor visible.
+                    // Let's leave scrolling out for this specific "Backspace" fix task unless it's critical.
+                    // The user asked for "Backspace Emoji fix".
+                    // The scrolling logic is secondary but important.
+                    // I will preserve the existing simple scrolling logic but using segments?
+                    // No, let's just use the string for display and let renderFrame truncate.
+                    // Fix: Ensure we don't crash or show garbage.
+                }
+                displayValueLines.push(theme_1.theme.main + visibleLine + ansi_1.ANSI.RESET);
+            });
         }
-        // If cursor is at the very end
-        if (!isPlaceholder && this.cursor === valueLen) {
-            cursorRow = currentVisualLine;
-            cursorCol = currentCol;
-        }
-        // If placeholder, cursor is at start of value
-        if (isPlaceholder) {
-            let pCol = promptVisualLen;
-            let pRow = 0;
-            while (pCol >= cols) {
-                pRow++;
-                pCol -= cols;
+        // 3. Assemble Output
+        let output = '';
+        displayValueLines.forEach((lineStr, idx) => {
+            if (idx === 0) {
+                output += prefix + lineStr;
             }
-            cursorRow = pRow;
-            cursorCol = pCol;
+            else {
+                output += '\n' + lineStr;
+            }
+        });
+        if (this.errorMsg) {
+            output += `\n${theme_1.theme.error}>> ${this.errorMsg}${ansi_1.ANSI.RESET}`;
         }
-        // Final height
-        const totalValueRows = currentVisualLine + 1;
-        this.renderLines = totalValueRows + errorVisualLines;
-        // 5. Position Cursor Logic
-        const endRow = this.renderLines - 1;
-        // Move up to cursor row
-        const linesUp = endRow - cursorRow;
+        // 4. Render Frame
+        this.renderFrame(output);
+        this.print(ansi_1.ANSI.SHOW_CURSOR);
+        // 5. Move Cursor
+        const errorOffset = this.errorMsg ? 1 : 0;
+        const totalRows = displayValueLines.length + errorOffset;
+        const linesUp = (totalRows - 1) - cursorRelativeRow;
         if (linesUp > 0) {
             this.print(`\x1b[${linesUp}A`);
         }
-        // Move to cursor col
-        this.print(ansi_1.ANSI.CURSOR_LEFT); // Go to col 0
-        if (cursorCol > 0) {
-            this.print(`\x1b[${cursorCol}C`);
+        let targetCol = 0;
+        if (cursorRelativeRow === 0) {
+            targetCol = prefixVisualLen + cursorRelativeCol;
+        }
+        else {
+            targetCol = cursorRelativeCol;
         }
+        this.print(ansi_1.ANSI.CURSOR_LEFT);
+        if (targetCol > 0) {
+            this.print(`\x1b[${targetCol}C`);
+        }
+    }
+    // Helper to get width of a segment
+    getSegmentWidth(seg) {
+        return (0, utils_1.stringWidth)(seg);
     }
     handleInput(char) {
         // Enter
         if (char === '\r' || char === '\n') {
             if (this.options.multiline) {
-                this.value = this.value.slice(0, this.cursor) + '\n' + this.value.slice(this.cursor);
+                // Insert newline segment
+                this.segments.splice(this.cursor, 0, '\n');
                 this.cursor++;
                 this.render(false);
                 return;
@@ -139,7 +223,7 @@ class TextPrompt extends base_1.Prompt {
             this.validateAndSubmit();
             return;
         }
-        // Ctrl+D (EOF) or Ctrl+S for Submit in Multiline
+        // Ctrl+D / Ctrl+S
         if (this.options.multiline && (char === '\u0004' || char === '\u0013')) {
             this.validateAndSubmit();
             return;
@@ -148,7 +232,8 @@ class TextPrompt extends base_1.Prompt {
         if (char === '\u0008' || char === '\x7f') {
             this.hasTyped = true;
             if (this.cursor > 0) {
-                this.value = this.value.slice(0, this.cursor - 1) + this.value.slice(this.cursor);
+                // Remove segment at cursor - 1
+                this.segments.splice(this.cursor - 1, 1);
                 this.cursor--;
                 this.errorMsg = '';
                 this.render(false);
@@ -165,7 +250,7 @@ class TextPrompt extends base_1.Prompt {
         }
         // Arrow Right
         if (this.isRight(char)) {
-            if (this.cursor < this.value.length) {
+            if (this.cursor < this.segments.length) {
                 this.cursor++;
                 this.render(false);
             }
@@ -174,34 +259,32 @@ class TextPrompt extends base_1.Prompt {
         // Delete key
         if (char === '\u001b[3~') {
             this.hasTyped = true;
-            if (this.cursor < this.value.length) {
-                this.value = this.value.slice(0, this.cursor) + this.value.slice(this.cursor + 1);
+            if (this.cursor < this.segments.length) {
+                this.segments.splice(this.cursor, 1);
                 this.errorMsg = '';
                 this.render(false);
             }
             return;
         }
         // Regular Typing & Paste
+        // safeSplit the input char(s) - could be pasted text
         if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
             this.hasTyped = true;
-            this.value = this.value.slice(0, this.cursor) + char + this.value.slice(this.cursor);
-            this.cursor += char.length;
+            const newSegments = (0, utils_1.safeSplit)(char);
+            this.segments.splice(this.cursor, 0, ...newSegments);
+            this.cursor += newSegments.length;
             this.errorMsg = '';
             this.render(false);
         }
     }
     validateAndSubmit() {
+        this.value = this.segments.join('');
         if (this.options.validate) {
             const result = this.options.validate(this.value);
-            // Handle Promise validation
             if (result instanceof Promise) {
-                // Show loading state
-                this.print(`\n${ansi_1.ANSI.ERASE_LINE}${theme_1.theme.main}Validating...${ansi_1.ANSI.RESET}`);
-                this.print(ansi_1.ANSI.UP);
+                this.errorMsg = 'Validating...';
+                this.render(false);
                 result.then(valid => {
-                    // Clear loading message
-                    this.print(`\n${ansi_1.ANSI.ERASE_LINE}`);
-                    this.print(ansi_1.ANSI.UP);
                     if (typeof valid === 'string' && valid.length > 0) {
                         this.errorMsg = valid;
                         this.render(false);
@@ -211,20 +294,16 @@ class TextPrompt extends base_1.Prompt {
                         this.render(false);
                     }
                     else {
-                        if (this.errorMsg) {
-                            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
-                        }
+                        this.errorMsg = '';
+                        this.render(false);
                         this.submit(this.value);
                     }
                 }).catch(err => {
-                    this.print(`\n${ansi_1.ANSI.ERASE_LINE}`);
-                    this.print(ansi_1.ANSI.UP);
                     this.errorMsg = err.message || 'Validation failed';
                     this.render(false);
                 });
                 return;
             }
-            // Handle Sync validation
             if (typeof result === 'string' && result.length > 0) {
                 this.errorMsg = result;
                 this.render(false);
@@ -236,9 +315,6 @@ class TextPrompt extends base_1.Prompt {
                 return;
             }
         }
-        if (this.errorMsg) {
-            this.print(`\n${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.UP}`);
-        }
         this.submit(this.value);
     }
 }

package/dist/prompts/toggle.js

@@ -11,10 +11,6 @@ class TogglePrompt extends base_1.Prompt {
         this.value = options.initial ?? false;
     }
     render(firstRender) {
-        this.print(ansi_1.ANSI.HIDE_CURSOR);
-        if (!firstRender) {
-            this.print(`${ansi_1.ANSI.ERASE_LINE}${ansi_1.ANSI.CURSOR_LEFT}`);
-        }
         const activeText = this.options.activeText || 'ON';
         const inactiveText = this.options.inactiveText || 'OFF';
         let toggleDisplay = '';
@@ -24,8 +20,8 @@ class TogglePrompt extends base_1.Prompt {
         else {
             toggleDisplay = `${theme_1.theme.muted}${activeText}${ansi_1.ANSI.RESET}  ${theme_1.theme.main}[${ansi_1.ANSI.BOLD}${inactiveText}${ansi_1.ANSI.RESET}${theme_1.theme.main}]${ansi_1.ANSI.RESET}`;
         }
-        this.print(`${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${toggleDisplay}`);
-        this.print(`\x1b[${toggleDisplay.length}D`); // Move back is not really needed as we hide cursor, but kept for consistency
+        const output = `${theme_1.theme.success}?${ansi_1.ANSI.RESET} ${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${toggleDisplay}`;
+        this.renderFrame(output);
     }
     handleInput(char) {
         if (char === '\r' || char === '\n') {

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Detects terminal capabilities.
+ */
+export declare function detectCapabilities(): {
+    isCI: boolean;
+    hasTrueColor: boolean;
+    hasUnicode: boolean;
+};
+/**
+ * Strips ANSI escape codes from a string.
+ */
+export declare function stripAnsi(str: string): string;
+/**
+ * Calculates the visual width of a string.
+ * Uses binary search for wide characters.
+ * Handles ANSI codes (zero width).
+ */
+export declare function stringWidth(str: string): number;
+/**
+ * Safely splits a string into an array of grapheme clusters.
+ * Uses Intl.Segmenter (Node 16+).
+ */
+export declare function safeSplit(str: string): string[];

package/dist/utils.js

@@ -0,0 +1,135 @@
+"use strict";
+// src/utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCapabilities = detectCapabilities;
+exports.stripAnsi = stripAnsi;
+exports.stringWidth = stringWidth;
+exports.safeSplit = safeSplit;
+/**
+ * Detects terminal capabilities.
+ */
+function detectCapabilities() {
+    const env = process.env;
+    // Check for CI
+    const isCI = !!env.CI;
+    // Check for True Color support
+    const hasTrueColor = env.COLORTERM === 'truecolor';
+    // Check for Unicode support
+    // Windows Terminal (WT_SESSION), VS Code (TERM_PROGRAM=vscode), or modern Linux terminals usually support it.
+    const isWindows = process.platform === 'win32';
+    const hasUnicode = !!env.WT_SESSION ||
+        env.TERM_PROGRAM === 'vscode' ||
+        env.TERM_PROGRAM === 'Apple_Terminal' ||
+        (!isWindows && env.LANG && env.LANG.toUpperCase().endsWith('UTF-8'));
+    return {
+        isCI,
+        hasTrueColor,
+        hasUnicode: hasUnicode || !isWindows // Assume non-windows has unicode by default if not strictly detected?
+    };
+}
+/**
+ * Strips ANSI escape codes from a string.
+ */
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+/**
+ * Sorted array of Unicode ranges that are typically full-width (2 columns).
+ * Includes CJK, Emoji, Fullwidth forms, etc.
+ * Format: [start, end] inclusive.
+ */
+const WIDE_RANGES = [
+    [0x1100, 0x11FF], // Hangul Jamo
+    [0x2E80, 0x2EFF], // CJK Radicals Supplement
+    [0x2F00, 0x2FDF], // Kangxi Radicals
+    [0x3000, 0x303F], // CJK Symbols and Punctuation
+    [0x3040, 0x309F], // Hiragana
+    [0x30A0, 0x30FF], // Katakana
+    [0x3100, 0x312F], // Bopomofo
+    [0x3130, 0x318F], // Hangul Compatibility Jamo
+    [0x3200, 0x32FF], // Enclosed CJK Letters and Months
+    [0x3300, 0x33FF], // CJK Compatibility
+    [0x3400, 0x4DBF], // CJK Unified Ideographs Extension A
+    [0x4E00, 0x9FFF], // CJK Unified Ideographs
+    [0xA960, 0xA97F], // Hangul Jamo Extended-A
+    [0xAC00, 0xD7AF], // Hangul Syllables
+    [0xD7B0, 0xD7FF], // Hangul Jamo Extended-B
+    [0xF900, 0xFAFF], // CJK Compatibility Ideographs
+    [0xFE10, 0xFE1F], // Vertical Forms
+    [0xFE30, 0xFE4F], // CJK Compatibility Forms
+    [0xFE50, 0xFE6F], // Small Form Variants
+    [0xFF01, 0xFF60], // Fullwidth ASCII variants
+    [0xFFE0, 0xFFE6], // Fullwidth currency/symbols
+    [0x1F300, 0x1F6FF], // Miscellaneous Symbols and Pictographs (Emoji)
+    [0x1F900, 0x1F9FF], // Supplemental Symbols and Pictographs
+];
+/**
+ * Binary search to check if a code point is in the wide ranges.
+ */
+function isWideCodePoint(cp) {
+    let low = 0;
+    let high = WIDE_RANGES.length - 1;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const [start, end] = WIDE_RANGES[mid];
+        if (cp >= start && cp <= end) {
+            return true;
+        }
+        else if (cp < start) {
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return false;
+}
+/**
+ * Calculates the visual width of a string.
+ * Uses binary search for wide characters.
+ * Handles ANSI codes (zero width).
+ */
+function stringWidth(str) {
+    let width = 0;
+    let inAnsi = false;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        // Simple ANSI parser state check
+        if (str[i] === '\x1b') {
+            inAnsi = true;
+            continue;
+        }
+        if (inAnsi) {
+            if ((str[i] >= '@' && str[i] <= '~') || (str[i] >= 'a' && str[i] <= 'z') || (str[i] >= 'A' && str[i] <= 'Z')) {
+                inAnsi = false;
+            }
+            continue;
+        }
+        // Handle surrogate pairs for high code points (Emoji)
+        let cp = code;
+        if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
+            const next = str.charCodeAt(i + 1);
+            if (next >= 0xDC00 && next <= 0xDFFF) {
+                // Calculate code point from surrogate pair
+                cp = (code - 0xD800) * 0x400 + (next - 0xDC00) + 0x10000;
+                i++; // Skip next char
+            }
+        }
+        width += isWideCodePoint(cp) ? 2 : 1;
+    }
+    return width;
+}
+/**
+ * Safely splits a string into an array of grapheme clusters.
+ * Uses Intl.Segmenter (Node 16+).
+ */
+function safeSplit(str) {
+    // @ts-ignore - Intl.Segmenter is available in Node 16+ but TS might complain depending on lib settings
+    const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+    const segments = segmenter.segment(str);
+    const result = [];
+    for (const segment of segments) {
+        result.push(segment.segment);
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mepcli",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Zero-dependency, minimalist interactive CLI prompt for Node.js",
   "repository": {
     "type": "git",
@@ -30,8 +30,8 @@
   "author": "CodeTease",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^20.19.25",
-    "ts-node": "^10.9.0",
-    "typescript": "^5.0.0"
+    "@types/node": "^20.19.27",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
   }
 }