terminal-richjs 0.1.0

package/dist/index.js

@@ -0,0 +1,2674 @@
+import process2 from 'process';
+import wrapAnsi from 'wrap-ansi';
+import terminalSize from 'terminal-size';
+import os from 'os';
+import stringWidth3 from 'string-width';
+import chalk from 'chalk';
+import tinycolor from 'tinycolor2';
+import fs from 'fs';
+import hljs from 'highlight.js';
+import ansiEscapes from 'ansi-escapes';
+import cliSpinners from 'cli-spinners';
+import boxes from 'cli-boxes';
+import readline from 'readline';
+import { marked } from 'marked';
+import TerminalRenderer from 'marked-terminal';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var Terminal = class {
+  constructor() {
+  }
+  get width() {
+    return terminalSize().columns;
+  }
+  get height() {
+    return terminalSize().rows;
+  }
+  get isInteractive() {
+    return !!process2.stdout.isTTY;
+  }
+  get isLegacyWindows() {
+    return os.platform() === "win32" && !process2.env.WT_SESSION;
+  }
+  get colorSystem() {
+    const env = process2.env;
+    if (env.NO_COLOR) return "none";
+    if (env.COLORTERM === "truecolor" || env.COLORTERM === "24bit") {
+      return "truecolor";
+    }
+    if (this.isLegacyWindows) {
+      return "standard";
+    }
+    if (env.TERM && env.TERM.includes("256")) {
+      return "256";
+    }
+    return "standard";
+  }
+};
+var Style = class _Style {
+  color;
+  backgroundColor;
+  bold;
+  italic;
+  underline;
+  strikethrough;
+  dim;
+  reverse;
+  blink;
+  hidden;
+  constructor(options = {}) {
+    this.color = options.color;
+    this.backgroundColor = options.backgroundColor;
+    this.bold = options.bold;
+    this.italic = options.italic;
+    this.underline = options.underline;
+    this.strikethrough = options.strikethrough;
+    this.dim = options.dim;
+    this.reverse = options.reverse;
+    this.blink = options.blink;
+    this.hidden = options.hidden;
+  }
+  static null() {
+    return new _Style({});
+  }
+  /**
+   * Parse a style string into a Style object.
+   * Supports:
+   * - Modifiers: bold, italic, underline, dim, strike, reverse, blink, hidden
+   * - Named colors: red, green, blue, cyan, magenta, yellow, white, black
+   * - Bright colors: bright_red, bright_green, etc.
+   * - Hex colors: #ff0000
+   * - RGB colors: rgb(255,0,0)
+   * - 256 colors: color(196)
+   * - Background: on red, on #ff0000, on rgb(255,0,0)
+   */
+  static parse(styleString) {
+    if (!styleString.trim()) return _Style.null();
+    const options = {};
+    const words = styleString.trim().split(/\s+/);
+    let i = 0;
+    while (i < words.length) {
+      const word = words[i];
+      if (word === "bold") {
+        options.bold = true;
+        i++;
+        continue;
+      }
+      if (word === "italic") {
+        options.italic = true;
+        i++;
+        continue;
+      }
+      if (word === "underline") {
+        options.underline = true;
+        i++;
+        continue;
+      }
+      if (word === "strike" || word === "strikethrough") {
+        options.strikethrough = true;
+        i++;
+        continue;
+      }
+      if (word === "dim") {
+        options.dim = true;
+        i++;
+        continue;
+      }
+      if (word === "reverse") {
+        options.reverse = true;
+        i++;
+        continue;
+      }
+      if (word === "blink") {
+        options.blink = true;
+        i++;
+        continue;
+      }
+      if (word === "hidden") {
+        options.hidden = true;
+        i++;
+        continue;
+      }
+      if (word === "on") {
+        if (i + 1 < words.length) {
+          const bgColor = _Style.parseColor(words[i + 1]);
+          if (bgColor !== null) {
+            options.backgroundColor = bgColor;
+            i += 2;
+            continue;
+          }
+        }
+        i++;
+        continue;
+      }
+      const color = _Style.parseColor(word);
+      if (color !== null) {
+        options.color = color;
+        i++;
+        continue;
+      }
+      i++;
+    }
+    return new _Style(options);
+  }
+  /**
+   * Parse a single color value.
+   * Supports hex (#ff0000), RGB (rgb(255,0,0)), 256-color (color(196)), and named colors.
+   */
+  static parseColor(word) {
+    if (word.startsWith("#")) {
+      if (/^#[0-9a-fA-F]{6}$/.test(word) || /^#[0-9a-fA-F]{3}$/.test(word)) {
+        return word;
+      }
+      return null;
+    }
+    const rgbMatch = word.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+    if (rgbMatch) {
+      return {
+        r: Math.min(255, parseInt(rgbMatch[1], 10)),
+        g: Math.min(255, parseInt(rgbMatch[2], 10)),
+        b: Math.min(255, parseInt(rgbMatch[3], 10))
+      };
+    }
+    const color256Match = word.match(/^color\(\s*(\d+)\s*\)$/i);
+    if (color256Match) {
+      return Math.min(255, parseInt(color256Match[1], 10));
+    }
+    const namedColors = [
+      "black",
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "white",
+      "gray",
+      "grey",
+      "blackBright",
+      "redBright",
+      "greenBright",
+      "yellowBright",
+      "blueBright",
+      "magentaBright",
+      "cyanBright",
+      "whiteBright",
+      // Underscore variants commonly used
+      "bright_black",
+      "bright_red",
+      "bright_green",
+      "bright_yellow",
+      "bright_blue",
+      "bright_magenta",
+      "bright_cyan",
+      "bright_white"
+    ];
+    let normalizedWord = word;
+    if (word.startsWith("bright_")) {
+      const base = word.slice(7);
+      normalizedWord = `${base}Bright`;
+    }
+    if (namedColors.includes(word) || namedColors.includes(normalizedWord)) {
+      return word;
+    }
+    if (/^[a-zA-Z]+$/.test(word)) {
+      return word;
+    }
+    return null;
+  }
+  combine(other) {
+    return new _Style({
+      color: other.color ?? this.color,
+      backgroundColor: other.backgroundColor ?? this.backgroundColor,
+      bold: other.bold ?? this.bold,
+      italic: other.italic ?? this.italic,
+      underline: other.underline ?? this.underline,
+      strikethrough: other.strikethrough ?? this.strikethrough,
+      dim: other.dim ?? this.dim,
+      reverse: other.reverse ?? this.reverse,
+      blink: other.blink ?? this.blink,
+      hidden: other.hidden ?? this.hidden
+    });
+  }
+  render(text) {
+    let result = chalk;
+    if (this.color) {
+      result = this.applyColor(result, this.color, false);
+    }
+    if (this.backgroundColor) {
+      result = this.applyColor(result, this.backgroundColor, true);
+    }
+    if (this.bold) result = result.bold;
+    if (this.italic) result = result.italic;
+    if (this.underline) result = result.underline;
+    if (this.strikethrough) result = result.strikethrough;
+    if (this.dim) result = result.dim;
+    if (this.reverse) result = result.inverse;
+    if (this.blink) result = result.blink;
+    if (this.hidden) result = result.hidden;
+    return result(text);
+  }
+  /**
+   * Apply a color to a chalk instance.
+   */
+  applyColor(chalkInstance, color, isBackground) {
+    if (typeof color === "string") {
+      if (color.startsWith("#")) {
+        return isBackground ? chalkInstance.bgHex(color) : chalkInstance.hex(color);
+      }
+      let colorName = color;
+      if (color.startsWith("bright_")) {
+        const base = color.slice(7);
+        colorName = `${base}Bright`;
+      }
+      if (isBackground) {
+        const bgMethod = `bg${colorName.charAt(0).toUpperCase()}${colorName.slice(1)}`;
+        if (bgMethod in chalkInstance) {
+          return chalkInstance[bgMethod];
+        }
+        const altMethod = `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+        if (altMethod in chalkInstance) {
+          return chalkInstance[altMethod];
+        }
+      } else {
+        if (colorName in chalkInstance) {
+          return chalkInstance[colorName];
+        }
+        if (color in chalkInstance) {
+          return chalkInstance[color];
+        }
+      }
+      return chalkInstance;
+    }
+    if (this.isRGB(color)) {
+      return isBackground ? chalkInstance.bgRgb(color.r, color.g, color.b) : chalkInstance.rgb(color.r, color.g, color.b);
+    }
+    if (typeof color === "number") {
+      return isBackground ? chalkInstance.bgAnsi256(color) : chalkInstance.ansi256(color);
+    }
+    return chalkInstance;
+  }
+  isRGB(color) {
+    return typeof color === "object" && color !== null && "r" in color && "g" in color && "b" in color;
+  }
+};
+
+// src/core/segment.ts
+var Segment = class _Segment {
+  constructor(text, style = Style.null(), isControl = false) {
+    this.text = text;
+    this.style = style;
+    this.isControl = isControl;
+  }
+  /**
+   * Implementation of Renderable protocol.
+   */
+  __rich_console__(_console, _options) {
+    return {
+      segments: [this],
+      width: this.cellLength()
+    };
+  }
+  /**
+   * Calculates the cell length of the text.
+   */
+  cellLength() {
+    if (this.isControl) return 0;
+    return stringWidth3(this.text);
+  }
+  /**
+   * Renders the segment to an ANSI string.
+   */
+  render() {
+    if (this.isControl) return this.text;
+    if (typeof this.style?.render === "function") {
+      return this.style.render(this.text);
+    }
+    return this.text;
+  }
+  /**
+   * Splits the segment into lines.
+   */
+  splitLines(_allowEmpty = false) {
+    const lines = this.text.split("\n");
+    return lines.map((line) => {
+      return [new _Segment(line, this.style, this.isControl)];
+    });
+  }
+  /**
+   * Creates a new Segment with modified properties.
+   */
+  clone(text, style, isControl) {
+    return new _Segment(text ?? this.text, style ?? this.style, isControl ?? this.isControl);
+  }
+};
+var Color = class _Color {
+  tc;
+  constructor(color) {
+    this.tc = tinycolor(color);
+  }
+  static parse(color) {
+    return new _Color(color);
+  }
+  get hex() {
+    return this.tc.toHexString();
+  }
+  get rgb() {
+    return this.tc.toRgb();
+  }
+  get isDark() {
+    return this.tc.isDark();
+  }
+  get isLight() {
+    return this.tc.isLight();
+  }
+  contrast(other) {
+    return tinycolor.readability(this.tc, other.tc);
+  }
+  lighten(amount = 10) {
+    return new _Color(this.tc.lighten(amount));
+  }
+  darken(amount = 10) {
+    return new _Color(this.tc.darken(amount));
+  }
+  /**
+   * Returns a readable foreground color (black or white) for this background color.
+   */
+  getContrastColor() {
+    return this.isDark ? new _Color("#ffffff") : new _Color("#000000");
+  }
+};
+
+// src/themes/palette.ts
+var Palette = class _Palette {
+  constructor(colors = {}) {
+    this.colors = colors;
+  }
+  get(name) {
+    return this.colors[name];
+  }
+  /**
+   * Generates a simple palette from a primary color.
+   */
+  static fromPrimary(primary) {
+    const p = new Color(primary);
+    return new _Palette({
+      primary: p.hex,
+      secondary: p.lighten(20).hex,
+      background: "#121212",
+      surface: "#1e1e1e",
+      text: "#ffffff",
+      error: "#cf6679",
+      success: "#03dac6",
+      warning: "#bb86fc"
+    });
+  }
+};
+var DEFAULT_PALETTE = new Palette({
+  primary: "#007bff",
+  secondary: "#6c757d",
+  success: "#28a745",
+  info: "#17a2b8",
+  warning: "#ffc107",
+  danger: "#dc3545",
+  light: "#f8f9fa",
+  dark: "#343a40"
+});
+
+// src/themes/theme.ts
+var Theme = class _Theme {
+  constructor(styles = {}, palette) {
+    this.styles = styles;
+    this.palette = palette ?? DEFAULT_PALETTE;
+  }
+  palette;
+  get(name) {
+    const style = this.styles[name];
+    if (style) {
+      return typeof style === "string" ? this.parseWithPalette(style) : style;
+    }
+    const paletteColor = this.palette.get(name);
+    if (paletteColor) {
+      return new Style({ color: paletteColor });
+    }
+    return Style.null();
+  }
+  /**
+   * Parses a style string replacing palette references.
+   * e.g. "bold primary" -> "bold #007bff"
+   */
+  parseWithPalette(styleString) {
+    const parts = styleString.split(" ");
+    const resolvedParts = parts.map((part) => {
+      const color = this.palette.get(part);
+      if (color) return color;
+      if (part.startsWith("on")) {
+        const bgName = part.startsWith("on_") ? part.slice(3) : part.slice(2) || parts[parts.indexOf(part) + 1];
+        const bgColor = this.palette.get(bgName);
+        if (bgColor) return `on ${bgColor}`;
+      }
+      return part;
+    });
+    return Style.parse(resolvedParts.join(" "));
+  }
+  static fromPalette(palette) {
+    return new _Theme({
+      "danger": `bold ${palette.get("danger")}`,
+      "success": `bold ${palette.get("success")}`,
+      "warning": `bold ${palette.get("warning")}`,
+      "info": `${palette.get("info")}`
+    }, palette);
+  }
+};
+var DEFAULT_THEME = new Theme({
+  "none": Style.null(),
+  "dim": Style.parse("dim"),
+  "bright": Style.parse("bold"),
+  // Semantic
+  "danger": Style.parse("bold red"),
+  "success": Style.parse("bold green"),
+  "warning": Style.parse("bold yellow"),
+  "info": Style.parse("cyan"),
+  // Components
+  "rule.line": Style.parse("green"),
+  "repr.str": Style.parse("green"),
+  "repr.brace": Style.parse("bold")
+});
+
+// src/core/markup.ts
+var MarkupParser = class _MarkupParser {
+  // Regex that matches standard tags [tag] and closing tags [/] or [/tag]
+  // We use a non-greedy match for content inside brackets
+  static TAG_REGEX = /\[(\/)?([\w\s#.,()]*?)\]/g;
+  theme;
+  constructor(theme) {
+    this.theme = theme ?? DEFAULT_THEME;
+  }
+  parse(markup) {
+    const segments = [];
+    const styleStack = [Style.null()];
+    let lastIndex = 0;
+    let match;
+    _MarkupParser.TAG_REGEX.lastIndex = 0;
+    while ((match = _MarkupParser.TAG_REGEX.exec(markup)) !== null) {
+      const fullMatch = match[0];
+      const isClosing = !!match[1];
+      const tagContent = match[2];
+      const index = match.index;
+      if (!isClosing && !tagContent) {
+        continue;
+      }
+      if (index > lastIndex) {
+        const text = markup.substring(lastIndex, index);
+        segments.push(new Segment(text, styleStack[styleStack.length - 1]));
+      }
+      if (isClosing) {
+        if (styleStack.length > 1) {
+          styleStack.pop();
+        }
+      } else {
+        const currentStyle = styleStack[styleStack.length - 1];
+        let nextStyle = this.theme.get(tagContent);
+        if (nextStyle === Style.null() && !this.theme.styles[tagContent]) {
+          nextStyle = Style.parse(tagContent);
+        } else if (this.theme.styles[tagContent]) ;
+        if (tagContent.includes(" ")) {
+          nextStyle = Style.parse(tagContent);
+        } else {
+          const themeStyle = this.theme.styles[tagContent];
+          if (themeStyle) {
+            nextStyle = typeof themeStyle === "string" ? Style.parse(themeStyle) : themeStyle;
+          } else {
+            nextStyle = Style.parse(tagContent);
+          }
+        }
+        const newStyle = currentStyle.combine(nextStyle);
+        styleStack.push(newStyle);
+      }
+      lastIndex = index + fullMatch.length;
+    }
+    if (lastIndex < markup.length) {
+      const text = markup.substring(lastIndex);
+      segments.push(new Segment(text, styleStack[styleStack.length - 1]));
+    }
+    return segments.filter((s) => s.text.length > 0);
+  }
+};
+
+// src/types/renderable.ts
+function isRenderable(obj) {
+  return typeof obj === "object" && obj !== null && "__rich_console__" in obj && typeof obj.__rich_console__ === "function";
+}
+
+// src/traceback/trace.ts
+var Trace = class {
+  static parse(error) {
+    if (!error.stack) return [];
+    const lines = error.stack.split("\n");
+    const frames = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line.startsWith("at ")) continue;
+      let functionName = "";
+      let location = "";
+      if (line.includes("(")) {
+        const parts = line.substring(3).split(" (");
+        functionName = parts[0];
+        location = parts[1].slice(0, -1);
+      } else {
+        location = line.substring(3);
+      }
+      const locParts = location.split(":");
+      const columnNumber = parseInt(locParts.pop() || "0");
+      const lineNumber = parseInt(locParts.pop() || "0");
+      const filePath = locParts.join(":");
+      frames.push({
+        functionName: functionName || "<anonymous>",
+        filePath,
+        lineNumber,
+        columnNumber
+      });
+    }
+    return frames;
+  }
+};
+
+// src/syntax/theme.ts
+var MONOKAI = {
+  name: "monokai",
+  background: "#272822",
+  styles: {
+    // Keywords and control flow
+    keyword: Style.parse("#f92672 bold"),
+    built_in: Style.parse("#66d9ef"),
+    type: Style.parse("#66d9ef italic"),
+    literal: Style.parse("#ae81ff"),
+    // Values
+    number: Style.parse("#ae81ff"),
+    string: Style.parse("#e6db74"),
+    regexp: Style.parse("#e6db74"),
+    symbol: Style.parse("#ae81ff"),
+    // Comments and docs
+    comment: Style.parse("#75715e dim"),
+    doctag: Style.parse("#75715e"),
+    meta: Style.parse("#75715e"),
+    // Functions and classes
+    function: Style.parse("#a6e22e"),
+    title: Style.parse("#a6e22e"),
+    "title.function": Style.parse("#a6e22e"),
+    "title.class": Style.parse("#a6e22e italic"),
+    "title.class.inherited": Style.parse("#a6e22e"),
+    // Variables and parameters
+    params: Style.parse("#fd971f italic"),
+    variable: Style.parse("#f8f8f2"),
+    "variable.language": Style.parse("#fd971f"),
+    "variable.constant": Style.parse("#ae81ff"),
+    // Properties and attributes
+    property: Style.parse("#66d9ef"),
+    attr: Style.parse("#a6e22e"),
+    attribute: Style.parse("#a6e22e"),
+    // Operators and punctuation
+    operator: Style.parse("#f92672"),
+    punctuation: Style.parse("#f8f8f2"),
+    // Misc
+    tag: Style.parse("#f92672"),
+    name: Style.parse("#a6e22e"),
+    "selector-tag": Style.parse("#f92672"),
+    "selector-class": Style.parse("#a6e22e"),
+    "selector-id": Style.parse("#a6e22e"),
+    // Template literals
+    "template-variable": Style.parse("#e6db74"),
+    "template-tag": Style.parse("#f92672"),
+    subst: Style.parse("#f8f8f2")
+  }
+};
+var DRACULA = {
+  name: "dracula",
+  background: "#282a36",
+  styles: {
+    keyword: Style.parse("#ff79c6 bold"),
+    built_in: Style.parse("#8be9fd"),
+    type: Style.parse("#8be9fd italic"),
+    literal: Style.parse("#bd93f9"),
+    number: Style.parse("#bd93f9"),
+    string: Style.parse("#f1fa8c"),
+    regexp: Style.parse("#f1fa8c"),
+    comment: Style.parse("#6272a4 dim"),
+    function: Style.parse("#50fa7b"),
+    title: Style.parse("#50fa7b"),
+    "title.function": Style.parse("#50fa7b"),
+    "title.class": Style.parse("#50fa7b italic"),
+    params: Style.parse("#ffb86c italic"),
+    variable: Style.parse("#f8f8f2"),
+    property: Style.parse("#8be9fd"),
+    attr: Style.parse("#50fa7b"),
+    operator: Style.parse("#ff79c6"),
+    tag: Style.parse("#ff79c6")
+  }
+};
+var GITHUB_LIGHT = {
+  name: "github",
+  styles: {
+    keyword: Style.parse("#d73a49 bold"),
+    built_in: Style.parse("#005cc5"),
+    type: Style.parse("#005cc5"),
+    literal: Style.parse("#005cc5"),
+    number: Style.parse("#005cc5"),
+    string: Style.parse("#032f62"),
+    regexp: Style.parse("#032f62"),
+    comment: Style.parse("#6a737d dim"),
+    function: Style.parse("#6f42c1"),
+    title: Style.parse("#6f42c1"),
+    "title.function": Style.parse("#6f42c1"),
+    "title.class": Style.parse("#6f42c1 bold"),
+    params: Style.parse("#24292e"),
+    variable: Style.parse("#24292e"),
+    property: Style.parse("#005cc5"),
+    attr: Style.parse("#6f42c1"),
+    operator: Style.parse("#d73a49"),
+    tag: Style.parse("#22863a")
+  }
+};
+var ONE_DARK = {
+  name: "one-dark",
+  background: "#282c34",
+  styles: {
+    keyword: Style.parse("#c678dd bold"),
+    built_in: Style.parse("#e5c07b"),
+    type: Style.parse("#e5c07b italic"),
+    literal: Style.parse("#d19a66"),
+    number: Style.parse("#d19a66"),
+    string: Style.parse("#98c379"),
+    regexp: Style.parse("#98c379"),
+    comment: Style.parse("#5c6370 dim"),
+    function: Style.parse("#61afef"),
+    title: Style.parse("#61afef"),
+    "title.function": Style.parse("#61afef"),
+    "title.class": Style.parse("#e5c07b bold"),
+    params: Style.parse("#abb2bf italic"),
+    variable: Style.parse("#e06c75"),
+    property: Style.parse("#e06c75"),
+    attr: Style.parse("#d19a66"),
+    operator: Style.parse("#56b6c2"),
+    tag: Style.parse("#e06c75")
+  }
+};
+var SYNTAX_THEMES = {
+  monokai: MONOKAI,
+  dracula: DRACULA,
+  github: GITHUB_LIGHT,
+  "github-light": GITHUB_LIGHT,
+  "one-dark": ONE_DARK,
+  atom: ONE_DARK
+};
+function getTheme(name) {
+  return SYNTAX_THEMES[name] ?? MONOKAI;
+}
+var MONOKAI_THEME = {
+  keyword: Style.parse("bold magenta"),
+  string: Style.parse("yellow"),
+  number: Style.parse("magenta"),
+  comment: Style.parse("dim white"),
+  operator: Style.parse("bold white"),
+  function: Style.parse("green"),
+  class: Style.parse("bold blue"),
+  title: Style.parse("bold white")
+};
+var Syntax = class _Syntax {
+  constructor(code, lexer, options = {}) {
+    this.code = code;
+    this.lexer = lexer;
+    this.options = options;
+    this.syntaxTheme = getTheme(options.theme ?? "monokai");
+  }
+  syntaxTheme;
+  /**
+   * Create Syntax from a file path (convenience method).
+   */
+  static fromPath(filePath, options = {}) {
+    const fs2 = __require("fs");
+    const path = __require("path");
+    const code = fs2.readFileSync(filePath, "utf-8");
+    const ext = path.extname(filePath).slice(1);
+    const lexerMap = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      py: "python",
+      rb: "ruby",
+      rs: "rust",
+      go: "go",
+      java: "java",
+      cpp: "cpp",
+      c: "c",
+      h: "c",
+      hpp: "cpp",
+      cs: "csharp",
+      php: "php",
+      sh: "bash",
+      bash: "bash",
+      zsh: "bash",
+      md: "markdown",
+      json: "json",
+      yaml: "yaml",
+      yml: "yaml",
+      toml: "ini",
+      css: "css",
+      scss: "scss",
+      html: "html",
+      xml: "xml",
+      sql: "sql"
+    };
+    const lexer = lexerMap[ext] ?? ext;
+    return new _Syntax(code, lexer, options);
+  }
+  __rich_console__(_console, _options) {
+    const segments = [];
+    const startLine = this.options.startLine ?? 1;
+    const showLineNumbers = this.options.lineNumbers ?? false;
+    const highlightLines = new Set(this.options.highlightLines ?? []);
+    let highlighted;
+    try {
+      highlighted = hljs.highlight(this.code, { language: this.lexer });
+    } catch {
+      highlighted = hljs.highlightAuto(this.code);
+    }
+    const tokens = this.parseHighlightedHtml(highlighted.value);
+    const lines = this.groupTokensByLine(tokens);
+    const lastLineNumber = startLine + lines.length - 1;
+    const lineNumberWidth = showLineNumbers ? String(lastLineNumber).length + 1 : 0;
+    let maxWidth = 0;
+    lines.forEach((lineTokens, i) => {
+      const lineNumber = startLine + i;
+      const isHighlighted = highlightLines.has(lineNumber);
+      if (isHighlighted) {
+        segments.push(new Segment("\u2771 ", Style.parse("#ff5555 bold")));
+      } else if (showLineNumbers) {
+        segments.push(new Segment("  ", Style.null()));
+      }
+      if (showLineNumbers) {
+        const lineNumStr = String(lineNumber).padStart(lineNumberWidth - 1);
+        const lineNumStyle = isHighlighted ? Style.parse("#ff5555 bold") : Style.parse("#6e7681 dim");
+        segments.push(new Segment(`${lineNumStr} \u2502 `, lineNumStyle));
+      }
+      let lineWidth = 0;
+      for (const token of lineTokens) {
+        let style = token.style;
+        if (isHighlighted) {
+          style = style.combine(Style.parse("on #3a1d1d"));
+        }
+        segments.push(new Segment(token.text, style));
+        lineWidth += stringWidth3(token.text);
+      }
+      segments.push(new Segment("\n", Style.null(), true));
+      const totalLineWidth = lineWidth + (showLineNumbers ? lineNumberWidth + 5 : 0);
+      if (totalLineWidth > maxWidth) maxWidth = totalLineWidth;
+    });
+    return {
+      segments,
+      width: maxWidth
+    };
+  }
+  /**
+   * Parse highlight.js HTML output into styled tokens.
+   */
+  parseHighlightedHtml(html) {
+    const tokens = [];
+    const processHtml = (input, inheritedScope = []) => {
+      let remaining = input;
+      while (remaining.length > 0) {
+        const openMatch = remaining.match(/^<span class="hljs-([^"]+)">/);
+        if (openMatch) {
+          remaining = remaining.slice(openMatch[0].length);
+          const scope = openMatch[1];
+          let depth = 1;
+          let innerEnd = 0;
+          for (let i = 0; i < remaining.length; i++) {
+            if (remaining.slice(i).startsWith("<span")) {
+              depth++;
+            } else if (remaining.slice(i).startsWith("</span>")) {
+              depth--;
+              if (depth === 0) {
+                innerEnd = i;
+                break;
+              }
+            }
+          }
+          const innerContent = remaining.slice(0, innerEnd);
+          remaining = remaining.slice(innerEnd + "</span>".length);
+          const newScope = [...inheritedScope, scope];
+          processHtml(innerContent, newScope);
+          continue;
+        }
+        const textMatch = remaining.match(/^([^<]+)/);
+        if (textMatch) {
+          const text = this.decodeHtmlEntities(textMatch[1]);
+          const scope = inheritedScope[inheritedScope.length - 1] ?? "";
+          const style = this.getStyleForScope(scope);
+          tokens.push({ text, style });
+          remaining = remaining.slice(textMatch[0].length);
+          continue;
+        }
+        const tagMatch = remaining.match(/^<[^>]+>/);
+        if (tagMatch) {
+          remaining = remaining.slice(tagMatch[0].length);
+          continue;
+        }
+        if (remaining.length > 0) {
+          tokens.push({ text: remaining[0], style: Style.null() });
+          remaining = remaining.slice(1);
+        }
+      }
+    };
+    processHtml(html);
+    return tokens;
+  }
+  /**
+   * Decode HTML entities to their character equivalents.
+   */
+  decodeHtmlEntities(text) {
+    return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&nbsp;/g, " ");
+  }
+  /**
+   * Get style for a highlight.js scope/class.
+   */
+  getStyleForScope(scope) {
+    if (!scope) return Style.null();
+    if (this.syntaxTheme.styles[scope]) {
+      return this.syntaxTheme.styles[scope];
+    }
+    const parts = scope.split(".");
+    for (let i = parts.length - 1; i >= 0; i--) {
+      const partialScope = parts.slice(0, i + 1).join(".");
+      if (this.syntaxTheme.styles[partialScope]) {
+        return this.syntaxTheme.styles[partialScope];
+      }
+    }
+    if (this.syntaxTheme.styles[parts[0]]) {
+      return this.syntaxTheme.styles[parts[0]];
+    }
+    return Style.null();
+  }
+  /**
+   * Group tokens by line (split on newlines).
+   */
+  groupTokensByLine(tokens) {
+    const lines = [[]];
+    for (const token of tokens) {
+      const parts = token.text.split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        if (i > 0) {
+          lines.push([]);
+        }
+        if (parts[i]) {
+          lines[lines.length - 1].push({ text: parts[i], style: token.style });
+        }
+      }
+    }
+    return lines;
+  }
+};
+
+// src/traceback/traceback.ts
+var Traceback = class {
+  constructor(error, options = {}) {
+    this.error = error;
+    this.options = options;
+    this.frames = Trace.parse(error);
+  }
+  frames;
+  __rich_console__(console, consoleOptions) {
+    const segments = [];
+    const extraLines = this.options.extraLines ?? 3;
+    const theme = this.options.theme ?? "monokai";
+    const suppressInternal = this.options.suppressInternal ?? true;
+    const maxFrames = this.options.maxFrames ?? 100;
+    const width = consoleOptions.width ?? console.width;
+    segments.push(new Segment("\n", Style.null(), true));
+    const headerStyle = Style.parse("#ff5555 bold");
+    segments.push(new Segment("Traceback", headerStyle));
+    segments.push(new Segment(" (most recent call last)\n", Style.parse("dim")));
+    segments.push(new Segment("\n", Style.null(), true));
+    let filteredFrames = this.frames;
+    if (suppressInternal) {
+      filteredFrames = filteredFrames.filter(
+        (f) => !f.filePath.startsWith("node:") && !f.filePath.includes("node_modules")
+      );
+    }
+    filteredFrames = filteredFrames.slice(0, maxFrames);
+    for (const frame of filteredFrames) {
+      const frameHeaderStyle = Style.parse("#6e7681");
+      segments.push(new Segment("  File ", frameHeaderStyle));
+      segments.push(new Segment(`"${frame.filePath}"`, Style.parse("#61afef")));
+      segments.push(new Segment(", line ", frameHeaderStyle));
+      segments.push(new Segment(String(frame.lineNumber), Style.parse("#e5c07b bold")));
+      segments.push(new Segment(", in ", frameHeaderStyle));
+      segments.push(new Segment(frame.functionName, Style.parse("#98c379 italic")));
+      segments.push(new Segment("\n", Style.null(), true));
+      let codeSnippet = "";
+      try {
+        if (fs.existsSync(frame.filePath)) {
+          const content = fs.readFileSync(frame.filePath, "utf-8");
+          const lines = content.split("\n");
+          const start = Math.max(0, frame.lineNumber - extraLines - 1);
+          const end = Math.min(lines.length, frame.lineNumber + extraLines);
+          codeSnippet = lines.slice(start, end).join("\n");
+          const ext = frame.filePath.split(".").pop() ?? "txt";
+          const lexerMap = {
+            ts: "typescript",
+            tsx: "typescript",
+            js: "javascript",
+            jsx: "javascript",
+            py: "python",
+            rb: "ruby",
+            rs: "rust",
+            go: "go"
+          };
+          const lexer = lexerMap[ext] ?? ext;
+          const syntax = new Syntax(codeSnippet, lexer, {
+            theme,
+            lineNumbers: true,
+            startLine: start + 1,
+            highlightLines: [frame.lineNumber]
+          });
+          const syntaxResult = syntax.__rich_console__(console, {
+            ...consoleOptions,
+            width: width - 4
+          });
+          segments.push(new Segment("\n", Style.null(), true));
+          for (const seg of syntaxResult.segments) {
+            if (seg.isControl && seg.text === "\n") {
+              segments.push(seg);
+              segments.push(new Segment("    "));
+            } else {
+              segments.push(seg);
+            }
+          }
+        }
+      } catch {
+        segments.push(new Segment("    ", Style.null()));
+        segments.push(new Segment("[source not available]", Style.parse("dim italic")));
+        segments.push(new Segment("\n", Style.null(), true));
+      }
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    const errorNameStyle = Style.parse("#ff5555 bold");
+    const errorMsgStyle = Style.parse("#ff5555");
+    segments.push(new Segment(this.error.name, errorNameStyle));
+    segments.push(new Segment(": ", Style.parse("dim")));
+    segments.push(new Segment(this.error.message, errorMsgStyle));
+    segments.push(new Segment("\n", Style.null(), true));
+    return { segments, width };
+  }
+};
+function installTracebackHandler(options = {}) {
+  const console = new Console();
+  process.on("uncaughtException", (error) => {
+    const traceback = new Traceback(error, options);
+    console.print(traceback);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    const error = reason instanceof Error ? reason : new Error(String(reason));
+    const traceback = new Traceback(error, options);
+    console.print(traceback);
+    process.exit(1);
+  });
+}
+
+// src/utils/render-utils.ts
+function getRenderResult(renderable, console, options) {
+  const result = renderable.__rich_console__(console, options);
+  if ("segments" in result) {
+    return result;
+  }
+  return {
+    segments: Array.from(result),
+    width: options.width
+    // approximation
+  };
+}
+var Live = class {
+  constructor(renderable, console, autoRefresh = true) {
+    this.renderable = renderable;
+    this.console = console;
+    this.autoRefresh = autoRefresh;
+  }
+  _started = false;
+  _lastHeight = 0;
+  start() {
+    this._started = true;
+    this.refresh();
+  }
+  stop() {
+    this._started = false;
+    this.console.print("");
+  }
+  update(renderable) {
+    this.renderable = renderable;
+    this.refresh();
+  }
+  refresh() {
+    if (!this._started) return;
+    if (this._lastHeight > 0) {
+      process.stdout.write(ansiEscapes.eraseLines(this._lastHeight));
+    }
+    const output = this.console.render(this.renderable);
+    const lines = output.split("\n").length;
+    this._lastHeight = lines;
+    process.stdout.write(output);
+  }
+};
+var Spinner = class {
+  // Type definition issues with cli-spinners
+  constructor(name = "dots", style = Style.null()) {
+    this.name = name;
+    this.style = style;
+    this.spinner = cliSpinners[name];
+  }
+  frame = 0;
+  // @ts-ignore
+  spinner;
+  get currentFrame() {
+    return this.spinner.frames[this.frame];
+  }
+  __rich_console__(_console, _options) {
+    return {
+      segments: [new Segment(this.currentFrame, this.style)],
+      width: 1
+      // approximates
+    };
+  }
+  nextFrame() {
+    this.frame = (this.frame + 1) % this.spinner.frames.length;
+  }
+};
+
+// src/core/lines.ts
+function splitLines(segments) {
+  const lines = [];
+  let currentLine = [];
+  for (const segment of segments) {
+    if (segment.text.includes("\n")) {
+      const parts = segment.text.split("\n");
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) {
+          currentLine.push(new Segment(part, segment.style, segment.isControl));
+        }
+        if (i < parts.length - 1) {
+          lines.push(currentLine);
+          currentLine = [];
+        }
+      }
+    } else {
+      currentLine.push(segment);
+    }
+  }
+  if (currentLine.length > 0) {
+    lines.push(currentLine);
+  }
+  return lines;
+}
+function padLine(line, width, style = Style.null()) {
+  const currentWidth = line.reduce((acc, s) => acc + s.cellLength(), 0);
+  if (currentWidth >= width) return line;
+  const padding = width - currentWidth;
+  return [...line, new Segment(" ".repeat(padding), style)];
+}
+
+// src/layout/layout.ts
+var Layout = class _Layout {
+  _renderable = null;
+  _children = [];
+  _direction = "column";
+  size;
+  ratio = 1;
+  minimumSize = 0;
+  visible = true;
+  constructor(renderable, options = {}) {
+    if (renderable) this._renderable = renderable;
+    this.size = options.size;
+    this.ratio = options.ratio ?? 1;
+    this.minimumSize = options.minimumSize ?? 0;
+    this.visible = options.visible ?? true;
+  }
+  /**
+   * Split the layout into a row (horizontal split).
+   */
+  splitRow(...layouts) {
+    this._direction = "row";
+    this._children = layouts.map((l) => l instanceof _Layout ? l : new _Layout(l));
+  }
+  /**
+   * Split the layout into a column (vertical split).
+   */
+  splitColumn(...layouts) {
+    this._direction = "column";
+    this._children = layouts.map((l) => l instanceof _Layout ? l : new _Layout(l));
+  }
+  get renderable() {
+    return this._renderable;
+  }
+  update(renderable) {
+    this._renderable = renderable;
+  }
+  __rich_console__(console, options) {
+    if (!this.visible) return { segments: [], width: 0, height: 0 };
+    const width = options.width ?? console.width;
+    const height = options.height ?? console.height;
+    if (this._children.length === 0) {
+      if (this._renderable) {
+        return getRenderResult(this._renderable, console, { ...options, width, height });
+      }
+      return { segments: [], width, height: 0 };
+    }
+    const segments = [];
+    if (this._direction === "column") {
+      for (const child of this._children) {
+        if (!child.visible) continue;
+        const result = getRenderResult(child, console, { ...options, width });
+        segments.push(...result.segments);
+        const last = result.segments[result.segments.length - 1];
+        if (last && !last.text.endsWith("\n")) {
+          segments.push(new Segment("\n"));
+        }
+      }
+    } else {
+      const childWidths = this.calculateSizes(width, this._children);
+      const renderedLines = [];
+      let maxHeight = 0;
+      this._children.forEach((child, i) => {
+        if (!child.visible) {
+          renderedLines.push([]);
+          return;
+        }
+        const w = childWidths[i];
+        const result = getRenderResult(child, console, { ...options, width: w });
+        let childSegments = result.segments;
+        const lines = splitLines(childSegments);
+        renderedLines.push(lines);
+        if (lines.length > maxHeight) maxHeight = lines.length;
+      });
+      for (let y = 0; y < maxHeight; y++) {
+        for (let x = 0; x < this._children.length; x++) {
+          if (!this._children[x].visible) continue;
+          const lines = renderedLines[x];
+          const w = childWidths[x];
+          if (y < lines.length) {
+            const line = lines[y];
+            segments.push(...padLine(line, w));
+          } else {
+            segments.push(new Segment(" ".repeat(w)));
+          }
+        }
+        segments.push(new Segment("\n"));
+      }
+    }
+    return { segments, width, height };
+  }
+  /**
+   * Calculates the size (width for rows, height for columns) for each child
+   * based on constraints.
+   */
+  calculateSizes(availableSpace, children) {
+    const sizes = new Array(children.length).fill(0);
+    const visibleChildren = children.map((c, i) => ({ child: c, index: i })).filter((x) => x.child.visible);
+    if (visibleChildren.length === 0) return sizes;
+    let remainingSpace = availableSpace;
+    let totalRatio = 0;
+    for (const { child, index } of visibleChildren) {
+      if (child.size !== void 0) {
+        const size = Math.min(child.size, remainingSpace);
+        sizes[index] = size;
+        remainingSpace -= size;
+      } else if (child.minimumSize > 0) {
+        sizes[index] = child.minimumSize;
+        remainingSpace -= child.minimumSize;
+      }
+      if (child.size === void 0) {
+        totalRatio += child.ratio;
+      }
+    }
+    if (remainingSpace <= 0) return sizes;
+    if (totalRatio > 0) {
+      let distributed = 0;
+      for (let i = 0; i < visibleChildren.length; i++) {
+        const { child, index } = visibleChildren[i];
+        if (child.size === void 0) {
+          const share = Math.floor(child.ratio / totalRatio * remainingSpace);
+          sizes[index] += share;
+          distributed += share;
+        }
+      }
+      const dust = remainingSpace - distributed;
+      if (dust > 0) {
+        for (let i = visibleChildren.length - 1; i >= 0; i--) {
+          const { child, index } = visibleChildren[i];
+          if (child.size === void 0) {
+            sizes[index] += dust;
+            break;
+          }
+        }
+      }
+    }
+    return sizes;
+  }
+};
+var Text = class {
+  constructor(content, style = Style.null(), justify = "left", overflow = "fold", noWrap = false) {
+    this.style = style;
+    this.justify = justify;
+    this.overflow = overflow;
+    this.noWrap = noWrap;
+    if (typeof content === "string") {
+      const parser = new MarkupParser();
+      this.segments = parser.parse(content);
+    } else {
+      this.segments = content;
+    }
+  }
+  segments;
+  __rich_console__(console, options) {
+    const width = options.width ?? console.width;
+    const text = this.segments.map((s) => s.render()).join("");
+    let wrapped = text;
+    if (!this.noWrap) {
+      wrapped = wrapAnsi(text, width, { hard: true, trim: false });
+    }
+    const resultSegments = wrapped.split("\n").flatMap((line) => {
+      return [new Segment(line), new Segment("\n", Style.null(), true)];
+    });
+    return {
+      segments: resultSegments,
+      width
+    };
+  }
+};
+
+// src/status/status.ts
+var Status = class {
+  live;
+  spinner;
+  message;
+  interval = null;
+  constructor(message, options = {}) {
+    this.message = message;
+    this.spinner = new Spinner(options.spinner ?? "dots");
+    const console = options.console ?? new Console();
+    this.live = new Live(this.render(), console);
+  }
+  start() {
+    this.live.start();
+    this.interval = setInterval(() => {
+      this.spinner.nextFrame();
+      this.live.update(this.render());
+    }, 80);
+  }
+  stop() {
+    if (this.interval) clearInterval(this.interval);
+    this.live.stop();
+  }
+  update(message) {
+    this.message = message;
+    this.live.update(this.render());
+  }
+  render() {
+    const layout = new Layout();
+    layout.splitRow(
+      this.spinner,
+      new Text(" " + this.message)
+    );
+    return layout;
+  }
+};
+
+// src/console/console.ts
+var Console = class {
+  terminal;
+  markupParser;
+  options;
+  theme;
+  constructor(options = {}) {
+    this.options = options;
+    this.terminal = new Terminal();
+    this.theme = options.theme ?? DEFAULT_THEME;
+    this.markupParser = new MarkupParser(this.theme);
+  }
+  get width() {
+    return this.options.width ?? this.terminal.width;
+  }
+  get height() {
+    return this.options.height ?? this.terminal.height;
+  }
+  /**
+   * Prints objects to the console.
+   */
+  print(...objects) {
+    const lastObj = objects[objects.length - 1];
+    let printObjects = objects;
+    let options = {};
+    if (objects.length > 1 && typeof lastObj === "object" && lastObj !== null && !isRenderable(lastObj) && ("style" in lastObj || "markup" in lastObj)) {
+      options = objects.pop();
+      printObjects = objects;
+    }
+    const output = printObjects.map((obj) => {
+      if (typeof obj === "string") {
+        return this.renderString(obj, options.markup ?? true);
+      }
+      if (isRenderable(obj)) {
+        return this.render(obj);
+      }
+      return String(obj);
+    }).join(" ");
+    this.write(output + "\n");
+  }
+  /**
+   * Prints a formatted exception.
+   */
+  printException(error) {
+    const traceback = new Traceback(error);
+    this.print(traceback);
+  }
+  /**
+   * Displays a status spinner.
+   */
+  status(message, options = {}) {
+    return new Status(message, { console: this, ...options });
+  }
+  /**
+   * Run a task with a status spinner.
+   */
+  async withStatus(message, task, options = {}) {
+    const status = new Status(message, { console: this, ...options });
+    status.start();
+    try {
+      return await task(status);
+    } finally {
+      status.stop();
+    }
+  }
+  /**
+   * Renders a renderable object to a string.
+   */
+  render(renderable) {
+    const result = getRenderResult(renderable, this, this.options);
+    return result.segments.map((s) => s.render()).join("");
+  }
+  /**
+   * Internal string rendering with markup and wrapping.
+   */
+  renderString(text, markup = true) {
+    const segments = markup ? this.markupParser.parse(text) : [new Segment(text)];
+    const rendered = segments.map((s) => s.render()).join("");
+    return wrapAnsi(rendered, this.width, { hard: true });
+  }
+  /**
+   * Low-level write to stdout.
+   */
+  write(text) {
+    process2.stdout.write(text);
+  }
+};
+var CUSTOM_BOXES = {
+  // Rounded corners (may not be in all versions of cli-boxes)
+  rounded: {
+    topLeft: "\u256D",
+    top: "\u2500",
+    topRight: "\u256E",
+    right: "\u2502",
+    bottomRight: "\u256F",
+    bottom: "\u2500",
+    bottomLeft: "\u2570",
+    left: "\u2502",
+    topMid: "\u252C",
+    midMid: "\u253C",
+    bottomMid: "\u2534",
+    leftMid: "\u251C",
+    rightMid: "\u2524",
+    mid: "\u2500",
+    verticalMid: "\u2502"
+  },
+  round: {
+    topLeft: "\u256D",
+    top: "\u2500",
+    topRight: "\u256E",
+    right: "\u2502",
+    bottomRight: "\u256F",
+    bottom: "\u2500",
+    bottomLeft: "\u2570",
+    left: "\u2502",
+    topMid: "\u252C",
+    midMid: "\u253C",
+    bottomMid: "\u2534",
+    leftMid: "\u251C",
+    rightMid: "\u2524",
+    mid: "\u2500",
+    verticalMid: "\u2502"
+  },
+  // Heavy/bold lines
+  heavy: {
+    topLeft: "\u250F",
+    top: "\u2501",
+    topRight: "\u2513",
+    right: "\u2503",
+    bottomRight: "\u251B",
+    bottom: "\u2501",
+    bottomLeft: "\u2517",
+    left: "\u2503",
+    topMid: "\u2533",
+    midMid: "\u254B",
+    bottomMid: "\u253B",
+    leftMid: "\u2523",
+    rightMid: "\u252B",
+    mid: "\u2501",
+    verticalMid: "\u2503"
+  },
+  // Double lines
+  double: {
+    topLeft: "\u2554",
+    top: "\u2550",
+    topRight: "\u2557",
+    right: "\u2551",
+    bottomRight: "\u255D",
+    bottom: "\u2550",
+    bottomLeft: "\u255A",
+    left: "\u2551",
+    topMid: "\u2566",
+    midMid: "\u256C",
+    bottomMid: "\u2569",
+    leftMid: "\u2560",
+    rightMid: "\u2563",
+    mid: "\u2550",
+    verticalMid: "\u2551"
+  },
+  // Single/square lines
+  single: {
+    topLeft: "\u250C",
+    top: "\u2500",
+    topRight: "\u2510",
+    right: "\u2502",
+    bottomRight: "\u2518",
+    bottom: "\u2500",
+    bottomLeft: "\u2514",
+    left: "\u2502",
+    topMid: "\u252C",
+    midMid: "\u253C",
+    bottomMid: "\u2534",
+    leftMid: "\u251C",
+    rightMid: "\u2524",
+    mid: "\u2500",
+    verticalMid: "\u2502"
+  },
+  square: {
+    topLeft: "\u250C",
+    top: "\u2500",
+    topRight: "\u2510",
+    right: "\u2502",
+    bottomRight: "\u2518",
+    bottom: "\u2500",
+    bottomLeft: "\u2514",
+    left: "\u2502",
+    topMid: "\u252C",
+    midMid: "\u253C",
+    bottomMid: "\u2534",
+    leftMid: "\u251C",
+    rightMid: "\u2524",
+    mid: "\u2500",
+    verticalMid: "\u2502"
+  },
+  // ASCII-safe
+  ascii: {
+    topLeft: "+",
+    top: "-",
+    topRight: "+",
+    right: "|",
+    bottomRight: "+",
+    bottom: "-",
+    bottomLeft: "+",
+    left: "|",
+    topMid: "+",
+    midMid: "+",
+    bottomMid: "+",
+    leftMid: "+",
+    rightMid: "+",
+    mid: "-",
+    verticalMid: "|"
+  },
+  // Minimal - no borders
+  minimal: {
+    topLeft: " ",
+    top: " ",
+    topRight: " ",
+    right: " ",
+    bottomRight: " ",
+    bottom: " ",
+    bottomLeft: " ",
+    left: " ",
+    topMid: " ",
+    midMid: " ",
+    bottomMid: " ",
+    leftMid: " ",
+    rightMid: " ",
+    mid: "\u2500",
+    verticalMid: " "
+  },
+  // Simple - just horizontal lines
+  simple: {
+    topLeft: " ",
+    top: "\u2500",
+    topRight: " ",
+    right: " ",
+    bottomRight: " ",
+    bottom: "\u2500",
+    bottomLeft: " ",
+    left: " ",
+    topMid: " ",
+    midMid: "\u2500",
+    bottomMid: " ",
+    leftMid: " ",
+    rightMid: " ",
+    mid: "\u2500",
+    verticalMid: " "
+  },
+  // Markdown style
+  markdown: {
+    topLeft: " ",
+    top: " ",
+    topRight: " ",
+    right: "|",
+    bottomRight: " ",
+    bottom: " ",
+    bottomLeft: " ",
+    left: "|",
+    topMid: " ",
+    midMid: "|",
+    bottomMid: " ",
+    leftMid: "|",
+    rightMid: "|",
+    mid: "-",
+    verticalMid: "|"
+  }
+};
+function getBox(style) {
+  if (style === "none") return null;
+  if (style in CUSTOM_BOXES) {
+    return CUSTOM_BOXES[style];
+  }
+  if (style === "bold") {
+    return CUSTOM_BOXES.heavy;
+  }
+  const cliBox = boxes[style];
+  if (cliBox) {
+    return {
+      ...cliBox,
+      topMid: cliBox.topMid ?? "\u252C",
+      midMid: cliBox.midMid ?? "\u253C",
+      bottomMid: cliBox.bottomMid ?? "\u2534",
+      leftMid: cliBox.leftMid ?? "\u251C",
+      rightMid: cliBox.rightMid ?? "\u2524",
+      mid: cliBox.mid ?? "\u2500",
+      verticalMid: cliBox.verticalMid ?? "\u2502"
+    };
+  }
+  return CUSTOM_BOXES.rounded;
+}
+function listBoxStyles() {
+  const customStyles = Object.keys(CUSTOM_BOXES);
+  const cliBoxStyles = Object.keys(boxes);
+  return [.../* @__PURE__ */ new Set([...customStyles, ...cliBoxStyles])];
+}
+var Panel = class _Panel {
+  constructor(renderable, options = {}) {
+    this.renderable = renderable;
+    this.options = options;
+  }
+  /**
+   * Create a panel that fits its content (expand=false).
+   */
+  static fit(renderable, options = {}) {
+    return new _Panel(renderable, { ...options, expand: false });
+  }
+  __rich_console__(console, consoleOptions) {
+    const box = getBox(this.options.box ?? "rounded");
+    const expand = this.options.expand ?? true;
+    const maxWidth = this.options.width ?? consoleOptions.width ?? console.width;
+    const borderStyle = typeof this.options.borderStyle === "string" ? Style.parse(this.options.borderStyle) : this.options.borderStyle ?? Style.parse("dim");
+    const titleAlign = this.options.titleAlign ?? "center";
+    const subtitleAlign = this.options.subtitleAlign ?? "center";
+    const padding = this.normalizePadding(this.options.padding ?? 1);
+    const segments = [];
+    if (!box) {
+      return { segments: [], width: 0 };
+    }
+    let contentSegments = [];
+    if (typeof this.renderable === "string") {
+      contentSegments = [new Segment(this.renderable)];
+    } else if (isRenderable(this.renderable)) {
+      const contentWidth = maxWidth - 2 - padding[1] - padding[3];
+      const result = this.renderable.__rich_console__(console, {
+        ...consoleOptions,
+        width: contentWidth
+      });
+      if ("segments" in result) {
+        contentSegments = Array.from(result.segments);
+      }
+    }
+    const lines = splitLines(contentSegments);
+    let maxContentWidth = 0;
+    for (const line of lines) {
+      const lineWidth = line.reduce((w, seg) => w + stringWidth3(seg.text), 0);
+      if (lineWidth > maxContentWidth) maxContentWidth = lineWidth;
+    }
+    const titleWidth = this.options.title ? stringWidth3(this.options.title) + 4 : 0;
+    const subtitleWidth = this.options.subtitle ? stringWidth3(this.options.subtitle) + 4 : 0;
+    let panelWidth;
+    if (expand) {
+      panelWidth = maxWidth;
+    } else {
+      panelWidth = Math.min(
+        maxWidth,
+        Math.max(maxContentWidth + 2 + padding[1] + padding[3], titleWidth + 2, subtitleWidth + 2)
+      );
+    }
+    const innerWidth = panelWidth - 2;
+    segments.push(...this.renderTopBorder(box, innerWidth, borderStyle, titleAlign));
+    segments.push(new Segment("\n", Style.null(), true));
+    for (let i = 0; i < padding[0]; i++) {
+      segments.push(new Segment(box.left, borderStyle));
+      segments.push(new Segment(" ".repeat(innerWidth)));
+      segments.push(new Segment(box.right, borderStyle));
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    for (const line of lines) {
+      segments.push(new Segment(box.left, borderStyle));
+      segments.push(new Segment(" ".repeat(padding[3])));
+      const contentPaddedWidth = innerWidth - padding[1] - padding[3];
+      const paddedLine = padLine(line, contentPaddedWidth);
+      segments.push(...paddedLine);
+      segments.push(new Segment(" ".repeat(padding[1])));
+      segments.push(new Segment(box.right, borderStyle));
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    if (lines.length === 0) {
+      segments.push(new Segment(box.left, borderStyle));
+      segments.push(new Segment(" ".repeat(innerWidth)));
+      segments.push(new Segment(box.right, borderStyle));
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    for (let i = 0; i < padding[2]; i++) {
+      segments.push(new Segment(box.left, borderStyle));
+      segments.push(new Segment(" ".repeat(innerWidth)));
+      segments.push(new Segment(box.right, borderStyle));
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    segments.push(...this.renderBottomBorder(box, innerWidth, borderStyle, subtitleAlign));
+    segments.push(new Segment("\n", Style.null(), true));
+    return {
+      segments,
+      width: panelWidth
+    };
+  }
+  /**
+   * Normalize padding to [top, right, bottom, left] format.
+   */
+  normalizePadding(padding) {
+    if (typeof padding === "number") {
+      return [padding, padding, padding, padding];
+    }
+    if (padding.length === 2) {
+      return [padding[0], padding[1], padding[0], padding[1]];
+    }
+    return padding;
+  }
+  /**
+   * Render top border with optional title.
+   */
+  renderTopBorder(box, innerWidth, borderStyle, align) {
+    const segments = [];
+    if (this.options.title) {
+      const title = ` ${this.options.title} `;
+      const titleWidth = stringWidth3(title);
+      const remainingWidth = Math.max(0, innerWidth - titleWidth);
+      let leftLine;
+      let rightLine;
+      switch (align) {
+        case "left":
+          leftLine = "";
+          rightLine = box.top.repeat(remainingWidth);
+          break;
+        case "right":
+          leftLine = box.top.repeat(remainingWidth);
+          rightLine = "";
+          break;
+        case "center":
+        default: {
+          const leftWidth = Math.floor(remainingWidth / 2);
+          leftLine = box.top.repeat(leftWidth);
+          rightLine = box.top.repeat(remainingWidth - leftWidth);
+          break;
+        }
+      }
+      segments.push(new Segment(box.topLeft, borderStyle));
+      segments.push(new Segment(leftLine, borderStyle));
+      segments.push(new Segment(title, Style.parse("bold")));
+      segments.push(new Segment(rightLine, borderStyle));
+      segments.push(new Segment(box.topRight, borderStyle));
+    } else {
+      segments.push(
+        new Segment(box.topLeft + box.top.repeat(innerWidth) + box.topRight, borderStyle)
+      );
+    }
+    return segments;
+  }
+  /**
+   * Render bottom border with optional subtitle.
+   */
+  renderBottomBorder(box, innerWidth, borderStyle, align) {
+    const segments = [];
+    if (this.options.subtitle) {
+      const subtitle = ` ${this.options.subtitle} `;
+      const subtitleWidth = stringWidth3(subtitle);
+      const remainingWidth = Math.max(0, innerWidth - subtitleWidth);
+      let leftLine;
+      let rightLine;
+      switch (align) {
+        case "left":
+          leftLine = "";
+          rightLine = box.bottom.repeat(remainingWidth);
+          break;
+        case "right":
+          leftLine = box.bottom.repeat(remainingWidth);
+          rightLine = "";
+          break;
+        case "center":
+        default: {
+          const leftWidth = Math.floor(remainingWidth / 2);
+          leftLine = box.bottom.repeat(leftWidth);
+          rightLine = box.bottom.repeat(remainingWidth - leftWidth);
+          break;
+        }
+      }
+      segments.push(new Segment(box.bottomLeft, borderStyle));
+      segments.push(new Segment(leftLine, borderStyle));
+      segments.push(new Segment(subtitle, Style.parse("dim italic")));
+      segments.push(new Segment(rightLine, borderStyle));
+      segments.push(new Segment(box.bottomRight, borderStyle));
+    } else {
+      segments.push(
+        new Segment(box.bottomLeft + box.bottom.repeat(innerWidth) + box.bottomRight, borderStyle)
+      );
+    }
+    return segments;
+  }
+};
+var Rule = class {
+  constructor(title = "", characters = "\u2500", style = Style.null()) {
+    this.title = title;
+    this.characters = characters;
+    this.style = style;
+  }
+  __rich_console__(console, options) {
+    const width = options.width ?? console.width;
+    let line = "";
+    if (this.title) {
+      const titleText = ` ${this.title} `;
+      const titleWidth = stringWidth3(titleText);
+      const sideWidth = Math.floor((width - titleWidth) / 2);
+      line = this.characters.repeat(sideWidth) + titleText + this.characters.repeat(width - titleWidth - sideWidth);
+    } else {
+      line = this.characters.repeat(width);
+    }
+    return {
+      segments: [new Segment(line, this.style), new Segment("\n", Style.null(), true)],
+      width
+    };
+  }
+};
+var Column = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get header() {
+    return this.options.header ?? "";
+  }
+  get footer() {
+    return this.options.footer ?? "";
+  }
+  get justify() {
+    return this.options.justify ?? "left";
+  }
+  get style() {
+    return typeof this.options.style === "string" ? Style.parse(this.options.style) : this.options.style ?? Style.null();
+  }
+  get headerStyle() {
+    return typeof this.options.headerStyle === "string" ? Style.parse(this.options.headerStyle) : this.options.headerStyle ?? Style.null();
+  }
+};
+var Table = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  columns = [];
+  rows = [];
+  footerRow = [];
+  addColumn(header, options) {
+    if (typeof header === "string") {
+      this.columns.push(new Column({ header, ...options }));
+    } else {
+      this.columns.push(new Column(header));
+    }
+    return this;
+  }
+  addRow(...cells) {
+    this.rows.push(cells);
+    return this;
+  }
+  addFooter(...cells) {
+    this.footerRow = cells;
+    return this;
+  }
+  alignText(text, width, justify) {
+    const textWidth = stringWidth3(text);
+    const space = Math.max(0, width - textWidth);
+    if (justify === "left") return text + " ".repeat(space);
+    if (justify === "right") return " ".repeat(space) + text;
+    const leftSpace = Math.floor(space / 2);
+    const rightSpace = space - leftSpace;
+    return " ".repeat(leftSpace) + text + " ".repeat(rightSpace);
+  }
+  __rich_console__(console, consoleOptions) {
+    const width = consoleOptions.width ?? console.width;
+    const box = getBox(this.options.box ?? "rounded");
+    const segments = [];
+    const borderStyle = typeof this.options.borderStyle === "string" ? Style.parse(this.options.borderStyle) : this.options.borderStyle ?? Style.parse("dim");
+    const headerStyle = typeof this.options.headerStyle === "string" ? Style.parse(this.options.headerStyle) : this.options.headerStyle ?? Style.parse("bold cyan");
+    const titleStyle = typeof this.options.titleStyle === "string" ? Style.parse(this.options.titleStyle) : this.options.titleStyle ?? Style.parse("bold");
+    const showLines = this.options.showLines ?? false;
+    const rowStyles = this.options.rowStyles ?? [];
+    const padding = this.options.padding ?? 1;
+    if (!box) return { segments: [], width: 0 };
+    const totalBorderWidth = this.columns.length + 1;
+    const paddingWidth = padding * 2 * this.columns.length;
+    const availableWidth = width - totalBorderWidth - paddingWidth;
+    const colWidth = Math.max(1, Math.floor(availableWidth / this.columns.length));
+    const paddingStr = " ".repeat(padding);
+    if (this.options.title) {
+      const titleLine = this.alignText(this.options.title, width, "center");
+      segments.push(new Segment(titleLine, titleStyle), new Segment("\n", Style.null(), true));
+    }
+    if (this.options.showHeader !== false) {
+      segments.push(
+        new Segment(
+          box.topLeft + this.columns.map(() => (box.top || "\u2500").repeat(colWidth + padding * 2)).join(box.topMid || "\u252C") + box.topRight,
+          borderStyle
+        ),
+        new Segment("\n", Style.null(), true)
+      );
+      segments.push(new Segment(box.left, borderStyle));
+      this.columns.forEach((col, i) => {
+        const text = this.alignText(col.header, colWidth, col.justify);
+        const cellStyle = col.headerStyle.combine(headerStyle);
+        segments.push(new Segment(paddingStr + text + paddingStr, cellStyle));
+        segments.push(
+          new Segment(
+            i === this.columns.length - 1 ? box.right : box.verticalMid || "\u2502",
+            borderStyle
+          )
+        );
+      });
+      segments.push(new Segment("\n", Style.null(), true));
+      segments.push(
+        new Segment(
+          (box.leftMid || "\u251C") + this.columns.map(() => (box.mid || "\u2500").repeat(colWidth + padding * 2)).join(box.midMid || "\u253C") + (box.rightMid || "\u2524"),
+          borderStyle
+        ),
+        new Segment("\n", Style.null(), true)
+      );
+    }
+    this.rows.forEach((row, rowIndex) => {
+      let rowStyle = Style.null();
+      if (rowStyles.length > 0) {
+        const styleStr = rowStyles[rowIndex % rowStyles.length];
+        if (styleStr) {
+          rowStyle = Style.parse(styleStr);
+        }
+      }
+      segments.push(new Segment(box.left, borderStyle));
+      this.columns.forEach((col, i) => {
+        const cell = row[i];
+        let cellSegments = [];
+        if (typeof cell === "string") {
+          const text = this.alignText(cell, colWidth, col.justify);
+          const cellStyle = col.style.combine(rowStyle);
+          cellSegments = [new Segment(paddingStr + text + paddingStr, cellStyle)];
+        } else if (isRenderable(cell)) {
+          const result = getRenderResult(cell, console, { ...consoleOptions, width: colWidth });
+          segments.push(new Segment(paddingStr));
+          cellSegments = result.segments.map((s) => {
+            return new Segment(s.text, s.style.combine(rowStyle), s.isControl);
+          });
+          const contentWidth = result.width ?? 0;
+          const space = Math.max(0, colWidth - contentWidth);
+          if (space > 0) {
+            cellSegments.push(new Segment(" ".repeat(space), rowStyle));
+          }
+          cellSegments.push(new Segment(paddingStr));
+        }
+        segments.push(...cellSegments);
+        segments.push(
+          new Segment(
+            i === this.columns.length - 1 ? box.right : box.verticalMid || "\u2502",
+            borderStyle
+          )
+        );
+      });
+      segments.push(new Segment("\n", Style.null(), true));
+      if (showLines && rowIndex < this.rows.length - 1) {
+        segments.push(
+          new Segment(
+            (box.leftMid || "\u251C") + this.columns.map(() => (box.mid || "\u2500").repeat(colWidth + padding * 2)).join(box.midMid || "\u253C") + (box.rightMid || "\u2524"),
+            borderStyle
+          ),
+          new Segment("\n", Style.null(), true)
+        );
+      }
+    });
+    if (this.options.showFooter && this.footerRow.length > 0) {
+      const footerStyle = typeof this.options.footerStyle === "string" ? Style.parse(this.options.footerStyle) : this.options.footerStyle ?? Style.parse("bold");
+      segments.push(
+        new Segment(
+          (box.leftMid || "\u251C") + this.columns.map(() => (box.mid || "\u2500").repeat(colWidth + padding * 2)).join(box.midMid || "\u253C") + (box.rightMid || "\u2524"),
+          borderStyle
+        ),
+        new Segment("\n", Style.null(), true)
+      );
+      segments.push(new Segment(box.left, borderStyle));
+      this.columns.forEach((col, i) => {
+        const cell = this.footerRow[i];
+        const text = typeof cell === "string" ? cell : "";
+        const alignedText = this.alignText(text, colWidth, col.justify);
+        segments.push(new Segment(paddingStr + alignedText + paddingStr, footerStyle));
+        segments.push(
+          new Segment(
+            i === this.columns.length - 1 ? box.right : box.verticalMid || "\u2502",
+            borderStyle
+          )
+        );
+      });
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    segments.push(
+      new Segment(
+        box.bottomLeft + this.columns.map(() => (box.bottom || "\u2500").repeat(colWidth + padding * 2)).join(box.bottomMid || "\u2534") + box.bottomRight,
+        borderStyle
+      ),
+      new Segment("\n", Style.null(), true)
+    );
+    if (this.options.caption) {
+      const captionStyle = typeof this.options.captionStyle === "string" ? Style.parse(this.options.captionStyle) : this.options.captionStyle ?? Style.parse("dim italic");
+      const captionLine = this.alignText(this.options.caption, width, "center");
+      segments.push(new Segment(captionLine, captionStyle), new Segment("\n", Style.null(), true));
+    }
+    return { segments, width };
+  }
+};
+
+// src/renderables/tree.ts
+var TREE_GUIDES = {
+  standard: {
+    branch: "\u251C\u2500\u2500 ",
+    last: "\u2514\u2500\u2500 ",
+    vertical: "\u2502   ",
+    space: "    "
+  },
+  bold: {
+    branch: "\u2523\u2501\u2501 ",
+    last: "\u2517\u2501\u2501 ",
+    vertical: "\u2503   ",
+    space: "    "
+  },
+  double: {
+    branch: "\u2560\u2550\u2550 ",
+    last: "\u255A\u2550\u2550 ",
+    vertical: "\u2551   ",
+    space: "    "
+  },
+  ascii: {
+    branch: "|-- ",
+    last: "`-- ",
+    vertical: "|   ",
+    space: "    "
+  }
+};
+var Tree = class _Tree {
+  constructor(label, options = {}) {
+    this.label = label;
+    this.options = options;
+    this.guideStyle = Style.parse(options.guideStyle ?? "#6e7681 dim");
+    if (options.guideStyle === "bold") {
+      this.guides = TREE_GUIDES.bold;
+    } else if (options.guideStyle === "double") {
+      this.guides = TREE_GUIDES.double;
+    } else if (options.guideStyle === "ascii") {
+      this.guides = TREE_GUIDES.ascii;
+    } else {
+      this.guides = TREE_GUIDES.standard;
+    }
+  }
+  children = [];
+  guideStyle;
+  guides;
+  /**
+   * Add a child node to the tree.
+   * Returns the added Tree node for method chaining.
+   */
+  add(label) {
+    if (label instanceof _Tree) {
+      this.children.push(label);
+      return label;
+    }
+    const node = new _Tree(label, this.options);
+    this.children.push(node);
+    return node;
+  }
+  __rich_console__(console, options) {
+    const segments = [];
+    if (!this.options.hideRoot) {
+      this.renderLabel(this.label, segments, console, options);
+      segments.push(new Segment("\n", Style.null(), true));
+    }
+    this.renderChildren(this.children, "", segments, console, options);
+    return { segments, width: 0 };
+  }
+  /**
+   * Render a label (string or renderable) and add segments.
+   */
+  renderLabel(label, segments, console, options) {
+    if (typeof label === "string") {
+      segments.push(new Segment(label));
+    } else if (isRenderable(label)) {
+      const result = label.__rich_console__(console, options);
+      if ("segments" in result) {
+        const labelSegments = result.segments.filter((s) => !s.isControl || s.text !== "\n");
+        segments.push(...labelSegments);
+      }
+    }
+  }
+  /**
+   * Render child nodes with appropriate prefixes.
+   */
+  renderChildren(children, prefix, segments, console, options) {
+    children.forEach((child, index) => {
+      const isLast = index === children.length - 1;
+      const connector = isLast ? this.guides.last : this.guides.branch;
+      const continuation = isLast ? this.guides.space : this.guides.vertical;
+      const labelSegments = [];
+      if (typeof child.label === "string") {
+        labelSegments.push(new Segment(child.label));
+      } else if (isRenderable(child.label)) {
+        const result = child.label.__rich_console__(console, options);
+        if ("segments" in result) {
+          labelSegments.push(...result.segments);
+        }
+      }
+      const labelLines = splitLines(labelSegments);
+      if (labelLines.length > 0) {
+        segments.push(new Segment(prefix, this.guideStyle));
+        segments.push(new Segment(connector, this.guideStyle));
+        segments.push(...labelLines[0]);
+        segments.push(new Segment("\n", Style.null(), true));
+      }
+      for (let i = 1; i < labelLines.length; i++) {
+        segments.push(new Segment(prefix, this.guideStyle));
+        segments.push(new Segment(continuation, this.guideStyle));
+        segments.push(...labelLines[i]);
+        segments.push(new Segment("\n", Style.null(), true));
+      }
+      const newPrefix = prefix + continuation;
+      this.renderChildren(child.children, newPrefix, segments, console, options);
+    });
+  }
+};
+
+// src/layout/grid.ts
+var Grid = class extends Layout {
+  constructor() {
+    super();
+  }
+  /**
+   * Adds a row to the grid with optional constraints.
+   */
+  addRow(content, options = {}) {
+    const layout = content instanceof Layout ? content : new Layout(content, options);
+    if (!(content instanceof Layout)) {
+      layout.size = options.size;
+      layout.ratio = options.ratio ?? 1;
+      layout.minimumSize = options.minimumSize ?? 0;
+    }
+    this.splitColumn(...this["_children"] || [], layout);
+  }
+};
+
+// src/renderables/padding.ts
+var Padding = class {
+  constructor(renderable, padding) {
+    this.renderable = renderable;
+    if (typeof padding === "number") {
+      this.top = this.right = this.bottom = this.left = padding;
+    } else if (Array.isArray(padding)) {
+      if (padding.length === 2) {
+        this.top = this.bottom = padding[0];
+        this.right = this.left = padding[1];
+      } else {
+        [this.top, this.right, this.bottom, this.left] = padding;
+      }
+    } else {
+      this.top = this.right = this.bottom = this.left = 0;
+    }
+  }
+  top;
+  right;
+  bottom;
+  left;
+  __rich_console__(console, options) {
+    const width = options.width ?? console.width;
+    const innerWidth = Math.max(0, width - this.left - this.right);
+    let contentSegments = [];
+    if (typeof this.renderable === "string") {
+      contentSegments = [new Segment(this.renderable)];
+    } else if (isRenderable(this.renderable)) {
+      const result = this.renderable.__rich_console__(console, { ...options, width: innerWidth });
+      if ("segments" in result) contentSegments = result.segments;
+    }
+    const lines = splitLines(contentSegments);
+    const segments = [];
+    for (let i = 0; i < this.top; i++) {
+      segments.push(new Segment(" ".repeat(width) + "\n"));
+    }
+    const leftPad = " ".repeat(this.left);
+    for (const line of lines) {
+      segments.push(new Segment(leftPad));
+      segments.push(...line);
+      segments.push(new Segment("\n"));
+    }
+    for (let i = 0; i < this.bottom; i++) {
+      segments.push(new Segment(" ".repeat(width) + "\n"));
+    }
+    return { segments, width };
+  }
+};
+
+// src/renderables/align.ts
+var Align = class _Align {
+  constructor(renderable, align, style) {
+    this.renderable = renderable;
+    this.align = align;
+    this.style = style;
+  }
+  static left(renderable) {
+    return new _Align(renderable, "left");
+  }
+  static center(renderable) {
+    return new _Align(renderable, "center");
+  }
+  static right(renderable) {
+    return new _Align(renderable, "right");
+  }
+  __rich_console__(console, options) {
+    const width = options.width ?? console.width;
+    let contentSegments = [];
+    if (typeof this.renderable === "string") {
+      contentSegments = [new Segment(this.renderable)];
+    } else if (isRenderable(this.renderable)) {
+      const result = this.renderable.__rich_console__(console, options);
+      if ("segments" in result) contentSegments = result.segments;
+    }
+    const lines = splitLines(contentSegments);
+    const segments = [];
+    for (const line of lines) {
+      const lineWidth = line.reduce((acc, s) => acc + s.cellLength(), 0);
+      const remaining = Math.max(0, width - lineWidth);
+      if (remaining === 0) {
+        segments.push(...line);
+      } else {
+        let leftSpace = 0;
+        if (this.align === "center") leftSpace = Math.floor(remaining / 2);
+        else if (this.align === "right") leftSpace = remaining;
+        if (leftSpace > 0) segments.push(new Segment(" ".repeat(leftSpace)));
+        segments.push(...line);
+      }
+      segments.push(new Segment("\n"));
+    }
+    return { segments, width };
+  }
+};
+var Prompt = class {
+  static async ask(message, options = {}) {
+    const console = options.console ?? new Console();
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true
+    });
+    const defaultStr = options.default !== void 0 ? ` [default: ${options.default}]` : "";
+    const choicesStr = options.choices ? ` [${options.choices.join("/")}]` : "";
+    const query = `${message}${choicesStr}${defaultStr}: `;
+    console.print(query);
+    return new Promise((resolve) => {
+      const askQuestion = () => {
+        process.stdout.write("> ");
+        rl.question("", (answer) => {
+          let value = answer.trim();
+          if (value === "" && options.default !== void 0) {
+            value = String(options.default);
+          }
+          if (options.choices && !options.choices.includes(value)) {
+            console.print(`[red]Please select one of: ${options.choices.join(", ")}[/]`);
+            askQuestion();
+            return;
+          }
+          if (options.validate) {
+            const validation = options.validate(value);
+            if (validation !== true) {
+              const msg = typeof validation === "string" ? validation : "Invalid input";
+              console.print(`[red]${msg}[/]`);
+              askQuestion();
+              return;
+            }
+          }
+          rl.close();
+          resolve(value);
+        });
+      };
+      askQuestion();
+    });
+  }
+};
+
+// src/prompt/confirm.ts
+var Confirm = class {
+  static async ask(message, options = {}) {
+    const defaultValue = options.default ?? true;
+    const choices = defaultValue ? ["Y", "n"] : ["y", "N"];
+    const answer = await Prompt.ask(message, {
+      ...options,
+      choices,
+      default: defaultValue ? "y" : "n",
+      validate: (input) => {
+        const norm2 = input.toLowerCase();
+        return norm2 === "y" || norm2 === "yes" || norm2 === "n" || norm2 === "no";
+      }
+    });
+    const norm = answer.toLowerCase();
+    return norm === "y" || norm === "yes";
+  }
+};
+
+// src/logging/handler.ts
+var RichHandler = class {
+  console;
+  constructor(console) {
+    this.console = console ?? new Console();
+  }
+  handle(record) {
+    const time = record.timestamp.toLocaleTimeString();
+    const levelStyle = this.getLevelStyle(record.level);
+    const parts = [
+      `[dim]${time}[/dim]`,
+      // Pad level to align messages
+      new Segment(` ${record.level.toUpperCase()} `.padEnd(7), levelStyle),
+      record.message
+    ];
+    if (record.context && Object.keys(record.context).length > 0) {
+      parts.push(`[dim]${JSON.stringify(record.context)}[/dim]`);
+    }
+    this.console.print(...parts);
+  }
+  getLevelStyle(level) {
+    switch (level) {
+      case "debug":
+        return Style.parse("dim cyan");
+      case "info":
+        return Style.parse("green");
+      case "warn":
+        return Style.parse("yellow");
+      case "error":
+        return Style.parse("bold red");
+      default:
+        return Style.null();
+    }
+  }
+};
+
+// src/hooks/install.ts
+function install(consoleOptions = {}) {
+  if (global.__rich_installed__) return;
+  const richConsole = new Console(consoleOptions);
+  const handler = new RichHandler(richConsole);
+  const originalLog = global.console.log;
+  const originalWarn = global.console.warn;
+  const originalError = global.console.error;
+  global.console.log = (...args) => {
+    richConsole.print(...args);
+  };
+  global.console.warn = (...args) => {
+    handler.handle({
+      level: "warn",
+      message: args.map(String).join(" "),
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  };
+  global.console.error = (...args) => {
+    handler.handle({
+      level: "error",
+      message: args.map(String).join(" "),
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  };
+  global.__rich_installed__ = true;
+  global.__rich_original_console__ = {
+    log: originalLog,
+    warn: originalWarn,
+    error: originalError
+  };
+}
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+var Markdown = class {
+  constructor(markup) {
+    this.markup = markup;
+  }
+  __rich_console__(_console, _options) {
+    const rendered = marked.parse(this.markup);
+    return {
+      segments: [new Segment(rendered)],
+      width: 0
+      // Placeholder
+    };
+  }
+};
+
+// src/progress/bar.ts
+var ProgressBar = class {
+  constructor(total = 100, completed = 0, options = {}) {
+    this.total = total;
+    this.completed = completed;
+    this.options = options;
+  }
+  pulseOffset = 0;
+  lastPulseTime = 0;
+  __rich_console__(console, consoleOptions) {
+    const width = this.options.width ?? Math.min(40, (consoleOptions.width ?? console.width) - 20);
+    const percentage = Math.min(1, Math.max(0, this.completed / this.total));
+    const isComplete = percentage >= 1;
+    const isPulse = this.options.pulse ?? false;
+    const completeChar = this.options.completeChar ?? "\u2501";
+    const remainingChar = this.options.remainingChar ?? "\u2501";
+    const completeStyleStr = isComplete ? this.options.finishedStyle ?? "#50fa7b bold" : this.options.completeStyle ?? "#61afef";
+    const remainingStyleStr = this.options.remainingStyle ?? "#3a3a3a dim";
+    const pulseStyleStr = this.options.pulseStyle ?? "#98c379 bold";
+    const completeStyle = Style.parse(completeStyleStr);
+    const remainingStyle = Style.parse(remainingStyleStr);
+    const pulseStyle = Style.parse(pulseStyleStr);
+    const filledWidth = Math.floor(width * percentage);
+    const segments = [];
+    if (isPulse && !isComplete) {
+      const now = Date.now();
+      if (now - this.lastPulseTime > 100) {
+        this.pulseOffset = (this.pulseOffset + 1) % width;
+        this.lastPulseTime = now;
+      }
+      for (let i = 0; i < width; i++) {
+        const isPulsePos = Math.abs(i - this.pulseOffset) < 3;
+        const style = isPulsePos ? pulseStyle : remainingStyle;
+        segments.push(new Segment(remainingChar, style));
+      }
+    } else {
+      if (filledWidth > 0) {
+        if (width >= 20 && !isComplete) {
+          const gradientColors = ["#61afef", "#66d9ef", "#50fa7b"];
+          for (let i = 0; i < filledWidth; i++) {
+            const colorIndex = Math.floor(i / filledWidth * gradientColors.length);
+            const color = gradientColors[Math.min(colorIndex, gradientColors.length - 1)];
+            segments.push(new Segment(completeChar, Style.parse(color)));
+          }
+        } else {
+          segments.push(new Segment(completeChar.repeat(filledWidth), completeStyle));
+        }
+      }
+      const remainingWidth = width - filledWidth;
+      if (remainingWidth > 0) {
+        segments.push(new Segment(remainingChar.repeat(remainingWidth), remainingStyle));
+      }
+    }
+    return {
+      segments,
+      width
+    };
+  }
+};
+var PercentageColumn = class {
+  constructor(percentage, style) {
+    this.percentage = percentage;
+    this.style = style;
+  }
+  __rich_console__(_console, _options) {
+    const pct = Math.floor(this.percentage * 100);
+    const text = `${pct.toString().padStart(3)}%`;
+    const style = Style.parse(this.style ?? (pct >= 100 ? "#50fa7b bold" : "#61afef"));
+    return {
+      segments: [new Segment(text, style)],
+      width: 4
+    };
+  }
+};
+var TimeElapsedColumn = class {
+  constructor(elapsedMs, style) {
+    this.elapsedMs = elapsedMs;
+    this.style = style;
+  }
+  __rich_console__(_console, _options) {
+    const seconds = Math.floor(this.elapsedMs / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    let text;
+    if (hours > 0) {
+      text = `${hours}:${(minutes % 60).toString().padStart(2, "0")}:${(seconds % 60).toString().padStart(2, "0")}`;
+    } else if (minutes > 0) {
+      text = `${minutes}:${(seconds % 60).toString().padStart(2, "0")}`;
+    } else {
+      text = `0:${seconds.toString().padStart(2, "0")}`;
+    }
+    const style = Style.parse(this.style ?? "#e5c07b");
+    return {
+      segments: [new Segment(text, style)],
+      width: text.length
+    };
+  }
+};
+var TimeRemainingColumn = class {
+  constructor(percentage, elapsedMs, style) {
+    this.percentage = percentage;
+    this.elapsedMs = elapsedMs;
+    this.style = style;
+  }
+  __rich_console__(_console, _options) {
+    if (this.percentage <= 0 || this.percentage >= 1) {
+      const text2 = "-:--";
+      return {
+        segments: [new Segment(text2, Style.parse(this.style ?? "dim"))],
+        width: 4
+      };
+    }
+    const estimatedTotal = this.elapsedMs / this.percentage;
+    const remainingMs = estimatedTotal - this.elapsedMs;
+    const seconds = Math.floor(remainingMs / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    let text;
+    if (hours > 0) {
+      text = `${hours}:${(minutes % 60).toString().padStart(2, "0")}:${(seconds % 60).toString().padStart(2, "0")}`;
+    } else if (minutes > 0) {
+      text = `${minutes}:${(seconds % 60).toString().padStart(2, "0")}`;
+    } else {
+      text = `0:${seconds.toString().padStart(2, "0")}`;
+    }
+    const style = Style.parse(this.style ?? "#c678dd");
+    return {
+      segments: [new Segment(text, style)],
+      width: text.length
+    };
+  }
+};
+
+// src/progress/progress.ts
+var Progress = class {
+  tasks = [];
+  live;
+  console;
+  taskIdCounter = 0;
+  constructor(options = {}) {
+    this.console = options.console ?? new Console();
+    this.live = new Live(new Layout(), this.console);
+  }
+  addTask(description, options = {}) {
+    const taskId = this.taskIdCounter++;
+    this.tasks.push({
+      id: taskId,
+      description,
+      total: options.total ?? 100,
+      completed: options.completed ?? 0,
+      visible: true,
+      finished: false,
+      startTime: Date.now(),
+      endTime: null
+    });
+    this.refresh();
+    return taskId;
+  }
+  update(taskId, options) {
+    const task = this.tasks.find((t) => t.id === taskId);
+    if (!task) return;
+    if (options.completed !== void 0) task.completed = options.completed;
+    if (options.description !== void 0) task.description = options.description;
+    if (task.completed >= task.total) {
+      task.finished = true;
+      task.endTime = Date.now();
+    }
+    this.refresh();
+  }
+  start() {
+    this.live.start();
+  }
+  stop() {
+    this.live.stop();
+  }
+  refresh() {
+    const layout = new Layout();
+    const children = this.tasks.filter((t) => t.visible).map((task) => {
+      const row = new Layout();
+      row.splitRow(
+        new Text(task.description, void 0, "right"),
+        // Label
+        new ProgressBar(task.total, task.completed),
+        // Bar
+        new Text(`${Math.floor(task.completed / task.total * 100)}%`)
+        // Percent
+      );
+      return row;
+    });
+    layout.splitColumn(...children);
+    this.live.update(layout);
+  }
+};
+
+// src/progress/track.ts
+function* track(sequence, description = "Working...") {
+  const progress = new Progress();
+  const arr = Array.isArray(sequence) ? sequence : Array.from(sequence);
+  const total = arr.length;
+  progress.start();
+  const taskId = progress.addTask(description, { total });
+  try {
+    for (let i = 0; i < total; i++) {
+      yield arr[i];
+      progress.update(taskId, { completed: i + 1 });
+    }
+  } finally {
+    progress.stop();
+  }
+}
+
+// src/logging/logger.ts
+var Logger = class {
+  handler;
+  constructor(console) {
+    this.handler = new RichHandler(console);
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  log(level, message, context) {
+    const record = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      context
+    };
+    this.handler.handle(record);
+  }
+};
+
+// src/utils/inspect.ts
+function inspect(obj, options = {}) {
+  const console = new Console();
+  const title = options.title ?? `Inspect: ${obj?.constructor?.name ?? typeof obj}`;
+  const table = new Table({ box: "single", showHeader: true });
+  table.addColumn("Property", { style: "cyan" });
+  table.addColumn("Type", { style: "magenta" });
+  table.addColumn("Value");
+  const props = Object.getOwnPropertyNames(obj);
+  props.sort();
+  for (const prop of props) {
+    const value = obj[prop];
+    let type = typeof value;
+    let valueStr = String(value);
+    if (value === null) type = "null";
+    else if (Array.isArray(value)) type = "Array";
+    if (valueStr.length > 50) valueStr = valueStr.substring(0, 47) + "...";
+    table.addRow(prop, type, valueStr);
+  }
+  let json = "";
+  try {
+    json = JSON.stringify(obj, null, 2);
+  } catch {
+    json = "[Circular]";
+  }
+  new Syntax(json, "json");
+  console.print(new Panel(table, { title, box: "round", borderStyle: void 0 }));
+}
+
+// src/index.ts
+var globalConsole = new Console();
+var print = globalConsole.print.bind(globalConsole);
+
+export { Align, Color, Confirm, Console, DEFAULT_THEME, DRACULA, GITHUB_LIGHT, Grid, Layout, Logger, MONOKAI, MONOKAI_THEME, Markdown, MarkupParser, ONE_DARK, Padding, Palette, Panel, PercentageColumn, Progress, ProgressBar, Prompt, RichHandler, Rule, SYNTAX_THEMES, Segment, Spinner, Status, Style, Syntax, Table, Text, Theme, TimeElapsedColumn, TimeRemainingColumn, Traceback, Tree, getBox, getTheme, inspect, install, installTracebackHandler, isRenderable, listBoxStyles, print, track };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map