@simonklee/opentui-tex 0.2.0

package/dist/index.js

@@ -0,0 +1,1379 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tex-renderable.ts
+import {
+  BoxRenderable,
+  ImageRenderable,
+  TextRenderable
+} from "@opentui/core";
+import stringWidth3 from "string-width";
+
+// src/math-layout.ts
+import stringWidth from "string-width";
+var CELL_LIMIT = 16384;
+var superscript = {
+  "0": "⁰",
+  "1": "¹",
+  "2": "²",
+  "3": "³",
+  "4": "⁴",
+  "5": "⁵",
+  "6": "⁶",
+  "7": "⁷",
+  "8": "⁸",
+  "9": "⁹",
+  "+": "⁺",
+  "-": "⁻",
+  "=": "⁼",
+  "(": "⁽",
+  ")": "⁾",
+  n: "ⁿ",
+  i: "ⁱ"
+};
+var subscript = {
+  "0": "₀",
+  "1": "₁",
+  "2": "₂",
+  "3": "₃",
+  "4": "₄",
+  "5": "₅",
+  "6": "₆",
+  "7": "₇",
+  "8": "₈",
+  "9": "₉",
+  "+": "₊",
+  "-": "₋",
+  "=": "₌",
+  "(": "₍",
+  ")": "₎",
+  a: "ₐ",
+  e: "ₑ",
+  h: "ₕ",
+  i: "ᵢ",
+  j: "ⱼ",
+  k: "ₖ",
+  l: "ₗ",
+  m: "ₘ",
+  n: "ₙ",
+  o: "ₒ",
+  p: "ₚ",
+  r: "ᵣ",
+  s: "ₛ",
+  t: "ₜ",
+  u: "ᵤ",
+  v: "ᵥ",
+  x: "ₓ"
+};
+function layoutMath(node, displayMode) {
+  return layout(node, displayMode);
+}
+function boxToString(box, widthMax, heightMax) {
+  const lines = [];
+  for (let y = 0;y < Math.min(box.height, heightMax); y++) {
+    let line = "";
+    let width = 0;
+    for (let x = 0;x < box.width && width < widthMax; x++) {
+      const value = box.cells[y][x];
+      if (!value) {
+        line += " ";
+        width++;
+        continue;
+      }
+      const cellWidth = stringWidth(value);
+      if (cellWidth > widthMax)
+        throw new Error(`Unicode glyph exceeds the ${widthMax}-column TeX width`);
+      if (width + cellWidth > widthMax)
+        break;
+      line += value;
+      width += cellWidth;
+      x += cellWidth - 1;
+    }
+    lines.push(line.trimEnd());
+  }
+  return lines.join(`
+`).trimEnd();
+}
+function layout(node, display) {
+  switch (node.type) {
+    case "row":
+      return layoutRow(node.body, display);
+    case "symbol":
+    case "text":
+    case "operator":
+      return textBox(node.value);
+    case "space":
+      return blank(node.width, 1, 0);
+    case "fraction":
+      return fraction(layout(node.numerator, display), layout(node.denominator, display), node.bar);
+    case "root":
+      return root(layout(node.body, display), node.index ? layout(node.index, display) : undefined);
+    case "scripts":
+      return scripts(node, display);
+    case "delimited":
+      return delimited(node.left, layout(node.body, display), node.right);
+    case "matrix":
+      return matrix(node.rows, node.environment, display);
+    case "accent":
+      return accent(node.accent, layout(node.body, display));
+    case "overunder":
+      return overUnder(layout(node.base, display), node.over ? layout(node.over, display) : undefined, node.under ? layout(node.under, display) : undefined);
+  }
+}
+function layoutRow(nodes, display) {
+  const boxes = [];
+  let previous;
+  for (let index = 0;index < nodes.length; index++) {
+    const role = normalizedRole(roleOf(nodes[index]), previous, nextRole(nodes, index + 1));
+    if (needsSpace(previous, role, boxes.length))
+      boxes.push(blank(1, 1, 0));
+    boxes.push(layout(nodes[index], display));
+    if (nodes[index].type !== "space")
+      previous = role ?? "ordinary";
+  }
+  return hpack(boxes);
+}
+function fraction(top, bottom, bar) {
+  const width = Math.max(top.width, bottom.width) + 2;
+  const result = blank(width, top.height + bottom.height + 1, top.height);
+  overlay(result, top, Math.floor((width - top.width) / 2), 0);
+  if (bar)
+    horizontal(result, top.height, width, "─");
+  overlay(result, bottom, Math.floor((width - bottom.width) / 2), top.height + 1);
+  return result;
+}
+function root(body, index) {
+  const indexWidth = index ? Math.max(0, index.width - 1) : 0;
+  const bodyX = indexWidth + 2;
+  const result = blank(bodyX + body.width, body.height + 1, body.baseline + 1);
+  set(result, bodyX - 1, 0, "╭");
+  for (let x = bodyX;x < result.width; x++)
+    set(result, x, 0, "─");
+  set(result, bodyX - 2, result.baseline, "√");
+  overlay(result, body, bodyX, 1);
+  if (index)
+    overlay(result, index, 0, 0);
+  return result;
+}
+function scripts(node, display) {
+  const base = layout(node.base, display);
+  const supText = node.superscript ? simpleText(node.superscript) : undefined;
+  const subText = node.subscript ? simpleText(node.subscript) : undefined;
+  const limits = node.base.type === "operator" && node.base.limits && display;
+  if (!limits) {
+    const mappedSup = supText === undefined ? undefined : mapScript(supText, superscript);
+    const mappedSub = subText === undefined ? undefined : mapScript(subText, subscript);
+    if ((!node.superscript || mappedSup !== undefined) && (!node.subscript || mappedSub !== undefined)) {
+      return hpack([base, textBox((mappedSup ?? "") + (mappedSub ?? ""))]);
+    }
+  }
+  if (limits)
+    return overUnder(base, node.superscript ? layout(node.superscript, display) : undefined, node.subscript ? layout(node.subscript, display) : undefined);
+  const sup = node.superscript ? layout(node.superscript, display) : undefined;
+  const sub = node.subscript ? layout(node.subscript, display) : undefined;
+  const sideWidth = Math.max(sup?.width ?? 0, sub?.width ?? 0);
+  const result = blank(base.width + sideWidth, (sup?.height ?? 0) + base.height + (sub?.height ?? 0), (sup?.height ?? 0) + base.baseline);
+  overlay(result, base, 0, sup?.height ?? 0);
+  if (sup)
+    overlay(result, sup, base.width, 0);
+  if (sub)
+    overlay(result, sub, base.width, (sup?.height ?? 0) + base.height);
+  return result;
+}
+function overUnder(base, over, under) {
+  const width = Math.max(base.width, over?.width ?? 0, under?.width ?? 0);
+  const result = blank(width, (over?.height ?? 0) + base.height + (under?.height ?? 0), (over?.height ?? 0) + base.baseline);
+  if (over)
+    overlay(result, over, Math.floor((width - over.width) / 2), 0);
+  overlay(result, base, Math.floor((width - base.width) / 2), over?.height ?? 0);
+  if (under)
+    overlay(result, under, Math.floor((width - under.width) / 2), (over?.height ?? 0) + base.height);
+  return result;
+}
+function delimited(left, body, right) {
+  return hpack([delimiter(left, body.height, body.baseline, true), body, delimiter(right, body.height, body.baseline, false)]);
+}
+function matrix(rows, environment, display) {
+  const cells = rows.map((row) => row.map((node) => layout(node, display)));
+  const columns = Math.max(0, ...cells.map((row) => row.length));
+  const widths = Array.from({ length: columns }, (_, x) => Math.max(0, ...cells.map((row) => row[x]?.width ?? 0)));
+  const ascents = cells.map((row) => Math.max(0, ...row.map((cell) => cell.baseline)));
+  const descents = cells.map((row) => Math.max(0, ...row.map((cell) => cell.height - cell.baseline - 1)));
+  const heights = ascents.map((value, y2) => value + descents[y2] + 1);
+  const gap = environment === "cases" || environment === "aligned" || environment === "align" ? 2 : 1;
+  const width = widths.reduce((sum, value) => sum + value, 0) + Math.max(0, columns - 1) * gap;
+  const height = Math.max(1, heights.reduce((sum, value) => sum + value, 0));
+  const result = blank(width, height, Math.floor(height / 2));
+  let y = 0;
+  for (let rowIndex = 0;rowIndex < cells.length; rowIndex++) {
+    let x = 0;
+    for (let column = 0;column < columns; column++) {
+      const cell = cells[rowIndex][column];
+      if (cell) {
+        const aligned = environment === "aligned" || environment === "align" || environment === "cases";
+        const offset = aligned ? column % 2 === 0 ? widths[column] - cell.width : 0 : Math.floor((widths[column] - cell.width) / 2);
+        overlay(result, cell, x + offset, y + ascents[rowIndex] - cell.baseline);
+      }
+      x += widths[column] + gap;
+    }
+    y += heights[rowIndex];
+  }
+  const pair = matrixDelimiters(environment);
+  return pair ? delimited(pair[0], result, pair[1]) : result;
+}
+function accent(kind, body) {
+  if (kind === "underline") {
+    const result2 = blank(body.width, body.height + 1, body.baseline);
+    overlay(result2, body, 0, 0);
+    horizontal(result2, body.height, body.width, "─");
+    return result2;
+  }
+  const result = blank(body.width, body.height + 1, body.baseline + 1);
+  overlay(result, body, 0, 1);
+  const mark = kind === "hat" || kind === "widehat" ? body.width === 1 ? "^" : "⌢" : kind === "bar" || kind === "overline" ? "─" : kind === "vec" ? "→" : kind === "tilde" ? "~" : kind === "dot" ? "·" : "¨";
+  if (kind === "bar" || kind === "overline")
+    horizontal(result, 0, body.width, mark);
+  else
+    set(result, Math.max(0, Math.floor((body.width - stringWidth(mark)) / 2)), 0, mark);
+  return result;
+}
+function delimiter(value, height, baseline, left) {
+  if (!value)
+    return blank(0, height, baseline);
+  if (height === 1)
+    return textBox(value);
+  const glyphs = delimiterGlyphs(value, left);
+  const result = blank(Math.max(...glyphs.map((glyph) => stringWidth(glyph))), height, baseline);
+  for (let y = 0;y < height; y++)
+    set(result, 0, y, y === 0 ? glyphs[0] : y === height - 1 ? glyphs[2] : glyphs[1]);
+  if ((value === "{" || value === "}") && height >= 3)
+    set(result, 0, Math.floor(height / 2), left ? "⎨" : "⎬");
+  return result;
+}
+function delimiterGlyphs(value, left) {
+  if (value === "(")
+    return ["⎛", "⎜", "⎝"];
+  if (value === ")")
+    return ["⎞", "⎟", "⎠"];
+  if (value === "[")
+    return ["⎡", "⎢", "⎣"];
+  if (value === "]")
+    return ["⎤", "⎥", "⎦"];
+  if (value === "{")
+    return ["⎧", "⎪", "⎩"];
+  if (value === "}")
+    return ["⎫", "⎪", "⎭"];
+  if (value === "⟨")
+    return ["/", "│", "\\"];
+  if (value === "⟩")
+    return ["\\", "│", "/"];
+  if (value === "⌊" || value === "⌋")
+    return ["│", "│", value];
+  if (value === "⌈" || value === "⌉")
+    return [value, "│", "│"];
+  return [value, value, value];
+}
+function matrixDelimiters(value) {
+  return value === "pmatrix" ? ["(", ")"] : value === "bmatrix" ? ["[", "]"] : value === "Bmatrix" ? ["{", "}"] : value === "vmatrix" ? ["│", "│"] : value === "Vmatrix" ? ["║", "║"] : value === "cases" ? ["{", ""] : undefined;
+}
+function textBox(text) {
+  const parts = typeof Intl.Segmenter === "function" ? [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)].map((part) => part.segment) : [...text];
+  const result = blank(parts.reduce((sum, part) => sum + stringWidth(part), 0), 1, 0);
+  let x = 0;
+  for (const part of parts) {
+    set(result, x, 0, part);
+    x += stringWidth(part);
+  }
+  return result;
+}
+function hpack(boxes) {
+  if (!boxes.length)
+    return blank(0, 1, 0);
+  const ascent = Math.max(...boxes.map((box) => box.baseline));
+  const descent = Math.max(...boxes.map((box) => box.height - box.baseline - 1));
+  const result = blank(boxes.reduce((sum, box) => sum + box.width, 0), ascent + descent + 1, ascent);
+  let x = 0;
+  for (const box of boxes) {
+    overlay(result, box, x, ascent - box.baseline);
+    x += box.width;
+  }
+  return result;
+}
+function blank(width, height, baseline) {
+  width = Math.max(0, width);
+  height = Math.max(1, height);
+  if (width * height > CELL_LIMIT)
+    throw new Error(`Unicode TeX output exceeds ${CELL_LIMIT} characters`);
+  return { width, height, baseline: Math.max(0, baseline), cells: Array.from({ length: height }, () => Array(width)) };
+}
+function overlay(target, source, x, y) {
+  for (let sy = 0;sy < source.height; sy++)
+    for (let sx = 0;sx < source.width; sx++)
+      if (source.cells[sy][sx])
+        target.cells[y + sy][x + sx] = source.cells[sy][sx];
+}
+function set(box, x, y, value) {
+  if (x >= 0 && y >= 0 && x < box.width && y < box.height)
+    box.cells[y][x] = value;
+}
+function horizontal(box, y, width, value) {
+  for (let x = 0;x < width; x++)
+    set(box, x, y, value);
+}
+function simpleText(node) {
+  if (node.type === "symbol" || node.type === "text" || node.type === "operator")
+    return node.value;
+  if (node.type === "row") {
+    const values = node.body.map(simpleText);
+    if (values.every((value) => value !== undefined))
+      return values.join("");
+  }
+  return;
+}
+function mapScript(value, table) {
+  let result = "";
+  for (const char of value) {
+    if (!table[char])
+      return;
+    result += table[char];
+  }
+  return result;
+}
+function roleOf(node) {
+  if (node.type === "symbol")
+    return node.role;
+  if (node.type === "operator" || node.type === "fraction" || node.type === "root" || node.type === "matrix")
+    return "operator";
+  if (node.type === "scripts")
+    return roleOf(node.base);
+  return;
+}
+function nextRole(nodes, start) {
+  for (let i = start;i < nodes.length; i++)
+    if (nodes[i].type !== "space")
+      return roleOf(nodes[i]) ?? "ordinary";
+  return;
+}
+function needsSpace(previous, current, count) {
+  return count > 0 && previous !== "opening" && previous !== "punctuation" && current !== "closing" && current !== "punctuation" && (previous === "binary" || previous === "relation" || previous === "operator" || current === "binary" || current === "relation" || current === "operator");
+}
+function normalizedRole(role, previous, next) {
+  return role === "binary" && (!previous || ["binary", "relation", "operator", "punctuation", "opening"].includes(previous) || !next || ["binary", "relation", "punctuation", "closing"].includes(next)) ? "ordinary" : role;
+}
+
+// src/math-symbols.ts
+var ordinary = {
+  alpha: "α",
+  beta: "β",
+  gamma: "γ",
+  delta: "δ",
+  epsilon: "ε",
+  varepsilon: "ϵ",
+  zeta: "ζ",
+  eta: "η",
+  theta: "θ",
+  vartheta: "ϑ",
+  iota: "ι",
+  kappa: "κ",
+  lambda: "λ",
+  mu: "μ",
+  nu: "ν",
+  xi: "ξ",
+  omicron: "ο",
+  pi: "π",
+  varpi: "ϖ",
+  rho: "ρ",
+  varrho: "ϱ",
+  sigma: "σ",
+  varsigma: "ς",
+  tau: "τ",
+  upsilon: "υ",
+  phi: "φ",
+  varphi: "ϕ",
+  chi: "χ",
+  psi: "ψ",
+  omega: "ω",
+  Gamma: "Γ",
+  Delta: "Δ",
+  Theta: "Θ",
+  Lambda: "Λ",
+  Xi: "Ξ",
+  Pi: "Π",
+  Sigma: "Σ",
+  Upsilon: "Υ",
+  Phi: "Φ",
+  Psi: "Ψ",
+  Omega: "Ω",
+  infty: "∞",
+  partial: "∂",
+  nabla: "∇",
+  emptyset: "∅",
+  varnothing: "∅",
+  forall: "∀",
+  exists: "∃",
+  neg: "¬",
+  angle: "∠",
+  degree: "°",
+  prime: "′",
+  hbar: "ℏ",
+  ell: "ℓ",
+  Re: "ℜ",
+  Im: "ℑ",
+  aleph: "ℵ",
+  top: "⊤",
+  bot: "⊥",
+  checkmark: "✓"
+};
+var binary = {
+  pm: "±",
+  mp: "∓",
+  times: "×",
+  div: "÷",
+  cdot: "·",
+  ast: "∗",
+  star: "⋆",
+  circ: "∘",
+  bullet: "•",
+  oplus: "⊕",
+  ominus: "⊖",
+  otimes: "⊗",
+  oslash: "⊘",
+  odot: "⊙",
+  cap: "∩",
+  cup: "∪",
+  land: "∧",
+  wedge: "∧",
+  lor: "∨",
+  vee: "∨",
+  setminus: "∖"
+};
+var relation = {
+  ne: "≠",
+  neq: "≠",
+  equiv: "≡",
+  approx: "≈",
+  sim: "∼",
+  simeq: "≃",
+  cong: "≅",
+  propto: "∝",
+  le: "≤",
+  leq: "≤",
+  ge: "≥",
+  geq: "≥",
+  ll: "≪",
+  gg: "≫",
+  in: "∈",
+  notin: "∉",
+  ni: "∋",
+  subset: "⊂",
+  supset: "⊃",
+  subseteq: "⊆",
+  supseteq: "⊇",
+  parallel: "∥",
+  perp: "⊥",
+  vdash: "⊢",
+  models: "⊨",
+  leftarrow: "←",
+  gets: "←",
+  rightarrow: "→",
+  to: "→",
+  leftrightarrow: "↔",
+  Leftarrow: "⇐",
+  Rightarrow: "⇒",
+  Leftrightarrow: "⇔",
+  mapsto: "↦",
+  longleftarrow: "⟵",
+  longrightarrow: "⟶",
+  longleftrightarrow: "⟷",
+  uparrow: "↑",
+  downarrow: "↓",
+  updownarrow: "↕"
+};
+var punctuation = { ldots: "…", dots: "…", cdots: "⋯", vdots: "⋮", ddots: "⋱", colon: ":" };
+function definitions(values, role) {
+  return Object.fromEntries(Object.entries(values).map(([name, value]) => [name, { value, role }]));
+}
+var symbols = {
+  ...definitions(ordinary, "ordinary"),
+  ...definitions(binary, "binary"),
+  ...definitions(relation, "relation"),
+  ...definitions(punctuation, "punctuation")
+};
+var operators = {
+  sum: "∑",
+  prod: "∏",
+  coprod: "∐",
+  int: "∫",
+  iint: "∬",
+  iiint: "∭",
+  oint: "∮",
+  bigcap: "⋂",
+  bigcup: "⋃",
+  bigvee: "⋁",
+  bigwedge: "⋀"
+};
+var namedOperators = new Set(["sin", "cos", "tan", "log", "ln", "exp", "lim", "min", "max", "sup", "inf", "det", "gcd", "ker"]);
+var delimiters = {
+  "(": "(",
+  ")": ")",
+  "[": "[",
+  "]": "]",
+  "{": "{",
+  "}": "}",
+  "|": "│",
+  "\\|": "║",
+  lbrace: "{",
+  rbrace: "}",
+  vert: "│",
+  Vert: "║",
+  langle: "⟨",
+  rangle: "⟩",
+  lfloor: "⌊",
+  rfloor: "⌋",
+  lceil: "⌈",
+  rceil: "⌉",
+  ".": ""
+};
+var accents = {
+  hat: "hat",
+  widehat: "widehat",
+  bar: "bar",
+  overline: "overline",
+  underline: "underline",
+  vec: "vec",
+  tilde: "tilde",
+  widetilde: "tilde",
+  dot: "dot",
+  ddot: "ddot"
+};
+var spacing = { ",": 0, ":": 1, ";": 1, "!": 0, quad: 2, qquad: 4, enspace: 1, thinspace: 0 };
+
+// src/math-parser.ts
+var MAX_NESTING_DEPTH = 256;
+var environments = new Set([
+  "matrix",
+  "pmatrix",
+  "bmatrix",
+  "Bmatrix",
+  "vmatrix",
+  "Vmatrix",
+  "cases",
+  "aligned",
+  "align",
+  "gathered",
+  "gather",
+  "smallmatrix",
+  "array"
+]);
+function parseMath(source) {
+  return new Parser(source).parse();
+}
+function parseMathIncomplete(source) {
+  return new Parser(source, true).parse();
+}
+
+class Parser {
+  source;
+  incomplete;
+  offset = 0;
+  depth = 0;
+  constructor(source, incomplete = false) {
+    this.source = source;
+    this.incomplete = incomplete;
+  }
+  parse() {
+    const result = row(this.parseRow());
+    this.skipWhitespace();
+    if (!this.done())
+      this.fail(this.peek() === "}" ? "Unexpected closing TeX group" : `Unexpected "${this.peek()}"`);
+    return result;
+  }
+  parseRow(stop) {
+    const body = [];
+    while (!this.done()) {
+      this.skipWhitespace();
+      if (this.done() || stop?.() || this.peek() === "}")
+        break;
+      const char = this.peek();
+      if (char === "^" || char === "_") {
+        this.offset++;
+        const argument = this.parseArgument();
+        const previous = body.pop() ?? row([]);
+        const scripts2 = previous.type === "scripts" ? previous : { type: "scripts", base: previous };
+        if (char === "^")
+          scripts2.superscript = argument;
+        else
+          scripts2.subscript = argument;
+        body.push(scripts2);
+      } else {
+        body.push(this.parseAtom());
+      }
+    }
+    return body;
+  }
+  parseAtom() {
+    this.depth++;
+    if (this.depth > MAX_NESTING_DEPTH)
+      this.fail(`TeX nesting exceeds the ${MAX_NESTING_DEPTH}-level limit`);
+    try {
+      if (this.peek() === "{")
+        return this.parseGroup();
+      if (this.peek() === "\\")
+        return this.parseCommand();
+      if (this.peek() === "~") {
+        this.offset++;
+        return { type: "space", width: 1 };
+      }
+      const value = [...this.source.slice(this.offset)][0] ?? "";
+      this.offset += value.length;
+      return { type: "symbol", value, role: inferRole(value) };
+    } finally {
+      this.depth--;
+    }
+  }
+  parseCommand() {
+    const start = this.offset;
+    const command = this.readCommand();
+    if (command === "\\")
+      return row([]);
+    if (command === "begin")
+      return this.parseEnvironment();
+    if (command === "end")
+      this.fail("Unexpected \\end", start);
+    if (["frac", "dfrac", "tfrac", "cfrac"].includes(command)) {
+      return { type: "fraction", numerator: this.parseArgument(), denominator: this.parseArgument(), bar: true };
+    }
+    if (["binom", "dbinom", "tbinom"].includes(command)) {
+      return { type: "delimited", left: "(", body: { type: "fraction", numerator: this.parseArgument(), denominator: this.parseArgument(), bar: false }, right: ")" };
+    }
+    if (command === "sqrt") {
+      const index = this.optionalArgument();
+      return { type: "root", body: this.parseArgument(), ...index ? { index } : {} };
+    }
+    if (command === "left")
+      return this.parseLeftRight();
+    if (command === "right")
+      this.fail("Unexpected \\right", start);
+    if (command === "middle")
+      return { type: "symbol", value: this.readDelimiter() };
+    if (command in accents)
+      return { type: "accent", accent: accents[command], body: this.parseArgument() };
+    if (["mathrm", "mathbf", "mathit", "mathsf", "mathtt", "mathbb", "mathcal", "mathfrak"].includes(command)) {
+      return this.parseArgument();
+    }
+    if (["text", "textrm", "mbox"].includes(command)) {
+      return { type: "text", value: this.readRawGroup().replace(/\\([{}%#$&_])/g, "$1").replaceAll("~", " ") };
+    }
+    if (command === "operatorname")
+      return { type: "operator", value: this.readRawGroup(), limits: false };
+    if (command === "overset" || command === "stackrel") {
+      const over = this.parseArgument();
+      return { type: "overunder", over, base: this.parseArgument() };
+    }
+    if (command === "underset") {
+      const under = this.parseArgument();
+      return { type: "overunder", under, base: this.parseArgument() };
+    }
+    if (command === "not") {
+      const target = this.parseArgument();
+      if (target.type === "symbol")
+        return { ...target, value: negate(target.value) };
+      return { type: "row", body: [{ type: "symbol", value: "¬" }, target] };
+    }
+    if (["limits", "nolimits", "displaystyle", "textstyle", "scriptstyle"].includes(command))
+      return row([]);
+    if (/^(?:big|Big|bigg|Bigg)[lrm]?$/.test(command))
+      return { type: "symbol", value: this.readDelimiter() };
+    if (command in spacing)
+      return { type: "space", width: spacing[command] };
+    if (command in symbols)
+      return { type: "symbol", ...symbols[command] };
+    if (command in operators)
+      return { type: "operator", value: operators[command], limits: !command.includes("int") };
+    if (namedOperators.has(command))
+      return { type: "operator", value: command, limits: ["lim", "min", "max"].includes(command) };
+    if (command in delimiters)
+      return { type: "symbol", value: delimiters[command] };
+    if (["{", "}", "%", "#", "$", "&", "_", "backslash"].includes(command))
+      return { type: "symbol", value: command === "backslash" ? "\\" : command };
+    return { type: "text", value: `\\${command}` };
+  }
+  parseEnvironment() {
+    const rawName = this.readRawGroup();
+    const name = rawName.replace(/\*$/, "");
+    if (!environments.has(name))
+      this.fail(`Unsupported TeX environment: ${rawName}`);
+    if (name === "array") {
+      this.skipWhitespace();
+      if (this.peek() === "{")
+        this.readRawGroup();
+    }
+    const rows = [];
+    let cells = [];
+    while (!this.done()) {
+      this.skipWhitespace();
+      if (this.done())
+        break;
+      if (this.isEnd(rawName)) {
+        this.offset += `\\end{${rawName}}`.length;
+        if (cells.length || !rows.length)
+          rows.push(cells);
+        return { type: "matrix", rows, environment: name };
+      }
+      const start = this.offset;
+      cells.push(row(this.parseRow(() => this.peek() === "&" || this.source.startsWith("\\\\", this.offset) || this.source.startsWith("\\end{", this.offset))));
+      if (this.offset === start)
+        this.fail(`Unexpected token in ${rawName}`);
+      this.skipWhitespace();
+      if (this.peek() === "&") {
+        this.offset++;
+        this.skipWhitespace();
+        if (this.incomplete && this.done())
+          cells.push(placeholder());
+        continue;
+      }
+      if (this.source.startsWith("\\\\", this.offset)) {
+        this.offset += 2;
+        this.skipOptionalRowSpacing();
+        rows.push(cells);
+        cells = [];
+        continue;
+      }
+    }
+    if (this.incomplete) {
+      if (cells.length)
+        rows.push(cells);
+      else if (!rows.length)
+        rows.push([placeholder()]);
+      return { type: "matrix", rows, environment: name };
+    }
+    this.fail(`Unclosed TeX environment: ${rawName}`);
+  }
+  parseLeftRight() {
+    const left = this.readDelimiter();
+    const nodes = this.parseRow(() => this.isCommand("right"));
+    const body = row(nodes);
+    if (!this.isCommand("right")) {
+      if (this.incomplete && this.done())
+        return { type: "delimited", left, body: nodes.length ? body : placeholder(), right: "" };
+      this.fail("Missing \\right");
+    }
+    this.readCommand();
+    return { type: "delimited", left, body, right: this.readDelimiter() };
+  }
+  parseArgument() {
+    this.skipWhitespace();
+    if (this.done()) {
+      if (this.incomplete)
+        return placeholder();
+      this.fail("Expected a TeX argument");
+    }
+    if (this.peek() === "}")
+      this.fail("Unexpected closing TeX group");
+    return this.peek() === "{" ? this.parseGroup() : this.parseAtom();
+  }
+  parseGroup() {
+    this.expect("{");
+    const nodes = this.parseRow();
+    const result = row(nodes);
+    if (this.peek() !== "}") {
+      if (this.incomplete && this.done())
+        return nodes.length ? result : placeholder();
+      this.fail("Unclosed TeX group");
+    }
+    this.offset++;
+    return result;
+  }
+  optionalArgument() {
+    this.skipWhitespace();
+    if (this.peek() !== "[")
+      return;
+    this.offset++;
+    const nodes = this.parseRow(() => this.peek() === "]");
+    const result = row(nodes);
+    if (this.peek() !== "]") {
+      if (this.incomplete && this.done())
+        return nodes.length ? result : placeholder();
+      this.fail('Expected "]"');
+    }
+    this.offset++;
+    return result;
+  }
+  readRawGroup() {
+    this.skipWhitespace();
+    this.expect("{");
+    const start = this.offset;
+    let depth = 1;
+    while (!this.done()) {
+      const char = this.source[this.offset++];
+      if (char === "{" && !this.escaped(this.offset - 1))
+        depth++;
+      else if (char === "}" && !this.escaped(this.offset - 1) && --depth === 0)
+        return this.source.slice(start, this.offset - 1);
+      if (depth > MAX_NESTING_DEPTH)
+        this.fail(`TeX nesting exceeds the ${MAX_NESTING_DEPTH}-level limit`);
+    }
+    if (this.incomplete)
+      return this.source.slice(start) || "□";
+    this.fail("Unclosed TeX group", start);
+  }
+  readCommand() {
+    this.expect("\\");
+    if (this.done())
+      return "\\";
+    if (!/[A-Za-z@]/.test(this.peek()))
+      return this.source[this.offset++];
+    const start = this.offset;
+    while (/[A-Za-z@]/.test(this.peek()))
+      this.offset++;
+    const result = this.source.slice(start, this.offset);
+    if (this.peek() === " ")
+      this.offset++;
+    return result;
+  }
+  readDelimiter() {
+    this.skipWhitespace();
+    if (this.done()) {
+      if (this.incomplete)
+        return "";
+      this.fail("Expected a TeX delimiter");
+    }
+    if (this.peek() === "}")
+      this.fail("Unexpected closing TeX group");
+    const token = this.peek() === "\\" ? this.readCommand() : this.source[this.offset++] ?? "";
+    return delimiters[token] ?? delimiters[`\\${token}`] ?? token;
+  }
+  skipOptionalRowSpacing() {
+    this.skipWhitespace();
+    if (this.peek() !== "[")
+      return;
+    while (!this.done() && this.source[this.offset++] !== "]") {}
+  }
+  isEnd(name) {
+    return this.source.startsWith(`\\end{${name}}`, this.offset);
+  }
+  isCommand(name) {
+    if (!this.source.startsWith(`\\${name}`, this.offset))
+      return false;
+    return !/[A-Za-z@]/.test(this.source[this.offset + name.length + 1] ?? "");
+  }
+  skipWhitespace() {
+    while (/\s/.test(this.peek()))
+      this.offset++;
+  }
+  done() {
+    return this.offset >= this.source.length;
+  }
+  peek() {
+    return this.source[this.offset] ?? "";
+  }
+  expect(value) {
+    if (!this.source.startsWith(value, this.offset))
+      this.fail(`Expected "${value}"`);
+    this.offset += value.length;
+  }
+  escaped(index) {
+    let count = 0;
+    while (index > count && this.source[index - count - 1] === "\\")
+      count++;
+    return count % 2 === 1;
+  }
+  fail(message, offset = this.offset) {
+    throw new Error(`${message} at offset ${offset}`);
+  }
+}
+function row(body) {
+  return body.length === 1 ? body[0] : { type: "row", body };
+}
+function placeholder() {
+  return { type: "symbol", value: "□" };
+}
+function inferRole(value) {
+  if ("+-*/×÷±∓".includes(value))
+    return "binary";
+  if ("=<>≤≥≠≈∈∉⊂⊃".includes(value))
+    return "relation";
+  if (",;:".includes(value))
+    return "punctuation";
+  if ("([{".includes(value))
+    return "opening";
+  if (")]}".includes(value))
+    return "closing";
+  return "ordinary";
+}
+function negate(value) {
+  return { "=": "≠", "<": "≮", ">": "≯", "≤": "≰", "≥": "≱", "∈": "∉", "∋": "∌", "⊂": "⊄", "⊃": "⊅" }[value] ?? `${value}̸`;
+}
+
+// src/unicode-tex-backend.ts
+import stringWidth2 from "string-width";
+var UNICODE_TEX_SOURCE_LENGTH_MAX = 4096;
+var OUTPUT_LENGTH_MAX = 16384;
+
+class UnicodeTexBackend {
+  renderSync(request) {
+    return renderUnicode(request, false);
+  }
+  async render(request) {
+    return this.renderSync(request);
+  }
+}
+function renderIncompleteUnicode(request) {
+  return renderUnicode(request, true);
+}
+function renderUnicode(request, incomplete) {
+  assertNotAborted(request.signal);
+  const sourceBytes = Buffer.byteLength(request.formula, "utf8");
+  if (sourceBytes === 0 || sourceBytes > UNICODE_TEX_SOURCE_LENGTH_MAX) {
+    throw new Error(`TeX formula must be between 1 and ${UNICODE_TEX_SOURCE_LENGTH_MAX} UTF-8 bytes`);
+  }
+  if (!Number.isFinite(request.widthMax) || !Number.isFinite(request.heightMax) || request.widthMax < 1 || request.heightMax < 1) {
+    throw new Error("Unicode TeX dimensions must be finite positive numbers");
+  }
+  const widthMax = Math.floor(request.widthMax);
+  const heightMax = Math.floor(request.heightMax);
+  const node = incomplete ? parseMathIncomplete(request.formula) : parseMath(request.formula);
+  const text = boxToString(layoutMath(node, request.display), widthMax, heightMax);
+  assertNotAborted(request.signal);
+  if (!text)
+    throw new Error("TeX formula produced no Unicode output");
+  if (text.length > OUTPUT_LENGTH_MAX)
+    throw new Error(`Unicode TeX output exceeds ${OUTPUT_LENGTH_MAX} characters`);
+  const lines = text.split(`
+`);
+  return {
+    kind: "unicode",
+    text,
+    columns: Math.max(1, ...lines.map((line) => stringWidth2(line))),
+    rows: lines.length
+  };
+}
+function assertNotAborted(signal) {
+  if (signal.aborted)
+    throw signal.reason ?? new Error("Unicode render cancelled");
+}
+
+// src/tex-renderable.ts
+var NATIVE_SUPERSAMPLE = 4;
+var RESIZE_AREA_THRESHOLD = 1.3;
+var DEFAULT_PREVIEW_BACKEND = new UnicodeTexBackend;
+function dimensionMax(value) {
+  if (!Number.isFinite(value))
+    throw new Error("TeX dimensions must be finite");
+  return Math.max(1, Math.floor(value));
+}
+function measureTex(width, height, display, widthMax, heightMax) {
+  let rows = Math.max(1, Math.ceil(height / NATIVE_SUPERSAMPLE / (display ? 10 : 12)));
+  let columns = Math.max(1, Math.round(width / height * rows * 2));
+  if (columns > widthMax) {
+    rows = Math.max(1, Math.round(rows * widthMax / columns));
+    columns = widthMax;
+  }
+  if (rows > heightMax) {
+    columns = Math.max(1, Math.round(columns * heightMax / rows));
+    rows = heightMax;
+  }
+  return { columns, rows };
+}
+function fitImageToPlacement(imageWidth, imageHeight, columns, rows, cellPxWidth, cellPxHeight) {
+  const boxWidth = Math.max(1, Math.floor(columns * cellPxWidth));
+  const boxHeight = Math.max(1, Math.floor(rows * cellPxHeight));
+  const scale = Math.min(boxWidth / imageWidth, boxHeight / imageHeight);
+  if (scale >= 1)
+    return null;
+  const width = Math.max(1, Math.round(imageWidth * scale));
+  const height = Math.max(1, Math.round(imageHeight * scale));
+  return imageWidth * imageHeight > width * height * RESIZE_AREA_THRESHOLD ? { width, height } : null;
+}
+
+class TexRenderable extends BoxRenderable {
+  ready;
+  backend;
+  fallback;
+  widthMax;
+  heightMax;
+  autoWidth;
+  autoHeight;
+  trackExplicitDimensions = false;
+  currentDimensions = { columns: 1, rows: 1 };
+  imageOptions;
+  onError;
+  _formula;
+  _foreground;
+  _background;
+  _display;
+  _streaming;
+  controller = null;
+  committedOutput = null;
+  constructor(context, options) {
+    const {
+      formula,
+      display = false,
+      foreground,
+      background,
+      widthMax = 80,
+      heightMax = 24,
+      backend,
+      fallback = "message",
+      imageOptions,
+      onError,
+      streaming = false,
+      ...boxOptions
+    } = options;
+    super(context, {
+      shouldFill: false,
+      ...boxOptions,
+      width: options.width ?? 1,
+      height: options.height ?? 1
+    });
+    this._formula = formula;
+    this._foreground = foreground;
+    this._background = background;
+    this._streaming = streaming;
+    this._display = display;
+    this.backend = backend;
+    this.fallback = fallback;
+    this.widthMax = dimensionMax(widthMax);
+    this.heightMax = dimensionMax(heightMax);
+    this.autoWidth = options.width === undefined;
+    this.autoHeight = options.height === undefined;
+    this.trackExplicitDimensions = true;
+    this.imageOptions = imageOptions;
+    this.onError = onError;
+    this.ready = this.update(formula, foreground, background, display);
+  }
+  get formula() {
+    return this._formula;
+  }
+  set formula(value) {
+    this.setSnapshot(value, this._foreground, this._background);
+  }
+  get display() {
+    return this._display;
+  }
+  set display(value) {
+    this.setSnapshot(this._formula, this._foreground, this._background, value === true);
+  }
+  get width() {
+    return super.width;
+  }
+  set width(value) {
+    if (this.trackExplicitDimensions && (value === "auto" || value == null)) {
+      this.autoWidth = true;
+      super.width = this.currentDimensions.columns;
+      return;
+    }
+    super.width = value;
+    if (this.trackExplicitDimensions)
+      this.autoWidth = false;
+  }
+  get height() {
+    return super.height;
+  }
+  set height(value) {
+    if (this.trackExplicitDimensions && (value === "auto" || value == null)) {
+      this.autoHeight = true;
+      super.height = this.currentDimensions.rows;
+      return;
+    }
+    super.height = value;
+    if (this.trackExplicitDimensions)
+      this.autoHeight = false;
+  }
+  get streaming() {
+    return this._streaming;
+  }
+  set streaming(value) {
+    if (value === this._streaming)
+      return;
+    this._streaming = value;
+    if (value) {
+      this.controller?.abort();
+      this.controller = null;
+      this.ready = Promise.resolve();
+      return;
+    }
+    this.ready = this.update(this._formula, this._foreground, this._background, this._display);
+  }
+  setColors(foreground, background) {
+    this.setSnapshot(this._formula, foreground, background);
+  }
+  setSnapshot(formula, foreground, background, display = this._display) {
+    if (formula === this._formula && foreground === this._foreground && background === this._background && display === this._display)
+      return;
+    this.ready = this.update(formula, foreground, background, display);
+  }
+  async whenReady() {
+    while (!this.isDestroyed) {
+      const pending = this.ready;
+      const controller = this.controller;
+      let onAbort;
+      const changed = new Promise((resolve) => {
+        if (controller) {
+          onAbort = () => resolve();
+          controller.signal.addEventListener("abort", onAbort, { once: true });
+        }
+      });
+      try {
+        await Promise.race([pending, changed]);
+      } catch (error) {
+        if (pending === this.ready)
+          throw error;
+        continue;
+      } finally {
+        if (onAbort)
+          controller?.signal.removeEventListener("abort", onAbort);
+      }
+      if (pending === this.ready)
+        return;
+    }
+  }
+  async update(formula, foreground, background, display) {
+    this.controller?.abort();
+    this._formula = formula;
+    this._foreground = foreground;
+    this._background = background;
+    this._display = display;
+    if (!formula) {
+      this.clearOutput();
+      if (!this._streaming) {
+        disposeOutput(this.committedOutput);
+        this.committedOutput = null;
+      }
+      this.controller = null;
+      return;
+    }
+    const controller = new AbortController;
+    this.controller = controller;
+    const request = {
+      formula,
+      display,
+      foreground,
+      background,
+      widthMax: this.widthMax,
+      heightMax: this.heightMax,
+      signal: controller.signal
+    };
+    if (this._streaming) {
+      this.applyOutput(this.previewOutput(request));
+      return;
+    }
+    let unicodeOutput = null;
+    try {
+      unicodeOutput = DEFAULT_PREVIEW_BACKEND.renderSync(request);
+      this.applyOutput(unicodeOutput);
+    } catch {}
+    try {
+      const output = await this.backend.render(request);
+      if (controller.signal.aborted || this.isDestroyed) {
+        disposeOutput(output);
+        return;
+      }
+      if (this.fallback === "retain") {
+        const previous = this.committedOutput;
+        try {
+          this.applyOutput(output);
+        } catch (error) {
+          disposeOutput(output);
+          throw error;
+        }
+        this.committedOutput = output;
+        disposeOutput(previous);
+      } else {
+        try {
+          this.applyOutput(output);
+        } finally {
+          disposeOutput(output);
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted && !this.isDestroyed) {
+        if (this.fallback === "retain" && this.committedOutput)
+          this.applyOutput(this.committedOutput);
+        else if (this.fallback === "message" || this.fallback === "unicode" && !unicodeOutput) {
+          const message = error instanceof Error ? error.message : String(error);
+          const text = fitLine(`[TeX error: ${message}]`, this.widthMax);
+          this.applyOutput({ kind: "unicode", text, columns: Math.max(1, stringWidth3(text)), rows: 1 });
+        }
+        this.onError?.(error);
+        if (this.fallback === "throw")
+          throw error;
+      }
+    }
+  }
+  previewOutput(request) {
+    if (request.formula.length <= UNICODE_TEX_SOURCE_LENGTH_MAX && Buffer.byteLength(request.formula, "utf8") <= UNICODE_TEX_SOURCE_LENGTH_MAX) {
+      try {
+        return DEFAULT_PREVIEW_BACKEND.renderSync(request);
+      } catch {
+        try {
+          return renderIncompleteUnicode(request);
+        } catch {}
+      }
+    }
+    return rawSourceOutput(request.formula, this.widthMax, this.heightMax);
+  }
+  clearOutput() {
+    for (const existing of this.getChildren())
+      existing.destroyRecursively();
+    this.currentDimensions = { columns: 1, rows: 1 };
+    if (this.autoWidth)
+      super.width = 1;
+    if (this.autoHeight)
+      super.height = 1;
+  }
+  applyOutput(output) {
+    const dimensions = output.kind === "image" ? measureTex(output.image.width, output.image.height, this.display, this.widthMax, this.heightMax) : { columns: Math.min(this.widthMax, output.columns), rows: Math.min(this.heightMax, output.rows) };
+    const child = output.kind === "image" ? this.createImageChild(output.image, dimensions) : new TextRenderable(this._ctx, {
+      content: output.text,
+      fg: this._foreground,
+      bg: this._background,
+      width: "100%",
+      height: "100%"
+    });
+    let added = false;
+    try {
+      this.clearOutput();
+      this.currentDimensions = dimensions;
+      if (this.autoWidth)
+        super.width = Math.max(1, dimensions.columns);
+      if (this.autoHeight)
+        super.height = Math.max(1, dimensions.rows);
+      this.add(child);
+      added = true;
+    } finally {
+      if (!added)
+        child.destroyRecursively();
+    }
+  }
+  createImageChild(image, dimensions) {
+    const resized = this.resizeToPlacement(image, dimensions);
+    const source = resized ?? image;
+    if (this._ctx.capabilities?.kitty_graphics) {
+      try {
+        source.ensureEncodedPng();
+      } catch {}
+    }
+    try {
+      return new ImageRenderable(this._ctx, {
+        protocol: "auto",
+        fit: "fit",
+        ...this.imageOptions,
+        source,
+        width: "100%",
+        height: "100%"
+      });
+    } finally {
+      resized?.dispose();
+    }
+  }
+  resizeToPlacement(image, dimensions) {
+    const { terminalWidth, terminalHeight, resolution } = this._ctx;
+    if (!terminalWidth || !terminalHeight || !resolution?.width || !resolution.height)
+      return null;
+    const target = fitImageToPlacement(image.width, image.height, dimensions.columns, dimensions.rows, resolution.width / terminalWidth, resolution.height / terminalHeight);
+    if (!target)
+      return null;
+    try {
+      return image.resize({ ...target, kernel: "area" });
+    } catch {
+      return null;
+    }
+  }
+  destroySelf() {
+    this.controller?.abort();
+    this.controller = null;
+    disposeOutput(this.committedOutput);
+    this.committedOutput = null;
+    super.destroySelf();
+  }
+}
+function disposeOutput(output) {
+  if (output?.kind === "image")
+    output.image.dispose();
+}
+function fitLine(value, widthMax) {
+  let output = "";
+  for (const character of value) {
+    if (stringWidth3(output + character) > widthMax)
+      break;
+    output += character;
+  }
+  return output || "?";
+}
+function rawSourceOutput(source, widthMax, heightMax) {
+  const cellLimit = Math.min(16384, widthMax * heightMax);
+  const tailStart = Math.max(0, source.length - cellLimit * 2);
+  let tail = source.slice(tailStart);
+  if (tailStart > 0) {
+    const restart = safeRawRestart(tail);
+    tail = restart < 0 ? "" : tail.slice(restart);
+  }
+  const tailGraphemes = graphemes(tail);
+  const lines = [];
+  let line = "";
+  let width = 0;
+  for (const sourceGrapheme of tailGraphemes) {
+    const visible2 = [...sourceGrapheme].map(visibleSourceCharacter).join("");
+    const segments = visible2 === sourceGrapheme ? [visible2] : [...visible2];
+    for (const character of segments) {
+      const characterWidth = stringWidth3(character);
+      if (characterWidth > widthMax) {
+        if (line)
+          lines.push(line);
+        lines.push("?");
+        line = "";
+        width = 0;
+      } else if (width + characterWidth > widthMax) {
+        lines.push(line);
+        line = character;
+        width = characterWidth;
+      } else {
+        line += character;
+        width += characterWidth;
+      }
+    }
+  }
+  if (line)
+    lines.push(line);
+  const visibleLines = lines.slice(-heightMax);
+  const widths = visibleLines.map((value) => stringWidth3(value));
+  const visible = visibleLines.some((value, index) => /\S/u.test(value) && widths[index] > 0);
+  const text = visible ? visibleLines.join(`
+`) : "?";
+  return {
+    kind: "unicode",
+    text,
+    columns: visible ? Math.max(1, ...widths) : 1,
+    rows: visible ? Math.max(1, visibleLines.length) : 1
+  };
+}
+function graphemes(value) {
+  return typeof Intl.Segmenter === "function" ? [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(value)].map((part) => part.segment) : [...value];
+}
+function safeRawRestart(value) {
+  for (let index = 1;index < value.length; index++) {
+    if (isPrintableAscii(value.charCodeAt(index - 1)) && isPrintableAscii(value.charCodeAt(index)))
+      return index;
+  }
+  return -1;
+}
+function isPrintableAscii(value) {
+  return value >= 32 && value <= 126;
+}
+function visibleSourceCharacter(character) {
+  if (character === `
+`)
+    return "\\n";
+  if (character === "\r")
+    return "\\r";
+  if (character === "\t")
+    return "\\t";
+  const code = character.codePointAt(0);
+  return code < 32 || code >= 127 && code <= 159 ? `\\x${code.toString(16).padStart(2, "0")}` : character;
+}
+export {
+  measureTex,
+  UnicodeTexBackend,
+  TexRenderable
+};