@flowtty/core 1.0.0-alpha.1

package/dist/host-DttBG-OZ.d.ts

@@ -0,0 +1,151 @@
+import { loadYoga } from 'yoga-layout/load';
+
+type Yoga = Awaited<ReturnType<typeof loadYoga>>;
+type YogaNode = ReturnType<Yoga['Node']['create']>;
+declare function getYoga(): Promise<Yoga>;
+
+type BorderStyle = 'single' | 'double' | 'round' | 'bold' | 'classic';
+/** The library-wide default for components that draw a box-border chrome
+ *  (DialogHost wrappers, Menu panels, Table grids). Declared once so the
+ *  default is a single edit, not one per component. */
+declare const DEFAULT_BORDER_STYLE: BorderStyle;
+interface GridChars {
+    h: string;
+    v: string;
+    tl: string;
+    tr: string;
+    bl: string;
+    br: string;
+    tDown: string;
+    tUp: string;
+    tRight: string;
+    tLeft: string;
+    cross: string;
+}
+declare const GRID_CHARS: Record<BorderStyle, GridChars>;
+type BorderChars = Pick<GridChars, 'h' | 'v' | 'tl' | 'tr' | 'bl' | 'br'>;
+declare const BORDER_CHARS: Record<BorderStyle, BorderChars>;
+
+interface Rect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+declare function computeLayout(container: Container, width: number, height: number): void;
+declare function layoutOf(inst: Instance, offsetX?: number, offsetY?: number): Rect;
+
+type HostType = 'flowtty-box';
+interface BoxProps {
+    /** Fixed size in cells. Strings like '100%' use Yoga's percentage sizing. */
+    width?: number | string;
+    height?: number | string;
+    flexDirection?: 'row' | 'column';
+    /** Default 'static' (Yoga's stack flow). 'absolute' positions via top/left/right/bottom relative to the nearest non-static ancestor. */
+    position?: 'static' | 'absolute';
+    top?: number;
+    left?: number;
+    right?: number;
+    bottom?: number;
+    /** Main-axis alignment of children (flexbox). */
+    justifyContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+    /** Cross-axis alignment of children. */
+    alignItems?: 'flex-start' | 'flex-end' | 'center' | 'stretch';
+    wrap?: 'wrap' | 'truncate' | 'none';
+    color?: string;
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    strikethrough?: boolean;
+    link?: string;
+    backgroundColor?: string;
+    border?: BorderStyle;
+    borderColor?: string;
+    borderTitle?: string;
+    padding?: number;
+    paddingX?: number;
+    paddingY?: number;
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    margin?: number;
+    marginX?: number;
+    marginY?: number;
+    marginTop?: number;
+    marginRight?: number;
+    marginBottom?: number;
+    marginLeft?: number;
+    gap?: number;
+    rowGap?: number;
+    columnGap?: number;
+    flexGrow?: number;
+    flexShrink?: number;
+    flexBasis?: number | 'auto' | `${number}%`;
+    flexWrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    /** Cross-axis distribution of wrap lines. Only effective when flexWrap is 'wrap' or 'wrap-reverse'
+     *  AND the parent has extra cross-axis space. Default 'flex-start'. */
+    alignContent?: 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch';
+    /** Minimum cell size — Yoga prevents the box from shrinking below this.
+     *  Accepts a number (cells) or a percent string (e.g. '50%'). Undefined = no minimum. */
+    minWidth?: number | `${number}%`;
+    maxWidth?: number | `${number}%`;
+    minHeight?: number | `${number}%`;
+    maxHeight?: number | `${number}%`;
+    /** Width / height ratio. Yoga derives the missing dimension from the constrained one.
+     *  CSS convention: `aspectRatio: 2` = twice as wide as tall; `0.5` = twice as tall as wide; `1` = square. */
+    aspectRatio?: number;
+    /** 'none' removes this box and all descendants from layout (siblings don't reserve space for it,
+     *  and paint skips the subtree). Default 'flex'. Useful for conditional UI without unmounting. */
+    display?: 'flex' | 'none';
+    /** Fires after layout with this box's computed rect. Use to read allocated dimensions
+     *  for responsive rendering (e.g. paginating an article reader). **Diff before setState** —
+     *  this fires on EVERY paint, and unconditionally calling setState with a new object
+     *  will infinite-loop. Pattern:
+     *    onLayout={(r) => { if (!size || size.width !== r.width || size.height !== r.height) setSize(r); }} */
+    onLayout?: (rect: Rect) => void;
+    /** Stacking order within the same paint pass. Higher values paint on top.
+     *  Default 0. Tree order is the tiebreaker. Does NOT cross pass boundaries:
+     *  absolutes always overlay stack-flow regardless of zIndex. */
+    zIndex?: number;
+    /** Clip descendants to this box's content rect. Default 'visible' (no clipping).
+     *  'hidden' clips ALL descendant writes including their backgrounds and borders.
+     *  Does NOT clip this box's own background or border (those are this box's own area). */
+    overflow?: 'visible' | 'hidden';
+}
+interface Instance {
+    type: 'box';
+    props: BoxProps;
+    yogaNode: YogaNode;
+    children: Array<Instance | TextInstance>;
+}
+interface TextInstance {
+    type: 'text';
+    text: string;
+    parent?: Instance;
+}
+/**
+ * Adapter-facing root container: a list of top-level Instances plus the loaded
+ * Yoga module. Each framework adapter (React reconciler, Vue, …) builds one of
+ * these and passes it to `computeLayout` + `paint`. Lives in host so layout /
+ * paint (in core) can depend on it without pulling in any adapter code.
+ */
+interface Container {
+    children: Instance[];
+    Yoga: Yoga;
+}
+declare function createInstance(type: HostType, props: BoxProps, Yoga: Yoga): Instance;
+declare function createTextInstance(text: string, _Yoga: Yoga): TextInstance;
+declare function applyProps(inst: Instance, props: BoxProps, _Yoga: Yoga): void;
+declare function measureText(text: string): {
+    width: number;
+    height: number;
+};
+declare function ownText(inst: Instance): string;
+declare function refreshMeasure(inst: Instance, _Yoga: Yoga): void;
+declare function appendChild(parent: Instance, child: Instance | TextInstance, Yoga: Yoga): void;
+declare function removeChild(parent: Instance, child: Instance | TextInstance, Yoga: Yoga): void;
+declare function insertBefore(parent: Instance, child: Instance | TextInstance, before: Instance | TextInstance, Yoga: Yoga): void;
+
+export { BORDER_CHARS as B, type Container as C, DEFAULT_BORDER_STYLE as D, GRID_CHARS as G, type HostType as H, type Instance as I, type Rect as R, type TextInstance as T, type Yoga as Y, type BorderChars as a, type BorderStyle as b, type BoxProps as c, type GridChars as d, type YogaNode as e, appendChild as f, applyProps as g, computeLayout as h, createInstance as i, createTextInstance as j, getYoga as k, insertBefore as l, layoutOf as m, measureText as n, ownText as o, removeChild as p, refreshMeasure as r };

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+export { B as Buffer, C as Cell, S as Style } from './cells-CaXEx4lH.js';
+import { K as Key } from './backend-BcB7VR87.js';
+export { B as Backend } from './backend-BcB7VR87.js';
+export { a as BorderChars, b as BorderStyle, c as BoxProps, D as DEFAULT_BORDER_STYLE, G as GRID_CHARS, d as GridChars } from './host-DttBG-OZ.js';
+import 'yoga-layout/load';
+
+type WrapMode = 'wrap' | 'truncate' | 'none';
+/**
+ * Lay out `text` into display lines fitting within `width` cells.
+ * Assumes 1 code point = 1 cell (no CJK/emoji width awareness in M1d).
+ *
+ *  - 'wrap'     — word-wrap at spaces; any single word longer than width is char-wrapped.
+ *  - 'truncate' — each source line truncated to width, with `…` in the last cell when truncated.
+ *  - 'none'     — each source line preserved unchanged (caller is responsible for overflow).
+ *
+ * Always returns at least one line (empty input → `['']`, matching measureText's height=1 default).
+ */
+declare function wrapText(text: string, width: number, mode: WrapMode): string[];
+
+/**
+ * Split a multi-line source text into visual lines for paginated rendering
+ * with an optional line-number gutter.
+ *
+ * - 'nowrap': one visual line per source line (caller is responsible for
+ *   horizontal clipping — typically via wrap='truncate' on the rendering Box).
+ * - 'wrap':   source lines longer than `width` are hard-wrapped at the cell
+ *   boundary; continuation visual-lines carry `lineNum: null` so the gutter
+ *   stays blank for them and only the first visual line shows the source line
+ *   number.
+ *
+ * Width is in cells (counted via `[...line]` for grapheme-naive codepoint
+ * iteration — matches flowtty's paint-side width assumptions).
+ *
+ * Typical use:
+ * ```ts
+ * const lines = splitVisualLines(bodyText, wrapMode, effectiveBodyWidth);
+ * const page  = lines.slice(pageIdx * pageH, (pageIdx + 1) * pageH);
+ * page.map(({ text, lineNum }) => ...);
+ * ```
+ */
+interface VisualLine {
+    text: string;
+    /** Source-file line number for the first visual line of a wrapped source line; null for continuation lines. 1-based. */
+    lineNum: number | null;
+}
+declare function splitVisualLines(text: string, mode: 'wrap' | 'nowrap', width: number): VisualLine[];
+
+/**
+ * Center a `visible`-sized window of items around `cursor`, clamped so the
+ * window never starts before 0 or extends past the end of the list. Returns
+ * the start index and the sliced items.
+ *
+ * Typical use — list views that scroll a cursor through long data:
+ * ```ts
+ * const { start, items } = windowAround(rows, cursor, termHeight - chrome);
+ * items.map((row, i) => {
+ *   const sel = (start + i) === cursor;
+ *   ...
+ * });
+ * ```
+ *
+ * The window prefers to center the cursor; near the edges it sticks to the
+ * top/bottom so the cursor remains visible without empty padding.
+ */
+declare function windowAround<T>(items: readonly T[], cursor: number, visible: number): {
+    start: number;
+    items: T[];
+};
+
+/**
+ * Display width in terminal cells of a single Unicode code point: 0 for control
+ * / combining / zero-width, 2 for East Asian Wide & Fullwidth (and most emoji),
+ * 1 otherwise. Pass a code point (e.g. from `String#codePointAt`), not a string.
+ */
+declare function charWidth(cp: number): 0 | 1 | 2;
+/**
+ * Display width in terminal cells of a string, summing `charWidth` over its
+ * code points (surrogate pairs counted once). See the file header for the
+ * grapheme-cluster caveat. Expects plain text, not ANSI-styled.
+ */
+declare function stringWidth(str: string): number;
+
+interface EditorState {
+    value: string;
+    cursor: number;
+}
+type EditorAction = {
+    kind: 'edit';
+    state: EditorState;
+} | {
+    kind: 'submit';
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'noop';
+};
+declare function reduce$2(state: EditorState, key: Key): EditorAction;
+
+interface SelectItem<T> {
+    label: string;
+    value: T;
+}
+interface SelectState {
+    cursor: number;
+    filter: string;
+}
+type SelectAction = {
+    kind: 'state';
+    state: SelectState;
+} | {
+    kind: 'submit';
+    index: number;
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'noop';
+};
+/**
+ * Indices into `items` of items whose label contains `filter` (case-insensitive
+ * substring). Empty filter → all indices.
+ */
+declare function visibleIndices<T>(items: SelectItem<T>[], filter: string): number[];
+declare function reduce$1<T>(items: SelectItem<T>[], state: SelectState, key: Key): SelectAction;
+
+interface MultiSelectState {
+    cursor: number;
+}
+type MultiSelectAction = {
+    kind: 'state';
+    state: MultiSelectState;
+} | {
+    kind: 'toggle';
+    index: number;
+} | {
+    kind: 'submit';
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'noop';
+};
+declare function reduce<T>(items: SelectItem<T>[], state: MultiSelectState, key: Key): MultiSelectAction;
+
+export { type EditorAction, type EditorState, Key, type MultiSelectAction, type MultiSelectState, type SelectAction, type SelectItem, type SelectState, type VisualLine, type WrapMode, charWidth, reduce$2 as editorReducer, reduce as multiSelectReducer, reduce$1 as selectReducer, splitVisualLines, stringWidth, visibleIndices, windowAround, wrapText };

