@hyperfrontend/questions 0.1.0

package/index.esm.js

@@ -0,0 +1,1211 @@
+import { createInterface } from 'node:readline';
+
+/**
+ * Safe copies of Object built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
+ */
+const _Object = globalThis.Object;
+/**
+ * (Safe copy) Prevents modification of existing property attributes and values,
+ * and prevents the addition of new properties.
+ */
+const freeze = _Object.freeze;
+
+/**
+ * Safe Promise factory and bound static methods.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/promise
+ */
+/* eslint-disable workspace/lib-require-jsdoc-example */
+const _Promise = globalThis.Promise;
+const _Reflect = globalThis.Reflect;
+/**
+ * (Safe copy) Creates a new Promise using the captured Promise constructor.
+ * Use this instead of `new Promise()`.
+ *
+ * @param executor - The executor function.
+ * @returns A new Promise instance.
+ */
+const createPromise = (executor) => _Reflect.construct(_Promise, [executor]);
+/**
+ * (Safe copy) Returns a Promise that resolves with the given value.
+ */
+_Promise.resolve.bind(_Promise);
+/**
+ * (Safe copy) Returns a Promise that rejects with the given reason.
+ */
+_Promise.reject.bind(_Promise);
+/**
+ * (Safe copy) Returns a Promise that resolves when all promises resolve.
+ */
+_Promise.all.bind(_Promise);
+/**
+ * (Safe copy) Returns a Promise that resolves/rejects with the first settled promise.
+ */
+_Promise.race.bind(_Promise);
+/**
+ * (Safe copy) Returns a Promise that resolves when all promises settle.
+ */
+_Promise.allSettled.bind(_Promise);
+/**
+ * (Safe copy) Returns a Promise that resolves with the first fulfilled promise.
+ */
+_Promise.any.bind(_Promise);
+/**
+ * (Safe copy) Creates a Promise along with its resolve and reject functions.
+ * Note: Available only in ES2024+ environments.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+_Promise.withResolvers?.bind(_Promise);
+
+/**
+ * Terminal I/O utilities using Node.js readline.
+ *
+ * @internal
+ */
+/**
+ * Key codes for terminal navigation.
+ */
+const Key = freeze({
+    Up: '\x1B[A',
+    Down: '\x1B[B',
+    Left: '\x1B[D',
+    Right: '\x1B[C',
+    Enter: '\r',
+    Space: ' ',
+    Tab: '\t',
+    Escape: '\x1B',
+    Backspace: '\x7F',
+    Delete: '\x1B[3~',
+    CtrlC: '\x03',
+});
+/**
+ * ANSI escape codes for terminal styling.
+ */
+const Ansi = freeze({
+    /** Clear entire line */
+    ClearLine: '\x1B[2K',
+    /** Move cursor to start of line */
+    CursorStart: '\r',
+    /**
+     * Generates ANSI escape code to move cursor up by specified lines.
+     *
+     * @param n - Number of lines to move up
+     * @returns ANSI escape sequence string
+     */
+    cursorUp: (n) => `\x1B[${n}A`,
+    /**
+     * Generates ANSI escape code to move cursor down by specified lines.
+     *
+     * @param n - Number of lines to move down
+     * @returns ANSI escape sequence string
+     */
+    cursorDown: (n) => `\x1B[${n}B`,
+    /** Escape code to hide cursor */
+    HideCursor: '\x1B[?25l',
+    /** Escape code to show cursor */
+    ShowCursor: '\x1B[?25h',
+    /** Escape code to save cursor position */
+    SaveCursor: '\x1B7',
+    /** Escape code to restore cursor position */
+    RestoreCursor: '\x1B8',
+    /** Clear from cursor to end of screen */
+    ClearToEnd: '\x1B[J',
+    /** Escape code for bold text */
+    Bold: '\x1B[1m',
+    /** Escape code for dim text */
+    Dim: '\x1B[2m',
+    /** Escape code to reset all styles */
+    Reset: '\x1B[0m',
+    /** Escape code for cyan foreground */
+    Cyan: '\x1B[36m',
+    /** Escape code for green foreground */
+    Green: '\x1B[32m',
+    /** Escape code for yellow foreground */
+    Yellow: '\x1B[33m',
+    /** Escape code for gray foreground */
+    Gray: '\x1B[90m',
+});
+/**
+ * Creates a terminal interface for interactive prompts.
+ *
+ * @param config - Terminal configuration options
+ * @returns Terminal interface with read/write methods
+ *
+ * @example Create terminal for prompts
+ * ```typescript
+ * const term = createTerminal()
+ * term.write('Enter name: ')
+ * const name = await term.readLine()
+ * term.close()
+ * ```
+ */
+function createTerminal(config = {}) {
+    const input = config.input ?? process.stdin;
+    const output = config.output ?? process.stdout;
+    let cancelled = false;
+    let rl;
+    const getReadline = () => {
+        if (!rl) {
+            rl = createInterface({ input, output, terminal: true });
+        }
+        return rl;
+    };
+    const write = (text) => {
+        output.write(text);
+    };
+    const readKey = () => createPromise((resolve) => {
+        const wasRaw = input.isRaw;
+        if (input.setRawMode) {
+            input.setRawMode(true);
+        }
+        const onData = (data) => {
+            input.removeListener('data', onData);
+            if (input.setRawMode) {
+                input.setRawMode(wasRaw);
+            }
+            const key = data.toString();
+            if (key === Key.CtrlC) {
+                cancelled = true;
+            }
+            resolve(key);
+        };
+        input.once('data', onData);
+    });
+    const readLine = () => createPromise((resolve) => {
+        const readline = getReadline();
+        readline.once('line', (line) => {
+            resolve(line);
+        });
+        readline.once('close', () => {
+            cancelled = true;
+            resolve('');
+        });
+    });
+    const clearLines = (count) => {
+        if (count <= 0)
+            return;
+        for (let i = 0; i < count; i++) {
+            write(Ansi.CursorStart + Ansi.ClearLine);
+            if (i < count - 1) {
+                write(Ansi.cursorUp(1));
+            }
+        }
+    };
+    const close = () => {
+        if (rl) {
+            rl.close();
+            rl = undefined;
+        }
+        write(Ansi.ShowCursor);
+    };
+    return freeze({
+        write,
+        readKey,
+        readLine,
+        clearLines,
+        close,
+        isCancelled: () => cancelled,
+        cancel: () => {
+            cancelled = true;
+        },
+    });
+}
+
+/**
+ * Symbols and styling for prompt rendering.
+ *
+ * @internal
+ */
+/**
+ * Unicode symbols for prompt rendering.
+ */
+const Symbol = freeze({
+    Pointer: '❯',
+    Radio: '◯',
+    RadioSelected: '◉',
+    Checkbox: '☐',
+    CheckboxSelected: '☑',
+    Check: '✔',
+    Cross: '✖',
+    Question: '?',
+    Ellipsis: '…',
+});
+/**
+ * Style functions for ANSI text formatting.
+ */
+const style = freeze({
+    /**
+     * Applies bold styling to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in bold ANSI codes
+     */
+    bold: (text) => `${Ansi.Bold}${text}${Ansi.Reset}`,
+    /**
+     * Applies dim styling to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in dim ANSI codes
+     */
+    dim: (text) => `${Ansi.Dim}${text}${Ansi.Reset}`,
+    /**
+     * Applies cyan color to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in cyan ANSI codes
+     */
+    cyan: (text) => `${Ansi.Cyan}${text}${Ansi.Reset}`,
+    /**
+     * Applies green color to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in green ANSI codes
+     */
+    green: (text) => `${Ansi.Green}${text}${Ansi.Reset}`,
+    /**
+     * Applies yellow color to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in yellow ANSI codes
+     */
+    yellow: (text) => `${Ansi.Yellow}${text}${Ansi.Reset}`,
+    /**
+     * Applies gray color to text.
+     *
+     * @param text - Text to style
+     * @returns Text wrapped in gray ANSI codes
+     */
+    gray: (text) => `${Ansi.Gray}${text}${Ansi.Reset}`,
+});
+/**
+ * Renders a prompt message with consistent styling.
+ *
+ * @param message - The prompt message to display
+ * @returns Formatted message string with cyan question mark and bold text
+ *
+ * @example Render a prompt message
+ * ```typescript
+ * const output = renderMessage('Enter your name')
+ * // Returns "? Enter your name " with styling
+ * ```
+ */
+function renderMessage(message) {
+    return `${style.cyan(Symbol.Question)} ${style.bold(message)} `;
+}
+/**
+ * Renders a submitted value with visual confirmation styling.
+ *
+ * @param value - The value that was submitted
+ * @returns Value string styled in cyan
+ *
+ * @example Render submitted input
+ * ```typescript
+ * const output = renderSubmitted('John Doe')
+ * // Returns "John Doe" in cyan
+ * ```
+ */
+function renderSubmitted(value) {
+    return style.cyan(value);
+}
+/**
+ * Renders a cancellation indicator.
+ *
+ * @returns Dimmed "(cancelled)" string
+ *
+ * @example Show cancellation
+ * ```typescript
+ * const output = renderCancelled()
+ * // Returns "(cancelled)" in dim style
+ * ```
+ */
+function renderCancelled() {
+    return style.dim('(cancelled)');
+}
+
+/**
+ * Core types for terminal prompts.
+ *
+ * @internal
+ */
+/**
+ * Result state of a prompt interaction.
+ */
+const PromptResult = freeze({
+    /** User submitted a value */
+    Submitted: 'submitted',
+    /** User cancelled the prompt (Ctrl+C) */
+    Cancelled: 'cancelled',
+});
+
+/**
+ * Renders the confirm prompt hint based on default value.
+ *
+ * @internal
+ * @param initial - The default value for the confirmation
+ * @returns Styled hint string showing Y/n options
+ */
+function renderOptions(initial) {
+    if (initial === true) {
+        return style.dim('(Y/n)');
+    }
+    if (initial === false) {
+        return style.dim('(y/N)');
+    }
+    return style.dim('(y/n)');
+}
+/**
+ * Prompts for yes/no confirmation.
+ *
+ * Pure functional prompt that asks a yes/no question and returns a boolean.
+ * Supports default values and responds to y/Y/n/N keys.
+ *
+ * @param config - Confirm prompt configuration
+ * @returns Promise resolving to boolean value or cancellation
+ *
+ * @example Basic confirmation
+ * ```typescript
+ * const outcome = await confirm({ message: 'Continue?' })
+ * if (outcome.result === 'submitted' && outcome.value) {
+ *   console.log('Proceeding...')
+ * }
+ * ```
+ *
+ * @example With default value
+ * ```typescript
+ * const outcome = await confirm({
+ *   message: 'Enable feature?',
+ *   initial: true, // Default to yes
+ * })
+ * ```
+ */
+async function confirm(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    const drawPrompt = () => {
+        term.write(Ansi.CursorStart + Ansi.ClearLine);
+        term.write(renderMessage(config.message) + renderOptions(config.initial) + ' ');
+    };
+    const drawResult = (value) => {
+        term.write(Ansi.CursorStart + Ansi.ClearLine);
+        term.write(renderMessage(config.message) + renderSubmitted(value ? 'Yes' : 'No') + '\n');
+    };
+    drawPrompt();
+    while (true) {
+        const key = await term.readKey();
+        const lowerKey = key.toLowerCase();
+        if (term.isCancelled()) {
+            term.write(Ansi.CursorStart + Ansi.ClearLine);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.close();
+            return freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (lowerKey === 'y') {
+            drawResult(true);
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value: true });
+        }
+        if (lowerKey === 'n') {
+            drawResult(false);
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value: false });
+        }
+        if (key === Key.Enter && config.initial !== undefined) {
+            drawResult(config.initial);
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value: config.initial });
+        }
+    }
+}
+
+/**
+ * Checks if an array includes a value.
+ *
+ * @internal
+ * @param arr - Array to search
+ * @param value - Value to find
+ * @returns True if value is in array
+ */
+function arrayIncludes(arr, value) {
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i] === value)
+            return true;
+    }
+    return false;
+}
+/**
+ * Filters choices based on search query.
+ *
+ * @internal
+ * @param choices - All available choices
+ * @param query - Search query string
+ * @returns Array of indices matching the query
+ */
+function filterChoices(choices, query) {
+    if (!query) {
+        return choices.map((_, i) => i);
+    }
+    const lowerQuery = query.toLowerCase();
+    const indices = [];
+    choices.forEach((choice, i) => {
+        if (choice.label.toLowerCase().includes(lowerQuery)) {
+            indices.push(i);
+        }
+    });
+    return freeze(indices);
+}
+/**
+ * Creates initial state for multiselect prompt.
+ *
+ * @internal
+ * @param config - Prompt configuration
+ * @returns Initial multiselect state
+ */
+function createInitialState$2(config) {
+    return freeze({
+        cursor: 0,
+        selected: config.initial ? [...config.initial] : [],
+        choices: config.choices,
+        filteredIndices: config.choices.map((_, i) => i),
+        searchQuery: '',
+        scrollOffset: 0,
+    });
+}
+/**
+ * Calculates the visible window of choices for scrolling.
+ *
+ * @internal
+ * @param state - Current prompt state
+ * @param maxVisible - Maximum number of visible choices
+ * @returns Object containing visible indices and start index
+ */
+function getVisibleChoices$1(state, maxVisible) {
+    const total = state.filteredIndices.length;
+    if (total <= maxVisible) {
+        return { indices: state.filteredIndices, startIndex: 0 };
+    }
+    let startIndex = state.scrollOffset;
+    if (state.cursor < startIndex) {
+        startIndex = state.cursor;
+    }
+    else if (state.cursor >= startIndex + maxVisible) {
+        startIndex = state.cursor - maxVisible + 1;
+    }
+    return {
+        indices: state.filteredIndices.slice(startIndex, startIndex + maxVisible),
+        startIndex,
+    };
+}
+/**
+ * Renders a single choice line for multiselect.
+ *
+ * @internal
+ * @param choice - The choice to render
+ * @param isSelected - Whether this choice is selected
+ * @param isFocused - Whether cursor is on this choice
+ * @returns Formatted choice string
+ */
+function renderChoice$1(choice, isSelected, isFocused) {
+    const pointer = isFocused ? style.cyan(Symbol.Pointer) : ' ';
+    const checkbox = isSelected ? style.green(Symbol.CheckboxSelected) : style.dim(Symbol.Checkbox);
+    let label = choice.label;
+    if (choice.disabled) {
+        label = style.dim(label + ' (disabled)');
+    }
+    else if (isFocused) {
+        label = isSelected ? style.green(label) : style.cyan(label);
+    }
+    else if (isSelected) {
+        label = style.green(label);
+    }
+    const hint = choice.hint ? style.dim(` — ${choice.hint}`) : '';
+    return `${pointer} ${checkbox} ${label}${hint}`;
+}
+/**
+ * Renders the multiselect prompt to the terminal.
+ *
+ * @internal
+ * @param term - Terminal interface
+ * @param config - Prompt configuration
+ * @param state - Current prompt state
+ * @param submitted - Whether the prompt has been submitted
+ * @returns Number of lines rendered
+ */
+function render$2(term, config, state, submitted) {
+    const maxVisible = config.maxVisible ?? 10;
+    const { indices: visibleIndices, startIndex } = getVisibleChoices$1(state, maxVisible);
+    let output = Ansi.CursorStart + Ansi.ClearLine + renderMessage(config.message);
+    if (submitted) {
+        const selectedLabels = state.selected.map((i) => state.choices[i]?.label ?? '').join(', ');
+        output += renderSubmitted(selectedLabels || 'none');
+        term.write(output);
+        return 1;
+    }
+    if (config.searchable && state.searchQuery) {
+        output += style.cyan(state.searchQuery) + style.dim(' (type to filter)');
+    }
+    else if (config.searchable) {
+        output += style.dim('(type to filter, space to toggle, enter to submit)');
+    }
+    else {
+        output += style.dim('(space to toggle, enter to submit)');
+    }
+    term.write(output + '\n');
+    let lineCount = 1;
+    const minMax = [];
+    if (config.min !== undefined)
+        minMax.push(`min: ${config.min}`);
+    if (config.max !== undefined)
+        minMax.push(`max: ${config.max}`);
+    const countHint = minMax.length > 0 ? ` (${minMax.join(', ')})` : '';
+    term.write(Ansi.ClearLine + style.dim(`  ${state.selected.length} selected${countHint}`) + '\n');
+    lineCount++;
+    const showScrollUp = startIndex > 0;
+    const showScrollDown = startIndex + maxVisible < state.filteredIndices.length;
+    if (showScrollUp) {
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${startIndex} more above)`) + '\n');
+        lineCount++;
+    }
+    visibleIndices.forEach((actualIndex, i) => {
+        const choice = state.choices[actualIndex];
+        /* istanbul ignore if -- @preserve defensive: actualIndex always valid from filteredIndices */
+        if (!choice)
+            return;
+        const viewIndex = startIndex + i;
+        const isFocused = viewIndex === state.cursor;
+        const isSelected = arrayIncludes(state.selected, actualIndex);
+        const line = renderChoice$1(choice, isSelected, isFocused);
+        term.write(Ansi.ClearLine + line + '\n');
+        lineCount++;
+    });
+    if (showScrollDown) {
+        const remaining = state.filteredIndices.length - (startIndex + maxVisible);
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${remaining} more below)`) + '\n');
+        lineCount++;
+    }
+    if (state.filteredIndices.length === 0 && config.searchable) {
+        term.write(Ansi.ClearLine + style.dim('  No matches found') + '\n');
+        lineCount++;
+    }
+    return lineCount;
+}
+/**
+ * Processes a keypress and returns updated state.
+ *
+ * @internal
+ * @param key - The key that was pressed
+ * @param state - Current prompt state
+ * @param config - Prompt configuration
+ * @returns Updated state after processing the key
+ */
+function processKey$2(key, state, config) {
+    const maxVisible = config.maxVisible ?? 10;
+    const total = state.filteredIndices.length;
+    if (total === 0 && key !== Key.Backspace && key !== '\b')
+        return state;
+    if (key === Key.Up) {
+        let newCursor = state.cursor - 1;
+        while (newCursor >= 0 && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor--;
+        }
+        if (newCursor < 0)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor < state.scrollOffset) {
+            newScrollOffset = newCursor;
+        }
+        return freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Down) {
+        let newCursor = state.cursor + 1;
+        while (newCursor < total && state.choices[state.filteredIndices[newCursor] ?? -1]?.disabled) {
+            newCursor++;
+        }
+        if (newCursor >= total)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor >= state.scrollOffset + maxVisible) {
+            newScrollOffset = newCursor - maxVisible + 1;
+        }
+        return freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Space) {
+        const actualIndex = state.filteredIndices[state.cursor];
+        if (actualIndex === undefined)
+            return state;
+        const choice = state.choices[actualIndex];
+        /* istanbul ignore if -- @preserve defensive: actualIndex validated above */
+        if (!choice || choice.disabled)
+            return state;
+        const isSelected = arrayIncludes(state.selected, actualIndex);
+        if (isSelected) {
+            const newSelected = state.selected.filter((i) => i !== actualIndex);
+            return freeze({ ...state, selected: newSelected });
+        }
+        else {
+            if (config.max !== undefined && state.selected.length >= config.max) {
+                return state;
+            }
+            const newSelected = [...state.selected, actualIndex];
+            return freeze({ ...state, selected: newSelected });
+        }
+    }
+    if (config.searchable) {
+        if (key === Key.Backspace || key === '\b') {
+            if (state.searchQuery.length > 0) {
+                const newQuery = state.searchQuery.slice(0, -1);
+                const newFiltered = filterChoices(state.choices, newQuery);
+                return freeze({
+                    ...state,
+                    searchQuery: newQuery,
+                    filteredIndices: newFiltered,
+                    cursor: 0,
+                    scrollOffset: 0,
+                });
+            }
+            return state;
+        }
+        if (key.length === 1 && key >= ' ' && key !== Key.Space) {
+            const newQuery = state.searchQuery + key;
+            const newFiltered = filterChoices(state.choices, newQuery);
+            return freeze({
+                ...state,
+                searchQuery: newQuery,
+                filteredIndices: newFiltered,
+                cursor: 0,
+                scrollOffset: 0,
+            });
+        }
+    }
+    return state;
+}
+/**
+ * Validates selection count against min/max constraints.
+ *
+ * @internal
+ * @param state - Current prompt state
+ * @param config - Prompt configuration with min/max constraints
+ * @returns Error message string if validation fails, undefined if valid
+ */
+function validateSelection(state, config) {
+    if (config.min !== undefined && state.selected.length < config.min) {
+        return `Select at least ${config.min} option${config.min === 1 ? '' : 's'}`;
+    }
+    if (config.max !== undefined && state.selected.length > config.max) {
+        return `Select at most ${config.max} option${config.max === 1 ? '' : 's'}`;
+    }
+    return undefined;
+}
+/**
+ * Prompts for multiple selections from a list of choices.
+ *
+ * Pure functional prompt with arrow key navigation, space to toggle,
+ * scrolling support, min/max constraints, and optional type-to-filter search.
+ *
+ * @param config - Multiselect prompt configuration
+ * @returns Promise resolving to array of selected values or cancellation
+ *
+ * @example Basic multiselect
+ * ```typescript
+ * const outcome = await multiselect({
+ *   message: 'Select toppings:',
+ *   choices: [
+ *     { label: 'Cheese', value: 'cheese' },
+ *     { label: 'Pepperoni', value: 'pepperoni' },
+ *     { label: 'Mushrooms', value: 'mushrooms' },
+ *   ],
+ * })
+ * if (outcome.result === 'submitted') {
+ *   console.log(`You selected: ${outcome.value.join(', ')}`)
+ * }
+ * ```
+ *
+ * @example With search and constraints
+ * ```typescript
+ * const outcome = await multiselect({
+ *   message: 'Select features:',
+ *   choices: features.map((f) => ({ label: f.name, value: f.id })),
+ *   searchable: true,
+ *   min: 1,
+ *   max: 5,
+ * })
+ * ```
+ *
+ * @example Pre-selected values
+ * ```typescript
+ * const outcome = await multiselect({
+ *   message: 'Select permissions:',
+ *   choices: permissions,
+ *   initial: [0, 2], // First and third choices pre-selected
+ * })
+ * ```
+ */
+async function multiselect(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    let state = createInitialState$2(config);
+    let lineCount = 0;
+    let errorMessage;
+    term.write(Ansi.HideCursor);
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+        }
+        term.write(Ansi.ClearToEnd);
+        lineCount = render$2(term, config, state, submitted);
+        if (errorMessage && !submitted) {
+            term.write(Ansi.ClearLine + style.yellow(`  ${errorMessage}`) + '\n');
+            lineCount++;
+        }
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const validationError = validateSelection(state, config);
+            if (validationError) {
+                errorMessage = validationError;
+                redraw();
+                continue;
+            }
+            const selectedValues = state.selected.map((i) => state.choices[i]?.value).filter((v) => v !== undefined);
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            render$2(term, config, state, true);
+            term.write('\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value: freeze(selectedValues) });
+        }
+        errorMessage = undefined;
+        state = processKey$2(key, state, config);
+        redraw();
+    }
+}
+
+/**
+ * Creates initial state for select prompt.
+ *
+ * @internal
+ * @param config - Prompt configuration
+ * @returns Initial select state
+ */
+function createInitialState$1(config) {
+    return freeze({
+        cursor: config.initial ?? 0,
+        choices: config.choices,
+        scrollOffset: 0,
+    });
+}
+/**
+ * Calculates the visible window of choices for scrolling.
+ *
+ * @internal
+ * @param state - Current prompt state
+ * @param maxVisible - Maximum number of visible choices
+ * @returns Visible choices and their start index
+ */
+function getVisibleChoices(state, maxVisible) {
+    const total = state.choices.length;
+    if (total <= maxVisible) {
+        return { choices: state.choices, startIndex: 0 };
+    }
+    let startIndex = state.scrollOffset;
+    if (state.cursor < startIndex) {
+        startIndex = state.cursor;
+    }
+    else if (state.cursor >= startIndex + maxVisible) {
+        startIndex = state.cursor - maxVisible + 1;
+    }
+    return {
+        choices: state.choices.slice(startIndex, startIndex + maxVisible),
+        startIndex,
+    };
+}
+/**
+ * Renders a single choice line with selection styling.
+ *
+ * @internal
+ * @param choice - The choice to render
+ * @param isSelected - Whether this choice is selected
+ * @param isFocused - Whether cursor is on this choice
+ * @returns Formatted choice string
+ */
+function renderChoice(choice, isSelected, isFocused) {
+    const pointer = isFocused ? style.cyan(Symbol.Pointer) : ' ';
+    const radio = isSelected ? style.green(Symbol.RadioSelected) : style.dim(Symbol.Radio);
+    let label = choice.label;
+    if (choice.disabled) {
+        label = style.dim(label + ' (disabled)');
+    }
+    else if (isFocused) {
+        label = style.cyan(label);
+    }
+    const hint = choice.hint ? style.dim(` — ${choice.hint}`) : '';
+    return `${pointer} ${radio} ${label}${hint}`;
+}
+/**
+ * Renders the select prompt to the terminal.
+ *
+ * @internal
+ * @param term - Terminal interface
+ * @param config - Prompt configuration
+ * @param state - Current prompt state
+ * @param submitted - Whether the prompt has been submitted
+ * @returns Number of lines rendered
+ */
+function render$1(term, config, state, submitted) {
+    const maxVisible = config.maxVisible ?? 10;
+    const { choices: visibleChoices, startIndex } = getVisibleChoices(state, maxVisible);
+    let output = Ansi.CursorStart + Ansi.ClearLine + renderMessage(config.message);
+    if (submitted) {
+        const selectedChoice = state.choices[state.cursor];
+        /* istanbul ignore next -- @preserve defensive: cursor always within bounds */
+        output += renderSubmitted(selectedChoice?.label ?? '');
+        term.write(output);
+        return 1;
+    }
+    output += style.dim('(use arrows, enter to select)');
+    term.write(output + '\n');
+    let lineCount = 1;
+    const showScrollUp = startIndex > 0;
+    const showScrollDown = startIndex + maxVisible < state.choices.length;
+    if (showScrollUp) {
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${startIndex} more above)`) + '\n');
+        lineCount++;
+    }
+    visibleChoices.forEach((choice, i) => {
+        const actualIndex = startIndex + i;
+        const isFocused = actualIndex === state.cursor;
+        const line = renderChoice(choice, isFocused, isFocused);
+        term.write(Ansi.ClearLine + line + '\n');
+        lineCount++;
+    });
+    if (showScrollDown) {
+        const remaining = state.choices.length - (startIndex + maxVisible);
+        term.write(Ansi.ClearLine + style.dim(`  ${Symbol.Ellipsis} (${remaining} more below)`) + '\n');
+        lineCount++;
+    }
+    return lineCount;
+}
+/**
+ * Processes a keypress and returns updated state.
+ *
+ * @internal
+ * @param key - The key that was pressed
+ * @param state - Current prompt state
+ * @param maxVisible - Maximum visible choices for scroll calculation
+ * @returns Updated state after processing the key
+ */
+function processKey$1(key, state, maxVisible) {
+    const total = state.choices.length;
+    if (total === 0)
+        return state;
+    if (key === Key.Up) {
+        let newCursor = state.cursor - 1;
+        while (newCursor >= 0 && state.choices[newCursor]?.disabled) {
+            newCursor--;
+        }
+        if (newCursor < 0)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor < state.scrollOffset) {
+            newScrollOffset = newCursor;
+        }
+        return freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    if (key === Key.Down) {
+        let newCursor = state.cursor + 1;
+        while (newCursor < total && state.choices[newCursor]?.disabled) {
+            newCursor++;
+        }
+        if (newCursor >= total)
+            return state;
+        let newScrollOffset = state.scrollOffset;
+        if (newCursor >= state.scrollOffset + maxVisible) {
+            newScrollOffset = newCursor - maxVisible + 1;
+        }
+        return freeze({ ...state, cursor: newCursor, scrollOffset: newScrollOffset });
+    }
+    return state;
+}
+/**
+ * Prompts for single selection from a list of choices.
+ *
+ * Pure functional prompt with arrow key navigation, scrolling support,
+ * and optional disabled choices.
+ *
+ * @param config - Select prompt configuration
+ * @returns Promise resolving to selected value or cancellation
+ *
+ * @example Basic select
+ * ```typescript
+ * const outcome = await select({
+ *   message: 'Choose a color:',
+ *   choices: [
+ *     { label: 'Red', value: 'red' },
+ *     { label: 'Green', value: 'green' },
+ *     { label: 'Blue', value: 'blue' },
+ *   ],
+ * })
+ * if (outcome.result === 'submitted') {
+ *   console.log(`You chose: ${outcome.value}`)
+ * }
+ * ```
+ *
+ * @example With hints and disabled options
+ * ```typescript
+ * const outcome = await select({
+ *   message: 'Select plan:',
+ *   choices: [
+ *     { label: 'Free', value: 'free', hint: '$0/month' },
+ *     { label: 'Pro', value: 'pro', hint: '$10/month' },
+ *     { label: 'Enterprise', value: 'enterprise', disabled: true },
+ *   ],
+ *   initial: 1, // Start on Pro
+ * })
+ * ```
+ */
+async function select(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    const maxVisible = config.maxVisible ?? 10;
+    let state = createInitialState$1(config);
+    let lineCount = 0;
+    term.write(Ansi.HideCursor);
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+        }
+        lineCount = render$1(term, config, state, submitted);
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            term.write(renderMessage(config.message) + renderCancelled() + '\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const selectedChoice = state.choices[state.cursor];
+            if (!selectedChoice || selectedChoice.disabled) {
+                continue;
+            }
+            if (lineCount > 0) {
+                term.write(Ansi.cursorUp(lineCount - 1) + Ansi.CursorStart);
+            }
+            term.write(Ansi.ClearToEnd);
+            render$1(term, config, state, true);
+            term.write('\n');
+            term.write(Ansi.ShowCursor);
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value: selectedChoice.value });
+        }
+        state = processKey$1(key, state, maxVisible);
+        redraw();
+    }
+}
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+const _Math = globalThis.Math;
+/**
+ * (Safe copy) Returns the larger of zero or more numbers.
+ */
+const max = _Math.max;
+/**
+ * (Safe copy) Returns the smaller of zero or more numbers.
+ */
+const min = _Math.min;
+
+/**
+ * Creates initial state for text prompt.
+ *
+ * @internal
+ * @param config - Prompt configuration containing initial value
+ * @returns Initial text state object
+ */
+function createInitialState(config) {
+    return {
+        value: config.initial ?? '',
+        cursorPos: (config.initial ?? '').length,
+        error: undefined,
+    };
+}
+/**
+ * Renders the text prompt to the terminal.
+ *
+ * @internal
+ * @param term - Terminal interface for output
+ * @param config - Prompt configuration
+ * @param state - Current prompt state
+ * @param submitted - Whether the prompt has been submitted
+ * @returns Number of lines rendered
+ */
+function render(term, config, state, submitted) {
+    const displayValue = config.format ? config.format(state.value) : state.value;
+    let output = renderMessage(config.message);
+    if (submitted) {
+        output += renderSubmitted(displayValue || config.initial || '');
+    }
+    else {
+        output += displayValue;
+        if (config.initial && !state.value) {
+            output += style.dim(config.initial);
+        }
+    }
+    term.write(Ansi.CursorStart + Ansi.ClearLine + output);
+    if (state.error) {
+        term.write('\n' + style.yellow(`  ${state.error}`));
+        return 2;
+    }
+    return 1;
+}
+/**
+ * Processes a keypress and returns updated state.
+ *
+ * @internal
+ * @param key - The key that was pressed
+ * @param state - Current prompt state
+ * @returns Updated state after processing the key
+ */
+function processKey(key, state) {
+    if (key.length === 1 && key >= ' ' && key !== Key.Backspace) {
+        const before = state.value.slice(0, state.cursorPos);
+        const after = state.value.slice(state.cursorPos);
+        return {
+            ...state,
+            value: before + key + after,
+            cursorPos: state.cursorPos + 1,
+            error: undefined,
+        };
+    }
+    if (key === Key.Backspace || key === '\b') {
+        if (state.cursorPos > 0) {
+            const before = state.value.slice(0, state.cursorPos - 1);
+            const after = state.value.slice(state.cursorPos);
+            return {
+                ...state,
+                value: before + after,
+                cursorPos: state.cursorPos - 1,
+                error: undefined,
+            };
+        }
+    }
+    if (key === Key.Left) {
+        return {
+            ...state,
+            cursorPos: max(0, state.cursorPos - 1),
+        };
+    }
+    if (key === Key.Right) {
+        return {
+            ...state,
+            cursorPos: min(state.value.length, state.cursorPos + 1),
+        };
+    }
+    return state;
+}
+/**
+ * Prompts for text input with optional validation.
+ *
+ * Pure functional prompt that reads text from the user with support for
+ * default values, input validation, and display formatting.
+ *
+ * @param config - Text prompt configuration
+ * @returns Promise resolving to submitted value or cancellation
+ *
+ * @example Basic text input
+ * ```typescript
+ * const outcome = await text({ message: 'What is your name?' })
+ * if (outcome.result === 'submitted') {
+ *   console.log(`Hello, ${outcome.value}!`)
+ * }
+ * ```
+ *
+ * @example With validation
+ * ```typescript
+ * const outcome = await text({
+ *   message: 'Enter email:',
+ *   validate: (value) => {
+ *     if (!value.includes('@')) return 'Must be a valid email'
+ *     return undefined
+ *   },
+ * })
+ * ```
+ *
+ * @example Password input with masking
+ * ```typescript
+ * const outcome = await text({
+ *   message: 'Password:',
+ *   format: (value) => '*'.repeat(value.length),
+ * })
+ * ```
+ */
+async function text(config) {
+    const term = createTerminal({ input: config.input, output: config.output });
+    let state = createInitialState(config);
+    let lineCount = 0;
+    term.write(Ansi.HideCursor);
+    const redraw = (submitted = false) => {
+        if (lineCount > 0) {
+            term.clearLines(lineCount);
+        }
+        lineCount = render(term, config, state, submitted);
+    };
+    redraw();
+    while (true) {
+        const key = await term.readKey();
+        if (term.isCancelled()) {
+            redraw();
+            term.write(renderCancelled() + '\n');
+            term.close();
+            return freeze({ result: PromptResult.Cancelled, value: undefined });
+        }
+        if (key === Key.Enter) {
+            const value = state.value || config.initial || '';
+            if (config.validate) {
+                const errorMessage = config.validate(value);
+                if (errorMessage) {
+                    state = { ...state, error: errorMessage };
+                    redraw();
+                    continue;
+                }
+            }
+            redraw(true);
+            term.write('\n');
+            term.close();
+            return freeze({ result: PromptResult.Submitted, value });
+        }
+        state = processKey(key, state);
+        redraw();
+    }
+}
+
+export { PromptResult, confirm, multiselect, select, text };
+//# sourceMappingURL=index.esm.js.map