terminal-richjs 0.1.0 → 0.2.1

package/dist/index.cjs

@@ -9,8 +9,6 @@ var chalk = require('chalk');
 var tinycolor = require('tinycolor2');
 var fs = require('fs');
 var hljs = require('highlight.js');
-var ansiEscapes = require('ansi-escapes');
-var cliSpinners = require('cli-spinners');
 var boxes = require('cli-boxes');
 var readline = require('readline');
 var marked = require('marked');
@@ -27,8 +25,6 @@ var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var tinycolor__default = /*#__PURE__*/_interopDefault(tinycolor);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 var hljs__default = /*#__PURE__*/_interopDefault(hljs);
-var ansiEscapes__default = /*#__PURE__*/_interopDefault(ansiEscapes);
-var cliSpinners__default = /*#__PURE__*/_interopDefault(cliSpinners);
 var boxes__default = /*#__PURE__*/_interopDefault(boxes);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 var TerminalRenderer__default = /*#__PURE__*/_interopDefault(TerminalRenderer);
@@ -70,6 +66,12 @@ var Terminal = class {
   }
 };
 var Style = class _Style {
+  /**
+   * Apply this style to text (alias for render).
+   */
+  apply(text) {
+    return this.render(text);
+  }
   color;
   backgroundColor;
   bold;
@@ -1053,253 +1055,488 @@ function getRenderResult(renderable, console, options) {
     // approximation
   };
 }
