@simonklee/opentui-tex 0.2.0 → 0.3.1

package/dist/chunk-gbwc618x.js

@@ -0,0 +1,1797 @@
+// src/tex-renderable.ts
+import {
+  BoxRenderable,
+  ImageRenderable,
+  TextRenderable,
+  StyledText,
+  createTextAttributes,
+  parseColor,
+  Yoga
+} from "@opentui/core";
+import stringWidth3 from "string-width";
+
+// src/math-graphemes.ts
+var graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+// 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, { display: displayMode });
+}
+function boxToOutput(box, widthMax, heightMax) {
+  const spans = [];
+  for (let y = 0;y < Math.min(box.height, heightMax); y++) {
+    const line = [];
+    let width = 0;
+    for (let x = 0;x < box.width && width < widthMax; x++) {
+      const value = box.cells[y][x];
+      const cellWidth = value ? stringWidth(value.char) : 0;
+      if (cellWidth === 0) {
+        appendSpan(line, " ");
+        width++;
+        continue;
+      }
+      if (cellWidth > widthMax)
+        throw new Error(`Unicode glyph exceeds the ${widthMax}-column TeX width`);
+      if (width + cellWidth > widthMax)
+        break;
+      appendSpan(line, value.char, value.style);
+      width += cellWidth;
+      x += cellWidth - 1;
+    }
+    trimSpans(line);
+    if (y)
+      appendSpan(spans, `
+`);
+    for (const span of line)
+      appendSpan(spans, span.text, span);
+  }
+  trimSpans(spans);
+  const text = spans.map((span) => span.text).join("");
+  return spans.some((span) => span.color !== undefined || span.bold !== undefined || span.italic !== undefined) ? { text, spans } : { text };
+}
+function appendSpan(spans, text, style) {
+  const last = spans.at(-1);
+  if (last && last.color === style?.color && last.bold === style?.bold && last.italic === style?.italic) {
+    last.text += text;
+    return;
+  }
+  spans.push({ ...style, text });
+}
+function trimSpans(spans) {
+  while (spans.length) {
+    const last = spans.at(-1);
+    last.text = last.text.trimEnd();
+    if (last.text)
+      return;
+    spans.pop();
+  }
+}
+function layout(node, context) {
+  switch (node.type) {
+    case "row":
+      return layoutRow(node.body, context);
+    case "symbol":
+    case "text":
+    case "operator":
+      return textBox(applyVariant(node.value, context.variant), context.style);
+    case "space":
+      return blank(node.width, 1, 0);
+    case "fraction":
+      return fraction(layout(node.numerator, context), layout(node.denominator, context), node.bar, node.numeratorAlign, context.style);
+    case "root":
+      return root(layout(node.body, context), node.index ? layout(node.index, context) : undefined, context.style);
+    case "scripts":
+      return scripts(node, context);
+    case "delimited":
+      return delimited(node.left, layout(node.body, context), node.right, context.style);
+    case "matrix":
+      return matrix(node, context);
+    case "accent":
+      return accent(node.accent, layout(node.body, context), context.style);
+    case "brace":
+      return brace(layout(node.body, context), node.position, context.style);
+    case "variant":
+      return layout(node.body, { ...context, variant: node.variant, style: node.variant === "bold" ? { ...context.style, bold: true } : node.variant === "italic" ? { ...context.style, italic: true } : context.style });
+    case "color":
+      return layout(node.body, { ...context, style: { ...context.style, color: node.color } });
+    case "overunder":
+      return overUnder(layout(node.base, context), node.over ? layout(node.over, context) : undefined, node.under ? layout(node.under, context) : undefined);
+  }
+}
+function layoutRow(nodes, context) {
+  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], context));
+    if (nodes[index].type !== "space")
+      previous = role ?? "ordinary";
+  }
+  return hpack(boxes);
+}
+function fraction(top, bottom, bar, align, style) {
+  const width = Math.max(top.width, bottom.width) + 2;
+  const result = blank(width, top.height + bottom.height + 1, top.height);
+  overlay(result, top, align === "left" ? 1 : align === "right" ? width - top.width - 1 : Math.floor((width - top.width) / 2), 0);
+  if (bar)
+    horizontal(result, top.height, width, "─", style);
+  overlay(result, bottom, Math.floor((width - bottom.width) / 2), top.height + 1);
+  return result;
+}
+function root(body, index, style) {
+  const indexWidth = index ? Math.max(0, index.width - 1) : 0;
+  const bodyX = indexWidth + 2;
+  const bodyY = index?.height ?? 1;
+  const result = blank(bodyX + body.width, body.height + bodyY, body.baseline + bodyY);
+  set(result, bodyX - 1, bodyY - 1, "╭", style);
+  for (let x = bodyX;x < result.width; x++)
+    set(result, x, bodyY - 1, "─", style);
+  set(result, bodyX - 2, result.baseline, "√", style);
+  overlay(result, body, bodyX, bodyY);
+  if (index)
+    overlay(result, index, 0, 0);
+  return result;
+}
+function scripts(node, context) {
+  const base = layout(node.base, context);
+  const sup = node.superscript ? layout(node.superscript, context) : undefined;
+  const sub = node.subscript ? layout(node.subscript, context) : undefined;
+  const supText = node.superscript ? simpleText(node.superscript) : undefined;
+  const subText = node.subscript ? simpleText(node.subscript) : undefined;
+  let target = node.base;
+  while (target.type === "variant" || target.type === "color" || target.type === "scripts") {
+    target = target.type === "scripts" ? target.base : target.body;
+  }
+  const limits = target.type === "operator" && (target.limits === true || target.limits === "display" && context.display);
+  if (limits || target.type === "brace")
+    return overUnder(base, sup, sub);
+  if (base.height === 1) {
+    const mappedSup = supText === undefined ? undefined : mapScript(supText, superscript);
+    const mappedSub = subText === undefined ? undefined : mapScript(subText, subscript);
+    if ((!sup?.width || mappedSup !== undefined) && (!sub?.width || mappedSub !== undefined)) {
+      return hpack([base, textBox((mappedSup ?? "") + (mappedSub ?? ""), context.style)]);
+    }
+  }
+  const sideWidth = Math.max(sup?.width ?? 0, sub?.width ?? 0);
+  const topHeight = sup?.width ? sup.height : 0;
+  const bottomHeight = sub?.width ? sub.height : 0;
+  const result = blank(base.width + sideWidth, topHeight + base.height + bottomHeight, topHeight + base.baseline);
+  overlay(result, base, 0, topHeight);
+  if (sup)
+    overlay(result, sup, base.width, 0);
+  if (sub)
+    overlay(result, sub, base.width, topHeight + base.height);
+  return result;
+}
+function overUnder(base, over, under) {
+  const width = Math.max(base.width, over?.width ?? 0, under?.width ?? 0);
+  const overHeight = over?.width ? over.height : 0;
+  const underHeight = under?.width ? under.height : 0;
+  const result = blank(width, overHeight + base.height + underHeight, overHeight + base.baseline);
+  if (over)
+    overlay(result, over, Math.floor((width - over.width) / 2), 0);
+  overlay(result, base, Math.floor((width - base.width) / 2), overHeight);
+  if (under)
+    overlay(result, under, Math.floor((width - under.width) / 2), overHeight + base.height);
+  return result;
+}
+function delimited(left, body, right, style) {
+  return hpack([delimiter(left, body.height, body.baseline, true, style), body, delimiter(right, body.height, body.baseline, false, style)]);
+}
+function matrix(node, context) {
+  const cells = node.rows.map((row) => row.map((cell) => layout(cell, context)));
+  const alignments = node.columns?.match(/[lcr]/g);
+  const rules = node.columns?.split(/[lcr]/).map((rule) => rule.length) ?? [];
+  const columns = Math.max(alignments?.length ?? 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 aligned = node.environment === "aligned" || node.environment === "align";
+  const gap = node.environment === "cases" || aligned ? 2 : 1;
+  const gaps = Array.from({ length: columns + 1 }, (_, boundary) => {
+    const edge = boundary === 0 || boundary === columns;
+    return rules[boundary] ? rules[boundary] + (edge ? 1 : 2) : edge ? 0 : gap;
+  });
+  const width = widths.reduce((sum, value) => sum + value, 0) + gaps.reduce((sum, value) => sum + value, 0);
+  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 = gaps[0];
+    for (let column = 0;column < columns; column++) {
+      const cell = cells[rowIndex][column];
+      if (cell) {
+        const alignment = alignments?.[column] ?? (node.environment === "cases" ? "l" : aligned ? column % 2 === 0 ? "r" : "l" : "c");
+        const offset = alignment === "l" ? 0 : alignment === "r" ? widths[column] - cell.width : Math.floor((widths[column] - cell.width) / 2);
+        overlay(result, cell, x + offset, y + ascents[rowIndex] - cell.baseline);
+      }
+      x += widths[column] + gaps[column + 1];
+    }
+    y += heights[rowIndex];
+  }
+  let boundaryX = 0;
+  for (let boundary = 0;boundary <= columns; boundary++) {
+    for (let rule = 0;rule < (rules[boundary] ?? 0); rule++) {
+      for (let row = 0;row < height; row++)
+        set(result, boundaryX + (boundary === 0 ? 0 : 1) + rule, row, "│", context.style);
+    }
+    boundaryX += gaps[boundary] + (widths[boundary] ?? 0);
+  }
+  const pair = matrixDelimiters(node.environment);
+  return pair ? delimited(pair[0], result, pair[1], context.style) : result;
+}
+function brace(body, position, style) {
+  const over = position === "over";
+  const width = Math.max(3, body.width);
+  const result = blank(width, body.height + 1, body.baseline + (over ? 1 : 0));
+  const y = over ? 0 : body.height;
+  overlay(result, body, Math.floor((width - body.width) / 2), over ? 1 : 0);
+  horizontal(result, y, width, "─", style);
+  set(result, 0, y, over ? "╭" : "╰", style);
+  set(result, width - 1, y, over ? "╮" : "╯", style);
+  set(result, Math.floor((width - 1) / 2), y, over ? "┴" : "┬", style);
+  return result;
+}
+function accent(kind, body, style) {
+  if (kind === "underline") {
+    const result2 = blank(body.width, body.height + 1, body.baseline);
+    overlay(result2, body, 0, 0);
+    horizontal(result2, body.height, body.width, "─", style);
+    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, style);
+  else
+    set(result, Math.max(0, Math.floor((body.width - stringWidth(mark)) / 2)), 0, mark, style);
+  return result;
+}
+function delimiter(value, height, baseline, left, style) {
+  const base = value.replace(/\p{Mark}+$/u, "");
+  if (!base)
+    return blank(0, height, baseline);
+  if (height === 1)
+    return textBox(value, style);
+  const glyphs = delimiterGlyphs(base, left);
+  const suffix = value.slice(base.length);
+  const result = blank(Math.max(...glyphs.map((glyph) => stringWidth(glyph + suffix))), height, baseline);
+  for (let y = 0;y < height; y++)
+    set(result, 0, y, y === 0 ? glyphs[0] : y === height - 1 ? glyphs[2] : glyphs[1], style);
+  if ((base === "{" || base === "}") && height >= 3)
+    set(result, 0, Math.floor(height / 2), left ? "⎨" : "⎬", style);
+  if (suffix)
+    set(result, 0, baseline, result.cells[baseline][0].char + suffix, style);
+  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, style) {
+  const parts = Array.from(graphemeSegmenter.segment(text), (part) => part.segment);
+  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, style);
+    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, char, style) {
+  if (x >= 0 && y >= 0 && x < box.width && y < box.height)
+    box.cells[y][x] = style ? { char, style } : { char };
+}
+function horizontal(box, y, width, value, style) {
+  for (let x = 0;x < width; x++)
+    set(box, x, y, value, style);
+}
+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);
+  if (node.type === "variant" || node.type === "color")
+    return roleOf(node.body);
+  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;
+}
+function applyVariant(value, variant) {
+  if (!variant || variant === "normal" || variant === "bold" || variant === "italic")
+    return value;
+  const exceptions = {
+    "double-struck": { C: "ℂ", H: "ℍ", N: "ℕ", P: "ℙ", Q: "ℚ", R: "ℝ", Z: "ℤ" },
+    script: { B: "ℬ", E: "ℰ", F: "ℱ", H: "ℋ", I: "ℐ", L: "ℒ", M: "ℳ", R: "ℛ", e: "ℯ", g: "ℊ", o: "ℴ" },
+    fraktur: { C: "ℭ", H: "ℌ", I: "ℑ", R: "ℜ", Z: "ℨ" }
+  };
+  const ranges = {
+    "double-struck": [120120, 120146, 120792],
+    script: [119964, 119990],
+    fraktur: [120068, 120094],
+    sans: [120224, 120250, 120802],
+    monospace: [120432, 120458, 120822]
+  };
+  const range = ranges[variant];
+  return Array.from(value).map((char) => {
+    const exception = exceptions[variant]?.[char];
+    if (exception)
+      return exception;
+    const code = char.codePointAt(0);
+    if (code >= 65 && code <= 90)
+      return String.fromCodePoint(range[0] + code - 65);
+    if (code >= 97 && code <= 122)
+      return String.fromCodePoint(range[1] + code - 97);
+    if (range[2] !== undefined && code >= 48 && code <= 57)
+      return String.fromCodePoint(range[2] + code - 48);
+    return char;
+  }).join("");
+}
+
+// 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: "✓",
+  imath: "ı",
+  jmath: "ȷ",
+  beth: "ℶ",
+  gimel: "ℷ",
+  daleth: "ℸ",
+  measuredangle: "∡",
+  triangle: "△",
+  square: "□",
+  lozenge: "◊",
+  nexists: "∄",
+  lnot: "¬",
+  backprime: "‵",
+  clubsuit: "♣",
+  diamondsuit: "♢",
+  heartsuit: "♡",
+  spadesuit: "♠"
+};
+var binary = {
+  pm: "±",
+  mp: "∓",
+  times: "×",
+  div: "÷",
+  cdot: "·",
+  ast: "∗",
+  star: "⋆",
+  circ: "∘",
+  bullet: "•",
+  oplus: "⊕",
+  ominus: "⊖",
+  otimes: "⊗",
+  oslash: "⊘",
+  odot: "⊙",
+  cap: "∩",
+  cup: "∪",
+  land: "∧",
+  wedge: "∧",
+  lor: "∨",
+  vee: "∨",
+  setminus: "∖",
+  uplus: "⊎",
+  sqcap: "⊓",
+  sqcup: "⊔",
+  wr: "≀",
+  diamond: "⋄",
+  bigtriangleup: "△",
+  bigtriangledown: "▽",
+  triangleleft: "◁",
+  triangleright: "▷"
+};
+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: "↕",
+  equals: "=",
+  asymp: "≍",
+  lt: "<",
+  gt: ">",
+  prec: "≺",
+  succ: "≻",
+  preceq: "⪯",
+  succeq: "⪰",
+  sqsubset: "⊏",
+  sqsupset: "⊐",
+  sqsubseteq: "⊑",
+  sqsupseteq: "⊒",
+  owns: "∋",
+  dashv: "⊣",
+  mid: "∣",
+  smile: "⌣",
+  frown: "⌢",
+  hookleftarrow: "↩",
+  hookrightarrow: "↪",
+  leftharpoonup: "↼",
+  leftharpoondown: "↽",
+  rightharpoonup: "⇀",
+  rightharpoondown: "⇁",
+  rightleftharpoons: "⇌",
+  Longleftarrow: "⟸",
+  Longrightarrow: "⟹",
+  Longleftrightarrow: "⟺",
+  longmapsto: "⟼",
+  Uparrow: "⇑",
+  Downarrow: "⇓",
+  Updownarrow: "⇕",
+  nearrow: "↗",
+  searrow: "↘",
+  swarrow: "↙",
+  nwarrow: "↖"
+};
+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: "⋀",
+  bigoplus: "⨁",
+  bigotimes: "⨂",
+  bigodot: "⨀"
+};
+var namedOperators = new Set([
+  "arccos",
+  "arcsin",
+  "arctan",
+  "arg",
+  "cos",
+  "cosh",
+  "cot",
+  "coth",
+  "csc",
+  "deg",
+  "det",
+  "dim",
+  "exp",
+  "gcd",
+  "hom",
+  "inf",
+  "ker",
+  "lg",
+  "lim",
+  "liminf",
+  "limsup",
+  "ln",
+  "log",
+  "max",
+  "min",
+  "mod",
+  "Pr",
+  "sec",
+  "sin",
+  "sinh",
+  "sup",
+  "tan",
+  "tanh"
+]);
+var delimiters = {
+  "(": "(",
+  ")": ")",
+  "[": "[",
+  "]": "]",
+  "{": "{",
+  "}": "}",
+  "|": "│",
+  "\\|": "║",
+  lbrace: "{",
+  rbrace: "}",
+  vert: "│",
+  Vert: "║",
+  langle: "⟨",
+  rangle: "⟩",
+  lfloor: "⌊",
+  rfloor: "⌋",
+  lceil: "⌈",
+  rceil: "⌉",
+  lvert: "│",
+  rvert: "│",
+  lVert: "║",
+  rVert: "║",
+  "\\{": "{",
+  "\\}": "}",
+  "/": "/",
+  "<": "<",
+  ">": ">",
+  backslash: "\\",
+  ".": ""
+};
+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"
+]);
+var variants = {
+  mathrm: "normal",
+  textrm: "normal",
+  mathnormal: "normal",
+  mathbf: "bold",
+  boldsymbol: "bold",
+  bm: "bold",
+  mathit: "italic",
+  mathsf: "sans",
+  mathtt: "monospace",
+  mathbb: "double-struck",
+  mathcal: "script",
+  mathscr: "script",
+  mathfrak: "fraktur"
+};
+function parseMath(source, options = {}) {
+  return new Parser(source, false, options.strict ?? false).parse();
+}
+function parseMathIncomplete(source, options = {}) {
+  return new Parser(source, true, options.strict ?? false).parse();
+}
+
+class Parser {
+  source;
+  incomplete;
+  strict;
+  offset = 0;
+  depth = 0;
+  graphemes;
+  constructor(source, incomplete, strict) {
+    this.source = source;
+    this.incomplete = incomplete;
+    this.strict = strict;
+    this.graphemes = graphemeSegmenter.segment(source);
+  }
+  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 {
+        const atom = this.parseAtom(body.at(-1), stop);
+        if (atom)
+          body.push(atom);
+      }
+    }
+    return body;
+  }
+  parseAtom(previous, stop) {
+    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() === "\\") {
+        const atom = this.parseCommand(previous, stop);
+        const value2 = atom && unwrapStyle(atom);
+        if (value2 && "value" in value2)
+          value2.value += this.readCombiningSuffix();
+        return atom;
+      }
+      if (this.peek() === "~") {
+        this.offset++;
+        return { type: "space", width: 1 };
+      }
+      const value = this.readLiteral();
+      return { type: "symbol", value, role: inferRole(value[0]) };
+    } finally {
+      this.depth--;
+    }
+  }
+  parseCommand(previous, stop) {
+    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)) {
+      this.skipWhitespace();
+      const alignment = command === "cfrac" && this.peek() === "[" ? /^\[([lr]?)(\]|$)/.exec(this.source.slice(this.offset)) : undefined;
+      if (alignment === null || alignment && !alignment[2] && (!this.incomplete || this.offset + alignment[0].length !== this.source.length)) {
+        this.fail("Unsupported \\cfrac alignment; expected [l], [r], or []");
+      }
+      if (alignment)
+        this.offset += alignment[0].length;
+      return {
+        type: "fraction",
+        numerator: this.parseArgument(),
+        denominator: this.parseArgument(),
+        bar: true,
+        ...alignment?.[1] ? { numeratorAlign: alignment[1] === "l" ? "left" : "right" } : {}
+      };
+    }
+    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 (Object.hasOwn(accents, command))
+      return { type: "accent", accent: accents[command], body: this.parseArgument() };
+    if (Object.hasOwn(variants, command)) {
+      return { type: "variant", variant: variants[command], body: command === "textrm" ? { type: "text", value: this.readTextGroup() } : this.parseArgument() };
+    }
+    if (command === "text" || command === "mbox")
+      return { type: "text", value: this.readTextGroup() };
+    if (command === "operatorname") {
+      const limits = this.peek() === "*";
+      if (limits)
+        this.offset++;
+      return { type: "operator", value: this.readTextGroup(), limits };
+    }
+    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 === "overbrace" || command === "underbrace") {
+      return { type: "brace", body: this.parseArgument(), position: command === "overbrace" ? "over" : "under" };
+    }
+    if (command === "textcolor" || command === "color") {
+      const color = this.readRawGroup().value;
+      return { type: "color", color, body: command === "textcolor" ? this.parseArgument() : row(this.parseRow(stop)) };
+    }
+    if (command === "not") {
+      const target = this.parseArgument();
+      const symbol = unwrapStyle(target);
+      if (symbol.type === "symbol") {
+        symbol.value = negate(symbol.value);
+        return target;
+      }
+      return { type: "row", body: [{ type: "symbol", value: "¬" }, target] };
+    }
+    if (command === "pmod") {
+      return { type: "row", body: [{ type: "space", width: 1 }, { type: "text", value: "(mod " }, this.parseArgument(), { type: "text", value: ")" }] };
+    }
+    if (command === "mod" || command === "bmod")
+      return { type: "operator", value: "mod", limits: false };
+    if (command === "displaylines") {
+      this.skipWhitespace();
+      if (this.incomplete && this.done())
+        return { type: "matrix", environment: "gathered", rows: [[placeholder()]] };
+      this.expect("{");
+      return this.parseMatrix("gathered", "}");
+    }
+    if (command === "limits" || command === "nolimits") {
+      let base = previous;
+      while (base?.type === "variant" || base?.type === "color" || base?.type === "scripts") {
+        base = base.type === "scripts" ? base.base : base.body;
+      }
+      if (base?.type === "operator")
+        base.limits = command === "limits";
+      return;
+    }
+    if (["displaystyle", "textstyle", "scriptstyle", "scriptscriptstyle"].includes(command))
+      return;
+    if (/^(?:big|Big|bigg|Bigg)[lrm]?$/.test(command))
+      return { type: "symbol", value: this.readDelimiter() };
+    if (Object.hasOwn(spacing, command))
+      return { type: "space", width: spacing[command] };
+    if (Object.hasOwn(symbols, command))
+      return { type: "symbol", ...symbols[command] };
+    if (Object.hasOwn(operators, command))
+      return { type: "operator", value: operators[command], limits: command.includes("int") ? false : "display" };
+    if (namedOperators.has(command))
+      return { type: "operator", value: command, limits: command.startsWith("lim") || ["min", "max"].includes(command) ? "display" : false };
+    if (Object.hasOwn(delimiters, command))
+      return { type: "symbol", value: delimiters[`\\${command}`] ?? delimiters[command] };
+    if (["{", "}", "%", "#", "$", "&", "_", "backslash"].includes(command))
+      return { type: "symbol", value: command === "backslash" ? "\\" : command };
+    if (command === " ")
+      return { type: "space", width: 1 };
+    if (this.strict)
+      this.fail(`Unsupported command \\${command}`, start);
+    return { type: "text", value: `\\${command}` };
+  }
+  parseEnvironment() {
+    const rawName = this.readRawGroup().value;
+    const name = rawName.replace(/\*$/, "");
+    if (!environments.has(name))
+      this.fail(`Unsupported TeX environment: ${rawName}`);
+    return this.parseMatrix(name, `\\end{${rawName}}`, name === "array" ? this.readArrayColumns() : undefined);
+  }
+  parseMatrix(environment, end, columns) {
+    const rows = [];
+    let cells = [];
+    while (!this.done()) {
+      this.skipWhitespace();
+      if (this.done())
+        break;
+      if (this.source.startsWith(end, this.offset) && !cells.length)
+        break;
+      const start = this.offset;
+      cells.push(row(this.parseRow(() => this.peek() === "&" || this.source.startsWith("\\\\", this.offset) || this.source.startsWith(end, this.offset) || this.isCommand("end"))));
+      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.source.startsWith(end, this.offset))
+        break;
+      if (this.offset === start)
+        this.fail(`Unexpected token in ${environment}`);
+    }
+    const closed = this.source.startsWith(end, this.offset);
+    if (!closed && !(this.incomplete && this.done()))
+      this.fail(`Unclosed TeX environment: ${environment}`);
+    if (closed)
+      this.offset += end.length;
+    if (!closed && !rows.length && !cells.length)
+      cells.push(placeholder());
+    if (cells.length || !rows.length)
+      rows.push(cells);
+    return { type: "matrix", rows, environment, ...columns !== undefined ? { columns } : {} };
+  }
+  readArrayColumns() {
+    const group = this.readRawGroup();
+    const columns = group.value.replace(/\s/g, "");
+    if (/[^lcr|]/.test(columns) || !/[lcr]/.test(columns) && group.closed) {
+      this.fail("Unsupported array columns; expected l, c, r, and |");
+    }
+    return columns;
+  }
+  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() {
+    while (true) {
+      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");
+      const argument = this.parseAtom();
+      if (argument)
+        return argument;
+    }
+  }
+  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;
+  }
+  readTextGroup() {
+    const group = this.readRawGroup(true);
+    return (group.value || (group.closed ? "" : "□")).replace(/\\([A-Za-z@]+|.)/g, (match, command) => {
+      if ("{}%#$&_ ".includes(command))
+        return command;
+      if (command === "textbackslash")
+        return "\\";
+      if (command === "!")
+        return "";
+      if (Object.hasOwn(spacing, command))
+        return " ".repeat(Math.max(1, spacing[command]));
+      return match;
+    }).replaceAll("~", " ");
+  }
+  readRawGroup(preserveComments = false) {
+    this.skipWhitespace();
+    if (this.incomplete && this.done())
+      return { value: "", closed: false };
+    this.expect("{");
+    let start = this.offset;
+    const parts = [];
+    let depth = 1;
+    while (!this.done()) {
+      const char = this.source[this.offset++];
+      if (char === "%" && !preserveComments && !this.escaped(this.offset - 1)) {
+        parts.push(this.source.slice(start, this.offset - 1));
+        while (!this.done() && !/[\r\n]/.test(this.peek()))
+          this.offset++;
+        if (this.peek() === "\r")
+          this.offset++;
+        if (this.peek() === `
+`)
+          this.offset++;
+        start = this.offset;
+        continue;
+      }
+      if (char === "{" && !this.escaped(this.offset - 1))
+        depth++;
+      else if (char === "}" && !this.escaped(this.offset - 1) && --depth === 0)
+        return { value: parts.join("") + this.source.slice(start, this.offset - 1), closed: true };
+      if (depth > MAX_NESTING_DEPTH)
+        this.fail(`TeX nesting exceeds the ${MAX_NESTING_DEPTH}-level limit`);
+    }
+    if (this.incomplete)
+      return { value: parts.join("") + this.source.slice(start), closed: false };
+    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");
+    if (this.peek() === "\\") {
+      const start = this.offset;
+      const command = this.readCommand();
+      if (Object.hasOwn(delimiters, command))
+        return (delimiters[`\\${command}`] ?? delimiters[command]) + this.readCombiningSuffix();
+      if (this.incomplete && this.done() && this.offset === start + 1)
+        return "";
+      if (this.strict)
+        this.fail(`Unsupported delimiter \\${command}`, start);
+      return command + this.readCombiningSuffix();
+    }
+    const token = this.peek();
+    if (Object.hasOwn(delimiters, token)) {
+      this.offset++;
+      return delimiters[token] + this.readCombiningSuffix();
+    }
+    if (this.strict)
+      this.fail(`Unsupported delimiter ${token}`);
+    return this.readLiteral();
+  }
+  readLiteral() {
+    const part = this.graphemes.containing(this.offset);
+    const literal = part.segment.slice(this.offset - part.index);
+    const boundary = literal.search(/[\\{}[\]^_~&%\s]/u);
+    const value = boundary > 0 ? literal.slice(0, boundary) : literal;
+    this.offset += value.length;
+    return value;
+  }
+  readCombiningSuffix() {
+    if (this.done())
+      return "";
+    const part = this.graphemes.containing(this.offset);
+    const suffix = part.segment.slice(this.offset - part.index).match(/^\p{Mark}+/u)?.[0] ?? "";
+    this.offset += suffix.length;
+    return suffix;
+  }
+  skipOptionalRowSpacing() {
+    this.skipWhitespace();
+    if (this.peek() !== "[")
+      return;
+    while (!this.done() && this.source[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 (!this.done()) {
+      if (/\s/.test(this.peek())) {
+        this.offset++;
+        continue;
+      }
+      if (this.peek() !== "%")
+        return;
+      while (!this.done() && !/[\r\n]/.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 unwrapStyle(node) {
+  while (node.type === "variant" || node.type === "color")
+    node = node.body;
+  return node;
+}
+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 options = { strict: request.strict };
+  const node = incomplete ? parseMathIncomplete(request.formula, options) : parseMath(request.formula, options);
+  const output = boxToOutput(layoutMath(node, request.display), widthMax, heightMax);
+  assertNotAborted(request.signal);
+  if (!output.text)
+    throw new Error("TeX formula produced no Unicode output");
+  if (output.text.length > OUTPUT_LENGTH_MAX)
+    throw new Error(`Unicode TeX output exceeds ${OUTPUT_LENGTH_MAX} characters`);
+  const lines = output.text.split(`
+`);
+  return {
+    kind: "unicode",
+    ...output,
+    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;
+var UNICODE_RENDER = UnicodeTexBackend.prototype.render;
+var UNICODE_RENDER_SYNC = UnicodeTexBackend.prototype.renderSync;
+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;
+  strict;
+  widthMax;
+  heightMax;
+  autoWidth;
+  autoHeight;
+  requestedAlignSelf;
+  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,
+      strict = false,
+      ...boxOptions
+    } = options;
+    super(context, {
+      shouldFill: false,
+      ...boxOptions,
+      flexShrink: options.flexShrink ?? (typeof options.width === "string" && typeof options.height === "string" ? 1 : 0),
+      width: options.width ?? "auto",
+      height: options.height ?? "auto"
+    });
+    this._formula = formula;
+    this._foreground = foreground;
+    this._background = background;
+    this._streaming = streaming;
+    this._display = display;
+    this.backend = backend;
+    this.fallback = fallback;
+    this.strict = strict;
+    this.widthMax = dimensionMax(widthMax);
+    this.heightMax = dimensionMax(heightMax);
+    this.autoWidth = options.width == null || options.width === "auto";
+    this.autoHeight = options.height == null || options.height === "auto";
+    this.requestedAlignSelf = this.yogaNode.getAlignSelf();
+    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) {
+    super.width = value ?? "auto";
+    this.autoWidth = value === "auto" || value == null;
+    for (const child of this.getChildren())
+      child.width = this.autoWidth ? this.currentDimensions.columns : "100%";
+  }
+  get height() {
+    return super.height;
+  }
+  set height(value) {
+    super.height = value ?? "auto";
+    this.autoHeight = value === "auto" || value == null;
+    for (const child of this.getChildren())
+      child.height = this.autoHeight ? this.currentDimensions.rows : "100%";
+  }
+  set alignSelf(value) {
+    super.alignSelf = value;
+    this.requestedAlignSelf = this.yogaNode.getAlignSelf();
+  }
+  onLifecyclePass = () => {
+    if (!this.parent)
+      return;
+    const crossAuto = this.parent.primaryAxis === "column" ? this.autoWidth : this.autoHeight;
+    const alignment = this.requestedAlignSelf === Yoga.Align.Auto ? this.parent.getLayoutNode().getAlignItems() : this.requestedAlignSelf;
+    const resolved = crossAuto && alignment === Yoga.Align.Stretch ? Yoga.Align.FlexStart : this.requestedAlignSelf;
+    if (this.yogaNode.getAlignSelf() !== resolved)
+      this.yogaNode.setAlignSelf(resolved);
+    for (const child of this.getChildren()) {
+      const options = child instanceof ImageRenderable ? this.imageOptions : undefined;
+      const node = child.getLayoutNode();
+      const shrink = options?.flexShrink ?? 1;
+      const flexible = shrink > 0 && node.getPositionType() !== Yoga.PositionType.Absolute;
+      node.setFlexShrink(shrink);
+      if (options?.maxWidth === undefined)
+        node.setMaxWidth(this.primaryAxis === "row" && flexible ? undefined : "100%");
+      if (options?.maxHeight === undefined)
+        node.setMaxHeight(this.primaryAxis === "column" && flexible ? undefined : "100%");
+    }
+  };
+  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();
+      this.currentDimensions = { columns: 1, rows: 1 };
+      this.yogaNode.setMeasureFunc(() => ({ width: 1, height: 1 }));
+      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,
+      strict: this.strict
+    };
+    if (this._streaming) {
+      try {
+        this.applyOutput(this.previewOutput(request));
+      } catch {
+        this.applyOutput(rawSourceOutput(formula, this.widthMax, this.heightMax));
+      }
+      return;
+    }
+    let unicodeOutput = null;
+    const synchronousBackend = this.backend instanceof UnicodeTexBackend && this.backend.render === UNICODE_RENDER && this.backend.renderSync === UNICODE_RENDER_SYNC ? this.backend : null;
+    if (!synchronousBackend) {
+      try {
+        const preview = DEFAULT_PREVIEW_BACKEND.renderSync(request);
+        this.applyOutput(preview);
+        unicodeOutput = preview;
+      } catch {}
+    }
+    try {
+      const output = synchronousBackend ? synchronousBackend.renderSync(request) : 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 (synchronousBackend)
+        await Promise.resolve();
+      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();
+  }
+  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.spans ? new StyledText(output.spans.map((span) => ({
+        __isChunk: true,
+        text: span.text,
+        fg: span.color === undefined ? undefined : parseColor(span.color),
+        attributes: createTextAttributes({ bold: span.bold, italic: span.italic })
+      }))) : output.text,
+      fg: this._foreground,
+      bg: this._background,
+      wrapMode: "none",
+      width: this.autoWidth ? dimensions.columns : "100%",
+      height: this.autoHeight ? dimensions.rows : "100%",
+      maxWidth: "100%",
+      maxHeight: "100%"
+    });
+    let added = false;
+    try {
+      this.clearOutput();
+      this.currentDimensions = dimensions;
+      this.yogaNode.unsetMeasureFunc();
+      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",
+        maxWidth: "100%",
+        maxHeight: "100%",
+        ...this.imageOptions,
+        source,
+        width: this.autoWidth ? dimensions.columns : "100%",
+        height: this.autoHeight ? dimensions.rows : "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 = Array.from(graphemeSegmenter.segment(tail), (part) => part.segment);
+  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 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 { UnicodeTexBackend, measureTex, TexRenderable };