mepcli 0.6.1 → 1.0.0-beta.2

package/dist/prompts/diff.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffPrompt = void 0;
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+const editor_1 = require("./editor");
+class DiffPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.activeAction = 0; // 0: Original, 1: Modified, 2: Edit
+        this.actions = ['Use Original', 'Use Modified', 'Edit'];
+    }
+    render(_firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        // Render Diff
+        const originalLines = this.options.original ? this.options.original.split('\n') : [];
+        const modifiedLines = this.options.modified ? this.options.modified.split('\n') : [];
+        const width = Math.max(40, (this.stdout.columns || 80) - 4);
+        const borderTop = `${ansi_1.ANSI.FG_GRAY}┌${'─'.repeat(width)}┐${ansi_1.ANSI.RESET}`;
+        const borderMid = `${ansi_1.ANSI.FG_GRAY}├${'─'.repeat(width)}┤${ansi_1.ANSI.RESET}`;
+        const borderBot = `${ansi_1.ANSI.FG_GRAY}└${'─'.repeat(width)}┘${ansi_1.ANSI.RESET}`;
+        output += borderTop + '\n';
+        // Original (Red)
+        if (originalLines.length === 0) {
+            output += `${ansi_1.ANSI.FG_GRAY}│ ${ansi_1.ANSI.DIM}(empty)${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            originalLines.forEach(line => {
+                const truncated = this.truncate(line, width - 4);
+                output += `${ansi_1.ANSI.FG_GRAY}│ ${ansi_1.ANSI.FG_RED}- ${truncated}${ansi_1.ANSI.RESET}\n`;
+            });
+        }
+        output += borderMid + '\n';
+        // Modified (Green)
+        if (modifiedLines.length === 0) {
+            output += `${ansi_1.ANSI.FG_GRAY}│ ${ansi_1.ANSI.DIM}(empty)${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            modifiedLines.forEach(line => {
+                const truncated = this.truncate(line, width - 4);
+                output += `${ansi_1.ANSI.FG_GRAY}│ ${ansi_1.ANSI.FG_GREEN}+ ${truncated}${ansi_1.ANSI.RESET}\n`;
+            });
+        }
+        output += borderBot + '\n';
+        // Render Actions
+        output += '\n';
+        this.actions.forEach((action, index) => {
+            if (index === this.activeAction) {
+                output += `${ansi_1.ANSI.REVERSE} ${action} ${ansi_1.ANSI.RESET}  `;
+            }
+            else {
+                output += `[ ${action} ]  `;
+            }
+        });
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (this.isLeft(char)) {
+            this.activeAction = (this.activeAction - 1 + this.actions.length) % this.actions.length;
+            this.render(false);
+        }
+        else if (this.isRight(char)) {
+            this.activeAction = (this.activeAction + 1) % this.actions.length;
+            this.render(false);
+        }
+        else if (char === '\r' || char === '\n') {
+            this.handleSubmit();
+        }
+    }
+    handleSubmit() {
+        if (this.activeAction === 0) {
+            this.submit(this.options.original);
+        }
+        else if (this.activeAction === 1) {
+            this.submit(this.options.modified);
+        }
+        else {
+            // Edit
+            this.cleanup(); // Stop listening to input for this prompt
+            // Prepare initial content for editor
+            const initial = `<<<<<<< ORIGINAL
+${this.options.original}
+=======
+${this.options.modified}
+>>>>>>> MODIFIED`;
+            // We delegate to EditorPrompt
+            new editor_1.EditorPrompt({
+                message: 'Resolve conflict (Edit)',
+                initial: initial,
+                extension: '.txt',
+                waitUserInput: false // Launch immediately
+            }).run().then(result => {
+                this.submit(result);
+            }).catch(_err => {
+                this.submit(initial);
+            });
+        }
+    }
+}
+exports.DiffPrompt = DiffPrompt;

package/dist/prompts/draw.d.ts