-var Live = class {
-  constructor(renderable, console, autoRefresh = true) {
-    this.renderable = renderable;
-    this.console = console;
-    this.autoRefresh = autoRefresh;
+
+// src/status/spinners.ts
+var SPINNERS = {
+  dots: {
+    interval: 80,
+    frames: "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F"
+  },
+  dots2: {
+    interval: 80,
+    frames: "\u28FE\u28FD\u28FB\u28BF\u287F\u28DF\u28EF\u28F7"
+  },
+  dots3: {
+    interval: 80,
+    frames: "\u280B\u2819\u281A\u281E\u2816\u2826\u2834\u2832\u2833\u2813"
+  },
+  line: {
+    interval: 130,
+    frames: ["-", "\\", "|", "/"]
+  },
+  line2: {
+    interval: 100,
+    frames: "\u2802-\u2013\u2014\u2013-"
+  },
+  pipe: {
+    interval: 100,
+    frames: "\u2524\u2518\u2534\u2514\u251C\u250C\u252C\u2510"
+  },
+  simpleDots: {
+    interval: 400,
+    frames: [".  ", ".. ", "...", "   "]
+  },
+  simpleDotsScrolling: {
+    interval: 200,
+    frames: [".  ", ".. ", "...", " ..", "  .", "   "]
+  },
+  star: {
+    interval: 70,
+    frames: "\u2736\u2738\u2739\u273A\u2739\u2737"
+  },
+  star2: {
+    interval: 80,
+    frames: "+x*"
+  },
+  flip: {
+    interval: 70,
+    frames: "___-``'\xB4-___"
+  },
+  hamburger: {
+    interval: 100,
+    frames: "\u2631\u2632\u2634"
+  },
+  growVertical: {
+    interval: 120,
+    frames: "\u2581\u2583\u2584\u2585\u2586\u2587\u2586\u2585\u2584\u2583"
+  },
+  growHorizontal: {
+    interval: 120,
+    frames: "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u258A\u258B\u258C\u258D\u258E"
+  },
+  balloon: {
+    interval: 140,
+    frames: " .oO@* "
+  },
+  balloon2: {
+    interval: 120,
+    frames: ".oO\xB0Oo."
+  },
+  noise: {
+    interval: 100,
+    frames: "\u2593\u2592\u2591"
+  },
+  bounce: {
+    interval: 120,
+    frames: "\u2801\u2802\u2804\u2802"
+  },
+  boxBounce: {
+    interval: 120,
+    frames: "\u2596\u2598\u259D\u2597"
+  },
+  boxBounce2: {
+    interval: 100,
+    frames: "\u258C\u2580\u2590\u2584"
+  },
+  triangle: {
+    interval: 50,
+    frames: "\u25E2\u25E3\u25E4\u25E5"
+  },
+  arc: {
+    interval: 100,
+    frames: "\u25DC\u25E0\u25DD\u25DE\u25E1\u25DF"
+  },
+  circle: {
+    interval: 120,
+    frames: "\u25E1\u2299\u25E0"
+  },
+  squareCorners: {
+    interval: 180,
+    frames: "\u25F0\u25F3\u25F2\u25F1"
+  },
+  circleQuarters: {
+    interval: 120,
+    frames: "\u25F4\u25F7\u25F6\u25F5"
+  },
+  circleHalves: {
+    interval: 50,
+    frames: "\u25D0\u25D3\u25D1\u25D2"
+  },
+  toggle: {
+    interval: 250,
+    frames: "\u22B6\u22B7"
+  },
+  toggle2: {
+    interval: 80,
+    frames: "\u25AB\u25AA"
+  },
+  toggle3: {
+    interval: 120,
+    frames: "\u25A1\u25A0"
+  },
+  arrow: {
+    interval: 100,
+    frames: "\u2190\u2196\u2191\u2197\u2192\u2198\u2193\u2199"
+  },
+  arrow3: {
+    interval: 120,
+    frames: ["\u25B9\u25B9\u25B9\u25B9\u25B9", "\u25B8\u25B9\u25B9\u25B9\u25B9", "\u25B9\u25B8\u25B9\u25B9\u25B9", "\u25B9\u25B9\u25B8\u25B9\u25B9", "\u25B9\u25B9\u25B9\u25B8\u25B9", "\u25B9\u25B9\u25B9\u25B9\u25B8"]
+  },
+  bouncingBar: {
+    interval: 80,
+    frames: [
+      "[    ]",
+      "[=   ]",
+      "[==  ]",
+      "[=== ]",
+      "[ ===]",
+      "[  ==]",
+      "[   =]",
+      "[    ]",
+      "[   =]",
+      "[  ==]",
+      "[ ===]",
+      "[====]",
+      "[=== ]",
+      "[==  ]",
+      "[=   ]"
+    ]
+  },
+  bouncingBall: {
+    interval: 80,
+    frames: [
+      "( \u25CF    )",
+      "(  \u25CF   )",
+      "(   \u25CF  )",
+      "(    \u25CF )",
+      "(     \u25CF)",
+      "(    \u25CF )",
+      "(   \u25CF  )",
+      "(  \u25CF   )",
+      "( \u25CF    )",
+      "(\u25CF     )"
+    ]
+  },
+  smiley: {
+    interval: 200,
+    frames: ["\u{1F604} ", "\u{1F61D} "]
+  },
+  monkey: {
+    interval: 300,
+    frames: ["\u{1F648} ", "\u{1F648} ", "\u{1F649} ", "\u{1F64A} "]
+  },
+  hearts: {
+    interval: 100,
+    frames: ["\u{1F49B} ", "\u{1F499} ", "\u{1F49C} ", "\u{1F49A} ", "\u2764\uFE0F "]
+  },
+  clock: {
+    interval: 100,
+    frames: ["\u{1F55B} ", "\u{1F550} ", "\u{1F551} ", "\u{1F552} ", "\u{1F553} ", "\u{1F554} ", "\u{1F555} ", "\u{1F556} ", "\u{1F557} ", "\u{1F558} ", "\u{1F559} ", "\u{1F55A} "]
+  },
+  earth: {
+    interval: 180,
+    frames: ["\u{1F30D} ", "\u{1F30E} ", "\u{1F30F} "]
+  },
+  moon: {
+    interval: 80,
+    frames: ["\u{1F311} ", "\u{1F312} ", "\u{1F313} ", "\u{1F314} ", "\u{1F315} ", "\u{1F316} ", "\u{1F317} ", "\u{1F318} "]
+  },
+  runner: {
+    interval: 140,
+    frames: ["\u{1F6B6} ", "\u{1F3C3} "]
+  },
+  weather: {
+    interval: 100,
+    frames: [
+      "\u2600\uFE0F ",
+      "\u{1F324} ",
+      "\u26C5\uFE0F ",
+      "\u{1F325} ",
+      "\u2601\uFE0F ",
+      "\u{1F327} ",
+      "\u{1F328} ",
+      "\u26C8 ",
+      "\u{1F327} ",
+      "\u2601\uFE0F ",
+      "\u{1F325} ",
+      "\u26C5\uFE0F ",
+      "\u{1F324} ",
+      "\u2600\uFE0F "
+    ]
+  },
+  christmas: {
+    interval: 400,
+    frames: "\u{1F332}\u{1F384}"
+  },
+  point: {
+    interval: 125,
+    frames: ["\u2219\u2219\u2219", "\u25CF\u2219\u2219", "\u2219\u25CF\u2219", "\u2219\u2219\u25CF", "\u2219\u2219\u2219"]
+  },
+  layer: {
+    interval: 150,
+    frames: "-=\u2261"
+  },
+  aesthetic: {
+    interval: 80,
+    frames: [
+      "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1",
+      "\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1",
+      "\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1\u25B1",
+      "\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1\u25B1",
+      "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1\u25B1",
+      "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B1",
+      "\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0\u25B0",
+      "\u25B0\u25B1\u25B1\u25B1\u25B1\u25B1\u25B1"
+    ]
+  }
+};
+function getSpinner(name) {
+  return SPINNERS[name];
+}
+function listSpinners() {
+  return Object.keys(SPINNERS);
+}
+
+// src/status/spinner.ts
+var Spinner = class {
+  name;
+  frames;
+  interval;
+  text;
+  style;
+  speed;
+  startTime = null;
+  frameNoOffset = 0;
+  constructor(name = "dots", options = {}) {
+    const spinner = SPINNERS[name];
+    if (!spinner) {
+      throw new Error(`No spinner called '${name}'. Use listSpinners() to see available spinners.`);
+    }
+    this.name = name;
+    this.frames = typeof spinner.frames === "string" ? [...spinner.frames] : [...spinner.frames];
+    this.interval = spinner.interval;
+    this.text = options.text ?? "";
+    this.style = options.style ?? "green";
+    this.speed = options.speed ?? 1;
+  }
+  /**
+   * Render the spinner for a given time.
+   */
+  render(time) {
+    if (this.startTime === null) {
+      this.startTime = time;
+    }
+    const frameNo = (time - this.startTime) * this.speed / (this.interval / 1e3) + this.frameNoOffset;
+    const frame = this.frames[Math.floor(frameNo) % this.frames.length];
+    const styledFrame = Style.parse(this.style).apply(frame);
+    if (this.text) {
+      return `${styledFrame} ${this.text}`;
+    }
+    return styledFrame;
+  }
+  /**
+   * Get the current frame without time advancement (for static rendering).
+   */
+  getCurrentFrame() {
+    const now = Date.now() / 1e3;
+    return this.render(now);
+  }
+  /**
+   * Update spinner properties.
+   */
+  update(options) {
+    if (options.text !== void 0) this.text = options.text;
+    if (options.style !== void 0) this.style = options.style;
+    if (options.speed !== void 0) {
+      this.frameNoOffset = this.startTime !== null ? (Date.now() / 1e3 - this.startTime) * this.speed / (this.interval / 1e3) + this.frameNoOffset : 0;
+      this.startTime = Date.now() / 1e3;
+      this.speed = options.speed;
+    }
+  }
+  __rich_console__(_console, _consoleOptions) {
+    const frame = this.getCurrentFrame();
+    return {
+      segments: [new Segment(`${frame}
+`, Style.null())],
+      width: frame.length
+    };
+  }
+};
+function listSpinners2() {
+  return Object.keys(SPINNERS);
+}
+
+// src/status/status.ts
+var Status = class {
+  spinner;
+  message;
+  interval = null;
+  started = false;
+  lastRenderedLines = 0;
+  constructor(message, options = {}) {
+    this.message = message;
+    this.spinner = new Spinner(options.spinnerName ?? "dots");
   }
-  _started = false;
-  _lastHeight = 0;
   start() {
-    this._started = true;
+    if (this.started) return;
+    this.started = true;
+    process.stdout.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      this.refresh();
+    }, this.spinner.interval);
     this.refresh();
   }
   stop() {
-    this._started = false;
-    this.console.print("");
+    if (!this.started) return;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.lastRenderedLines > 0) {
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+      for (let i = 0; i < this.lastRenderedLines; i++) {
+        process.stdout.write("\x1B[2K\n");
+      }
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+    }
+    process.stdout.write("\x1B[?25h");
+    this.started = false;
   }
