@opentui/core 0.1.7 → 0.1.8

package/index.js

@@ -1,4 +1,32 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __require = import.meta.require;
+
 // src/Renderable.ts
 import { EventEmitter as EventEmitter3 } from "events";
 
@@ -2014,6 +2042,74 @@ function parseAlign(value) {
       return Align.Auto;
   }
 }
+function parseBoxSizing(value) {
+  switch (value.toLowerCase()) {
+    case "border-box":
+      return BoxSizing.BorderBox;
+    case "content-box":
+      return BoxSizing.ContentBox;
+    default:
+      return BoxSizing.BorderBox;
+  }
+}
+function parseDimension(value) {
+  switch (value.toLowerCase()) {
+    case "width":
+      return Dimension.Width;
+    case "height":
+      return Dimension.Height;
+    default:
+      return Dimension.Width;
+  }
+}
+function parseDirection(value) {
+  switch (value.toLowerCase()) {
+    case "inherit":
+      return Direction.Inherit;
+    case "ltr":
+      return Direction.LTR;
+    case "rtl":
+      return Direction.RTL;
+    default:
+      return Direction.LTR;
+  }
+}
+function parseDisplay(value) {
+  switch (value.toLowerCase()) {
+    case "flex":
+      return Display.Flex;
+    case "none":
+      return Display.None;
+    case "contents":
+      return Display.Contents;
+    default:
+      return Display.Flex;
+  }
+}
+function parseEdge(value) {
+  switch (value.toLowerCase()) {
+    case "left":
+      return Edge.Left;
+    case "top":
+      return Edge.Top;
+    case "right":
+      return Edge.Right;
+    case "bottom":
+      return Edge.Bottom;
+    case "start":
+      return Edge.Start;
+    case "end":
+      return Edge.End;
+    case "horizontal":
+      return Edge.Horizontal;
+    case "vertical":
+      return Edge.Vertical;
+    case "all":
+      return Edge.All;
+    default:
+      return Edge.All;
+  }
+}
 function parseFlexDirection(value) {
   switch (value.toLowerCase()) {
     case "column":
@@ -2028,6 +2124,18 @@ function parseFlexDirection(value) {
       return FlexDirection.Column;
   }
 }
+function parseGutter(value) {
+  switch (value.toLowerCase()) {
+    case "column":
+      return Gutter.Column;
+    case "row":
+      return Gutter.Row;
+    case "all":
+      return Gutter.All;
+    default:
+      return Gutter.All;
+  }
+}
 function parseJustify(value) {
   switch (value.toLowerCase()) {
     case "flex-start":
@@ -2046,6 +2154,48 @@ function parseJustify(value) {
       return Justify.FlexStart;
   }
 }
+function parseLogLevel(value) {
+  switch (value.toLowerCase()) {
+    case "error":
+      return LogLevel.Error;
+    case "warn":
+      return LogLevel.Warn;
+    case "info":
+      return LogLevel.Info;
+    case "debug":
+      return LogLevel.Debug;
+    case "verbose":
+      return LogLevel.Verbose;
+    case "fatal":
+      return LogLevel.Fatal;
+    default:
+      return LogLevel.Info;
+  }
+}
+function parseMeasureMode(value) {
+  switch (value.toLowerCase()) {
+    case "undefined":
+      return MeasureMode.Undefined;
+    case "exactly":
+      return MeasureMode.Exactly;
+    case "at-most":
+      return MeasureMode.AtMost;
+    default:
+      return MeasureMode.Undefined;
+  }
+}
+function parseOverflow(value) {
+  switch (value.toLowerCase()) {
+    case "visible":
+      return Overflow.Visible;
+    case "hidden":
+      return Overflow.Hidden;
+    case "scroll":
+      return Overflow.Scroll;
+    default:
+      return Overflow.Visible;
+  }
+}
 function parsePositionType(value) {
   switch (value.toLowerCase()) {
     case "static":
@@ -2058,6 +2208,32 @@ function parsePositionType(value) {
       return PositionType.Static;
   }
 }
+function parseUnit(value) {
+  switch (value.toLowerCase()) {
+    case "undefined":
+      return Unit.Undefined;
+    case "point":
+      return Unit.Point;
+    case "percent":
+      return Unit.Percent;
+    case "auto":
+      return Unit.Auto;
+    default:
+      return Unit.Point;
+  }
+}
+function parseWrap(value) {
+  switch (value.toLowerCase()) {
+    case "no-wrap":
+      return Wrap.NoWrap;
+    case "wrap":
+      return Wrap.Wrap;
+    case "wrap-reverse":
+      return Wrap.WrapReverse;
+    default:
+      return Wrap.NoWrap;
+  }
+}
 
 // src/Renderable.ts
 var LayoutEvents;
@@ -2117,6 +2293,9 @@ function isPositionType(value) {
   }
   return isValidPercentage(value);
 }
+function isPostionTypeType(value) {
+  return value === "relative" || value === "absolute";
+}
 function isDimensionType(value) {
   return isPositionType(value);
 }
@@ -2160,6 +2339,10 @@ class Renderable extends EventEmitter3 {
   _focused = false;
   keyHandler = getKeyHandler();
   keypressHandler = null;
+  _live = false;
+  _liveCount = 0;
+  _mouseListeners = {};
+  _keyListeners = {};
   layoutNode;
   _positionType = "relative";
   _position = {};
@@ -2185,9 +2368,12 @@ class Renderable extends EventEmitter3 {
     this._zIndex = options.zIndex ?? 0;
     this._visible = options.visible !== false;
     this.buffered = options.buffered ?? false;
+    this._live = options.live ?? false;
+    this._liveCount = this._live && this._visible ? 1 : 0;
     this.layoutNode = createTrackedNode({ renderable: this });
     this.layoutNode.yogaNode.setDisplay(this._visible ? Display.Flex : Display.None);
     this.setupYogaProperties(options);
+    this.applyEventOptions(options);
     if (this.buffered) {
       this.createFrameBuffer();
     }
@@ -2196,8 +2382,18 @@ class Renderable extends EventEmitter3 {
     return this._visible;
   }
   set visible(value) {
+    if (this._visible === value)
+      return;
+    const wasVisible = this._visible;
     this._visible = value;
     this.layoutNode.yogaNode.setDisplay(value ? Display.Flex : Display.None);
+    if (this._live) {
+      if (!wasVisible && value) {
+        this.propagateLiveCount(1);
+      } else if (wasVisible && !value) {
+        this.propagateLiveCount(-1);
+      }
+    }
     if (this._focused) {
       this.blur();
     }
@@ -2221,6 +2417,7 @@ class Renderable extends EventEmitter3 {
     this._focused = true;
     this.needsUpdate();
     this.keypressHandler = (key) => {
+      this._keyListeners["down"]?.(key);
       if (this.handleKeyPress) {
         this.handleKeyPress(key);
       }
@@ -2242,6 +2439,25 @@ class Renderable extends EventEmitter3 {
   get focused() {
     return this._focused;
   }
+  get live() {
+    return this._live;
+  }
+  get liveCount() {
+    return this._liveCount;
+  }
+  set live(value) {
+    if (this._live === value)
+      return;
+    this._live = value;
+    if (this._visible) {
+      const delta = value ? 1 : -1;
+      this.propagateLiveCount(delta);
+    }
+  }
+  propagateLiveCount(delta) {
+    this._liveCount += delta;
+    this.parent?.propagateLiveCount(delta);
+  }
   get isDirty() {
     return this._dirty;
   }
@@ -2379,7 +2595,7 @@ class Renderable extends EventEmitter3 {
       this._height = options.height;
       this.layoutNode.setHeight(options.height);
     }
-    this._positionType = options.position ?? "relative";
+    this._positionType = options.position === "absolute" ? "absolute" : "relative";
     if (this._positionType !== "relative") {
       node.setPositionType(parsePositionType(this._positionType));
     }
@@ -2441,7 +2657,7 @@ class Renderable extends EventEmitter3 {
     }
   }
   set position(positionType) {
-    if (this._positionType === positionType)
+    if (!isPostionTypeType(positionType) || this._positionType === positionType)
       return;
     this._positionType = positionType;
     this.layoutNode.yogaNode.setPositionType(parsePositionType(positionType));
@@ -2704,6 +2920,9 @@ class Renderable extends EventEmitter3 {
     }
     this.needsZIndexSort = true;
     this.renderableMap.set(obj.id, obj);
+    if (obj._liveCount > 0) {
+      this.propagateLiveCount(obj._liveCount);
+    }
     this.requestLayout();
     this.emit("child:added", obj);
     return insertedIndex;
@@ -2737,6 +2956,9 @@ class Renderable extends EventEmitter3 {
     if (this.renderableMap.has(id)) {
       const obj = this.renderableMap.get(id);
       if (obj) {
+        if (obj._liveCount > 0) {
+          this.propagateLiveCount(-obj._liveCount);
+        }
         const childLayoutNode = obj.getLayoutNode();
         this.layoutNode.removeChild(childLayoutNode);
         this.requestLayout();
@@ -2801,19 +3023,107 @@ class Renderable extends EventEmitter3 {
   }
   destroySelf() {}
   processMouseEvent(event) {
+    this._mouseListeners[event.type]?.(event);
     this.onMouseEvent(event);
     if (this.parent && !event.defaultPrevented) {
       this.parent.processMouseEvent(event);
     }
   }
   onMouseEvent(event) {}
+  set onMouseDown(handler) {
+    if (handler)
+      this._mouseListeners["down"] = handler;
+    else
+      delete this._mouseListeners["down"];
+  }
+  set onMouseUp(handler) {
+    if (handler)
+      this._mouseListeners["up"] = handler;
+    else
+      delete this._mouseListeners["up"];
+  }
+  set onMouseMove(handler) {
+    if (handler)
+      this._mouseListeners["move"] = handler;
+    else
+      delete this._mouseListeners["move"];
+  }
+  set onMouseDrag(handler) {
+    if (handler)
+      this._mouseListeners["drag"] = handler;
+    else
+      delete this._mouseListeners["drag"];
+  }
+  set onMouseDragEnd(handler) {
+    if (handler)
+      this._mouseListeners["drag-end"] = handler;
+    else
+      delete this._mouseListeners["drag-end"];
+  }
+  set onMouseDrop(handler) {
+    if (handler)
+      this._mouseListeners["drop"] = handler;
+    else
+      delete this._mouseListeners["drop"];
+  }
+  set onMouseOver(handler) {
+    if (handler)
+      this._mouseListeners["over"] = handler;
+    else
+      delete this._mouseListeners["over"];
+  }
+  set onMouseOut(handler) {
+    if (handler)
+      this._mouseListeners["out"] = handler;
+    else
+      delete this._mouseListeners["out"];
+  }
+  set onMouseScroll(handler) {
+    if (handler)
+      this._mouseListeners["scroll"] = handler;
+    else
+      delete this._mouseListeners["scroll"];
+  }
+  set onKeyDown(handler) {
+    if (handler)
+      this._keyListeners["down"] = handler;
+    else
+      delete this._keyListeners["down"];
+  }
+  get onKeyDown() {
+    return this._keyListeners["down"];
+  }
+  applyEventOptions(options) {
+    if (options.onMouseDown)
+      this.onMouseDown = options.onMouseDown;
+    if (options.onMouseUp)
+      this.onMouseUp = options.onMouseUp;
+    if (options.onMouseMove)
+      this.onMouseMove = options.onMouseMove;
+    if (options.onMouseDrag)
+      this.onMouseDrag = options.onMouseDrag;
+    if (options.onMouseDragEnd)
+      this.onMouseDragEnd = options.onMouseDragEnd;
+    if (options.onMouseDrop)
+      this.onMouseDrop = options.onMouseDrop;
+    if (options.onMouseOver)
+      this.onMouseOver = options.onMouseOver;
+    if (options.onMouseOut)
+      this.onMouseOut = options.onMouseOut;
+    if (options.onMouseScroll)
+      this.onMouseScroll = options.onMouseScroll;
+    if (options.onKeyDown)
+      this.onKeyDown = options.onKeyDown;
+  }
 }
 
 class RootRenderable extends Renderable {
   yogaConfig;
-  constructor(width, height, ctx) {
+  rootContext;
+  constructor(width, height, ctx, rootContext) {
     super("__root__", { zIndex: 0, visible: true, width, height, enableLayout: true });
     this.ctx = ctx;
+    this.rootContext = rootContext;
     this.yogaConfig = src_default.Config.create();
     this.yogaConfig.setUseWebDefaults(false);
     this.yogaConfig.setPointScaleFactor(1);
@@ -2829,13 +3139,22 @@ class RootRenderable extends Renderable {
   requestLayout() {
     this.needsUpdate();
   }
+  propagateLiveCount(delta) {
+    const oldCount = this._liveCount;
+    this._liveCount += delta;
+    if (oldCount === 0 && this._liveCount > 0) {
+      this.rootContext.requestLive();
+    } else if (oldCount > 0 && this._liveCount === 0) {
+      this.rootContext.dropLive();
+    }
+  }
   calculateLayout() {
     this.layoutNode.yogaNode.calculateLayout(this.width, this.height, Direction.LTR);
     this.emit("layout-changed" /* LAYOUT_CHANGED */);
   }
   resize(width, height) {
-    this.layoutNode.setWidth(width);
-    this.layoutNode.setHeight(height);
+    this.width = width;
+    this.height = height;
     this.emit("resized" /* RESIZED */, { width, height });
   }
   beforeRender() {
@@ -2853,111 +3172,26 @@ class RootRenderable extends Renderable {
     super.destroySelf();
   }
 }
-// src/utils.ts
-function hexToRgb(hex) {
-  hex = hex.replace(/^#/, "");
-  if (hex.length === 3) {
-    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
-  }
-  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
-    console.warn(`Invalid hex color: ${hex}, defaulting to magenta`);
-    return RGBA.fromValues(1, 0, 1, 1);
-  }
-  const r = parseInt(hex.substring(0, 2), 16) / 255;
-  const g = parseInt(hex.substring(2, 4), 16) / 255;
-  const b = parseInt(hex.substring(4, 6), 16) / 255;
-  return RGBA.fromValues(r, g, b, 1);
-}
-function rgbToHex(rgb) {
-  return "#" + [rgb.r, rgb.g, rgb.b].map((x) => {
-    const hex = Math.floor(Math.max(0, Math.min(1, x) * 255)).toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-  }).join("");
-}
-function hsvToRgb(h, s, v) {
-  let r = 0, g = 0, b = 0;
-  const i = Math.floor(h / 60) % 6;
-  const f = h / 60 - Math.floor(h / 60);
-  const p = v * (1 - s);
-  const q = v * (1 - f * s);
-  const t = v * (1 - (1 - f) * s);
-  switch (i) {
-    case 0:
-      r = v;
-      g = t;
-      b = p;
-      break;
-    case 1:
-      r = q;
-      g = v;
-      b = p;
-      break;
-    case 2:
-      r = p;
-      g = v;
-      b = t;
-      break;
-    case 3:
-      r = p;
-      g = q;
-      b = v;
-      break;
-    case 4:
-      r = t;
-      g = p;
-      b = v;
-      break;
-    case 5:
-      r = v;
-      g = p;
-      b = q;
-      break;
-  }
-  return RGBA.fromValues(r, g, b, 1);
-}
-var CSS_COLOR_NAMES = {
-  black: "#000000",
-  white: "#FFFFFF",
-  red: "#FF0000",
-  green: "#008000",
-  blue: "#0000FF",
-  yellow: "#FFFF00",
-  cyan: "#00FFFF",
-  magenta: "#FF00FF",
-  silver: "#C0C0C0",
-  gray: "#808080",
-  grey: "#808080",
-  maroon: "#800000",
-  olive: "#808000",
-  lime: "#00FF00",
-  aqua: "#00FFFF",
-  teal: "#008080",
-  navy: "#000080",
-  fuchsia: "#FF00FF",
-  purple: "#800080",
-  orange: "#FFA500",
-  brightblack: "#666666",
-  brightred: "#FF6666",
-  brightgreen: "#66FF66",
-  brightblue: "#6666FF",
-  brightyellow: "#FFFF66",
-  brightcyan: "#66FFFF",
-  brightmagenta: "#FF66FF",
-  brightwhite: "#FFFFFF"
+// src/types.ts
+var TextAttributes = {
+  NONE: 0,
+  BOLD: 1 << 0,
+  DIM: 1 << 1,
+  ITALIC: 1 << 2,
+  UNDERLINE: 1 << 3,
+  BLINK: 1 << 4,
+  INVERSE: 1 << 5,
+  HIDDEN: 1 << 6,
+  STRIKETHROUGH: 1 << 7
 };
-function parseColor(color) {
-  if (typeof color === "string") {
-    const lowerColor = color.toLowerCase();
-    if (lowerColor === "transparent") {
-      return RGBA.fromValues(0, 0, 0, 0);
-    }
-    if (CSS_COLOR_NAMES[lowerColor]) {
-      return hexToRgb(CSS_COLOR_NAMES[lowerColor]);
-    }
-    return hexToRgb(color);
-  }
-  return color;
-}
+var DebugOverlayCorner;
+((DebugOverlayCorner2) => {
+  DebugOverlayCorner2[DebugOverlayCorner2["topLeft"] = 0] = "topLeft";
+  DebugOverlayCorner2[DebugOverlayCorner2["topRight"] = 1] = "topRight";
+  DebugOverlayCorner2[DebugOverlayCorner2["bottomLeft"] = 2] = "bottomLeft";
+  DebugOverlayCorner2[DebugOverlayCorner2["bottomRight"] = 3] = "bottomRight";
+})(DebugOverlayCorner ||= {});
+// src/utils.ts
 function createTextAttributes({
   bold = false,
   italic = false,
@@ -2987,15 +3221,110 @@ function createTextAttributes({
     attributes |= TextAttributes.STRIKETHROUGH;
   return attributes;
 }
-
-// src/types.ts
-class RGBA {
-  buffer;
-  constructor(buffer) {
-    this.buffer = buffer;
+// src/lib/border.ts
+var BorderChars = {
+  single: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    topT: "\u252C",
+    bottomT: "\u2534",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    cross: "\u253C"
+  },
+  double: {
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    horizontal: "\u2550",
+    vertical: "\u2551",
+    topT: "\u2566",
+    bottomT: "\u2569",
+    leftT: "\u2560",
+    rightT: "\u2563",
+    cross: "\u256C"
+  },
+  rounded: {
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    topT: "\u252C",
+    bottomT: "\u2534",
+    leftT: "\u251C",
+    rightT: "\u2524",
+    cross: "\u253C"
+  },
+  heavy: {
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B",
+    horizontal: "\u2501",
+    vertical: "\u2503",
+    topT: "\u2533",
+    bottomT: "\u253B",
+    leftT: "\u2523",
+    rightT: "\u252B",
+    cross: "\u254B"
   }
-  static fromArray(array) {
-    return new RGBA(array);
+};
+function getBorderFromSides(sides) {
+  const result = [];
+  if (sides.top)
+    result.push("top");
+  if (sides.right)
+    result.push("right");
+  if (sides.bottom)
+    result.push("bottom");
+  if (sides.left)
+    result.push("left");
+  return result.length > 0 ? result : false;
+}
+function getBorderSides(border) {
+  return border === true ? { top: true, right: true, bottom: true, left: true } : Array.isArray(border) ? {
+    top: border.includes("top"),
+    right: border.includes("right"),
+    bottom: border.includes("bottom"),
+    left: border.includes("left")
+  } : { top: false, right: false, bottom: false, left: false };
+}
+function borderCharsToArray(chars) {
+  const array = new Uint32Array(11);
+  array[0] = chars.topLeft.codePointAt(0);
+  array[1] = chars.topRight.codePointAt(0);
+  array[2] = chars.bottomLeft.codePointAt(0);
+  array[3] = chars.bottomRight.codePointAt(0);
+  array[4] = chars.horizontal.codePointAt(0);
+  array[5] = chars.vertical.codePointAt(0);
+  array[6] = chars.topT.codePointAt(0);
+  array[7] = chars.bottomT.codePointAt(0);
+  array[8] = chars.leftT.codePointAt(0);
+  array[9] = chars.rightT.codePointAt(0);
+  array[10] = chars.cross.codePointAt(0);
+  return array;
+}
+var BorderCharArrays = {
+  single: borderCharsToArray(BorderChars.single),
+  double: borderCharsToArray(BorderChars.double),
+  rounded: borderCharsToArray(BorderChars.rounded),
+  heavy: borderCharsToArray(BorderChars.heavy)
+};
+// src/lib/RGBA.ts
+class RGBA {
+  buffer;
+  constructor(buffer) {
+    this.buffer = buffer;
+  }
+  static fromArray(array) {
+    return new RGBA(array);
   }
   static fromValues(r, g, b, a = 1) {
     return new RGBA(new Float32Array([r, g, b, a]));
@@ -3040,863 +3369,110 @@ class RGBA {
     return `rgba(${this.r.toFixed(2)}, ${this.g.toFixed(2)}, ${this.b.toFixed(2)}, ${this.a.toFixed(2)})`;
   }
 }
-var TextAttributes = {
-  NONE: 0,
-  BOLD: 1 << 0,
-  DIM: 1 << 1,
-  ITALIC: 1 << 2,
-  UNDERLINE: 1 << 3,
-  BLINK: 1 << 4,
-  INVERSE: 1 << 5,
-  HIDDEN: 1 << 6,
-  STRIKETHROUGH: 1 << 7
-};
-var DebugOverlayCorner;
-((DebugOverlayCorner2) => {
-  DebugOverlayCorner2[DebugOverlayCorner2["topLeft"] = 0] = "topLeft";
-  DebugOverlayCorner2[DebugOverlayCorner2["topRight"] = 1] = "topRight";
-  DebugOverlayCorner2[DebugOverlayCorner2["bottomLeft"] = 2] = "bottomLeft";
-  DebugOverlayCorner2[DebugOverlayCorner2["bottomRight"] = 3] = "bottomRight";
-})(DebugOverlayCorner ||= {});
-// src/zig.ts
-import { dlopen, toArrayBuffer } from "bun:ffi";
-import { existsSync } from "fs";
-
-// src/text-buffer.ts
-class TextBuffer {
-  lib;
-  bufferPtr;
-  buffer;
-  _length = 0;
-  _capacity;
-  _lineInfo;
-  constructor(lib, ptr, buffer, capacity) {
-    this.lib = lib;
-    this.bufferPtr = ptr;
-    this.buffer = buffer;
-    this._capacity = capacity;
-  }
-  static create(capacity = 256) {
-    const lib = resolveRenderLib();
-    return lib.createTextBuffer(capacity);
-  }
-  syncBuffersAfterResize() {
-    const capacity = this.lib.textBufferGetCapacity(this.bufferPtr);
-    this.buffer = this.lib.getTextBufferArrays(this.bufferPtr, capacity);
-    this._capacity = capacity;
-  }
-  setStyledText(text) {
-    this.lib.textBufferReset(this.bufferPtr);
-    this._length = 0;
-    this._lineInfo = undefined;
-    for (const chunk of text.chunks) {
-      const result = this.lib.textBufferWriteChunk(this.bufferPtr, chunk.text, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
-      if (result & 1) {
-        this.syncBuffersAfterResize();
-      }
-    }
-    this.lib.textBufferFinalizeLineInfo(this.bufferPtr);
-    this._length = this.lib.textBufferGetLength(this.bufferPtr);
-  }
-  setDefaultFg(fg) {
-    this.lib.textBufferSetDefaultFg(this.bufferPtr, fg);
-  }
-  setDefaultBg(bg) {
-    this.lib.textBufferSetDefaultBg(this.bufferPtr, bg);
-  }
-  setDefaultAttributes(attributes) {
-    this.lib.textBufferSetDefaultAttributes(this.bufferPtr, attributes);
-  }
-  resetDefaults() {
-    this.lib.textBufferResetDefaults(this.bufferPtr);
-  }
-  get length() {
-    return this._length;
+function hexToRgb(hex) {
+  hex = hex.replace(/^#/, "");
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
   }
-  get capacity() {
-    return this._capacity;
+  if (!/^[0-9A-Fa-f]{6}$/.test(hex)) {
+    console.warn(`Invalid hex color: ${hex}, defaulting to magenta`);
+    return RGBA.fromValues(1, 0, 1, 1);
   }
-  get ptr() {
-    return this.bufferPtr;
+  const r = parseInt(hex.substring(0, 2), 16) / 255;
+  const g = parseInt(hex.substring(2, 4), 16) / 255;
+  const b = parseInt(hex.substring(4, 6), 16) / 255;
+  return RGBA.fromValues(r, g, b, 1);
+}
+function rgbToHex(rgb) {
+  return "#" + [rgb.r, rgb.g, rgb.b].map((x) => {
+    const hex = Math.floor(Math.max(0, Math.min(1, x) * 255)).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+function hsvToRgb(h, s, v) {
+  let r = 0, g = 0, b = 0;
+  const i = Math.floor(h / 60) % 6;
+  const f = h / 60 - Math.floor(h / 60);
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  switch (i) {
+    case 0:
+      r = v;
+      g = t;
+      b = p;
+      break;
+    case 1:
+      r = q;
+      g = v;
+      b = p;
+      break;
+    case 2:
+      r = p;
+      g = v;
+      b = t;
+      break;
+    case 3:
+      r = p;
+      g = q;
+      b = v;
+      break;
+    case 4:
+      r = t;
+      g = p;
+      b = v;
+      break;
+    case 5:
+      r = v;
+      g = p;
+      b = q;
+      break;
   }
-  get lineInfo() {
-    if (!this._lineInfo) {
-      this._lineInfo = this.lib.textBufferGetLineInfo(this.bufferPtr);
+  return RGBA.fromValues(r, g, b, 1);
+}
+var CSS_COLOR_NAMES = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  silver: "#C0C0C0",
+  gray: "#808080",
+  grey: "#808080",
+  maroon: "#800000",
+  olive: "#808000",
+  lime: "#00FF00",
+  aqua: "#00FFFF",
+  teal: "#008080",
+  navy: "#000080",
+  fuchsia: "#FF00FF",
+  purple: "#800080",
+  orange: "#FFA500",
+  brightblack: "#666666",
+  brightred: "#FF6666",
+  brightgreen: "#66FF66",
+  brightblue: "#6666FF",
+  brightyellow: "#FFFF66",
+  brightcyan: "#66FFFF",
+  brightmagenta: "#FF66FF",
+  brightwhite: "#FFFFFF"
+};
+function parseColor(color) {
+  if (typeof color === "string") {
+    const lowerColor = color.toLowerCase();
+    if (lowerColor === "transparent") {
+      return RGBA.fromValues(0, 0, 0, 0);
     }
-    return this._lineInfo;
-  }
-  toString() {
-    const chars = [];
-    for (let i = 0;i < this._length; i++) {
-      chars.push(String.fromCharCode(this.buffer.char[i]));
+    if (CSS_COLOR_NAMES[lowerColor]) {
+      return hexToRgb(CSS_COLOR_NAMES[lowerColor]);
     }
-    return chars.join("");
-  }
-  concat(other) {
-    return this.lib.textBufferConcat(this.bufferPtr, other.bufferPtr);
-  }
-  setSelection(start, end, bgColor, fgColor) {
-    this.lib.textBufferSetSelection(this.bufferPtr, start, end, bgColor || null, fgColor || null);
-  }
-  resetSelection() {
-    this.lib.textBufferResetSelection(this.bufferPtr);
-  }
-  destroy() {
-    this.lib.destroyTextBuffer(this.bufferPtr);
+    return hexToRgb(color);
   }
+  return color;
 }
-
-// src/zig.ts
-var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
-var targetLibPath = module.default;
-if (!existsSync(targetLibPath)) {
-  throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
-}
-function getOpenTUILib(libPath) {
-  const resolvedLibPath = libPath || targetLibPath;
-  return dlopen(resolvedLibPath, {
-    createRenderer: {
-      args: ["u32", "u32"],
-      returns: "ptr"
-    },
-    destroyRenderer: {
-      args: ["ptr", "bool", "u32"],
-      returns: "void"
-    },
-    setUseThread: {
-      args: ["ptr", "bool"],
-      returns: "void"
-    },
-    setBackgroundColor: {
-      args: ["ptr", "ptr"],
-      returns: "void"
-    },
-    setRenderOffset: {
-      args: ["ptr", "u32"],
-      returns: "void"
-    },
-    updateStats: {
-      args: ["ptr", "f64", "u32", "f64"],
-      returns: "void"
-    },
-    updateMemoryStats: {
-      args: ["ptr", "u32", "u32", "u32"],
-      returns: "void"
-    },
-    render: {
-      args: ["ptr", "bool"],
-      returns: "void"
-    },
-    getNextBuffer: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    getCurrentBuffer: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    createOptimizedBuffer: {
-      args: ["u32", "u32", "bool"],
-      returns: "ptr"
-    },
-    destroyOptimizedBuffer: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    drawFrameBuffer: {
-      args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "u32", "u32"],
-      returns: "void"
-    },
-    getBufferWidth: {
-      args: ["ptr"],
-      returns: "u32"
-    },
-    getBufferHeight: {
-      args: ["ptr"],
-      returns: "u32"
-    },
-    bufferClear: {
-      args: ["ptr", "ptr"],
-      returns: "void"
-    },
-    bufferGetCharPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    bufferGetFgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    bufferGetBgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    bufferGetAttributesPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    bufferGetRespectAlpha: {
-      args: ["ptr"],
-      returns: "bool"
-    },
-    bufferSetRespectAlpha: {
-      args: ["ptr", "bool"],
-      returns: "void"
-    },
-    bufferDrawText: {
-      args: ["ptr", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
-      returns: "void"
-    },
-    bufferSetCellWithAlphaBlending: {
-      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
-      returns: "void"
-    },
-    bufferFillRect: {
-      args: ["ptr", "u32", "u32", "u32", "u32", "ptr"],
-      returns: "void"
-    },
-    bufferResize: {
-      args: ["ptr", "u32", "u32"],
-      returns: "void"
-    },
-    resizeRenderer: {
-      args: ["ptr", "u32", "u32"],
-      returns: "void"
-    },
-    setCursorPosition: {
-      args: ["i32", "i32", "bool"],
-      returns: "void"
-    },
-    setCursorStyle: {
-      args: ["ptr", "u32", "bool"],
-      returns: "void"
-    },
-    setCursorColor: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    setDebugOverlay: {
-      args: ["ptr", "bool", "u8"],
-      returns: "void"
-    },
-    clearTerminal: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    bufferDrawSuperSampleBuffer: {
-      args: ["ptr", "u32", "u32", "ptr", "usize", "u8", "u32"],
-      returns: "void"
-    },
-    bufferDrawPackedBuffer: {
-      args: ["ptr", "ptr", "usize", "u32", "u32", "u32", "u32"],
-      returns: "void"
-    },
-    bufferDrawBox: {
-      args: ["ptr", "i32", "i32", "u32", "u32", "ptr", "u32", "ptr", "ptr", "ptr", "u32"],
-      returns: "void"
-    },
-    addToHitGrid: {
-      args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
-      returns: "void"
-    },
-    checkHit: {
-      args: ["ptr", "u32", "u32"],
-      returns: "u32"
-    },
-    dumpHitGrid: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    dumpBuffers: {
-      args: ["ptr", "i64"],
-      returns: "void"
-    },
-    dumpStdoutBuffer: {
-      args: ["ptr", "i64"],
-      returns: "void"
-    },
-    enableMouse: {
-      args: ["ptr", "bool"],
-      returns: "void"
-    },
-    disableMouse: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    createTextBuffer: {
-      args: ["u32"],
-      returns: "ptr"
-    },
-    destroyTextBuffer: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    textBufferGetCharPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetFgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetBgPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetAttributesPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetLength: {
-      args: ["ptr"],
-      returns: "u32"
-    },
-    textBufferSetCell: {
-      args: ["ptr", "u32", "u32", "ptr", "ptr", "u16"],
-      returns: "void"
-    },
-    textBufferConcat: {
-      args: ["ptr", "ptr"],
-      returns: "ptr"
-    },
-    textBufferResize: {
-      args: ["ptr", "u32"],
-      returns: "void"
-    },
-    textBufferReset: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    textBufferSetSelection: {
-      args: ["ptr", "u32", "u32", "ptr", "ptr"],
-      returns: "void"
-    },
-    textBufferResetSelection: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    textBufferSetDefaultFg: {
-      args: ["ptr", "ptr"],
-      returns: "void"
-    },
-    textBufferSetDefaultBg: {
-      args: ["ptr", "ptr"],
-      returns: "void"
-    },
-    textBufferSetDefaultAttributes: {
-      args: ["ptr", "ptr"],
-      returns: "void"
-    },
-    textBufferResetDefaults: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    textBufferWriteChunk: {
-      args: ["ptr", "ptr", "u32", "ptr", "ptr", "ptr"],
-      returns: "u32"
-    },
-    textBufferGetCapacity: {
-      args: ["ptr"],
-      returns: "u32"
-    },
-    textBufferFinalizeLineInfo: {
-      args: ["ptr"],
-      returns: "void"
-    },
-    textBufferGetLineStartsPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetLineWidthsPtr: {
-      args: ["ptr"],
-      returns: "ptr"
-    },
-    textBufferGetLineCount: {
-      args: ["ptr"],
-      returns: "u32"
-    },
-    bufferDrawTextBuffer: {
-      args: ["ptr", "ptr", "i32", "i32", "i32", "i32", "u32", "u32", "bool"],
-      returns: "void"
-    }
-  });
-}
-
-class FFIRenderLib {
-  opentui;
-  encoder = new TextEncoder;
-  constructor(libPath) {
-    this.opentui = getOpenTUILib(libPath);
-  }
-  createRenderer(width, height) {
-    return this.opentui.symbols.createRenderer(width, height);
-  }
-  destroyRenderer(renderer, useAlternateScreen, splitHeight) {
-    this.opentui.symbols.destroyRenderer(renderer, useAlternateScreen, splitHeight);
-  }
-  setUseThread(renderer, useThread) {
-    this.opentui.symbols.setUseThread(renderer, useThread);
-  }
-  setBackgroundColor(renderer, color) {
-    this.opentui.symbols.setBackgroundColor(renderer, color.buffer);
-  }
-  setRenderOffset(renderer, offset) {
-    this.opentui.symbols.setRenderOffset(renderer, offset);
-  }
-  updateStats(renderer, time, fps, frameCallbackTime) {
-    this.opentui.symbols.updateStats(renderer, time, fps, frameCallbackTime);
-  }
-  updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers) {
-    this.opentui.symbols.updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers);
-  }
-  getNextBuffer(renderer) {
-    const bufferPtr = this.opentui.symbols.getNextBuffer(renderer);
-    if (!bufferPtr) {
-      throw new Error("Failed to get next buffer");
-    }
-    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
-    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, {});
-  }
-  getCurrentBuffer(renderer) {
-    const bufferPtr = this.opentui.symbols.getCurrentBuffer(renderer);
-    if (!bufferPtr) {
-      throw new Error("Failed to get current buffer");
-    }
-    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
-    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, {});
-  }
-  getBuffer(bufferPtr, size) {
-    const charPtr = this.opentui.symbols.bufferGetCharPtr(bufferPtr);
-    const fgPtr = this.opentui.symbols.bufferGetFgPtr(bufferPtr);
-    const bgPtr = this.opentui.symbols.bufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.opentui.symbols.bufferGetAttributesPtr(bufferPtr);
-    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
-      throw new Error("Failed to get buffer pointers");
-    }
-    const buffers = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-      attributes: new Uint8Array(toArrayBuffer(attributesPtr, 0, size))
-    };
-    return buffers;
-  }
-  getTextBuffer(bufferPtr, size) {
-    const charPtr = this.opentui.symbols.textBufferGetCharPtr(bufferPtr);
-    const fgPtr = this.opentui.symbols.textBufferGetFgPtr(bufferPtr);
-    const bgPtr = this.opentui.symbols.textBufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.opentui.symbols.textBufferGetAttributesPtr(bufferPtr);
-    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
-      throw new Error("Failed to get text buffer pointers");
-    }
-    const buffers = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, size * 2))
-    };
-    return buffers;
-  }
-  bufferGetCharPtr(buffer) {
-    const ptr = this.opentui.symbols.bufferGetCharPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get char pointer");
-    }
-    return ptr;
-  }
-  bufferGetFgPtr(buffer) {
-    const ptr = this.opentui.symbols.bufferGetFgPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get fg pointer");
-    }
-    return ptr;
-  }
-  bufferGetBgPtr(buffer) {
-    const ptr = this.opentui.symbols.bufferGetBgPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get bg pointer");
-    }
-    return ptr;
-  }
-  bufferGetAttributesPtr(buffer) {
-    const ptr = this.opentui.symbols.bufferGetAttributesPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get attributes pointer");
-    }
-    return ptr;
-  }
-  bufferGetRespectAlpha(buffer) {
-    return this.opentui.symbols.bufferGetRespectAlpha(buffer);
-  }
-  bufferSetRespectAlpha(buffer, respectAlpha) {
-    this.opentui.symbols.bufferSetRespectAlpha(buffer, respectAlpha);
-  }
-  getBufferWidth(buffer) {
-    return this.opentui.symbols.getBufferWidth(buffer);
-  }
-  getBufferHeight(buffer) {
-    return this.opentui.symbols.getBufferHeight(buffer);
-  }
-  bufferClear(buffer, color) {
-    this.opentui.symbols.bufferClear(buffer, color.buffer);
-  }
-  bufferDrawText(buffer, text, x, y, color, bgColor, attributes) {
-    const textBytes = this.encoder.encode(text);
-    const textLength = textBytes.byteLength;
-    const bg = bgColor ? bgColor.buffer : null;
-    const fg = color.buffer;
-    this.opentui.symbols.bufferDrawText(buffer, textBytes, textLength, x, y, fg, bg, attributes ?? 0);
-  }
-  bufferSetCellWithAlphaBlending(buffer, x, y, char, color, bgColor, attributes) {
-    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
-    const bg = bgColor.buffer;
-    const fg = color.buffer;
-    this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x, y, charPtr, fg, bg, attributes ?? 0);
-  }
-  bufferFillRect(buffer, x, y, width, height, color) {
-    const bg = color.buffer;
-    this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg);
-  }
-  bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
-    const formatId = format === "bgra8unorm" ? 0 : 1;
-    this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, formatId, alignedBytesPerRow);
-  }
-  bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
-    this.opentui.symbols.bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
-  }
-  bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, title) {
-    const titleBytes = title ? this.encoder.encode(title) : null;
-    const titleLen = title ? titleBytes.length : 0;
-    const titlePtr = title ? titleBytes : null;
-    this.opentui.symbols.bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor.buffer, backgroundColor.buffer, titlePtr, titleLen);
-  }
-  bufferResize(buffer, width, height) {
-    this.opentui.symbols.bufferResize(buffer, width, height);
-    const buffers = this.getBuffer(buffer, width * height);
-    return buffers;
-  }
-  resizeRenderer(renderer, width, height) {
-    this.opentui.symbols.resizeRenderer(renderer, width, height);
-  }
-  setCursorPosition(x, y, visible) {
-    this.opentui.symbols.setCursorPosition(x, y, visible);
-  }
-  setCursorStyle(style, blinking) {
-    const stylePtr = this.encoder.encode(style);
-    this.opentui.symbols.setCursorStyle(stylePtr, style.length, blinking);
-  }
-  setCursorColor(color) {
-    this.opentui.symbols.setCursorColor(color.buffer);
-  }
-  render(renderer, force) {
-    this.opentui.symbols.render(renderer, force);
-  }
-  createOptimizedBuffer(width, height, respectAlpha = false) {
-    if (Number.isNaN(width) || Number.isNaN(height)) {
-      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
-    }
-    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, respectAlpha);
-    if (!bufferPtr) {
-      throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
-    }
-    const size = width * height;
-    const buffers = this.getBuffer(bufferPtr, size);
-    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, { respectAlpha });
-  }
-  destroyOptimizedBuffer(bufferPtr) {
-    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
-  }
-  drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, sourceX, sourceY, sourceWidth, sourceHeight) {
-    const srcX = sourceX ?? 0;
-    const srcY = sourceY ?? 0;
-    const srcWidth = sourceWidth ?? 0;
-    const srcHeight = sourceHeight ?? 0;
-    this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
-  }
-  setDebugOverlay(renderer, enabled, corner) {
-    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
-  }
-  clearTerminal(renderer) {
-    this.opentui.symbols.clearTerminal(renderer);
-  }
-  addToHitGrid(renderer, x, y, width, height, id) {
-    this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id);
-  }
-  checkHit(renderer, x, y) {
-    return this.opentui.symbols.checkHit(renderer, x, y);
-  }
-  dumpHitGrid(renderer) {
-    this.opentui.symbols.dumpHitGrid(renderer);
-  }
-  dumpBuffers(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
-    this.opentui.symbols.dumpBuffers(renderer, ts);
-  }
-  dumpStdoutBuffer(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
-    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
-  }
-  enableMouse(renderer, enableMovement) {
-    this.opentui.symbols.enableMouse(renderer, enableMovement);
-  }
-  disableMouse(renderer) {
-    this.opentui.symbols.disableMouse(renderer);
-  }
-  createTextBuffer(capacity) {
-    const bufferPtr = this.opentui.symbols.createTextBuffer(capacity);
-    if (!bufferPtr) {
-      throw new Error(`Failed to create TextBuffer with capacity ${capacity}`);
-    }
-    const charPtr = this.textBufferGetCharPtr(bufferPtr);
-    const fgPtr = this.textBufferGetFgPtr(bufferPtr);
-    const bgPtr = this.textBufferGetBgPtr(bufferPtr);
-    const attributesPtr = this.textBufferGetAttributesPtr(bufferPtr);
-    const buffer = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, capacity * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, capacity * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, capacity * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, capacity * 2))
-    };
-    return new TextBuffer(this, bufferPtr, buffer, capacity);
-  }
-  destroyTextBuffer(buffer) {
-    this.opentui.symbols.destroyTextBuffer(buffer);
-  }
-  textBufferGetCharPtr(buffer) {
-    const ptr = this.opentui.symbols.textBufferGetCharPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get TextBuffer char pointer");
-    }
-    return ptr;
-  }
-  textBufferGetFgPtr(buffer) {
-    const ptr = this.opentui.symbols.textBufferGetFgPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get TextBuffer fg pointer");
-    }
-    return ptr;
-  }
-  textBufferGetBgPtr(buffer) {
-    const ptr = this.opentui.symbols.textBufferGetBgPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get TextBuffer bg pointer");
-    }
-    return ptr;
-  }
-  textBufferGetAttributesPtr(buffer) {
-    const ptr = this.opentui.symbols.textBufferGetAttributesPtr(buffer);
-    if (!ptr) {
-      throw new Error("Failed to get TextBuffer attributes pointer");
-    }
-    return ptr;
-  }
-  textBufferGetLength(buffer) {
-    return this.opentui.symbols.textBufferGetLength(buffer);
-  }
-  textBufferSetCell(buffer, index, char, fg, bg, attr) {
-    this.opentui.symbols.textBufferSetCell(buffer, index, char, fg, bg, attr);
-  }
-  textBufferConcat(buffer1, buffer2) {
-    const resultPtr = this.opentui.symbols.textBufferConcat(buffer1, buffer2);
-    if (!resultPtr) {
-      throw new Error("Failed to concatenate TextBuffers");
-    }
-    const length = this.textBufferGetLength(resultPtr);
-    const charPtr = this.textBufferGetCharPtr(resultPtr);
-    const fgPtr = this.textBufferGetFgPtr(resultPtr);
-    const bgPtr = this.textBufferGetBgPtr(resultPtr);
-    const attributesPtr = this.textBufferGetAttributesPtr(resultPtr);
-    const buffer = {
-      char: new Uint32Array(toArrayBuffer(charPtr, 0, length * 4)),
-      fg: new Float32Array(toArrayBuffer(fgPtr, 0, length * 4 * 4)),
-      bg: new Float32Array(toArrayBuffer(bgPtr, 0, length * 4 * 4)),
-      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, length * 2))
-    };
-    return new TextBuffer(this, resultPtr, buffer, length);
-  }
-  textBufferResize(buffer, newLength) {
-    this.opentui.symbols.textBufferResize(buffer, newLength);
-    const buffers = this.getTextBuffer(buffer, newLength);
-    return buffers;
-  }
-  textBufferReset(buffer) {
-    this.opentui.symbols.textBufferReset(buffer);
-  }
-  textBufferSetSelection(buffer, start, end, bgColor, fgColor) {
-    const bg = bgColor ? bgColor.buffer : null;
-    const fg = fgColor ? fgColor.buffer : null;
-    this.opentui.symbols.textBufferSetSelection(buffer, start, end, bg, fg);
-  }
-  textBufferResetSelection(buffer) {
-    this.opentui.symbols.textBufferResetSelection(buffer);
-  }
-  textBufferSetDefaultFg(buffer, fg) {
-    const fgPtr = fg ? fg.buffer : null;
-    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
-  }
-  textBufferSetDefaultBg(buffer, bg) {
-    const bgPtr = bg ? bg.buffer : null;
-    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
-  }
-  textBufferSetDefaultAttributes(buffer, attributes) {
-    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
-    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
-  }
-  textBufferResetDefaults(buffer) {
-    this.opentui.symbols.textBufferResetDefaults(buffer);
-  }
-  textBufferWriteChunk(buffer, textBytes, fg, bg, attributes) {
-    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
-    return this.opentui.symbols.textBufferWriteChunk(buffer, textBytes, textBytes.length, fg ? fg.buffer : null, bg ? bg.buffer : null, attrValue);
-  }
-  textBufferGetCapacity(buffer) {
-    return this.opentui.symbols.textBufferGetCapacity(buffer);
-  }
-  textBufferFinalizeLineInfo(buffer) {
-    this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
-  }
-  textBufferGetLineInfo(buffer) {
-    const lineCount = this.opentui.symbols.textBufferGetLineCount(buffer);
-    if (lineCount === 0) {
-      return { lineStarts: [], lineWidths: [] };
-    }
-    const lineStartsPtr = this.opentui.symbols.textBufferGetLineStartsPtr(buffer);
-    const lineWidthsPtr = this.opentui.symbols.textBufferGetLineWidthsPtr(buffer);
-    if (!lineStartsPtr || !lineWidthsPtr) {
-      return { lineStarts: [], lineWidths: [] };
-    }
-    const lineStartsArray = new Uint32Array(toArrayBuffer(lineStartsPtr, 0, lineCount * 4));
-    const lineWidthsArray = new Uint32Array(toArrayBuffer(lineWidthsPtr, 0, lineCount * 4));
-    const lineStarts = Array.from(lineStartsArray);
-    const lineWidths = Array.from(lineWidthsArray);
-    return { lineStarts, lineWidths };
-  }
-  getTextBufferArrays(buffer, size) {
-    return this.getTextBuffer(buffer, size);
-  }
-  bufferDrawTextBuffer(buffer, textBuffer, x, y, clipRect) {
-    const hasClipRect = clipRect !== undefined && clipRect !== null;
-    const clipX = clipRect?.x ?? 0;
-    const clipY = clipRect?.y ?? 0;
-    const clipWidth = clipRect?.width ?? 0;
-    const clipHeight = clipRect?.height ?? 0;
-    this.opentui.symbols.bufferDrawTextBuffer(buffer, textBuffer, x, y, clipX, clipY, clipWidth, clipHeight, hasClipRect);
-  }
-}
-var opentuiLibPath;
-var opentuiLib;
-function setRenderLibPath(libPath) {
-  opentuiLibPath = libPath;
-}
-function resolveRenderLib() {
-  if (!opentuiLib) {
-    opentuiLib = new FFIRenderLib(opentuiLibPath);
-  }
-  return opentuiLib;
-}
-
-// src/lib/border.ts
-var BorderChars = {
-  single: {
-    topLeft: "\u250C",
-    topRight: "\u2510",
-    bottomLeft: "\u2514",
-    bottomRight: "\u2518",
-    horizontal: "\u2500",
-    vertical: "\u2502",
-    topT: "\u252C",
-    bottomT: "\u2534",
-    leftT: "\u251C",
-    rightT: "\u2524",
-    cross: "\u253C"
-  },
-  double: {
-    topLeft: "\u2554",
-    topRight: "\u2557",
-    bottomLeft: "\u255A",
-    bottomRight: "\u255D",
-    horizontal: "\u2550",
-    vertical: "\u2551",
-    topT: "\u2566",
-    bottomT: "\u2569",
-    leftT: "\u2560",
-    rightT: "\u2563",
-    cross: "\u256C"
-  },
-  rounded: {
-    topLeft: "\u256D",
-    topRight: "\u256E",
-    bottomLeft: "\u2570",
-    bottomRight: "\u256F",
-    horizontal: "\u2500",
-    vertical: "\u2502",
-    topT: "\u252C",
-    bottomT: "\u2534",
-    leftT: "\u251C",
-    rightT: "\u2524",
-    cross: "\u253C"
-  },
-  heavy: {
-    topLeft: "\u250F",
-    topRight: "\u2513",
-    bottomLeft: "\u2517",
-    bottomRight: "\u251B",
-    horizontal: "\u2501",
-    vertical: "\u2503",
-    topT: "\u2533",
-    bottomT: "\u253B",
-    leftT: "\u2523",
-    rightT: "\u252B",
-    cross: "\u254B"
-  }
-};
-function getBorderFromSides(sides) {
-  const result = [];
-  if (sides.top)
-    result.push("top");
-  if (sides.right)
-    result.push("right");
-  if (sides.bottom)
-    result.push("bottom");
-  if (sides.left)
-    result.push("left");
-  return result.length > 0 ? result : false;
-}
-function getBorderSides(border) {
-  return border === true ? { top: true, right: true, bottom: true, left: true } : Array.isArray(border) ? {
-    top: border.includes("top"),
-    right: border.includes("right"),
-    bottom: border.includes("bottom"),
-    left: border.includes("left")
-  } : { top: false, right: false, bottom: false, left: false };
-}
-function borderCharsToArray(chars) {
-  const array = new Uint32Array(11);
-  array[0] = chars.topLeft.codePointAt(0);
-  array[1] = chars.topRight.codePointAt(0);
-  array[2] = chars.bottomLeft.codePointAt(0);
-  array[3] = chars.bottomRight.codePointAt(0);
-  array[4] = chars.horizontal.codePointAt(0);
-  array[5] = chars.vertical.codePointAt(0);
-  array[6] = chars.topT.codePointAt(0);
-  array[7] = chars.bottomT.codePointAt(0);
-  array[8] = chars.leftT.codePointAt(0);
-  array[9] = chars.rightT.codePointAt(0);
-  array[10] = chars.cross.codePointAt(0);
-  return array;
-}
-var BorderCharArrays = {
-  single: borderCharsToArray(BorderChars.single),
-  double: borderCharsToArray(BorderChars.double),
-  rounded: borderCharsToArray(BorderChars.rounded),
-  heavy: borderCharsToArray(BorderChars.heavy)
-};
 // src/lib/fonts/tiny.json
 var tiny_default = {
   name: "tiny",
@@ -5286,526 +4862,1633 @@ var slick_default = {
     '"': ["<c1>\u256D\u256E\u256D\u256E</c1>", "<c1>\u2570\u256F\u2570\u256F</c1>", "<c2>\u2571\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571\u2571</c2>"],
     " ": ["<c2>\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571</c2>", "<c2>\u2571\u2571\u2571</c2>"]
   }
-};
+};
+
+// src/lib/ascii.font.ts
+var fonts = {
+  tiny: tiny_default,
+  block: block_default,
+  shade: shade_default,
+  slick: slick_default
+};
+var parsedFonts = {};
+function parseColorTags(text) {
+  const segments = [];
+  let currentIndex = 0;
+  const colorTagRegex = /<c(\d+)>(.*?)<\/c\d+>/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = colorTagRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      const plainText = text.slice(lastIndex, match.index);
+      if (plainText) {
+        segments.push({ text: plainText, colorIndex: 0 });
+      }
+    }
+    const colorIndex = parseInt(match[1]) - 1;
+    const taggedText = match[2];
+    segments.push({ text: taggedText, colorIndex: Math.max(0, colorIndex) });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    const remainingText = text.slice(lastIndex);
+    if (remainingText) {
+      segments.push({ text: remainingText, colorIndex: 0 });
+    }
+  }
+  return segments;
+}
+function getParsedFont(fontKey) {
+  if (!parsedFonts[fontKey]) {
+    const fontDef = fonts[fontKey];
+    const parsedChars = {};
+    for (const [char, lines] of Object.entries(fontDef.chars)) {
+      parsedChars[char] = lines.map((line) => parseColorTags(line));
+    }
+    parsedFonts[fontKey] = {
+      ...fontDef,
+      colors: fontDef.colors || 1,
+      chars: parsedChars
+    };
+  }
+  return parsedFonts[fontKey];
+}
+function measureText({ text, font = "tiny" }) {
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`);
+    return { width: 0, height: 0 };
+  }
+  let currentX = 0;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0;
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length;
+        }
+        currentX += spaceWidth;
+      } else {
+        currentX += 1;
+      }
+      continue;
+    }
+    let charWidth = 0;
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+  }
+  return {
+    width: currentX,
+    height: fontDef.lines
+  };
+}
+function getCharacterPositions(text, font = "tiny") {
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    return [0];
+  }
+  const positions = [0];
+  let currentX = 0;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    let charWidth = 0;
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        for (const segment of spaceChar[0]) {
+          charWidth += segment.text.length;
+        }
+      } else {
+        charWidth = 1;
+      }
+    } else if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+    positions.push(currentX);
+  }
+  return positions;
+}
+function coordinateToCharacterIndex(x, text, font = "tiny") {
+  const positions = getCharacterPositions(text, font);
+  if (x < 0) {
+    return 0;
+  }
+  for (let i = 0;i < positions.length - 1; i++) {
+    const currentPos = positions[i];
+    const nextPos = positions[i + 1];
+    if (x >= currentPos && x < nextPos) {
+      const charMidpoint = currentPos + (nextPos - currentPos) / 2;
+      return x < charMidpoint ? i : i + 1;
+    }
+  }
+  if (positions.length > 0 && x >= positions[positions.length - 1]) {
+    return text.length;
+  }
+  return 0;
+}
+function renderFontToFrameBuffer(buffer, {
+  text,
+  x = 0,
+  y = 0,
+  fg = [RGBA.fromInts(255, 255, 255, 255)],
+  bg = RGBA.fromInts(0, 0, 0, 255),
+  font = "tiny"
+}) {
+  const width = buffer.getWidth();
+  const height = buffer.getHeight();
+  const fontDef = getParsedFont(font);
+  if (!fontDef) {
+    console.warn(`Font '${font}' not found`);
+    return { width: 0, height: 0 };
+  }
+  const colors = Array.isArray(fg) ? fg : [fg];
+  if (y < 0 || y + fontDef.lines > height) {
+    return { width: 0, height: fontDef.lines };
+  }
+  let currentX = x;
+  const startX = x;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i].toUpperCase();
+    const charDef = fontDef.chars[char];
+    if (!charDef) {
+      const spaceChar = fontDef.chars[" "];
+      if (spaceChar && spaceChar[0]) {
+        let spaceWidth = 0;
+        for (const segment of spaceChar[0]) {
+          spaceWidth += segment.text.length;
+        }
+        currentX += spaceWidth;
+      } else {
+        currentX += 1;
+      }
+      continue;
+    }
+    let charWidth = 0;
+    if (charDef[0]) {
+      for (const segment of charDef[0]) {
+        charWidth += segment.text.length;
+      }
+    }
+    if (currentX >= width)
+      break;
+    if (currentX + charWidth < 0) {
+      currentX += charWidth + fontDef.letterspace_size;
+      continue;
+    }
+    for (let lineIdx = 0;lineIdx < fontDef.lines && lineIdx < charDef.length; lineIdx++) {
+      const segments = charDef[lineIdx];
+      const renderY = y + lineIdx;
+      if (renderY >= 0 && renderY < height) {
+        let segmentX = currentX;
+        for (const segment of segments) {
+          const segmentColor = colors[segment.colorIndex] || colors[0];
+          for (let charIdx = 0;charIdx < segment.text.length; charIdx++) {
+            const renderX = segmentX + charIdx;
+            if (renderX >= 0 && renderX < width) {
+              const fontChar = segment.text[charIdx];
+              if (fontChar !== " ") {
+                buffer.setCell(renderX, renderY, fontChar, segmentColor, bg);
+              }
+            }
+          }
+          segmentX += segment.text.length;
+        }
+      }
+    }
+    currentX += charWidth;
+    if (i < text.length - 1) {
+      currentX += fontDef.letterspace_size;
+    }
+  }
+  return {
+    width: currentX - startX,
+    height: fontDef.lines
+  };
+}
+// src/lib/styled-text.ts
+var textEncoder = new TextEncoder;
+
+class StyledText {
+  chunks;
+  _plainText = "";
+  constructor(chunks) {
+    this.chunks = chunks;
+    for (let i = 0;i < chunks.length; i++) {
+      this._plainText += chunks[i].plainText;
+    }
+  }
+  toString() {
+    return this._plainText;
+  }
+  static _createInstance(chunks, plainText) {
+    const newInstance = Object.create(StyledText.prototype);
+    newInstance.chunks = chunks;
+    newInstance._plainText = plainText;
+    return newInstance;
+  }
+  static _chunksToPlainText(chunks) {
+    let plainText = "";
+    for (const chunk of chunks) {
+      plainText += chunk.plainText;
+    }
+    return plainText;
+  }
+  insert(chunk, index) {
+    const originalLength = this.chunks.length;
+    let newChunks;
+    let newPlainText;
+    if (index === undefined) {
+      newChunks = [...this.chunks, chunk];
+      newPlainText = this._plainText + chunk.plainText;
+    } else if (index === originalLength) {
+      newChunks = [...this.chunks, chunk];
+      newPlainText = this._plainText + chunk.plainText;
+    } else {
+      newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index)];
+      newPlainText = StyledText._chunksToPlainText(newChunks);
+    }
+    return StyledText._createInstance(newChunks, newPlainText);
+  }
+  remove(chunk) {
+    const originalLength = this.chunks.length;
+    const index = this.chunks.indexOf(chunk);
+    if (index === -1)
+      return this;
+    let newChunks;
+    let newPlainText;
+    if (index === originalLength - 1) {
+      newChunks = this.chunks.slice(0, -1);
+      newPlainText = this._plainText.slice(0, this._plainText.length - chunk.plainText.length);
+    } else {
+      newChunks = [...this.chunks.slice(0, index), ...this.chunks.slice(index + 1)];
+      newPlainText = StyledText._chunksToPlainText(newChunks);
+    }
+    return StyledText._createInstance(newChunks, newPlainText);
+  }
+  replace(chunk, oldChunk) {
+    const index = this.chunks.indexOf(oldChunk);
+    if (index === -1)
+      return this;
+    let newChunks;
+    let newPlainText;
+    if (index === this.chunks.length - 1) {
+      newChunks = [...this.chunks.slice(0, -1), chunk];
+      newPlainText = this._plainText.slice(0, this._plainText.length - oldChunk.plainText.length) + chunk.plainText;
+    } else {
+      newChunks = [...this.chunks.slice(0, index), chunk, ...this.chunks.slice(index + 1)];
+      newPlainText = StyledText._chunksToPlainText(newChunks);
+    }
+    return StyledText._createInstance(newChunks, newPlainText);
+  }
+}
+function stringToStyledText(content) {
+  const textEncoder2 = new TextEncoder;
+  const chunk = {
+    __isChunk: true,
+    text: textEncoder2.encode(content),
+    plainText: content
+  };
+  return new StyledText([chunk]);
+}
+var templateCache = new WeakMap;
+function applyStyle(input, style) {
+  if (typeof input === "object" && "__isChunk" in input) {
+    const existingChunk = input;
+    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
+    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
+    const newAttrs = createTextAttributes(style);
+    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
+    return {
+      __isChunk: true,
+      text: existingChunk.text,
+      plainText: existingChunk.plainText,
+      fg,
+      bg,
+      attributes: mergedAttrs
+    };
+  } else {
+    const plainTextStr = String(input);
+    const text = textEncoder.encode(plainTextStr);
+    const fg = style.fg ? parseColor(style.fg) : undefined;
+    const bg = style.bg ? parseColor(style.bg) : undefined;
+    const attributes = createTextAttributes(style);
+    return {
+      __isChunk: true,
+      text,
+      plainText: plainTextStr,
+      fg,
+      bg,
+      attributes
+    };
+  }
+}
+var black = (input) => applyStyle(input, { fg: "black" });
+var red = (input) => applyStyle(input, { fg: "red" });
+var green = (input) => applyStyle(input, { fg: "green" });
+var yellow = (input) => applyStyle(input, { fg: "yellow" });
+var blue = (input) => applyStyle(input, { fg: "blue" });
+var magenta = (input) => applyStyle(input, { fg: "magenta" });
+var cyan = (input) => applyStyle(input, { fg: "cyan" });
+var white = (input) => applyStyle(input, { fg: "white" });
+var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
+var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
+var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
+var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
+var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
+var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
+var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
+var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
+var bgBlack = (input) => applyStyle(input, { bg: "black" });
+var bgRed = (input) => applyStyle(input, { bg: "red" });
+var bgGreen = (input) => applyStyle(input, { bg: "green" });
+var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
+var bgBlue = (input) => applyStyle(input, { bg: "blue" });
+var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
+var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
+var bgWhite = (input) => applyStyle(input, { bg: "white" });
+var bold = (input) => applyStyle(input, { bold: true });
+var italic = (input) => applyStyle(input, { italic: true });
+var underline = (input) => applyStyle(input, { underline: true });
+var strikethrough = (input) => applyStyle(input, { strikethrough: true });
+var dim = (input) => applyStyle(input, { dim: true });
+var reverse = (input) => applyStyle(input, { reverse: true });
+var blink = (input) => applyStyle(input, { blink: true });
+var fg = (color) => (input) => applyStyle(input, { fg: color });
+var bg = (color) => (input) => applyStyle(input, { bg: color });
+function tn(strings, ...values) {
+  const chunks = [];
+  let length = 0;
+  let plainText = "";
+  for (let i = 0;i < strings.length; i++) {
+    const raw = strings[i];
+    if (raw) {
+      chunks.push({
+        __isChunk: true,
+        text: textEncoder.encode(raw),
+        plainText: raw,
+        attributes: 0
+      });
+      length += raw.length;
+      plainText += raw;
+    }
+    const val = values[i];
+    if (typeof val === "object" && "__isChunk" in val) {
+      chunks.push(val);
+      length += val.plainText.length;
+      plainText += val.plainText;
+    } else if (val !== undefined) {
+      const plainTextStr = String(val);
+      chunks.push({
+        __isChunk: true,
+        text: textEncoder.encode(plainTextStr),
+        plainText: plainTextStr,
+        attributes: 0
+      });
+      length += plainTextStr.length;
+      plainText += plainTextStr;
+    }
+  }
+  return new StyledText(chunks);
+}
+function t(strings, ...values) {
+  let cachedStringChunks = templateCache.get(strings);
+  let length = 0;
+  let plainText = "";
+  if (!cachedStringChunks) {
+    cachedStringChunks = [];
+    for (let i = 0;i < strings.length; i++) {
+      const raw = strings[i];
+      if (raw) {
+        cachedStringChunks.push({
+          __isChunk: true,
+          text: textEncoder.encode(raw),
+          plainText: raw,
+          attributes: 0
+        });
+      } else {
+        cachedStringChunks.push(null);
+      }
+    }
+    templateCache.set(strings, cachedStringChunks);
+  }
+  const chunks = [];
+  for (let i = 0;i < strings.length; i++) {
+    const stringChunk = cachedStringChunks[i];
+    if (stringChunk) {
+      chunks.push(stringChunk);
+      length += stringChunk.plainText.length;
+      plainText += stringChunk.plainText;
+    }
+    const val = values[i];
+    if (typeof val === "object" && "__isChunk" in val) {
+      chunks.push(val);
+      length += val.plainText.length;
+      plainText += val.plainText;
+    } else if (val !== undefined) {
+      const plainTextStr = String(val);
+      chunks.push({
+        __isChunk: true,
+        text: textEncoder.encode(plainTextStr),
+        plainText: plainTextStr,
+        attributes: 0
+      });
+      length += plainTextStr.length;
+      plainText += plainTextStr;
+    }
+  }
+  return new StyledText(chunks);
+}
+
+// src/lib/hast-styled-text.ts
+class SyntaxStyle {
+  styles;
+  mergedStyleCache;
+  constructor(styles) {
+    this.styles = styles;
+    this.mergedStyleCache = new Map;
+  }
+  mergeStyles(...styleNames) {
+    const cacheKey = styleNames.join(":");
+    const cached = this.mergedStyleCache.get(cacheKey);
+    if (cached)
+      return cached;
+    const styleDefinition = {};
+    for (const name of styleNames) {
+      const style = this.styles[name];
+      if (!style)
+        continue;
+      if (style.fg)
+        styleDefinition.fg = style.fg;
+      if (style.bg)
+        styleDefinition.bg = style.bg;
+      if (style.bold !== undefined)
+        styleDefinition.bold = style.bold;
+      if (style.italic !== undefined)
+        styleDefinition.italic = style.italic;
+      if (style.underline !== undefined)
+        styleDefinition.underline = style.underline;
+      if (style.dim !== undefined)
+        styleDefinition.dim = style.dim;
+    }
+    const attributes = createTextAttributes({
+      bold: styleDefinition.bold,
+      italic: styleDefinition.italic,
+      underline: styleDefinition.underline,
+      dim: styleDefinition.dim
+    });
+    const merged = {
+      fg: styleDefinition.fg,
+      bg: styleDefinition.bg,
+      attributes
+    };
+    this.mergedStyleCache.set(cacheKey, merged);
+    return merged;
+  }
+  clearCache() {
+    this.mergedStyleCache.clear();
+  }
+  getCacheSize() {
+    return this.mergedStyleCache.size;
+  }
+}
+var textEncoder2 = new TextEncoder;
+function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
+  const chunks = [];
+  if (node.type === "text") {
+    const stylesToMerge = parentStyles.length > 0 ? parentStyles : ["default"];
+    const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
+    chunks.push({
+      __isChunk: true,
+      text: textEncoder2.encode(node.value),
+      plainText: node.value,
+      fg: mergedStyle.fg,
+      bg: mergedStyle.bg,
+      attributes: mergedStyle.attributes
+    });
+  } else if (node.type === "element") {
+    let currentStyles = [...parentStyles];
+    if (node.properties?.className) {
+      const classes = node.properties.className.split(" ");
+      for (const cls of classes) {
+        currentStyles.push(cls);
+      }
+    }
+    for (const child of node.children) {
+      chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
+    }
+  }
+  return chunks;
+}
+function hastToStyledText(hast, syntaxStyle) {
+  const chunks = hastToTextChunks(hast, syntaxStyle);
+  return new StyledText(chunks);
+}
+// src/lib/parse.mouse.ts
+class MouseParser {
+  mouseButtonsPressed = new Set;
+  static SCROLL_DIRECTIONS = {
+    64: "up",
+    65: "down",
+    66: "left",
+    67: "right"
+  };
+  reset() {
+    this.mouseButtonsPressed.clear();
+  }
+  parseMouseEvent(data) {
+    const str = data.toString();
+    const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+    if (sgrMatch) {
+      const [, buttonCode, x, y, pressRelease] = sgrMatch;
+      const rawButtonCode = parseInt(buttonCode);
+      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[rawButtonCode];
+      const isScroll = scrollDirection !== undefined;
+      const button = rawButtonCode & 3;
+      const isMotion = (rawButtonCode & 32) !== 0;
+      const modifiers = {
+        shift: (rawButtonCode & 4) !== 0,
+        alt: (rawButtonCode & 8) !== 0,
+        ctrl: (rawButtonCode & 16) !== 0
+      };
+      let type;
+      let scrollInfo;
+      if (isScroll && pressRelease === "M") {
+        type = "scroll";
+        scrollInfo = {
+          direction: scrollDirection,
+          delta: 1
+        };
+      } else if (isMotion) {
+        const isDragging = this.mouseButtonsPressed.size > 0;
+        if (button === 3) {
+          type = "move";
+        } else if (isDragging) {
+          type = "drag";
+        } else {
+          type = "move";
+        }
+      } else {
+        type = pressRelease === "M" ? "down" : "up";
+        if (type === "down" && button !== 3) {
+          this.mouseButtonsPressed.add(button);
+        } else if (type === "up") {
+          this.mouseButtonsPressed.clear();
+        }
+      }
+      return {
+        type,
+        button: button === 3 ? 0 : button,
+        x: parseInt(x) - 1,
+        y: parseInt(y) - 1,
+        modifiers,
+        scroll: scrollInfo
+      };
+    }
+    if (str.startsWith("\x1B[M") && str.length >= 6) {
+      const buttonByte = str.charCodeAt(3) - 32;
+      const x = str.charCodeAt(4) - 33;
+      const y = str.charCodeAt(5) - 33;
+      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[buttonByte];
+      const isScroll = scrollDirection !== undefined;
+      const button = buttonByte & 3;
+      const modifiers = {
+        shift: (buttonByte & 4) !== 0,
+        alt: (buttonByte & 8) !== 0,
+        ctrl: (buttonByte & 16) !== 0
+      };
+      let type;
+      let actualButton;
+      let scrollInfo;
+      if (isScroll) {
+        type = "scroll";
+        actualButton = 0;
+        scrollInfo = {
+          direction: scrollDirection,
+          delta: 1
+        };
+      } else {
+        type = button === 3 ? "up" : "down";
+        actualButton = button === 3 ? 0 : button;
+      }
+      return {
+        type,
+        button: actualButton,
+        x,
+        y,
+        modifiers,
+        scroll: scrollInfo
+      };
+    }
+    return null;
+  }
+}
+// src/lib/selection.ts
+class Selection {
+  _anchor;
+  _focus;
+  _selectedRenderables = [];
+  constructor(anchor, focus) {
+    this._anchor = { ...anchor };
+    this._focus = { ...focus };
+  }
+  get anchor() {
+    return { ...this._anchor };
+  }
+  get focus() {
+    return { ...this._focus };
+  }
+  get bounds() {
+    return {
+      startX: Math.min(this._anchor.x, this._focus.x),
+      startY: Math.min(this._anchor.y, this._focus.y),
+      endX: Math.max(this._anchor.x, this._focus.x),
+      endY: Math.max(this._anchor.y, this._focus.y)
+    };
+  }
+  updateSelectedRenderables(selectedRenderables) {
+    this._selectedRenderables = selectedRenderables;
+  }
+  getSelectedText() {
+    const selectedTexts = this._selectedRenderables.sort((a, b) => {
+      const aY = a.y;
+      const bY = b.y;
+      if (aY !== bY) {
+        return aY - bY;
+      }
+      return a.x - b.x;
+    }).map((renderable) => renderable.getSelectedText()).filter((text) => text);
+    return selectedTexts.join(`
+`);
+  }
+}
+
+class TextSelectionHelper {
+  getX;
+  getY;
+  getTextLength;
+  getLineInfo;
+  localSelection = null;
+  cachedGlobalSelection = null;
+  constructor(getX, getY, getTextLength, getLineInfo) {
+    this.getX = getX;
+    this.getY = getY;
+    this.getTextLength = getTextLength;
+    this.getLineInfo = getLineInfo;
+  }
+  hasSelection() {
+    return this.localSelection !== null;
+  }
+  getSelection() {
+    return this.localSelection;
+  }
+  reevaluateSelection(width, height = 1) {
+    if (!this.cachedGlobalSelection) {
+      return false;
+    }
+    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
+  }
+  shouldStartSelection(x, y, width, height) {
+    const localX = x - this.getX();
+    const localY = y - this.getY();
+    return localX >= 0 && localX < width && localY >= 0 && localY < height;
+  }
+  onSelectionChanged(selection, width, height = 1) {
+    this.cachedGlobalSelection = selection;
+    const previousSelection = this.localSelection;
+    if (!selection?.isActive) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    const myY = this.getY();
+    const myEndY = myY + height - 1;
+    if (myEndY < selection.anchor.y || myY > selection.focus.y) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    if (height === 1) {
+      this.localSelection = this.calculateSingleLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x, width);
+    } else {
+      this.localSelection = this.calculateMultiLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x);
+    }
+    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
+  }
+  calculateSingleLineSelection(lineY, anchorY, focusY, anchorX, focusX, width) {
+    const textLength = this.getTextLength();
+    const myX = this.getX();
+    if (lineY > anchorY && lineY < focusY) {
+      return { start: 0, end: textLength };
+    }
+    if (lineY === anchorY && lineY === focusY) {
+      const start = Math.max(0, Math.min(anchorX - myX, textLength));
+      const end = Math.max(0, Math.min(focusX - myX, textLength));
+      return start < end ? { start, end } : null;
+    }
+    if (lineY === anchorY) {
+      const start = Math.max(0, Math.min(anchorX - myX, textLength));
+      return start < textLength ? { start, end: textLength } : null;
+    }
+    if (lineY === focusY) {
+      const end = Math.max(0, Math.min(focusX - myX, textLength));
+      return end > 0 ? { start: 0, end } : null;
+    }
+    return null;
+  }
+  calculateMultiLineSelection(startY, anchorY, focusY, anchorX, focusX) {
+    const lineInfo = this.getLineInfo?.();
+    if (!lineInfo) {
+      return { start: 0, end: this.getTextLength() };
+    }
+    const myX = this.getX();
+    let selectionStart = null;
+    let selectionEnd = null;
+    for (let i = 0;i < lineInfo.lineStarts.length; i++) {
+      const lineY = startY + i;
+      if (lineY < anchorY || lineY > focusY)
+        continue;
+      const lineStart = lineInfo.lineStarts[i];
+      const lineEnd = i < lineInfo.lineStarts.length - 1 ? lineInfo.lineStarts[i + 1] - 1 : this.getTextLength();
+      const lineWidth = lineInfo.lineWidths[i];
+      if (lineY > anchorY && lineY < focusY) {
+        if (selectionStart === null)
+          selectionStart = lineStart;
+        selectionEnd = lineEnd;
+      } else if (lineY === anchorY && lineY === focusY) {
+        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
+        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
+        if (localStartX < localEndX) {
+          selectionStart = lineStart + localStartX;
+          selectionEnd = lineStart + localEndX;
+        }
+      } else if (lineY === anchorY) {
+        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
+        if (localStartX < lineWidth) {
+          selectionStart = lineStart + localStartX;
+          selectionEnd = lineEnd;
+        }
+      } else if (lineY === focusY) {
+        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
+        if (localEndX > 0) {
+          if (selectionStart === null)
+            selectionStart = lineStart;
+          selectionEnd = lineStart + localEndX;
+        }
+      }
+    }
+    return selectionStart !== null && selectionEnd !== null && selectionStart < selectionEnd ? { start: selectionStart, end: selectionEnd } : null;
+  }
+}
+
+class ASCIIFontSelectionHelper {
+  getX;
+  getY;
+  getText;
+  getFont;
+  localSelection = null;
+  cachedGlobalSelection = null;
+  constructor(getX, getY, getText, getFont) {
+    this.getX = getX;
+    this.getY = getY;
+    this.getText = getText;
+    this.getFont = getFont;
+  }
+  hasSelection() {
+    return this.localSelection !== null;
+  }
+  getSelection() {
+    return this.localSelection;
+  }
+  shouldStartSelection(x, y, width, height) {
+    const localX = x - this.getX();
+    const localY = y - this.getY();
+    if (localX < 0 || localX >= width || localY < 0 || localY >= height) {
+      return false;
+    }
+    const text = this.getText();
+    const font = this.getFont();
+    const charIndex = coordinateToCharacterIndex(localX, text, font);
+    return charIndex >= 0 && charIndex <= text.length;
+  }
+  onSelectionChanged(selection, width, height) {
+    this.cachedGlobalSelection = selection;
+    const previousSelection = this.localSelection;
+    if (!selection?.isActive) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    const myX = this.getX();
+    const myY = this.getY();
+    const myEndY = myY + height - 1;
+    const text = this.getText();
+    const font = this.getFont();
+    let selStart;
+    let selEnd;
+    if (selection.anchor.y < selection.focus.y || selection.anchor.y === selection.focus.y && selection.anchor.x <= selection.focus.x) {
+      selStart = selection.anchor;
+      selEnd = selection.focus;
+    } else {
+      selStart = selection.focus;
+      selEnd = selection.anchor;
+    }
+    if (myEndY < selStart.y || myY > selEnd.y) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    }
+    let startCharIndex = 0;
+    let endCharIndex = text.length;
+    if (selStart.y > myEndY) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    } else if (selStart.y >= myY && selStart.y <= myEndY) {
+      const localX = selStart.x - myX;
+      if (localX > 0) {
+        startCharIndex = coordinateToCharacterIndex(localX, text, font);
+      }
+    }
+    if (selEnd.y < myY) {
+      this.localSelection = null;
+      return previousSelection !== null;
+    } else if (selEnd.y >= myY && selEnd.y <= myEndY) {
+      const localX = selEnd.x - myX;
+      if (localX >= 0) {
+        endCharIndex = coordinateToCharacterIndex(localX, text, font);
+      } else {
+        endCharIndex = 0;
+      }
+    }
+    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
+      this.localSelection = { start: startCharIndex, end: endCharIndex };
+    } else {
+      this.localSelection = null;
+    }
+    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
+  }
+  reevaluateSelection(width, height) {
+    if (!this.cachedGlobalSelection) {
+      return false;
+    }
+    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
+  }
+}
+// src/zig.ts
+import { dlopen, toArrayBuffer } from "bun:ffi";
+import { existsSync } from "fs";
+
+// src/text-buffer.ts
+class TextBuffer {
+  lib;
+  bufferPtr;
+  buffer;
+  _length = 0;
+  _capacity;
+  _lineInfo;
+  constructor(lib, ptr, buffer, capacity) {
+    this.lib = lib;
+    this.bufferPtr = ptr;
+    this.buffer = buffer;
+    this._capacity = capacity;
+  }
+  static create(capacity = 256) {
+    const lib = resolveRenderLib();
+    return lib.createTextBuffer(capacity);
+  }
+  syncBuffersAfterResize() {
+    const capacity = this.lib.textBufferGetCapacity(this.bufferPtr);
+    this.buffer = this.lib.getTextBufferArrays(this.bufferPtr, capacity);
+    this._capacity = capacity;
+  }
+  setStyledText(text) {
+    this.lib.textBufferReset(this.bufferPtr);
+    this._length = 0;
+    this._lineInfo = undefined;
+    for (const chunk of text.chunks) {
+      const result = this.lib.textBufferWriteChunk(this.bufferPtr, chunk.text, chunk.fg || null, chunk.bg || null, chunk.attributes ?? null);
+      if (result & 1) {
+        this.syncBuffersAfterResize();
+      }
+    }
+    this.lib.textBufferFinalizeLineInfo(this.bufferPtr);
+    this._length = this.lib.textBufferGetLength(this.bufferPtr);
+  }
+  setDefaultFg(fg2) {
+    this.lib.textBufferSetDefaultFg(this.bufferPtr, fg2);
+  }
+  setDefaultBg(bg2) {
+    this.lib.textBufferSetDefaultBg(this.bufferPtr, bg2);
+  }
+  setDefaultAttributes(attributes) {
+    this.lib.textBufferSetDefaultAttributes(this.bufferPtr, attributes);
+  }
+  resetDefaults() {
+    this.lib.textBufferResetDefaults(this.bufferPtr);
+  }
+  get length() {
+    return this._length;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+  get ptr() {
+    return this.bufferPtr;
+  }
+  get lineInfo() {
+    if (!this._lineInfo) {
+      this._lineInfo = this.lib.textBufferGetLineInfo(this.bufferPtr);
+    }
+    return this._lineInfo;
+  }
+  toString() {
+    const chars = [];
+    for (let i = 0;i < this._length; i++) {
+      chars.push(String.fromCharCode(this.buffer.char[i]));
+    }
+    return chars.join("");
+  }
+  concat(other) {
+    return this.lib.textBufferConcat(this.bufferPtr, other.bufferPtr);
+  }
+  setSelection(start, end, bgColor, fgColor) {
+    this.lib.textBufferSetSelection(this.bufferPtr, start, end, bgColor || null, fgColor || null);
+  }
+  resetSelection() {
+    this.lib.textBufferResetSelection(this.bufferPtr);
+  }
+  destroy() {
+    this.lib.destroyTextBuffer(this.bufferPtr);
+  }
+}
+
+// src/zig.ts
+var module = await import(`@opentui/core-${process.platform}-${process.arch}/index.ts`);
+var targetLibPath = module.default;
+if (!existsSync(targetLibPath)) {
+  throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
+}
+function getOpenTUILib(libPath) {
+  const resolvedLibPath = libPath || targetLibPath;
+  return dlopen(resolvedLibPath, {
+    createRenderer: {
+      args: ["u32", "u32"],
+      returns: "ptr"
+    },
+    destroyRenderer: {
+      args: ["ptr", "bool", "u32"],
+      returns: "void"
+    },
+    setUseThread: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    setBackgroundColor: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    setRenderOffset: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    updateStats: {
+      args: ["ptr", "f64", "u32", "f64"],
+      returns: "void"
+    },
+    updateMemoryStats: {
+      args: ["ptr", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    render: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    getNextBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    getCurrentBuffer: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    createOptimizedBuffer: {
+      args: ["u32", "u32", "bool"],
+      returns: "ptr"
+    },
+    destroyOptimizedBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    drawFrameBuffer: {
+      args: ["ptr", "i32", "i32", "ptr", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    getBufferWidth: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    getBufferHeight: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferClear: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    bufferGetCharPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetFgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetBgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetAttributesPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    bufferGetRespectAlpha: {
+      args: ["ptr"],
+      returns: "bool"
+    },
+    bufferSetRespectAlpha: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    bufferDrawText: {
+      args: ["ptr", "ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
+      returns: "void"
+    },
+    bufferSetCellWithAlphaBlending: {
+      args: ["ptr", "u32", "u32", "u32", "ptr", "ptr", "u8"],
+      returns: "void"
+    },
+    bufferFillRect: {
+      args: ["ptr", "u32", "u32", "u32", "u32", "ptr"],
+      returns: "void"
+    },
+    bufferResize: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    resizeRenderer: {
+      args: ["ptr", "u32", "u32"],
+      returns: "void"
+    },
+    setCursorPosition: {
+      args: ["i32", "i32", "bool"],
+      returns: "void"
+    },
+    setCursorStyle: {
+      args: ["ptr", "u32", "bool"],
+      returns: "void"
+    },
+    setCursorColor: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    setDebugOverlay: {
+      args: ["ptr", "bool", "u8"],
+      returns: "void"
+    },
+    clearTerminal: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    bufferDrawSuperSampleBuffer: {
+      args: ["ptr", "u32", "u32", "ptr", "usize", "u8", "u32"],
+      returns: "void"
+    },
+    bufferDrawPackedBuffer: {
+      args: ["ptr", "ptr", "usize", "u32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    bufferDrawBox: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "ptr", "u32", "ptr", "ptr", "ptr", "u32"],
+      returns: "void"
+    },
+    addToHitGrid: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
+      returns: "void"
+    },
+    checkHit: {
+      args: ["ptr", "u32", "u32"],
+      returns: "u32"
+    },
+    dumpHitGrid: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    dumpBuffers: {
+      args: ["ptr", "i64"],
+      returns: "void"
+    },
+    dumpStdoutBuffer: {
+      args: ["ptr", "i64"],
+      returns: "void"
+    },
+    enableMouse: {
+      args: ["ptr", "bool"],
+      returns: "void"
+    },
+    disableMouse: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    createTextBuffer: {
+      args: ["u32"],
+      returns: "ptr"
+    },
+    destroyTextBuffer: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferGetCharPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetFgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetBgPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetAttributesPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetLength: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferSetCell: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr", "u16"],
+      returns: "void"
+    },
+    textBufferConcat: {
+      args: ["ptr", "ptr"],
+      returns: "ptr"
+    },
+    textBufferResize: {
+      args: ["ptr", "u32"],
+      returns: "void"
+    },
+    textBufferReset: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetSelection: {
+      args: ["ptr", "u32", "u32", "ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferResetSelection: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultFg: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultBg: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferSetDefaultAttributes: {
+      args: ["ptr", "ptr"],
+      returns: "void"
+    },
+    textBufferResetDefaults: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferWriteChunk: {
+      args: ["ptr", "ptr", "u32", "ptr", "ptr", "ptr"],
+      returns: "u32"
+    },
+    textBufferGetCapacity: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    textBufferFinalizeLineInfo: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    textBufferGetLineStartsPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetLineWidthsPtr: {
+      args: ["ptr"],
+      returns: "ptr"
+    },
+    textBufferGetLineCount: {
+      args: ["ptr"],
+      returns: "u32"
+    },
+    bufferDrawTextBuffer: {
+      args: ["ptr", "ptr", "i32", "i32", "i32", "i32", "u32", "u32", "bool"],
+      returns: "void"
+    }
+  });
+}
 
-// src/lib/ascii.font.ts
-var fonts = {
-  tiny: tiny_default,
-  block: block_default,
-  shade: shade_default,
-  slick: slick_default
-};
-var parsedFonts = {};
-function parseColorTags(text) {
-  const segments = [];
-  let currentIndex = 0;
-  const colorTagRegex = /<c(\d+)>(.*?)<\/c\d+>/g;
-  let lastIndex = 0;
-  let match;
-  while ((match = colorTagRegex.exec(text)) !== null) {
-    if (match.index > lastIndex) {
-      const plainText = text.slice(lastIndex, match.index);
-      if (plainText) {
-        segments.push({ text: plainText, colorIndex: 0 });
-      }
+class FFIRenderLib {
+  opentui;
+  encoder = new TextEncoder;
+  constructor(libPath) {
+    this.opentui = getOpenTUILib(libPath);
+  }
+  createRenderer(width, height) {
+    return this.opentui.symbols.createRenderer(width, height);
+  }
+  destroyRenderer(renderer, useAlternateScreen, splitHeight) {
+    this.opentui.symbols.destroyRenderer(renderer, useAlternateScreen, splitHeight);
+  }
+  setUseThread(renderer, useThread) {
+    this.opentui.symbols.setUseThread(renderer, useThread);
+  }
+  setBackgroundColor(renderer, color) {
+    this.opentui.symbols.setBackgroundColor(renderer, color.buffer);
+  }
+  setRenderOffset(renderer, offset) {
+    this.opentui.symbols.setRenderOffset(renderer, offset);
+  }
+  updateStats(renderer, time, fps, frameCallbackTime) {
+    this.opentui.symbols.updateStats(renderer, time, fps, frameCallbackTime);
+  }
+  updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers) {
+    this.opentui.symbols.updateMemoryStats(renderer, heapUsed, heapTotal, arrayBuffers);
+  }
+  getNextBuffer(renderer) {
+    const bufferPtr = this.opentui.symbols.getNextBuffer(renderer);
+    if (!bufferPtr) {
+      throw new Error("Failed to get next buffer");
     }
-    const colorIndex = parseInt(match[1]) - 1;
-    const taggedText = match[2];
-    segments.push({ text: taggedText, colorIndex: Math.max(0, colorIndex) });
-    lastIndex = match.index + match[0].length;
+    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
+    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
+    const size = width * height;
+    const buffers = this.getBuffer(bufferPtr, size);
+    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, {});
   }
-  if (lastIndex < text.length) {
-    const remainingText = text.slice(lastIndex);
-    if (remainingText) {
-      segments.push({ text: remainingText, colorIndex: 0 });
+  getCurrentBuffer(renderer) {
+    const bufferPtr = this.opentui.symbols.getCurrentBuffer(renderer);
+    if (!bufferPtr) {
+      throw new Error("Failed to get current buffer");
     }
+    const width = this.opentui.symbols.getBufferWidth(bufferPtr);
+    const height = this.opentui.symbols.getBufferHeight(bufferPtr);
+    const size = width * height;
+    const buffers = this.getBuffer(bufferPtr, size);
+    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, {});
   }
-  return segments;
-}
-function getParsedFont(fontKey) {
-  if (!parsedFonts[fontKey]) {
-    const fontDef = fonts[fontKey];
-    const parsedChars = {};
-    for (const [char, lines] of Object.entries(fontDef.chars)) {
-      parsedChars[char] = lines.map((line) => parseColorTags(line));
+  getBuffer(bufferPtr, size) {
+    const charPtr = this.opentui.symbols.bufferGetCharPtr(bufferPtr);
+    const fgPtr = this.opentui.symbols.bufferGetFgPtr(bufferPtr);
+    const bgPtr = this.opentui.symbols.bufferGetBgPtr(bufferPtr);
+    const attributesPtr = this.opentui.symbols.bufferGetAttributesPtr(bufferPtr);
+    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
+      throw new Error("Failed to get buffer pointers");
     }
-    parsedFonts[fontKey] = {
-      ...fontDef,
-      colors: fontDef.colors || 1,
-      chars: parsedChars
+    const buffers = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
+      attributes: new Uint8Array(toArrayBuffer(attributesPtr, 0, size))
     };
+    return buffers;
   }
-  return parsedFonts[fontKey];
-}
-function measureText({ text, font = "tiny" }) {
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    console.warn(`Font '${font}' not found`);
-    return { width: 0, height: 0 };
+  getTextBuffer(bufferPtr, size) {
+    const charPtr = this.opentui.symbols.textBufferGetCharPtr(bufferPtr);
+    const fgPtr = this.opentui.symbols.textBufferGetFgPtr(bufferPtr);
+    const bgPtr = this.opentui.symbols.textBufferGetBgPtr(bufferPtr);
+    const attributesPtr = this.opentui.symbols.textBufferGetAttributesPtr(bufferPtr);
+    if (!charPtr || !fgPtr || !bgPtr || !attributesPtr) {
+      throw new Error("Failed to get text buffer pointers");
+    }
+    const buffers = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, size * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, size * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, size * 4 * 4)),
+      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, size * 2))
+    };
+    return buffers;
   }
-  let currentX = 0;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        let spaceWidth = 0;
-        for (const segment of spaceChar[0]) {
-          spaceWidth += segment.text.length;
-        }
-        currentX += spaceWidth;
-      } else {
-        currentX += 1;
-      }
-      continue;
+  bufferGetCharPtr(buffer) {
+    const ptr = this.opentui.symbols.bufferGetCharPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get char pointer");
     }
-    let charWidth = 0;
-    if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
-      }
+    return ptr;
+  }
+  bufferGetFgPtr(buffer) {
+    const ptr = this.opentui.symbols.bufferGetFgPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get fg pointer");
     }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
+    return ptr;
+  }
+  bufferGetBgPtr(buffer) {
+    const ptr = this.opentui.symbols.bufferGetBgPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get bg pointer");
+    }
+    return ptr;
+  }
+  bufferGetAttributesPtr(buffer) {
+    const ptr = this.opentui.symbols.bufferGetAttributesPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get attributes pointer");
     }
+    return ptr;
   }
-  return {
-    width: currentX,
-    height: fontDef.lines
-  };
-}
-function getCharacterPositions(text, font = "tiny") {
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    return [0];
+  bufferGetRespectAlpha(buffer) {
+    return this.opentui.symbols.bufferGetRespectAlpha(buffer);
+  }
+  bufferSetRespectAlpha(buffer, respectAlpha) {
+    this.opentui.symbols.bufferSetRespectAlpha(buffer, respectAlpha);
+  }
+  getBufferWidth(buffer) {
+    return this.opentui.symbols.getBufferWidth(buffer);
+  }
+  getBufferHeight(buffer) {
+    return this.opentui.symbols.getBufferHeight(buffer);
+  }
+  bufferClear(buffer, color) {
+    this.opentui.symbols.bufferClear(buffer, color.buffer);
+  }
+  bufferDrawText(buffer, text, x, y, color, bgColor, attributes) {
+    const textBytes = this.encoder.encode(text);
+    const textLength = textBytes.byteLength;
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferDrawText(buffer, textBytes, textLength, x, y, fg2, bg2, attributes ?? 0);
+  }
+  bufferSetCellWithAlphaBlending(buffer, x, y, char, color, bgColor, attributes) {
+    const charPtr = char.codePointAt(0) ?? " ".codePointAt(0);
+    const bg2 = bgColor.buffer;
+    const fg2 = color.buffer;
+    this.opentui.symbols.bufferSetCellWithAlphaBlending(buffer, x, y, charPtr, fg2, bg2, attributes ?? 0);
+  }
+  bufferFillRect(buffer, x, y, width, height, color) {
+    const bg2 = color.buffer;
+    this.opentui.symbols.bufferFillRect(buffer, x, y, width, height, bg2);
+  }
+  bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, format, alignedBytesPerRow) {
+    const formatId = format === "bgra8unorm" ? 0 : 1;
+    this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, formatId, alignedBytesPerRow);
+  }
+  bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
+    this.opentui.symbols.bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
+  }
+  bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, title) {
+    const titleBytes = title ? this.encoder.encode(title) : null;
+    const titleLen = title ? titleBytes.length : 0;
+    const titlePtr = title ? titleBytes : null;
+    this.opentui.symbols.bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor.buffer, backgroundColor.buffer, titlePtr, titleLen);
   }
-  const positions = [0];
-  let currentX = 0;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    let charWidth = 0;
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        for (const segment of spaceChar[0]) {
-          charWidth += segment.text.length;
-        }
-      } else {
-        charWidth = 1;
-      }
-    } else if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
-      }
-    }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
-    }
-    positions.push(currentX);
+  bufferResize(buffer, width, height) {
+    this.opentui.symbols.bufferResize(buffer, width, height);
+    const buffers = this.getBuffer(buffer, width * height);
+    return buffers;
   }
-  return positions;
-}
-function coordinateToCharacterIndex(x, text, font = "tiny") {
-  const positions = getCharacterPositions(text, font);
-  if (x < 0) {
-    return 0;
+  resizeRenderer(renderer, width, height) {
+    this.opentui.symbols.resizeRenderer(renderer, width, height);
   }
-  for (let i = 0;i < positions.length - 1; i++) {
-    const currentPos = positions[i];
-    const nextPos = positions[i + 1];
-    if (x >= currentPos && x < nextPos) {
-      const charMidpoint = currentPos + (nextPos - currentPos) / 2;
-      return x < charMidpoint ? i : i + 1;
-    }
+  setCursorPosition(x, y, visible) {
+    this.opentui.symbols.setCursorPosition(x, y, visible);
   }
-  if (positions.length > 0 && x >= positions[positions.length - 1]) {
-    return text.length;
+  setCursorStyle(style, blinking) {
+    const stylePtr = this.encoder.encode(style);
+    this.opentui.symbols.setCursorStyle(stylePtr, style.length, blinking);
   }
-  return 0;
-}
-function renderFontToFrameBuffer(buffer, {
-  text,
-  x = 0,
-  y = 0,
-  fg = [RGBA.fromInts(255, 255, 255, 255)],
-  bg = RGBA.fromInts(0, 0, 0, 255),
-  font = "tiny"
-}) {
-  const width = buffer.getWidth();
-  const height = buffer.getHeight();
-  const fontDef = getParsedFont(font);
-  if (!fontDef) {
-    console.warn(`Font '${font}' not found`);
-    return { width: 0, height: 0 };
+  setCursorColor(color) {
+    this.opentui.symbols.setCursorColor(color.buffer);
   }
-  const colors = Array.isArray(fg) ? fg : [fg];
-  if (y < 0 || y + fontDef.lines > height) {
-    return { width: 0, height: fontDef.lines };
+  render(renderer, force) {
+    this.opentui.symbols.render(renderer, force);
   }
-  let currentX = x;
-  const startX = x;
-  for (let i = 0;i < text.length; i++) {
-    const char = text[i].toUpperCase();
-    const charDef = fontDef.chars[char];
-    if (!charDef) {
-      const spaceChar = fontDef.chars[" "];
-      if (spaceChar && spaceChar[0]) {
-        let spaceWidth = 0;
-        for (const segment of spaceChar[0]) {
-          spaceWidth += segment.text.length;
-        }
-        currentX += spaceWidth;
-      } else {
-        currentX += 1;
-      }
-      continue;
-    }
-    let charWidth = 0;
-    if (charDef[0]) {
-      for (const segment of charDef[0]) {
-        charWidth += segment.text.length;
-      }
-    }
-    if (currentX >= width)
-      break;
-    if (currentX + charWidth < 0) {
-      currentX += charWidth + fontDef.letterspace_size;
-      continue;
-    }
-    for (let lineIdx = 0;lineIdx < fontDef.lines && lineIdx < charDef.length; lineIdx++) {
-      const segments = charDef[lineIdx];
-      const renderY = y + lineIdx;
-      if (renderY >= 0 && renderY < height) {
-        let segmentX = currentX;
-        for (const segment of segments) {
-          const segmentColor = colors[segment.colorIndex] || colors[0];
-          for (let charIdx = 0;charIdx < segment.text.length; charIdx++) {
-            const renderX = segmentX + charIdx;
-            if (renderX >= 0 && renderX < width) {
-              const fontChar = segment.text[charIdx];
-              if (fontChar !== " ") {
-                buffer.setCell(renderX, renderY, fontChar, segmentColor, bg);
-              }
-            }
-          }
-          segmentX += segment.text.length;
-        }
-      }
+  createOptimizedBuffer(width, height, respectAlpha = false) {
+    if (Number.isNaN(width) || Number.isNaN(height)) {
+      console.error(new Error(`Invalid dimensions for OptimizedBuffer: ${width}x${height}`).stack);
     }
-    currentX += charWidth;
-    if (i < text.length - 1) {
-      currentX += fontDef.letterspace_size;
+    const bufferPtr = this.opentui.symbols.createOptimizedBuffer(width, height, respectAlpha);
+    if (!bufferPtr) {
+      throw new Error(`Failed to create optimized buffer: ${width}x${height}`);
     }
+    const size = width * height;
+    const buffers = this.getBuffer(bufferPtr, size);
+    return new OptimizedBuffer(this, bufferPtr, buffers, width, height, { respectAlpha });
   }
-  return {
-    width: currentX - startX,
-    height: fontDef.lines
-  };
-}
-// src/lib/styled-text.ts
-var textEncoder = new TextEncoder;
-
-class StyledText {
-  chunks;
-  _plainText = "";
-  constructor(chunks) {
-    this.chunks = chunks;
-    for (let i = 0;i < chunks.length; i++) {
-      this._plainText += chunks[i].plainText;
-    }
+  destroyOptimizedBuffer(bufferPtr) {
+    this.opentui.symbols.destroyOptimizedBuffer(bufferPtr);
   }
-  toString() {
-    return this._plainText;
+  drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, sourceX, sourceY, sourceWidth, sourceHeight) {
+    const srcX = sourceX ?? 0;
+    const srcY = sourceY ?? 0;
+    const srcWidth = sourceWidth ?? 0;
+    const srcHeight = sourceHeight ?? 0;
+    this.opentui.symbols.drawFrameBuffer(targetBufferPtr, destX, destY, bufferPtr, srcX, srcY, srcWidth, srcHeight);
   }
-  _chunksToPlainText() {
-    this._plainText = "";
-    for (const chunk of this.chunks) {
-      this._plainText += chunk.plainText;
-    }
+  setDebugOverlay(renderer, enabled, corner) {
+    this.opentui.symbols.setDebugOverlay(renderer, enabled, corner);
   }
-  insert(chunk, index) {
-    const originalLength = this.chunks.length;
-    if (index === undefined) {
-      this.chunks.push(chunk);
-    } else {
-      this.chunks.splice(index, 0, chunk);
-    }
-    if (index === undefined || index === originalLength) {
-      this._plainText += chunk.plainText;
-    } else {
-      this._chunksToPlainText();
-    }
+  clearTerminal(renderer) {
+    this.opentui.symbols.clearTerminal(renderer);
   }
-  remove(chunk) {
-    const originalLength = this.chunks.length;
-    const index = this.chunks.indexOf(chunk);
-    if (index === -1)
-      return;
-    this.chunks.splice(index, 1);
-    if (index === originalLength - 1) {
-      this._plainText = this._plainText.slice(0, this._plainText.length - chunk.plainText.length);
-    } else {
-      this._chunksToPlainText();
-    }
+  addToHitGrid(renderer, x, y, width, height, id) {
+    this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id);
   }
-  replace(chunk, oldChunk) {
-    const index = this.chunks.indexOf(oldChunk);
-    if (index === -1)
-      return;
-    this.chunks.splice(index, 1, chunk);
-    if (index === this.chunks.length - 1) {
-      this._plainText = this._plainText.slice(0, this._plainText.length - oldChunk.plainText.length) + chunk.plainText;
-    } else {
-      this._chunksToPlainText();
-    }
+  checkHit(renderer, x, y) {
+    return this.opentui.symbols.checkHit(renderer, x, y);
   }
-}
-function stringToStyledText(content) {
-  const textEncoder2 = new TextEncoder;
-  const chunk = {
-    __isChunk: true,
-    text: textEncoder2.encode(content),
-    plainText: content
-  };
-  return new StyledText([chunk]);
-}
-var templateCache = new WeakMap;
-function applyStyle(input, style) {
-  if (typeof input === "object" && "__isChunk" in input) {
-    const existingChunk = input;
-    const fg = style.fg ? parseColor(style.fg) : existingChunk.fg;
-    const bg = style.bg ? parseColor(style.bg) : existingChunk.bg;
-    const newAttrs = createTextAttributes(style);
-    const mergedAttrs = existingChunk.attributes ? existingChunk.attributes | newAttrs : newAttrs;
-    return {
-      __isChunk: true,
-      text: existingChunk.text,
-      plainText: existingChunk.plainText,
-      fg,
-      bg,
-      attributes: mergedAttrs
-    };
-  } else {
-    const plainTextStr = String(input);
-    const text = textEncoder.encode(plainTextStr);
-    const fg = style.fg ? parseColor(style.fg) : undefined;
-    const bg = style.bg ? parseColor(style.bg) : undefined;
-    const attributes = createTextAttributes(style);
-    return {
-      __isChunk: true,
-      text,
-      plainText: plainTextStr,
-      fg,
-      bg,
-      attributes
+  dumpHitGrid(renderer) {
+    this.opentui.symbols.dumpHitGrid(renderer);
+  }
+  dumpBuffers(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpBuffers(renderer, ts);
+  }
+  dumpStdoutBuffer(renderer, timestamp) {
+    const ts = timestamp ?? Date.now();
+    this.opentui.symbols.dumpStdoutBuffer(renderer, ts);
+  }
+  enableMouse(renderer, enableMovement) {
+    this.opentui.symbols.enableMouse(renderer, enableMovement);
+  }
+  disableMouse(renderer) {
+    this.opentui.symbols.disableMouse(renderer);
+  }
+  createTextBuffer(capacity) {
+    const bufferPtr = this.opentui.symbols.createTextBuffer(capacity);
+    if (!bufferPtr) {
+      throw new Error(`Failed to create TextBuffer with capacity ${capacity}`);
+    }
+    const charPtr = this.textBufferGetCharPtr(bufferPtr);
+    const fgPtr = this.textBufferGetFgPtr(bufferPtr);
+    const bgPtr = this.textBufferGetBgPtr(bufferPtr);
+    const attributesPtr = this.textBufferGetAttributesPtr(bufferPtr);
+    const buffer = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, capacity * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, capacity * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, capacity * 4 * 4)),
+      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, capacity * 2))
     };
+    return new TextBuffer(this, bufferPtr, buffer, capacity);
   }
-}
-var black = (input) => applyStyle(input, { fg: "black" });
-var red = (input) => applyStyle(input, { fg: "red" });
-var green = (input) => applyStyle(input, { fg: "green" });
-var yellow = (input) => applyStyle(input, { fg: "yellow" });
-var blue = (input) => applyStyle(input, { fg: "blue" });
-var magenta = (input) => applyStyle(input, { fg: "magenta" });
-var cyan = (input) => applyStyle(input, { fg: "cyan" });
-var white = (input) => applyStyle(input, { fg: "white" });
-var brightBlack = (input) => applyStyle(input, { fg: "brightBlack" });
-var brightRed = (input) => applyStyle(input, { fg: "brightRed" });
-var brightGreen = (input) => applyStyle(input, { fg: "brightGreen" });
-var brightYellow = (input) => applyStyle(input, { fg: "brightYellow" });
-var brightBlue = (input) => applyStyle(input, { fg: "brightBlue" });
-var brightMagenta = (input) => applyStyle(input, { fg: "brightMagenta" });
-var brightCyan = (input) => applyStyle(input, { fg: "brightCyan" });
-var brightWhite = (input) => applyStyle(input, { fg: "brightWhite" });
-var bgBlack = (input) => applyStyle(input, { bg: "black" });
-var bgRed = (input) => applyStyle(input, { bg: "red" });
-var bgGreen = (input) => applyStyle(input, { bg: "green" });
-var bgYellow = (input) => applyStyle(input, { bg: "yellow" });
-var bgBlue = (input) => applyStyle(input, { bg: "blue" });
-var bgMagenta = (input) => applyStyle(input, { bg: "magenta" });
-var bgCyan = (input) => applyStyle(input, { bg: "cyan" });
-var bgWhite = (input) => applyStyle(input, { bg: "white" });
-var bold = (input) => applyStyle(input, { bold: true });
-var italic = (input) => applyStyle(input, { italic: true });
-var underline = (input) => applyStyle(input, { underline: true });
-var strikethrough = (input) => applyStyle(input, { strikethrough: true });
-var dim = (input) => applyStyle(input, { dim: true });
-var reverse = (input) => applyStyle(input, { reverse: true });
-var blink = (input) => applyStyle(input, { blink: true });
-var fg = (color) => (input) => applyStyle(input, { fg: color });
-var bg = (color) => (input) => applyStyle(input, { bg: color });
-function tn(strings, ...values) {
-  const chunks = [];
-  let length = 0;
-  let plainText = "";
-  for (let i = 0;i < strings.length; i++) {
-    const raw = strings[i];
-    if (raw) {
-      chunks.push({
-        __isChunk: true,
-        text: textEncoder.encode(raw),
-        plainText: raw,
-        attributes: 0
-      });
-      length += raw.length;
-      plainText += raw;
-    }
-    const val = values[i];
-    if (typeof val === "object" && "__isChunk" in val) {
-      chunks.push(val);
-      length += val.plainText.length;
-      plainText += val.plainText;
-    } else if (val !== undefined) {
-      const plainTextStr = String(val);
-      chunks.push({
-        __isChunk: true,
-        text: textEncoder.encode(plainTextStr),
-        plainText: plainTextStr,
-        attributes: 0
-      });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
+  destroyTextBuffer(buffer) {
+    this.opentui.symbols.destroyTextBuffer(buffer);
+  }
+  textBufferGetCharPtr(buffer) {
+    const ptr = this.opentui.symbols.textBufferGetCharPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get TextBuffer char pointer");
     }
+    return ptr;
   }
-  return new StyledText(chunks);
-}
-function t(strings, ...values) {
-  let cachedStringChunks = templateCache.get(strings);
-  let length = 0;
-  let plainText = "";
-  if (!cachedStringChunks) {
-    cachedStringChunks = [];
-    for (let i = 0;i < strings.length; i++) {
-      const raw = strings[i];
-      if (raw) {
-        cachedStringChunks.push({
-          __isChunk: true,
-          text: textEncoder.encode(raw),
-          plainText: raw,
-          attributes: 0
-        });
-      } else {
-        cachedStringChunks.push(null);
-      }
+  textBufferGetFgPtr(buffer) {
+    const ptr = this.opentui.symbols.textBufferGetFgPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get TextBuffer fg pointer");
     }
-    templateCache.set(strings, cachedStringChunks);
+    return ptr;
   }
-  const chunks = [];
-  for (let i = 0;i < strings.length; i++) {
-    const stringChunk = cachedStringChunks[i];
-    if (stringChunk) {
-      chunks.push(stringChunk);
-      length += stringChunk.plainText.length;
-      plainText += stringChunk.plainText;
+  textBufferGetBgPtr(buffer) {
+    const ptr = this.opentui.symbols.textBufferGetBgPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get TextBuffer bg pointer");
     }
-    const val = values[i];
-    if (typeof val === "object" && "__isChunk" in val) {
-      chunks.push(val);
-      length += val.plainText.length;
-      plainText += val.plainText;
-    } else if (val !== undefined) {
-      const plainTextStr = String(val);
-      chunks.push({
-        __isChunk: true,
-        text: textEncoder.encode(plainTextStr),
-        plainText: plainTextStr,
-        attributes: 0
-      });
-      length += plainTextStr.length;
-      plainText += plainTextStr;
+    return ptr;
+  }
+  textBufferGetAttributesPtr(buffer) {
+    const ptr = this.opentui.symbols.textBufferGetAttributesPtr(buffer);
+    if (!ptr) {
+      throw new Error("Failed to get TextBuffer attributes pointer");
     }
+    return ptr;
   }
-  return new StyledText(chunks);
-}
-
-// src/lib/hast-styled-text.ts
-class SyntaxStyle {
-  styles;
-  mergedStyleCache;
-  constructor(styles) {
-    this.styles = styles;
-    this.mergedStyleCache = new Map;
+  textBufferGetLength(buffer) {
+    return this.opentui.symbols.textBufferGetLength(buffer);
   }
-  mergeStyles(...styleNames) {
-    const cacheKey = styleNames.join(":");
-    const cached = this.mergedStyleCache.get(cacheKey);
-    if (cached)
-      return cached;
-    const styleDefinition = {};
-    for (const name of styleNames) {
-      const style = this.styles[name];
-      if (!style)
-        continue;
-      if (style.fg)
-        styleDefinition.fg = style.fg;
-      if (style.bg)
-        styleDefinition.bg = style.bg;
-      if (style.bold !== undefined)
-        styleDefinition.bold = style.bold;
-      if (style.italic !== undefined)
-        styleDefinition.italic = style.italic;
-      if (style.underline !== undefined)
-        styleDefinition.underline = style.underline;
-      if (style.dim !== undefined)
-        styleDefinition.dim = style.dim;
+  textBufferSetCell(buffer, index, char, fg2, bg2, attr) {
+    this.opentui.symbols.textBufferSetCell(buffer, index, char, fg2, bg2, attr);
+  }
+  textBufferConcat(buffer1, buffer2) {
+    const resultPtr = this.opentui.symbols.textBufferConcat(buffer1, buffer2);
+    if (!resultPtr) {
+      throw new Error("Failed to concatenate TextBuffers");
     }
-    const attributes = createTextAttributes({
-      bold: styleDefinition.bold,
-      italic: styleDefinition.italic,
-      underline: styleDefinition.underline,
-      dim: styleDefinition.dim
-    });
-    const merged = {
-      fg: styleDefinition.fg,
-      bg: styleDefinition.bg,
-      attributes
+    const length = this.textBufferGetLength(resultPtr);
+    const charPtr = this.textBufferGetCharPtr(resultPtr);
+    const fgPtr = this.textBufferGetFgPtr(resultPtr);
+    const bgPtr = this.textBufferGetBgPtr(resultPtr);
+    const attributesPtr = this.textBufferGetAttributesPtr(resultPtr);
+    const buffer = {
+      char: new Uint32Array(toArrayBuffer(charPtr, 0, length * 4)),
+      fg: new Float32Array(toArrayBuffer(fgPtr, 0, length * 4 * 4)),
+      bg: new Float32Array(toArrayBuffer(bgPtr, 0, length * 4 * 4)),
+      attributes: new Uint16Array(toArrayBuffer(attributesPtr, 0, length * 2))
     };
-    this.mergedStyleCache.set(cacheKey, merged);
-    return merged;
+    return new TextBuffer(this, resultPtr, buffer, length);
   }
-  clearCache() {
-    this.mergedStyleCache.clear();
+  textBufferResize(buffer, newLength) {
+    this.opentui.symbols.textBufferResize(buffer, newLength);
+    const buffers = this.getTextBuffer(buffer, newLength);
+    return buffers;
   }
-  getCacheSize() {
-    return this.mergedStyleCache.size;
+  textBufferReset(buffer) {
+    this.opentui.symbols.textBufferReset(buffer);
   }
-}
-var textEncoder2 = new TextEncoder;
-function hastToTextChunks(node, syntaxStyle, parentStyles = []) {
-  const chunks = [];
-  if (node.type === "text") {
-    const stylesToMerge = parentStyles.length > 0 ? parentStyles : ["default"];
-    const mergedStyle = syntaxStyle.mergeStyles(...stylesToMerge);
-    chunks.push({
-      __isChunk: true,
-      text: textEncoder2.encode(node.value),
-      plainText: node.value,
-      fg: mergedStyle.fg,
-      bg: mergedStyle.bg,
-      attributes: mergedStyle.attributes
-    });
-  } else if (node.type === "element") {
-    let currentStyles = [...parentStyles];
-    if (node.properties?.className) {
-      const classes = node.properties.className.split(" ");
-      for (const cls of classes) {
-        currentStyles.push(cls);
-      }
+  textBufferSetSelection(buffer, start, end, bgColor, fgColor) {
+    const bg2 = bgColor ? bgColor.buffer : null;
+    const fg2 = fgColor ? fgColor.buffer : null;
+    this.opentui.symbols.textBufferSetSelection(buffer, start, end, bg2, fg2);
+  }
+  textBufferResetSelection(buffer) {
+    this.opentui.symbols.textBufferResetSelection(buffer);
+  }
+  textBufferSetDefaultFg(buffer, fg2) {
+    const fgPtr = fg2 ? fg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultFg(buffer, fgPtr);
+  }
+  textBufferSetDefaultBg(buffer, bg2) {
+    const bgPtr = bg2 ? bg2.buffer : null;
+    this.opentui.symbols.textBufferSetDefaultBg(buffer, bgPtr);
+  }
+  textBufferSetDefaultAttributes(buffer, attributes) {
+    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
+    this.opentui.symbols.textBufferSetDefaultAttributes(buffer, attrValue);
+  }
+  textBufferResetDefaults(buffer) {
+    this.opentui.symbols.textBufferResetDefaults(buffer);
+  }
+  textBufferWriteChunk(buffer, textBytes, fg2, bg2, attributes) {
+    const attrValue = attributes === null ? null : new Uint8Array([attributes]);
+    return this.opentui.symbols.textBufferWriteChunk(buffer, textBytes, textBytes.length, fg2 ? fg2.buffer : null, bg2 ? bg2.buffer : null, attrValue);
+  }
+  textBufferGetCapacity(buffer) {
+    return this.opentui.symbols.textBufferGetCapacity(buffer);
+  }
+  textBufferFinalizeLineInfo(buffer) {
+    this.opentui.symbols.textBufferFinalizeLineInfo(buffer);
+  }
+  textBufferGetLineInfo(buffer) {
+    const lineCount = this.opentui.symbols.textBufferGetLineCount(buffer);
+    if (lineCount === 0) {
+      return { lineStarts: [], lineWidths: [] };
     }
-    for (const child of node.children) {
-      chunks.push(...hastToTextChunks(child, syntaxStyle, currentStyles));
+    const lineStartsPtr = this.opentui.symbols.textBufferGetLineStartsPtr(buffer);
+    const lineWidthsPtr = this.opentui.symbols.textBufferGetLineWidthsPtr(buffer);
+    if (!lineStartsPtr || !lineWidthsPtr) {
+      return { lineStarts: [], lineWidths: [] };
     }
+    const lineStartsArray = new Uint32Array(toArrayBuffer(lineStartsPtr, 0, lineCount * 4));
+    const lineWidthsArray = new Uint32Array(toArrayBuffer(lineWidthsPtr, 0, lineCount * 4));
+    const lineStarts = Array.from(lineStartsArray);
+    const lineWidths = Array.from(lineWidthsArray);
+    return { lineStarts, lineWidths };
+  }
+  getTextBufferArrays(buffer, size) {
+    return this.getTextBuffer(buffer, size);
+  }
+  bufferDrawTextBuffer(buffer, textBuffer, x, y, clipRect) {
+    const hasClipRect = clipRect !== undefined && clipRect !== null;
+    const clipX = clipRect?.x ?? 0;
+    const clipY = clipRect?.y ?? 0;
+    const clipWidth = clipRect?.width ?? 0;
+    const clipHeight = clipRect?.height ?? 0;
+    this.opentui.symbols.bufferDrawTextBuffer(buffer, textBuffer, x, y, clipX, clipY, clipWidth, clipHeight, hasClipRect);
   }
-  return chunks;
 }
-function hastToStyledText(hast, syntaxStyle) {
-  const chunks = hastToTextChunks(hast, syntaxStyle);
-  return new StyledText(chunks);
+var opentuiLibPath;
+var opentuiLib;
+function setRenderLibPath(libPath) {
+  opentuiLibPath = libPath;
+}
+function resolveRenderLib() {
+  if (!opentuiLib) {
+    opentuiLib = new FFIRenderLib(opentuiLibPath);
+  }
+  return opentuiLib;
 }
+
 // src/buffer.ts
 var fbIdCounter = 0;
 function isRGBAWithAlpha(color) {
@@ -5982,17 +6665,17 @@ class OptimizedBuffer {
     }
     this.setCell(x, y, char, fg2, bg2, attributes);
   }
-  drawText(text, x, y, fg2, bg2, attributes = 0, selection) {
-    if (!selection) {
+  drawText(text, x, y, fg2, bg2, attributes = 0, selection2) {
+    if (!selection2) {
       this.drawTextFFI.call(this, text, x, y, fg2, bg2, attributes);
       return;
     }
-    const { start, end } = selection;
+    const { start, end } = selection2;
     let selectionBg;
     let selectionFg;
-    if (selection.bgColor) {
-      selectionBg = selection.bgColor;
-      selectionFg = selection.fgColor || fg2;
+    if (selection2.bgColor) {
+      selectionBg = selection2.bgColor;
+      selectionFg = selection2.fgColor || fg2;
     } else {
       const defaultBg = bg2 || RGBA.fromValues(0, 0, 0, 0);
       selectionFg = defaultBg.a > 0 ? defaultBg : RGBA.fromValues(0, 0, 0, 1);
@@ -7124,312 +7807,65 @@ class Timeline {
       evaluateTimelineSync(subTimeline, this.currentTime + deltaTime, deltaTime);
     }
     if (!this.isPlaying)
-      return;
-    this.currentTime += deltaTime;
-    for (const item of this.items) {
-      evaluateItem(item, this.currentTime, deltaTime);
-    }
-    for (let i = this.items.length - 1;i >= 0; i--) {
-      const item = this.items[i];
-      if (item.type === "animation" && item.once && item.completed) {
-        this.items.splice(i, 1);
-      }
-    }
-    if (this.loop && this.currentTime >= this.duration) {
-      const overshoot = this.currentTime % this.duration;
-      this.resetItems();
-      this.currentTime = 0;
-      if (overshoot > 0) {
-        this.update(overshoot);
-      }
-    } else if (!this.loop && this.currentTime >= this.duration) {
-      this.currentTime = this.duration;
-      this.isPlaying = false;
-      this.isComplete = true;
-      if (this.onComplete) {
-        this.onComplete();
-      }
-    }
-  }
-}
-
-class TimelineEngine {
-  timelines = new Set;
-  defaults = {
-    frameRate: 60
-  };
-  register(timeline) {
-    this.timelines.add(timeline);
-  }
-  unregister(timeline) {
-    this.timelines.delete(timeline);
-  }
-  clear() {
-    this.timelines.clear();
-  }
-  update(deltaTime) {
-    for (const timeline of this.timelines) {
-      if (!timeline.synced) {
-        timeline.update(deltaTime);
-      }
-    }
-  }
-}
-var engine = new TimelineEngine;
-function createTimeline(options = {}) {
-  const timeline = new Timeline(options);
-  if (options.autoplay !== false) {
-    timeline.play();
-  }
-  engine.register(timeline);
-  return timeline;
-}
-// src/lib/selection.ts
-class Selection {
-  _anchor;
-  _focus;
-  _selectedRenderables = [];
-  constructor(anchor, focus) {
-    this._anchor = { ...anchor };
-    this._focus = { ...focus };
-  }
-  get anchor() {
-    return { ...this._anchor };
-  }
-  get focus() {
-    return { ...this._focus };
-  }
-  get bounds() {
-    return {
-      startX: Math.min(this._anchor.x, this._focus.x),
-      startY: Math.min(this._anchor.y, this._focus.y),
-      endX: Math.max(this._anchor.x, this._focus.x),
-      endY: Math.max(this._anchor.y, this._focus.y)
-    };
-  }
-  updateSelectedRenderables(selectedRenderables) {
-    this._selectedRenderables = selectedRenderables;
-  }
-  getSelectedText() {
-    const selectedTexts = this._selectedRenderables.sort((a, b) => {
-      const aY = a.y;
-      const bY = b.y;
-      if (aY !== bY) {
-        return aY - bY;
-      }
-      return a.x - b.x;
-    }).map((renderable) => renderable.getSelectedText()).filter((text) => text);
-    return selectedTexts.join(`
-`);
-  }
-}
-
-class TextSelectionHelper {
-  getX;
-  getY;
-  getTextLength;
-  getLineInfo;
-  localSelection = null;
-  cachedGlobalSelection = null;
-  constructor(getX, getY, getTextLength, getLineInfo) {
-    this.getX = getX;
-    this.getY = getY;
-    this.getTextLength = getTextLength;
-    this.getLineInfo = getLineInfo;
-  }
-  hasSelection() {
-    return this.localSelection !== null;
-  }
-  getSelection() {
-    return this.localSelection;
-  }
-  reevaluateSelection(width, height = 1) {
-    if (!this.cachedGlobalSelection) {
-      return false;
-    }
-    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
-  }
-  shouldStartSelection(x, y, width, height) {
-    const localX = x - this.getX();
-    const localY = y - this.getY();
-    return localX >= 0 && localX < width && localY >= 0 && localY < height;
-  }
-  onSelectionChanged(selection, width, height = 1) {
-    this.cachedGlobalSelection = selection;
-    const previousSelection = this.localSelection;
-    if (!selection?.isActive) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    const myY = this.getY();
-    const myEndY = myY + height - 1;
-    if (myEndY < selection.anchor.y || myY > selection.focus.y) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    if (height === 1) {
-      this.localSelection = this.calculateSingleLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x, width);
-    } else {
-      this.localSelection = this.calculateMultiLineSelection(myY, selection.anchor.y, selection.focus.y, selection.anchor.x, selection.focus.x);
-    }
-    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
-  }
-  calculateSingleLineSelection(lineY, anchorY, focusY, anchorX, focusX, width) {
-    const textLength = this.getTextLength();
-    const myX = this.getX();
-    if (lineY > anchorY && lineY < focusY) {
-      return { start: 0, end: textLength };
-    }
-    if (lineY === anchorY && lineY === focusY) {
-      const start = Math.max(0, Math.min(anchorX - myX, textLength));
-      const end = Math.max(0, Math.min(focusX - myX, textLength));
-      return start < end ? { start, end } : null;
-    }
-    if (lineY === anchorY) {
-      const start = Math.max(0, Math.min(anchorX - myX, textLength));
-      return start < textLength ? { start, end: textLength } : null;
-    }
-    if (lineY === focusY) {
-      const end = Math.max(0, Math.min(focusX - myX, textLength));
-      return end > 0 ? { start: 0, end } : null;
-    }
-    return null;
-  }
-  calculateMultiLineSelection(startY, anchorY, focusY, anchorX, focusX) {
-    const lineInfo = this.getLineInfo?.();
-    if (!lineInfo) {
-      return { start: 0, end: this.getTextLength() };
-    }
-    const myX = this.getX();
-    let selectionStart = null;
-    let selectionEnd = null;
-    for (let i = 0;i < lineInfo.lineStarts.length; i++) {
-      const lineY = startY + i;
-      if (lineY < anchorY || lineY > focusY)
-        continue;
-      const lineStart = lineInfo.lineStarts[i];
-      const lineEnd = i < lineInfo.lineStarts.length - 1 ? lineInfo.lineStarts[i + 1] - 1 : this.getTextLength();
-      const lineWidth = lineInfo.lineWidths[i];
-      if (lineY > anchorY && lineY < focusY) {
-        if (selectionStart === null)
-          selectionStart = lineStart;
-        selectionEnd = lineEnd;
-      } else if (lineY === anchorY && lineY === focusY) {
-        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
-        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
-        if (localStartX < localEndX) {
-          selectionStart = lineStart + localStartX;
-          selectionEnd = lineStart + localEndX;
-        }
-      } else if (lineY === anchorY) {
-        const localStartX = Math.max(0, Math.min(anchorX - myX, lineWidth));
-        if (localStartX < lineWidth) {
-          selectionStart = lineStart + localStartX;
-          selectionEnd = lineEnd;
-        }
-      } else if (lineY === focusY) {
-        const localEndX = Math.max(0, Math.min(focusX - myX, lineWidth));
-        if (localEndX > 0) {
-          if (selectionStart === null)
-            selectionStart = lineStart;
-          selectionEnd = lineStart + localEndX;
-        }
+      return;
+    this.currentTime += deltaTime;
+    for (const item of this.items) {
+      evaluateItem(item, this.currentTime, deltaTime);
+    }
+    for (let i = this.items.length - 1;i >= 0; i--) {
+      const item = this.items[i];
+      if (item.type === "animation" && item.once && item.completed) {
+        this.items.splice(i, 1);
+      }
+    }
+    if (this.loop && this.currentTime >= this.duration) {
+      const overshoot = this.currentTime % this.duration;
+      this.resetItems();
+      this.currentTime = 0;
+      if (overshoot > 0) {
+        this.update(overshoot);
+      }
+    } else if (!this.loop && this.currentTime >= this.duration) {
+      this.currentTime = this.duration;
+      this.isPlaying = false;
+      this.isComplete = true;
+      if (this.onComplete) {
+        this.onComplete();
       }
     }
-    return selectionStart !== null && selectionEnd !== null && selectionStart < selectionEnd ? { start: selectionStart, end: selectionEnd } : null;
   }
 }
 
-class ASCIIFontSelectionHelper {
-  getX;
-  getY;
-  getText;
-  getFont;
-  localSelection = null;
-  cachedGlobalSelection = null;
-  constructor(getX, getY, getText, getFont) {
-    this.getX = getX;
-    this.getY = getY;
-    this.getText = getText;
-    this.getFont = getFont;
-  }
-  hasSelection() {
-    return this.localSelection !== null;
+class TimelineEngine {
+  timelines = new Set;
+  defaults = {
+    frameRate: 60
+  };
+  register(timeline) {
+    this.timelines.add(timeline);
   }
-  getSelection() {
-    return this.localSelection;
+  unregister(timeline) {
+    this.timelines.delete(timeline);
   }
-  shouldStartSelection(x, y, width, height) {
-    const localX = x - this.getX();
-    const localY = y - this.getY();
-    if (localX < 0 || localX >= width || localY < 0 || localY >= height) {
-      return false;
-    }
-    const text = this.getText();
-    const font = this.getFont();
-    const charIndex = coordinateToCharacterIndex(localX, text, font);
-    return charIndex >= 0 && charIndex <= text.length;
+  clear() {
+    this.timelines.clear();
   }
-  onSelectionChanged(selection, width, height) {
-    this.cachedGlobalSelection = selection;
-    const previousSelection = this.localSelection;
-    if (!selection?.isActive) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    const myX = this.getX();
-    const myY = this.getY();
-    const myEndY = myY + height - 1;
-    const text = this.getText();
-    const font = this.getFont();
-    let selStart;
-    let selEnd;
-    if (selection.anchor.y < selection.focus.y || selection.anchor.y === selection.focus.y && selection.anchor.x <= selection.focus.x) {
-      selStart = selection.anchor;
-      selEnd = selection.focus;
-    } else {
-      selStart = selection.focus;
-      selEnd = selection.anchor;
-    }
-    if (myEndY < selStart.y || myY > selEnd.y) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    }
-    let startCharIndex = 0;
-    let endCharIndex = text.length;
-    if (selStart.y > myEndY) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selStart.y >= myY && selStart.y <= myEndY) {
-      const localX = selStart.x - myX;
-      if (localX > 0) {
-        startCharIndex = coordinateToCharacterIndex(localX, text, font);
-      }
-    }
-    if (selEnd.y < myY) {
-      this.localSelection = null;
-      return previousSelection !== null;
-    } else if (selEnd.y >= myY && selEnd.y <= myEndY) {
-      const localX = selEnd.x - myX;
-      if (localX >= 0) {
-        endCharIndex = coordinateToCharacterIndex(localX, text, font);
-      } else {
-        endCharIndex = 0;
+  update(deltaTime) {
+    for (const timeline of this.timelines) {
+      if (!timeline.synced) {
+        timeline.update(deltaTime);
       }
     }
-    if (startCharIndex < endCharIndex && startCharIndex >= 0 && endCharIndex <= text.length) {
-      this.localSelection = { start: startCharIndex, end: endCharIndex };
-    } else {
-      this.localSelection = null;
-    }
-    return this.localSelection !== null !== (previousSelection !== null) || this.localSelection?.start !== previousSelection?.start || this.localSelection?.end !== previousSelection?.end;
   }
-  reevaluateSelection(width, height) {
-    if (!this.cachedGlobalSelection) {
-      return false;
-    }
-    return this.onSelectionChanged(this.cachedGlobalSelection, width, height);
+}
+var engine = new TimelineEngine;
+function createTimeline(options = {}) {
+  const timeline = new Timeline(options);
+  if (options.autoplay !== false) {
+    timeline.play();
   }
+  engine.register(timeline);
+  return timeline;
 }
 // src/ansi.ts
 var ANSI = {
@@ -8119,106 +8555,6 @@ class TerminalConsole extends EventEmitter5 {
   }
 }
 
-// src/lib/parse.mouse.ts
-class MouseParser {
-  mouseButtonsPressed = new Set;
-  static SCROLL_DIRECTIONS = {
-    64: "up",
-    65: "down",
-    66: "left",
-    67: "right"
-  };
-  reset() {
-    this.mouseButtonsPressed.clear();
-  }
-  parseMouseEvent(data) {
-    const str = data.toString();
-    const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
-    if (sgrMatch) {
-      const [, buttonCode, x, y, pressRelease] = sgrMatch;
-      const rawButtonCode = parseInt(buttonCode);
-      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[rawButtonCode];
-      const isScroll = scrollDirection !== undefined;
-      const button = rawButtonCode & 3;
-      const isMotion = (rawButtonCode & 32) !== 0;
-      const modifiers = {
-        shift: (rawButtonCode & 4) !== 0,
-        alt: (rawButtonCode & 8) !== 0,
-        ctrl: (rawButtonCode & 16) !== 0
-      };
-      let type;
-      let scrollInfo;
-      if (isScroll && pressRelease === "M") {
-        type = "scroll";
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else if (isMotion) {
-        const isDragging = this.mouseButtonsPressed.size > 0;
-        if (button === 3) {
-          type = "move";
-        } else if (isDragging) {
-          type = "drag";
-        } else {
-          type = "move";
-        }
-      } else {
-        type = pressRelease === "M" ? "down" : "up";
-        if (type === "down" && button !== 3) {
-          this.mouseButtonsPressed.add(button);
-        } else if (type === "up") {
-          this.mouseButtonsPressed.clear();
-        }
-      }
-      return {
-        type,
-        button: button === 3 ? 0 : button,
-        x: parseInt(x) - 1,
-        y: parseInt(y) - 1,
-        modifiers,
-        scroll: scrollInfo
-      };
-    }
-    if (str.startsWith("\x1B[M") && str.length >= 6) {
-      const buttonByte = str.charCodeAt(3) - 32;
-      const x = str.charCodeAt(4) - 33;
-      const y = str.charCodeAt(5) - 33;
-      const scrollDirection = MouseParser.SCROLL_DIRECTIONS[buttonByte];
-      const isScroll = scrollDirection !== undefined;
-      const button = buttonByte & 3;
-      const modifiers = {
-        shift: (buttonByte & 4) !== 0,
-        alt: (buttonByte & 8) !== 0,
-        ctrl: (buttonByte & 16) !== 0
-      };
-      let type;
-      let actualButton;
-      let scrollInfo;
-      if (isScroll) {
-        type = "scroll";
-        actualButton = 0;
-        scrollInfo = {
-          direction: scrollDirection,
-          delta: 1
-        };
-      } else {
-        type = button === 3 ? "up" : "down";
-        actualButton = button === 3 ? 0 : button;
-      }
-      return {
-        type,
-        button: actualButton,
-        x,
-        y,
-        modifiers,
-        scroll: scrollInfo
-      };
-    }
-    return null;
-  }
-}
-
 // src/renderer.ts
 import { EventEmitter as EventEmitter6 } from "events";
 
@@ -8319,7 +8655,6 @@ class CliRenderer extends EventEmitter6 {
   postProcessFns = [];
   backgroundColor = RGBA.fromHex("#000000");
   waitingForPixelResolution = false;
-  shutdownRequested = null;
   rendering = false;
   renderingNative = false;
   renderTimeout = null;
@@ -8330,6 +8665,8 @@ class CliRenderer extends EventEmitter6 {
   targetFrameTime = 0;
   immediateRerenderRequested = false;
   updateScheduled = false;
+  liveRequestCounter = 0;
+  controlState = "idle" /* IDLE */;
   frameCallbacks = [];
   renderStats = {
     frameCount: 0,
@@ -8415,7 +8752,15 @@ class CliRenderer extends EventEmitter6 {
     this.nextRenderBuffer = this.lib.getNextBuffer(this.rendererPtr);
     this.currentRenderBuffer = this.lib.getCurrentBuffer(this.rendererPtr);
     this.postProcessFns = config.postProcessFns || [];
-    this.root = new RootRenderable(this.width, this.height, this.renderContext);
+    const rootContext = {
+      requestLive: () => {
+        this.requestLive();
+      },
+      dropLive: () => {
+        this.dropLive();
+      }
+    };
+    this.root = new RootRenderable(this.width, this.height, this.renderContext, rootContext);
     this.setupTerminal();
     this.takeMemorySnapshot();
     if (this.memorySnapshotInterval > 0) {
@@ -8548,6 +8893,12 @@ Error details:
   get experimental_splitHeight() {
     return this._splitHeight;
   }
+  get liveRequestCount() {
+    return this.liveRequestCounter;
+  }
+  get currentControlState() {
+    return this.controlState;
+  }
   set experimental_splitHeight(splitHeight) {
     if (splitHeight < 0)
       splitHeight = 0;
@@ -8736,6 +9087,7 @@ Error details:
       if (this.capturedRenderable && mouseEvent.type === "up") {
         const event = new MouseEvent(this.capturedRenderable, { ...mouseEvent, type: "drag-end" });
         this.capturedRenderable.processMouseEvent(event);
+        this.capturedRenderable.processMouseEvent(new MouseEvent(this.capturedRenderable, mouseEvent));
         if (maybeRenderable) {
           const event2 = new MouseEvent(maybeRenderable, {
             ...mouseEvent,
@@ -8749,7 +9101,7 @@ Error details:
         this.capturedRenderable = undefined;
       }
       if (maybeRenderable) {
-        if (mouseEvent.type === "down" && mouseEvent.button === 0 /* LEFT */) {
+        if (mouseEvent.type === "drag" && mouseEvent.button === 0 /* LEFT */) {
           this.capturedRenderable = maybeRenderable;
         } else {
           this.capturedRenderable = undefined;
@@ -8916,7 +9268,25 @@ Error details:
   clearFrameCallbacks() {
     this.frameCallbacks = [];
   }
+  requestLive() {
+    this.liveRequestCounter++;
+    if (this.controlState === "idle" /* IDLE */ && this.liveRequestCounter > 0) {
+      this.controlState = "auto_started" /* AUTO_STARTED */;
+      this.internalStart();
+    }
+  }
+  dropLive() {
+    this.liveRequestCounter = Math.max(0, this.liveRequestCounter - 1);
+    if (this.controlState === "auto_started" /* AUTO_STARTED */ && this.liveRequestCounter === 0) {
+      this.controlState = "idle" /* IDLE */;
+      this.internalPause();
+    }
+  }
   start() {
+    this.controlState = "explicit_started" /* EXPLICIT_STARTED */;
+    this.internalStart();
+  }
+  internalStart() {
     if (!this._isRunning && !this.isDestroyed) {
       this._isRunning = true;
       if (this.memorySnapshotInterval > 0) {
@@ -8926,9 +9296,17 @@ Error details:
     }
   }
   pause() {
+    this.controlState = "explicit_paused" /* EXPLICIT_PAUSED */;
+    this.internalPause();
+  }
+  internalPause() {
     this._isRunning = false;
   }
   stop() {
+    this.controlState = "explicit_stopped" /* EXPLICIT_STOPPED */;
+    this.internalStop();
+  }
+  internalStop() {
     if (this.isRunning && !this.isDestroyed) {
       this._isRunning = false;
       if (this.memorySnapshotTimer) {
@@ -9349,9 +9727,8 @@ class TextRenderable extends Renderable {
   constructor(id, options) {
     super(id, options);
     this.selectionHelper = new TextSelectionHelper(() => this.x, () => this.y, () => this._plainText.length, () => this._lineInfo);
-    if (options.content) {
-      this._text = typeof options.content === "string" ? stringToStyledText(options.content) : options.content;
-    }
+    const content = options.content ?? "";
+    this._text = typeof content === "string" ? stringToStyledText(content) : content;
     this._defaultFg = options.fg ? parseColor(options.fg) : RGBA.fromValues(1, 1, 1, 1);
     this._defaultBg = options.bg ? parseColor(options.bg) : RGBA.fromValues(0, 0, 0, 0);
     this._defaultAttributes = options.attributes ?? 0;
@@ -9362,8 +9739,8 @@ class TextRenderable extends Renderable {
     this.textBuffer.setDefaultFg(this._defaultFg);
     this.textBuffer.setDefaultBg(this._defaultBg);
     this.textBuffer.setDefaultAttributes(this._defaultAttributes);
-    this.updateTextInfo();
     this.setupMeasureFunc();
+    this.updateTextInfo();
   }
   get content() {
     return this._text;
@@ -9408,9 +9785,9 @@ class TextRenderable extends Renderable {
     }
   }
   syncSelectionToTextBuffer() {
-    const selection = this.selectionHelper.getSelection();
-    if (selection) {
-      this.textBuffer.setSelection(selection.start, selection.end, this._selectionBg, this._selectionFg);
+    const selection2 = this.selectionHelper.getSelection();
+    if (selection2) {
+      this.textBuffer.setSelection(selection2.start, selection2.end, this._selectionBg, this._selectionFg);
     } else {
       this.textBuffer.resetSelection();
     }
@@ -9422,12 +9799,14 @@ class TextRenderable extends Renderable {
     this._lineInfo.lineStarts = lineInfo.lineStarts;
     this._lineInfo.lineWidths = lineInfo.lineWidths;
     const numLines = this._lineInfo.lineStarts.length;
-    if (this._height === "auto") {
-      this.height = numLines;
+    if (this._positionType === "absolute" && this._height === "auto") {
+      this._heightValue = numLines;
+      this.layoutNode.yogaNode.markDirty();
     }
     const maxLineWidth = Math.max(...this._lineInfo.lineWidths);
     if (this._positionType === "absolute" && this._width === "auto") {
-      this.width = maxLineWidth;
+      this._widthValue = maxLineWidth;
+      this.layoutNode.yogaNode.markDirty();
     }
     const changed = this.selectionHelper.reevaluateSelection(this.width, this.height);
     if (changed) {
@@ -9436,35 +9815,33 @@ class TextRenderable extends Renderable {
     this.needsUpdate();
   }
   setupMeasureFunc() {
-    if (this._positionType === "relative" && this._width === "auto") {
-      const measureFunc = (width, widthMode, height, heightMode) => {
-        const maxLineWidth = Math.max(...this._lineInfo.lineWidths, 0);
-        const numLines = this._lineInfo.lineStarts.length || 1;
-        let measuredWidth = maxLineWidth;
-        let measuredHeight = numLines;
-        if (widthMode === MeasureMode.Exactly) {
-          measuredWidth = width;
-        } else if (widthMode === MeasureMode.AtMost) {
-          measuredWidth = Math.min(maxLineWidth, width);
-        }
-        if (heightMode === MeasureMode.Exactly) {
-          measuredHeight = height;
-        } else if (heightMode === MeasureMode.AtMost) {
-          measuredHeight = Math.min(numLines, height);
-        }
-        return {
-          width: Math.max(1, measuredWidth),
-          height: Math.max(1, measuredHeight)
-        };
+    const measureFunc = (width, widthMode, height, heightMode) => {
+      const maxLineWidth = Math.max(...this._lineInfo.lineWidths, 0);
+      const numLines = this._lineInfo.lineStarts.length || 1;
+      let measuredWidth = maxLineWidth;
+      let measuredHeight = numLines;
+      if (widthMode === MeasureMode.Exactly) {
+        measuredWidth = width;
+      } else if (widthMode === MeasureMode.AtMost) {
+        measuredWidth = Math.min(maxLineWidth, width);
+      }
+      if (heightMode === MeasureMode.Exactly) {
+        measuredHeight = height;
+      } else if (heightMode === MeasureMode.AtMost) {
+        measuredHeight = Math.min(numLines, height);
+      }
+      return {
+        width: Math.max(1, measuredWidth),
+        height: Math.max(1, measuredHeight)
       };
-      this.layoutNode.yogaNode.setMeasureFunc(measureFunc);
-    }
+    };
+    this.layoutNode.yogaNode.setMeasureFunc(measureFunc);
   }
   shouldStartSelection(x, y) {
     return this.selectionHelper.shouldStartSelection(x, y, this.width, this.height);
   }
-  onSelectionChanged(selection) {
-    const changed = this.selectionHelper.onSelectionChanged(selection, this.width, this.height);
+  onSelectionChanged(selection2) {
+    const changed = this.selectionHelper.onSelectionChanged(selection2, this.width, this.height);
     if (changed) {
       this.syncSelectionToTextBuffer();
       this.needsUpdate();
@@ -9472,10 +9849,10 @@ class TextRenderable extends Renderable {
     return this.selectionHelper.hasSelection();
   }
   getSelectedText() {
-    const selection = this.selectionHelper.getSelection();
-    if (!selection)
+    const selection2 = this.selectionHelper.getSelection();
+    if (!selection2)
       return "";
-    return this._plainText.slice(selection.start, selection.end);
+    return this._plainText.slice(selection2.start, selection2.end);
   }
   hasSelection() {
     return this.selectionHelper.hasSelection();
@@ -9577,8 +9954,8 @@ class ASCIIFontRenderable extends FrameBufferRenderable {
   shouldStartSelection(x, y) {
     return this.selectionHelper.shouldStartSelection(x, y, this.width, this.height);
   }
-  onSelectionChanged(selection) {
-    const changed = this.selectionHelper.onSelectionChanged(selection, this.width, this.height);
+  onSelectionChanged(selection2) {
+    const changed = this.selectionHelper.onSelectionChanged(selection2, this.width, this.height);
     if (changed) {
       this.renderFontToBuffer();
       this.needsUpdate();
@@ -9586,10 +9963,10 @@ class ASCIIFontRenderable extends FrameBufferRenderable {
     return this.selectionHelper.hasSelection();
   }
   getSelectedText() {
-    const selection = this.selectionHelper.getSelection();
-    if (!selection)
+    const selection2 = this.selectionHelper.getSelection();
+    if (!selection2)
       return "";
-    return this._text.slice(selection.start, selection.end);
+    return this._text.slice(selection2.start, selection2.end);
   }
   hasSelection() {
     return this.selectionHelper.hasSelection();
@@ -9608,20 +9985,20 @@ class ASCIIFontRenderable extends FrameBufferRenderable {
       bg: this._bg,
       font: this._font
     });
-    const selection = this.selectionHelper.getSelection();
-    if (selection && (this._selectionBg || this._selectionFg)) {
-      this.renderSelectionHighlight(selection);
+    const selection2 = this.selectionHelper.getSelection();
+    if (selection2 && (this._selectionBg || this._selectionFg)) {
+      this.renderSelectionHighlight(selection2);
     }
   }
-  renderSelectionHighlight(selection) {
+  renderSelectionHighlight(selection2) {
     if (!this._selectionBg && !this._selectionFg)
       return;
-    const selectedText = this._text.slice(selection.start, selection.end);
+    const selectedText = this._text.slice(selection2.start, selection2.end);
     if (!selectedText)
       return;
     const positions = getCharacterPositions(this._text, this._font);
-    const startX = positions[selection.start] || 0;
-    const endX = selection.end < positions.length ? positions[selection.end] : measureText({ text: this._text, font: this._font }).width;
+    const startX = positions[selection2.start] || 0;
+    const endX = selection2.end < positions.length ? positions[selection2.end] : measureText({ text: this._text, font: this._font }).width;
     if (this._selectionBg) {
       this.frameBuffer.fillRect(startX, 0, endX - startX, this.height, this._selectionBg);
     }
@@ -10424,13 +10801,29 @@ export {
   resolveRenderLib,
   renderFontToFrameBuffer,
   red,
+  parseWrap,
+  parseUnit,
+  parsePositionType,
+  parseOverflow,
+  parseMeasureMode,
+  parseLogLevel,
   parseKeypress,
+  parseJustify,
+  parseGutter,
+  parseFlexDirection,
+  parseEdge,
+  parseDisplay,
+  parseDirection,
+  parseDimension,
   parseColor,
+  parseBoxSizing,
+  parseAlign,
   nonAlphanumericKeys,
   measureText,
   magenta,
   italic,
   isSizeType,
+  isPostionTypeType,
   isPositionType,
   isPaddingType,
   isMarginType,
@@ -10504,6 +10897,7 @@ export {
   Renderable,
   RGBA,
   OptimizedBuffer,
+  MouseParser,
   MouseEvent,
   MouseButton,
   LayoutEvents,
@@ -10526,3 +10920,6 @@ export {
   ASCIIFontSelectionHelper,
   ASCIIFontRenderable
 };
+export { __toESM, __commonJS, __export, __require };
+//# debugId=D2D08A0277CDE28864756E2164756E21
+//# sourceMappingURL=index.js.map