@crustjs/prompts 0.0.1

package/dist/index.js

@@ -0,0 +1,1002 @@
+// @bun
+// src/core/theme.ts
+import { bold, cyan, dim, green, magenta, red, yellow } from "@crustjs/style";
+var defaultTheme = {
+  prefix: cyan,
+  message: bold,
+  placeholder: dim,
+  cursor: cyan,
+  selected: yellow,
+  unselected: dim,
+  error: red,
+  success: green,
+  hint: dim,
+  spinner: magenta,
+  filterMatch: cyan
+};
+function createTheme(overrides) {
+  if (!overrides)
+    return defaultTheme;
+  return { ...defaultTheme, ...overrides };
+}
+var globalOverrides;
+function setTheme(theme) {
+  globalOverrides = theme;
+}
+function getTheme() {
+  if (!globalOverrides)
+    return defaultTheme;
+  return { ...defaultTheme, ...globalOverrides };
+}
+function resolveTheme(promptTheme) {
+  if (!globalOverrides && !promptTheme)
+    return defaultTheme;
+  return {
+    ...defaultTheme,
+    ...globalOverrides,
+    ...promptTheme
+  };
+}
+// src/core/renderer.ts
+import * as readline from "readline";
+var SUBMIT = Symbol("submit");
+function submit(value) {
+  return { [SUBMIT]: value };
+}
+var promptActive = false;
+var ESC = "\x1B[";
+var HIDE_CURSOR = `${ESC}?25l`;
+var SHOW_CURSOR = `${ESC}?25h`;
+var ERASE_LINE = `${ESC}2K`;
+function cursorUp(n) {
+  return n > 0 ? `${ESC}${n}A` : "";
+}
+
+class NonInteractiveError extends Error {
+  constructor(message) {
+    super(message ?? "Prompts require an interactive terminal (TTY). Provide an `initial` value for non-interactive environments.");
+    this.name = "NonInteractiveError";
+  }
+}
+
+class CancelledError extends Error {
+  constructor(message) {
+    super(message ?? "Prompt was cancelled.");
+    this.name = "CancelledError";
+  }
+}
+function assertTTY() {
+  if (!process.stdin.isTTY) {
+    throw new NonInteractiveError;
+  }
+}
+function isSubmit(result) {
+  return typeof result === "object" && result !== null && SUBMIT in result;
+}
+function runPrompt(config) {
+  const { render, handleKey, initialState, theme, renderSubmitted } = config;
+  return new Promise((resolve, reject) => {
+    if (promptActive) {
+      reject(new Error("Cannot run multiple prompts concurrently. Await each prompt before starting the next."));
+      return;
+    }
+    try {
+      assertTTY();
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    promptActive = true;
+    let state = initialState;
+    let prevLineCount = 0;
+    let isCleanedUp = false;
+    const stdin = process.stdin;
+    const output = process.stderr;
+    function cleanup() {
+      if (isCleanedUp)
+        return;
+      isCleanedUp = true;
+      promptActive = false;
+      stdin.removeListener("keypress", onKeypress);
+      if (stdin.isTTY && stdin.isRaw) {
+        stdin.setRawMode(false);
+      }
+      stdin.pause();
+      output.write(SHOW_CURSOR);
+    }
+    function renderFrame(content) {
+      if (prevLineCount > 0) {
+        output.write(`${cursorUp(prevLineCount - 1)}\r`);
+        for (let i = 0;i < prevLineCount; i++) {
+          output.write(ERASE_LINE);
+          if (i < prevLineCount - 1) {
+            output.write(`${ESC}1B`);
+          }
+        }
+        if (prevLineCount > 1) {
+          output.write(cursorUp(prevLineCount - 1));
+        }
+        output.write(`\r`);
+      }
+      output.write(content);
+      const lines = content.split(`
+`);
+      prevLineCount = lines.length;
+    }
+    async function onKeypress(ch, key) {
+      if (key?.ctrl && key.name === "c") {
+        cleanup();
+        reject(new CancelledError);
+        return;
+      }
+      const event = {
+        char: ch ?? "",
+        name: key?.name ?? "",
+        ctrl: key?.ctrl ?? false,
+        meta: key?.meta ?? false,
+        shift: key?.shift ?? false
+      };
+      try {
+        const result = await handleKey(event, state);
+        if (isSubmit(result)) {
+          const value = result[SUBMIT];
+          if (renderSubmitted) {
+            renderFrame(renderSubmitted(state, value, theme));
+          }
+          output.write(`
+`);
+          cleanup();
+          resolve(value);
+        } else {
+          state = result;
+          renderFrame(render(state, theme));
+        }
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
+    }
+    try {
+      readline.emitKeypressEvents(stdin);
+      stdin.setRawMode(true);
+      stdin.resume();
+      output.write(HIDE_CURSOR);
+      const initialContent = render(state, theme);
+      output.write(initialContent);
+      const lines = initialContent.split(`
+`);
+      prevLineCount = lines.length;
+      stdin.on("keypress", onKeypress);
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+// src/prompts/confirm.ts
+function handleKey(key, state) {
+  if (key.name === "return") {
+    return submit(state.value);
+  }
+  if (key.name === "left" || key.name === "right") {
+    return { value: !state.value };
+  }
+  if (key.name === "h") {
+    return { value: true };
+  }
+  if (key.name === "l") {
+    return { value: false };
+  }
+  if (key.name === "tab") {
+    return { value: !state.value };
+  }
+  if (key.char === "y" || key.char === "Y") {
+    return { value: true };
+  }
+  if (key.char === "n" || key.char === "N") {
+    return { value: false };
+  }
+  return state;
+}
+var PREFIX_SYMBOL = "?";
+var SEPARATOR = " / ";
+function renderConfirm(state, theme, message, activeLabel, inactiveLabel) {
+  const prefix = theme.prefix(PREFIX_SYMBOL);
+  const msg = theme.message(message);
+  const activeDisplay = state.value ? theme.selected(activeLabel) : theme.unselected(activeLabel);
+  const inactiveDisplay = state.value ? theme.unselected(inactiveLabel) : theme.selected(inactiveLabel);
+  return `${prefix} ${msg}
+${activeDisplay}${SEPARATOR}${inactiveDisplay}`;
+}
+function renderSubmitted(_state, value, theme, message, activeLabel, inactiveLabel) {
+  const prefix = theme.prefix(PREFIX_SYMBOL);
+  const msg = theme.message(message);
+  const answer = value ? activeLabel : inactiveLabel;
+  return `${prefix} ${msg} ${theme.success(answer)}`;
+}
+async function confirm(options) {
+  if (options.initial !== undefined) {
+    return options.initial;
+  }
+  const theme = resolveTheme(options.theme);
+  const activeLabel = options.active ?? "Yes";
+  const inactiveLabel = options.inactive ?? "No";
+  const defaultValue = options.default ?? true;
+  const initialState = {
+    value: defaultValue
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderConfirm(state, t, options.message, activeLabel, inactiveLabel),
+    handleKey,
+    renderSubmitted: (state, value, t) => renderSubmitted(state, value, t, options.message, activeLabel, inactiveLabel)
+  });
+}
+// src/core/fuzzy.ts
+var CONSECUTIVE_BONUS = 5;
+var START_BONUS = 10;
+var WORD_BOUNDARY_BONUS = 8;
+var MATCH_SCORE = 1;
+function fuzzyMatch(query, candidate) {
+  if (query.length === 0) {
+    return { match: true, score: 0, indices: [] };
+  }
+  const queryLower = query.toLowerCase();
+  const candidateLower = candidate.toLowerCase();
+  const indices = [];
+  let score = 0;
+  let queryIdx = 0;
+  let prevMatchIdx = -2;
+  for (let candIdx = 0;candIdx < candidateLower.length && queryIdx < queryLower.length; candIdx++) {
+    if (candidateLower[candIdx] === queryLower[queryIdx]) {
+      indices.push(candIdx);
+      score += MATCH_SCORE;
+      if (candIdx === prevMatchIdx + 1) {
+        score += CONSECUTIVE_BONUS;
+      }
+      if (candIdx === 0) {
+        score += START_BONUS;
+      }
+      if (candIdx > 0) {
+        const prevChar = candidate[candIdx - 1];
+        if (prevChar === " " || prevChar === "-" || prevChar === "_" || prevChar === ".") {
+          score += WORD_BOUNDARY_BONUS;
+        }
+      }
+      prevMatchIdx = candIdx;
+      queryIdx++;
+    }
+  }
+  if (queryIdx < queryLower.length) {
+    return { match: false, score: 0, indices: [] };
+  }
+  return { match: true, score, indices };
+}
+function fuzzyFilter(query, items) {
+  if (query.length === 0) {
+    return items.map((item) => ({ item, score: 0, indices: [] }));
+  }
+  const results = [];
+  for (const item of items) {
+    const result = fuzzyMatch(query, item.label);
+    if (result.match) {
+      results.push({
+        item,
+        score: result.score,
+        indices: result.indices
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results;
+}
+
+// src/core/textEdit.ts
+var CURSOR_CHAR = "\u2502";
+function handleTextEdit(key, text, cursorPos) {
+  if (key.name === "backspace") {
+    if (cursorPos === 0)
+      return { text, cursorPos };
+    const before = text.slice(0, cursorPos - 1);
+    const after = text.slice(cursorPos);
+    return { text: before + after, cursorPos: cursorPos - 1 };
+  }
+  if (key.name === "delete") {
+    if (cursorPos >= text.length)
+      return { text, cursorPos };
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos + 1);
+    return { text: before + after, cursorPos };
+  }
+  if (key.name === "left") {
+    if (cursorPos === 0)
+      return { text, cursorPos };
+    return { text, cursorPos: cursorPos - 1 };
+  }
+  if (key.name === "right") {
+    if (cursorPos >= text.length)
+      return { text, cursorPos };
+    return { text, cursorPos: cursorPos + 1 };
+  }
+  if (key.name === "home") {
+    return { text, cursorPos: 0 };
+  }
+  if (key.name === "end") {
+    return { text, cursorPos: text.length };
+  }
+  if (key.char.length === 1 && !key.ctrl && !key.meta) {
+    const before = text.slice(0, cursorPos);
+    const after = text.slice(cursorPos);
+    return { text: before + key.char + after, cursorPos: cursorPos + 1 };
+  }
+  return null;
+}
+
+// src/core/utils.ts
+function calculateScrollOffset(cursor, scrollOffset, totalItems, maxVisible) {
+  const visibleCount = Math.min(totalItems, maxVisible);
+  if (cursor < scrollOffset) {
+    return cursor;
+  }
+  if (cursor >= scrollOffset + visibleCount) {
+    return cursor - visibleCount + 1;
+  }
+  return scrollOffset;
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (typeof choice === "string") {
+      return { label: choice, value: choice };
+    }
+    return choice;
+  });
+}
+
+// src/prompts/filter.ts
+var DEFAULT_MAX_VISIBLE = 10;
+var PREFIX_SYMBOL2 = "?";
+var LIST_CURSOR_INDICATOR = ">";
+var SCROLL_UP_INDICATOR = "...";
+var SCROLL_DOWN_INDICATOR = "...";
+function refilter(state, maxVisible) {
+  const results = fuzzyFilter(state.query, state.choices);
+  const listCursor = 0;
+  const scrollOffset = calculateScrollOffset(listCursor, 0, results.length, maxVisible);
+  return { ...state, results, listCursor, scrollOffset };
+}
+function createHandleKey(maxVisible) {
+  return (key, state) => {
+    if (key.name === "return") {
+      const result = state.results[state.listCursor];
+      if (result) {
+        return submit(result.item.value);
+      }
+      return state;
+    }
+    if (key.name === "up") {
+      if (state.results.length === 0)
+        return state;
+      const totalItems = state.results.length;
+      const newCursor = state.listCursor <= 0 ? totalItems - 1 : state.listCursor - 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return {
+        ...state,
+        listCursor: newCursor,
+        scrollOffset: newScrollOffset
+      };
+    }
+    if (key.name === "down") {
+      if (state.results.length === 0)
+        return state;
+      const totalItems = state.results.length;
+      const newCursor = state.listCursor >= totalItems - 1 ? 0 : state.listCursor + 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return {
+        ...state,
+        listCursor: newCursor,
+        scrollOffset: newScrollOffset
+      };
+    }
+    const edit = handleTextEdit(key, state.query, state.cursorPos);
+    if (edit) {
+      const queryChanged = edit.text !== state.query;
+      const newState = {
+        ...state,
+        query: edit.text,
+        cursorPos: edit.cursorPos
+      };
+      return queryChanged ? refilter(newState, maxVisible) : newState;
+    }
+    return state;
+  };
+}
+function highlightMatches(label, indices, theme) {
+  if (indices.length === 0)
+    return label;
+  const indexSet = new Set(indices);
+  let result = "";
+  let i = 0;
+  while (i < label.length) {
+    if (indexSet.has(i)) {
+      let matchedChars = "";
+      while (i < label.length && indexSet.has(i)) {
+        matchedChars += label[i];
+        i++;
+      }
+      result += theme.filterMatch(matchedChars);
+    } else {
+      result += label[i];
+      i++;
+    }
+  }
+  return result;
+}
+function renderFilter(state, theme, message, placeholder, maxVisible) {
+  const prefix = theme.prefix(PREFIX_SYMBOL2);
+  const msg = theme.message(message);
+  let queryLine;
+  if (state.query === "") {
+    if (placeholder) {
+      queryLine = theme.placeholder(placeholder);
+    } else {
+      queryLine = theme.cursor(CURSOR_CHAR);
+    }
+  } else {
+    const before = state.query.slice(0, state.cursorPos);
+    const after = state.query.slice(state.cursorPos);
+    queryLine = `${before}${theme.cursor(CURSOR_CHAR)}${after}`;
+  }
+  const lines = [`${prefix} ${msg}`, queryLine];
+  const totalResults = state.results.length;
+  if (totalResults === 0 && state.query.length > 0) {
+    lines.push(theme.hint("No matches"));
+    return lines.join(`
+`);
+  }
+  const visibleCount = Math.min(totalResults, maxVisible);
+  const hasScrollUp = state.scrollOffset > 0;
+  if (hasScrollUp) {
+    lines.push(theme.hint(SCROLL_UP_INDICATOR));
+  }
+  for (let i = 0;i < visibleCount; i++) {
+    const resultIndex = state.scrollOffset + i;
+    const result = state.results[resultIndex];
+    if (!result)
+      break;
+    const isActive = resultIndex === state.listCursor;
+    const label = highlightMatches(result.item.label, result.indices, theme);
+    if (isActive) {
+      lines.push(`${theme.cursor(LIST_CURSOR_INDICATOR)} ${theme.selected(label)}`);
+    } else {
+      lines.push(`  ${theme.unselected(label)}`);
+    }
+  }
+  const hasScrollDown = state.scrollOffset + visibleCount < totalResults;
+  if (hasScrollDown) {
+    lines.push(theme.hint(SCROLL_DOWN_INDICATOR));
+  }
+  return lines.join(`
+`);
+}
+function renderSubmitted2(_state, _value, theme, message, results, listCursor) {
+  const prefix = theme.prefix(PREFIX_SYMBOL2);
+  const msg = theme.message(message);
+  const selected = results[listCursor];
+  const label = selected ? selected.item.label : "";
+  return `${prefix} ${msg} ${theme.success(label)}`;
+}
+async function filter(options) {
+  if (options.initial !== undefined) {
+    return options.initial;
+  }
+  const theme = resolveTheme(options.theme);
+  const maxVisible = options.maxVisible ?? DEFAULT_MAX_VISIBLE;
+  const choices = normalizeChoices(options.choices);
+  const initialResults = fuzzyFilter("", choices);
+  const initialState = {
+    query: "",
+    cursorPos: 0,
+    choices,
+    results: initialResults,
+    listCursor: 0,
+    scrollOffset: 0
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderFilter(state, t, options.message, options.placeholder, maxVisible),
+    handleKey: createHandleKey(maxVisible),
+    renderSubmitted: (state, value, t) => renderSubmitted2(state, value, t, options.message, state.results, state.listCursor)
+  });
+}
+// src/prompts/input.ts
+function createHandleKey2(validate, defaultValue) {
+  return async (key, state) => {
+    if (key.name === "return") {
+      const submitValue = state.value === "" && defaultValue !== undefined ? defaultValue : state.value;
+      if (validate) {
+        const result = await validate(submitValue);
+        if (result !== true) {
+          return { ...state, error: result };
+        }
+      }
+      return submit(submitValue);
+    }
+    const edit = handleTextEdit(key, state.value, state.cursorPos);
+    if (edit) {
+      return { value: edit.text, cursorPos: edit.cursorPos, error: null };
+    }
+    return state;
+  };
+}
+var PREFIX_SYMBOL3 = "?";
+function renderInput(state, theme, message, placeholder, defaultValue) {
+  const prefix = theme.prefix(PREFIX_SYMBOL3);
+  const msg = theme.message(message);
+  const defaultHint = defaultValue !== undefined && state.value === "" ? ` ${theme.hint(`(${defaultValue})`)}` : "";
+  let valueLine;
+  if (state.value === "") {
+    if (placeholder) {
+      valueLine = theme.placeholder(placeholder);
+    } else {
+      valueLine = theme.cursor(CURSOR_CHAR);
+    }
+  } else {
+    const before = state.value.slice(0, state.cursorPos);
+    const after = state.value.slice(state.cursorPos);
+    valueLine = `${before}${theme.cursor(CURSOR_CHAR)}${after}`;
+  }
+  let output = `${prefix} ${msg}${defaultHint}
+${valueLine}`;
+  if (state.error !== null) {
+    output += `
+${theme.error(state.error)}`;
+  }
+  return output;
+}
+function renderSubmitted3(_state, value, theme, message) {
+  const prefix = theme.prefix(PREFIX_SYMBOL3);
+  const msg = theme.message(message);
+  return `${prefix} ${msg} ${theme.success(value)}`;
+}
+async function input(options) {
+  if (options.initial !== undefined) {
+    return options.initial;
+  }
+  const theme = resolveTheme(options.theme);
+  const initialState = {
+    value: "",
+    cursorPos: 0,
+    error: null
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderInput(state, t, options.message, options.placeholder, options.default),
+    handleKey: createHandleKey2(options.validate, options.default),
+    renderSubmitted: (state, value, t) => renderSubmitted3(state, value, t, options.message)
+  });
+}
+// src/prompts/multiselect.ts
+var DEFAULT_MAX_VISIBLE2 = 10;
+var PREFIX_SYMBOL4 = "?";
+var CURSOR_INDICATOR = ">";
+var CHECKBOX_CHECKED = "[x]";
+var CHECKBOX_UNCHECKED = "[ ]";
+var SCROLL_UP_INDICATOR2 = "...";
+var SCROLL_DOWN_INDICATOR2 = "...";
+var HINT_LINE = "(Space to toggle, a to toggle all, i to invert, Enter to confirm)";
+function validateSelection(selectedCount, required, min, max) {
+  if (required && selectedCount === 0) {
+    return "At least one item must be selected";
+  }
+  if (min !== undefined && selectedCount < min) {
+    return `Select at least ${min} item${min === 1 ? "" : "s"}`;
+  }
+  if (max !== undefined && selectedCount > max) {
+    return `Select at most ${max} item${max === 1 ? "" : "s"}`;
+  }
+  return null;
+}
+function createHandleKey3(maxVisible, required, min, max) {
+  return (key, state) => {
+    const totalItems = state.choices.length;
+    if (key.name === "return") {
+      const error = validateSelection(state.selected.size, required, min, max);
+      if (error) {
+        return { ...state, error };
+      }
+      const selectedValues = state.choices.filter((_, i) => state.selected.has(i)).map((c) => c.value);
+      return submit(selectedValues);
+    }
+    if (key.name === "space") {
+      const newSelected = new Set(state.selected);
+      if (newSelected.has(state.cursor)) {
+        newSelected.delete(state.cursor);
+      } else {
+        if (max === undefined || newSelected.size < max) {
+          newSelected.add(state.cursor);
+        }
+      }
+      return { ...state, selected: newSelected, error: null };
+    }
+    if (key.name === "a" && !key.ctrl && !key.meta) {
+      const allSelected = state.selected.size === totalItems;
+      let newSelected;
+      if (allSelected) {
+        newSelected = new Set;
+      } else {
+        newSelected = new Set;
+        for (let i = 0;i < totalItems; i++) {
+          if (max !== undefined && newSelected.size >= max)
+            break;
+          newSelected.add(i);
+        }
+      }
+      return { ...state, selected: newSelected, error: null };
+    }
+    if (key.name === "i" && !key.ctrl && !key.meta) {
+      const newSelected = new Set;
+      for (let i = 0;i < totalItems; i++) {
+        if (!state.selected.has(i)) {
+          if (max !== undefined && newSelected.size >= max)
+            break;
+          newSelected.add(i);
+        }
+      }
+      return { ...state, selected: newSelected, error: null };
+    }
+    if (key.name === "up" || key.name === "k") {
+      const newCursor = state.cursor <= 0 ? totalItems - 1 : state.cursor - 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return {
+        ...state,
+        cursor: newCursor,
+        scrollOffset: newScrollOffset,
+        error: null
+      };
+    }
+    if (key.name === "down" || key.name === "j") {
+      const newCursor = state.cursor >= totalItems - 1 ? 0 : state.cursor + 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return {
+        ...state,
+        cursor: newCursor,
+        scrollOffset: newScrollOffset,
+        error: null
+      };
+    }
+    return state;
+  };
+}
+function renderMultiselect(state, theme, message, maxVisible) {
+  const prefix = theme.prefix(PREFIX_SYMBOL4);
+  const msg = theme.message(message);
+  const totalItems = state.choices.length;
+  const visibleCount = Math.min(totalItems, maxVisible);
+  const lines = [`${prefix} ${msg}`];
+  lines.push(theme.hint(HINT_LINE));
+  const hasScrollUp = state.scrollOffset > 0;
+  if (hasScrollUp) {
+    lines.push(theme.hint(SCROLL_UP_INDICATOR2));
+  }
+  for (let i = 0;i < visibleCount; i++) {
+    const choiceIndex = state.scrollOffset + i;
+    const choice = state.choices[choiceIndex];
+    if (!choice)
+      break;
+    const isActive = choiceIndex === state.cursor;
+    const isChecked = state.selected.has(choiceIndex);
+    const checkbox = isChecked ? theme.success(CHECKBOX_CHECKED) : CHECKBOX_UNCHECKED;
+    const hintText = choice.hint ? ` ${theme.hint(choice.hint)}` : "";
+    if (isActive) {
+      lines.push(`${theme.cursor(CURSOR_INDICATOR)} ${checkbox} ${theme.selected(choice.label)}${hintText}`);
+    } else {
+      lines.push(`  ${checkbox} ${theme.unselected(choice.label)}${hintText}`);
+    }
+  }
+  const hasScrollDown = state.scrollOffset + visibleCount < totalItems;
+  if (hasScrollDown) {
+    lines.push(theme.hint(SCROLL_DOWN_INDICATOR2));
+  }
+  if (state.error) {
+    lines.push(theme.error(state.error));
+  }
+  return lines.join(`
+`);
+}
+function renderSubmitted4(_state, _value, theme, message, choices, selected) {
+  const prefix = theme.prefix(PREFIX_SYMBOL4);
+  const msg = theme.message(message);
+  const selectedLabels = choices.filter((_, i) => selected.has(i)).map((c) => c.label).join(", ");
+  return `${prefix} ${msg} ${theme.success(selectedLabels)}`;
+}
+async function multiselect(options) {
+  if (options.initial !== undefined) {
+    return [...options.initial];
+  }
+  const theme = resolveTheme(options.theme);
+  const maxVisible = options.maxVisible ?? DEFAULT_MAX_VISIBLE2;
+  const choices = normalizeChoices(options.choices);
+  const initialSelected = new Set;
+  if (options.default) {
+    for (const defaultValue of options.default) {
+      const idx = choices.findIndex((c) => c.value === defaultValue);
+      if (idx !== -1) {
+        initialSelected.add(idx);
+      }
+    }
+  }
+  const initialState = {
+    cursor: 0,
+    choices,
+    selected: initialSelected,
+    scrollOffset: 0,
+    error: null
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderMultiselect(state, t, options.message, maxVisible),
+    handleKey: createHandleKey3(maxVisible, options.required, options.min, options.max),
+    renderSubmitted: (state, value, t) => renderSubmitted4(state, value, t, options.message, choices, state.selected)
+  });
+}
+// src/prompts/password.ts
+function createHandleKey4(validate) {
+  return async (key, state) => {
+    if (key.name === "return") {
+      if (validate) {
+        const result = await validate(state.value);
+        if (result !== true) {
+          return { ...state, error: result };
+        }
+      }
+      return submit(state.value);
+    }
+    const edit = handleTextEdit(key, state.value, state.cursorPos);
+    if (edit) {
+      return { value: edit.text, cursorPos: edit.cursorPos, error: null };
+    }
+    return state;
+  };
+}
+var PREFIX_SYMBOL5 = "?";
+var SUBMITTED_MASK_LENGTH = 4;
+function renderPassword(state, theme, message, mask) {
+  const prefix = theme.prefix(PREFIX_SYMBOL5);
+  const msg = theme.message(message);
+  let valueLine;
+  if (state.value === "") {
+    valueLine = theme.cursor(CURSOR_CHAR);
+  } else {
+    const beforeMask = mask.repeat(state.cursorPos);
+    const afterMask = mask.repeat(state.value.length - state.cursorPos);
+    valueLine = `${beforeMask}${theme.cursor(CURSOR_CHAR)}${afterMask}`;
+  }
+  let output = `${prefix} ${msg}
+${valueLine}`;
+  if (state.error !== null) {
+    output += `
+${theme.error(state.error)}`;
+  }
+  return output;
+}
+function renderSubmitted5(_state, _value, theme, message, mask) {
+  const prefix = theme.prefix(PREFIX_SYMBOL5);
+  const msg = theme.message(message);
+  const maskedDisplay = theme.success(mask.repeat(SUBMITTED_MASK_LENGTH));
+  return `${prefix} ${msg} ${maskedDisplay}`;
+}
+async function password(options) {
+  if (options.initial !== undefined) {
+    return options.initial;
+  }
+  const theme = resolveTheme(options.theme);
+  const mask = options.mask ?? "*";
+  const initialState = {
+    value: "",
+    cursorPos: 0,
+    error: null
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderPassword(state, t, options.message, mask),
+    handleKey: createHandleKey4(options.validate),
+    renderSubmitted: (state, value, t) => renderSubmitted5(state, value, t, options.message, mask)
+  });
+}
+// src/prompts/select.ts
+var DEFAULT_MAX_VISIBLE3 = 10;
+var PREFIX_SYMBOL6 = "?";
+var CURSOR_INDICATOR2 = ">";
+var SCROLL_UP_INDICATOR3 = "...";
+var SCROLL_DOWN_INDICATOR3 = "...";
+function createHandleKey5(maxVisible) {
+  return (key, state) => {
+    const totalItems = state.choices.length;
+    if (key.name === "return") {
+      const selected = state.choices[state.cursor];
+      if (selected) {
+        return submit(selected.value);
+      }
+      return state;
+    }
+    if (key.name === "up" || key.name === "k") {
+      const newCursor = state.cursor <= 0 ? totalItems - 1 : state.cursor - 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return { ...state, cursor: newCursor, scrollOffset: newScrollOffset };
+    }
+    if (key.name === "down" || key.name === "j") {
+      const newCursor = state.cursor >= totalItems - 1 ? 0 : state.cursor + 1;
+      const newScrollOffset = calculateScrollOffset(newCursor, state.scrollOffset, totalItems, maxVisible);
+      return { ...state, cursor: newCursor, scrollOffset: newScrollOffset };
+    }
+    return state;
+  };
+}
+function renderSelect(state, theme, message, maxVisible) {
+  const prefix = theme.prefix(PREFIX_SYMBOL6);
+  const msg = theme.message(message);
+  const totalItems = state.choices.length;
+  const visibleCount = Math.min(totalItems, maxVisible);
+  const lines = [`${prefix} ${msg}`];
+  const hasScrollUp = state.scrollOffset > 0;
+  if (hasScrollUp) {
+    lines.push(theme.hint(SCROLL_UP_INDICATOR3));
+  }
+  for (let i = 0;i < visibleCount; i++) {
+    const choiceIndex = state.scrollOffset + i;
+    const choice = state.choices[choiceIndex];
+    if (!choice)
+      break;
+    const isActive = choiceIndex === state.cursor;
+    const hintText = choice.hint ? ` ${theme.hint(choice.hint)}` : "";
+    if (isActive) {
+      lines.push(`${theme.cursor(CURSOR_INDICATOR2)} ${theme.selected(choice.label)}${hintText}`);
+    } else {
+      lines.push(`  ${theme.unselected(choice.label)}${hintText}`);
+    }
+  }
+  const hasScrollDown = state.scrollOffset + visibleCount < totalItems;
+  if (hasScrollDown) {
+    lines.push(theme.hint(SCROLL_DOWN_INDICATOR3));
+  }
+  return lines.join(`
+`);
+}
+function renderSubmitted6(_state, _value, theme, message, choices, cursor) {
+  const prefix = theme.prefix(PREFIX_SYMBOL6);
+  const msg = theme.message(message);
+  const selected = choices[cursor];
+  const label = selected ? selected.label : "";
+  return `${prefix} ${msg} ${theme.success(label)}`;
+}
+async function select(options) {
+  if (options.initial !== undefined) {
+    return options.initial;
+  }
+  const theme = resolveTheme(options.theme);
+  const maxVisible = options.maxVisible ?? DEFAULT_MAX_VISIBLE3;
+  const choices = normalizeChoices(options.choices);
+  let initialCursor = 0;
+  if (options.default !== undefined) {
+    const idx = choices.findIndex((c) => c.value === options.default);
+    if (idx !== -1) {
+      initialCursor = idx;
+    }
+  }
+  const initialScrollOffset = calculateScrollOffset(initialCursor, 0, choices.length, maxVisible);
+  const initialState = {
+    cursor: initialCursor,
+    choices,
+    scrollOffset: initialScrollOffset
+  };
+  return runPrompt({
+    initialState,
+    theme,
+    render: (state, t) => renderSelect(state, t, options.message, maxVisible),
+    handleKey: createHandleKey5(maxVisible),
+    renderSubmitted: (state, value, t) => renderSubmitted6(state, value, t, options.message, choices, state.cursor)
+  });
+}
+// src/prompts/spinner.ts
+var ESC2 = "\x1B[";
+var HIDE_CURSOR2 = `${ESC2}?25l`;
+var SHOW_CURSOR2 = `${ESC2}?25h`;
+var ERASE_LINE2 = `${ESC2}2K`;
+var CURSOR_TO_START = "\r";
+var BUILTIN_SPINNERS = {
+  dots: {
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+    interval: 80
+  },
+  line: {
+    frames: ["-", "\\", "|", "/"],
+    interval: 130
+  },
+  arc: {
+    frames: ["\u25D0", "\u25D3", "\u25D1", "\u25D2"],
+    interval: 100
+  },
+  bounce: {
+    frames: ["\u2801", "\u2802", "\u2804", "\u2840", "\u2880", "\u2820", "\u2810", "\u2808"],
+    interval: 120
+  }
+};
+function resolveSpinner(spinnerType) {
+  if (spinnerType === undefined) {
+    return BUILTIN_SPINNERS.dots;
+  }
+  if (typeof spinnerType === "string") {
+    return BUILTIN_SPINNERS[spinnerType];
+  }
+  return spinnerType;
+}
+var SUCCESS_SYMBOL = "\u2714";
+var ERROR_SYMBOL = "\u2716";
+function renderFrame(frame, message, theme) {
+  return `${ERASE_LINE2}${CURSOR_TO_START}${theme.spinner(frame)} ${theme.message(message)}`;
+}
+function renderSuccess(message, theme) {
+  return `${ERASE_LINE2}${CURSOR_TO_START}${theme.success(SUCCESS_SYMBOL)} ${theme.message(message)}
+`;
+}
+function renderError(message, theme) {
+  return `${ERASE_LINE2}${CURSOR_TO_START}${theme.error(ERROR_SYMBOL)} ${theme.message(message)}
+`;
+}
+async function spinner(options) {
+  const theme = resolveTheme(options.theme);
+  const { frames, interval } = resolveSpinner(options.spinner);
+  let frameIndex = 0;
+  let timerId;
+  process.stderr.write(HIDE_CURSOR2);
+  process.stderr.write(renderFrame(frames[0], options.message, theme));
+  timerId = setInterval(() => {
+    frameIndex = (frameIndex + 1) % frames.length;
+    process.stderr.write(renderFrame(frames[frameIndex], options.message, theme));
+  }, interval);
+  try {
+    const result = await options.task();
+    clearInterval(timerId);
+    timerId = undefined;
+    process.stderr.write(renderSuccess(options.message, theme));
+    process.stderr.write(SHOW_CURSOR2);
+    return result;
+  } catch (error) {
+    if (timerId !== undefined) {
+      clearInterval(timerId);
+      timerId = undefined;
+    }
+    process.stderr.write(renderError(options.message, theme));
+    process.stderr.write(SHOW_CURSOR2);
+    throw error;
+  }
+}
+export {
+  submit,
+  spinner,
+  setTheme,
+  select,
+  runPrompt,
+  password,
+  normalizeChoices,
+  multiselect,
+  input,
+  handleTextEdit,
+  getTheme,
+  fuzzyMatch,
+  fuzzyFilter,
+  filter,
+  defaultTheme,
+  createTheme,
+  confirm,
+  calculateScrollOffset,
+  assertTTY,
+  NonInteractiveError,
+  CancelledError,
+  CURSOR_CHAR
+};