-  update(renderable) {
-    this.renderable = renderable;
-    this.refresh();
+  update(message) {
+    this.message = message;
+    if (this.started) {
+      this.refresh();
+    }
   }
   refresh() {
-    if (!this._started) return;
-    if (this._lastHeight > 0) {
-      process.stdout.write(ansiEscapes__default.default.eraseLines(this._lastHeight));
+    if (this.lastRenderedLines > 0) {
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+      for (let i = 0; i < this.lastRenderedLines; i++) {
+        process.stdout.write("\x1B[2K\n");
+      }
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
     }
-    const output = this.console.render(this.renderable);
-    const lines = output.split("\n").length;
-    this._lastHeight = lines;
+    const frame = this.spinner.getCurrentFrame();
+    const output = `${frame} ${this.message}
+`;
+    this.lastRenderedLines = 1;
     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__default.default[name];
+
+// src/console/console.ts
+var Console = class {
+  error(message) {
+    const text = String(message);
+    process2__default.default.stderr.write(`\x1B[31m${text}\x1B[0m
+`);
   }
-  frame = 0;
-  // @ts-ignore
-  spinner;
-  get currentFrame() {
-    return this.spinner.frames[this.frame];
+  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);
   }
-  __rich_console__(_console, _options) {
-    return {
-      segments: [new Segment(this.currentFrame, this.style)],
-      width: 1
-      // approximates
-    };
+  get width() {
+    return this.options.width ?? this.terminal.width;
   }
-  nextFrame() {
-    this.frame = (this.frame + 1) % this.spinner.frames.length;
+  get height() {
+    return this.options.height ?? this.terminal.height;
   }
-};
-
-// 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);
+  /**
+   * 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}
+`);
   }
-  if (currentLine.length > 0) {
-    lines.push(currentLine);
+  /**
+   * Prints a formatted exception.
+   */
+  printException(error) {
+    const traceback = new Traceback(error);
+    this.print(traceback);
   }
-  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;
+  /**
+   * Displays a status spinner.
+   */
+  status(message, options = {}) {
+    return new Status(message, { spinnerName: options.spinner, ...options });
   }
   /**
-   * Split the layout into a row (horizontal split).
+   * Run a task with a status spinner.
    */
-  splitRow(...layouts) {
-    this._direction = "row";
-    this._children = layouts.map((l) => l instanceof _Layout ? l : new _Layout(l));
+  async withStatus(message, task, options = {}) {
+    const status = new Status(message, { spinnerName: options.spinner });
+    status.start();
+    try {
+      return await task(status);
+    } finally {
+      status.stop();
+    }
   }
   /**
-   * Split the layout into a column (vertical split).
+   * Renders a renderable object to a string.
    */
-  splitColumn(...layouts) {
-    this._direction = "column";
-    this._children = layouts.map((l) => l instanceof _Layout ? l : new _Layout(l));
+  render(renderable) {
+    const result = getRenderResult(renderable, this, this.options);
+    return result.segments.map((s) => s.render()).join("");
   }
-  get renderable() {
-    return this._renderable;
+  /**
+   * 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__default.default(rendered, this.width, { hard: true });
   }
-  update(renderable) {
-    this._renderable = renderable;
+  /**
+   * Low-level write to stdout.
+   */
+  write(text) {
+    process2__default.default.stdout.write(text);
+  }
+};
+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) {
-    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__default.default(text, width, { hard: true, trim: false });
+    const text = this.segments.map((s) => s.render()).join("");
+    let wrapped = text;
+    if (!this.noWrap) {
+      wrapped = wrapAnsi__default.default(text, width, { hard: true, trim: false });
     }
     const resultSegments = wrapped.split("\n").flatMap((line) => {
       return [new Segment(line), new Segment("\n", Style.null(), true)];
@@ -1310,131 +1547,6 @@ var Text = class {
     };
   }
 };
-
-// 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__default.default(rendered, this.width, { hard: true });
-  }
-  /**
-   * Low-level write to stdout.
-   */
-  write(text) {
-    process2__default.default.stdout.write(text);
-  }
-};
 var CUSTOM_BOXES = {
   // Rounded corners (may not be in all versions of cli-boxes)
   rounded: {
@@ -1643,6 +1755,39 @@ function listBoxStyles() {
   const cliBoxStyles = Object.keys(boxes__default.default);
   return [.../* @__PURE__ */ new Set([...customStyles, ...cliBoxStyles])];
 }
+
+// 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)];
+}
 var Panel = class _Panel {
   constructor(renderable, options = {}) {
     this.renderable = renderable;
@@ -2156,6 +2301,145 @@ var Tree = class _Tree {
   }
 };
 
+// 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;
+  }
+};
+
 // src/layout/grid.ts
 var Grid = class extends Layout {
   constructor() {
@@ -2268,6 +2552,187 @@ var Align = class _Align {
     return { segments, width };
   }
 };
+
+// src/renderables/columns.ts
+var Columns = class {
+  renderables;
+  options;
+  constructor(renderables = [], options = {}) {
+    this.renderables = Array.from(renderables);
+    this.options = {
+      padding: options.padding ?? 1,
+      expand: options.expand ?? false,
+      equal: options.equal ?? false,
+      columnFirst: options.columnFirst ?? false,
+      rightToLeft: options.rightToLeft ?? false,
+      ...options
+    };
+  }
+  /**
+   * Add a renderable to the columns.
+   */
+  add(renderable) {
+    this.renderables.push(renderable);
+    return this;
+  }
+  __rich_console__(console, consoleOptions) {
+    if (this.renderables.length === 0) {
+      return { segments: [], width: 0 };
+    }
+    const items = this.renderables.map((r) => {
+      if (typeof r === "string") {
+        return r;
+      }
+      const result = r.__rich_console__(console, consoleOptions);
+      if ("segments" in result) {
+        return result.segments.map((s) => s.text).join("");
+      }
+      return "";
+    });
+    const terminalWidth = consoleOptions.width ?? console.width ?? 80;
+    const padding = this.options.padding ?? 1;
+    const paddingStr = " ".repeat(padding);
+    let columnWidth;
+    if (this.options.width) {
+      columnWidth = this.options.width;
+    } else if (this.options.equal) {
+      columnWidth = Math.max(...items.map((item) => this.getDisplayWidth(item)));
+    } else {
+      columnWidth = Math.max(...items.map((item) => this.getDisplayWidth(item)));
+    }
+    const columnCount = Math.max(
+      1,
+      Math.floor((terminalWidth + padding) / (columnWidth + padding))
+    );
+    const lines = [];
+    if (this.options.title) {
+      lines.push(this.options.title);
+    }
+    const rows = [];
+    if (this.options.columnFirst) {
+      const rowCount = Math.ceil(items.length / columnCount);
+      for (let row = 0; row < rowCount; row++) {
+        const rowItems = [];
+        for (let col = 0; col < columnCount; col++) {
+          const index = col * rowCount + row;
+          if (index < items.length) {
+            rowItems.push(this.padItem(items[index], columnWidth));
+          }
+        }
+        rows.push(rowItems);
+      }
+    } else {
+      for (let i = 0; i < items.length; i += columnCount) {
+        const rowItems = [];
+        for (let j = 0; j < columnCount && i + j < items.length; j++) {
+          rowItems.push(this.padItem(items[i + j], columnWidth));
+        }
+        rows.push(rowItems);
+      }
+    }
+    for (const row of rows) {
+      let rowItems = row;
+      if (this.options.rightToLeft) {
+        rowItems = [...row].reverse();
+      }
+      lines.push(rowItems.join(paddingStr));
+    }
+    const output = `${lines.join("\n")}
+`;
+    return {
+      segments: [new Segment(output, Style.null())],
+      width: terminalWidth
+    };
+  }
+  /**
+   * Get the display width of a string (accounting for ANSI codes).
+   */
+  getDisplayWidth(text) {
+    const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
+    return stripped.length;
+  }
+  /**
+   * Pad an item to the specified width.
+   */
+  padItem(item, width) {
+    const currentWidth = this.getDisplayWidth(item);
+    if (currentWidth >= width) {
+      return item;
+    }
+    return item + " ".repeat(width - currentWidth);
+  }
+};
+
+// src/renderables/json.ts
+var JSON2 = class _JSON {
+  text;
+  highlight;
+  constructor(json, options = {}) {
+    const { indent = 2, sortKeys = false } = options;
+    this.highlight = options.highlight ?? true;
+    try {
+      let data = globalThis.JSON.parse(json);
+      if (sortKeys && typeof data === "object" && data !== null) {
+        data = this.sortObject(data);
+      }
+      this.text = globalThis.JSON.stringify(data, null, indent);
+    } catch {
+      this.text = json;
+    }
+  }
+  /**
+   * Create JSON from any data object.
+   */
+  static fromData(data, options = {}) {
+    const { indent = 2, sortKeys = false } = options;
+    let processedData = data;
+    if (sortKeys && typeof data === "object" && data !== null) {
+      processedData = _JSON.prototype.sortObject(data);
+    }
+    const json = globalThis.JSON.stringify(processedData, null, indent);
+    const instance = new _JSON(json, { ...options, sortKeys: false });
+    return instance;
+  }
+  sortObject(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.sortObject(item));
+    }
+    if (obj !== null && typeof obj === "object") {
+      const sorted = {};
+      const keys = Object.keys(obj).sort();
+      for (const key of keys) {
+        sorted[key] = this.sortObject(obj[key]);
+      }
+      return sorted;
+    }
+    return obj;
+  }
+  /**
+   * Apply JSON syntax highlighting.
+   */
+  highlightJSON(text) {
+    if (!this.highlight) {
+      return text;
+    }
+    const highlighted = text.replace(/"([^"\\]|\\.)*"/g, (match) => {
+      return Style.parse("#f1fa8c").apply(match);
+    }).replace(/\b(-?\d+\.?\d*(?:e[+-]?\d+)?)\b/gi, (match) => {
+      return Style.parse("#bd93f9").apply(match);
+    }).replace(/\b(true|false)\b/g, (match) => {
+      return match === "true" ? Style.parse("#50fa7b").apply(match) : Style.parse("#ff79c6").apply(match);
+    }).replace(/\bnull\b/g, (match) => {
+      return Style.parse("#8be9fd italic").apply(match);
+    });
+    return highlighted;
+  }
+  __rich_console__(_console, _consoleOptions) {
+    const highlighted = this.highlightJSON(this.text);
+    return {
+      segments: [new Segment(highlighted + "\n", Style.null())],
+      width: this.text.split("\n").reduce((max, line) => Math.max(max, line.length), 0)
+    };
+  }
+};
 var Prompt = class {
   static async ask(message, options = {}) {
     const console = options.console ?? new Console();
@@ -2422,6 +2887,9 @@ var ProgressBar = class {
     this.completed = completed;
     this.options = options;
   }
+  render(_arg0) {
+    throw new Error("Method not implemented.");
+  }
   pulseOffset = 0;
   lastPulseTime = 0;
   __rich_console__(console, consoleOptions) {
@@ -2551,13 +3019,10 @@ var TimeRemainingColumn = class {
 // 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);
-  }
+  started = false;
+  refreshInterval = null;
+  lastRenderedLines = 0;
   addTask(description, options = {}) {
     const taskId = this.taskIdCounter++;
     this.tasks.push({
@@ -2585,27 +3050,50 @@ var Progress = class {
     this.refresh();
   }
   start() {
-    this.live.start();
+    if (this.started) return;
+    this.started = true;
+    process.stdout.write("\x1B[?25l");
+    this.refreshInterval = setInterval(() => this.refresh(), 100);
+    this.refresh();
   }
   stop() {
-    this.live.stop();
+    if (!this.started) return;
+    if (this.refreshInterval) {
+      clearInterval(this.refreshInterval);
+      this.refreshInterval = null;
+    }
+    process.stdout.write("\x1B[?25h");
+    this.started = false;
   }
   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);
+    if (!this.started) return;
+    if (this.lastRenderedLines > 0) {
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+      for (let i = 0; i < this.lastRenderedLines; i++) {
+        process.stdout.write("\x1B[2K\n");
+      }
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+    }
+    const lines = [];
+    for (const task of this.tasks.filter((t) => t.visible)) {
+      const percent = Math.floor(task.completed / task.total * 100);
+      const barStr = this.renderSimpleBar(task.completed, task.total, 30);
+      const percentStyle = percent >= 100 ? Style.parse("#50fa7b bold") : Style.parse("#61afef");
+      lines.push(`${task.description.padEnd(20)} ${barStr} ${percentStyle.apply(`${percent}%`)}`);
+    }
+    const output = lines.join("\n") + "\n";
+    this.lastRenderedLines = lines.length;
+    process.stdout.write(output);
+  }
+  renderSimpleBar(completed, total, width) {
+    const percentage = Math.min(1, Math.max(0, completed / total));
+    const filledWidth = Math.floor(width * percentage);
+    const remainingWidth = width - filledWidth;
+    const filledStyle = percentage >= 1 ? Style.parse("#50fa7b bold") : Style.parse("#61afef");
+    const remainingStyle = Style.parse("#3a3a3a dim");
+    const filled = filledStyle.apply("\u2501".repeat(filledWidth));
+    const remaining = remainingStyle.apply("\u2501".repeat(remainingWidth));
+    return filled + remaining;
   }
 };
 
@@ -2626,6 +3114,293 @@ function* track(sequence, description = "Working...") {
   }
 }
 
+// src/live/live.ts
+var Live = class {
+  transient;
+  started = false;
+  refreshThread = null;
+  lastRenderedLines = 0;
+  currentContent = "";
+  constructor(options = {}) {
+    this.transient = options.transient ?? false;
+  }
+  /**
+   * Check if live display is currently running.
+   */
+  get isStarted() {
+    return this.started;
+  }
+  /**
+   * Update the displayed content.
+   */
+  update(content) {
+    this.currentContent = content;
+  }
+  /**
+   * Refresh the display with current content.
+   */
+  refresh() {
+    if (!this.started) return;
+    if (this.lastRenderedLines > 0) {
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+      for (let i = 0; i < this.lastRenderedLines; i++) {
+        process.stdout.write("\x1B[2K\n");
+      }
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+    }
+    this.lastRenderedLines = (this.currentContent.match(/\n/g) || []).length + 1;
+    process.stdout.write(`${this.currentContent}
+`);
+  }
+  /**
+   * Start live display with a callback function.
+   * The callback receives an update function to change the displayed content.
+   */
+  async start(callback) {
+    if (this.started) {
+      throw new Error("Live display already started");
+    }
+    this.started = true;
+    process.stdout.write("\x1B[?25l");
+    const updateFn = (content) => {
+      this.currentContent = content;
+      this.refresh();
+    };
+    try {
+      await callback(updateFn);
+    } finally {
+      this.stop();
+    }
+  }
+  /**
+   * Stop live display.
+   */
+  stop() {
+    if (!this.started) return;
+    if (this.refreshThread) {
+      clearInterval(this.refreshThread);
+      this.refreshThread = null;
+    }
+    process.stdout.write("\x1B[?25h");
+    if (this.transient && this.lastRenderedLines > 0) {
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+      for (let i = 0; i < this.lastRenderedLines; i++) {
+        process.stdout.write("\x1B[2K\n");
+      }
+      process.stdout.write(`\x1B[${this.lastRenderedLines}A`);
+    }
+    this.started = false;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/emoji.ts
+var EMOJI = {
+  // Common emojis
+  rocket: "\u{1F680}",
+  star: "\u2B50",
+  sparkles: "\u2728",
+  fire: "\u{1F525}",
+  heart: "\u2764\uFE0F",
+  thumbs_up: "\u{1F44D}",
+  thumbs_down: "\u{1F44E}",
+  clap: "\u{1F44F}",
+  wave: "\u{1F44B}",
+  ok_hand: "\u{1F44C}",
+  // Faces
+  smile: "\u{1F60A}",
+  grin: "\u{1F601}",
+  joy: "\u{1F602}",
+  wink: "\u{1F609}",
+  thinking: "\u{1F914}",
+  sunglasses: "\u{1F60E}",
+  heart_eyes: "\u{1F60D}",
+  sob: "\u{1F62D}",
+  angry: "\u{1F620}",
+  scream: "\u{1F631}",
+  skull: "\u{1F480}",
+  ghost: "\u{1F47B}",
+  robot: "\u{1F916}",
+  // Status
+  check: "\u2705",
+  check_mark: "\u2714\uFE0F",
+  x: "\u274C",
+  cross_mark: "\u274C",
+  warning: "\u26A0\uFE0F",
+  exclamation: "\u2757",
+  question: "\u2753",
+  info: "\u2139\uFE0F",
+  bulb: "\u{1F4A1}",
+  gear: "\u2699\uFE0F",
+  wrench: "\u{1F527}",
+  hammer: "\u{1F528}",
+  bug: "\u{1F41B}",
+  construction: "\u{1F6A7}",
+  // Weather & Nature
+  sun: "\u2600\uFE0F",
+  moon: "\u{1F319}",
+  cloud: "\u2601\uFE0F",
+  rain: "\u{1F327}\uFE0F",
+  snow: "\u2744\uFE0F",
+  thunder: "\u26A1",
+  rainbow: "\u{1F308}",
+  tree: "\u{1F333}",
+  flower: "\u{1F338}",
+  leaf: "\u{1F343}",
+  // Objects
+  book: "\u{1F4D6}",
+  books: "\u{1F4DA}",
+  pencil: "\u270F\uFE0F",
+  pen: "\u{1F58A}\uFE0F",
+  clipboard: "\u{1F4CB}",
+  folder: "\u{1F4C1}",
+  file_folder: "\u{1F4C1}",
+  package: "\u{1F4E6}",
+  inbox: "\u{1F4E5}",
+  outbox: "\u{1F4E4}",
+  email: "\u{1F4E7}",
+  computer: "\u{1F4BB}",
+  keyboard: "\u2328\uFE0F",
+  phone: "\u{1F4F1}",
+  camera: "\u{1F4F7}",
+  video_camera: "\u{1F4F9}",
+  clock: "\u{1F550}",
+  hourglass: "\u23F3",
+  key: "\u{1F511}",
+  lock: "\u{1F512}",
+  unlock: "\u{1F513}",
+  link: "\u{1F517}",
+  trophy: "\u{1F3C6}",
+  medal: "\u{1F3C5}",
+  crown: "\u{1F451}",
+  gem: "\u{1F48E}",
+  money: "\u{1F4B0}",
+  coin: "\u{1FA99}",
+  // Arrows & Symbols
+  arrow_right: "\u27A1\uFE0F",
+  arrow_left: "\u2B05\uFE0F",
+  arrow_up: "\u2B06\uFE0F",
+  arrow_down: "\u2B07\uFE0F",
+  arrow_forward: "\u25B6\uFE0F",
+  arrow_backward: "\u25C0\uFE0F",
+  play: "\u25B6\uFE0F",
+  pause: "\u23F8\uFE0F",
+  stop: "\u23F9\uFE0F",
+  refresh: "\u{1F504}",
+  plus: "\u2795",
+  minus: "\u2796",
+  // Animals
+  dog: "\u{1F415}",
+  cat: "\u{1F408}",
+  bird: "\u{1F426}",
+  fish: "\u{1F41F}",
+  butterfly: "\u{1F98B}",
+  bee: "\u{1F41D}",
+  snake: "\u{1F40D}",
+  turtle: "\u{1F422}",
+  crab: "\u{1F980}",
+  octopus: "\u{1F419}",
+  unicorn: "\u{1F984}",
+  dragon: "\u{1F409}",
+  // Food & Drink
+  coffee: "\u2615",
+  tea: "\u{1F375}",
+  beer: "\u{1F37A}",
+  wine: "\u{1F377}",
+  pizza: "\u{1F355}",
+  burger: "\u{1F354}",
+  fries: "\u{1F35F}",
+  taco: "\u{1F32E}",
+  sushi: "\u{1F363}",
+  apple: "\u{1F34E}",
+  banana: "\u{1F34C}",
+  cake: "\u{1F382}",
+  cookie: "\u{1F36A}",
+  // Celebrations
+  party: "\u{1F389}",
+  balloon: "\u{1F388}",
+  confetti: "\u{1F38A}",
+  gift: "\u{1F381}",
+  christmas_tree: "\u{1F384}",
+  fireworks: "\u{1F386}",
+  // Hands
+  point_up: "\u261D\uFE0F",
+  point_down: "\u{1F447}",
+  point_left: "\u{1F448}",
+  point_right: "\u{1F449}",
+  raised_hand: "\u270B",
+  fist: "\u270A",
+  v: "\u270C\uFE0F",
+  muscle: "\u{1F4AA}",
+  pray: "\u{1F64F}",
+  // Transport
+  car: "\u{1F697}",
+  bus: "\u{1F68C}",
+  train: "\u{1F686}",
+  plane: "\u2708\uFE0F",
+  ship: "\u{1F6A2}",
+  bike: "\u{1F6B2}",
+  // Places
+  house: "\u{1F3E0}",
+  office: "\u{1F3E2}",
+  hospital: "\u{1F3E5}",
+  school: "\u{1F3EB}",
+  globe: "\u{1F30D}",
+  earth: "\u{1F30D}",
+  earth_americas: "\u{1F30E}",
+  earth_asia: "\u{1F30F}",
+  // Colors
+  red_circle: "\u{1F534}",
+  orange_circle: "\u{1F7E0}",
+  yellow_circle: "\u{1F7E1}",
+  green_circle: "\u{1F7E2}",
+  blue_circle: "\u{1F535}",
+  purple_circle: "\u{1F7E3}",
+  white_circle: "\u26AA",
+  black_circle: "\u26AB",
+  // Misc
+  zap: "\u26A1",
+  boom: "\u{1F4A5}",
+  hundred: "\u{1F4AF}",
+  zzz: "\u{1F4A4}",
+  speech_balloon: "\u{1F4AC}",
+  thought_balloon: "\u{1F4AD}",
+  mega: "\u{1F4E3}",
+  bell: "\u{1F514}",
+  pin: "\u{1F4CC}",
+  scissors: "\u2702\uFE0F",
+  art: "\u{1F3A8}",
+  music: "\u{1F3B5}",
+  notes: "\u{1F3B6}",
+  mic: "\u{1F3A4}",
+  headphones: "\u{1F3A7}",
+  game: "\u{1F3AE}",
+  dice: "\u{1F3B2}",
+  // Programming
+  terminal: "\u{1F4BB}",
+  code: "\u{1F4BB}",
+  database: "\u{1F5C4}\uFE0F",
+  api: "\u{1F50C}",
+  test_tube: "\u{1F9EA}",
+  microscope: "\u{1F52C}",
+  satellite: "\u{1F6F0}\uFE0F",
+  atom: "\u269B\uFE0F"
+};
+function replaceEmoji(text) {
+  return text.replace(/:([a-z0-9_]+):/gi, (match, name) => {
+    const emoji = EMOJI[name.toLowerCase()];
+    return emoji ?? match;
+  });
+}
+function listEmoji() {
+  return Object.keys(EMOJI);
+}
+function hasEmoji(name) {
+  return name.toLowerCase() in EMOJI;
+}
+
 // src/logging/logger.ts
 var Logger = class {
   handler;
@@ -2690,13 +3465,17 @@ var print = globalConsole.print.bind(globalConsole);
 
 exports.Align = Align;
 exports.Color = Color;
+exports.Columns = Columns;
 exports.Confirm = Confirm;
 exports.Console = Console;
 exports.DEFAULT_THEME = DEFAULT_THEME;
 exports.DRACULA = DRACULA;
+exports.EMOJI = EMOJI;
 exports.GITHUB_LIGHT = GITHUB_LIGHT;
 exports.Grid = Grid;
+exports.JSON = JSON2;
 exports.Layout = Layout;
+exports.Live = Live;
 exports.Logger = Logger;
 exports.MONOKAI = MONOKAI;
 exports.MONOKAI_THEME = MONOKAI_THEME;
@@ -2712,6 +3491,7 @@ exports.ProgressBar = ProgressBar;
 exports.Prompt = Prompt;
 exports.RichHandler = RichHandler;
 exports.Rule = Rule;
+exports.SPINNERS = SPINNERS;
 exports.SYNTAX_THEMES = SYNTAX_THEMES;
 exports.Segment = Segment;
 exports.Spinner = Spinner;
@@ -2726,13 +3506,20 @@ exports.TimeRemainingColumn = TimeRemainingColumn;
 exports.Traceback = Traceback;
 exports.Tree = Tree;
 exports.getBox = getBox;
+exports.getSpinner = getSpinner;
+exports.getSpinnerNames = listSpinners;
 exports.getTheme = getTheme;
+exports.hasEmoji = hasEmoji;
 exports.inspect = inspect;
 exports.install = install;
 exports.installTracebackHandler = installTracebackHandler;
 exports.isRenderable = isRenderable;
 exports.listBoxStyles = listBoxStyles;
+exports.listEmoji = listEmoji;
+exports.listSpinners = listSpinners2;
 exports.print = print;
+exports.replaceEmoji = replaceEmoji;
+exports.sleep = sleep;
 exports.track = track;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map