herm-tui 1.0.0-dev.1 → 1.0.0-dev.2

package/src/utils/math-unicode.ts

@@ -1,818 +0,0 @@
-// Best-effort LaTeX → Unicode for inline / display math captured by the
-// markdown renderer. The terminal can't typeset LaTeX, but Unicode covers
-// most of what models actually emit: Greek letters, blackboard / fraktur /
-// calligraphic capitals, set theory + logic operators, common arrows,
-// sub/superscripts, and `\frac{a}{b}` collapsed to `a/b`.
-//
-// Ported from hermes-agent ui-tui/src/lib/mathUnicode.ts (c3d39feb3 +
-// cb039ac00). Single divergence: `\boxed` / `\fbox` emit markdown-level
-// `**X**` instead of U+0001 / U+0002 sentinels, because herm feeds this
-// output directly to OpenTUI's <markdown> component which has no
-// sentinel-split hook. Upstream's React renderer uses the sentinels to
-// apply inverse+bold; we trade that visual for plain bold and keep the
-// pipeline single-pass.
-//
-// Design rules:
-//   • Pure regex pipeline. Anything we don't recognise is preserved
-//     verbatim (so a `\foo{bar}` we've never heard of still survives).
-//     A real LaTeX parser would be more correct but throws on partial
-//     input — terminal users would rather see the raw command than a
-//     parse-error placeholder.
-//   • Longest-match-first ordering on commands so `\le` doesn't shadow
-//     `\leq`, `\sub` doesn't shadow `\subseteq`, etc.
-//   • Word-boundary lookahead `(?![A-Za-z])` after each command so
-//     `\pix` (made-up command) doesn't get partially substituted as `π`.
-//   • `\mathbb{X}`, `\mathcal{X}`, `\mathfrak{X}` only handle a single
-//     letter argument — multi-letter `\mathbb{NN}` is rare and would
-//     need a real parser to do correctly.
-//   • Sub/super scripts only convert if EVERY character has a Unicode
-//     equivalent. Mixed content like `^{n+1}` falls back to the raw
-//     LaTeX so we don't emit `ⁿ+¹` (which has no `+` superscript glyph
-//     in some fonts and reads worse than the source).
-
-const SYMBOLS: Record<string, string> = {
-  // Greek lowercase
-  '\\alpha': 'α',
-  '\\beta': 'β',
-  '\\gamma': 'γ',
-  '\\delta': 'δ',
-  '\\epsilon': 'ε',
-  '\\varepsilon': 'ε',
-  '\\zeta': 'ζ',
-  '\\eta': 'η',
-  '\\theta': 'θ',
-  '\\vartheta': 'ϑ',
-  '\\iota': 'ι',
-  '\\kappa': 'κ',
-  '\\lambda': 'λ',
-  '\\mu': 'μ',
-  '\\nu': 'ν',
-  '\\xi': 'ξ',
-  '\\pi': 'π',
-  '\\varpi': 'ϖ',
-  '\\rho': 'ρ',
-  '\\varrho': 'ϱ',
-  '\\sigma': 'σ',
-  '\\varsigma': 'ς',
-  '\\tau': 'τ',
-  '\\upsilon': 'υ',
-  '\\phi': 'φ',
-  '\\varphi': 'φ',
-  '\\chi': 'χ',
-  '\\psi': 'ψ',
-  '\\omega': 'ω',
-
-  // Greek uppercase
-  '\\Gamma': 'Γ',
-  '\\Delta': 'Δ',
-  '\\Theta': 'Θ',
-  '\\Lambda': 'Λ',
-  '\\Xi': 'Ξ',
-  '\\Pi': 'Π',
-  '\\Sigma': 'Σ',
-  '\\Upsilon': 'Υ',
-  '\\Phi': 'Φ',
-  '\\Psi': 'Ψ',
-  '\\Omega': 'Ω',
-
-  // Big operators
-  '\\sum': '∑',
-  '\\prod': '∏',
-  '\\coprod': '∐',
-  '\\int': '∫',
-  '\\iint': '∬',
-  '\\iiint': '∭',
-  '\\oint': '∮',
-  '\\bigcup': '⋃',
-  '\\bigcap': '⋂',
-  '\\bigvee': '⋁',
-  '\\bigwedge': '⋀',
-  '\\bigoplus': '⨁',
-  '\\bigotimes': '⨂',
-
-  // Calculus
-  '\\partial': '∂',
-  '\\nabla': '∇',
-  '\\sqrt': '√',
-
-  // Sets
-  '\\emptyset': '∅',
-  '\\varnothing': '∅',
-  '\\infty': '∞',
-  '\\in': '∈',
-  '\\notin': '∉',
-  '\\ni': '∋',
-  '\\subset': '⊂',
-  '\\supset': '⊃',
-  '\\subseteq': '⊆',
-  '\\supseteq': '⊇',
-  '\\subsetneq': '⊊',
-  '\\supsetneq': '⊋',
-  '\\cup': '∪',
-  '\\cap': '∩',
-  '\\setminus': '∖',
-  '\\complement': '∁',
-
-  // Logic
-  '\\forall': '∀',
-  '\\exists': '∃',
-  '\\nexists': '∄',
-  '\\land': '∧',
-  '\\lor': '∨',
-  '\\lnot': '¬',
-  '\\neg': '¬',
-  '\\therefore': '∴',
-  '\\because': '∵',
-
-  // Relations
-  '\\le': '≤',
-  '\\leq': '≤',
-  '\\ge': '≥',
-  '\\geq': '≥',
-  '\\ne': '≠',
-  '\\neq': '≠',
-  '\\ll': '≪',
-  '\\gg': '≫',
-  '\\approx': '≈',
-  '\\equiv': '≡',
-  '\\cong': '≅',
-  '\\sim': '∼',
-  '\\simeq': '≃',
-  '\\propto': '∝',
-  '\\perp': '⊥',
-  '\\parallel': '∥',
-  '\\models': '⊨',
-  '\\vdash': '⊢',
-  '\\mid': '∣',
-  '\\nmid': '∤',
-  '\\divides': '∣',
-
-  // Common standalone glyphs
-  '\\blacksquare': '■',
-  '\\square': '□',
-  '\\Box': '□',
-  '\\qed': '∎',
-  '\\bigstar': '★',
-
-  // Modular arithmetic — the `\pmod{p}` form (with arg) is handled below;
-  // the bare `\bmod` / `\mod` commands are simple text substitutions.
-  '\\bmod': 'mod',
-  '\\mod': 'mod',
-
-  // Brackets / fences (named delimiter commands; the `\left\X` / `\right\X`
-  // unwrapping below leaves these behind for the symbol pass to resolve).
-  '\\langle': '⟨',
-  '\\rangle': '⟩',
-  '\\lceil': '⌈',
-  '\\rceil': '⌉',
-  '\\lfloor': '⌊',
-  '\\rfloor': '⌋',
-  '\\|': '‖',
-
-  // Arrows
-  '\\to': '→',
-  '\\rightarrow': '→',
-  '\\leftarrow': '←',
-  '\\leftrightarrow': '↔',
-  '\\Rightarrow': '⇒',
-  '\\Leftarrow': '⇐',
-  '\\Leftrightarrow': '⇔',
-  '\\implies': '⟹',
-  '\\impliedby': '⟸',
-  '\\iff': '⟺',
-  '\\mapsto': '↦',
-  '\\hookrightarrow': '↪',
-  '\\hookleftarrow': '↩',
-  '\\uparrow': '↑',
-  '\\downarrow': '↓',
-  '\\updownarrow': '↕',
-
-  // Binary operators
-  '\\cdot': '⋅',
-  '\\cdots': '⋯',
-  '\\ldots': '…',
-  '\\dots': '…',
-  '\\dotsb': '…',
-  '\\dotsc': '…',
-  '\\vdots': '⋮',
-  '\\ddots': '⋱',
-  '\\times': '×',
-  '\\div': '÷',
-  '\\pm': '±',
-  '\\mp': '∓',
-  '\\circ': '∘',
-  '\\bullet': '•',
-  '\\star': '⋆',
-  '\\ast': '∗',
-  '\\oplus': '⊕',
-  '\\ominus': '⊖',
-  '\\otimes': '⊗',
-  '\\odot': '⊙',
-  '\\diamond': '⋄',
-  '\\angle': '∠',
-  '\\triangle': '△',
-
-  // Spacing — collapse to varying widths of regular space
-  '\\,': ' ',
-  '\\;': ' ',
-  '\\:': ' ',
-  '\\!': '',
-  '\\ ': ' ',
-  '\\quad': '  ',
-  '\\qquad': '    ',
-
-  // Functions (LaTeX renders these in roman; we just keep the name)
-  '\\sin': 'sin',
-  '\\cos': 'cos',
-  '\\tan': 'tan',
-  '\\cot': 'cot',
-  '\\sec': 'sec',
-  '\\csc': 'csc',
-  '\\arcsin': 'arcsin',
-  '\\arccos': 'arccos',
-  '\\arctan': 'arctan',
-  '\\sinh': 'sinh',
-  '\\cosh': 'cosh',
-  '\\tanh': 'tanh',
-  '\\log': 'log',
-  '\\ln': 'ln',
-  '\\exp': 'exp',
-  '\\det': 'det',
-  '\\dim': 'dim',
-  '\\ker': 'ker',
-  '\\lim': 'lim',
-  '\\liminf': 'liminf',
-  '\\limsup': 'limsup',
-  '\\sup': 'sup',
-  '\\inf': 'inf',
-  '\\max': 'max',
-  '\\min': 'min',
-  '\\arg': 'arg',
-  '\\gcd': 'gcd',
-
-  // Escaped literals — model occasionally emits these for display
-  '\\&': '&',
-  '\\%': '%',
-  '\\$': '$',
-  '\\#': '#',
-  '\\_': '_',
-  '\\{': '{',
-  '\\}': '}'
-}
-
-const BB: Record<string, string> = {
-  A: '𝔸',
-  B: '𝔹',
-  C: 'ℂ',
-  D: '𝔻',
-  E: '𝔼',
-  F: '𝔽',
-  G: '𝔾',
-  H: 'ℍ',
-  I: '𝕀',
-  J: '𝕁',
-  K: '𝕂',
-  L: '𝕃',
-  M: '𝕄',
-  N: 'ℕ',
-  O: '𝕆',
-  P: 'ℙ',
-  Q: 'ℚ',
-  R: 'ℝ',
-  S: '𝕊',
-  T: '𝕋',
-  U: '𝕌',
-  V: '𝕍',
-  W: '𝕎',
-  X: '𝕏',
-  Y: '𝕐',
-  Z: 'ℤ'
-}
-
-const CAL: Record<string, string> = {
-  A: '𝒜',
-  B: 'ℬ',
-  C: '𝒞',
-  D: '𝒟',
-  E: 'ℰ',
-  F: 'ℱ',
-  G: '𝒢',
-  H: 'ℋ',
-  I: 'ℐ',
-  J: '𝒥',
-  K: '𝒦',
-  L: 'ℒ',
-  M: 'ℳ',
-  N: '𝒩',
-  O: '𝒪',
-  P: '𝒫',
-  Q: '𝒬',
-  R: 'ℛ',
-  S: '𝒮',
-  T: '𝒯',
-  U: '𝒰',
-  V: '𝒱',
-  W: '𝒲',
-  X: '𝒳',
-  Y: '𝒴',
-  Z: '𝒵'
-}
-
-const FRAK: Record<string, string> = {
-  A: '𝔄',
-  B: '𝔅',
-  C: 'ℭ',
-  D: '𝔇',
-  E: '𝔈',
-  F: '𝔉',
-  G: '𝔊',
-  H: 'ℌ',
-  I: 'ℑ',
-  J: '𝔍',
-  K: '𝔎',
-  L: '𝔏',
-  M: '𝔐',
-  N: '𝔑',
-  O: '𝔒',
-  P: '𝔓',
-  Q: '𝔔',
-  R: 'ℜ',
-  S: '𝔖',
-  T: '𝔗',
-  U: '𝔘',
-  V: '𝔙',
-  W: '𝔚',
-  X: '𝔛',
-  Y: '𝔜',
-  Z: 'ℨ'
-}
-
-const SUPERSCRIPT: Record<string, string> = {
-  '0': '⁰',
-  '1': '¹',
-  '2': '²',
-  '3': '³',
-  '4': '⁴',
-  '5': '⁵',
-  '6': '⁶',
-  '7': '⁷',
-  '8': '⁸',
-  '9': '⁹',
-  '+': '⁺',
-  '-': '⁻',
-  '=': '⁼',
-  '(': '⁽',
-  ')': '⁾',
-  a: 'ᵃ',
-  b: 'ᵇ',
-  c: 'ᶜ',
-  d: 'ᵈ',
-  e: 'ᵉ',
-  f: 'ᶠ',
-  g: 'ᵍ',
-  h: 'ʰ',
-  i: 'ⁱ',
-  j: 'ʲ',
-  k: 'ᵏ',
-  l: 'ˡ',
-  m: 'ᵐ',
-  n: 'ⁿ',
-  o: 'ᵒ',
-  p: 'ᵖ',
-  r: 'ʳ',
-  s: 'ˢ',
-  t: 'ᵗ',
-  u: 'ᵘ',
-  v: 'ᵛ',
-  w: 'ʷ',
-  x: 'ˣ',
-  y: 'ʸ',
-  z: 'ᶻ'
-}
-
-const SUBSCRIPT: Record<string, string> = {
-  '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: 'ₓ'
-}
-
-// Markers for `\boxed` / `\fbox` regions. Upstream hermes-agent uses
-// non-printable U+0001 / U+0002 sentinels and its React renderer
-// splits on them to apply inverse+bold. Herm feeds the converted
-// string directly to OpenTUI's <markdown> component, which doesn't
-// have a split-and-style hook — so we emit markdown-level `**X**`
-// instead, and let the markdown renderer turn it into bold on its
-// own. This trades the inverse-video visual for standard bold but
-// keeps the pipeline hook-free.
-const BOX_WRAP_OPEN = "**"
-const BOX_WRAP_CLOSE = "**"
-
-const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-// Pre-compile two symbol regexes: one for letter-ending commands (`\pi`,
-// `\sum`) which need a `(?![A-Za-z])` lookahead so they don't partially
-// match `\pix` or `\summa`, and one for punctuation-ending commands
-// (`\{`, `\,`, `\|`) which must NOT have the lookahead — otherwise
-// `\{p` would refuse to substitute because `p` is a letter.
-//
-// Longest commands first inside each group so `\leq` beats `\le`.
-const splitByEnding = (keys: string[]) => {
-  const letter: string[] = []
-  const punct: string[] = []
-
-  for (const k of keys) {
-    if (/[A-Za-z]$/.test(k)) {
-      letter.push(k)
-    } else {
-      punct.push(k)
-    }
-  }
-
-  return { letter, punct }
-}
-
-const buildAlt = (cmds: string[]) =>
-  cmds
-    .sort((a, b) => b.length - a.length)
-    .map(escapeRe)
-    .join('|')
-
-const { letter: LETTER_CMDS, punct: PUNCT_CMDS } = splitByEnding(Object.keys(SYMBOLS))
-
-const SYMBOL_LETTER_RE = new RegExp('(?:' + buildAlt(LETTER_CMDS) + ')(?![A-Za-z])', 'g')
-const SYMBOL_PUNCT_RE = new RegExp('(?:' + buildAlt(PUNCT_CMDS) + ')', 'g')
-
-const convertScript = (input: string, table: Record<string, string>, sigil: '^' | '_'): string => {
-  let out = ''
-  let allMapped = true
-
-  for (const ch of input) {
-    const mapped = table[ch]
-
-    if (!mapped) {
-      allMapped = false
-
-      break
-    }
-
-    out += mapped
-  }
-
-  if (allMapped) {
-    return out
-  }
-
-  // Fallback: if the body is a single visible character (e.g. `∞` after
-  // earlier symbol substitution), render it without braces — `^∞` reads
-  // far better than `^{∞}` in a terminal. Multi-char bodies that don't
-  // fully convert use parens (`e^(iπ)`) instead of braces (`e^{iπ}`)
-  // because parens are normal punctuation while braces look like
-  // unrendered LaTeX.
-  const trimmed = input.trim()
-
-  if ([...trimmed].length === 1) {
-    return `${sigil}${trimmed}`
-  }
-
-  return `${sigil}(${trimmed})`
-}
-
-// Walk the string and parse `{...}` honouring nested braces. Unlike a
-// `\{[^{}]*\}` regex this survives `\frac{|t|^{p-1}|P(t)|^p}{...}` where
-// the numerator contains its own braces from a superscript. Returns the
-// inner content (without the outer braces) and the offset just past the
-// closing `}`. Returns null if there is no balanced brace at `start`.
-const readBraced = (s: string, start: number): { content: string; end: number } | null => {
-  if (s[start] !== '{') {
-    return null
-  }
-
-  let depth = 1
-  let i = start + 1
-
-  while (i < s.length && depth > 0) {
-    const c = s[i]
-
-    // Skip escapes — `\{` and `\}` inside a body are literal braces and
-    // should not change the brace counter.
-    if (c === '\\' && i + 1 < s.length) {
-      i += 2
-      continue
-    }
-
-    if (c === '{') {
-      depth++
-    } else if (c === '}') {
-      depth--
-    }
-
-    if (depth > 0) {
-      i++
-    }
-  }
-
-  if (depth !== 0) {
-    return null
-  }
-
-  return { content: s.slice(start + 1, i), end: i + 1 }
-}
-
-// Replace every occurrence of `\command{arg}` using balanced-brace parsing
-// (so `\boxed{x^{n+1}}` works where a `[^{}]*` regex would fail). The
-// `render` callback receives the inner content already recursed-into, so
-// `\boxed{\boxed{x}}` resolves outside-in cleanly. Unmatched `\command`
-// (no following `{...}`) is preserved verbatim.
-const replaceBracedCommand = (input: string, command: string, render: (content: string) => string): string => {
-  const cmdLen = command.length
-  let out = ''
-  let i = 0
-
-  while (i < input.length) {
-    const idx = input.indexOf(command, i)
-
-    if (idx < 0) {
-      out += input.slice(i)
-
-      return out
-    }
-
-    const after = input[idx + cmdLen]
-
-    if (after && /[A-Za-z]/.test(after)) {
-      out += input.slice(i, idx + cmdLen)
-      i = idx + cmdLen
-      continue
-    }
-
-    out += input.slice(i, idx)
-
-    let p = idx + cmdLen
-
-    while (input[p] === ' ' || input[p] === '\t') p++
-
-    const arg = readBraced(input, p)
-
-    if (!arg) {
-      out += input.slice(idx, p + 1)
-      i = p + 1
-      continue
-    }
-
-    out += render(replaceBracedCommand(arg.content, command, render))
-    i = arg.end
-  }
-
-  return out
-}
-
-// Replace every `\frac{num}{den}` with `num/den` (parens around either
-// side when its precedence demands it). The recursion handles nested
-// fractions naturally: `\frac{1}{\frac{1}{x}}` collapses to `1/(1/x)`
-// because we recurse into `den` before deciding whether to parenthesise.
-const replaceFracs = (input: string): string => {
-  let out = ''
-  let i = 0
-
-  while (i < input.length) {
-    const idx = input.indexOf('\\frac', i)
-
-    if (idx < 0) {
-      out += input.slice(i)
-
-      return out
-    }
-
-    const after = input[idx + 5]
-
-    // `(?![A-Za-z])` — protect hypothetical commands like `\fraction`.
-    if (after && /[A-Za-z]/.test(after)) {
-      out += input.slice(i, idx + 5)
-      i = idx + 5
-      continue
-    }
-
-    out += input.slice(i, idx)
-
-    let p = idx + 5
-
-    while (input[p] === ' ' || input[p] === '\t') p++
-
-    const num = readBraced(input, p)
-
-    if (!num) {
-      out += input.slice(idx, p + 1)
-      i = p + 1
-      continue
-    }
-
-    p = num.end
-
-    while (input[p] === ' ' || input[p] === '\t') p++
-
-    const den = readBraced(input, p)
-
-    if (!den) {
-      out += input.slice(idx, p + 1)
-      i = p + 1
-      continue
-    }
-
-    out += `${wrapForFrac(replaceFracs(num.content))}/${wrapForFrac(replaceFracs(den.content))}`
-    i = den.end
-  }
-
-  return out
-}
-
-// Wrap multi-token expressions in parens so `\frac{a+b}{c}` becomes
-// `(a+b)/c` rather than `a+b/c`. We wrap whenever inline `/` would
-// change the meaning — that's any binary operator (`+`, `-`, `*`, `/`)
-// or whitespace separating tokens. `*` and `/` matter because nested
-// fractions and products like `\frac{a*b}{c}` and `\frac{1/x}{y}` would
-// otherwise read as `a*b/c` (right-associative ambiguity) and `1/x/y`.
-// Atomic factors like `n!`, `x^2`, `\sin x` don't trigger any of these
-// and stay un-parenthesised — wrapping them just clutters the output.
-const wrapForFrac = (expr: string) => {
-  const trimmed = expr.trim()
-
-  if (!trimmed) {
-    return trimmed
-  }
-
-  if (/^\(.*\)$/.test(trimmed)) {
-    return trimmed
-  }
-
-  if (/[+\-/*]|\s/.test(trimmed)) {
-    return `(${trimmed})`
-  }
-
-  return trimmed
-}
-
-export function texToUnicode(input: string): string {
-  let s = input
-
-  s = s.replace(/\\mathbb\s*\{([A-Za-z])\}/g, (raw, c: string) => BB[c] ?? raw)
-  s = s.replace(/\\mathcal\s*\{([A-Za-z])\}/g, (raw, c: string) => CAL[c] ?? raw)
-  s = s.replace(/\\mathfrak\s*\{([A-Za-z])\}/g, (raw, c: string) => FRAK[c] ?? raw)
-  s = s.replace(/\\mathbf\s*\{([^{}]+)\}/g, (_, c: string) => c)
-  s = s.replace(/\\mathit\s*\{([^{}]+)\}/g, (_, c: string) => c)
-  s = s.replace(/\\mathrm\s*\{([^{}]+)\}/g, (_, c: string) => c)
-  s = s.replace(/\\text\s*\{([^{}]+)\}/g, (_, c: string) => c)
-  s = s.replace(/\\operatorname\s*\{([^{}]+)\}/g, (_, c: string) => c)
-
-  s = s.replace(/\\overline\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0305`)
-  s = s.replace(/\\hat\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0302`)
-  s = s.replace(/\\bar\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0304`)
-  s = s.replace(/\\tilde\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0303`)
-  s = s.replace(/\\vec\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u20D7`)
-  s = s.replace(/\\dot\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0307`)
-  s = s.replace(/\\ddot\s*\{([^{}]+)\}/g, (_, c: string) => `${c}\u0308`)
-
-  s = replaceFracs(s)
-
-  // `\boxed{X}` / `\fbox{X}` highlight a final answer. Terminals can't
-  // draw a real box, so we wrap the content in U+0001 / U+0002 control
-  // characters — non-printable, never present in real text — and let the
-  // markdown renderer split on them and apply a highlight style (inverse
-  // video) to the bracketed region. This keeps `texToUnicode` pure-string
-  // while letting the React layer do the actual visual emphasis.
-  // Argument is parsed with balanced braces so nested `{...}` from
-  // superscripts / fractions inside the box survive.
-  s = replaceBracedCommand(s, '\\boxed', body => `${BOX_WRAP_OPEN}${body.trim()}${BOX_WRAP_CLOSE}`)
-  s = replaceBracedCommand(s, '\\fbox', body => `${BOX_WRAP_OPEN}${body.trim()}${BOX_WRAP_CLOSE}`)
-
-  // `\xrightarrow{label}` / `\xleftarrow{label}` collapse to an arrow with
-  // the label inline. LaTeX renders the label above the arrow; in monospace
-  // we put it adjacent — `─label→` is the closest readable approximation.
-  // Run before the symbol pass so the label can still pick up Greek and
-  // operator substitutions afterwards.
-  s = s.replace(/\\xrightarrow\s*\{([^{}]*)\}/g, (_, label: string) => `─${label.trim()}→`)
-  s = s.replace(/\\xleftarrow\s*\{([^{}]*)\}/g, (_, label: string) => `←${label.trim()}─`)
-  s = s.replace(/\\Longrightarrow/g, '⟹')
-  s = s.replace(/\\Longleftarrow/g, '⟸')
-  s = s.replace(/\\Longleftrightarrow/g, '⟺')
-
-  // `\pmod{p}` → ` (mod p)` (LaTeX adds parens automatically); `\pod{p}`
-  // is a paren-less variant; `\tag{n}` is the equation-number annotation
-  // shown to the right of an equation. Collapse to a single-space-prefixed
-  // bracketed form. The leading `\s*` in the pattern absorbs any whitespace
-  // already in the source so we don't end up with `b  (mod p)` (double
-  // space) when the user wrote `b \pmod{p}`.
-  s = s.replace(/\s*\\pmod\s*\{([^{}]*)\}/g, (_, p: string) => ` (mod ${p.trim()})`)
-  s = s.replace(/\s*\\pod\s*\{([^{}]*)\}/g, (_, p: string) => ` (${p.trim()})`)
-  s = s.replace(/\s*\\tag\s*\{([^{}]*)\}/g, (_, n: string) => ` (${n.trim()})`)
-
-  // `\big`, `\Big`, `\bigg`, `\Bigg` (with optional `l`/`r`/`m` suffix)
-  // are sizing wrappers analogous to `\left`/`\right` but without the
-  // automatic-pairing semantics. Strip them and leave whatever delimiter
-  // follows. The trailing `(?![A-Za-z])` protects `\bigtriangleup` and
-  // any other letter-continuation command from being shaved.
-  s = s.replace(/\\(?:Bigg|bigg|Big|big)[lrm]?(?![A-Za-z])/g, '')
-
-  // Style / size hints that don't typeset any glyph and only affect how
-  // things would be sized in a real LaTeX engine. In a terminal every
-  // glyph is one monospace cell, so there's nothing to do — drop them
-  // (with any trailing whitespace) so they don't leak through as raw
-  // `\displaystyle` in the output.
-  s = s.replace(/\\(?:scriptscriptstyle|displaystyle|scriptstyle|textstyle|nolimits|limits)(?![A-Za-z])\s*/g, '')
-
-  // `\left` and `\right` are sizing wrappers around any delimiter — bare
-  // (`\left(`), escaped (`\left\{`), or named (`\left\langle`). Strip the
-  // wrapper unconditionally and let the rest of the pipeline (or the
-  // upcoming symbol pass) handle whatever delimiter follows. The optional
-  // `.?` consumes `\left.` / `\right.` which mean "no delimiter".
-  // Lookahead `(?![A-Za-z])` keeps `\leftarrow` / `\leftrightarrow` safe.
-  s = s.replace(/\\left(?![A-Za-z])\.?/g, '')
-  s = s.replace(/\\right(?![A-Za-z])\.?/g, '')
-
-  // Run symbol substitution BEFORE scripts so a body like `^{\infty}`
-  // becomes `^{∞}` first; convertScript can then either map ∞ to a
-  // superscript (it can't — Unicode lacks one) or fall back to `^∞`
-  // by stripping braces around the now-single-character body.
-  //
-  // Punctuation pass first — these can be followed by letters (`\{p`
-  // is "open-brace then p"), so the letter pass's `(?![A-Za-z])` rule
-  // would wrongly block them.
-  s = s.replace(SYMBOL_PUNCT_RE, m => SYMBOLS[m] ?? m)
-  s = s.replace(SYMBOL_LETTER_RE, m => SYMBOLS[m] ?? m)
-
-  // Bare `^c` / `_c` handles ONLY alphanumerics and `+`/`-`/`=`. Parens
-  // are intentionally excluded because the braced-fallback above can
-  // emit `(...)` and we don't want a second pass to greedily convert
-  // its opening paren into `⁽` and orphan the closing one.
-  s = s.replace(/\^\s*\{([^{}]+)\}/g, (_, body: string) => convertScript(body, SUPERSCRIPT, '^'))
-  s = s.replace(/\^([A-Za-z0-9+\-=])/g, (raw, ch: string) => SUPERSCRIPT[ch] ?? raw)
-  s = s.replace(/_\s*\{([^{}]+)\}/g, (_, body: string) => convertScript(body, SUBSCRIPT, '_'))
-  s = s.replace(/_([A-Za-z0-9+\-=])/g, (raw, ch: string) => SUBSCRIPT[ch] ?? raw)
-
-  return s
-}
-
-// Inline-code spans: 1–2 backticks, non-greedy body, same-length closer.
-// Captured so mathify can step over them without a placeholder dance.
-const CODE_SPAN_RE = /(`{1,2})[^`\n]+?\1/g
-
-// Math delimiters, tightest-to-loosest. `$$…$$` before `$…$` so the
-// single-dollar branch never eats a display-math opener. `$…$` uses the
-// same no-space-adjacent rule upstream uses to dodge `$5 to $10` prose.
-const MATH_SPAN_RE = new RegExp(
-  [
-    String.raw`\$\$([^$]+?)\$\$`,
-    String.raw`\\\[([\s\S]+?)\\\]`,
-    String.raw`\\\(([^\n]+?)\\\)`,
-    String.raw`(?<!\$)\$([^\s$](?:[^$\n]*?[^\s$])?)\$(?!\$)`,
-  ].join('|'),
-  'g',
-)
-
-// Apply texToUnicode only inside math delimiters. texToUnicode is a
-// whole-string transform (it will turn prose `_n` into `ₙ`), so it must
-// never see non-math text. Walk the string, skip inline-code spans
-// verbatim, and rewrite math spans in the gaps.
-export function mathify(md: string): string {
-  if (!/[$\\]/.test(md)) return md
-  let out = ''
-  let i = 0
-  CODE_SPAN_RE.lastIndex = 0
-  for (const m of md.matchAll(CODE_SPAN_RE)) {
-    out += md.slice(i, m.index).replace(MATH_SPAN_RE,
-      (_, a, b, c, d) => texToUnicode(a ?? b ?? c ?? d))
-    out += m[0]
-    i = m.index + m[0].length
-  }
-  out += md.slice(i).replace(MATH_SPAN_RE,
-    (_, a, b, c, d) => texToUnicode(a ?? b ?? c ?? d))
-  return out
-}