@@ -0,0 +1,20 @@
+import { Prompt } from '../base';
+import { DrawOptions, MouseEvent } from '../types';
+export declare class DrawPrompt extends Prompt<string | boolean[][], DrawOptions> {
+    private grid;
+    private cursorX;
+    private cursorY;
+    private gridWidth;
+    private gridHeight;
+    private lastMouse;
+    constructor(options: DrawOptions);
+    private getBrailleChar;
+    private getPixel;
+    private setPixel;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string, _key: Buffer): void;
+    protected handleMouse(event: MouseEvent): void;
+    private clearGrid;
+    private invertGrid;
+    private handleSubmit;
+}

package/dist/prompts/draw.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DrawPrompt = void 0;
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const ansi_1 = require("../ansi");
+class DrawPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.cursorX = 0;
+        this.cursorY = 0;
+        this.lastMouse = null;
+        this.gridWidth = options.width * 2;
+        this.gridHeight = options.height * 4;
+        if (options.initial) {
+            // Deep copy to avoid mutating original if passed
+            this.grid = options.initial.map(row => [...row]);
+        }
+        else {
+            this.grid = [];
+            for (let y = 0; y < this.gridHeight; y++) {
+                const row = new Array(this.gridWidth).fill(false);
+                this.grid.push(row);
+            }
+        }
+    }
+    getBrailleChar(x, y) {
+        const baseX = x * 2;
+        const baseY = y * 4;
+        let code = 0x2800; // Base Braille
+        // Column 0
+        if (this.getPixel(baseX, baseY))
+            code |= 0x1; // Dot 1
+        if (this.getPixel(baseX, baseY + 1))
+            code |= 0x2; // Dot 2
+        if (this.getPixel(baseX, baseY + 2))
+            code |= 0x4; // Dot 3
+        if (this.getPixel(baseX, baseY + 3))
+            code |= 0x40; // Dot 7 (Bottom-left)
+        // Column 1
+        if (this.getPixel(baseX + 1, baseY))
+            code |= 0x8; // Dot 4
+        if (this.getPixel(baseX + 1, baseY + 1))
+            code |= 0x10; // Dot 5
+        if (this.getPixel(baseX + 1, baseY + 2))
+            code |= 0x20; // Dot 6
+        if (this.getPixel(baseX + 1, baseY + 3))
+            code |= 0x80; // Dot 8 (Bottom-right)
+        return String.fromCharCode(code);
+    }
+    getPixel(x, y) {
+        if (y >= 0 && y < this.gridHeight && x >= 0 && x < this.gridWidth) {
+            return this.grid[y][x];
+        }
+        return false;
+    }
+    setPixel(x, y, val) {
+        if (y >= 0 && y < this.gridHeight && x >= 0 && x < this.gridWidth) {
+            this.grid[y][x] = val;
+        }
+    }
+    render(_firstRender) {
+        let output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}\n`;
+        output += `${ansi_1.ANSI.FG_GRAY}┌${'─'.repeat(this.options.width + 2)}┐${ansi_1.ANSI.RESET}\n`;
+        for (let y = 0; y < this.options.height; y++) {
+            let line = '';
+            for (let x = 0; x < this.options.width; x++) {
+                const char = this.getBrailleChar(x, y);
+                // Highlight cursor position (pixel level approximation)
+                // If cursor is within this character block
+                const containsCursor = Math.floor(this.cursorX / 2) === x &&
+                    Math.floor(this.cursorY / 4) === y;
+                if (containsCursor) {
+                    line += ansi_1.ANSI.REVERSE + char + ansi_1.ANSI.RESET;
+                }
+                else {
+                    line += char;
+                }
+            }
+            output += `${ansi_1.ANSI.FG_GRAY}│ ${ansi_1.ANSI.RESET}${line} ${ansi_1.ANSI.FG_GRAY}│${ansi_1.ANSI.RESET}\n`;
+        }
+        output += `${ansi_1.ANSI.FG_GRAY}└${'─'.repeat(this.options.width + 2)}┘${ansi_1.ANSI.RESET}\n`;
+        output += `\n${ansi_1.ANSI.FG_GRAY}(Arrows: move, Space: toggle, Mouse: drag, 'c': clear, 'i': invert, Enter: done)${ansi_1.ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char, _key) {
+        if (this.isLeft(char)) {
+            this.cursorX = Math.max(0, this.cursorX - 1);
+            this.render(false);
+        }
+        else if (this.isRight(char)) {
+            this.cursorX = Math.min(this.gridWidth - 1, this.cursorX + 1);
+            this.render(false);
+        }
+        else if (this.isUp(char)) {
+            this.cursorY = Math.max(0, this.cursorY - 1);
+            this.render(false);
+        }
+        else if (this.isDown(char)) {
+            this.cursorY = Math.min(this.gridHeight - 1, this.cursorY + 1);
+            this.render(false);
+        }
+        else if (char === ' ') {
+            const current = this.getPixel(this.cursorX, this.cursorY);
+            this.setPixel(this.cursorX, this.cursorY, !current);
+            this.render(false);
+        }
+        else if (char === 'c') {
+            this.clearGrid();
+            this.render(false);
+        }
+        else if (char === 'i') {
+            this.invertGrid();
+            this.render(false);
+        }
+        else if (char === '\r' || char === '\n') {
+            this.handleSubmit();
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'release') {
+            this.lastMouse = null;
+            return;
+        }
+        if (this.lastMouse) {
+            const dx = event.x - this.lastMouse.x;
+            const dy = event.y - this.lastMouse.y;
+            // Relative movement: scale to grid density
+            // X: 1 char = 2 pixels
+            // Y: 1 char = 4 pixels
+            if (dx !== 0 || dy !== 0) {
+                this.cursorX += dx * 2;
+                this.cursorY += dy * 4;
+                // Clamp
+                this.cursorX = Math.max(0, Math.min(this.gridWidth - 1, this.cursorX));
+                this.cursorY = Math.max(0, Math.min(this.gridHeight - 1, this.cursorY));
+                // Draw if pressing (Left Button = 0)
+                if (event.action === 'press' || (event.action === 'move' && event.button === 0)) {
+                    this.setPixel(this.cursorX, this.cursorY, true);
+                }
+                // Eraser (Right Button = 2)
+                if ((event.action === 'press' || event.action === 'move') && event.button === 2) {
+                    this.setPixel(this.cursorX, this.cursorY, false);
+                }
+                this.render(false);
+            }
+        }
+        else {
+            if (event.action === 'press' && event.button === 0) {
+                this.setPixel(this.cursorX, this.cursorY, true);
+                this.render(false);
+            }
+        }
+        this.lastMouse = { x: event.x, y: event.y };
+    }
+    clearGrid() {
+        for (let y = 0; y < this.gridHeight; y++) {
+            for (let x = 0; x < this.gridWidth; x++) {
+                this.grid[y][x] = false;
+            }
+        }
+    }
+    invertGrid() {
+        for (let y = 0; y < this.gridHeight; y++) {
+            for (let x = 0; x < this.gridWidth; x++) {
+                this.grid[y][x] = !this.grid[y][x];
+            }
+        }
+    }
+    handleSubmit() {
+        if (this.options.exportType === 'text') {
+            // Render to string
+            let result = '';
+            for (let y = 0; y < this.options.height; y++) {
+                for (let x = 0; x < this.options.width; x++) {
+                    result += this.getBrailleChar(x, y);
+                }
+                result += '\n';
+            }
+            this.submit(result.trim());
+        }
+        else {
+            // Default: return matrix
+            this.submit(this.grid);
+        }
+    }
+}
+exports.DrawPrompt = DrawPrompt;

