arcie 0.1.4 → 0.1.6

package/dist/chunk-HWD2Z2CH.js

@@ -0,0 +1,742 @@
+// src/cli/tui/renderer/live-region.ts
+var ESC = "\x1B[";
+var ERASE_DOWN = `${ESC}J`;
+var CURSOR_TO_COL_1 = `${ESC}G`;
+var HIDE_CURSOR = `${ESC}?25l`;
+var SHOW_CURSOR = `${ESC}?25h`;
+function cursorUp(rows) {
+  return rows > 0 ? `${ESC}${rows}A` : "";
+}
+function cursorToColumn(col) {
+  return `${ESC}${Math.max(1, col)}G`;
+}
+var LiveRegion = class {
+  #output;
+  #resizeListener;
+  #lastFrame = [];
+  #caret = { row: 0, col: 1 };
+  #stopped = false;
+  constructor(options = {}) {
+    this.#output = options.output ?? process.stdout;
+    this.#resizeListener = () => {
+      if (this.#stopped) return;
+      options.onResize?.({
+        columns: this.#output.columns ?? 80,
+        rows: this.#output.rows ?? 24
+      });
+      const previous = this.#lastFrame;
+      this.#lastFrame = [];
+      this.paint(previous, this.#caret);
+    };
+    this.#output.on("resize", this.#resizeListener);
+  }
+  get columns() {
+    return this.#output.columns ?? 80;
+  }
+  get rows() {
+    return this.#output.rows ?? 24;
+  }
+  /**
+   * Redraws the live region to match `rows`. The cursor is positioned at
+   * `caret` (1-indexed row within the region, 1-indexed column). Passing an
+   * empty array clears the region without leaving trailing blank lines.
+   */
+  paint(rows, caret = { row: 1, col: 1 }) {
+    if (this.#stopped) return;
+    const output = this.#output;
+    const previousHeight = this.#lastFrame.length;
+    let chunk = HIDE_CURSOR;
+    if (previousHeight > 0) {
+      chunk += cursorUp(previousHeight - 1) + CURSOR_TO_COL_1 + ERASE_DOWN;
+    } else {
+      chunk += CURSOR_TO_COL_1 + ERASE_DOWN;
+    }
+    chunk += rows.join("\n");
+    const rowsBelowCaret = Math.max(0, rows.length - Math.max(1, caret.row));
+    if (rowsBelowCaret > 0) chunk += cursorUp(rowsBelowCaret);
+    chunk += cursorToColumn(caret.col);
+    chunk += SHOW_CURSOR;
+    output.write(chunk);
+    this.#lastFrame = [...rows];
+    this.#caret = caret;
+  }
+  /**
+   * Commits `rows` to scrollback above the live region, then repaints the
+   * region beneath them. Rows are terminated by newlines so the terminal
+   * scrolls each into history.
+   */
+  commit(rows) {
+    if (this.#stopped) return;
+    if (rows.length === 0) return;
+    const output = this.#output;
+    const previousHeight = this.#lastFrame.length;
+    let chunk = HIDE_CURSOR;
+    if (previousHeight > 0) {
+      chunk += cursorUp(previousHeight - 1) + CURSOR_TO_COL_1 + ERASE_DOWN;
+    } else {
+      chunk += CURSOR_TO_COL_1;
+    }
+    for (const row of rows) chunk += `${row}
+`;
+    output.write(chunk);
+    const preserved = this.#lastFrame;
+    const caret = this.#caret;
+    this.#lastFrame = [];
+    if (preserved.length > 0) {
+      this.paint(preserved, caret);
+    } else {
+      output.write(SHOW_CURSOR);
+    }
+  }
+  /**
+   * Clears the live region and shows the cursor at the start of what used to
+   * be the region's first row. Idempotent; safe to call from cleanup paths.
+   */
+  stop() {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    this.#output.off("resize", this.#resizeListener);
+    if (this.#lastFrame.length > 0) {
+      const chunk = cursorUp(this.#lastFrame.length - 1) + CURSOR_TO_COL_1 + ERASE_DOWN + SHOW_CURSOR;
+      this.#output.write(chunk);
+    } else {
+      this.#output.write(SHOW_CURSOR);
+    }
+    this.#lastFrame = [];
+  }
+};
+
+// src/cli/tui/attach-keys.ts
+import { stdin as input } from "process";
+
+// src/cli/tui/key-parser.ts
+var CSI_FINAL = /[@-~]/u;
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+function sanitizePastedText(text) {
+  let printable = "";
+  for (const character of text.replace(/\r\n?/gu, "\n")) {
+    if (character === "\n" || character === "	") {
+      printable += character;
+      continue;
+    }
+    const code = character.codePointAt(0);
+    if (code === void 0) continue;
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) continue;
+    printable += character;
+  }
+  return printable;
+}
+function isIncompletePaste(buffer) {
+  return buffer.startsWith(PASTE_START) && !buffer.includes(PASTE_END, PASTE_START.length);
+}
+function stripPromptControlCharacters(text) {
+  let printable = "";
+  for (const character of text) {
+    if (character >= " " && character !== "\x7F") printable += character;
+  }
+  return printable;
+}
+function nextKey(buffer) {
+  const first = buffer[0];
+  if (first === void 0) return { consumed: 0, incomplete: true };
+  if (first === "\x1B") {
+    if (buffer.length === 1) return { consumed: 0, incomplete: true };
+    const second = buffer[1];
+    if (second === "O") {
+      if (buffer.length < 3) return { consumed: 0, incomplete: true };
+      return { key: parseKey(Buffer.from(buffer.slice(0, 3))), consumed: 3 };
+    }
+    if (second === "[") {
+      if (buffer.startsWith(PASTE_START)) {
+        const end2 = buffer.indexOf(PASTE_END, PASTE_START.length);
+        if (end2 === -1) return { consumed: 0, incomplete: true };
+        return {
+          key: {
+            type: "text",
+            value: sanitizePastedText(buffer.slice(PASTE_START.length, end2)),
+            framing: "bracketed-paste"
+          },
+          consumed: end2 + PASTE_END.length
+        };
+      }
+      for (let i = 2; i < buffer.length; i += 1) {
+        if (CSI_FINAL.test(buffer[i])) {
+          return { key: parseKey(Buffer.from(buffer.slice(0, i + 1))), consumed: i + 1 };
+        }
+      }
+      return { consumed: 0, incomplete: true };
+    }
+    return { key: { type: "escape" }, consumed: 1 };
+  }
+  if (first < " " || first === "\x7F") {
+    return { key: parseKey(Buffer.from(first)), consumed: 1 };
+  }
+  let end = 1;
+  while (end < buffer.length) {
+    const char = buffer[end];
+    if (char === "\x1B" || char < " " || char === "\x7F") break;
+    end += 1;
+  }
+  return { key: parseKey(Buffer.from(buffer.slice(0, end))), consumed: end };
+}
+function parseKey(chunk) {
+  const value = chunk.toString("utf8");
+  switch (value) {
+    case "
":
+      return { type: "ctrl-a" };
+    case "":
+      return { type: "ctrl-e" };
+    case "":
+      return { type: "ctrl-d" };
+    case "\v":
+      return { type: "ctrl-k" };
+    case "":
+      return { type: "ctrl-n" };
+    case "":
+      return { type: "ctrl-p" };
+    case "\f":
+      return { type: "ctrl-l" };
+    case "":
+      return { type: "ctrl-r" };
+    case "":
+      return { type: "ctrl-u" };
+    case "":
+      return { type: "ctrl-w" };
+    case "":
+      return { type: "ctrl-c" };
+    case "\r":
+    case "\n":
+      return { type: "enter" };
+    case "\x1B[27;2;13~":
+    case "\x1B[13;2u":
+      return { type: "newline" };
+    case "\x7F":
+    case "\b":
+      return { type: "backspace" };
+    case "\x1B[A":
+    case "\x1BOA":
+      return { type: "up" };
+    case "\x1B[B":
+    case "\x1BOB":
+      return { type: "down" };
+    case "\x1B[C":
+    case "\x1BOC":
+      return { type: "right" };
+    case "\x1B[D":
+    case "\x1BOD":
+      return { type: "left" };
+    case "\x1B[H":
+    case "\x1BOH":
+    case "\x1B[1~":
+      return { type: "home" };
+    case "\x1B[F":
+    case "\x1BOF":
+    case "\x1B[4~":
+      return { type: "end" };
+    case "\x1B[3~":
+      return { type: "delete" };
+    case "	":
+      return { type: "tab" };
+    case "\x1B":
+      return { type: "escape" };
+    default: {
+      const printable = stripPromptControlCharacters(value);
+      return printable.length > 0 ? { type: "text", value: printable, framing: "unframed" } : { type: "ignore" };
+    }
+  }
+}
+
+// src/cli/tui/attach-keys.ts
+function attachKeyStream(onKey) {
+  let buffer = "";
+  const originalRawMode = input.isRaw;
+  const onData = (chunk) => {
+    buffer += chunk.toString("utf8");
+    if (isIncompletePaste(buffer)) return;
+    while (buffer.length > 0) {
+      const token = nextKey(buffer);
+      if (token.incomplete === true) break;
+      buffer = buffer.slice(token.consumed);
+      if (token.key !== void 0 && token.key.type !== "ignore") onKey(token.key);
+    }
+  };
+  try {
+    input.setRawMode?.(true);
+  } catch {
+  }
+  input.resume();
+  input.on("data", onData);
+  return () => {
+    input.off("data", onData);
+    try {
+      input.setRawMode?.(originalRawMode ?? false);
+    } catch {
+    }
+    input.pause();
+  };
+}
+
+// src/cli/tui/theme.ts
+var ESC2 = "\x1B[";
+function ansi(open, close, enabled) {
+  if (!enabled) return (text) => text;
+  const prefix = `${ESC2}${open}m`;
+  const suffix = `${ESC2}${close}m`;
+  return (text) => `${prefix}${text}${suffix}`;
+}
+function ansi256(code, enabled) {
+  if (!enabled) return (text) => text;
+  const prefix = `${ESC2}38;5;${code}m`;
+  const suffix = `${ESC2}39m`;
+  return (text) => `${prefix}${text}${suffix}`;
+}
+var UNICODE_GLYPHS = {
+  brand: "\u26A1",
+  user: "\u258C",
+  reasoning: "\u25CB",
+  success: "\u2713",
+  error: "\u2A2F",
+  warning: "\u26A0",
+  subagent: "\u25C6",
+  rule: "\u2502",
+  question: "?",
+  connection: "\u25CF",
+  arrow: "\u2192",
+  pointer: "\u25B7",
+  selectedPointer: "\u25B6",
+  option: "\u25E6",
+  prompt: "\u276F",
+  elbow: "\u23BF",
+  hrule: "\u2594",
+  caret: "\u258F",
+  dot: "\xB7",
+  ellipsis: "\u2026",
+  arrowUp: "\u2191",
+  arrowDown: "\u2193"
+};
+var ASCII_GLYPHS = {
+  brand: "*",
+  user: "|",
+  reasoning: "o",
+  success: "+",
+  error: "x",
+  warning: "!",
+  subagent: "*",
+  rule: "|",
+  question: "?",
+  connection: "*",
+  arrow: "->",
+  pointer: ">",
+  selectedPointer: ">",
+  option: ".",
+  prompt: ">",
+  elbow: "`-",
+  hrule: "=",
+  caret: "_",
+  dot: "-",
+  ellipsis: "...",
+  arrowUp: "^",
+  arrowDown: "v"
+};
+var UNICODE_SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var ASCII_SPINNER = ["-", "\\", "|", "/"];
+function createTheme(options = {}) {
+  const color = options.color ?? true;
+  const unicode = options.unicode ?? true;
+  return {
+    color,
+    unicode,
+    colors: {
+      reset: ansi(0, 0, color),
+      bold: ansi(1, 22, color),
+      dim: ansi(2, 22, color),
+      inverse: ansi(7, 27, color),
+      italic: ansi(3, 23, color),
+      white: ansi(97, 39, color),
+      gray: ansi(90, 39, color),
+      cyan: ansi(36, 39, color),
+      green: ansi(32, 39, color),
+      red: ansi(31, 39, color),
+      yellow: ansi(33, 39, color),
+      magenta: ansi(35, 39, color),
+      blue: ansi(34, 39, color),
+      orange: ansi256(208, color)
+    },
+    glyph: unicode ? UNICODE_GLYPHS : ASCII_GLYPHS,
+    spinner: unicode ? UNICODE_SPINNER : ASCII_SPINNER
+  };
+}
+function detectUnicode(env = process.env) {
+  const override = env.ARCIE_TUI_UNICODE;
+  if (override === "0" || override === "false") return false;
+  if (override === "1" || override === "true") return true;
+  if (env.TERM === "dumb") return false;
+  if (process.platform === "win32") {
+    return Boolean(env.WT_SESSION || env.TERM_PROGRAM === "vscode");
+  }
+  return true;
+}
+
+// src/cli/shared/text-boundaries.ts
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function graphemes(text) {
+  return Array.from(graphemeSegmenter.segment(text), ({ index, segment }) => ({
+    text: segment,
+    start: index,
+    end: index + segment.length
+  }));
+}
+function previousGraphemeBoundary(text, offset) {
+  const clamped = Math.max(0, Math.min(offset, text.length));
+  if (clamped === 0) return 0;
+  return graphemeSegmenter.segment(text).containing(clamped - 1)?.index ?? 0;
+}
+function nextGraphemeBoundary(text, offset) {
+  const clamped = Math.max(0, Math.min(offset, text.length));
+  if (clamped === text.length) return clamped;
+  const grapheme = graphemeSegmenter.segment(text).containing(clamped);
+  return grapheme === void 0 ? text.length : grapheme.index + grapheme.segment.length;
+}
+function graphemeBoundaryAtOrAfter(text, offset) {
+  const clamped = Math.max(0, Math.min(offset, text.length));
+  if (clamped === 0 || clamped === text.length) return clamped;
+  const grapheme = graphemeSegmenter.segment(text).containing(clamped);
+  if (grapheme === void 0 || grapheme.index === clamped) return clamped;
+  return grapheme.index + grapheme.segment.length;
+}
+
+// src/cli/ui/terminal-text.ts
+var ansiEscape = String.fromCharCode(27);
+var ansiPattern = new RegExp(`${ansiEscape}\\[[0-?]*[ -/]*[@-~]`, "g");
+var ansiPrefixPattern = new RegExp(`^${ansiEscape}\\[[0-?]*[ -/]*[@-~]`);
+var emojiPresentationPattern = /\p{Emoji_Presentation}/u;
+var extendedPictographicPattern = /\p{Extended_Pictographic}/u;
+var keycapPattern = /^[#*0-9]\u{fe0f}?\u{20e3}$/u;
+function stripTerminalControls(input2) {
+  let output = "";
+  let index = 0;
+  while (index < input2.length) {
+    const codePoint = input2.codePointAt(index);
+    if (codePoint == null) break;
+    const character = String.fromCodePoint(codePoint);
+    index += character.length;
+    if (isUnsafeTerminalControlCodePoint(codePoint)) continue;
+    output += character;
+  }
+  return output;
+}
+function visibleLength(input2) {
+  let width = 0;
+  for (const unit of terminalTextUnits(input2)) width += unit.width;
+  return width;
+}
+function sliceVisible(input2, width) {
+  if (width <= 0) return "";
+  let output = "";
+  let visible = 0;
+  const units = terminalTextUnits(input2);
+  let index = 0;
+  while (index < units.length && visible < width) {
+    const unit = units[index];
+    if (unit.width > 0 && visible + unit.width > width) break;
+    output += unit.text;
+    visible += unit.width;
+    index += 1;
+  }
+  while (units[index]?.ansi === true) {
+    output += units[index].text;
+    index += 1;
+  }
+  return output;
+}
+function inputTextWidth(input2) {
+  let width = 0;
+  for (const grapheme of graphemes(input2)) {
+    width += terminalGraphemeWidth(grapheme.text);
+  }
+  return width;
+}
+function terminalGraphemeWidth(grapheme) {
+  let width = 0;
+  for (const character of grapheme) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint !== void 0) width = Math.max(width, codePointWidth(codePoint));
+  }
+  const emojiPresentation = emojiPresentationPattern.test(grapheme) || keycapPattern.test(grapheme) || grapheme.includes("\uFE0F") && extendedPictographicPattern.test(grapheme);
+  return emojiPresentation ? Math.max(2, width) : width;
+}
+function terminalTextUnits(input2) {
+  const units = [];
+  let index = 0;
+  while (index < input2.length) {
+    const remaining = input2.slice(index);
+    const ansiMatch = remaining.match(ansiPrefixPattern);
+    if (ansiMatch !== null) {
+      units.push({ text: ansiMatch[0], width: 0, ansi: true });
+      index += ansiMatch[0].length;
+      continue;
+    }
+    const nextAnsi = remaining.search(ansiPattern);
+    const plain = remaining.slice(0, nextAnsi === -1 ? remaining.length : nextAnsi);
+    for (const grapheme of graphemes(plain)) {
+      units.push({ text: grapheme.text, width: terminalGraphemeWidth(grapheme.text), ansi: false });
+    }
+    index += plain.length;
+  }
+  return units;
+}
+function wrapVisibleLine(line, width) {
+  if (width <= 0) return [line];
+  if (line.length === 0) return [""];
+  const lines = [];
+  let remaining = line;
+  while (visibleLength(remaining) > width) {
+    const breakAt = findVisibleBreakPoint(remaining, width);
+    lines.push(remaining.slice(0, breakAt).trimEnd());
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  if (remaining.length > 0 || lines.length === 0) lines.push(remaining);
+  return lines;
+}
+function findVisibleBreakPoint(input2, width) {
+  const slice = sliceVisible(input2, width + 1);
+  const lastSpace = slice.lastIndexOf(" ");
+  if (lastSpace > 0) return lastSpace;
+  const hardSlice = sliceVisible(input2, width);
+  if (visibleLength(hardSlice) > 0) return hardSlice.length;
+  let offset = 0;
+  let foundVisibleUnit = false;
+  for (const unit of terminalTextUnits(input2)) {
+    if (foundVisibleUnit && unit.width > 0) return offset;
+    offset += unit.text.length;
+    if (unit.width > 0) foundVisibleUnit = true;
+  }
+  return offset;
+}
+function codePointWidth(codePoint) {
+  if (codePoint === 9) return 4;
+  if (codePoint < 32 || codePoint >= 127 && codePoint < 160) return 0;
+  if (isZeroWidthCodePoint(codePoint)) return 0;
+  return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function isUnsafeTerminalControlCodePoint(codePoint) {
+  return codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 1155 && codePoint <= 1161 || codePoint >= 1425 && codePoint <= 1469 || codePoint === 1471 || codePoint >= 1473 && codePoint <= 1474 || codePoint >= 1476 && codePoint <= 1477 || codePoint === 1479 || codePoint >= 1552 && codePoint <= 1562 || codePoint >= 1611 && codePoint <= 1631 || codePoint === 1648 || codePoint >= 1750 && codePoint <= 1756 || codePoint >= 1759 && codePoint <= 1764 || codePoint >= 1767 && codePoint <= 1768 || codePoint >= 1770 && codePoint <= 1773 || codePoint === 1809 || codePoint >= 1840 && codePoint <= 1866 || codePoint >= 1958 && codePoint <= 1968 || codePoint >= 2027 && codePoint <= 2035 || codePoint >= 2070 && codePoint <= 2073 || codePoint >= 2075 && codePoint <= 2083 || codePoint >= 2085 && codePoint <= 2087 || codePoint >= 2089 && codePoint <= 2093 || codePoint >= 2137 && codePoint <= 2139 || codePoint >= 2259 && codePoint <= 2306 || codePoint === 2362 || codePoint === 2364 || codePoint >= 2369 && codePoint <= 2376 || codePoint === 2381 || codePoint >= 2385 && codePoint <= 2391 || codePoint === 8205 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 917760 && codePoint <= 917999;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+
+// src/cli/tui/line-editor.ts
+var EMPTY_LINE = { text: "", cursor: 0 };
+function lineOf(text) {
+  return { text, cursor: text.length };
+}
+function maskLine(state) {
+  return {
+    text: "\u2022".repeat(graphemes(state.text).length),
+    cursor: graphemes(state.text.slice(0, state.cursor)).length
+  };
+}
+function insert(state, value) {
+  if (value.length === 0) return state;
+  const text = state.text.slice(0, state.cursor) + value + state.text.slice(state.cursor);
+  const cursor = graphemeBoundaryAtOrAfter(text, state.cursor + value.length);
+  return { text, cursor };
+}
+function backspace(state) {
+  if (state.cursor === 0) return state;
+  const cursor = previousGraphemeBoundary(state.text, state.cursor);
+  const text = state.text.slice(0, cursor) + state.text.slice(state.cursor);
+  return { text, cursor: graphemeBoundaryAtOrAfter(text, cursor) };
+}
+function deleteForward(state) {
+  if (state.cursor >= state.text.length) return state;
+  const end = nextGraphemeBoundary(state.text, state.cursor);
+  const text = state.text.slice(0, state.cursor) + state.text.slice(end);
+  return { text, cursor: graphemeBoundaryAtOrAfter(text, state.cursor) };
+}
+function moveLeft(state) {
+  return state.cursor === 0 ? state : { text: state.text, cursor: previousGraphemeBoundary(state.text, state.cursor) };
+}
+function moveRight(state) {
+  return state.cursor >= state.text.length ? state : { text: state.text, cursor: nextGraphemeBoundary(state.text, state.cursor) };
+}
+function moveHome(state) {
+  const cursor = logicalLineStart(state.text, state.cursor);
+  return state.cursor === cursor ? state : { text: state.text, cursor };
+}
+function moveEnd(state) {
+  const cursor = logicalLineEnd(state.text, state.cursor);
+  return state.cursor === cursor ? state : { text: state.text, cursor };
+}
+function killToEnd(state) {
+  const lineEnd = logicalLineEnd(state.text, state.cursor);
+  if (state.cursor >= lineEnd) return state;
+  return {
+    text: state.text.slice(0, state.cursor) + state.text.slice(lineEnd),
+    cursor: state.cursor
+  };
+}
+function killToStart(state) {
+  const lineStart = logicalLineStart(state.text, state.cursor);
+  if (state.cursor <= lineStart) return state;
+  return {
+    text: state.text.slice(0, lineStart) + state.text.slice(state.cursor),
+    cursor: lineStart
+  };
+}
+function deleteWord(state) {
+  if (state.cursor === 0) return state;
+  const lineStart = logicalLineStart(state.text, state.cursor);
+  let start = state.cursor;
+  while (start > lineStart) {
+    const previous = previousGraphemeBoundary(state.text, start);
+    if (!isWhitespace(state.text.slice(previous, start))) break;
+    start = previous;
+  }
+  while (start > lineStart) {
+    const previous = previousGraphemeBoundary(state.text, start);
+    if (isWhitespace(state.text.slice(previous, start))) break;
+    start = previous;
+  }
+  const text = state.text.slice(0, start) + state.text.slice(state.cursor);
+  return { text, cursor: graphemeBoundaryAtOrAfter(text, start) };
+}
+function logicalLineStart(text, cursor) {
+  if (cursor === 0) return 0;
+  return text.lastIndexOf("\n", cursor - 1) + 1;
+}
+function logicalLineEnd(text, cursor) {
+  const newline = text.indexOf("\n", cursor);
+  return newline === -1 ? text.length : newline;
+}
+function applyLineEditorKey(state, key, options) {
+  const multiline = options?.multiline ?? false;
+  switch (key.type) {
+    case "text":
+      return insert(state, multiline ? key.value : key.value.replaceAll("\n", " "));
+    case "newline":
+      return multiline ? insert(state, "\n") : void 0;
+    case "backspace":
+      return backspace(state);
+    case "delete":
+      return deleteForward(state);
+    case "left":
+      return moveLeft(state);
+    case "right":
+      return moveRight(state);
+    case "home":
+    case "ctrl-a":
+      return moveHome(state);
+    case "end":
+    case "ctrl-e":
+      return moveEnd(state);
+    case "ctrl-k":
+      return killToEnd(state);
+    case "ctrl-u":
+      return killToStart(state);
+    case "ctrl-w":
+      return deleteWord(state);
+    default:
+      return void 0;
+  }
+}
+function isWhitespace(text) {
+  return /^\s+$/u.test(text);
+}
+function visibleLine(state, budget, ellipsis = "\u2026") {
+  const width = Math.max(1, budget);
+  const { text, cursor } = state;
+  const segments = graphemes(text);
+  const caretIndex = segments.findIndex((segment) => segment.start === cursor);
+  const underIndex = caretIndex === -1 ? segments.length : caretIndex;
+  const under = segments[underIndex]?.text ?? "";
+  if (inputTextWidth(text) <= width) {
+    return {
+      before: text.slice(0, cursor),
+      under,
+      after: text.slice(cursor + under.length)
+    };
+  }
+  let start = underIndex;
+  let end = underIndex + (under.length > 0 ? 1 : 0);
+  const windowWidth = (candidateStart, candidateEnd) => {
+    const startOffset2 = segments[candidateStart]?.start ?? text.length;
+    const endOffset2 = segments[candidateEnd]?.start ?? text.length;
+    return inputTextWidth(text.slice(startOffset2, endOffset2)) + (candidateStart > 0 ? inputTextWidth(ellipsis) : 0) + (candidateEnd < segments.length ? inputTextWidth(ellipsis) : 0);
+  };
+  let preferBefore = true;
+  while (true) {
+    const beforeFits = start > 0 && windowWidth(start - 1, end) <= width;
+    const afterFits = end < segments.length && windowWidth(start, end + 1) <= width;
+    if (!beforeFits && !afterFits) break;
+    if (preferBefore && beforeFits || !afterFits) start -= 1;
+    else end += 1;
+    preferBefore = !preferBefore;
+  }
+  const startOffset = segments[start]?.start ?? text.length;
+  const endOffset = segments[end]?.start ?? text.length;
+  return {
+    before: `${start > 0 ? ellipsis : ""}${text.slice(startOffset, cursor)}`,
+    under,
+    after: `${text.slice(cursor + under.length, endOffset)}${end < segments.length ? ellipsis : ""}`
+  };
+}
+var PromptHistory = class {
+  #entries = [];
+  #index = 0;
+  #draft = "";
+  add(entry) {
+    const value = entry.trim();
+    if (value.length === 0) return;
+    if (this.#entries.at(-1) === entry) {
+      this.#resetCursor();
+      return;
+    }
+    this.#entries.push(entry);
+    this.#resetCursor();
+  }
+  begin(draft) {
+    this.#index = this.#entries.length;
+    this.#draft = draft;
+  }
+  previous(currentDraft) {
+    if (this.#entries.length === 0) return void 0;
+    if (this.#index === this.#entries.length) this.#draft = currentDraft;
+    if (this.#index === 0) return void 0;
+    this.#index -= 1;
+    return this.#entries[this.#index];
+  }
+  next() {
+    if (this.#index >= this.#entries.length) return void 0;
+    this.#index += 1;
+    return this.#index === this.#entries.length ? this.#draft : this.#entries[this.#index];
+  }
+  #resetCursor() {
+    this.#index = this.#entries.length;
+    this.#draft = "";
+  }
+};
+
+export {
+  LiveRegion,
+  attachKeyStream,
+  createTheme,
+  detectUnicode,
+  stripTerminalControls,
+  visibleLength,
+  sliceVisible,
+  inputTextWidth,
+  wrapVisibleLine,
+  EMPTY_LINE,
+  lineOf,
+  maskLine,
+  applyLineEditorKey,
+  visibleLine,
+  PromptHistory
+};
+//# sourceMappingURL=chunk-HWD2Z2CH.js.map