1ch 0.1.0

package/dist/index.js

@@ -0,0 +1,3283 @@
+// src/termui/table-tag.ts
+var TABLE_TAG = /* @__PURE__ */ Symbol("tableLine");
+function toTaggedLine(line) {
+  return line;
+}
+function markTableLine(line) {
+  toTaggedLine(line)[TABLE_TAG] = true;
+  return line;
+}
+function isTableLine(line) {
+  return toTaggedLine(line)[TABLE_TAG] === true;
+}
+function preserveTableTag(source, target) {
+  if (toTaggedLine(source)[TABLE_TAG]) toTaggedLine(target)[TABLE_TAG] = true;
+}
+
+// src/termui/base.ts
+function normalizedWidth(width) {
+  if (!Number.isFinite(width)) return 0;
+  return Math.max(0, Math.floor(width));
+}
+
+// src/termui/text.ts
+function pad(s, w, right) {
+  if (s.length >= w) return s.slice(0, w);
+  const space = " ".repeat(w - s.length);
+  return right ? space + s : s + space;
+}
+function hl(n) {
+  return "\u2500".repeat(normalizedWidth(n));
+}
+function bar(val, max, w) {
+  const width = normalizedWidth(w);
+  if (width <= 0) return "";
+  if (!Number.isFinite(max) || max <= 0) return "\u2591".repeat(width);
+  const ratio = Number.isFinite(val) ? val / max : 0;
+  const filled = Math.round(Math.min(1, Math.max(0, ratio)) * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function spark(data, w) {
+  const width = normalizedWidth(w);
+  if (width <= 0 || data.length === 0) return "";
+  const ticks = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  const v = data.slice(-width);
+  const mn = Math.min(...v);
+  const mx = Math.max(...v);
+  const rg = mx - mn || 1;
+  return v.map((x) => ticks[Math.round((x - mn) / rg * 7)]).join("");
+}
+function segLen(seg) {
+  return typeof seg === "string" ? seg.length : seg.text.length;
+}
+function lineLen(line) {
+  let n = 0;
+  for (const seg of line) n += segLen(seg);
+  return n;
+}
+function sliceSeg(seg, end) {
+  if (end <= 0) return null;
+  if (typeof seg === "string") {
+    const text2 = seg.slice(0, end);
+    return text2.length > 0 ? text2 : null;
+  }
+  const text = seg.text.slice(0, end);
+  if (text.length === 0) return null;
+  return { ...seg, text };
+}
+function truncateLine(line, w) {
+  if (w <= 0) return [];
+  const out = [];
+  let remaining = w;
+  for (const seg of line) {
+    if (remaining <= 0) break;
+    const len = segLen(seg);
+    if (len <= remaining) {
+      out.push(seg);
+      remaining -= len;
+      continue;
+    }
+    const clipped = sliceSeg(seg, remaining);
+    if (clipped) out.push(clipped);
+    remaining = 0;
+  }
+  return out;
+}
+function padLine(line, w) {
+  if (w <= 0) return [];
+  const used = lineLen(line);
+  if (used > w) return truncateLine(line, w);
+  if (used === w) return line;
+  return [...line, { text: " ".repeat(w - used), noSelect: true }];
+}
+function wrapText(text, w) {
+  if (w <= 0) return [""];
+  if (text.length <= w) return [text];
+  const result = [];
+  let pos = 0;
+  while (pos < text.length) {
+    if (pos + w >= text.length) {
+      result.push(text.slice(pos));
+      break;
+    }
+    let breakAt = text.lastIndexOf(" ", pos + w);
+    if (breakAt <= pos) {
+      result.push(text.slice(pos, pos + w));
+      pos += w;
+    } else {
+      result.push(text.slice(pos, breakAt));
+      pos = breakAt + 1;
+    }
+  }
+  return result.length > 0 ? result : [""];
+}
+
+// src/termui/layout.ts
+function borderTop(w, title, color) {
+  const width = normalizedWidth(w);
+  if (width <= 0) return [];
+  if (width === 1) return [{ text: "\u250C", color, noSelect: true }];
+  if (title) {
+    const maxTitle = Math.max(0, width - 6);
+    const safeTitle = title.length > maxTitle ? title.slice(0, maxTitle) : title;
+    const titleStr = "\u2500 " + safeTitle + " ";
+    const remaining = Math.max(0, width - 2 - titleStr.length);
+    return [
+      { text: "\u250C" + titleStr + hl(remaining) + "\u2510", color, noSelect: true }
+    ];
+  }
+  return [{ text: "\u250C" + hl(width - 2) + "\u2510", color, noSelect: true }];
+}
+function borderBottom(w, color) {
+  const width = normalizedWidth(w);
+  if (width <= 0) return [];
+  if (width === 1) return [{ text: "\u2514", color, noSelect: true }];
+  return [{ text: "\u2514" + hl(width - 2) + "\u2518", color, noSelect: true }];
+}
+function lines(content) {
+  return (w) => {
+    const ls = typeof content === "function" ? content(w) : content;
+    return ls.map((line) => padLine(line, w));
+  };
+}
+function box(content, opts) {
+  return (w) => {
+    const width = normalizedWidth(w);
+    if (width < 2) return content(width);
+    const bc = opts?.borderColor;
+    const inner = width - 2;
+    const contentBlock = content(inner);
+    const result = [];
+    result.push(borderTop(width, opts?.title, bc));
+    for (const line of contentBlock) {
+      result.push([
+        { text: "\u2502", color: bc, noSelect: true },
+        ...padLine(line, inner),
+        { text: "\u2502", color: bc, noSelect: true }
+      ]);
+    }
+    result.push(borderBottom(width, bc));
+    return result;
+  };
+}
+function hstack(children, opts) {
+  return (w) => {
+    const width = normalizedWidth(w);
+    const n = children.length;
+    if (n === 0) return [];
+    const gap = normalizedWidth(opts?.gap ?? 1);
+    const totalGap = gap * (n - 1);
+    let childWidths;
+    if (opts?.widths && opts.widths.length === n) {
+      childWidths = opts.widths.map((cw) => normalizedWidth(cw));
+    } else {
+      const available = Math.max(0, width - totalGap);
+      const base = Math.floor(available / n);
+      const remainder = available - base * n;
+      childWidths = children.map((_, i) => base + (i < remainder ? 1 : 0));
+    }
+    const blocks = children.map((child, i) => child(childWidths[i]));
+    const maxLines = Math.max(...blocks.map((b) => b.length));
+    const gapStr = gap > 0 ? " ".repeat(gap) : "";
+    const result = [];
+    for (let i = 0; i < maxLines; i++) {
+      const line = [];
+      for (let j = 0; j < blocks.length; j++) {
+        if (j > 0 && gapStr) line.push(gapStr);
+        const childLine = blocks[j][i];
+        if (childLine) {
+          line.push(...padLine(childLine, childWidths[j]));
+        } else {
+          line.push(" ".repeat(childWidths[j]));
+        }
+      }
+      result.push(line);
+    }
+    return result;
+  };
+}
+function vstack(...children) {
+  return (w) => {
+    const result = [];
+    for (const child of children) {
+      result.push(...child(w));
+    }
+    return result;
+  };
+}
+function separator(color) {
+  return (w) => [[{ text: hl(w), color, noSelect: true }]];
+}
+function blank() {
+  return (w) => [[" ".repeat(normalizedWidth(w))]];
+}
+
+// src/termui/table.ts
+function tableSep(ws, l, m, r, color) {
+  const line = [{ text: l, color, noSelect: true }];
+  for (let i = 0; i < ws.length; i++) {
+    line.push({ text: hl(ws[i]), color, noSelect: true, cell: i });
+    line.push({ text: i < ws.length - 1 ? m : r, color, noSelect: true });
+  }
+  return line;
+}
+function tableTop(ws, color) {
+  return tableSep(ws, "\u250C", "\u252C", "\u2510", color);
+}
+function tableMid(ws, color) {
+  return tableSep(ws, "\u251C", "\u253C", "\u2524", color);
+}
+function tableBot(ws, color) {
+  return tableSep(ws, "\u2514", "\u2534", "\u2518", color);
+}
+function table(columns, data, opts) {
+  return (w) => {
+    const bc = opts?.borderColor;
+    const hc = opts?.headerColor;
+    const cp = normalizedWidth(opts?.cellPadding ?? 1);
+    const nSep = columns.length + 1;
+    const minColWidth = 1;
+    const widthBudget = Math.max(0, normalizedWidth(w) - nSep);
+    const padStr = " ".repeat(cp);
+    const ws = columns.map((col) => {
+      if (col.width) return Math.max(minColWidth, col.width);
+      const displayTitle = col.title ?? col.key;
+      const titleW = displayTitle.length + 2 * cp;
+      const dataW = Math.max(
+        ...data.map((row) => String(row[col.key] ?? "").length + 2 * cp),
+        0
+      );
+      return Math.max(minColWidth, titleW, dataW);
+    });
+    if (opts?.fillWidth && widthBudget > 0) {
+      const used = ws.reduce((a, b) => a + b, 0);
+      const remaining = widthBudget - used;
+      if (remaining > 0 && ws.length > 0) {
+        const even = Math.floor(remaining / ws.length);
+        const rem = remaining % ws.length;
+        for (let i = 0; i < ws.length; i++) {
+          ws[i] = ws[i] + even + (i < rem ? 1 : 0);
+        }
+      }
+    }
+    if (widthBudget > 0) {
+      let used = ws.reduce((a, b) => a + b, 0);
+      let overflow = used - widthBudget;
+      while (overflow > 0) {
+        let idx = -1;
+        let widest = 0;
+        for (let i = 0; i < ws.length; i++) {
+          if (ws[i] > minColWidth && ws[i] > widest) {
+            widest = ws[i];
+            idx = i;
+          }
+        }
+        if (idx === -1) break;
+        ws[idx] = ws[idx] - 1;
+        overflow -= 1;
+      }
+    }
+    const result = [];
+    result.push(tableTop(ws, bc));
+    const headerLine = [{ text: "\u2502", color: bc, noSelect: true }];
+    for (let i = 0; i < columns.length; i++) {
+      const col = columns[i];
+      const displayTitle = col.title ?? col.key;
+      const innerW = Math.max(0, ws[i] - 2 * cp);
+      const text = padStr + pad(displayTitle, innerW, col.align === "right") + padStr;
+      headerLine.push({
+        text,
+        color: col.headerColor ?? hc,
+        bold: col.headerBold ?? true,
+        cell: i
+      });
+      headerLine.push({ text: "\u2502", color: bc, noSelect: true });
+    }
+    result.push(headerLine);
+    result.push(tableMid(ws, bc));
+    for (const row of data) {
+      const wrapped = columns.map((col, ci) => {
+        const val = String(row[col.key] ?? "");
+        const innerW = Math.max(1, ws[ci] - 2 * cp);
+        return wrapText(val, innerW);
+      });
+      const rowHeight = Math.max(...wrapped.map((c) => c.length), 1);
+      for (let ln = 0; ln < rowHeight; ln++) {
+        const dataLine = [{ text: "\u2502", color: bc, noSelect: true }];
+        for (let i = 0; i < columns.length; i++) {
+          const col = columns[i];
+          const cellLine = wrapped[i][ln] ?? "";
+          const innerW = Math.max(0, ws[i] - 2 * cp);
+          const text = padStr + pad(cellLine, innerW, col.align === "right") + padStr;
+          const color = typeof col.color === "function" ? col.color(row[col.key], row) : col.color;
+          const dim = typeof col.dim === "function" ? col.dim(row[col.key], row) : col.dim;
+          dataLine.push({ text, color: color || void 0, dim: dim || void 0, cell: i });
+          dataLine.push({ text: "\u2502", color: bc, noSelect: true });
+        }
+        result.push(dataLine);
+      }
+    }
+    result.push(tableBot(ws, bc));
+    for (const line of result) markTableLine(line);
+    return result;
+  };
+}
+
+// src/termui/widgets.ts
+function statusbar(left, right, opts) {
+  return (w) => {
+    const rightLen = right.reduce(
+      (acc, s) => acc + (typeof s === "string" ? s.length : s.text.length),
+      0
+    );
+    const leftWidth = Math.max(0, w - rightLen);
+    const paddedLeft = padLine(left, leftWidth);
+    const theme = opts?.theme;
+    const bg = opts?.bg ?? theme?.components.statusbar.bg;
+    const color = opts?.color ?? theme?.components.statusbar.fg;
+    const line = [...paddedLeft, ...right].map((seg) => {
+      if (typeof seg === "string") {
+        return bg || color ? { text: seg, bg, color } : seg;
+      }
+      return { ...seg, bg: seg.bg ?? bg, color: seg.color ?? color };
+    });
+    return [padLine(line, w)];
+  };
+}
+function tabs(names, active, opts) {
+  return (w) => {
+    const line = [];
+    const onSelect = opts?.onSelect;
+    const t = opts?.theme;
+    for (let i = 0; i < names.length; i++) {
+      const isActive = i === active;
+      const name = names[i];
+      const label = " " + (isActive ? name.toUpperCase() : name) + " ";
+      const onClick = opts?.onClicks?.[i] ?? (onSelect ? () => onSelect(i) : void 0);
+      if (isActive) {
+        line.push({
+          text: label,
+          color: opts?.activeColor ?? t?.components.tabs.activeFg,
+          bg: opts?.activeBg ?? t?.components.tabs.activeBg,
+          onClick
+        });
+      } else {
+        line.push({
+          text: label,
+          color: opts?.inactiveColor ?? t?.components.tabs.inactiveFg,
+          onClick
+        });
+      }
+      if (i < names.length - 1) {
+        line.push({ text: "\u2502", color: opts?.separatorColor ?? t?.components.tabs.separator, noSelect: true });
+      }
+    }
+    return [padLine(line, w)];
+  };
+}
+function badge(label, opts) {
+  const t = opts?.theme;
+  return {
+    text: label,
+    color: opts?.color ?? t?.components.badge.fg,
+    bg: opts?.bg ?? t?.components.badge.bg,
+    onClick: opts?.onClick
+  };
+}
+
+// src/termui/json.ts
+function fromJsonNode(node) {
+  switch (node.type) {
+    case "vstack":
+      return vstack(...node.children.map(fromJsonNode));
+    case "hstack":
+      return hstack(node.children.map(fromJsonNode), {
+        gap: node.gap,
+        widths: node.widths
+      });
+    case "box":
+      return box(vstack(...node.children.map(fromJsonNode)), {
+        title: node.title,
+        borderColor: node.borderColor
+      });
+    case "lines":
+      return lines(node.content);
+    case "separator":
+      return separator(node.color);
+    case "blank":
+      return blank();
+    case "table":
+      return table(node.columns, node.data, {
+        borderColor: node.borderColor,
+        fillWidth: node.fillWidth
+      });
+    case "statusbar":
+      return statusbar(node.left, node.right, {
+        bg: node.bg,
+        color: node.color
+      });
+    case "tabs":
+      return tabs(node.names, node.active, {
+        activeColor: node.activeColor,
+        activeBg: node.activeBg,
+        inactiveColor: node.inactiveColor,
+        separatorColor: node.separatorColor
+      });
+    case "bar":
+      return (w) => {
+        const labelStr = node.label ? " " + node.label : "";
+        const barW = Math.max(0, w - 1 - labelStr.length);
+        return [[" ", { text: bar(node.value, node.max, barW), color: node.color }, labelStr]];
+      };
+    case "text":
+      return lines([node.segments]);
+  }
+}
+
+// src/termui/tree-list.ts
+function tree(data, opts) {
+  return (w) => {
+    const result = [];
+    function walk(nodes, prefix) {
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const last = i === nodes.length - 1;
+        const hasKids = node.children && node.children.length > 0;
+        const connector = last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const line = [];
+        if (prefix) line.push({ text: prefix, color: opts?.branchColor ?? opts?.color, noSelect: true });
+        line.push({ text: connector, color: opts?.branchColor ?? opts?.color, noSelect: true });
+        line.push({ text: node.label, color: hasKids ? opts?.color : opts?.leafColor ?? opts?.color });
+        result.push(padLine(line, w));
+        if (hasKids) {
+          walk(node.children, prefix + (last ? "    " : "\u2502   "));
+        }
+      }
+    }
+    walk(data, "");
+    return result;
+  };
+}
+function list(items, opts) {
+  return (w) => {
+    const result = [];
+    const ordered = opts?.ordered ?? false;
+    const digits = String(items.length).length;
+    for (let i = 0; i < items.length; i++) {
+      const prefix = ordered ? ` ${String(i + 1).padStart(digits, " ")}. ` : " * ";
+      const indent = " ".repeat(prefix.length);
+      const wrapped = wrapText(items[i], w - prefix.length);
+      for (let j = 0; j < wrapped.length; j++) {
+        const line = [];
+        if (j === 0) {
+          line.push({ text: prefix, color: opts?.bulletColor });
+        } else {
+          line.push(indent);
+        }
+        line.push(opts?.color ? { text: wrapped[j], color: opts.color } : wrapped[j]);
+        result.push(padLine(line, w));
+      }
+    }
+    return result;
+  };
+}
+
+// src/tokenize.ts
+function rules(pairs) {
+  return pairs.map(([pattern, type]) => ({
+    pattern: new RegExp(pattern.source, "y"),
+    type
+  }));
+}
+var JS_RULES = rules([
+  [/\/\/.*/, "comment"],
+  [/\/\*[\s\S]*?\*\//, "comment"],
+  [/"(?:[^"\\]|\\.)*"/, "string"],
+  [/'(?:[^'\\]|\\.)*'/, "string"],
+  [/`(?:[^`\\]|\\.)*`/, "string"],
+  [/\b(?:const|let|var|function|return|if|else|for|while|do|class|import|export|from|async|await|new|throw|try|catch|finally|typeof|instanceof|in|of|void|delete|switch|case|break|continue|default|yield|extends|implements|interface|type|as|this|super|null|undefined|true|false)\b/, "keyword"],
+  [/\b\d[\d_.]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?\b/, "number"],
+  [/\b[A-Z][a-zA-Z0-9]*\b/, "type"],
+  [/\b[a-zA-Z_$][\w$]*(?=\s*\()/, "function"],
+  [/=>/, "punctuation"],
+  [/[{}()\[\];:.,<>=!+\-*/%&|?@^~]/, "punctuation"]
+]);
+var JSON_RULES = rules([
+  [/"(?:[^"\\]|\\.)*"(?=\s*:)/, "function"],
+  [/"(?:[^"\\]|\\.)*"/, "string"],
+  [/\b(?:true|false|null)\b/, "keyword"],
+  [/-?\b\d[\d_.]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?\b/, "number"],
+  [/[{}\[\]:,]/, "punctuation"]
+]);
+var BASH_RULES = rules([
+  [/#.*/, "comment"],
+  [/"(?:[^"\\]|\\.)*"/, "string"],
+  [/'[^']*'/, "string"],
+  [/\$\{[^}]*\}/, "type"],
+  [/\$[A-Za-z_]\w*/, "type"],
+  [/\b(?:if|then|else|elif|fi|for|do|done|while|until|case|esac|function|in|return|exit|echo|export|local|readonly|source|alias|cd|ls|rm|cp|mv|mkdir|grep|sed|awk|cat|chmod|chown|sudo|apt|brew|npm|npx|bun|yarn|git|docker|curl|wget|pipe)\b/, "keyword"],
+  [/\b\d+\b/, "number"],
+  [/[|;&<>()\[\]{}]/, "punctuation"]
+]);
+var GENERIC_RULES = rules([
+  [/\/\/.*/, "comment"],
+  [/#.*/, "comment"],
+  [/"(?:[^"\\]|\\.)*"/, "string"],
+  [/'(?:[^'\\]|\\.)*'/, "string"],
+  [/\b\d[\d_.]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?\b/, "number"],
+  [/\b[A-Z][a-zA-Z0-9]*\b/, "type"],
+  [/[{}()\[\];:.,<>=!+\-*/%&|?@^~]/, "punctuation"]
+]);
+function rulesFor(lang) {
+  if (!lang) return GENERIC_RULES;
+  const l = lang.toLowerCase();
+  if (l === "json" || l === "jsonc") return JSON_RULES;
+  if (l === "bash" || l === "sh" || l === "zsh" || l === "shell") return BASH_RULES;
+  if (l === "js" || l === "jsx" || l === "ts" || l === "tsx" || l === "javascript" || l === "typescript") return JS_RULES;
+  return GENERIC_RULES;
+}
+function tokenizeLine(line, langRules) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < line.length) {
+    if (line[pos] === " " || line[pos] === "	") {
+      let ws = pos;
+      while (ws < line.length && (line[ws] === " " || line[ws] === "	")) ws++;
+      tokens.push({ text: line.slice(pos, ws), type: "default" });
+      pos = ws;
+      continue;
+    }
+    let matched = false;
+    for (const rule of langRules) {
+      rule.pattern.lastIndex = pos;
+      const m = rule.pattern.exec(line);
+      if (m && m.index === pos) {
+        tokens.push({ text: m[0], type: rule.type });
+        pos += m[0].length;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      const start = pos;
+      pos++;
+      while (pos < line.length && line[pos] !== " " && line[pos] !== "	") {
+        let anyMatch = false;
+        for (const rule of langRules) {
+          rule.pattern.lastIndex = pos;
+          const m = rule.pattern.exec(line);
+          if (m && m.index === pos) {
+            anyMatch = true;
+            break;
+          }
+        }
+        if (anyMatch) break;
+        pos++;
+      }
+      tokens.push({ text: line.slice(start, pos), type: "default" });
+    }
+  }
+  return tokens;
+}
+function tokenize(source, language) {
+  const langRules = rulesFor(language);
+  return source.split("\n").map((line) => tokenizeLine(line, langRules));
+}
+
+// src/theme.ts
+var DARK_PALETTE = {
+  black: "#0c0c0c",
+  red: "#e06c75",
+  green: "#98c379",
+  yellow: "#e5c07b",
+  blue: "#61afef",
+  magenta: "#c678dd",
+  cyan: "#56b6c2",
+  white: "#cccccc",
+  brightBlack: "#555555",
+  brightWhite: "#ffffff"
+};
+var DARK_SEMANTIC = {
+  frameBg: "#0c0c0c",
+  frameFg: "#cccccc",
+  frameMuted: "#555555",
+  border: "#555555",
+  borderStrong: "#808080",
+  inverseFg: "#0c0c0c",
+  inverseBg: "#ffffff",
+  info: "#56b6c2",
+  success: "#98c379",
+  warn: "#e5c07b",
+  danger: "#e06c75"
+};
+var DARK_SYNTAX = {
+  default: "#ffffff",
+  keyword: "#c678dd",
+  string: "#98c379",
+  number: "#e5c07b",
+  comment: "#555555",
+  punctuation: "#555555",
+  function: "#61afef",
+  type: "#56b6c2"
+};
+var DARK_MARKDOWN = {
+  headingMarker: "#555555",
+  headingBoldMaxLevel: 3,
+  headings: {
+    h1: "#e5c07b",
+    h2: "#56b6c2",
+    h3: "#98c379",
+    h4: "#c678dd",
+    h5: "#cccccc",
+    h6: "#cccccc"
+  },
+  paragraph: "#cccccc",
+  unorderedBullet: "#56b6c2",
+  orderedMarker: "#56b6c2",
+  tableHeader: "#56b6c2",
+  tableBorder: "#555555",
+  quoteMarker: "#555555",
+  quoteText: "#555555",
+  separator: "#555555",
+  codeText: "#ffffff",
+  codeEmpty: "#555555",
+  codeBorder: "#555555"
+};
+var DARK_COMPONENTS = {
+  tabs: {
+    activeFg: "#0c0c0c",
+    activeBg: "#e5c07b",
+    inactiveFg: "#555555",
+    separator: "#555555"
+  },
+  statusbar: {
+    fg: "#0c0c0c",
+    bg: "#98c379"
+  },
+  badge: {
+    fg: "#0c0c0c",
+    bg: "#ffffff"
+  },
+  button: {
+    fg: "#0c0c0c",
+    bg: "#ffffff"
+  }
+};
+var LIGHT_PALETTE = {
+  black: "#1f2328",
+  red: "#cf222e",
+  green: "#1a7f37",
+  yellow: "#9a6700",
+  blue: "#0969da",
+  magenta: "#8250df",
+  cyan: "#1b7c83",
+  white: "#30363d",
+  brightBlack: "#6e7781",
+  brightWhite: "#0f172a"
+};
+var LIGHT_SEMANTIC = {
+  frameBg: "#f6f8fa",
+  frameFg: "#1f2328",
+  frameMuted: "#6e7781",
+  border: "#d0d7de",
+  borderStrong: "#8c959f",
+  inverseFg: "#f6f8fa",
+  inverseBg: "#0f172a",
+  info: "#0969da",
+  success: "#1a7f37",
+  warn: "#9a6700",
+  danger: "#cf222e"
+};
+var LIGHT_SYNTAX = {
+  default: "#1f2328",
+  keyword: "#8250df",
+  string: "#116329",
+  number: "#9a6700",
+  comment: "#6e7781",
+  punctuation: "#6e7781",
+  function: "#0969da",
+  type: "#1b7c83"
+};
+var LIGHT_MARKDOWN = {
+  headingMarker: "#6e7781",
+  headingBoldMaxLevel: 3,
+  headings: {
+    h1: "#9a6700",
+    h2: "#0969da",
+    h3: "#1a7f37",
+    h4: "#8250df",
+    h5: "#1f2328",
+    h6: "#1f2328"
+  },
+  paragraph: "#1f2328",
+  unorderedBullet: "#0969da",
+  orderedMarker: "#0969da",
+  tableHeader: "#0969da",
+  tableBorder: "#d0d7de",
+  quoteMarker: "#6e7781",
+  quoteText: "#6e7781",
+  separator: "#d0d7de",
+  codeText: "#1f2328",
+  codeEmpty: "#6e7781",
+  codeBorder: "#d0d7de"
+};
+var LIGHT_COMPONENTS = {
+  tabs: {
+    activeFg: "#f6f8fa",
+    activeBg: "#0969da",
+    inactiveFg: "#6e7781",
+    separator: "#8c959f"
+  },
+  statusbar: {
+    fg: "#f6f8fa",
+    bg: "#0969da"
+  },
+  badge: {
+    fg: "#f6f8fa",
+    bg: "#0f172a"
+  },
+  button: {
+    fg: "#f6f8fa",
+    bg: "#0f172a"
+  }
+};
+var defaultThemeSpec = {
+  id: "termui-default",
+  label: "TermUI Default",
+  version: 1,
+  modes: {
+    dark: {
+      palette: DARK_PALETTE,
+      semantic: DARK_SEMANTIC,
+      syntax: DARK_SYNTAX,
+      markdown: DARK_MARKDOWN,
+      components: DARK_COMPONENTS
+    },
+    light: {
+      palette: LIGHT_PALETTE,
+      semantic: LIGHT_SEMANTIC,
+      syntax: LIGHT_SYNTAX,
+      markdown: LIGHT_MARKDOWN,
+      components: LIGHT_COMPONENTS
+    }
+  }
+};
+var builtinThemes = {
+  default: defaultThemeSpec
+};
+function resolveThemeMode(preference, systemMode = "dark") {
+  return preference === "system" ? systemMode : preference;
+}
+function resolveTheme(spec, preference = "dark", opts) {
+  const mode = resolveThemeMode(preference, opts?.systemMode ?? "dark");
+  const modeTokens = spec.modes[mode] ?? defaultThemeSpec.modes[mode];
+  return {
+    id: spec.id,
+    label: spec.label,
+    version: spec.version,
+    mode,
+    palette: modeTokens.palette,
+    semantic: modeTokens.semantic,
+    syntax: modeTokens.syntax,
+    markdown: modeTokens.markdown,
+    components: modeTokens.components,
+    black: modeTokens.palette.black,
+    red: modeTokens.palette.red,
+    green: modeTokens.palette.green,
+    yellow: modeTokens.palette.yellow,
+    blue: modeTokens.palette.blue,
+    magenta: modeTokens.palette.magenta,
+    cyan: modeTokens.palette.cyan,
+    white: modeTokens.palette.white,
+    brightBlack: modeTokens.palette.brightBlack,
+    brightWhite: modeTokens.palette.brightWhite,
+    border: modeTokens.semantic.border,
+    bg: modeTokens.semantic.frameBg
+  };
+}
+var dark = resolveTheme(defaultThemeSpec, "dark");
+var light = resolveTheme(defaultThemeSpec, "light");
+function themeToCssVars(theme) {
+  return {
+    "--termui-bg": theme.semantic.frameBg,
+    "--termui-fg": theme.semantic.frameFg,
+    "--termui-muted": theme.semantic.frameMuted,
+    "--termui-border": theme.semantic.border,
+    "--termui-border-strong": theme.semantic.borderStrong,
+    "--termui-info": theme.semantic.info,
+    "--termui-success": theme.semantic.success,
+    "--termui-warn": theme.semantic.warn,
+    "--termui-danger": theme.semantic.danger,
+    "--termui-inverse-fg": theme.semantic.inverseFg,
+    "--termui-inverse-bg": theme.semantic.inverseBg
+  };
+}
+function parseThemeSpec(json) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch (error) {
+    return {
+      ok: false,
+      issues: [{ path: "$", message: error instanceof Error ? error.message : "Invalid JSON" }]
+    };
+  }
+  return validateThemeSpec(value);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function issue(path, message) {
+  return { path, message };
+}
+function isColorValue(value) {
+  const v = value.trim();
+  if (!v) return false;
+  if (/^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(v)) return true;
+  if (/^(?:rgb|rgba|hsl|hsla|oklch|oklab|lab|lch|color)\(.+\)$/i.test(v)) return true;
+  if (/^var\(--[a-zA-Z0-9-_]+\)$/.test(v)) return true;
+  if (/^[a-zA-Z]+$/.test(v)) return true;
+  return false;
+}
+function validateColorField(value, path, issues) {
+  if (typeof value !== "string") {
+    issues.push(issue(path, "Expected a string color value"));
+    return;
+  }
+  if (!isColorValue(value)) {
+    issues.push(issue(path, "Invalid CSS color value"));
+  }
+}
+function validateHeadingBoldMaxLevel(value, path, issues) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    issues.push(issue(path, "Expected an integer between 1 and 6"));
+    return;
+  }
+  if (value < 1 || value > 6) {
+    issues.push(issue(path, "Expected an integer between 1 and 6"));
+  }
+}
+function validateTokenGroup(value, path, fields, issues) {
+  if (!isRecord(value)) {
+    issues.push(issue(path, "Expected an object"));
+    return;
+  }
+  for (const field of fields) {
+    validateColorField(value[field], `${path}.${field}`, issues);
+  }
+}
+function validateMarkdownTokens(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push(issue(path, "Expected an object"));
+    return;
+  }
+  validateColorField(value.headingMarker, `${path}.headingMarker`, issues);
+  validateHeadingBoldMaxLevel(value.headingBoldMaxLevel, `${path}.headingBoldMaxLevel`, issues);
+  if (!isRecord(value.headings)) {
+    issues.push(issue(`${path}.headings`, "Expected an object"));
+  } else {
+    for (const level of ["h1", "h2", "h3", "h4", "h5", "h6"]) {
+      validateColorField(value.headings[level], `${path}.headings.${level}`, issues);
+    }
+  }
+  for (const field of [
+    "paragraph",
+    "unorderedBullet",
+    "orderedMarker",
+    "tableHeader",
+    "tableBorder",
+    "quoteMarker",
+    "quoteText",
+    "separator",
+    "codeText",
+    "codeEmpty",
+    "codeBorder"
+  ]) {
+    validateColorField(value[field], `${path}.${field}`, issues);
+  }
+}
+function validateComponentTokens(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push(issue(path, "Expected an object"));
+    return;
+  }
+  validateTokenGroup(
+    value.tabs,
+    `${path}.tabs`,
+    ["activeFg", "activeBg", "inactiveFg", "separator"],
+    issues
+  );
+  validateTokenGroup(value.statusbar, `${path}.statusbar`, ["fg", "bg"], issues);
+  validateTokenGroup(value.badge, `${path}.badge`, ["fg", "bg"], issues);
+  validateTokenGroup(value.button, `${path}.button`, ["fg", "bg"], issues);
+}
+function validateModeTokens(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push(issue(path, "Expected an object"));
+    return;
+  }
+  validateTokenGroup(
+    value.palette,
+    `${path}.palette`,
+    [
+      "black",
+      "red",
+      "green",
+      "yellow",
+      "blue",
+      "magenta",
+      "cyan",
+      "white",
+      "brightBlack",
+      "brightWhite"
+    ],
+    issues
+  );
+  validateTokenGroup(
+    value.semantic,
+    `${path}.semantic`,
+    [
+      "frameBg",
+      "frameFg",
+      "frameMuted",
+      "border",
+      "borderStrong",
+      "inverseFg",
+      "inverseBg",
+      "info",
+      "success",
+      "warn",
+      "danger"
+    ],
+    issues
+  );
+  validateTokenGroup(
+    value.syntax,
+    `${path}.syntax`,
+    [
+      "default",
+      "keyword",
+      "string",
+      "number",
+      "comment",
+      "punctuation",
+      "function",
+      "type"
+    ],
+    issues
+  );
+  validateMarkdownTokens(value.markdown, `${path}.markdown`, issues);
+  validateComponentTokens(value.components, `${path}.components`, issues);
+}
+function validateThemeSpec(value) {
+  const issues = [];
+  if (!isRecord(value)) {
+    return { ok: false, issues: [issue("$", "Expected an object")] };
+  }
+  if (typeof value.id !== "string" || !value.id.trim()) {
+    issues.push(issue("$.id", "Expected a non-empty string"));
+  }
+  if (typeof value.label !== "string" || !value.label.trim()) {
+    issues.push(issue("$.label", "Expected a non-empty string"));
+  }
+  if (typeof value.version !== "number" || !Number.isInteger(value.version) || value.version < 1) {
+    issues.push(issue("$.version", "Expected a positive integer"));
+  }
+  if (!isRecord(value.modes)) {
+    issues.push(issue("$.modes", "Expected an object with light/dark modes"));
+  } else {
+    validateModeTokens(value.modes.dark, "$.modes.dark", issues);
+    validateModeTokens(value.modes.light, "$.modes.light", issues);
+  }
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  return {
+    ok: true,
+    issues: [],
+    theme: value
+  };
+}
+
+// src/termui/code-diff.ts
+function tokenColor(type, theme) {
+  switch (type) {
+    case "keyword":
+      return theme.syntax.keyword;
+    case "string":
+      return theme.syntax.string;
+    case "number":
+      return theme.syntax.number;
+    case "comment":
+      return theme.syntax.comment;
+    case "punctuation":
+      return theme.syntax.punctuation;
+    case "function":
+      return theme.syntax.function;
+    case "type":
+      return theme.syntax.type;
+    default:
+      return theme.syntax.default;
+  }
+}
+function code(source, opts) {
+  const t = opts?.theme ?? dark;
+  const tokens = tokenize(source, opts?.language);
+  return box(
+    lines(
+      tokens.length > 0 ? tokens.map(
+        (lineTokens) => lineTokens.length === 0 ? [{ text: " ", color: t.markdown.codeEmpty }] : lineTokens.map((tok) => ({ text: tok.text, color: tokenColor(tok.type, t) }))
+      ) : [[{ text: " ", color: t.markdown.codeEmpty, dim: true }]]
+    ),
+    {
+      title: opts?.title ?? (opts?.language ? `code:${opts.language}` : "code"),
+      borderColor: opts?.borderColor ?? t.markdown.codeBorder
+    }
+  );
+}
+function diff(value, opts) {
+  const t = opts?.theme ?? dark;
+  const addC = opts?.addColor ?? t.semantic.success;
+  const remC = opts?.removeColor ?? t.semantic.danger;
+  const metC = opts?.metaColor ?? t.semantic.info;
+  return lines((_) => {
+    return value.replace(/\r\n/g, "\n").split("\n").map((row) => {
+      if (row.startsWith("@@")) return [{ text: row, color: metC }];
+      if (row.startsWith("+")) return [{ text: row, color: addC }];
+      if (row.startsWith("-")) return [{ text: row, color: remC }];
+      return [{ text: row, dim: true }];
+    });
+  });
+}
+
+// src/document/common.ts
+function headingLevelKey(level) {
+  if (level <= 1) return "h1";
+  if (level === 2) return "h2";
+  if (level === 3) return "h3";
+  if (level === 4) return "h4";
+  if (level === 5) return "h5";
+  return "h6";
+}
+function headingColor(level, theme, overrides) {
+  const key = headingLevelKey(level);
+  return overrides?.headings?.[key] ?? theme.markdown.headings[key];
+}
+function isNumericValue(value) {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  return /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed);
+}
+function wrapText2(text, maxWidth) {
+  const width = Math.max(1, maxWidth);
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return [""];
+  const linesOut = [];
+  let rest = normalized;
+  while (rest.length > width) {
+    const slice = rest.slice(0, width + 1);
+    const splitAt = slice.lastIndexOf(" ");
+    const end = splitAt > 0 ? splitAt : width;
+    linesOut.push(rest.slice(0, end).trimEnd());
+    rest = rest.slice(end).trimStart();
+  }
+  linesOut.push(rest);
+  return linesOut;
+}
+function renderPrefixedText(text, width, prefix, continuationPrefix, textStyle) {
+  const prefixText = typeof prefix === "string" ? prefix : prefix.text;
+  const wrapped = wrapText2(text, width - prefixText.length);
+  return wrapped.map((chunk, index) => {
+    if (index === 0) {
+      return [prefix, textStyle ? { text: chunk, ...textStyle } : chunk];
+    }
+    return [continuationPrefix, textStyle ? { text: chunk, ...textStyle } : chunk];
+  });
+}
+function normalizeHtmlText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getValueByPath(source, path) {
+  const parts = path.split(".");
+  let current = source;
+  for (const part of parts) {
+    if (!isRecord2(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function resolveThemeColor(value, theme) {
+  if (!value) return void 0;
+  const raw = value.trim();
+  if (!raw) return void 0;
+  const topLevel = theme[raw];
+  if (typeof topLevel === "string") return topLevel;
+  const nested = getValueByPath(theme, raw);
+  if (typeof nested === "string") return nested;
+  return raw;
+}
+function getColorAttr(el, theme, names) {
+  for (const name of names) {
+    const value = resolveThemeColor(el.getAttribute(name), theme);
+    if (value) return value;
+  }
+  return void 0;
+}
+function parseIntegerAttr(el, name) {
+  const raw = el.getAttribute(name);
+  if (!raw) return void 0;
+  const n = Number.parseInt(raw.trim(), 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseCodeLanguage(el) {
+  const explicit = el.getAttribute("language") ?? el.getAttribute("data-language");
+  if (explicit && explicit.trim()) return explicit.trim();
+  const klass = el.getAttribute("class") ?? "";
+  const match = klass.match(/\blanguage-([\w+-]+)\b/);
+  return match?.[1];
+}
+
+// src/document/markdown.ts
+function isBlockStart(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (/^#{1,6}\s+/.test(trimmed)) return true;
+  if (/^```/.test(trimmed)) return true;
+  if (/^>\s?/.test(trimmed)) return true;
+  if (/^[-*+]\s+/.test(trimmed)) return true;
+  if (/^\d+\.\s+/.test(trimmed)) return true;
+  const collapsed = trimmed.replace(/\s+/g, "");
+  return /^(-{3,}|\*{3,}|_{3,})$/.test(collapsed);
+}
+function parsePipeCells(line) {
+  const trimmed = line.trim();
+  if (!trimmed.includes("|")) return null;
+  let core = trimmed;
+  if (core.startsWith("|")) core = core.slice(1);
+  if (core.endsWith("|")) core = core.slice(0, -1);
+  const cells = core.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 ? cells : null;
+}
+function isTableDividerLine(line) {
+  const cells = parsePipeCells(line);
+  if (!cells) return false;
+  return cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+function parseMarkdown(markdown) {
+  const rows = markdown.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  let i = 0;
+  while (i < rows.length) {
+    const raw = rows[i] ?? "";
+    const trimmed = raw.trim();
+    if (!trimmed) {
+      i += 1;
+      continue;
+    }
+    const codeStart = trimmed.match(/^```([\w+-]+)?\s*$/);
+    if (codeStart) {
+      i += 1;
+      const codeLines = [];
+      while (i < rows.length && !(rows[i] ?? "").trim().startsWith("```")) {
+        codeLines.push((rows[i] ?? "").replace(/\t/g, "  "));
+        i += 1;
+      }
+      if (i < rows.length) i += 1;
+      blocks.push({
+        type: "code",
+        language: codeStart[1],
+        lines: codeLines
+      });
+      continue;
+    }
+    const heading = trimmed.match(/^(#{1,6})\s+(.*)$/);
+    if (heading) {
+      blocks.push({
+        type: "heading",
+        level: heading[1].length,
+        text: heading[2].trim()
+      });
+      i += 1;
+      continue;
+    }
+    const collapsed = trimmed.replace(/\s+/g, "");
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(collapsed)) {
+      blocks.push({ type: "separator" });
+      i += 1;
+      continue;
+    }
+    const maybeHeaderCells = parsePipeCells(raw);
+    const nextLine = rows[i + 1] ?? "";
+    if (maybeHeaderCells && isTableDividerLine(nextLine)) {
+      const headers = maybeHeaderCells;
+      i += 2;
+      const dataRows = [];
+      while (i < rows.length) {
+        const rowCells = parsePipeCells(rows[i] ?? "");
+        if (!rowCells) break;
+        const normalized = headers.map((_, idx) => rowCells[idx] ?? "");
+        dataRows.push(normalized);
+        i += 1;
+      }
+      blocks.push({ type: "table", headers, rows: dataRows });
+      continue;
+    }
+    if (/^>\s?/.test(trimmed)) {
+      const quoteLines = [];
+      while (i < rows.length) {
+        const m = (rows[i] ?? "").match(/^\s*>\s?(.*)$/);
+        if (!m) break;
+        quoteLines.push(m[1]);
+        i += 1;
+      }
+      blocks.push({ type: "quote", lines: quoteLines });
+      continue;
+    }
+    const ulStart = trimmed.match(/^[-*+]\s+(.*)$/);
+    if (ulStart) {
+      const items = [];
+      while (i < rows.length) {
+        const current = (rows[i] ?? "").trim();
+        const item = current.match(/^[-*+]\s+(.*)$/);
+        if (item) {
+          items.push(item[1].trim());
+          i += 1;
+          continue;
+        }
+        const continuation = (rows[i] ?? "").match(/^\s{2,}(.*)$/);
+        if (continuation && items.length > 0) {
+          const last = items[items.length - 1] ?? "";
+          items[items.length - 1] = (last + " " + continuation[1].trim()).trim();
+          i += 1;
+          continue;
+        }
+        break;
+      }
+      blocks.push({ type: "unordered-list", items });
+      continue;
+    }
+    const olStart = trimmed.match(/^(\d+)\.\s+(.*)$/);
+    if (olStart) {
+      const items = [];
+      const start = Number(olStart[1]);
+      while (i < rows.length) {
+        const current = (rows[i] ?? "").trim();
+        const item = current.match(/^\d+\.\s+(.*)$/);
+        if (item) {
+          items.push(item[1].trim());
+          i += 1;
+          continue;
+        }
+        const continuation = (rows[i] ?? "").match(/^\s{2,}(.*)$/);
+        if (continuation && items.length > 0) {
+          const last = items[items.length - 1] ?? "";
+          items[items.length - 1] = (last + " " + continuation[1].trim()).trim();
+          i += 1;
+          continue;
+        }
+        break;
+      }
+      blocks.push({ type: "ordered-list", start, items });
+      continue;
+    }
+    const paragraphRows = [trimmed];
+    i += 1;
+    while (i < rows.length) {
+      const nextRaw = rows[i] ?? "";
+      const next = (rows[i] ?? "").trim();
+      const maybeTableStart = parsePipeCells(nextRaw) !== null && isTableDividerLine(rows[i + 1] ?? "");
+      if (!next || isBlockStart(next) || maybeTableStart) break;
+      paragraphRows.push(next);
+      i += 1;
+    }
+    blocks.push({ type: "paragraph", text: paragraphRows.join(" ") });
+  }
+  return blocks;
+}
+function renderMarkdownBlock(block, theme, overrides) {
+  const md = theme.markdown;
+  switch (block.type) {
+    case "heading":
+      return (w) => renderPrefixedText(
+        block.text,
+        w,
+        {
+          text: "#".repeat(block.level) + " ",
+          color: overrides?.headingMarker ?? md.headingMarker
+        },
+        " ".repeat(block.level + 1),
+        {
+          color: headingColor(block.level, theme, overrides),
+          bold: block.level <= (overrides?.headingBoldMaxLevel ?? md.headingBoldMaxLevel)
+        }
+      );
+    case "paragraph":
+      return (w) => wrapText2(block.text, w).map((line) => [
+        { text: line, color: overrides?.paragraph ?? md.paragraph }
+      ]);
+    case "unordered-list":
+      return (w) => {
+        const out = [];
+        for (const item of block.items) {
+          out.push(
+            ...renderPrefixedText(
+              item,
+              w,
+              { text: " \u2022 ", color: overrides?.unorderedBullet ?? md.unorderedBullet },
+              "   "
+            )
+          );
+        }
+        return out;
+      };
+    case "ordered-list":
+      return (w) => {
+        const out = [];
+        const lastNumber = block.start + block.items.length - 1;
+        const digits = String(Math.max(block.start, lastNumber)).length;
+        for (let i = 0; i < block.items.length; i++) {
+          const n = String(block.start + i).padStart(digits, " ");
+          const prefix = {
+            text: `${n}. `,
+            color: overrides?.orderedMarker ?? md.orderedMarker
+          };
+          out.push(...renderPrefixedText(block.items[i], w, prefix, " ".repeat(digits + 2)));
+        }
+        return out;
+      };
+    case "table": {
+      const keys = block.headers.map((_, i) => `c${i}`);
+      const columns = block.headers.map((header, i) => ({
+        key: keys[i],
+        title: header || `col_${i + 1}`,
+        align: block.rows.every((row) => isNumericValue(row[i] ?? "")) ? "right" : "left",
+        headerColor: overrides?.tableHeader ?? md.tableHeader
+      }));
+      const data = block.rows.map((row) => {
+        const out = {};
+        keys.forEach((key, i) => {
+          out[key] = row[i] ?? "";
+        });
+        return out;
+      });
+      return table(columns, data, {
+        borderColor: overrides?.tableBorder ?? md.tableBorder
+      });
+    }
+    case "quote":
+      return (w) => {
+        const out = [];
+        for (const quoteLine of block.lines) {
+          out.push(
+            ...renderPrefixedText(
+              quoteLine,
+              w,
+              { text: "\u258C ", color: overrides?.quoteMarker ?? md.quoteMarker },
+              "  ",
+              { color: overrides?.quoteText ?? md.quoteText, dim: true }
+            )
+          );
+        }
+        return out;
+      };
+    case "separator":
+      return separator(overrides?.separator ?? md.separator);
+    case "code":
+      return box(
+        lines(
+          block.lines.length > 0 ? block.lines.map((line) => [{ text: line || " ", color: overrides?.codeText ?? md.codeText }]) : [[{ text: " ", color: overrides?.codeEmpty ?? md.codeEmpty, dim: true }]]
+        ),
+        {
+          title: block.language ? `code:${block.language}` : "code",
+          borderColor: overrides?.codeBorder ?? md.codeBorder
+        }
+      );
+  }
+}
+function fromMarkdown(markdown, opts) {
+  const theme = opts?.theme ?? dark;
+  const blocks = parseMarkdown(markdown);
+  const layouts = blocks.map((block) => renderMarkdownBlock(block, theme, opts?.overrides));
+  return (w) => {
+    if (layouts.length === 0) return blank()(w);
+    const out = [];
+    layouts.forEach((layout, index) => {
+      if (index > 0) out.push(...blank()(w));
+      out.push(...layout(w));
+    });
+    return out;
+  };
+}
+
+// src/document/html.ts
+function htmlParagraph(text, color) {
+  return (w) => {
+    const wrapped = wrapText2(text, w);
+    if (!color) return wrapped.map((line) => [line]);
+    return wrapped.map((line) => [{ text: line, color }]);
+  };
+}
+function htmlHeading(level, text, theme, overrides, markerColor) {
+  const md = theme.markdown;
+  return (w) => renderPrefixedText(
+    text,
+    w,
+    {
+      text: "#".repeat(level) + " ",
+      color: markerColor ?? overrides?.headingMarker ?? md.headingMarker
+    },
+    " ".repeat(level + 1),
+    {
+      color: headingColor(level, theme, overrides),
+      bold: level <= (overrides?.headingBoldMaxLevel ?? md.headingBoldMaxLevel)
+    }
+  );
+}
+function collectDirectChildElements(el) {
+  return Array.from(el.childNodes).filter((n) => n.nodeType === 1);
+}
+function collectHtmlChildLayouts(el, theme, overrides) {
+  const layouts = [];
+  for (const child of Array.from(el.childNodes)) {
+    const layout = renderHtmlNode(child, theme, overrides);
+    if (layout) layouts.push(layout);
+  }
+  return layouts;
+}
+function htmlContainer(el, theme, overrides) {
+  const layouts = collectHtmlChildLayouts(el, theme, overrides);
+  if (layouts.length === 0) return blank();
+  const withSpacing = [];
+  layouts.forEach((layout, index) => {
+    if (index > 0) withSpacing.push(blank());
+    withSpacing.push(layout);
+  });
+  return (w) => withSpacing.flatMap((layout) => layout(w));
+}
+function htmlList(el, ordered, theme, overrides) {
+  const items = collectDirectChildElements(el).filter(
+    (child) => child.tagName.toLowerCase() === "li"
+  );
+  if (items.length === 0) return blank();
+  return (w) => {
+    const out = [];
+    const start = ordered ? parseIntegerAttr(el, "start") ?? 1 : 1;
+    const digits = ordered ? String(start + items.length - 1).length : 0;
+    items.forEach((item, index) => {
+      const text = normalizeHtmlText(item.textContent ?? "");
+      if (!text) return;
+      if (ordered) {
+        const n = String(start + index).padStart(digits, " ");
+        const prefix = {
+          text: `${n}. `,
+          color: overrides?.orderedMarker ?? theme.markdown.orderedMarker
+        };
+        out.push(...renderPrefixedText(text, w, prefix, " ".repeat(digits + 2)));
+      } else {
+        out.push(
+          ...renderPrefixedText(
+            text,
+            w,
+            { text: " \u2022 ", color: overrides?.unorderedBullet ?? theme.markdown.unorderedBullet },
+            "   "
+          )
+        );
+      }
+    });
+    return out.length > 0 ? out : blank()(w);
+  };
+}
+function collectTableRowElements(tableEl) {
+  const rows = [];
+  for (const child of collectDirectChildElements(tableEl)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag === "tr") {
+      rows.push(child);
+      continue;
+    }
+    if (tag === "thead" || tag === "tbody" || tag === "tfoot") {
+      for (const row of collectDirectChildElements(child)) {
+        if (row.tagName.toLowerCase() === "tr") rows.push(row);
+      }
+    }
+  }
+  return rows;
+}
+function tableRowCells(rowEl) {
+  const parentTag = rowEl.parentElement?.tagName.toLowerCase();
+  const inHead = parentTag === "thead";
+  const cells = [];
+  for (const child of collectDirectChildElements(rowEl)) {
+    const tag = child.tagName.toLowerCase();
+    if (tag !== "th" && tag !== "td") continue;
+    cells.push({
+      text: normalizeHtmlText(child.textContent ?? ""),
+      header: inHead || tag === "th"
+    });
+  }
+  return cells;
+}
+function htmlTable(el, theme, overrides) {
+  const rowEls = collectTableRowElements(el);
+  if (rowEls.length === 0) {
+    return lines([[{ text: "(empty table)", color: theme.semantic.frameMuted, dim: true }]]);
+  }
+  const rows = rowEls.map(tableRowCells).filter((cells) => cells.length > 0);
+  if (rows.length === 0) {
+    return lines([[{ text: "(empty table)", color: theme.semantic.frameMuted, dim: true }]]);
+  }
+  const firstRow = rows[0];
+  const hasHeader = firstRow.some((cell) => cell.header);
+  const headers = hasHeader ? firstRow.map((cell, index) => cell.text || `col_${index + 1}`) : firstRow.map((_, index) => `col_${index + 1}`);
+  const dataRows = rows.slice(hasHeader ? 1 : 0).map((row) => headers.map((_, index) => row[index]?.text ?? ""));
+  const keys = headers.map((_, index) => `c${index}`);
+  const headerColor = getColorAttr(el, theme, ["header-color", "data-header-color"]) ?? overrides?.tableHeader ?? theme.markdown.tableHeader;
+  const borderColor = getColorAttr(el, theme, ["border-color", "data-border-color"]) ?? overrides?.tableBorder ?? theme.markdown.tableBorder;
+  const columns = headers.map((header, i) => ({
+    key: keys[i],
+    title: header,
+    align: dataRows.every((row) => isNumericValue(row[i] ?? "")) ? "right" : "left",
+    headerColor
+  }));
+  const data = dataRows.map((row) => {
+    const out = {};
+    keys.forEach((key, index) => {
+      out[key] = row[index] ?? "";
+    });
+    return out;
+  });
+  return table(columns, data, { borderColor });
+}
+function htmlPre(el, theme, overrides) {
+  const raw = (el.textContent ?? "").replace(/\r\n/g, "\n");
+  const trimmed = raw.replace(/^\n+|\n+$/g, "");
+  const linesOut = trimmed.length > 0 ? trimmed.split("\n").map((line) => line.replace(/\t/g, "  ")) : [];
+  const language = parseCodeLanguage(el) ?? parseCodeLanguage(el.querySelector("code") ?? el);
+  const textColor = getColorAttr(el, theme, ["text-color", "data-text-color", "color", "data-color"]) ?? overrides?.codeText ?? theme.markdown.codeText;
+  const borderColor = getColorAttr(el, theme, ["border-color", "data-border-color"]) ?? overrides?.codeBorder ?? theme.markdown.codeBorder;
+  const emptyColor = overrides?.codeEmpty ?? theme.markdown.codeEmpty;
+  return box(
+    lines(
+      linesOut.length > 0 ? linesOut.map((line) => [{ text: line || " ", color: textColor }]) : [[{ text: " ", color: emptyColor, dim: true }]]
+    ),
+    {
+      title: language ? `code:${language}` : "code",
+      borderColor
+    }
+  );
+}
+function renderHtmlNode(node, theme, overrides) {
+  if (node.nodeType === 3) {
+    const text2 = normalizeHtmlText(node.textContent ?? "");
+    if (!text2) return null;
+    return htmlParagraph(text2, theme.markdown.paragraph);
+  }
+  if (node.nodeType !== 1) return null;
+  const el = node;
+  const tag = el.tagName.toLowerCase();
+  if (/^h[1-6]$/.test(tag)) {
+    const level = Number.parseInt(tag[1] ?? "1", 10) || 1;
+    const text2 = normalizeHtmlText(el.textContent ?? "");
+    if (!text2) return null;
+    return htmlHeading(
+      level,
+      text2,
+      theme,
+      overrides,
+      getColorAttr(el, theme, ["marker-color", "data-marker-color"])
+    );
+  }
+  if (tag === "p") {
+    const text2 = normalizeHtmlText(el.textContent ?? "");
+    if (!text2) return null;
+    const color2 = getColorAttr(el, theme, ["color", "data-color"]) ?? overrides?.paragraph ?? theme.markdown.paragraph;
+    return htmlParagraph(text2, color2);
+  }
+  if (tag === "ul") return htmlList(el, false, theme, overrides);
+  if (tag === "ol") return htmlList(el, true, theme, overrides);
+  if (tag === "blockquote") {
+    const text2 = normalizeHtmlText(el.textContent ?? "");
+    if (!text2) return null;
+    return (w) => renderPrefixedText(
+      text2,
+      w,
+      {
+        text: "\u258C ",
+        color: getColorAttr(el, theme, ["marker-color", "data-marker-color"]) ?? overrides?.quoteMarker ?? theme.markdown.quoteMarker
+      },
+      "  ",
+      { color: overrides?.quoteText ?? theme.markdown.quoteText, dim: true }
+    );
+  }
+  if (tag === "hr") {
+    return separator(
+      getColorAttr(el, theme, ["color", "data-color"]) ?? overrides?.separator ?? theme.markdown.separator
+    );
+  }
+  if (tag === "pre") return htmlPre(el, theme, overrides);
+  if (tag === "table") return htmlTable(el, theme, overrides);
+  if (tag === "term" || tag === "main" || tag === "section" || tag === "article" || tag === "div" || tag === "header" || tag === "footer" || tag === "nav" || tag === "body") {
+    return htmlContainer(el, theme, overrides);
+  }
+  const text = normalizeHtmlText(el.textContent ?? "");
+  if (!text) return htmlContainer(el, theme, overrides);
+  const color = getColorAttr(el, theme, ["color", "data-color"]);
+  return htmlParagraph(text, color ?? theme.markdown.paragraph);
+}
+function fromHtml(html, opts) {
+  const theme = opts?.theme ?? dark;
+  if (typeof DOMParser === "undefined") {
+    return fromMarkdown(html, { theme, overrides: opts?.overrides });
+  }
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  const host = doc.body.querySelector("term");
+  const root = host ?? doc.body;
+  if (!root) return blank();
+  return htmlContainer(root, theme, opts?.overrides);
+}
+
+// src/document/json.ts
+var JSON_NODE_TYPES = /* @__PURE__ */ new Set([
+  "vstack",
+  "hstack",
+  "box",
+  "lines",
+  "separator",
+  "blank",
+  "table",
+  "statusbar",
+  "tabs",
+  "bar",
+  "text"
+]);
+function isJsonNode(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const type = value.type;
+  return typeof type === "string" && JSON_NODE_TYPES.has(type);
+}
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function primitiveStyle(value, theme) {
+  if (typeof value === "string") return { color: theme.green };
+  if (typeof value === "number") return { color: theme.yellow };
+  if (typeof value === "boolean") {
+    return { color: value ? theme.green : theme.red, bold: true };
+  }
+  if (value === null) return { color: theme.brightBlack, dim: true };
+  return void 0;
+}
+function primitiveText(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === void 0) return "undefined";
+  return String(value);
+}
+function isPrimitiveJsonValue(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isPrimitiveArrayValue(value) {
+  return Array.isArray(value) && value.every((item) => isPrimitiveJsonValue(item));
+}
+function segmentLength(segment) {
+  return typeof segment === "string" ? segment.length : segment.text.length;
+}
+function lineLength(line) {
+  let total = 0;
+  for (const segment of line) total += segmentLength(segment);
+  return total;
+}
+function primitiveSegment(value, theme) {
+  const text = primitiveText(value);
+  const style = primitiveStyle(value, theme);
+  return style ? { text, ...style } : text;
+}
+function indentLayout(layout, indent) {
+  return (w) => {
+    if (indent <= 0) return layout(w);
+    const pad2 = " ".repeat(indent);
+    if (w <= indent) return layout(w);
+    return layout(w - indent).map((line) => [pad2, ...line]);
+  };
+}
+function sectionHeader(title, theme) {
+  return (w) => {
+    const label = ` ${title} `;
+    const remaining = Math.max(0, w - label.length);
+    return [[
+      { text: label, color: theme.brightBlack, bold: true },
+      { text: "\u2500".repeat(remaining), color: theme.border }
+    ]];
+  };
+}
+function isShallowSectionValue(value) {
+  if (isRecord3(value)) {
+    const vals = Object.values(value);
+    return vals.every((item) => isPrimitiveJsonValue(item) || isPrimitiveArrayValue(item));
+  }
+  if (Array.isArray(value)) return value.every((item) => isPrimitiveJsonValue(item));
+  return isPrimitiveJsonValue(value);
+}
+function stackWithSpacing(children) {
+  if (children.length === 0) return blank();
+  if (children.length === 1) return children[0];
+  const layouts = [];
+  children.forEach((child, index) => {
+    if (index > 0) layouts.push(blank());
+    layouts.push(child);
+  });
+  return vstack(...layouts);
+}
+function renderPrimitiveValue(value, theme) {
+  return (w) => {
+    const text = primitiveText(value);
+    const style = primitiveStyle(value, theme);
+    const rows = text.split("\n");
+    const out = [];
+    for (const row of rows) {
+      const wrapped = wrapText2(row, w);
+      for (const chunk of wrapped) {
+        out.push([style ? { text: chunk, ...style } : chunk]);
+      }
+    }
+    return out.length > 0 ? out : [[{ text: " ", dim: true }]];
+  };
+}
+function renderStandalonePrimitiveArray(value, theme) {
+  return (w) => {
+    if (value.length === 0) {
+      return [[{ text: "(empty array)", color: theme.brightBlack, dim: true }]];
+    }
+    const out = [];
+    const digits = String(value.length).length;
+    value.forEach((item, index) => {
+      const prefix = ` ${String(index + 1).padStart(digits, " ")}. `;
+      out.push(
+        ...renderPrefixedText(
+          primitiveText(item),
+          w,
+          { text: prefix, color: theme.brightBlack },
+          " ".repeat(prefix.length),
+          primitiveStyle(item, theme)
+        )
+      );
+    });
+    return out;
+  };
+}
+function isTabularRecordArray(value) {
+  if (value.length === 0) return false;
+  if (!value.every((item) => isRecord3(item))) return false;
+  const keys = Object.keys(value[0]);
+  if (keys.length < 2) return false;
+  return value.every((row) => {
+    const rowKeys = Object.keys(row);
+    if (rowKeys.length !== keys.length) return false;
+    if (!keys.every((key) => rowKeys.includes(key))) return false;
+    return keys.every((key) => isPrimitiveJsonValue(row[key]));
+  });
+}
+function renderTabularRecordArray(rows, theme) {
+  const keys = Object.keys(rows[0] ?? {});
+  const columns = keys.map((key) => {
+    const values = rows.map((row) => row[key]);
+    const isBoolCol = values.every((v) => typeof v === "boolean");
+    const isNumCol = values.every((v) => isNumericValue(v));
+    return {
+      key,
+      title: key,
+      align: isNumCol ? "right" : "left",
+      headerColor: theme.cyan,
+      color: isBoolCol ? (value) => value === true ? theme.green : value === false ? theme.red : void 0 : isNumCol ? theme.yellow : void 0
+    };
+  });
+  return table(columns, rows, {
+    borderColor: theme.border
+  });
+}
+function renderArrayValue(value, theme) {
+  if (value.length === 0) {
+    return lines([[{ text: "(empty array)", color: theme.brightBlack, dim: true }]]);
+  }
+  if (isTabularRecordArray(value)) {
+    return renderTabularRecordArray(value, theme);
+  }
+  if (value.every((item) => isPrimitiveJsonValue(item))) {
+    return renderStandalonePrimitiveArray(value, theme);
+  }
+  const children = value.map(
+    (item, index) => renderJsonSection(`item ${index + 1}`, item, theme)
+  );
+  return stackWithSpacing(children);
+}
+function renderPrimitiveRows(rows, theme) {
+  return (w) => {
+    const out = [];
+    const keyWidth = Math.max(...rows.map((row) => row.key.length), 0);
+    for (const row of rows) {
+      const keyPrefix = ` ${row.key.padEnd(keyWidth)}: `;
+      if (row.kind === "primitive") {
+        out.push(
+          ...renderPrefixedText(
+            primitiveText(row.value),
+            w,
+            { text: keyPrefix, color: theme.brightBlack },
+            " ".repeat(keyPrefix.length),
+            primitiveStyle(row.value, theme)
+          )
+        );
+        continue;
+      }
+      if (row.value.length === 0) {
+        out.push([
+          { text: keyPrefix, color: theme.brightBlack },
+          { text: "(empty)", color: theme.brightBlack, dim: true }
+        ]);
+        continue;
+      }
+      const inlineSegments = [];
+      row.value.forEach((item, index) => {
+        if (index > 0) inlineSegments.push({ text: ", ", color: theme.brightBlack });
+        inlineSegments.push(primitiveSegment(item, theme));
+      });
+      const inlineLine = [{ text: keyPrefix, color: theme.brightBlack }, ...inlineSegments];
+      if (lineLength(inlineLine) <= w) {
+        out.push(inlineLine);
+        continue;
+      }
+      out.push([{ text: ` ${row.key}:`, color: theme.brightBlack }]);
+      const digits = String(row.value.length).length;
+      row.value.forEach((item, index) => {
+        const listPrefix = `   ${String(index + 1).padStart(digits, " ")}. `;
+        out.push(
+          ...renderPrefixedText(
+            primitiveText(item),
+            w,
+            { text: listPrefix, color: theme.brightBlack },
+            " ".repeat(listPrefix.length),
+            primitiveStyle(item, theme)
+          )
+        );
+      });
+    }
+    return out;
+  };
+}
+function renderObjectValue(value, theme) {
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return lines([[{ text: "(empty object)", color: theme.brightBlack, dim: true }]]);
+  }
+  const groups = [];
+  let pendingRows = [];
+  const flushRows = () => {
+    if (pendingRows.length === 0) return;
+    groups.push(renderPrimitiveRows(pendingRows, theme));
+    pendingRows = [];
+  };
+  for (const [key, item] of entries) {
+    if (isPrimitiveJsonValue(item)) {
+      pendingRows.push({ kind: "primitive", key, value: item });
+      continue;
+    }
+    if (isPrimitiveArrayValue(item)) {
+      pendingRows.push({ kind: "array", key, value: item });
+      continue;
+    }
+    flushRows();
+    groups.push(renderJsonSection(key, item, theme));
+  }
+  flushRows();
+  return stackWithSpacing(groups);
+}
+function renderJsonContent(value, theme) {
+  if (isRecord3(value)) return renderObjectValue(value, theme);
+  if (Array.isArray(value)) return renderArrayValue(value, theme);
+  return renderPrimitiveValue(value, theme);
+}
+function renderJsonSection(title, value, theme) {
+  if (Array.isArray(value) && isTabularRecordArray(value)) {
+    return vstack(sectionHeader(title, theme), indentLayout(renderJsonContent(value, theme), 1));
+  }
+  if (isShallowSectionValue(value)) {
+    return vstack(sectionHeader(title, theme), indentLayout(renderJsonContent(value, theme), 1));
+  }
+  return box(renderJsonContent(value, theme), {
+    title,
+    borderColor: theme.border
+  });
+}
+function fromJson(value, opts) {
+  const theme = opts?.theme ?? dark;
+  let parsedValue = value;
+  if (typeof value === "string") {
+    try {
+      parsedValue = JSON.parse(value);
+    } catch {
+      parsedValue = value;
+    }
+  }
+  if (isJsonNode(parsedValue)) return fromJsonNode(parsedValue);
+  const content = renderJsonContent(parsedValue, theme);
+  if (opts?.title) {
+    return box(content, {
+      title: opts.title,
+      borderColor: theme.border
+    });
+  }
+  return content;
+}
+
+// src/document/index.ts
+function fromDocument(source, opts) {
+  if (source.format === "markdown") {
+    return fromMarkdown(source.value, {
+      theme: opts?.theme,
+      overrides: opts?.markdownOverrides
+    });
+  }
+  if (source.format === "html") {
+    return fromHtml(source.value, {
+      theme: opts?.theme,
+      overrides: opts?.markdownOverrides
+    });
+  }
+  return fromJson(source.value, {
+    theme: opts?.theme,
+    title: opts?.jsonTitle
+  });
+}
+
+// src/theme-provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var FALLBACK_THEME = resolveTheme(defaultThemeSpec, "dark");
+var noopThemeSpec = () => {
+};
+var noopModePreference = () => {
+};
+var TermThemeContext = createContext({
+  themeSpec: defaultThemeSpec,
+  modePreference: "dark",
+  systemMode: "dark",
+  theme: FALLBACK_THEME,
+  setThemeSpec: noopThemeSpec,
+  setModePreference: noopModePreference
+});
+function readSystemMode() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return "dark";
+  }
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function TermThemeProvider({
+  children,
+  initialTheme = defaultThemeSpec,
+  initialMode = "system"
+}) {
+  const [themeSpec, setThemeSpec] = useState(initialTheme);
+  const [modePreference, setModePreference] = useState(initialMode);
+  const [systemMode, setSystemMode] = useState(readSystemMode);
+  useEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const media = window.matchMedia("(prefers-color-scheme: dark)");
+    const onChange = (event) => {
+      setSystemMode(event.matches ? "dark" : "light");
+    };
+    if (typeof media.addEventListener === "function") {
+      media.addEventListener("change", onChange);
+      return () => media.removeEventListener("change", onChange);
+    }
+    media.addListener(onChange);
+    return () => media.removeListener(onChange);
+  }, []);
+  const theme = useMemo(
+    () => resolveTheme(themeSpec, modePreference, { systemMode }),
+    [themeSpec, modePreference, systemMode]
+  );
+  const value = useMemo(
+    () => ({
+      themeSpec,
+      modePreference,
+      systemMode,
+      theme,
+      setThemeSpec,
+      setModePreference
+    }),
+    [themeSpec, modePreference, systemMode, theme, setThemeSpec, setModePreference]
+  );
+  return /* @__PURE__ */ jsx(TermThemeContext.Provider, { value, children });
+}
+function useTermTheme() {
+  return useContext(TermThemeContext);
+}
+
+// src/render.tsx
+import {
+  memo,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useMemo as useMemo2,
+  useRef,
+  useSyncExternalStore
+} from "react";
+
+// src/reconciler.ts
+import Reconciler from "react-reconciler";
+import { DefaultEventPriority } from "react-reconciler/constants";
+function isRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function asNumberArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "number") return void 0;
+    out.push(item);
+  }
+  return out;
+}
+function asRecordArray(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    if (isRecord4(item)) out.push(item);
+  }
+  return out;
+}
+function isMarkdownOverrides(value) {
+  if (!isRecord4(value)) return false;
+  if (value.headingMarker !== void 0 && typeof value.headingMarker !== "string") return false;
+  if (value.headingBoldMaxLevel !== void 0 && typeof value.headingBoldMaxLevel !== "number") return false;
+  if (value.paragraph !== void 0 && typeof value.paragraph !== "string") return false;
+  if (value.unorderedBullet !== void 0 && typeof value.unorderedBullet !== "string") return false;
+  if (value.orderedMarker !== void 0 && typeof value.orderedMarker !== "string") return false;
+  if (value.tableHeader !== void 0 && typeof value.tableHeader !== "string") return false;
+  if (value.tableBorder !== void 0 && typeof value.tableBorder !== "string") return false;
+  if (value.quoteMarker !== void 0 && typeof value.quoteMarker !== "string") return false;
+  if (value.quoteText !== void 0 && typeof value.quoteText !== "string") return false;
+  if (value.separator !== void 0 && typeof value.separator !== "string") return false;
+  if (value.codeText !== void 0 && typeof value.codeText !== "string") return false;
+  if (value.codeEmpty !== void 0 && typeof value.codeEmpty !== "string") return false;
+  if (value.codeBorder !== void 0 && typeof value.codeBorder !== "string") return false;
+  if (value.headings !== void 0) {
+    if (!isRecord4(value.headings)) return false;
+    if (Object.values(value.headings).some(
+      (headingColor2) => typeof headingColor2 !== "string"
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+function asMarkdownOverrides(value) {
+  return isMarkdownOverrides(value) ? value : void 0;
+}
+function isSegment(value) {
+  if (typeof value === "string") return true;
+  if (!isRecord4(value)) return false;
+  if (typeof value.text !== "string") return false;
+  if (value.color !== void 0 && typeof value.color !== "string") return false;
+  if (value.bg !== void 0 && typeof value.bg !== "string") return false;
+  if (value.bold !== void 0 && typeof value.bold !== "boolean") return false;
+  if (value.dim !== void 0 && typeof value.dim !== "boolean") return false;
+  if (value.inverted !== void 0 && typeof value.inverted !== "boolean") return false;
+  if (value.blink !== void 0 && typeof value.blink !== "boolean") return false;
+  if (value.onClick !== void 0 && typeof value.onClick !== "function") return false;
+  if (value.noSelect !== void 0 && typeof value.noSelect !== "boolean") return false;
+  if (value.cell !== void 0 && typeof value.cell !== "number") return false;
+  return true;
+}
+function isColumn(value) {
+  if (!isRecord4(value)) return false;
+  if (typeof value.key !== "string") return false;
+  if (value.title !== void 0 && typeof value.title !== "string") return false;
+  if (value.width !== void 0 && typeof value.width !== "number") return false;
+  if (value.align !== void 0 && value.align !== "left" && value.align !== "right") return false;
+  if (value.headerColor !== void 0 && typeof value.headerColor !== "string") return false;
+  if (value.headerBold !== void 0 && typeof value.headerBold !== "boolean") return false;
+  if (value.color !== void 0 && typeof value.color !== "string" && typeof value.color !== "function") return false;
+  if (value.dim !== void 0 && typeof value.dim !== "boolean" && typeof value.dim !== "function") return false;
+  return true;
+}
+function asColumns(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    if (isColumn(item)) out.push(item);
+  }
+  return out;
+}
+function isTreeNode(value) {
+  if (!isRecord4(value)) return false;
+  if (typeof value.label !== "string") return false;
+  if (value.children === void 0) return true;
+  if (!Array.isArray(value.children)) return false;
+  return value.children.every((child) => isTreeNode(child));
+}
+function asTreeNodes(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    if (isTreeNode(item)) out.push(item);
+  }
+  return out;
+}
+function isLayoutFn(value) {
+  return typeof value === "function";
+}
+function isSelectHandler(value) {
+  return typeof value === "function";
+}
+var TermNode = class {
+  type;
+  props;
+  children = [];
+  parent = null;
+  text;
+  constructor(type, props) {
+    this.type = type;
+    this.props = props;
+  }
+  appendChild(child) {
+    child.parent = this;
+    this.children.push(child);
+  }
+  removeChild(child) {
+    const idx = this.children.indexOf(child);
+    if (idx !== -1) {
+      this.children.splice(idx, 1);
+      child.parent = null;
+    }
+  }
+  insertBefore(child, before) {
+    child.parent = this;
+    const idx = this.children.indexOf(before);
+    if (idx !== -1) {
+      this.children.splice(idx, 0, child);
+    } else {
+      this.children.push(child);
+    }
+  }
+};
+var TermRoot = class {
+  children = [];
+  theme;
+  markdownOverrides;
+  _layoutFn = blank();
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(theme, markdownOverrides) {
+    this.theme = theme;
+    this.markdownOverrides = markdownOverrides;
+  }
+  appendChild(child) {
+    child.parent = null;
+    this.children.push(child);
+  }
+  removeChild(child) {
+    const idx = this.children.indexOf(child);
+    if (idx !== -1) {
+      this.children.splice(idx, 1);
+      child.parent = null;
+    }
+  }
+  insertBefore(child, before) {
+    child.parent = null;
+    const idx = this.children.indexOf(before);
+    if (idx !== -1) {
+      this.children.splice(idx, 0, child);
+    } else {
+      this.children.push(child);
+    }
+  }
+  commitTree() {
+    this._layoutFn = compileTermChildren(
+      this.children,
+      this.theme,
+      this.markdownOverrides
+    );
+    for (const cb of this._listeners) cb();
+  }
+  subscribe = (listener) => {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  };
+  getLayoutFn = () => this._layoutFn;
+};
+function extractTermText(children) {
+  return children.map((c) => {
+    if (c.type === "t-text") return c.text ?? "";
+    return extractTermText(c.children);
+  }).join("");
+}
+function stackWithGap(children, gap = 0) {
+  if (children.length === 0) return blank();
+  if (children.length === 1 && gap <= 0) return children[0];
+  const layouts = [];
+  for (let i = 0; i < children.length; i++) {
+    if (i > 0) {
+      for (let j = 0; j < gap; j++) layouts.push(blank());
+    }
+    layouts.push(children[i]);
+  }
+  return vstack(...layouts);
+}
+function compileTermChildren(children, theme, mdOverrides) {
+  const out = [];
+  for (const child of children) {
+    const layout = compileTermNode(child, theme, mdOverrides);
+    if (layout) out.push(layout);
+  }
+  if (out.length === 0) return blank();
+  if (out.length === 1) return out[0];
+  return vstack(...out);
+}
+var tabHandlerCache = /* @__PURE__ */ new WeakMap();
+function cachedTabHandler(onSelect, index) {
+  let map = tabHandlerCache.get(onSelect);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    tabHandlerCache.set(onSelect, map);
+  }
+  let handler = map.get(index);
+  if (!handler) {
+    handler = () => onSelect(index);
+    map.set(index, handler);
+  }
+  return handler;
+}
+function toSegments(value) {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const segment of value) {
+    if (isSegment(segment)) out.push(segment);
+  }
+  return out;
+}
+function compileRaw(p, children) {
+  const color = asString(p.color);
+  const bg = asString(p.bg);
+  const bold = asBoolean(p.bold);
+  const dim = asBoolean(p.dim);
+  const blink = asBoolean(p.blink);
+  const inverted = asBoolean(p.inverted);
+  const onClick = typeof p.onClick === "function" ? p.onClick : void 0;
+  const rawText = asString(p.text) ?? extractTermText(children);
+  const text = rawText.replace(/\r\n/g, "\n");
+  const rows = text.length > 0 ? text.split("\n") : [" "];
+  if (!color && !bg && bold === void 0 && dim === void 0 && blink === void 0 && inverted === void 0 && !onClick) {
+    return lines(rows.map((row) => [row]));
+  }
+  return lines(
+    rows.map((row) => [
+      {
+        text: row,
+        color,
+        bg,
+        bold,
+        dim,
+        blink,
+        inverted,
+        onClick
+      }
+    ])
+  );
+}
+function compileLine(children) {
+  const segments = [];
+  for (const child of children) {
+    if (child.type === "t-text") {
+      segments.push(child.text ?? "");
+      continue;
+    }
+    if (child.type === "t-span") {
+      const cp = child.props;
+      const text = asString(cp.text) ?? extractTermText(child.children);
+      const color = asString(cp.color);
+      const bg = asString(cp.bg);
+      const bold = asBoolean(cp.bold);
+      const dim = asBoolean(cp.dim);
+      const inverted = asBoolean(cp.inverted);
+      const blink = asBoolean(cp.blink);
+      if (color || bg || bold !== void 0 || dim !== void 0 || inverted !== void 0 || blink !== void 0) {
+        segments.push({
+          text,
+          color,
+          bg,
+          bold,
+          dim,
+          inverted,
+          blink
+        });
+      } else {
+        segments.push(text);
+      }
+    } else {
+      segments.push(extractTermText(child.children));
+    }
+  }
+  return lines([segments]);
+}
+function compileTermNode(node, theme, mdOverrides) {
+  if (node.type === "t-text") {
+    return node.text ? lines([[node.text]]) : null;
+  }
+  const p = node.props;
+  switch (node.type) {
+    case "t-vstack": {
+      const ch = compileChildLayouts(node.children, theme, mdOverrides);
+      const gap = asNumber(p.gap) ?? 0;
+      return stackWithGap(ch, gap);
+    }
+    case "t-hstack": {
+      const ch = compileChildLayouts(node.children, theme, mdOverrides);
+      if (ch.length === 0) return blank();
+      return hstack(ch, {
+        gap: asNumber(p.gap),
+        widths: asNumberArray(p.widths)
+      });
+    }
+    case "t-box": {
+      const ch = compileChildLayouts(node.children, theme, mdOverrides);
+      const gap = asNumber(p.gap) ?? 0;
+      return box(stackWithGap(ch, gap), {
+        title: asString(p.title),
+        borderColor: asString(p.borderColor) ?? theme.semantic.border
+      });
+    }
+    case "t-separator":
+      return separator(asString(p.color) ?? theme.semantic.border);
+    case "t-blank":
+      return blank();
+    case "t-raw":
+      return compileRaw(p, node.children);
+    case "t-line":
+      return compileLine(node.children);
+    case "t-layout": {
+      const layout = p.layout;
+      return isLayoutFn(layout) ? layout : blank();
+    }
+    case "t-table": {
+      const columns = asColumns(p.columns);
+      const data = asRecordArray(p.data);
+      return table(columns, data, {
+        borderColor: asString(p.borderColor) ?? theme.semantic.border,
+        fillWidth: asBoolean(p.fillWidth),
+        headerColor: asString(p.headerColor),
+        cellPadding: asNumber(p.cellPadding)
+      });
+    }
+    case "t-tab":
+      return null;
+    case "t-tabs": {
+      const tabNodes = node.children.filter((c) => c.type === "t-tab");
+      const names = tabNodes.map((t) => asString(t.props.name) ?? "");
+      const active = asNumber(p.active) ?? 0;
+      const onSelect = isSelectHandler(p.onSelect) ? p.onSelect : void 0;
+      const onClicks = onSelect ? names.map((_, i) => cachedTabHandler(onSelect, i)) : void 0;
+      const tabBar = tabs(names, active, {
+        activeColor: asString(p.activeColor),
+        activeBg: asString(p.activeBg),
+        inactiveColor: asString(p.inactiveColor),
+        separatorColor: asString(p.separatorColor),
+        onClicks,
+        theme
+      });
+      const activeNode = tabNodes[active];
+      if (!activeNode || activeNode.children.length === 0) return tabBar;
+      const content = compileChildLayouts(activeNode.children, theme, mdOverrides);
+      if (content.length === 0) return tabBar;
+      return vstack(tabBar, stackWithGap(content, 0));
+    }
+    case "t-statusbar":
+      return statusbar(toSegments(p.left), toSegments(p.right), {
+        bg: asString(p.bg),
+        color: asString(p.color),
+        theme
+      });
+    case "t-markdown":
+      return fromMarkdown(asString(p.value) ?? "", {
+        theme,
+        overrides: asMarkdownOverrides(p.themeOverrides) ?? mdOverrides
+      });
+    case "t-json":
+      return fromJson(p.value, {
+        theme,
+        title: asString(p.title)
+      });
+    case "t-html":
+      return fromHtml(asString(p.value) ?? "", {
+        theme,
+        overrides: asMarkdownOverrides(p.themeOverrides) ?? mdOverrides
+      });
+    case "t-tree":
+      return tree(asTreeNodes(p.data), {
+        color: asString(p.color),
+        branchColor: asString(p.branchColor) ?? theme.semantic.border,
+        leafColor: asString(p.leafColor)
+      });
+    case "t-code":
+      return code(asString(p.code) ?? "", {
+        language: asString(p.language),
+        title: asString(p.title),
+        borderColor: asString(p.borderColor) ?? theme.markdown.codeBorder,
+        theme
+      });
+    case "t-diff":
+      return diff(asString(p.value) ?? "", {
+        addColor: asString(p.addColor),
+        removeColor: asString(p.removeColor),
+        metaColor: asString(p.metaColor),
+        theme
+      });
+    case "t-bar": {
+      const label = asString(p.label) ?? "";
+      const value = asNumber(p.value) ?? 0;
+      const max = asNumber(p.max) ?? 100;
+      const barColor = asString(p.color);
+      return (w) => {
+        const safeMax = Number.isFinite(max) && max > 0 ? max : 0;
+        const safeValue = Number.isFinite(value) ? value : 0;
+        const pct = safeMax > 0 ? Math.round(safeValue / safeMax * 100) : 0;
+        const pctStr = `${String(pct).padStart(3)}%`;
+        const barW = Math.max(0, w - label.length - 2 - 1 - pctStr.length);
+        const barStr = bar(safeValue, safeMax, barW);
+        const segments = [
+          ` ${label} `,
+          barColor ? { text: barStr, color: barColor } : barStr,
+          ` ${pctStr}`
+        ];
+        return [segments];
+      };
+    }
+    case "t-spark": {
+      const data = Array.isArray(p.data) ? p.data.filter((value) => typeof value === "number") : [];
+      const sparkColor = asString(p.color);
+      return (w) => {
+        const sparkW = Math.max(0, w - 2);
+        const sparkStr = spark(data, sparkW);
+        const segments = [
+          " ",
+          sparkColor ? { text: sparkStr, color: sparkColor } : sparkStr
+        ];
+        return [segments];
+      };
+    }
+    case "t-list":
+      return list(asStringArray(p.items), {
+        ordered: asBoolean(p.ordered),
+        bulletColor: asString(p.bulletColor),
+        color: asString(p.color)
+      });
+    case "t-button": {
+      const label = asString(p.label) ?? "";
+      const btnColor = asString(p.color);
+      const btnBg = asString(p.bg);
+      const onClick = typeof p.onClick === "function" ? p.onClick : void 0;
+      const resolvedBtnColor = btnColor ?? theme.components.button.fg;
+      const resolvedBtnBg = btnBg ?? theme.components.button.bg;
+      const decorated = `[ ${label} ]`;
+      return (w) => {
+        const lp = Math.max(0, Math.floor((w - decorated.length) / 2));
+        const rp = Math.max(0, w - lp - decorated.length);
+        const segments = [];
+        if (lp > 0) segments.push(" ".repeat(lp));
+        segments.push({ text: decorated, color: resolvedBtnColor, bg: resolvedBtnBg, onClick });
+        if (rp > 0) segments.push(" ".repeat(rp));
+        return [segments];
+      };
+    }
+    default: {
+      const ch = compileChildLayouts(node.children, theme, mdOverrides);
+      return ch.length > 0 ? stackWithGap(ch, 0) : null;
+    }
+  }
+}
+function compileChildLayouts(children, theme, mdOverrides) {
+  const out = [];
+  for (const child of children) {
+    const layout = compileTermNode(child, theme, mdOverrides);
+    if (layout) out.push(layout);
+  }
+  return out;
+}
+var noop = () => {
+};
+var currentUpdatePriority = 0;
+var hostTransitionContext = {
+  $$typeof: /* @__PURE__ */ Symbol.for("react.context"),
+  Consumer: null,
+  Provider: null,
+  _currentValue: null,
+  _currentValue2: null,
+  _threadCount: 0
+};
+var hostConfig = {
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  isPrimaryRenderer: false,
+  // ── Core ────────────────────────────────────────────────────
+  createInstance(type, props) {
+    return new TermNode(type, { ...props });
+  },
+  createTextInstance(text) {
+    const node = new TermNode("t-text", {});
+    node.text = text;
+    return node;
+  },
+  appendInitialChild(parent, child) {
+    parent.appendChild(child);
+  },
+  finalizeInitialChildren() {
+    return false;
+  },
+  shouldSetTextContent() {
+    return false;
+  },
+  getRootHostContext() {
+    return {};
+  },
+  getChildHostContext(ctx) {
+    return ctx;
+  },
+  getPublicInstance(instance) {
+    return instance;
+  },
+  prepareForCommit() {
+    return null;
+  },
+  resetAfterCommit(container) {
+    container.commitTree();
+  },
+  preparePortalMount: noop,
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: -1,
+  supportsMicrotasks: true,
+  scheduleMicrotask: queueMicrotask,
+  // ── Mutation ────────────────────────────────────────────────
+  appendChild(parent, child) {
+    parent.appendChild(child);
+  },
+  appendChildToContainer(container, child) {
+    container.appendChild(child);
+  },
+  removeChild(parent, child) {
+    parent.removeChild(child);
+  },
+  removeChildFromContainer(container, child) {
+    container.removeChild(child);
+  },
+  insertBefore(parent, child, before) {
+    parent.insertBefore(child, before);
+  },
+  insertInContainerBefore(container, child, before) {
+    container.insertBefore(child, before);
+  },
+  commitUpdate(instance, _type, _prevProps, nextProps) {
+    instance.props = { ...nextProps };
+  },
+  commitTextUpdate(textInstance, _oldText, newText) {
+    textInstance.text = newText;
+  },
+  hideInstance: noop,
+  hideTextInstance: noop,
+  unhideInstance: noop,
+  unhideTextInstance: noop,
+  clearContainer(container) {
+    container.children.length = 0;
+  },
+  // ── Required stubs (React 19) ─────────────────────────────
+  getInstanceFromNode() {
+    return null;
+  },
+  beforeActiveInstanceBlur: noop,
+  afterActiveInstanceBlur: noop,
+  prepareScopeUpdate: noop,
+  getInstanceFromScope() {
+    return null;
+  },
+  detachDeletedInstance: noop,
+  // Priority
+  setCurrentUpdatePriority(newPriority) {
+    currentUpdatePriority = newPriority;
+  },
+  getCurrentUpdatePriority() {
+    return currentUpdatePriority;
+  },
+  resolveUpdatePriority() {
+    return currentUpdatePriority || DefaultEventPriority;
+  },
+  // Forms
+  resetFormInstance: noop,
+  // Paint callback
+  requestPostPaintCallback: noop,
+  // Transitions
+  shouldAttemptEagerTransition() {
+    return false;
+  },
+  trackSchedulerEvent: noop,
+  // Events
+  resolveEventType() {
+    return null;
+  },
+  resolveEventTimeStamp() {
+    return Date.now();
+  },
+  // Suspense commit
+  maySuspendCommit() {
+    return false;
+  },
+  preloadInstance() {
+    return true;
+  },
+  startSuspendingCommit: noop,
+  suspendInstance: noop,
+  waitForCommitToBeReady() {
+    return null;
+  },
+  NotPendingTransition: null,
+  HostTransitionContext: hostTransitionContext
+};
+var reconciler = Reconciler(hostConfig);
+function createTermContainer(theme, markdownOverrides) {
+  const root = new TermRoot(theme, markdownOverrides);
+  const container = reconciler.createContainer(
+    root,
+    0,
+    // LegacyRoot
+    null,
+    false,
+    null,
+    "",
+    (err) => console.error("termui uncaught:", err),
+    (err) => console.error("termui caught:", err),
+    (err) => console.error("termui recoverable:", err),
+    noop
+  );
+  return { root, container };
+}
+function updateTermContainer(container, element) {
+  reconciler.updateContainer(element, container, null, null);
+}
+function flushTermSync(fn) {
+  if (fn) {
+    reconciler.flushSync(fn);
+  } else {
+    reconciler.flushSync();
+  }
+}
+
+// src/render.tsx
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+function segmentStyle(seg, theme) {
+  const style = {};
+  if (seg.inverted) {
+    style.color = seg.color ?? theme.semantic.inverseFg;
+    style.backgroundColor = seg.bg ?? theme.semantic.inverseBg;
+  } else {
+    if (seg.color) style.color = seg.color;
+    if (seg.bg) style.backgroundColor = seg.bg;
+  }
+  if (seg.bold) style.fontWeight = "bold";
+  if (seg.dim) style.opacity = 0.6;
+  if (seg.blink) style.animation = "bk 1s step-end infinite";
+  if (seg.onClick) style.cursor = "pointer";
+  if (seg.noSelect) style.userSelect = "none";
+  return style;
+}
+var TermSegment = memo(
+  function TermSegment2({ seg, theme }) {
+    if (typeof seg === "string") return /* @__PURE__ */ jsx2("span", { children: seg });
+    const style = segmentStyle(seg, theme);
+    return /* @__PURE__ */ jsx2("span", { className: seg.onClick ? "termui-clickable" : void 0, style, onClick: seg.onClick, children: seg.text });
+  },
+  (prev, next) => prev.seg === next.seg && prev.theme === next.theme
+);
+function renderSegment(seg, key, theme) {
+  return /* @__PURE__ */ jsx2(TermSegment, { seg, theme }, key);
+}
+function sameSegment(a, b) {
+  if (typeof a === "string" || typeof b === "string") return a === b;
+  return a.text === b.text && a.color === b.color && a.bg === b.bg && a.bold === b.bold && a.dim === b.dim && a.inverted === b.inverted && a.blink === b.blink && a.onClick === b.onClick && a.noSelect === b.noSelect && a.cell === b.cell;
+}
+function sameLine(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!sameSegment(a[i], b[i])) return false;
+  }
+  return true;
+}
+function reconcileLine(prevLine, nextLine) {
+  if (!prevLine || prevLine.length === 0) return nextLine;
+  if (sameLine(prevLine, nextLine)) return prevLine;
+  const reconciled = new Array(nextLine.length);
+  for (let i = 0; i < nextLine.length; i++) {
+    const nextSeg = nextLine[i];
+    const prevSeg = prevLine[i];
+    reconciled[i] = prevSeg !== void 0 && sameSegment(prevSeg, nextSeg) ? prevSeg : nextSeg;
+  }
+  preserveTableTag(nextLine, reconciled);
+  return reconciled;
+}
+function reconcileBlock(prevBlock, nextBlock) {
+  if (!prevBlock) return nextBlock;
+  let changed = prevBlock.length !== nextBlock.length;
+  const next = new Array(nextBlock.length);
+  for (let i = 0; i < nextBlock.length; i++) {
+    const line = reconcileLine(prevBlock[i], nextBlock[i]);
+    next[i] = line;
+    if (!changed && line !== prevBlock[i]) changed = true;
+  }
+  return changed ? next : prevBlock;
+}
+function useReconciledBlock(block) {
+  const prevRef = useRef(null);
+  return useMemo2(() => {
+    const prev = prevRef.current;
+    if (!prev) {
+      prevRef.current = block;
+      return block;
+    }
+    const next = reconcileBlock(prev, block);
+    prevRef.current = next;
+    return next;
+  }, [block]);
+}
+var TermLine = memo(function TermLine2({ line, theme }) {
+  return /* @__PURE__ */ jsx2("div", { className: "termui-line", children: line.map((seg, i) => renderSegment(seg, i, theme)) });
+});
+function isAllNoSelect(line) {
+  for (const seg of line) {
+    if (typeof seg === "string") return false;
+    if (!seg.noSelect) return false;
+  }
+  return true;
+}
+function segText(seg) {
+  return typeof seg === "string" ? seg : seg.text;
+}
+function trimSeg(seg) {
+  if (typeof seg === "string") {
+    const t2 = seg.trimEnd();
+    return t2 === seg ? seg : t2;
+  }
+  const t = seg.text.trimEnd();
+  return t === seg.text ? seg : { ...seg, text: t };
+}
+function getTableCols(lines2) {
+  const row = lines2.find((l) => !isAllNoSelect(l));
+  if (!row) return null;
+  const cols = [];
+  for (let i = 0; i < row.length; i++) {
+    const seg = row[i];
+    if (typeof seg !== "string" && seg.cell !== void 0 && !seg.noSelect) {
+      const prev = row[i - 1];
+      const bw = prev ? segText(prev).length : 0;
+      cols.push({ totalWidth: bw + seg.text.length });
+    }
+  }
+  const last = row[row.length - 1];
+  const rightBorderW = last ? segText(last).length : 1;
+  return { cols, rightBorderW };
+}
+var TermTableBorderRow = memo(function TermTableBorderRow2({
+  line,
+  totalCols,
+  theme
+}) {
+  return /* @__PURE__ */ jsx2("tr", { className: "termui-line", children: /* @__PURE__ */ jsx2("td", { colSpan: totalCols, className: "termui-border-cell", children: line.map((seg, i) => renderSegment(seg, i, theme)) }) });
+});
+var TermTableContentRow = memo(function TermTableContentRow2({ line, theme }) {
+  const cells = [];
+  for (let i = 0; i < line.length; i++) {
+    const seg = line[i];
+    if (typeof seg !== "string" && seg.cell !== void 0 && !seg.noSelect) {
+      const prev = line[i - 1];
+      const borderChar = prev ? segText(prev) : "";
+      const borderColor = prev && typeof prev !== "string" ? prev.color : void 0;
+      cells.push(
+        /* @__PURE__ */ jsxs("td", { className: "termui-cell", children: [
+          /* @__PURE__ */ jsx2("span", { className: "termui-border-span", style: borderColor ? { color: borderColor } : void 0, children: borderChar }),
+          renderSegment(trimSeg(seg), 0, theme)
+        ] }, seg.cell)
+      );
+    }
+  }
+  const last = line[line.length - 1];
+  if (last && typeof last !== "string" && last.noSelect) {
+    cells.push(
+      /* @__PURE__ */ jsx2("td", { className: "termui-border-cell", children: renderSegment(last, 0, theme) }, "rb")
+    );
+  }
+  return /* @__PURE__ */ jsx2("tr", { className: "termui-line", children: cells });
+});
+var TermTable = memo(
+  function TermTable2({ lines: lines2, theme }) {
+    const info = getTableCols(lines2);
+    if (!info) {
+      return /* @__PURE__ */ jsx2(Fragment, { children: lines2.map((line, i) => /* @__PURE__ */ jsx2(TermLine, { line, theme }, i)) });
+    }
+    const totalCols = info.cols.length + 1;
+    return /* @__PURE__ */ jsxs("table", { className: "termui-table", children: [
+      /* @__PURE__ */ jsxs("colgroup", { children: [
+        info.cols.map((col, i) => /* @__PURE__ */ jsx2("col", { style: { width: col.totalWidth + "ch" } }, i)),
+        /* @__PURE__ */ jsx2("col", { style: { width: info.rightBorderW + "ch" } }, "rb")
+      ] }),
+      /* @__PURE__ */ jsx2("tbody", { children: lines2.map((line, i) => {
+        if (isAllNoSelect(line)) {
+          return /* @__PURE__ */ jsx2(TermTableBorderRow, { line, totalCols, theme }, i);
+        }
+        return /* @__PURE__ */ jsx2(TermTableContentRow, { line, theme }, i);
+      }) })
+    ] });
+  },
+  (prev, next) => {
+    if (prev.theme !== next.theme) return false;
+    const a = prev.lines, b = next.lines;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+);
+var TermBlock = memo(
+  function TermBlock2({ block, theme }) {
+    const elements = [];
+    let tableLines = null;
+    let tableStart = 0;
+    const flushTable = () => {
+      if (tableLines) {
+        elements.push(/* @__PURE__ */ jsx2(TermTable, { lines: tableLines, theme }, `t${tableStart}`));
+        tableLines = null;
+      }
+    };
+    for (let i = 0; i < block.length; i++) {
+      const line = block[i];
+      if (isTableLine(line)) {
+        if (!tableLines) {
+          tableLines = [];
+          tableStart = i;
+        }
+        tableLines.push(line);
+      } else {
+        flushTable();
+        elements.push(/* @__PURE__ */ jsx2(TermLine, { line, theme }, i));
+      }
+    }
+    flushTable();
+    return /* @__PURE__ */ jsx2(Fragment, { children: elements });
+  },
+  (prev, next) => prev.block === next.block && prev.theme === next.theme
+);
+function TermFrame({ width, theme, className, style, children }) {
+  const frameStyle = {
+    width: width + "ch",
+    ...themeToCssVars(theme),
+    ...style
+  };
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: `termui-frame${className ? ` ${className}` : ""}`,
+      style: frameStyle,
+      children
+    }
+  );
+}
+function TermUIBase({
+  block,
+  children,
+  width = 80,
+  theme,
+  themeSpec,
+  mode,
+  markdownOverrides,
+  className,
+  style
+}) {
+  const themeContext = useTermTheme();
+  const resolvedTheme = useMemo2(() => {
+    if (theme) return theme;
+    if (!themeSpec && !mode) return themeContext.theme;
+    return resolveTheme(themeSpec ?? themeContext.themeSpec, mode ?? themeContext.modePreference, {
+      systemMode: themeContext.systemMode
+    });
+  }, [
+    theme,
+    themeSpec,
+    mode,
+    themeContext.theme,
+    themeContext.themeSpec,
+    themeContext.modePreference,
+    themeContext.systemMode
+  ]);
+  const containerRef = useRef(null);
+  if (!containerRef.current && children) {
+    containerRef.current = createTermContainer(resolvedTheme, markdownOverrides);
+  }
+  const root = containerRef.current?.root;
+  const container = containerRef.current?.container;
+  const layoutFn = useSyncExternalStore(
+    root?.subscribe ?? noopSubscribe,
+    root?.getLayoutFn ?? getBlankLayout,
+    root?.getLayoutFn ?? getBlankLayout
+  );
+  useLayoutEffect(() => {
+    if (!root || !container) return;
+    root.theme = resolvedTheme;
+    root.markdownOverrides = markdownOverrides;
+    updateTermContainer(container, children ?? null);
+  }, [root, container, children, resolvedTheme, markdownOverrides]);
+  useEffect2(() => {
+    return () => {
+      if (containerRef.current) {
+        updateTermContainer(containerRef.current.container, null);
+      }
+    };
+  }, []);
+  const computedBlock = block ?? (children ? layoutFn(width) : []);
+  const reconciledBlock = useReconciledBlock(computedBlock);
+  return /* @__PURE__ */ jsx2(TermFrame, { width, theme: resolvedTheme, className, style, children: /* @__PURE__ */ jsx2(TermBlock, { block: reconciledBlock, theme: resolvedTheme }) });
+}
+var _blankLayout = () => [];
+function noopSubscribe() {
+  return () => {
+  };
+}
+function getBlankLayout() {
+  return _blankLayout;
+}
+var TermUI = memo(TermUIBase);
+var render_default = TermUI;
+function TermDocument({
+  source,
+  width = 80,
+  theme,
+  themeSpec,
+  mode,
+  jsonTitle,
+  markdownOverrides,
+  className,
+  style
+}) {
+  const themeContext = useTermTheme();
+  const resolvedTheme = useMemo2(() => {
+    if (theme) return theme;
+    if (!themeSpec && !mode) return themeContext.theme;
+    return resolveTheme(themeSpec ?? themeContext.themeSpec, mode ?? themeContext.modePreference, {
+      systemMode: themeContext.systemMode
+    });
+  }, [
+    theme,
+    themeSpec,
+    mode,
+    themeContext.theme,
+    themeContext.themeSpec,
+    themeContext.modePreference,
+    themeContext.systemMode
+  ]);
+  const layout = useMemo2(
+    () => fromDocument(source, { theme: resolvedTheme, jsonTitle, markdownOverrides }),
+    [source, resolvedTheme, jsonTitle, markdownOverrides]
+  );
+  const block = useMemo2(() => layout(width), [layout, width]);
+  return /* @__PURE__ */ jsx2(TermUI, { block, width, theme: resolvedTheme, className, style });
+}
+
+// src/term-react.tsx
+import { createElement } from "react";
+function TVStack({ children, gap }) {
+  return createElement("t-vstack", { gap }, children);
+}
+function THStack({ children, gap, widths }) {
+  return createElement("t-hstack", { gap, widths }, children);
+}
+function TBox({ children, title, borderColor, gap }) {
+  return createElement("t-box", { title, borderColor, gap }, children);
+}
+function TSeparator({ color }) {
+  return createElement("t-separator", { color });
+}
+function TBlank() {
+  return createElement("t-blank", {});
+}
+function TRaw({ children, text, color, bg, bold, dim, blink, inverted, onClick }) {
+  return createElement(
+    "t-raw",
+    { text, color, bg, bold, dim, blink, inverted, onClick },
+    children
+  );
+}
+function TTable({
+  columns,
+  data,
+  borderColor,
+  fillWidth,
+  headerColor,
+  cellPadding
+}) {
+  return createElement("t-table", {
+    columns,
+    data,
+    borderColor,
+    fillWidth,
+    headerColor,
+    cellPadding
+  });
+}
+function TTab({ name, children }) {
+  return createElement("t-tab", { name }, children);
+}
+function TTabs({
+  children,
+  active,
+  activeColor,
+  activeBg,
+  inactiveColor,
+  separatorColor,
+  onSelect
+}) {
+  return createElement("t-tabs", {
+    active,
+    activeColor,
+    activeBg,
+    inactiveColor,
+    separatorColor,
+    onSelect
+  }, children);
+}
+function TStatusbar({ left, right, bg, color }) {
+  return createElement("t-statusbar", { left, right, bg, color });
+}
+function TMarkdown({ value, themeOverrides }) {
+  return createElement("t-markdown", { value, themeOverrides });
+}
+function TJson({ value, title }) {
+  return createElement("t-json", { value, title });
+}
+function THtml({ value, themeOverrides }) {
+  return createElement("t-html", { value, themeOverrides });
+}
+function TLine({ children }) {
+  return createElement("t-line", {}, children);
+}
+function TSpan({ children, text, color, bg, bold, dim, inverted, blink }) {
+  return createElement(
+    "t-span",
+    { text, color, bg, bold, dim, inverted, blink },
+    children
+  );
+}
+function TLayout({ layout }) {
+  return createElement("t-layout", { layout });
+}
+function TTree({ data, color, branchColor, leafColor }) {
+  return createElement("t-tree", { data, color, branchColor, leafColor });
+}
+function TCode({ code: code2, language, title, borderColor }) {
+  return createElement("t-code", { code: code2, language, title, borderColor });
+}
+function TDiff({ value, addColor, removeColor, metaColor }) {
+  return createElement("t-diff", { value, addColor, removeColor, metaColor });
+}
+function TBar({ label, value, max, color }) {
+  return createElement("t-bar", { label, value, max, color });
+}
+function TSpark({ data, color }) {
+  return createElement("t-spark", { data, color });
+}
+function TList({ items, ordered, bulletColor, color }) {
+  return createElement("t-list", { items, ordered, bulletColor, color });
+}
+function TButton({ label, onClick, color, bg }) {
+  return createElement("t-button", { label, onClick, color, bg });
+}
+function renderTermReact(tree2, opts) {
+  const resolvedTheme = opts?.theme ?? resolveTheme(opts?.themeSpec ?? defaultThemeSpec, opts?.mode ?? "dark");
+  const { root, container } = createTermContainer(
+    resolvedTheme,
+    opts?.markdownOverrides
+  );
+  flushTermSync(() => updateTermContainer(container, tree2));
+  const layout = root.getLayoutFn();
+  updateTermContainer(container, null);
+  return (w) => layout(w);
+}
+
+// src/hooks.ts
+import { useState as useState2, useEffect as useEffect3, useRef as useRef2 } from "react";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function useSpinner(ms = 80) {
+  const [frame, setFrame] = useState2(0);
+  useEffect3(() => {
+    const id = setInterval(() => setFrame((v) => (v + 1) % FRAMES.length), ms);
+    return () => clearInterval(id);
+  }, [ms]);
+  return FRAMES[frame % FRAMES.length];
+}
+function useTick(ms = 500) {
+  const [tick, setTick] = useState2(0);
+  useEffect3(() => {
+    const id = setInterval(() => setTick((v) => v + 1), ms);
+    return () => clearInterval(id);
+  }, [ms]);
+  return tick;
+}
+function useTermWidth(ref, fallback = 80) {
+  const [width, setWidth] = useState2(fallback);
+  useEffect3(() => {
+    const el = ref.current;
+    if (!el) return;
+    const m = document.createElement("span");
+    m.style.cssText = "font:inherit;visibility:hidden;position:absolute;white-space:pre";
+    m.textContent = "0".repeat(100);
+    el.appendChild(m);
+    const ch = m.getBoundingClientRect().width / 100;
+    el.removeChild(m);
+    if (ch <= 0) return;
+    const update = () => setWidth(Math.floor(el.clientWidth / ch) || fallback);
+    update();
+    const ro = new ResizeObserver(update);
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [ref, fallback]);
+  return width;
+}
+function useStreamingText(text, lerp = 0.08) {
+  const visibleRef = useRef2(0);
+  const prevTextRef = useRef2("");
+  const [sliceEnd, setSliceEnd] = useState2(0);
+  if (!text.startsWith(prevTextRef.current)) {
+    visibleRef.current = text.length;
+  }
+  prevTextRef.current = text;
+  useEffect3(() => {
+    const target = text.length;
+    if (visibleRef.current >= target) {
+      setSliceEnd(target);
+      return;
+    }
+    let raf;
+    let lastTime = performance.now();
+    const tick = (now) => {
+      const dt = (now - lastTime) / 16.67;
+      lastTime = now;
+      const current = visibleRef.current;
+      const diff2 = target - current;
+      if (diff2 < 0.5) {
+        visibleRef.current = target;
+        setSliceEnd(target);
+        return;
+      }
+      const step = Math.max(1, diff2 * lerp * dt);
+      visibleRef.current = Math.min(current + step, target);
+      const next = Math.floor(visibleRef.current);
+      setSliceEnd((prev) => prev !== next ? next : prev);
+      raf = requestAnimationFrame(tick);
+    };
+    raf = requestAnimationFrame(tick);
+    return () => cancelAnimationFrame(raf);
+  }, [text.length, lerp]);
+  return text.slice(0, sliceEnd);
+}
+export {
+  TBar,
+  TBlank,
+  TBox,
+  TButton,
+  TCode,
+  TDiff,
+  THStack,
+  THtml,
+  TJson,
+  TLayout,
+  TLine,
+  TList,
+  TMarkdown,
+  TRaw,
+  TSeparator,
+  TSpan,
+  TSpark,
+  TStatusbar,
+  TTab,
+  TTable,
+  TTabs,
+  TTree,
+  TVStack,
+  TermDocument,
+  TermThemeProvider,
+  render_default as TermUI,
+  badge,
+  bar,
+  blank,
+  box,
+  builtinThemes,
+  code,
+  dark,
+  defaultThemeSpec,
+  diff,
+  fromDocument,
+  fromHtml,
+  fromJson,
+  fromJsonNode,
+  fromMarkdown,
+  hl,
+  hstack,
+  isTableLine,
+  light,
+  lines,
+  list,
+  pad,
+  padLine,
+  parseThemeSpec,
+  preserveTableTag,
+  renderTermReact,
+  resolveTheme,
+  resolveThemeMode,
+  separator,
+  spark,
+  statusbar,
+  table,
+  tabs,
+  themeToCssVars,
+  tokenColor,
+  tokenize,
+  tree,
+  useSpinner,
+  useStreamingText,
+  useTermTheme,
+  useTermWidth,
+  useTick,
+  validateThemeSpec,
+  vstack
+};
+//# sourceMappingURL=index.js.map