@termuijs/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2365 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  App: () => App,
+  BORDER_CHARS: () => BORDER_CHARS,
+  CTRL_KEYS: () => CTRL_KEYS,
+  ColorDepth: () => ColorDepth,
+  ESCAPE_SEQUENCES: () => ESCAPE_SEQUENCES,
+  EventEmitter: () => EventEmitter,
+  FocusManager: () => FocusManager,
+  InputParser: () => InputParser,
+  LayerManager: () => LayerManager,
+  Renderer: () => Renderer,
+  SPECIAL_KEYS: () => SPECIAL_KEYS,
+  Screen: () => Screen,
+  Terminal: () => Terminal,
+  ansi: () => ansi_exports,
+  borderSize: () => borderSize,
+  cellsEqual: () => cellsEqual,
+  colorToAnsiBg: () => colorToAnsiBg,
+  colorToAnsiFg: () => colorToAnsiFg,
+  colorToRgb: () => colorToRgb,
+  computeLayout: () => computeLayout,
+  containsPoint: () => containsPoint,
+  createKeyEvent: () => createKeyEvent,
+  createLayoutNode: () => createLayoutNode,
+  defaultStyle: () => defaultStyle,
+  detectColorDepth: () => detectColorDepth,
+  emptyCell: () => emptyCell,
+  emptyRect: () => emptyRect,
+  getBorderChars: () => getBorderChars,
+  intersectRect: () => intersectRect,
+  isMouseSequence: () => isMouseSequence,
+  mergeStyles: () => mergeStyles,
+  normalizeEdges: () => normalizeEdges,
+  parseColor: () => parseColor,
+  parseMouseEvent: () => parseMouseEvent,
+  renderFallback: () => renderFallback,
+  shouldUseFallback: () => shouldUseFallback,
+  shrinkRect: () => shrinkRect,
+  stringWidth: () => stringWidth,
+  stripAnsi: () => stripAnsi,
+  styleToCellAttrs: () => styleToCellAttrs,
+  truncate: () => truncate,
+  unionRect: () => unionRect,
+  wordWrap: () => wordWrap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/style/Color.ts
+var ColorDepth = /* @__PURE__ */ ((ColorDepth3) => {
+  ColorDepth3[ColorDepth3["None"] = 0] = "None";
+  ColorDepth3[ColorDepth3["Basic"] = 4] = "Basic";
+  ColorDepth3[ColorDepth3["Ansi256"] = 8] = "Ansi256";
+  ColorDepth3[ColorDepth3["TrueColor"] = 24] = "TrueColor";
+  return ColorDepth3;
+})(ColorDepth || {});
+var NAMED_TO_ANSI = {
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  brightBlack: 8,
+  brightRed: 9,
+  brightGreen: 10,
+  brightYellow: 11,
+  brightBlue: 12,
+  brightMagenta: 13,
+  brightCyan: 14,
+  brightWhite: 15
+};
+var NAMED_TO_RGB = {
+  black: [0, 0, 0],
+  red: [170, 0, 0],
+  green: [0, 170, 0],
+  yellow: [170, 170, 0],
+  blue: [0, 0, 170],
+  magenta: [170, 0, 170],
+  cyan: [0, 170, 170],
+  white: [170, 170, 170],
+  brightBlack: [85, 85, 85],
+  brightRed: [255, 85, 85],
+  brightGreen: [85, 255, 85],
+  brightYellow: [255, 255, 85],
+  brightBlue: [85, 85, 255],
+  brightMagenta: [255, 85, 255],
+  brightCyan: [85, 255, 255],
+  brightWhite: [255, 255, 255]
+};
+function parseColor(input) {
+  if (input === "none" || input === "") {
+    return { type: "none" };
+  }
+  if (input in NAMED_TO_ANSI) {
+    return { type: "named", name: input };
+  }
+  if (input.startsWith("#")) {
+    let hex = input.slice(1);
+    if (hex.length === 3) {
+      hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+    }
+    if (hex.length === 6 && /^[0-9a-fA-F]{6}$/.test(hex)) {
+      return { type: "hex", hex: "#" + hex.toLowerCase() };
+    }
+    throw new Error(`Invalid hex color: ${input}`);
+  }
+  const rgbMatch = input.match(/^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/);
+  if (rgbMatch) {
+    const r = Math.min(255, parseInt(rgbMatch[1], 10));
+    const g = Math.min(255, parseInt(rgbMatch[2], 10));
+    const b = Math.min(255, parseInt(rgbMatch[3], 10));
+    return { type: "rgb", r, g, b };
+  }
+  const ansi256Match = input.match(/^ansi256\(\s*(\d{1,3})\s*\)$/);
+  if (ansi256Match) {
+    const code = Math.min(255, parseInt(ansi256Match[1], 10));
+    return { type: "ansi256", code };
+  }
+  throw new Error(`Unknown color format: ${input}`);
+}
+function colorToRgb(color) {
+  switch (color.type) {
+    case "none":
+      return [0, 0, 0];
+    case "named":
+      return NAMED_TO_RGB[color.name];
+    case "rgb":
+      return [color.r, color.g, color.b];
+    case "hex": {
+      const hex = color.hex.slice(1);
+      return [
+        parseInt(hex.slice(0, 2), 16),
+        parseInt(hex.slice(2, 4), 16),
+        parseInt(hex.slice(4, 6), 16)
+      ];
+    }
+    case "ansi256":
+      return ansi256ToRgb(color.code);
+  }
+}
+function ansi256ToRgb(code) {
+  if (code < 16) {
+    const names = Object.keys(NAMED_TO_RGB);
+    return NAMED_TO_RGB[names[code]];
+  }
+  if (code < 232) {
+    const idx = code - 16;
+    const b = idx % 6 * 51;
+    const g = Math.floor(idx / 6) % 6 * 51;
+    const r = Math.floor(idx / 36) * 51;
+    return [r, g, b];
+  }
+  const gray = (code - 232) * 10 + 8;
+  return [gray, gray, gray];
+}
+function rgbToAnsi256(r, g, b) {
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return Math.round((r - 8) / 247 * 24) + 232;
+  }
+  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+}
+function rgbToBasic(r, g, b) {
+  let minDist = Infinity;
+  let best = 0;
+  const names = Object.keys(NAMED_TO_RGB);
+  for (let i = 0; i < names.length; i++) {
+    const [cr, cg, cb] = NAMED_TO_RGB[names[i]];
+    const dist = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
+    if (dist < minDist) {
+      minDist = dist;
+      best = i;
+    }
+  }
+  return best;
+}
+function detectColorDepth() {
+  const env = process.env;
+  if (env["NO_COLOR"] !== void 0) {
+    return 0 /* None */;
+  }
+  if (env["FORCE_COLOR"] !== void 0) {
+    const level = parseInt(env["FORCE_COLOR"], 10);
+    if (level === 0) return 0 /* None */;
+    if (level === 1) return 4 /* Basic */;
+    if (level === 2) return 8 /* Ansi256 */;
+    if (level >= 3) return 24 /* TrueColor */;
+  }
+  const colorterm = env["COLORTERM"];
+  if (colorterm === "truecolor" || colorterm === "24bit") {
+    return 24 /* TrueColor */;
+  }
+  const term = env["TERM"] || "";
+  if (term === "dumb") {
+    return 0 /* None */;
+  }
+  if (term.includes("256color") || term.includes("256")) {
+    return 8 /* Ansi256 */;
+  }
+  if (env["TERM_PROGRAM"] === "iTerm.app" || env["TERM_PROGRAM"] === "Hyper") {
+    return 24 /* TrueColor */;
+  }
+  if (process.stdout?.isTTY) {
+    return 4 /* Basic */;
+  }
+  return 0 /* None */;
+}
+function colorToAnsiFg(color, depth) {
+  if (color.type === "none" || depth === 0 /* None */) return "";
+  const [r, g, b] = colorToRgb(color);
+  switch (depth) {
+    case 24 /* TrueColor */:
+      return `\x1B[38;2;${r};${g};${b}m`;
+    case 8 /* Ansi256 */:
+      return `\x1B[38;5;${rgbToAnsi256(r, g, b)}m`;
+    case 4 /* Basic */: {
+      const idx = rgbToBasic(r, g, b);
+      return idx < 8 ? `\x1B[${30 + idx}m` : `\x1B[${90 + idx - 8}m`;
+    }
+    default:
+      return "";
+  }
+}
+function colorToAnsiBg(color, depth) {
+  if (color.type === "none" || depth === 0 /* None */) return "";
+  const [r, g, b] = colorToRgb(color);
+  switch (depth) {
+    case 24 /* TrueColor */:
+      return `\x1B[48;2;${r};${g};${b}m`;
+    case 8 /* Ansi256 */:
+      return `\x1B[48;5;${rgbToAnsi256(r, g, b)}m`;
+    case 4 /* Basic */: {
+      const idx = rgbToBasic(r, g, b);
+      return idx < 8 ? `\x1B[${40 + idx}m` : `\x1B[${100 + idx - 8}m`;
+    }
+    default:
+      return "";
+  }
+}
+
+// src/utils/ansi.ts
+var ansi_exports = {};
+__export(ansi_exports, {
+  CSI: () => CSI,
+  ESC: () => ESC,
+  OSC: () => OSC,
+  beginSyncUpdate: () => beginSyncUpdate,
+  blink: () => blink,
+  bold: () => bold,
+  clearDown: () => clearDown,
+  clearLine: () => clearLine,
+  clearLineToEnd: () => clearLineToEnd,
+  clearLineToStart: () => clearLineToStart,
+  clearScreen: () => clearScreen,
+  clearUp: () => clearUp,
+  dim: () => dim,
+  disableBracketedPaste: () => disableBracketedPaste,
+  disableMouse: () => disableMouse,
+  enableBracketedPaste: () => enableBracketedPaste,
+  enableMouse: () => enableMouse,
+  endSyncUpdate: () => endSyncUpdate,
+  enterAltScreen: () => enterAltScreen,
+  exitAltScreen: () => exitAltScreen,
+  hideCursor: () => hideCursor,
+  inverse: () => inverse,
+  italic: () => italic,
+  moveDown: () => moveDown,
+  moveLeft: () => moveLeft,
+  moveRight: () => moveRight,
+  moveTo: () => moveTo,
+  moveUp: () => moveUp,
+  reset: () => reset,
+  resetBlink: () => resetBlink,
+  resetBold: () => resetBold,
+  resetDim: () => resetDim,
+  resetInverse: () => resetInverse,
+  resetItalic: () => resetItalic,
+  resetScrollRegion: () => resetScrollRegion,
+  resetStrikethrough: () => resetStrikethrough,
+  resetUnderline: () => resetUnderline,
+  restoreCursorPosition: () => restoreCursorPosition,
+  saveCursorPosition: () => saveCursorPosition,
+  setScrollRegion: () => setScrollRegion,
+  setTitle: () => setTitle,
+  showCursor: () => showCursor,
+  strikethrough: () => strikethrough,
+  underline: () => underline
+});
+var CSI = "\x1B[";
+var OSC = "\x1B]";
+var ESC = "\x1B";
+var hideCursor = `${CSI}?25l`;
+var showCursor = `${CSI}?25h`;
+var saveCursorPosition = `${CSI}s`;
+var restoreCursorPosition = `${CSI}u`;
+function moveTo(col, row) {
+  return `${CSI}${row + 1};${col + 1}H`;
+}
+function moveUp(n = 1) {
+  return `${CSI}${n}A`;
+}
+function moveDown(n = 1) {
+  return `${CSI}${n}B`;
+}
+function moveRight(n = 1) {
+  return `${CSI}${n}C`;
+}
+function moveLeft(n = 1) {
+  return `${CSI}${n}D`;
+}
+var clearScreen = `${CSI}2J`;
+var clearLine = `${CSI}2K`;
+var clearLineToEnd = `${CSI}0K`;
+var clearLineToStart = `${CSI}1K`;
+var clearDown = `${CSI}J`;
+var clearUp = `${CSI}1J`;
+var enterAltScreen = `${CSI}?1049h`;
+var exitAltScreen = `${CSI}?1049l`;
+var beginSyncUpdate = `${CSI}?2026h`;
+var endSyncUpdate = `${CSI}?2026l`;
+var enableMouse = `${CSI}?1000h${CSI}?1002h${CSI}?1006h`;
+var disableMouse = `${CSI}?1000l${CSI}?1002l${CSI}?1006l`;
+var enableBracketedPaste = `${CSI}?2004h`;
+var disableBracketedPaste = `${CSI}?2004l`;
+var reset = `${CSI}0m`;
+var bold = `${CSI}1m`;
+var dim = `${CSI}2m`;
+var italic = `${CSI}3m`;
+var underline = `${CSI}4m`;
+var blink = `${CSI}5m`;
+var inverse = `${CSI}7m`;
+var strikethrough = `${CSI}9m`;
+var resetBold = `${CSI}22m`;
+var resetDim = `${CSI}22m`;
+var resetItalic = `${CSI}23m`;
+var resetUnderline = `${CSI}24m`;
+var resetBlink = `${CSI}25m`;
+var resetInverse = `${CSI}27m`;
+var resetStrikethrough = `${CSI}29m`;
+function setScrollRegion(top, bottom) {
+  return `${CSI}${top + 1};${bottom + 1}r`;
+}
+var resetScrollRegion = `${CSI}r`;
+function setTitle(title) {
+  return `${OSC}0;${title}\x07`;
+}
+
+// src/terminal/Terminal.ts
+var Terminal = class {
+  stdout;
+  stdin;
+  colorDepth;
+  _cols;
+  _rows;
+  _isRawMode = false;
+  _isAltScreen = false;
+  _isMouseEnabled = false;
+  _resizeHandlers = [];
+  _cleanupHandlers = [];
+  _originalRawMode;
+  constructor(options = {}) {
+    this.stdout = options.stdout ?? process.stdout;
+    this.stdin = options.stdin ?? process.stdin;
+    this.colorDepth = options.colorDepth ?? detectColorDepth();
+    this._cols = this.stdout.columns ?? 80;
+    this._rows = this.stdout.rows ?? 24;
+    this.stdout.on("resize", () => {
+      this._cols = this.stdout.columns ?? 80;
+      this._rows = this.stdout.rows ?? 24;
+      for (const handler of this._resizeHandlers) {
+        handler(this._cols, this._rows);
+      }
+    });
+    this._setupCleanup();
+  }
+  /** Current terminal width in columns */
+  get cols() {
+    return this._cols;
+  }
+  /** Current terminal height in rows */
+  get rows() {
+    return this._rows;
+  }
+  /** Whether stdin is a TTY (interactive) */
+  isInteractive() {
+    return Boolean(this.stdin.isTTY) && !process.env["CI"];
+  }
+  /** Whether the terminal supports raw mode */
+  supportsRawMode() {
+    return Boolean(this.stdin.isTTY && typeof this.stdin.setRawMode === "function");
+  }
+  // ── Raw Mode ────────────────────────────────────────
+  enterRawMode() {
+    if (this._isRawMode || !this.supportsRawMode()) return;
+    this._originalRawMode = this.stdin.isRaw;
+    this.stdin.setRawMode(true);
+    this.stdin.resume();
+    this._isRawMode = true;
+  }
+  exitRawMode() {
+    if (!this._isRawMode) return;
+    this.stdin.setRawMode(this._originalRawMode ?? false);
+    this.stdin.pause();
+    this._isRawMode = false;
+  }
+  // ── Alternate Screen ────────────────────────────────
+  enterAltScreen() {
+    if (this._isAltScreen) return;
+    this.write(enterAltScreen);
+    this._isAltScreen = true;
+  }
+  exitAltScreen() {
+    if (!this._isAltScreen) return;
+    this.write(exitAltScreen);
+    this._isAltScreen = false;
+  }
+  // ── Mouse ───────────────────────────────────────────
+  enableMouse() {
+    if (this._isMouseEnabled) return;
+    this.write(enableMouse);
+    this._isMouseEnabled = true;
+  }
+  disableMouse() {
+    if (!this._isMouseEnabled) return;
+    this.write(disableMouse);
+    this._isMouseEnabled = false;
+  }
+  // ── Cursor ──────────────────────────────────────────
+  hideCursor() {
+    this.write(hideCursor);
+  }
+  showCursor() {
+    this.write(showCursor);
+  }
+  // ── Output ──────────────────────────────────────────
+  write(data) {
+    this.stdout.write(data);
+  }
+  // ── Resize ──────────────────────────────────────────
+  onResize(handler) {
+    this._resizeHandlers.push(handler);
+    return () => {
+      const idx = this._resizeHandlers.indexOf(handler);
+      if (idx >= 0) this._resizeHandlers.splice(idx, 1);
+    };
+  }
+  // ── Cleanup ─────────────────────────────────────────
+  /**
+   * Restore terminal to its original state.
+   * Called automatically on SIGINT, SIGTERM, process exit.
+   */
+  restore() {
+    this.disableMouse();
+    this.exitAltScreen();
+    this.exitRawMode();
+    this.showCursor();
+    this.write(reset);
+  }
+  /**
+   * Register a custom cleanup handler that runs on terminal restore.
+   */
+  onCleanup(handler) {
+    this._cleanupHandlers.push(handler);
+  }
+  _setupCleanup() {
+    const cleanup = () => {
+      for (const handler of this._cleanupHandlers) {
+        try {
+          handler();
+        } catch {
+        }
+      }
+      this.restore();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(143);
+    });
+    process.on("uncaughtException", (err) => {
+      cleanup();
+      console.error(err);
+      process.exit(1);
+    });
+  }
+};
+
+// src/terminal/Screen.ts
+function emptyCell() {
+  return {
+    char: " ",
+    fg: { type: "none" },
+    bg: { type: "none" },
+    bold: false,
+    italic: false,
+    underline: false,
+    dim: false,
+    strikethrough: false,
+    inverse: false,
+    width: 1
+  };
+}
+function cellsEqual(a, b) {
+  return a.char === b.char && a.bold === b.bold && a.italic === b.italic && a.underline === b.underline && a.dim === b.dim && a.strikethrough === b.strikethrough && a.inverse === b.inverse && a.width === b.width && colorsEqual(a.fg, b.fg) && colorsEqual(a.bg, b.bg);
+}
+function colorsEqual(a, b) {
+  if (a.type !== b.type) return false;
+  switch (a.type) {
+    case "none":
+      return true;
+    case "named":
+      return a.name === b.name;
+    case "ansi256":
+      return a.code === b.code;
+    case "rgb":
+      return a.r === b.r && a.g === b.g && a.b === b.b;
+    case "hex":
+      return a.hex === b.hex;
+  }
+}
+var Screen = class {
+  _cols;
+  _rows;
+  front;
+  back;
+  /**
+   * Stack of clipping regions. When non-empty, setCell/writeString
+   * only write to cells within the topmost clip rectangle.
+   */
+  _clipStack = [];
+  constructor(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    this.front = this._createGrid(cols, rows);
+    this.back = this._createGrid(cols, rows);
+  }
+  get cols() {
+    return this._cols;
+  }
+  get rows() {
+    return this._rows;
+  }
+  /**
+   * Push a clipping region onto the stack.
+   * All subsequent setCell/writeString calls will be constrained
+   * to cells within this rectangle. Clips are intersected with
+   * any parent clip already on the stack (nested clipping).
+   */
+  pushClip(region) {
+    if (this._clipStack.length > 0) {
+      const parent = this._clipStack[this._clipStack.length - 1];
+      const x = Math.max(region.x, parent.x);
+      const y = Math.max(region.y, parent.y);
+      const right = Math.min(region.x + region.width, parent.x + parent.width);
+      const bottom = Math.min(region.y + region.height, parent.y + parent.height);
+      if (right <= x || bottom <= y) {
+        this._clipStack.push({ x: 0, y: 0, width: 0, height: 0 });
+      } else {
+        this._clipStack.push({ x, y, width: right - x, height: bottom - y });
+      }
+    } else {
+      this._clipStack.push({ ...region });
+    }
+  }
+  /**
+   * Pop the most recent clipping region from the stack.
+   */
+  popClip() {
+    this._clipStack.pop();
+  }
+  /**
+   * Get the current active clip region, or null if no clip is active.
+   */
+  get activeClip() {
+    return this._clipStack.length > 0 ? this._clipStack[this._clipStack.length - 1] : null;
+  }
+  /**
+   * Write a cell to the back buffer at position (col, row).
+   */
+  setCell(col, row, cell) {
+    col = Math.floor(col);
+    row = Math.floor(row);
+    if (!(col >= 0 && col < this._cols && row >= 0 && row < this._rows)) return;
+    if (this._clipStack.length > 0) {
+      const clip = this._clipStack[this._clipStack.length - 1];
+      if (col < clip.x || col >= clip.x + clip.width || row < clip.y || row >= clip.y + clip.height) {
+        return;
+      }
+    }
+    const existing = this.back[row][col];
+    Object.assign(existing, cell);
+  }
+  /**
+   * Write a string to the back buffer starting at (col, row).
+   * Applies the provided style attributes to each character.
+   */
+  writeString(col, row, str, style = {}) {
+    row = Math.floor(row);
+    col = Math.floor(col);
+    if (!(row >= 0 && row < this._rows)) return;
+    let x = col;
+    for (const char of str) {
+      if (x >= this._cols) break;
+      if (x < 0) {
+        x++;
+        continue;
+      }
+      const cp = char.codePointAt(0);
+      const isWide = this._isWideCodePoint(cp);
+      const width = isWide ? 2 : 1;
+      this.setCell(x, row, {
+        char,
+        width,
+        ...style
+      });
+      if (isWide && x + 1 < this._cols) {
+        this.setCell(x + 1, row, {
+          char: "",
+          width: 0,
+          ...style
+        });
+        x += 2;
+      } else {
+        x += 1;
+      }
+    }
+  }
+  /**
+   * Clear the back buffer to all empty cells.
+   */
+  clear() {
+    for (let r = 0; r < this._rows; r++) {
+      for (let c = 0; c < this._cols; c++) {
+        this.back[r][c] = emptyCell();
+      }
+    }
+  }
+  /**
+   * Swap front and back buffers. Called after rendering diffs.
+   */
+  swap() {
+    const temp = this.front;
+    this.front = this.back;
+    this.back = temp;
+  }
+  /**
+   * Resize the screen. Clears both buffers.
+   */
+  resize(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    this.front = this._createGrid(cols, rows);
+    this.back = this._createGrid(cols, rows);
+  }
+  /**
+   * Clear the front buffer (marks everything as "needs redraw").
+   */
+  invalidate() {
+    for (let r = 0; r < this._rows; r++) {
+      for (let c = 0; c < this._cols; c++) {
+        this.front[r][c] = { ...emptyCell(), char: "\0" };
+      }
+    }
+  }
+  _createGrid(cols, rows) {
+    const grid = [];
+    for (let r = 0; r < rows; r++) {
+      const row = [];
+      for (let c = 0; c < cols; c++) {
+        row.push(emptyCell());
+      }
+      grid.push(row);
+    }
+    return grid;
+  }
+  _isWideCodePoint(cp) {
+    return cp >= 19968 && cp <= 40959 || cp >= 13312 && cp <= 19903 || cp >= 63744 && cp <= 64255 || cp >= 44032 && cp <= 55215 || cp >= 12448 && cp <= 12543 || cp >= 12288 && cp <= 12351 || cp >= 12352 && cp <= 12447 || cp >= 65281 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 128512 && cp <= 128591 || cp >= 127744 && cp <= 128511 || cp >= 128640 && cp <= 128767 || cp >= 129280 && cp <= 129535 || cp >= 131072 && cp <= 173791;
+  }
+};
+
+// src/terminal/Renderer.ts
+var Renderer = class {
+  _terminal;
+  _screen;
+  _fps;
+  _frameTimer = null;
+  _renderRequested = false;
+  _colorDepth;
+  constructor(terminal, screen, fps = 30) {
+    this._terminal = terminal;
+    this._screen = screen;
+    this._fps = fps;
+    this._colorDepth = terminal.colorDepth;
+  }
+  /** Change the rendering frame rate cap */
+  setFPS(fps) {
+    this._fps = fps;
+    if (this._frameTimer) {
+      this.stop();
+      this.start();
+    }
+  }
+  /** Start the render loop */
+  start() {
+    if (this._frameTimer) return;
+    const interval = Math.floor(1e3 / this._fps);
+    this._frameTimer = setInterval(() => {
+      if (this._renderRequested) {
+        this._renderRequested = false;
+        this._flush();
+      }
+    }, interval);
+  }
+  /** Stop the render loop */
+  stop() {
+    if (this._frameTimer) {
+      clearInterval(this._frameTimer);
+      this._frameTimer = null;
+    }
+  }
+  /** Request a render on the next frame */
+  requestFrame() {
+    this._renderRequested = true;
+  }
+  /** Force an immediate render (bypass frame rate) */
+  renderNow() {
+    this._flush();
+  }
+  /**
+   * Full-screen clear and redraw (first render or after resize).
+   */
+  fullRender() {
+    this._screen.invalidate();
+    this._flush();
+  }
+  /**
+   * Core diff and flush: compare front vs back buffer,
+   * emit only changed cells.
+   */
+  _flush() {
+    const { front, back, cols, rows } = this._screen;
+    let output = beginSyncUpdate;
+    let lastRow = -1;
+    let lastCol = -1;
+    for (let r = 0; r < rows; r++) {
+      for (let c = 0; c < cols; c++) {
+        const frontCell = front[r][c];
+        const backCell = back[r][c];
+        if (cellsEqual(frontCell, backCell)) continue;
+        if (backCell.width === 0) continue;
+        if (r !== lastRow || c !== lastCol) {
+          output += moveTo(c, r);
+        }
+        output += this._renderCell(backCell);
+        lastRow = r;
+        lastCol = c + (backCell.width === 2 ? 2 : 1);
+      }
+    }
+    output += reset;
+    output += endSyncUpdate;
+    this._terminal.write(output);
+    this._screen.swap();
+  }
+  /**
+   * Generate the ANSI escape sequence to render a single cell.
+   */
+  _renderCell(cell) {
+    let seq = "";
+    seq += reset;
+    if (cell.bold) seq += "\x1B[1m";
+    if (cell.dim) seq += "\x1B[2m";
+    if (cell.italic) seq += "\x1B[3m";
+    if (cell.underline) seq += "\x1B[4m";
+    if (cell.strikethrough) seq += "\x1B[9m";
+    if (cell.inverse) seq += "\x1B[7m";
+    seq += colorToAnsiFg(cell.fg, this._colorDepth);
+    seq += colorToAnsiBg(cell.bg, this._colorDepth);
+    seq += cell.char || " ";
+    return seq;
+  }
+};
+
+// src/terminal/LayerManager.ts
+function isCellTransparent(cell) {
+  return cell.char === " " && cell.fg.type === "none" && cell.bg.type === "none" && !cell.bold && !cell.italic && !cell.underline && !cell.dim && !cell.strikethrough && !cell.inverse;
+}
+var LayerManager = class {
+  _layers = /* @__PURE__ */ new Map();
+  _cols;
+  _rows;
+  constructor(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+  }
+  get cols() {
+    return this._cols;
+  }
+  get rows() {
+    return this._rows;
+  }
+  /**
+   * Create a new overlay layer.
+   * @param id   Unique identifier (e.g. 'modal', 'select-dropdown', 'toast')
+   * @param zIndex  Stacking order (higher = rendered on top)
+   */
+  createLayer(id, zIndex) {
+    if (this._layers.has(id)) {
+      return this._layers.get(id);
+    }
+    const layer = {
+      id,
+      zIndex,
+      cells: this._createGrid(),
+      visible: true,
+      dirtyRegion: null
+    };
+    this._layers.set(id, layer);
+    return layer;
+  }
+  /**
+   * Remove an overlay layer and clean up its resources.
+   */
+  removeLayer(id) {
+    this._layers.delete(id);
+  }
+  /**
+   * Get a layer by ID.
+   */
+  getLayer(id) {
+    return this._layers.get(id);
+  }
+  /**
+   * Check if a layer exists.
+   */
+  hasLayer(id) {
+    return this._layers.has(id);
+  }
+  /**
+   * Get all layers sorted by z-index (ascending).
+   */
+  getSortedLayers() {
+    return Array.from(this._layers.values()).filter((l) => l.visible).sort((a, b) => a.zIndex - b.zIndex);
+  }
+  /**
+   * Write a cell to a specific layer.
+   */
+  setCell(layerId, col, row, cell) {
+    const layer = this._layers.get(layerId);
+    if (!layer) return;
+    col = Math.floor(col);
+    row = Math.floor(row);
+    if (!(col >= 0 && col < this._cols && row >= 0 && row < this._rows)) return;
+    const existing = layer.cells[row][col];
+    Object.assign(existing, cell);
+    this._expandDirty(layer, col, row);
+  }
+  /**
+   * Write a string to a specific layer at position (col, row).
+   */
+  writeString(layerId, col, row, str, style = {}) {
+    const layer = this._layers.get(layerId);
+    if (!layer) return;
+    row = Math.floor(row);
+    col = Math.floor(col);
+    if (!(row >= 0 && row < this._rows)) return;
+    let x = col;
+    for (const char of str) {
+      if (x >= this._cols) break;
+      if (x < 0) {
+        x++;
+        continue;
+      }
+      this.setCell(layerId, x, row, { char, width: 1, ...style });
+      x++;
+    }
+  }
+  /**
+   * Clear all cells in a specific layer.
+   */
+  clearLayer(id) {
+    const layer = this._layers.get(id);
+    if (!layer) return;
+    for (let r = 0; r < this._rows; r++) {
+      for (let c = 0; c < this._cols; c++) {
+        layer.cells[r][c] = emptyCell();
+      }
+    }
+    layer.dirtyRegion = null;
+  }
+  /**
+   * Clear all overlay layers.
+   */
+  clearAll() {
+    for (const layer of this._layers.values()) {
+      this.clearLayer(layer.id);
+    }
+  }
+  /**
+   * Composite all overlay layers onto the Screen's back buffer.
+   * Layers are applied in z-index order (lowest first).
+   * Transparent cells (empty with no colors) are skipped.
+   */
+  composite(screen) {
+    const sorted = this.getSortedLayers();
+    for (const layer of sorted) {
+      if (!layer.dirtyRegion) continue;
+      const { x: dx, y: dy, width: dw, height: dh } = layer.dirtyRegion;
+      for (let r = dy; r < dy + dh && r < this._rows; r++) {
+        for (let c = dx; c < dx + dw && c < this._cols; c++) {
+          const cell = layer.cells[r][c];
+          if (isCellTransparent(cell)) continue;
+          screen.setCell(c, r, {
+            char: cell.char,
+            fg: cell.fg,
+            bg: cell.bg,
+            bold: cell.bold,
+            italic: cell.italic,
+            underline: cell.underline,
+            dim: cell.dim,
+            strikethrough: cell.strikethrough,
+            inverse: cell.inverse,
+            width: cell.width
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Resize all layers when the terminal is resized.
+   */
+  resize(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    for (const layer of this._layers.values()) {
+      layer.cells = this._createGrid();
+      layer.dirtyRegion = null;
+    }
+  }
+  /**
+   * Create an empty cell grid.
+   */
+  _createGrid() {
+    const grid = [];
+    for (let r = 0; r < this._rows; r++) {
+      const row = [];
+      for (let c = 0; c < this._cols; c++) {
+        row.push(emptyCell());
+      }
+      grid.push(row);
+    }
+    return grid;
+  }
+  /**
+   * Expand the dirty region of a layer to include the given cell.
+   */
+  _expandDirty(layer, col, row) {
+    if (!layer.dirtyRegion) {
+      layer.dirtyRegion = { x: col, y: row, width: 1, height: 1 };
+      return;
+    }
+    const r = layer.dirtyRegion;
+    const newX = Math.min(r.x, col);
+    const newY = Math.min(r.y, row);
+    const newRight = Math.max(r.x + r.width, col + 1);
+    const newBottom = Math.max(r.y + r.height, row + 1);
+    r.x = newX;
+    r.y = newY;
+    r.width = newRight - newX;
+    r.height = newBottom - newY;
+  }
+};
+
+// src/events/types.ts
+function createKeyEvent(base) {
+  const event = {
+    ...base,
+    _propagationStopped: false,
+    _defaultPrevented: false,
+    stopPropagation() {
+      this._propagationStopped = true;
+    },
+    preventDefault() {
+      this._defaultPrevented = true;
+    }
+  };
+  return event;
+}
+
+// src/input/KeyMap.ts
+var ESCAPE_SEQUENCES = {
+  // Arrow keys
+  "\x1B[A": "up",
+  "\x1B[B": "down",
+  "\x1B[C": "right",
+  "\x1B[D": "left",
+  // Shift+Arrow
+  "\x1B[1;2A": "shift+up",
+  "\x1B[1;2B": "shift+down",
+  "\x1B[1;2C": "shift+right",
+  "\x1B[1;2D": "shift+left",
+  // Ctrl+Arrow
+  "\x1B[1;5A": "ctrl+up",
+  "\x1B[1;5B": "ctrl+down",
+  "\x1B[1;5C": "ctrl+right",
+  "\x1B[1;5D": "ctrl+left",
+  // Alt+Arrow
+  "\x1B[1;3A": "alt+up",
+  "\x1B[1;3B": "alt+down",
+  "\x1B[1;3C": "alt+right",
+  "\x1B[1;3D": "alt+left",
+  // Home/End/Insert/Delete/PageUp/PageDown
+  "\x1B[H": "home",
+  "\x1B[F": "end",
+  "\x1B[2~": "insert",
+  "\x1B[3~": "delete",
+  "\x1B[5~": "pageup",
+  "\x1B[6~": "pagedown",
+  // Alternate Home/End (some terminals)
+  "\x1B[1~": "home",
+  "\x1B[4~": "end",
+  "\x1BOH": "home",
+  "\x1BOF": "end",
+  // Function keys
+  "\x1BOP": "f1",
+  "\x1BOQ": "f2",
+  "\x1BOR": "f3",
+  "\x1BOS": "f4",
+  "\x1B[15~": "f5",
+  "\x1B[17~": "f6",
+  "\x1B[18~": "f7",
+  "\x1B[19~": "f8",
+  "\x1B[20~": "f9",
+  "\x1B[21~": "f10",
+  "\x1B[23~": "f11",
+  "\x1B[24~": "f12",
+  // Special keys
+  "\x1B[Z": "shift+tab"
+};
+var CTRL_KEYS = {
+  1: "a",
+  2: "b",
+  3: "c",
+  4: "d",
+  5: "e",
+  6: "f",
+  7: "g",
+  8: "backspace",
+  9: "tab",
+  10: "enter",
+  11: "k",
+  12: "l",
+  13: "enter",
+  14: "n",
+  15: "o",
+  16: "p",
+  17: "q",
+  18: "r",
+  19: "s",
+  20: "t",
+  21: "u",
+  22: "v",
+  23: "w",
+  24: "x",
+  25: "y",
+  26: "z"
+};
+var SPECIAL_KEYS = {
+  27: "escape",
+  127: "backspace",
+  9: "tab",
+  13: "enter",
+  10: "enter",
+  32: "space"
+};
+
+// src/input/MouseParser.ts
+function parseMouseEvent(data) {
+  const match = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
+  if (!match) return null;
+  const cb = parseInt(match[1], 10);
+  const cx = parseInt(match[2], 10) - 1;
+  const cy = parseInt(match[3], 10) - 1;
+  const isRelease = match[4] === "m";
+  let button;
+  let type;
+  let scrollDelta;
+  const buttonBits = cb & 3;
+  const motion = (cb & 32) !== 0;
+  const isScroll = (cb & 64) !== 0;
+  if (isScroll) {
+    button = "none";
+    type = "scroll";
+    scrollDelta = buttonBits === 0 ? -1 : 1;
+  } else if (motion) {
+    type = "mousemove";
+    button = decodeButton(buttonBits);
+  } else if (isRelease) {
+    type = "mouseup";
+    button = decodeButton(buttonBits);
+  } else {
+    type = "mousedown";
+    button = decodeButton(buttonBits);
+  }
+  return {
+    x: cx,
+    y: cy,
+    button,
+    type,
+    scrollDelta
+  };
+}
+function decodeButton(bits) {
+  switch (bits) {
+    case 0:
+      return "left";
+    case 1:
+      return "middle";
+    case 2:
+      return "right";
+    default:
+      return "none";
+  }
+}
+function isMouseSequence(data) {
+  return data.startsWith("\x1B[<");
+}
+
+// src/events/EventEmitter.ts
+var EventEmitter = class {
+  _handlers = /* @__PURE__ */ new Map();
+  _onceHandlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to an event.
+   * @returns Unsubscribe function.
+   */
+  on(event, handler) {
+    if (!this._handlers.has(event)) {
+      this._handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._handlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Subscribe to an event, but only fire once.
+   */
+  once(event, handler) {
+    if (!this._onceHandlers.has(event)) {
+      this._onceHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this._onceHandlers.get(event).add(handler);
+    return () => {
+      this._onceHandlers.get(event)?.delete(handler);
+    };
+  }
+  /**
+   * Unsubscribe from an event.
+   */
+  off(event, handler) {
+    this._handlers.get(event)?.delete(handler);
+    this._onceHandlers.get(event)?.delete(handler);
+  }
+  /**
+   * Emit an event to all subscribed handlers.
+   */
+  emit(event, data) {
+    const handlers = this._handlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(data);
+      }
+    }
+    const onceHandlers = this._onceHandlers.get(event);
+    if (onceHandlers) {
+      for (const handler of onceHandlers) {
+        handler(data);
+      }
+      onceHandlers.clear();
+    }
+  }
+  /**
+   * Remove all handlers for a specific event, or all events if no event specified.
+   */
+  removeAll(event) {
+    if (event) {
+      this._handlers.delete(event);
+      this._onceHandlers.delete(event);
+    } else {
+      this._handlers.clear();
+      this._onceHandlers.clear();
+    }
+  }
+  /**
+   * Check if there are any handlers for an event.
+   */
+  hasListeners(event) {
+    return (this._handlers.get(event)?.size ?? 0) > 0 || (this._onceHandlers.get(event)?.size ?? 0) > 0;
+  }
+};
+
+// src/input/InputParser.ts
+var InputParser = class {
+  _events = new EventEmitter();
+  _stdin;
+  _handler = null;
+  _escapeTimeout = null;
+  _escapeBuffer = "";
+  constructor(stdin) {
+    this._stdin = stdin;
+  }
+  /** Subscribe to key events */
+  onKey(handler) {
+    return this._events.on("key", handler);
+  }
+  /** Subscribe to mouse events */
+  onMouse(handler) {
+    return this._events.on("mouse", handler);
+  }
+  /** Start listening for input */
+  start() {
+    if (this._handler) return;
+    this._handler = (data) => {
+      this._processInput(data);
+    };
+    this._stdin.on("data", this._handler);
+  }
+  /** Stop listening for input */
+  stop() {
+    if (this._handler) {
+      this._stdin.off("data", this._handler);
+      this._handler = null;
+    }
+    if (this._escapeTimeout) {
+      clearTimeout(this._escapeTimeout);
+      this._escapeTimeout = null;
+    }
+    this._escapeBuffer = "";
+  }
+  /**
+   * Process a chunk of raw input bytes.
+   */
+  _processInput(data) {
+    const str = data.toString("utf8");
+    if (this._escapeBuffer) {
+      this._escapeBuffer += str;
+      if (this._escapeTimeout) {
+        clearTimeout(this._escapeTimeout);
+        this._escapeTimeout = null;
+      }
+      this._tryParseEscape(data);
+      return;
+    }
+    if (str.startsWith("\x1B") && str.length === 1) {
+      this._escapeBuffer = str;
+      this._escapeTimeout = setTimeout(() => {
+        this._events.emit("key", createKeyEvent({
+          key: "escape",
+          raw: Buffer.from(this._escapeBuffer),
+          ctrl: false,
+          alt: false,
+          shift: false
+        }));
+        this._escapeBuffer = "";
+        this._escapeTimeout = null;
+      }, 50);
+      return;
+    }
+    if (str.startsWith("\x1B")) {
+      this._escapeBuffer = str;
+      this._tryParseEscape(data);
+      return;
+    }
+    for (let i = 0; i < str.length; i++) {
+      const ch = str[i];
+      const code = str.charCodeAt(i);
+      const raw = Buffer.from(ch, "utf8");
+      if (code >= 1 && code <= 26) {
+        const keyName = CTRL_KEYS[code];
+        const isCtrl = code !== 9 && code !== 13 && code !== 10;
+        this._events.emit("key", createKeyEvent({
+          key: keyName || String.fromCharCode(code + 96),
+          raw,
+          ctrl: isCtrl,
+          alt: false,
+          shift: false
+        }));
+        continue;
+      }
+      if (code in SPECIAL_KEYS) {
+        this._events.emit("key", createKeyEvent({
+          key: SPECIAL_KEYS[code],
+          raw,
+          ctrl: false,
+          alt: false,
+          shift: false
+        }));
+        continue;
+      }
+      if (code >= 32) {
+        this._events.emit("key", createKeyEvent({
+          key: ch,
+          raw,
+          ctrl: false,
+          alt: false,
+          shift: ch !== ch.toLowerCase() && ch === ch.toUpperCase()
+        }));
+      }
+    }
+  }
+  /**
+   * Try to parse buffered escape sequence.
+   */
+  _tryParseEscape(rawData) {
+    const seq = this._escapeBuffer;
+    if (isMouseSequence(seq)) {
+      const mouseEvt = parseMouseEvent(seq);
+      if (mouseEvt) {
+        this._events.emit("mouse", mouseEvt);
+        this._escapeBuffer = "";
+        return;
+      }
+      if (seq.length < 20) {
+        this._escapeTimeout = setTimeout(() => {
+          this._escapeBuffer = "";
+          this._escapeTimeout = null;
+        }, 100);
+        return;
+      }
+    }
+    if (seq in ESCAPE_SEQUENCES) {
+      const keyName = ESCAPE_SEQUENCES[seq];
+      const isShift = keyName.startsWith("shift+");
+      const isCtrl = keyName.startsWith("ctrl+");
+      const isAlt = keyName.startsWith("alt+");
+      const cleanKey = keyName.replace(/^(shift|ctrl|alt)\+/, "");
+      this._events.emit("key", createKeyEvent({
+        key: cleanKey,
+        raw: rawData,
+        ctrl: isCtrl,
+        alt: isAlt,
+        shift: isShift
+      }));
+      this._escapeBuffer = "";
+      return;
+    }
+    if (seq.length === 2 && seq[0] === "\x1B") {
+      const ch = seq[1];
+      this._events.emit("key", createKeyEvent({
+        key: ch,
+        raw: rawData,
+        ctrl: false,
+        alt: true,
+        shift: ch !== ch.toLowerCase() && ch === ch.toUpperCase()
+      }));
+      this._escapeBuffer = "";
+      return;
+    }
+    if (seq.length > 20) {
+      this._escapeBuffer = "";
+      return;
+    }
+    this._escapeTimeout = setTimeout(() => {
+      this._escapeBuffer = "";
+      this._escapeTimeout = null;
+    }, 100);
+  }
+};
+
+// src/style/Style.ts
+function normalizeEdges(value) {
+  if (value === void 0) return { top: 0, right: 0, bottom: 0, left: 0 };
+  if (typeof value === "number") {
+    return { top: value, right: value, bottom: value, left: value };
+  }
+  return {
+    top: value.top ?? 0,
+    right: value.right ?? 0,
+    bottom: value.bottom ?? 0,
+    left: value.left ?? 0
+  };
+}
+function mergeStyles(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const val = override[key];
+    if (val !== void 0) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function defaultStyle() {
+  return {
+    visible: true,
+    flexDirection: "column",
+    justifyContent: "flex-start",
+    alignItems: "stretch",
+    flexGrow: 0,
+    flexShrink: 1,
+    flexWrap: "nowrap",
+    overflow: "hidden",
+    gap: 0
+  };
+}
+function styleToCellAttrs(style) {
+  return {
+    fg: style.fg ?? { type: "none" },
+    bg: style.bg ?? { type: "none" },
+    bold: style.bold ?? false,
+    italic: style.italic ?? false,
+    underline: style.underline ?? false,
+    dim: style.dim ?? false,
+    strikethrough: style.strikethrough ?? false,
+    inverse: style.inverse ?? false
+  };
+}
+
+// src/style/Border.ts
+var BORDER_CHARS = {
+  single: {
+    topLeft: "\u250C",
+    top: "\u2500",
+    topRight: "\u2510",
+    right: "\u2502",
+    bottomRight: "\u2518",
+    bottom: "\u2500",
+    bottomLeft: "\u2514",
+    left: "\u2502"
+  },
+  double: {
+    topLeft: "\u2554",
+    top: "\u2550",
+    topRight: "\u2557",
+    right: "\u2551",
+    bottomRight: "\u255D",
+    bottom: "\u2550",
+    bottomLeft: "\u255A",
+    left: "\u2551"
+  },
+  round: {
+    topLeft: "\u256D",
+    top: "\u2500",
+    topRight: "\u256E",
+    right: "\u2502",
+    bottomRight: "\u256F",
+    bottom: "\u2500",
+    bottomLeft: "\u2570",
+    left: "\u2502"
+  },
+  heavy: {
+    topLeft: "\u250F",
+    top: "\u2501",
+    topRight: "\u2513",
+    right: "\u2503",
+    bottomRight: "\u251B",
+    bottom: "\u2501",
+    bottomLeft: "\u2517",
+    left: "\u2503"
+  },
+  dashed: {
+    topLeft: "\u250C",
+    top: "\u2504",
+    topRight: "\u2510",
+    right: "\u2506",
+    bottomRight: "\u2518",
+    bottom: "\u2504",
+    bottomLeft: "\u2514",
+    left: "\u2506"
+  }
+};
+function getBorderChars(style, customChars) {
+  if (style === "none") return null;
+  if (style === "custom") {
+    const base = BORDER_CHARS.single;
+    return { ...base, ...customChars };
+  }
+  return BORDER_CHARS[style];
+}
+function borderSize(style) {
+  if (style === "none") return { horizontal: 0, vertical: 0 };
+  return { horizontal: 2, vertical: 2 };
+}
+
+// src/layout/LayoutEngine.ts
+function createLayoutNode(id, style, children = []) {
+  return {
+    id,
+    style,
+    children,
+    computed: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+function computeLayout(root, containerWidth, containerHeight) {
+  root.computed = { x: 0, y: 0, width: containerWidth, height: containerHeight };
+  layoutNode(root, containerWidth, containerHeight);
+}
+function layoutNode(node, availWidth, availHeight, precomputed = false) {
+  const style = node.style;
+  const padding = normalizeEdges(style.padding);
+  const margin = normalizeEdges(style.margin);
+  const border = borderSize(style.border ?? "none");
+  if (!precomputed) {
+    let nodeWidth2 = resolveSize(style.width, availWidth);
+    let nodeHeight2 = resolveSize(style.height, availHeight);
+    if (nodeWidth2 === void 0) nodeWidth2 = availWidth - margin.left - margin.right;
+    if (nodeHeight2 === void 0) nodeHeight2 = availHeight - margin.top - margin.bottom;
+    nodeWidth2 = clampSize(nodeWidth2, style.minWidth, style.maxWidth);
+    nodeHeight2 = clampSize(nodeHeight2, style.minHeight, style.maxHeight);
+    node.computed.width = nodeWidth2;
+    node.computed.height = nodeHeight2;
+  }
+  if (node.children.length === 0) return;
+  const nodeWidth = node.computed.width;
+  const nodeHeight = node.computed.height;
+  const innerX = padding.left + border.horizontal / 2;
+  const innerY = padding.top + border.vertical / 2;
+  const innerWidth = Math.max(0, nodeWidth - padding.left - padding.right - border.horizontal);
+  const innerHeight = Math.max(0, nodeHeight - padding.top - padding.bottom - border.vertical);
+  const direction = style.flexDirection ?? "column";
+  const isRow = direction === "row";
+  const gap = style.gap ?? 0;
+  const childInfos = [];
+  let totalFixed = 0;
+  let totalGrow = 0;
+  let totalShrink = 0;
+  for (const child of node.children) {
+    if (child.style.visible === false) continue;
+    const childMargin = normalizeEdges(child.style.margin);
+    const childBorder = borderSize(child.style.border ?? "none");
+    const grow = child.style.flexGrow ?? 0;
+    const shrink = child.style.flexShrink ?? 1;
+    let mainSize;
+    let crossSize;
+    if (isRow) {
+      mainSize = resolveSize(child.style.width, innerWidth) ?? 0;
+      crossSize = resolveSize(child.style.height, innerHeight) ?? innerHeight;
+      mainSize += childMargin.left + childMargin.right;
+      crossSize = clampSize(crossSize, child.style.minHeight, child.style.maxHeight);
+    } else {
+      mainSize = resolveSize(child.style.height, innerHeight) ?? 0;
+      crossSize = resolveSize(child.style.width, innerWidth) ?? innerWidth;
+      mainSize += childMargin.top + childMargin.bottom;
+      crossSize = clampSize(crossSize, child.style.minWidth, child.style.maxWidth);
+    }
+    totalFixed += mainSize;
+    totalGrow += grow;
+    totalShrink += shrink;
+    childInfos.push({ node: child, mainSize, crossSize, flexGrow: grow, flexShrink: shrink, margin: childMargin });
+  }
+  const totalGaps = Math.max(0, childInfos.length - 1) * gap;
+  const mainAvail = isRow ? innerWidth : innerHeight;
+  const freeSpace = mainAvail - totalFixed - totalGaps;
+  if (freeSpace > 0 && totalGrow > 0) {
+    for (const info of childInfos) {
+      if (info.flexGrow > 0) {
+        info.mainSize += info.flexGrow / totalGrow * freeSpace;
+      }
+    }
+  } else if (freeSpace < 0 && totalShrink > 0) {
+    for (const info of childInfos) {
+      if (info.flexShrink > 0) {
+        info.mainSize += info.flexShrink / totalShrink * freeSpace;
+        info.mainSize = Math.max(0, info.mainSize);
+      }
+    }
+  }
+  const totalMainUsed = childInfos.reduce((sum, i) => sum + i.mainSize, 0) + totalGaps;
+  const remainingSpace = Math.max(0, mainAvail - totalMainUsed);
+  let mainOffset;
+  let spaceBetween = 0;
+  const justify = style.justifyContent ?? "flex-start";
+  switch (justify) {
+    case "flex-start":
+      mainOffset = 0;
+      break;
+    case "flex-end":
+      mainOffset = remainingSpace;
+      break;
+    case "center":
+      mainOffset = remainingSpace / 2;
+      break;
+    case "space-between":
+      mainOffset = 0;
+      spaceBetween = childInfos.length > 1 ? remainingSpace / (childInfos.length - 1) : 0;
+      break;
+    case "space-around":
+      spaceBetween = childInfos.length > 0 ? remainingSpace / childInfos.length : 0;
+      mainOffset = spaceBetween / 2;
+      break;
+    default:
+      mainOffset = 0;
+  }
+  const crossAvail = isRow ? innerHeight : innerWidth;
+  const align = style.alignItems ?? "stretch";
+  for (const info of childInfos) {
+    let crossOffset;
+    let finalCrossSize = info.crossSize;
+    switch (align) {
+      case "flex-start":
+        crossOffset = 0;
+        break;
+      case "flex-end":
+        crossOffset = crossAvail - finalCrossSize;
+        break;
+      case "center":
+        crossOffset = (crossAvail - finalCrossSize) / 2;
+        break;
+      case "stretch":
+        crossOffset = 0;
+        finalCrossSize = crossAvail;
+        break;
+      default:
+        crossOffset = 0;
+    }
+    if (isRow) {
+      info.node.computed = {
+        x: node.computed.x + innerX + mainOffset + info.margin.left,
+        y: node.computed.y + innerY + crossOffset + info.margin.top,
+        width: Math.max(0, info.mainSize - info.margin.left - info.margin.right),
+        height: Math.max(0, finalCrossSize - info.margin.top - info.margin.bottom)
+      };
+    } else {
+      info.node.computed = {
+        x: node.computed.x + innerX + crossOffset + info.margin.left,
+        y: node.computed.y + innerY + mainOffset + info.margin.top,
+        width: Math.max(0, finalCrossSize - info.margin.left - info.margin.right),
+        height: Math.max(0, info.mainSize - info.margin.top - info.margin.bottom)
+      };
+    }
+    mainOffset += info.mainSize + gap + spaceBetween;
+    layoutNode(info.node, info.node.computed.width, info.node.computed.height, true);
+  }
+}
+function resolveSize(value, available) {
+  if (value === void 0) return void 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.endsWith("%")) {
+    const pct = parseFloat(value) / 100;
+    return Math.floor(available * pct);
+  }
+  return void 0;
+}
+function clampSize(value, min, max) {
+  let result = value;
+  if (min !== void 0) result = Math.max(result, min);
+  if (max !== void 0) result = Math.min(result, max);
+  return result;
+}
+
+// src/layout/Rect.ts
+function emptyRect() {
+  return { x: 0, y: 0, width: 0, height: 0 };
+}
+function containsPoint(rect, x, y) {
+  return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height;
+}
+function shrinkRect(rect, top, right, bottom, left) {
+  return {
+    x: rect.x + left,
+    y: rect.y + top,
+    width: Math.max(0, rect.width - left - right),
+    height: Math.max(0, rect.height - top - bottom)
+  };
+}
+function intersectRect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const r = Math.min(a.x + a.width, b.x + b.width);
+  const bot = Math.min(a.y + a.height, b.y + b.height);
+  if (r <= x || bot <= y) return null;
+  return { x, y, width: r - x, height: bot - y };
+}
+function unionRect(a, b) {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  const r = Math.max(a.x + a.width, b.x + b.width);
+  const bot = Math.max(a.y + a.height, b.y + b.height);
+  return { x, y, width: r - x, height: bot - y };
+}
+
+// src/events/FocusManager.ts
+var FocusManager = class {
+  _focusables = [];
+  _currentIndex = -1;
+  _events = new EventEmitter();
+  /**
+   * Stack of trap container IDs. When non-empty, only focusables
+   * that belong to the topmost trap container are reachable via Tab.
+   */
+  _trapStack = [];
+  /**
+   * Map of container ID → child widget IDs that belong to it.
+   * Used for trap membership lookup.
+   */
+  _containerMembers = /* @__PURE__ */ new Map();
+  /**
+   * Named focus groups. Arrow keys move within a group, Tab moves between groups.
+   * Maps groupId → ordered list of widget IDs.
+   */
+  _groups = /* @__PURE__ */ new Map();
+  /** Currently focused widget ID, or null if none */
+  get currentId() {
+    if (this._currentIndex < 0 || this._currentIndex >= this._focusables.length) {
+      return null;
+    }
+    return this._focusables[this._currentIndex].id;
+  }
+  /** Subscribe to focus/blur events */
+  on(event, handler) {
+    return this._events.on(event, handler);
+  }
+  /**
+   * Register a focusable widget.
+   * Widgets are ordered by tabIndex (ascending), then insertion order.
+   */
+  register(focusable) {
+    this._focusables.push(focusable);
+    this._focusables.sort((a, b) => a.tabIndex - b.tabIndex);
+    if (this._currentIndex < 0 && focusable.focusable) {
+      this._currentIndex = this._focusables.indexOf(focusable);
+      this._events.emit("focus", { targetId: focusable.id, type: "focus" });
+    }
+  }
+  /**
+   * Unregister a focusable widget.
+   */
+  unregister(id) {
+    const idx = this._focusables.findIndex((f) => f.id === id);
+    if (idx < 0) return;
+    const wasFocused = idx === this._currentIndex;
+    this._focusables.splice(idx, 1);
+    if (wasFocused) {
+      this._events.emit("blur", { targetId: id, type: "blur" });
+      if (this._focusables.length > 0) {
+        this._currentIndex = Math.min(this._currentIndex, this._focusables.length - 1);
+        this._events.emit("focus", {
+          targetId: this._focusables[this._currentIndex].id,
+          type: "focus"
+        });
+      } else {
+        this._currentIndex = -1;
+      }
+    } else if (idx < this._currentIndex) {
+      this._currentIndex--;
+    }
+  }
+  /**
+   * Move focus to the next focusable widget (wraps around).
+   * Respects focus traps — if a trap is active, only cycles within it.
+   */
+  focusNext() {
+    const candidates = this._getActiveFocusables();
+    if (candidates.length === 0) return;
+    const currentInCandidates = this.currentId ? candidates.findIndex((f) => f.id === this.currentId) : -1;
+    let next = (currentInCandidates + 1) % candidates.length;
+    const start = next;
+    while (!candidates[next].focusable) {
+      next = (next + 1) % candidates.length;
+      if (next === start) return;
+    }
+    const masterIdx = this._focusables.findIndex((f) => f.id === candidates[next].id);
+    if (masterIdx >= 0) this._changeFocus(masterIdx);
+  }
+  /**
+   * Move focus to the previous focusable widget (wraps around).
+   * Respects focus traps.
+   */
+  focusPrev() {
+    const candidates = this._getActiveFocusables();
+    if (candidates.length === 0) return;
+    const currentInCandidates = this.currentId ? candidates.findIndex((f) => f.id === this.currentId) : 0;
+    let prev = (currentInCandidates - 1 + candidates.length) % candidates.length;
+    const start = prev;
+    while (!candidates[prev].focusable) {
+      prev = (prev - 1 + candidates.length) % candidates.length;
+      if (prev === start) return;
+    }
+    const masterIdx = this._focusables.findIndex((f) => f.id === candidates[prev].id);
+    if (masterIdx >= 0) this._changeFocus(masterIdx);
+  }
+  /**
+   * Focus a specific widget by ID.
+   */
+  focusWidget(id) {
+    const idx = this._focusables.findIndex((f) => f.id === id);
+    if (idx < 0 || !this._focusables[idx].focusable) return;
+    this._changeFocus(idx);
+  }
+  /**
+   * Check if a specific widget currently has focus.
+   */
+  isFocused(id) {
+    return this.currentId === id;
+  }
+  // ── Focus Trap ──────────────────────────────────────
+  /**
+   * Register widget IDs as members of a container (for trap lookup).
+   */
+  registerContainerMembers(containerId, memberIds) {
+    const set = this._containerMembers.get(containerId) ?? /* @__PURE__ */ new Set();
+    for (const id of memberIds) set.add(id);
+    this._containerMembers.set(containerId, set);
+  }
+  /**
+   * Unregister a container's member list.
+   */
+  unregisterContainerMembers(containerId) {
+    this._containerMembers.delete(containerId);
+  }
+  /**
+   * Trap focus within a container. Only focusables inside the
+   * container are reachable via Tab. Traps are stacked —
+   * nested modals create nested traps.
+   */
+  trap(containerId) {
+    this._trapStack.push(containerId);
+    const trapped = this._getActiveFocusables();
+    if (trapped.length > 0) {
+      const first = trapped.find((f) => f.focusable);
+      if (first) {
+        const idx = this._focusables.findIndex((f) => f.id === first.id);
+        if (idx >= 0) this._changeFocus(idx);
+      }
+    }
+  }
+  /**
+   * Release the current focus trap. Restores previous trap or free navigation.
+   */
+  release() {
+    this._trapStack.pop();
+  }
+  /** Whether a focus trap is currently active */
+  get isTrapped() {
+    return this._trapStack.length > 0;
+  }
+  /** ID of the current trap container, or null */
+  get currentTrapId() {
+    return this._trapStack.length > 0 ? this._trapStack[this._trapStack.length - 1] : null;
+  }
+  // ── Focus Groups ────────────────────────────────────
+  /**
+   * Register a focus group. Arrow keys move within the group.
+   * @param groupId   Unique group identifier
+   * @param widgetIds Ordered list of widget IDs in the group
+   */
+  registerGroup(groupId, widgetIds) {
+    this._groups.set(groupId, widgetIds);
+  }
+  /**
+   * Unregister a focus group.
+   */
+  unregisterGroup(groupId) {
+    this._groups.delete(groupId);
+  }
+  /**
+   * Move focus to the next widget within the same group.
+   * Returns true if focus was moved, false if the widget isn't in a group.
+   */
+  focusNextInGroup() {
+    const currentId = this.currentId;
+    if (!currentId) return false;
+    for (const [, ids] of this._groups) {
+      const idx = ids.indexOf(currentId);
+      if (idx >= 0) {
+        const nextIdx = (idx + 1) % ids.length;
+        this.focusWidget(ids[nextIdx]);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Move focus to the previous widget within the same group.
+   */
+  focusPrevInGroup() {
+    const currentId = this.currentId;
+    if (!currentId) return false;
+    for (const [, ids] of this._groups) {
+      const idx = ids.indexOf(currentId);
+      if (idx >= 0) {
+        const prevIdx = (idx - 1 + ids.length) % ids.length;
+        this.focusWidget(ids[prevIdx]);
+        return true;
+      }
+    }
+    return false;
+  }
+  // ── Private ──────────────────────────────────────────
+  /**
+   * Get the active focusables, filtered by the current trap if any.
+   */
+  _getActiveFocusables() {
+    if (this._trapStack.length === 0) return this._focusables;
+    const containerId = this._trapStack[this._trapStack.length - 1];
+    const members = this._containerMembers.get(containerId);
+    if (!members) return this._focusables;
+    return this._focusables.filter((f) => members.has(f.id));
+  }
+  _changeFocus(newIndex) {
+    const oldId = this.currentId;
+    if (oldId) {
+      this._events.emit("blur", { targetId: oldId, type: "blur" });
+    }
+    this._currentIndex = newIndex;
+    this._events.emit("focus", {
+      targetId: this._focusables[newIndex].id,
+      type: "focus"
+    });
+  }
+};
+
+// src/app/Fallback.ts
+function shouldUseFallback() {
+  if (!process.stdout.isTTY) return true;
+  if (process.env["CI"]) return true;
+  if (process.env["TERM"] === "dumb") return true;
+  return false;
+}
+function renderFallback(screen) {
+  const lines = [];
+  for (let r = 0; r < screen.rows; r++) {
+    let line = "";
+    for (let c = 0; c < screen.cols; c++) {
+      const cell = screen.back[r][c];
+      if (cell.width === 0) continue;
+      line += cell.char || " ";
+    }
+    lines.push(line.trimEnd());
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  return lines.join("\n");
+}
+
+// src/app/App.ts
+var App = class {
+  terminal;
+  screen;
+  renderer;
+  input;
+  focus;
+  events;
+  layers;
+  _rootWidget;
+  _options;
+  _mounted = false;
+  _exitResolve = null;
+  constructor(rootWidget, options = {}) {
+    this._rootWidget = rootWidget;
+    this._options = {
+      fullscreen: true,
+      mouse: false,
+      fps: 30,
+      ...options
+    };
+    this.terminal = new Terminal(options);
+    this.screen = new Screen(this.terminal.cols, this.terminal.rows);
+    this.renderer = new Renderer(this.terminal, this.screen, this._options.fps);
+    this.input = new InputParser(this.terminal.stdin);
+    this.focus = new FocusManager();
+    this.events = new EventEmitter();
+    this.layers = new LayerManager(this.terminal.cols, this.terminal.rows);
+  }
+  /**
+   * Start the application.
+   * Sets up the terminal, starts the render loop, and mounts the root widget.
+   * Returns a promise that resolves when exit() is called.
+   */
+  async mount() {
+    if (this._mounted) return 0;
+    if (this._options.forceFallback || shouldUseFallback()) {
+      this._renderFallback();
+      return 0;
+    }
+    this._mounted = true;
+    this.terminal.enterRawMode();
+    if (this._options.fullscreen) {
+      this.terminal.enterAltScreen();
+    }
+    this.terminal.hideCursor();
+    if (this._options.mouse) {
+      this.terminal.enableMouse();
+    }
+    if (this._options.title) {
+      this.terminal.write(`\x1B]0;${this._options.title}\x07`);
+    }
+    this.terminal.onResize((cols, rows) => {
+      this.screen.resize(cols, rows);
+      this.screen.invalidate();
+      this.layers.resize(cols, rows);
+      this.events.emit("resize", { cols, rows });
+      this.requestRender();
+    });
+    this.input.start();
+    this.input.onKey((rawEvent) => {
+      const event = createKeyEvent({
+        ...rawEvent,
+        targetId: this.focus.currentId ?? void 0
+      });
+      const focusedId = this.focus.currentId;
+      if (focusedId) {
+        const chain = this._buildBubbleChain(focusedId);
+        for (const widget of chain) {
+          widget.events.emit("key", event);
+          if (event._propagationStopped) break;
+        }
+      }
+      if (!event._defaultPrevented) {
+        if (event.key === "tab" && !event.ctrl && !event.alt) {
+          if (event.shift) {
+            this.focus.focusPrev();
+          } else {
+            this.focus.focusNext();
+          }
+        }
+      }
+      if (!event._propagationStopped) {
+        this.events.emit("key", event);
+      }
+    });
+    this.input.onMouse((event) => {
+      this.events.emit("mouse", event);
+    });
+    this.renderer.start();
+    this._rootWidget.mount?.();
+    this.events.emit("mount", void 0);
+    this.screen.invalidate();
+    this.requestRender();
+    return new Promise((resolve) => {
+      this._exitResolve = resolve;
+    });
+  }
+  /**
+   * Stop the application and restore terminal state.
+   */
+  unmount() {
+    if (!this._mounted) return;
+    this._mounted = false;
+    this._rootWidget.unmount?.();
+    this.events.emit("unmount", void 0);
+    this.renderer.stop();
+    this.input.stop();
+    this.terminal.restore();
+    this.events.removeAll();
+  }
+  /**
+   * Create an overlay layer for rendering above normal widgets.
+   * @param id     Unique layer identifier (e.g. 'modal', 'select-dropdown', 'toast')
+   * @param zIndex Stacking order (higher = rendered on top). Default: 100
+   */
+  addOverlay(id, zIndex = 100) {
+    this.layers.createLayer(id, zIndex);
+  }
+  /**
+   * Remove an overlay layer.
+   */
+  removeOverlay(id) {
+    this.layers.removeLayer(id);
+  }
+  /**
+   * Request a re-render on the next frame.
+   */
+  requestRender() {
+    if (!this._mounted) return;
+    const layoutRoot = this._rootWidget.getLayoutNode();
+    computeLayout(layoutRoot, this.terminal.cols, this.terminal.rows);
+    this._rootWidget.syncLayout?.();
+    this.screen.clear();
+    this._rootWidget.render(this.screen);
+    this.layers.composite(this.screen);
+    this.renderer.requestFrame();
+  }
+  /**
+   * Exit the app (convenience method).
+   */
+  exit(code = 0) {
+    this.unmount();
+    if (this._exitResolve) {
+      this._exitResolve(code);
+      this._exitResolve = null;
+    } else {
+      process.exit(code);
+    }
+  }
+  /**
+   * Render in fallback (static) mode for non-interactive environments.
+   */
+  _renderFallback() {
+    const layoutRoot = this._rootWidget.getLayoutNode();
+    computeLayout(layoutRoot, this.terminal.cols, this.terminal.rows);
+    this._rootWidget.syncLayout?.();
+    this.screen.clear();
+    this._rootWidget.render(this.screen);
+    const output = renderFallback(this.screen);
+    this.terminal.write(output + "\n");
+  }
+  /**
+   * Build the bubble chain for keyboard events.
+   * Returns an array: [focused widget, parent, grandparent, ..., root]
+   */
+  _buildBubbleChain(widgetId) {
+    const chain = [];
+    const widget = this._findWidgetById(this._rootWidget, widgetId);
+    if (!widget) return chain;
+    let current = widget;
+    while (current) {
+      if (current.events) {
+        chain.push(current);
+      }
+      current = current.parent ?? null;
+    }
+    return chain;
+  }
+  /**
+   * Find a widget by ID in the widget tree (DFS).
+   * Uses duck-typing to work with any object that has id/children.
+   */
+  _findWidgetById(root, id) {
+    if (root.id === id) return root;
+    const children = root._children ?? root.children ?? [];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        const found = this._findWidgetById(child, id);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+};
+
+// src/utils/unicode.ts
+function isWideChar(codePoint) {
+  return (
+    // CJK Unified Ideographs (common Chinese/Japanese/Korean)
+    codePoint >= 19968 && codePoint <= 40959 || // CJK Unified Ideographs Extension A
+    codePoint >= 13312 && codePoint <= 19903 || // CJK Compatibility Ideographs
+    codePoint >= 63744 && codePoint <= 64255 || // Hangul Syllables
+    codePoint >= 44032 && codePoint <= 55215 || // Katakana
+    codePoint >= 12448 && codePoint <= 12543 || // CJK Symbols and Punctuation
+    codePoint >= 12288 && codePoint <= 12351 || // Hiragana
+    codePoint >= 12352 && codePoint <= 12447 || // Fullwidth Forms
+    codePoint >= 65281 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || // CJK Unified Ideographs Extension B
+    codePoint >= 131072 && codePoint <= 173791 || // CJK Unified Ideographs Extension C,D,E,F
+    codePoint >= 173824 && codePoint <= 191471 || // CJK Compatibility Ideographs Supplement
+    codePoint >= 194560 && codePoint <= 195103
+  );
+}
+function isCombining(codePoint) {
+  return (
+    // Combining Diacritical Marks
+    codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks Extended
+    codePoint >= 6832 && codePoint <= 6911 || // Combining Diacritical Marks Supplement
+    codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks for Symbols
+    codePoint >= 8400 && codePoint <= 8447 || // Combining Half Marks
+    codePoint >= 65056 && codePoint <= 65071 || // Variation selectors
+    codePoint >= 65024 && codePoint <= 65039 || // Zero-width joiner / non-joiner
+    codePoint === 8203 || codePoint === 8204 || codePoint === 8205 || codePoint === 65279
+  );
+}
+function isEmoji(codePoint) {
+  return (
+    // Emoticons
+    codePoint >= 128512 && codePoint <= 128591 || // Misc Symbols and Pictographs
+    codePoint >= 127744 && codePoint <= 128511 || // Transport and Map
+    codePoint >= 128640 && codePoint <= 128767 || // Supplemental Symbols
+    codePoint >= 129280 && codePoint <= 129535 || // Misc symbols
+    codePoint >= 9728 && codePoint <= 9983 || // Dingbats
+    codePoint >= 9984 && codePoint <= 10175 || // Flags
+    codePoint >= 127456 && codePoint <= 127487
+  );
+}
+function stringWidth(str) {
+  let width = 0;
+  let inEscape = false;
+  for (const char of str) {
+    const cp = char.codePointAt(0);
+    if (cp === 27) {
+      inEscape = true;
+      continue;
+    }
+    if (inEscape) {
+      if (cp >= 64 && cp <= 126 && cp !== 91) {
+        inEscape = false;
+      }
+      continue;
+    }
+    if (cp < 32 || cp >= 127 && cp < 160) {
+      continue;
+    }
+    if (isCombining(cp)) {
+      continue;
+    }
+    if (isWideChar(cp) || isEmoji(cp)) {
+      width += 2;
+      continue;
+    }
+    width += 1;
+  }
+  return width;
+}
+function truncate(str, maxWidth, ellipsis = "\u2026") {
+  if (maxWidth <= 0) return "";
+  const strW = stringWidth(str);
+  if (strW <= maxWidth) return str;
+  const ellipsisW = stringWidth(ellipsis);
+  const targetW = maxWidth - ellipsisW;
+  if (targetW <= 0) return ellipsis.slice(0, maxWidth);
+  let width = 0;
+  let result = "";
+  let inEscape = false;
+  let escapeBuffer = "";
+  for (const char of str) {
+    const cp = char.codePointAt(0);
+    if (cp === 27) {
+      inEscape = true;
+      escapeBuffer += char;
+      continue;
+    }
+    if (inEscape) {
+      escapeBuffer += char;
+      if (cp >= 64 && cp <= 126 && cp !== 91) {
+        inEscape = false;
+        result += escapeBuffer;
+        escapeBuffer = "";
+      }
+      continue;
+    }
+    let charW = 1;
+    if (isCombining(cp)) {
+      charW = 0;
+    } else if (isWideChar(cp) || isEmoji(cp)) {
+      charW = 2;
+    } else if (cp < 32 || cp >= 127 && cp < 160) {
+      charW = 0;
+    }
+    if (width + charW > targetW) break;
+    width += charW;
+    result += char;
+  }
+  return result + ellipsis;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function wordWrap(str, width) {
+  if (width <= 0) return str;
+  const lines = str.split("\n");
+  const result = [];
+  for (const line of lines) {
+    if (stringWidth(line) <= width) {
+      result.push(line);
+      continue;
+    }
+    let currentLine = "";
+    let currentWidth = 0;
+    const words = line.split(/(\s+)/);
+    for (const word of words) {
+      const wordW = stringWidth(word);
+      if (currentWidth + wordW <= width) {
+        currentLine += word;
+        currentWidth += wordW;
+      } else if (wordW > width) {
+        if (currentLine) {
+          result.push(currentLine);
+          currentLine = "";
+          currentWidth = 0;
+        }
+        for (const char of word) {
+          const cp = char.codePointAt(0);
+          const charW = isWideChar(cp) || isEmoji(cp) ? 2 : isCombining(cp) ? 0 : 1;
+          if (currentWidth + charW > width) {
+            result.push(currentLine);
+            currentLine = "";
+            currentWidth = 0;
+          }
+          currentLine += char;
+          currentWidth += charW;
+        }
+      } else {
+        result.push(currentLine);
+        currentLine = word.trimStart();
+        currentWidth = stringWidth(currentLine);
+      }
+    }
+    if (currentLine) {
+      result.push(currentLine);
+    }
+  }
+  return result.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  App,
+  BORDER_CHARS,
+  CTRL_KEYS,
+  ColorDepth,
+  ESCAPE_SEQUENCES,
+  EventEmitter,
+  FocusManager,
+  InputParser,
+  LayerManager,
+  Renderer,
+  SPECIAL_KEYS,
+  Screen,
+  Terminal,
+  ansi,
+  borderSize,
+  cellsEqual,
+  colorToAnsiBg,
+  colorToAnsiFg,
+  colorToRgb,
+  computeLayout,
+  containsPoint,
+  createKeyEvent,
+  createLayoutNode,
+  defaultStyle,
+  detectColorDepth,
+  emptyCell,
+  emptyRect,
+  getBorderChars,
+  intersectRect,
+  isMouseSequence,
+  mergeStyles,
+  normalizeEdges,
+  parseColor,
+  parseMouseEvent,
+  renderFallback,
+  shouldUseFallback,
+  shrinkRect,
+  stringWidth,
+  stripAnsi,
+  styleToCellAttrs,
+  truncate,
+  unionRect,
+  wordWrap
+});
+//# sourceMappingURL=index.cjs.map