package/dist/prompts/editor.js

@@ -180,10 +180,6 @@ class EditorPrompt extends base_1.Prompt {
             }
             // Success
             this.status = 'done';
-            // Trim trailing newline which editors often add
-            // We only trim the *last* newline added by the editor if it wasn't there?
-            // Usually editors ensure a final newline.
-            // If the user entered "abc", vim saves "abc\n". We probably want "abc".
             if (content.endsWith('\n')) {
                 content = content.slice(0, -1);
             }

package/dist/prompts/emoji.d.ts

@@ -0,0 +1,18 @@
+import { Prompt } from '../base';
+import { EmojiOptions, MouseEvent } from '../types';
+export declare class EmojiPrompt extends Prompt<string, EmojiOptions> {
+    private search;
+    private cursor;
+    private filtered;
+    private sortedEmojis;
+    private cols;
+    private scrollTop;
+    private pageSize;
+    constructor(options: EmojiOptions);
+    private calculateLayout;
+    private updateFilter;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(char: string): void;
+    protected handleMouse(event: MouseEvent): void;
+    private adjustScroll;
+}

package/dist/prompts/emoji.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmojiPrompt = void 0;
+const ansi_1 = require("../ansi");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const utils_1 = require("../utils");
+class EmojiPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.search = '';
+        this.cursor = 0; // Index in the filtered list
+        this.filtered = [];
+        this.sortedEmojis = [];
+        this.cols = 0;
+        this.scrollTop = 0;
+        this.pageSize = 8; // Number of rows to display
+        // Sort emojis by recent
+        this.sortedEmojis = [...options.emojis];
+        if (options.recent && options.recent.length > 0) {
+            const recentSet = new Set(options.recent);
+            this.sortedEmojis.sort((a, b) => {
+                const aRecent = recentSet.has(a.name);
+                const bRecent = recentSet.has(b.name);
+                if (aRecent && !bRecent)
+                    return -1;
+                if (!aRecent && bRecent)
+                    return 1;
+                return 0;
+            });
+        }
+        this.checkWindowsAttention();
+        // Initial filter
+        this.filtered = this.sortedEmojis;
+        // Calculate layout
+        this.calculateLayout();
+    }
+    calculateLayout() {
+        if (this.options.cols) {
+            this.cols = this.options.cols;
+        }
+        else {
+            // Auto-detect based on terminal width
+            // Assume each emoji cell takes ~4 chars (2 char emoji + 2 padding)
+            const termWidth = process.stdout.columns || 80;
+            this.cols = Math.floor((termWidth - 4) / 4); // -4 for margin
+            if (this.cols < 1)
+                this.cols = 1;
+        }
+    }
+    updateFilter() {
+        if (!this.search) {
+            this.filtered = this.sortedEmojis;
+        }
+        else {
+            const lowerSearch = this.search.toLowerCase();
+            this.filtered = this.sortedEmojis.filter(e => e.name.toLowerCase().includes(lowerSearch) ||
+                (e.description && e.description.toLowerCase().includes(lowerSearch)) ||
+                e.char === this.search // Allow searching by exact char
+            );
+        }
+        this.cursor = 0;
+        this.scrollTop = 0;
+    }
+    render(_firstRender) {
+        // Prepare header (Search bar)
+        const icon = `${theme_1.theme.success}?`;
+        const title = `${ansi_1.ANSI.BOLD}${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET}`;
+        const searchDisplay = this.search ? `${theme_1.theme.main}${this.search}${ansi_1.ANSI.RESET}` : `${theme_1.theme.muted}Type to search...${ansi_1.ANSI.RESET}`;
+        let output = `${icon} ${title} ${searchDisplay}\n`;
+        // Render Grid
+        if (this.filtered.length === 0) {
+            output += `\n${theme_1.theme.error}No results found.${ansi_1.ANSI.RESET}\n`;
+        }
+        else {
+            const totalRows = Math.ceil(this.filtered.length / this.cols);
+            const startRow = this.scrollTop;
+            const endRow = Math.min(totalRows, startRow + this.pageSize);
+            for (let r = startRow; r < endRow; r++) {
+                let rowStr = '  '; // Left margin
+                for (let c = 0; c < this.cols; c++) {
+                    const idx = r * this.cols + c;
+                    if (idx >= this.filtered.length)
+                        break;
+                    const item = this.filtered[idx];
+                    const isSelected = idx === this.cursor;
+                    // Render Emoji
+                    // Align center in 4 chars
+                    // Emoji width is typically 2.
+                    const emoji = item.char;
+                    const width = (0, utils_1.stringWidth)(emoji);
+                    const padding = 4 - width;
+                    const leftPad = Math.floor(padding / 2);
+                    const rightPad = padding - leftPad;
+                    let cell = `${' '.repeat(leftPad)}${emoji}${' '.repeat(rightPad)}`;
+                    if (isSelected) {
+                        cell = `${ansi_1.ANSI.REVERSE}${cell}${ansi_1.ANSI.RESET}`;
+                    }
+                    rowStr += cell;
+                }
+                output += rowStr + '\n';
+            }
+            // Footer (Preview of selected)
+            if (this.filtered.length > 0) {
+                const selectedItem = this.filtered[this.cursor];
+                output += `\n${ansi_1.ANSI.BOLD}${selectedItem.char}  ${selectedItem.name}${ansi_1.ANSI.RESET}`;
+                if (selectedItem.description) {
+                    output += ` - ${theme_1.theme.muted}${selectedItem.description}${ansi_1.ANSI.RESET}`;
+                }
+            }
+            else {
+                output += '\n'; // Spacer
+            }
+        }
+        // Navigation hints
+        // output += `\n${theme.muted}Arrows to navigate, Enter to select${ANSI.RESET}`;
+        this.renderFrame(output);
+    }
+    handleInput(char) {
+        // Navigation
+        if (this.isUp(char)) {
+            if (this.filtered.length === 0)
+                return;
+            const newCursor = this.cursor - this.cols;
+            if (newCursor >= 0) {
+                this.cursor = newCursor;
+            }
+            this.adjustScroll();
+            this.render(false);
+            return;
+        }
+        if (this.isDown(char)) {
+            if (this.filtered.length === 0)
+                return;
+            const newCursor = this.cursor + this.cols;
+            if (newCursor < this.filtered.length) {
+                this.cursor = newCursor;
+            }
+            this.adjustScroll();
+            this.render(false);
+            return;
+        }
+        if (this.isLeft(char)) {
+            if (this.filtered.length === 0)
+                return;
+            if (this.cursor > 0) {
+                this.cursor--;
+            }
+            else {
+                // Wrap to end?
+                this.cursor = this.filtered.length - 1;
+            }
+            this.adjustScroll();
+            this.render(false);
+            return;
+        }
+        if (this.isRight(char)) {
+            if (this.filtered.length === 0)
+                return;
+            if (this.cursor < this.filtered.length - 1) {
+                this.cursor++;
+            }
+            else {
+                // Wrap to start?
+                this.cursor = 0;
+            }
+            this.adjustScroll();
+            this.render(false);
+            return;
+        }
+        // Enter
+        if (char === '\r' || char === '\n') {
+            if (this.filtered.length > 0) {
+                this.submit(this.filtered[this.cursor].char);
+            }
+            return;
+        }
+        // Backspace
+        if (char === '\u0008' || char === '\x7f') {
+            if (this.search.length > 0) {
+                this.search = this.search.slice(0, -1);
+                this.updateFilter();
+                this.render(false);
+            }
+            return;
+        }
+        // Typing
+        if (!/^[\x00-\x1F]/.test(char) && !char.startsWith('\x1b')) {
+            this.search += char;
+            this.updateFilter();
+            this.render(false);
+        }
+    }
+    handleMouse(event) {
+        if (event.action === 'scroll' && this.filtered.length > 0) {
+            if (event.scroll === 'up') {
+                // Left / Previous
+                if (this.cursor > 0) {
+                    this.cursor--;
+                }
+                else {
+                    this.cursor = this.filtered.length - 1;
+                }
+            }
+            else {
+                // Right / Next
+                if (this.cursor < this.filtered.length - 1) {
+                    this.cursor++;
+                }
+                else {
+                    this.cursor = 0;
+                }
+            }
+            this.adjustScroll();
+            this.render(false);
+        }
+    }
+    adjustScroll() {
+        const cursorRow = Math.floor(this.cursor / this.cols);
+        if (cursorRow < this.scrollTop) {
+            this.scrollTop = cursorRow;
+        }
+        else if (cursorRow >= this.scrollTop + this.pageSize) {
+            this.scrollTop = cursorRow - this.pageSize + 1;
+        }
+    }
+}
+exports.EmojiPrompt = EmojiPrompt;