package/dist/index.js

@@ -0,0 +1,382 @@
+export { Buffer, DEFAULT_BORDER_STYLE, GRID_CHARS, wrapText } from './chunk-D6HW2BNM.js';
+
+// src/visualLines.ts
+function splitVisualLines(text, mode, width) {
+  const sources = text.split("\n");
+  if (mode === "nowrap" || width <= 0) {
+    return sources.map((line, i) => ({ text: line, lineNum: i + 1 }));
+  }
+  const out = [];
+  for (let i = 0; i < sources.length; i++) {
+    const line = sources[i];
+    const chars = [...line];
+    if (chars.length <= width) {
+      out.push({ text: line, lineNum: i + 1 });
+      continue;
+    }
+    let first = true;
+    for (let j = 0; j < chars.length; j += width) {
+      out.push({
+        text: chars.slice(j, j + width).join(""),
+        lineNum: first ? i + 1 : null
+      });
+      first = false;
+    }
+  }
+  return out;
+}
+
+// src/windowAround.ts
+function windowAround(items, cursor, visible) {
+  const v = Math.max(1, visible);
+  const start = Math.max(0, Math.min(items.length - v, cursor - Math.floor(v / 2)));
+  return { start, items: items.slice(start, start + v) };
+}
+
+// src/displayWidth.ts
+var ZERO_WIDTH = [
+  [768, 879],
+  [1155, 1158],
+  [1160, 1161],
+  [1425, 1469],
+  [1471, 1471],
+  [1473, 1474],
+  [1476, 1477],
+  [1479, 1479],
+  [1536, 1539],
+  [1552, 1557],
+  [1611, 1630],
+  [1648, 1648],
+  [1750, 1764],
+  [1767, 1768],
+  [1770, 1773],
+  [1807, 1807],
+  [1809, 1809],
+  [1840, 1866],
+  [1958, 1968],
+  [2027, 2035],
+  [2305, 2306],
+  [2364, 2364],
+  [2369, 2376],
+  [2381, 2381],
+  [2385, 2388],
+  [2402, 2403],
+  [2433, 2433],
+  [2492, 2492],
+  [2497, 2500],
+  [2509, 2509],
+  [2530, 2531],
+  [2561, 2562],
+  [2620, 2620],
+  [2625, 2626],
+  [2631, 2632],
+  [2635, 2637],
+  [2672, 2673],
+  [2689, 2690],
+  [2748, 2748],
+  [2753, 2757],
+  [2759, 2760],
+  [2765, 2765],
+  [2786, 2787],
+  [2817, 2817],
+  [2876, 2876],
+  [2879, 2879],
+  [2881, 2883],
+  [2893, 2893],
+  [2902, 2902],
+  [2946, 2946],
+  [3008, 3008],
+  [3021, 3021],
+  [3134, 3136],
+  [3142, 3144],
+  [3146, 3149],
+  [3157, 3158],
+  [3260, 3260],
+  [3263, 3263],
+  [3270, 3270],
+  [3276, 3277],
+  [3298, 3299],
+  [3393, 3395],
+  [3405, 3405],
+  [3530, 3530],
+  [3538, 3540],
+  [3542, 3542],
+  [3633, 3633],
+  [3636, 3642],
+  [3655, 3662],
+  [3761, 3761],
+  [3764, 3769],
+  [3771, 3772],
+  [3784, 3789],
+  [3864, 3865],
+  [3893, 3893],
+  [3895, 3895],
+  [3897, 3897],
+  [3953, 3966],
+  [3968, 3972],
+  [3974, 3975],
+  [3984, 3991],
+  [3993, 4028],
+  [4038, 4038],
+  [4141, 4144],
+  [4146, 4146],
+  [4150, 4151],
+  [4153, 4153],
+  [4184, 4185],
+  [4448, 4607],
+  [4959, 4959],
+  [5906, 5908],
+  [5938, 5940],
+  [5970, 5971],
+  [6002, 6003],
+  [6068, 6069],
+  [6071, 6077],
+  [6086, 6086],
+  [6089, 6099],
+  [6109, 6109],
+  [6155, 6157],
+  [6313, 6313],
+  [6432, 6434],
+  [6439, 6440],
+  [6450, 6450],
+  [6457, 6459],
+  [6679, 6680],
+  [6912, 6915],
+  [6964, 6964],
+  [6966, 6970],
+  [6972, 6972],
+  [6978, 6978],
+  [7019, 7027],
+  [7616, 7626],
+  [7678, 7679],
+  [8203, 8207],
+  [8234, 8238],
+  [8288, 8291],
+  [8298, 8303],
+  [8400, 8431],
+  [12330, 12335],
+  [12441, 12442],
+  [43014, 43014],
+  [43019, 43019],
+  [43045, 43046],
+  [64286, 64286],
+  [65024, 65039],
+  [65056, 65059],
+  [65279, 65279],
+  [65529, 65531],
+  [68097, 68099],
+  [68101, 68102],
+  [68108, 68111],
+  [68152, 68154],
+  [68159, 68159],
+  [119143, 119145],
+  [119155, 119170],
+  [119173, 119179],
+  [119210, 119213],
+  [119362, 119364],
+  [917505, 917505],
+  [917536, 917631],
+  [917760, 917999]
+];
+var WIDE = [
+  [4352, 4447],
+  // Hangul Jamo (leading consonants)
+  [9001, 9002],
+  // angle brackets
+  [11904, 12350],
+  // CJK Radicals … Kangxi … CJK Symbols (stops before U+303F)
+  [12353, 13311],
+  // Hiragana … Katakana … CJK compatibility
+  [13312, 19903],
+  // CJK Unified Ideographs Extension A
+  [19968, 40959],
+  // CJK Unified Ideographs
+  [40960, 42191],
+  // Yi Syllables / Radicals
+  [43360, 43391],
+  // Hangul Jamo Extended-A
+  [44032, 55203],
+  // Hangul Syllables
+  [63744, 64255],
+  // CJK Compatibility Ideographs
+  [65040, 65049],
+  // Vertical Forms
+  [65072, 65135],
+  // CJK Compatibility Forms / Small Form Variants
+  [65280, 65376],
+  // Fullwidth Forms (stops before halfwidth katakana U+FF61)
+  [65504, 65510],
+  // Fullwidth signs
+  [110592, 110593],
+  // Kana Supplement
+  [127488, 127569],
+  // Enclosed Ideographic Supplement
+  [127744, 128591],
+  // Misc Symbols & Pictographs + Emoticons
+  [129280, 129535],
+  // Supplemental Symbols and Pictographs
+  [131072, 262141]
+  // CJK Unified Ideographs Extension B and beyond
+];
+function inRanges(cp, table) {
+  let lo = 0;
+  let hi = table.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const [start, end] = table[mid];
+    if (cp < start) hi = mid - 1;
+    else if (cp > end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+}
+function charWidth(cp) {
+  if (cp < 32 || cp >= 127 && cp < 160) return 0;
+  if (inRanges(cp, ZERO_WIDTH)) return 0;
+  if (inRanges(cp, WIDE)) return 2;
+  return 1;
+}
+function stringWidth(str) {
+  let w = 0;
+  for (const ch of str) w += charWidth(ch.codePointAt(0));
+  return w;
+}
+
+// src/editor.ts
+var OPT_MAP = {
+  " ": ["\xA0"],
+  // U+00A0 NBSP
+  "-": ["\u2013", "\u2014"],
+  // en-dash U+2013, em-dash U+2014
+  "[": ["\u201C", "\u201D"],
+  // left/right double quote
+  "]": ["\u2018", "\u2019"]
+  // left/right single quote
+};
+var isWord = (c) => /[\p{L}\p{N}_]/u.test(c);
+function wordLeft(value, cursor) {
+  let c = cursor;
+  while (c > 0 && !isWord(value[c - 1])) c--;
+  while (c > 0 && isWord(value[c - 1])) c--;
+  return c;
+}
+function wordRight(value, cursor) {
+  let c = cursor;
+  while (c < value.length && !isWord(value[c])) c++;
+  while (c < value.length && isWord(value[c])) c++;
+  return c;
+}
+function reduce(state, key) {
+  const { value, cursor } = state;
+  const clamp = (n) => Math.max(0, Math.min(value.length, n));
+  if (key.name === "left" && key.meta) return { kind: "edit", state: { value, cursor: wordLeft(value, cursor) } };
+  if (key.name === "b" && key.meta) return { kind: "edit", state: { value, cursor: wordLeft(value, cursor) } };
+  if (key.name === "right" && key.meta) return { kind: "edit", state: { value, cursor: wordRight(value, cursor) } };
+  if (key.name === "f" && key.meta) return { kind: "edit", state: { value, cursor: wordRight(value, cursor) } };
+  if (key.name === "left") return { kind: "edit", state: { value, cursor: clamp(cursor - 1) } };
+  if (key.name === "right") return { kind: "edit", state: { value, cursor: clamp(cursor + 1) } };
+  if (key.name === "home") return { kind: "edit", state: { value, cursor: 0 } };
+  if (key.name === "end") return { kind: "edit", state: { value, cursor: value.length } };
+  if (key.name === "a" && key.ctrl) return { kind: "edit", state: { value, cursor: 0 } };
+  if (key.name === "e" && key.ctrl) return { kind: "edit", state: { value, cursor: value.length } };
+  if (key.name === "backspace" && key.meta) {
+    const start = wordLeft(value, cursor);
+    return { kind: "edit", state: { value: value.slice(0, start) + value.slice(cursor), cursor: start } };
+  }
+  if (key.name === "w" && key.ctrl) {
+    const start = wordLeft(value, cursor);
+    return { kind: "edit", state: { value: value.slice(0, start) + value.slice(cursor), cursor: start } };
+  }
+  if (key.name === "d" && key.meta) {
+    const end = wordRight(value, cursor);
+    return { kind: "edit", state: { value: value.slice(0, cursor) + value.slice(end), cursor } };
+  }
+  if (key.name === "delete" && key.meta) {
+    const end = wordRight(value, cursor);
+    return { kind: "edit", state: { value: value.slice(0, cursor) + value.slice(end), cursor } };
+  }
+  if (key.name === "k" && key.ctrl) {
+    return { kind: "edit", state: { value: value.slice(0, cursor), cursor } };
+  }
+  if (key.name === "u" && key.ctrl) {
+    return { kind: "edit", state: { value: value.slice(cursor), cursor: 0 } };
+  }
+  if (key.meta && OPT_MAP[key.name]) {
+    const entry = OPT_MAP[key.name];
+    const ch = key.shift && entry[1] !== void 0 ? entry[1] : entry[0];
+    return { kind: "edit", state: { value: value.slice(0, cursor) + ch + value.slice(cursor), cursor: cursor + 1 } };
+  }
+  if (key.name === "backspace") {
+    if (cursor === 0) return { kind: "edit", state };
+    return { kind: "edit", state: { value: value.slice(0, cursor - 1) + value.slice(cursor), cursor: cursor - 1 } };
+  }
+  if (key.name === "delete" || key.name === "d" && key.ctrl) {
+    if (cursor === value.length) return { kind: "edit", state };
+    return { kind: "edit", state: { value: value.slice(0, cursor) + value.slice(cursor + 1), cursor } };
+  }
+  if (key.name === "return") return { kind: "submit" };
+  if (key.name === "escape") return { kind: "cancel" };
+  if (!key.ctrl && !key.meta && key.name.length === 1) {
+    const ch = key.name;
+    return { kind: "edit", state: { value: value.slice(0, cursor) + ch + value.slice(cursor), cursor: cursor + 1 } };
+  }
+  return { kind: "noop" };
+}
+
+// src/selectReducer.ts
+function visibleIndices(items, filter) {
+  if (filter === "") return items.map((_, i) => i);
+  const q = filter.toLowerCase();
+  const out = [];
+  for (let i = 0; i < items.length; i++) {
+    if (items[i].label.toLowerCase().includes(q)) out.push(i);
+  }
+  return out;
+}
+function reduce2(items, state, key) {
+  const visible = visibleIndices(items, state.filter);
+  const n = visible.length;
+  if (key.name === "escape") return { kind: "cancel" };
+  if (key.name === "return") {
+    if (n === 0) return { kind: "noop" };
+    const cursor = Math.min(state.cursor, n - 1);
+    return { kind: "submit", index: visible[cursor] };
+  }
+  if (key.name === "down" || key.name === "j" && !key.ctrl && !key.meta) {
+    if (n === 0) return { kind: "noop" };
+    return { kind: "state", state: { cursor: (state.cursor + 1) % n, filter: state.filter } };
+  }
+  if (key.name === "up" || key.name === "k" && !key.ctrl && !key.meta) {
+    if (n === 0) return { kind: "noop" };
+    return { kind: "state", state: { cursor: (state.cursor - 1 + n) % n, filter: state.filter } };
+  }
+  if (key.name === "backspace") {
+    if (state.filter === "") return { kind: "noop" };
+    return { kind: "state", state: { cursor: 0, filter: state.filter.slice(0, -1) } };
+  }
+  if (!key.ctrl && !key.meta && key.name.length === 1) {
+    return { kind: "state", state: { cursor: 0, filter: state.filter + key.name } };
+  }
+  return { kind: "noop" };
+}
+
+// src/multiSelectReducer.ts
+function reduce3(items, state, key) {
+  const n = items.length;
+  if (key.name === "escape") return { kind: "cancel" };
+  if (key.name === "return") return { kind: "submit" };
+  if (n === 0) return { kind: "noop" };
+  if (key.name === "down" || key.name === "j" && !key.ctrl && !key.meta) {
+    return { kind: "state", state: { cursor: (state.cursor + 1) % n } };
+  }
+  if (key.name === "up" || key.name === "k" && !key.ctrl && !key.meta) {
+    return { kind: "state", state: { cursor: (state.cursor - 1 + n) % n } };
+  }
+  if (key.name === " ") {
+    const index = Math.max(0, Math.min(state.cursor, n - 1));
+    return { kind: "toggle", index };
+  }
+  return { kind: "noop" };
+}
+
+export { charWidth, reduce as editorReducer, reduce3 as multiSelectReducer, reduce2 as selectReducer, splitVisualLines, stringWidth, visibleIndices, windowAround };