package/dist/prompts/exec.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from '../base';
+import { ExecOptions } from '../types';
+export declare class ExecPrompt extends Prompt<void, ExecOptions> {
+    private child?;
+    private status;
+    private timer?;
+    constructor(options: ExecOptions);
+    run(): Promise<void>;
+    private killChild;
+    protected cleanup(): void;
+    protected render(_firstRender: boolean): void;
+    protected handleInput(_char: string, _key: Buffer): void;
+}

package/dist/prompts/exec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecPrompt = void 0;
+const child_process_1 = require("child_process");
+const base_1 = require("../base");
+const theme_1 = require("../theme");
+const symbols_1 = require("../symbols");
+const ansi_1 = require("../ansi");
+class ExecPrompt extends base_1.Prompt {
+    constructor(options) {
+        super(options);
+        this.status = 'running';
+        this.warnExperimental();
+    }
+    run() {
+        this.child = (0, child_process_1.spawn)(this.options.command, [], {
+            cwd: this.options.cwd || process.cwd(),
+            shell: true,
+            stdio: this.options.streamOutput ? 'inherit' : 'ignore'
+        });
+        if (this.options.timeout && this.options.timeout > 0) {
+            this.timer = setTimeout(() => {
+                if (this.status !== 'running')
+                    return;
+                this.status = 'error';
+                this.render(false);
+                this.cancel(new Error(`Timeout after ${this.options.timeout}ms`));
+            }, this.options.timeout);
+        }
+        this.child.on('exit', (code) => {
+            if (this.status !== 'running')
+                return;
+            if (code === 0) {
+                this.status = 'done';
+                this.render(false);
+                this.submit();
+            }
+            else {
+                this.status = 'error';
+                this.render(false);
+                this.cancel(new Error(`Command failed with exit code ${code}`));
+            }
+        });
+        this.child.on('error', (err) => {
+            if (this.status !== 'running')
+                return;
+            this.status = 'error';
+            this.render(false);
+            this.cancel(err);
+        });
+        return super.run();
+    }
+    killChild() {
+        if (this.child && !this.child.killed) {
+            this.child.kill();
+        }
+    }
+    cleanup() {
+        this.status = 'done';
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.killChild();
+        super.cleanup();
+    }
+    render(_firstRender) {
+        let symbol = '';
+        if (this.status === 'running') {
+            symbol = theme_1.theme.muted + '...' + ansi_1.ANSI.RESET;
+        }
+        else if (this.status === 'done') {
+            symbol = theme_1.theme.success + symbols_1.symbols.tick + ansi_1.ANSI.RESET;
+        }
+        else if (this.status === 'error') {
+            symbol = theme_1.theme.error + symbols_1.symbols.cross + ansi_1.ANSI.RESET;
+        }
+        const output = `${theme_1.theme.title}${this.options.message}${ansi_1.ANSI.RESET} ${symbol}`;
+        this.renderFrame(output);
+    }
+    handleInput(_char, _key) {
+        // Ignore input
+    }
+}
+exports.ExecPrompt = ExecPrompt;

package/dist/prompts/fuzzy.d.ts

@@ -0,0 +1,12 @@
+import { SelectPrompt } from './select';
+import { FuzzySelectOptions } from '../types';
+export declare class FuzzySelectPrompt<V> extends SelectPrompt<V, FuzzySelectOptions<V>> {
+    private filteredResults;
+    private debounceTimer;
+    constructor(options: FuzzySelectOptions<V>);
+    protected getFilteredChoices(): any[];
+    protected handleInput(char: string): void;
+    private performSearch;
+    private highlight;
+    protected render(_firstRender: boolean): void;
+}