diff --git a/dist/render.js b/dist/render.js
index d50d626..1ee30a5 100644
--- a/dist/render.js
+++ b/dist/render.js
@@ -4,6 +4,7 @@ import stripAnsi from "strip-ansi";
 import { hyperlinkSupported, osc8 } from "./hyperlink.js";
 import { parse } from "./parser.js";
 import { convertLatexToUnicode } from "./latex.js";
+import { renderDisplayLatex } from "./txm.js";
 import { createStyler, themes } from "./theme.js";
 import { visibleWidth, wrapText, wrapWithPrefix } from "./wrap.js";
 function dedent(markdown) {
@@ -461,8 +462,8 @@ function renderCodeBlock(node, ctx) {
     return [`${top}\n${boxLines.join("\n")}\n${bottom}\n\n`];
 }
 function renderDisplayMath(node, ctx) {
-    const converted = convertLatexToUnicode(node.value);
-    const styled = ctx.style(converted, ctx.options.theme.math || ctx.options.theme.inlineCode);
+    const rendered = renderDisplayLatex(node.value);
+    const styled = ctx.style(rendered, ctx.options.theme.math || ctx.options.theme.inlineCode);
     const lines = styled.split("\n");
     return [`\n${lines.map((l) => `  ${l}`).join("\n")}\n`];
 }
diff --git a/dist/txm-wasm/package.json b/dist/txm-wasm/package.json
new file mode 100644
index 0000000..5bbefff
--- /dev/null
+++ b/dist/txm-wasm/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}
diff --git a/dist/txm-wasm/txm.d.ts b/dist/txm-wasm/txm.d.ts
new file mode 100644
index 0000000..b9b5a16
--- /dev/null
+++ b/dist/txm-wasm/txm.d.ts
@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function render_latex(latex: string): string;
diff --git a/dist/txm-wasm/txm.js b/dist/txm-wasm/txm.js
new file mode 100644
index 0000000..7775be4
--- /dev/null
+++ b/dist/txm-wasm/txm.js
@@ -0,0 +1,134 @@
+/* @ts-self-types="./txm.d.ts" */
+
+/**
+ * @param {string} latex
+ * @returns {string}
+ */
+function render_latex(latex) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(latex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.render_latex(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.render_latex = render_latex;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./txm_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/txm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();
diff --git a/dist/txm-wasm/txm_bg.wasm b/dist/txm-wasm/txm_bg.wasm
new file mode 100644
index 0000000..aaec9ac
Binary files /dev/null and b/dist/txm-wasm/txm_bg.wasm differ
diff --git a/dist/txm-wasm/txm_bg.wasm.d.ts b/dist/txm-wasm/txm_bg.wasm.d.ts
new file mode 100644
index 0000000..2d0b227
--- /dev/null
+++ b/dist/txm-wasm/txm_bg.wasm.d.ts
@@ -0,0 +1,10 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const render_latex: (a: number, b: number) => [number, number, number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;
diff --git a/dist/txm.d.ts b/dist/txm.d.ts
new file mode 100644
index 0000000..49ed953
--- /dev/null
+++ b/dist/txm.d.ts
@@ -0,0 +1 @@
+export declare function renderDisplayLatex(latex: string): string;
diff --git a/dist/txm.js b/dist/txm.js
new file mode 100644
index 0000000..7029138
--- /dev/null
+++ b/dist/txm.js
@@ -0,0 +1,17 @@
+import { createRequire } from "node:module";
+import { convertLatexToUnicode } from "./latex.js";
+const require = createRequire(import.meta.url);
+const txm = require("./txm-wasm/txm.js");
+export function renderDisplayLatex(latex) {
+    try {
+        return txm
+            .render_latex(latex)
+            .trimEnd()
+            .split("\n")
+            .map((line) => line.trimEnd())
+            .join("\n");
+    }
+    catch {
+        return convertLatexToUnicode(latex);
+    }
+}
diff --git a/package.json b/package.json
index ddd6cae..ea96617 100644
--- a/package.json
+++ b/package.json
@@ -46,14 +46,14 @@
   "scripts": {
     "build": "pnpm lint && pnpm typecheck && pnpm test && pnpm compile",
     "clean": "rm -rf dist",
-    "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
+    "format": "oxfmt --write src/*.ts test scripts package.json",
+    "format:check": "oxfmt --check src/*.ts test scripts package.json",
     "lint": "rm -rf dist coverage && pnpm format:check && oxlint --deny-warnings src test",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "types": "tsc -p tsconfig.json --emitDeclarationOnly",
-    "compile": "tsc -p tsconfig.json",
+    "compile": "tsc -p tsconfig.json && node scripts/copy-txm-wasm.mjs",
     "markdansi": "tsx src/cli.ts",
     "release": "node scripts/release.mjs"
   },
diff --git a/scripts/copy-txm-wasm.mjs b/scripts/copy-txm-wasm.mjs
new file mode 100644
index 0000000..27861a7
--- /dev/null
+++ b/scripts/copy-txm-wasm.mjs
@@ -0,0 +1,9 @@
+import { cp } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+await cp(path.join(projectRoot, "src", "txm-wasm"), path.join(projectRoot, "dist", "txm-wasm"), {
+  recursive: true,
+});
diff --git a/src/render.ts b/src/render.ts
index 7786ed7..e21f7df 100644
--- a/src/render.ts
+++ b/src/render.ts
@@ -16,6 +16,7 @@ import { hyperlinkSupported, osc8 } from "./hyperlink.js";
 import { parse } from "./parser.js";
 import { convertLatexToUnicode } from "./latex.js";
 import type { Styler } from "./theme.js";
+import { renderDisplayLatex } from "./txm.js";
 import { createStyler, themes } from "./theme.js";
 import type { RenderOptions, StyleIntent, Theme } from "./types.js";
 import { visibleWidth, wrapText, wrapWithPrefix } from "./wrap.js";
@@ -590,8 +591,8 @@ function renderCodeBlock(node: Code, ctx: RenderContext): string[] {
 }
 
 function renderDisplayMath(node: { value: string }, ctx: RenderContext): string[] {
-  const converted = convertLatexToUnicode(node.value);
-  const styled = ctx.style(converted, ctx.options.theme.math || ctx.options.theme.inlineCode);
+  const rendered = renderDisplayLatex(node.value);
+  const styled = ctx.style(rendered, ctx.options.theme.math || ctx.options.theme.inlineCode);
   const lines = styled.split("\n");
   return [`\n${lines.map((l) => `  ${l}`).join("\n")}\n`];
 }
diff --git a/src/txm-wasm/package.json b/src/txm-wasm/package.json
new file mode 100644
index 0000000..5bbefff
--- /dev/null
+++ b/src/txm-wasm/package.json
@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}
diff --git a/src/txm-wasm/txm.d.ts b/src/txm-wasm/txm.d.ts
new file mode 100644
index 0000000..b9b5a16
--- /dev/null
+++ b/src/txm-wasm/txm.d.ts
@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function render_latex(latex: string): string;
diff --git a/src/txm-wasm/txm.js b/src/txm-wasm/txm.js
new file mode 100644
index 0000000..7775be4
--- /dev/null
+++ b/src/txm-wasm/txm.js
@@ -0,0 +1,134 @@
+/* @ts-self-types="./txm.d.ts" */
+
+/**
+ * @param {string} latex
+ * @returns {string}
+ */
+function render_latex(latex) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(latex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.render_latex(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+exports.render_latex = render_latex;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./txm_bg.js": import0,
+    };
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/txm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();
diff --git a/src/txm-wasm/txm_bg.wasm b/src/txm-wasm/txm_bg.wasm
new file mode 100644
index 0000000..aaec9ac
Binary files /dev/null and b/src/txm-wasm/txm_bg.wasm differ
diff --git a/src/txm-wasm/txm_bg.wasm.d.ts b/src/txm-wasm/txm_bg.wasm.d.ts
new file mode 100644
index 0000000..2d0b227
--- /dev/null
+++ b/src/txm-wasm/txm_bg.wasm.d.ts
@@ -0,0 +1,10 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const render_latex: (a: number, b: number) => [number, number, number, number];
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;
diff --git a/src/txm.ts b/src/txm.ts
new file mode 100644
index 0000000..710362d
--- /dev/null
+++ b/src/txm.ts
@@ -0,0 +1,23 @@
+import { createRequire } from "node:module";
+
+import { convertLatexToUnicode } from "./latex.js";
+
+type Txm = {
+  render_latex(latex: string): string;
+};
+
+const require = createRequire(import.meta.url);
+const txm = require("./txm-wasm/txm.js") as Txm;
+
+export function renderDisplayLatex(latex: string): string {
+  try {
+    return txm
+      .render_latex(latex)
+      .trimEnd()
+      .split("\n")
+      .map((line) => line.trimEnd())
+      .join("\n");
+  } catch {
+    return convertLatexToUnicode(latex);
+  }
+}
diff --git a/test/render.test.ts b/test/render.test.ts
index b174371..5484033 100644
--- a/test/render.test.ts
+++ b/test/render.test.ts
@@ -50,17 +50,26 @@ describe("inline formatting", () => {
     expect(out).not.toContain("\\mathrm");
   });
 
-  it("renders display LaTeX math as an indented block", () => {
-    const out = strip(
-      "Before\n\n$$\n\\partial\\Gamma\\coloneqq\\Gamma\\times(\\Gamma\\to\\Gamma)\\tag{5}\n$$\n\nAfter",
-      noColor,
-    );
+  it("renders display LaTeX math as an indented two-dimensional Unicode grid", () => {
+    const out = strip("Before\n\n$$\n\\frac{a}{b}\n$$\n\nAfter", noColor);
     expect(out).toContain("Before");
-    expect(out).toContain("  ∂Γ≔Γ×(Γ→Γ)    (5)");
+    expect(out).toContain("   a\n  ───\n   b");
     expect(out).toContain("After");
     expect(out).not.toContain("$$");
   });
 
+  it("renders display matrices as a two-dimensional Unicode grid", () => {
+    const out = strip("$$\\begin{bmatrix}a&b\\\\c&d\\end{bmatrix}$$", noColor);
+    expect(out).toContain("  ⎡ a    b ⎤");
+    expect(out).toContain("  ⎢");
+    expect(out).toContain("  ⎣ c    d ⎦");
+  });
+
+  it("falls back to inline Unicode conversion for unsupported display LaTeX", () => {
+    const out = strip("$$\\unknown{x}$$", noColor);
+    expect(out).toContain("  unknownx");
+  });
+
   it("leaves code spans, fenced code, and dollar amounts unchanged", () => {
     const out = strip("Use `$PATH` and pay $100.\n\n```ts\nconst formula = '$x$'\n```", noColor);
     expect(out).toContain("Use $PATH and pay $100.");
diff --git a/vendor/txm-wasm/Cargo.lock b/vendor/txm-wasm/Cargo.lock
new file mode 100644
index 0000000..923afe8
--- /dev/null
+++ b/vendor/txm-wasm/Cargo.lock
@@ -0,0 +1,231 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "logos"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970"
+dependencies = [
+ "fnv",
+ "proc-macro2",
+ "quote",
+ "regex-automata",
+ "regex-syntax",
+ "syn 2.0.119",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31"
+dependencies = [
+ "logos-codegen",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.119"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 3.0.3",
+]
+
+[[package]]
+name = "txm"
+version = "0.1.5"
+dependencies = [
+ "logos",
+ "thiserror",
+ "unicode-width",
+]
+
+[[package]]
+name = "txm-wasm"
+version = "0.1.0"
+dependencies = [
+ "txm",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.119",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b"
+dependencies = [
+ "unicode-ident",
+]
diff --git a/vendor/txm-wasm/Cargo.toml b/vendor/txm-wasm/Cargo.toml
new file mode 100644
index 0000000..d1208ef
--- /dev/null
+++ b/vendor/txm-wasm/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "txm-wasm"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+txm = { path = "../txm" }
+wasm-bindgen = "=0.2.117"
diff --git a/vendor/txm-wasm/src/lib.rs b/vendor/txm-wasm/src/lib.rs
new file mode 100644
index 0000000..cc3fa23
--- /dev/null
+++ b/vendor/txm-wasm/src/lib.rs
@@ -0,0 +1,39 @@
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen]
+pub fn render_latex(latex: &str) -> Result<String, String> {
+    txm::render(latex)
+        .map(|rendered| strip_sgr(&rendered))
+        .map_err(|error| error.to_string())
+}
+
+fn strip_sgr(text: &str) -> String {
+    let mut result = String::with_capacity(text.len());
+    let mut chars = text.chars();
+
+    while let Some(ch) = chars.next() {
+        if ch == '\u{1b}' && chars.next() == Some('[') {
+            for parameter in chars.by_ref() {
+                if parameter == 'm' {
+                    break;
+                }
+            }
+        } else {
+            result.push(ch);
+        }
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::render_latex;
+
+    #[test]
+    fn renders_plain_unicode_grid() {
+        let rendered = render_latex(r"\color{red}{\frac{a}{b}}").unwrap();
+        assert_eq!(rendered, " a \n───\n b \n");
+        assert!(!rendered.contains('\u{1b}'));
+    }
+}
diff --git a/vendor/txm/Cargo.lock b/vendor/txm/Cargo.lock
new file mode 100644
index 0000000..fee40f2
--- /dev/null
+++ b/vendor/txm/Cargo.lock
@@ -0,0 +1,340 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "bitflags"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+
+[[package]]
+name = "castaway"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "compact_str"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
+dependencies = [
+ "castaway",
+ "cfg-if",
+ "itoa",
+ "rustversion",
+ "ryu",
+ "static_assertions",
+]
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "kasuari"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde5057d6143cc94e861d90f591b9303d6716c6b9602309150bd068853c10899"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror",
+]
+
+[[package]]
+name = "logos"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2c55a318a87600ea870ff8c2012148b44bf18b74fad48d0f835c38c7d07c5f"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58b3ffaa284e1350d017a57d04ada118c4583cf260c8fb01e0fe28a2e9cf8970"
+dependencies = [
+ "fnv",
+ "proc-macro2",
+ "quote",
+ "regex-automata",
+ "regex-syntax",
+ "syn",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52d3a9855747c17eaf4383823f135220716ab49bea5fbea7dd42cc9a92f8aa31"
+dependencies = [
+ "logos-codegen",
+]
+
+[[package]]
+name = "lru"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b6180140927ee907000b0aa540091f6ea512ead4447c92b8fc35bc72788a5a6"
+dependencies = [
+ "hashbrown 0.17.1",
+]
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ratatui-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbb175c433c8e28a809d1f5773a2ae96e68c0ce40db865cbab1020bf33ae479c"
+dependencies = [
+ "bitflags",
+ "compact_str",
+ "hashbrown 0.17.1",
+ "itertools",
+ "kasuari",
+ "lru",
+ "strum",
+ "thiserror",
+ "unicode-segmentation",
+ "unicode-truncate",
+ "unicode-width",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strum"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "txm"
+version = "0.1.5"
+dependencies = [
+ "logos",
+ "ratatui-core",
+ "thiserror",
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
+
+[[package]]
+name = "unicode-truncate"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b380a1238663e5f8a691f9039c73e1cdae598a30e9855f541d29b08b53e9a5"
+dependencies = [
+ "itertools",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
diff --git a/vendor/txm/Cargo.toml b/vendor/txm/Cargo.toml
new file mode 100644
index 0000000..d69d90a
--- /dev/null
+++ b/vendor/txm/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "txm"
+version = "0.1.5"
+edition = "2024"
+license = "MIT OR Apache-2.0"
+description = "Terminal math rendering engine"
+authors = ["thatmagicalcat <thatmagicalcat@hotmail.com>"]
+repository = "https://github.com/thatmagicalcat/txm"
+readme = "README.md"
+
+[dependencies]
+logos = "0.16"
+thiserror = "2"
+unicode-width = "0.2"
+
+ratatui-core = { version = "0.1", optional = true }
+
+[features]
+default = []
+ratatui = ["dep:ratatui-core"]
diff --git a/vendor/txm/LICENSE-APACHE b/vendor/txm/LICENSE-APACHE
new file mode 100644
index 0000000..79b85c0
--- /dev/null
+++ b/vendor/txm/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 thatmagicalcat
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/txm/LICENSE-MIT b/vendor/txm/LICENSE-MIT
new file mode 100644
index 0000000..6d20923
--- /dev/null
+++ b/vendor/txm/LICENSE-MIT
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 thatmagicalcat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/txm/README.md b/vendor/txm/README.md
new file mode 100644
index 0000000..42c742f
--- /dev/null
+++ b/vendor/txm/README.md
@@ -0,0 +1,57 @@
+<div align="center">
+  <h1>TXM</h1>
+  <p>TXM (Terminal TeX Math) is a math rendering engine with LaTeX support.</p>
+</div>
+
+# Screenshots:
+![s0](./screenshots/0.png)
+![s1](./screenshots/1.png)
+![s2](./screenshots/2.png)
+![s3](./screenshots/3.png)
+![s4](./screenshots/4.png)
+![s5](./screenshots/5.png)
+
+### Quick run using nix
+```
+nix run github:thatmagicalcat/txm -- "E = mc^2"
+```
+Requires [Nix](https://nix.dev/install-nix) with flakes enabled.
+
+# Installation
+### Arch Linux (AUR)
+Install `txm-git` using an AUR helper like `yay` or `paru`:
+```bash
+yay -S txm-git
+```
+
+Or install it manually:
+```bash
+git clone https://aur.archlinux.org/txm-git.git
+cd txm-git
+makepkg -si
+```
+
+### Gentoo Linux (GURU)
+```bash
+emerge -a app-text/txm
+```
+
+### Cargo (Rust)
+```
+$ cargo install txm
+```
+Or
+```
+$ cargo install --git https://github.com/thatmagicalcat/txm
+```
+
+### Bindings
+- C/C++ bindings live in [`bindings/c/`](./bindings/c/).
+- Python bindings live in [`bindings/py/`](./bindings/py/).
+
+# Projects using TXM:
+- [**txm.nvim**](https://github.com/rv178/txm.nvim/): LaTeX preview inside NeoVim using
+
+## License
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
+- MIT license ([LICENSE-MIT](LICENSE-MIT))
diff --git a/vendor/txm/UPSTREAM.md b/vendor/txm/UPSTREAM.md
new file mode 100644
index 0000000..edc39fb
--- /dev/null
+++ b/vendor/txm/UPSTREAM.md
@@ -0,0 +1,2 @@
+Upstream: https://github.com/thatmagicalcat/txm
+Revision: 26e6d3cfef4d5d040711f4c49d9147aabd350d4d
diff --git a/vendor/txm/src/ast.rs b/vendor/txm/src/ast.rs
new file mode 100644
index 0000000..159f694
--- /dev/null
+++ b/vendor/txm/src/ast.rs
@@ -0,0 +1,36 @@
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    Ident(String),
+    Number(String),
+    Delimiter {
+        left: char,
+        right: char,
+        inner: Box<Expr>,
+    },
+    Neg(Box<Expr>),
+    Command {
+        name: String,
+        opts: Vec<Expr>,
+        args: Vec<Expr>,
+    },
+    Superscript(Box<Expr>, Box<Expr>),
+    Subscript(Box<Expr>, Box<Expr>),
+    BothScripts(Box<Expr>, Box<Expr>, Box<Expr>),
+    Prime(Box<Expr>, usize),
+    BinOp(Box<Expr>, BinOp, Box<Expr>),
+    Juxtapose(Vec<Expr>),
+    Escape(String),
+    Empty,
+    Matrix {
+        name: String,
+        rows: Vec<Vec<Expr>>,
+    },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Eq,
+    Mul,
+}
diff --git a/vendor/txm/src/backend.rs b/vendor/txm/src/backend.rs
new file mode 100644
index 0000000..bb732fd
--- /dev/null
+++ b/vendor/txm/src/backend.rs
@@ -0,0 +1,14 @@
+use crate::layout_tree::LayoutNode;
+use crate::style::Style;
+
+pub trait Backend {
+    type Output;
+    type Error: std::error::Error;
+
+    fn render(&self, tree: &LayoutNode) -> Result<Self::Output, Self::Error>;
+}
+
+pub trait RenderTarget {
+    fn set(&mut self, x: usize, y: usize, ch: char, style: Style);
+    fn fill_row(&mut self, y: usize, x_start: usize, x_end: usize, ch: char, style: Style);
+}
diff --git a/vendor/txm/src/backends/generic_backend.rs b/vendor/txm/src/backends/generic_backend.rs
new file mode 100644
index 0000000..32f41d5
--- /dev/null
+++ b/vendor/txm/src/backends/generic_backend.rs
@@ -0,0 +1,495 @@
+use crate::ast::BinOp;
+use crate::backend::RenderTarget;
+use crate::layout_tree::{LayoutNode, LineStyle, NodeKind};
+use crate::style::Style;
+
+pub(crate) fn render_node(node: &LayoutNode, buf: &mut impl RenderTarget, x: usize, y: usize) {
+    render_inner(node, buf, x, y, Style::new())
+}
+
+fn render_inner(
+    node: &LayoutNode,
+    buf: &mut impl RenderTarget,
+    x: usize,
+    y: usize,
+    inherited: Style,
+) {
+    let style = inherited.merge(node.style);
+
+    match &node.kind {
+        NodeKind::Text { content } => {
+            for (i, &c) in content.iter().enumerate() {
+                buf.set(x + i, y, c, style);
+            }
+        }
+
+        NodeKind::HStack { children, spacing } => {
+            let mut cx = x;
+            for child in children {
+                let cy = y + (node.baseline - child.baseline);
+                render_inner(child, buf, cx, cy, style);
+                cx += child.width + spacing;
+            }
+        }
+
+        NodeKind::VStack { top, bottom, line } => {
+            let max_h = top.height.max(bottom.height);
+            let inner_w = top.width.max(bottom.width);
+            let pad = 1;
+            let top_x = x + pad + (inner_w.saturating_sub(top.width)) / 2;
+            let bot_x = x + pad + (inner_w.saturating_sub(bottom.width)) / 2;
+
+            render_inner(top, buf, top_x, max_h - top.height + y, style);
+            render_inner(bottom, buf, bot_x, y + max_h + 1, style);
+
+            if *line == LineStyle::Solid {
+                let w = node.width;
+                buf.fill_row(y + max_h, x, x + w, '─', style);
+            }
+        }
+
+        NodeKind::Infix { lhs, op, rhs } => {
+            let baseline = lhs.baseline.max(rhs.baseline);
+            let lhs_y = y + (baseline - lhs.baseline);
+            let rhs_y = y + (baseline - rhs.baseline);
+
+            render_inner(lhs, buf, x, lhs_y, style);
+
+            let op_char = match op {
+                BinOp::Add => '+',
+                BinOp::Sub => '-',
+                BinOp::Eq => '=',
+                BinOp::Mul => '·',
+            };
+            buf.set(x + lhs.width + 1, y + baseline, op_char, style);
+
+            render_inner(rhs, buf, x + lhs.width + 3, rhs_y, style);
+        }
+
+        NodeKind::Superscript { inline, base, exp } => {
+            let inline_shift = if !inline { exp.height } else { 0 };
+
+            render_inner(exp, buf, x + base.width, y, style);
+            render_inner(base, buf, x, y + inline_shift, style);
+        }
+
+        NodeKind::Subscript { inline, base, sub } => {
+            let inline_shift = if !inline { base.height } else { 0 };
+
+            render_inner(base, buf, x, y, style);
+            render_inner(sub, buf, x + base.width, y + inline_shift, style);
+        }
+
+        NodeKind::BothScripts { base, sub, sup } => {
+            render_inner(sup, buf, x + base.width, y, style);
+            render_inner(base, buf, x, y + sup.height, style);
+            let sub_y = y + sup.height + base.baseline + 1;
+            render_inner(sub, buf, x + base.width, sub_y, style);
+        }
+
+        NodeKind::StretchyDelim {
+            inner,
+            left,
+            right,
+            fill,
+        } => {
+            if inner.height <= 1 {
+                let resolved_left = resolve_delimiter_single(*left);
+                let resolved_right = resolve_delimiter_single(*right);
+                buf.set(x, y, resolved_left, style);
+                render_inner(inner, buf, x + 1, y, style);
+                buf.set(x + node.width - 1, y, resolved_right, style);
+            } else {
+                let resolved =
+                    resolve_delimiters(*left, *right, inner.height, *fill, inner.baseline);
+                for (row, (l, r)) in resolved.iter().enumerate().take(inner.height) {
+                    buf.set(x, y + row, *l, style);
+                    buf.set(x + node.width - 1, y + row, *r, style);
+                }
+                render_inner(inner, buf, x + 2, y, style);
+            }
+        }
+
+        NodeKind::Accent {
+            inner,
+            mark,
+            stretch,
+        } => {
+            if *stretch {
+                for i in 0..node.width {
+                    buf.set(x + i, y, *mark, style);
+                }
+            } else {
+                buf.set(x + node.width / 2, y, *mark, style);
+            }
+            render_inner(inner, buf, x, y + 1, style);
+        }
+
+        NodeKind::Limits { base, lower, upper } => {
+            let max_h = upper.height.max(lower.height);
+            render_inner(upper, buf, x, y + (max_h - upper.height), style);
+            render_inner(base, buf, x, y + max_h, style);
+            render_inner(lower, buf, x, y + max_h + base.height, style);
+        }
+
+        NodeKind::Sqrt { inner, index } => {
+            buf.set(x + 1, y, '┌', style);
+            for i in 2..node.width {
+                buf.set(x + i, y, '─', style);
+            }
+            for row in 1..node.height {
+                buf.set(x + 1, y + row, '│', style);
+            }
+            buf.set(x, y + node.height - 1, '╲', style);
+            render_inner(inner, buf, x + 3, y + 1, style);
+
+            if let Some(idx) = index {
+                render_inner(idx, buf, x, y, style);
+            }
+        }
+
+        NodeKind::Summation { inner } => {
+            render_summation(inner.as_deref(), buf, x, y, node.height, style);
+        }
+
+        NodeKind::Product { inner } => {
+            render_product(inner.as_deref(), buf, x, y, node.height, style);
+        }
+
+        NodeKind::Integral { inner } => {
+            render_integral(inner.as_deref(), buf, x, y, node.height, style);
+        }
+
+        NodeKind::Matrix { .. } => {
+            render_matrix(node, buf, x, y, style);
+        }
+
+        NodeKind::Neg { inner } => {
+            buf.set(x, y + inner.baseline, '-', style);
+            render_inner(inner, buf, x + 1, y, style);
+        }
+
+        NodeKind::Prime { base, count } => {
+            render_inner(base, buf, x, y, style);
+            for i in 0..*count {
+                buf.set(x + base.width + i, y + base.baseline, '\'', style);
+            }
+        }
+
+        NodeKind::Empty => {}
+    }
+}
+
+fn resolve_delimiter_single(c: char) -> char {
+    match c {
+        '|' => '│',
+        _ => c,
+    }
+}
+
+fn resolve_delimiters(
+    left: char,
+    right: char,
+    height: usize,
+    fill: bool,
+    baseline: usize,
+) -> Vec<(char, char)> {
+    let (tl, tr, bl, br, ml, mr) = match (left, right) {
+        ('(', ')') => ('⎛', '⎞', '⎝', '⎠', '⎜', '⎟'),
+        ('[', ']') => ('⎡', '⎤', '⎣', '⎦', '⎢', '⎥'),
+        ('{', '}') => ('⎧', '⎫', '⎩', '⎭', '⎪', '⎪'),
+        ('|', '|') => ('⎪', '⎪', '⎪', '⎪', '⎪', '⎪'),
+        _ if fill => (left, right, left, right, left, right),
+        _ => (left, right, left, right, '│', '│'),
+    };
+
+    let mut result = Vec::with_capacity(height);
+    for row in 0..height {
+        let (l, r) = if row == 0 {
+            (tl, tr)
+        } else if row == height - 1 {
+            (bl, br)
+        } else if left == '{' && row == baseline {
+            ('⎨', '⎬')
+        } else {
+            (ml, mr)
+        };
+        result.push((l, r));
+    }
+    result
+}
+
+fn render_summation(
+    inner: Option<&LayoutNode>,
+    buf: &mut impl RenderTarget,
+    x: usize,
+    y: usize,
+    h: usize,
+    style: Style,
+) {
+    let inner = match inner {
+        Some(i) => i,
+        None => {
+            buf.set(x, y, '━', style);
+            buf.set(x + 1, y, '━', style);
+            buf.set(x + 2, y, '━', style);
+            buf.set(x + 3, y, '┓', style);
+            buf.set(x, y + 1, '⟩', style);
+            buf.set(x, y + 2, '━', style);
+            buf.set(x + 1, y + 2, '━', style);
+            buf.set(x + 2, y + 2, '━', style);
+            buf.set(x + 3, y + 2, '┛', style);
+
+            return;
+        }
+    };
+
+    if inner.height <= 2 {
+        let w_sigma = 4;
+        buf.set(x, y, '━', style);
+        buf.set(x + 1, y, '━', style);
+        buf.set(x + 2, y, '━', style);
+        buf.set(x + 3, y, '┓', style);
+        buf.set(x, y + 1, '⟩', style);
+        buf.set(x, y + 2, '━', style);
+        buf.set(x + 1, y + 2, '━', style);
+        buf.set(x + 2, y + 2, '━', style);
+        buf.set(x + 3, y + 2, '┛', style);
+        let inner_y = y + (h.saturating_sub(inner.height)) / 2;
+        render_inner(inner, buf, x + w_sigma + 1, inner_y, style);
+        return;
+    }
+
+    let w_sigma = ((1.5 * h as f32) as usize).max(h / 2 + 2);
+
+    buf.fill_row(y, x, x + w_sigma - 1, '━', style);
+    buf.set(x + w_sigma - 1, y, '┓', style);
+
+    buf.fill_row(y + h - 1, x, x + w_sigma - 1, '━', style);
+    buf.set(x + w_sigma - 1, y + h - 1, '┛', style);
+
+    for r in 1..h - 1 {
+        let d = r.min(h - 1 - r);
+        let col = d.saturating_sub(1);
+
+        let ch = if !h.is_power_of_two() && r == h / 2 {
+            '⟩'
+        } else if r < h / 2 {
+            '╲'
+        } else {
+            '╱'
+        };
+
+        buf.set(x + col, y + r, ch, style);
+    }
+
+    render_inner(inner, buf, x + w_sigma + 1, y, style);
+}
+
+fn render_product(
+    inner: Option<&LayoutNode>,
+    buf: &mut impl RenderTarget,
+    x: usize,
+    y: usize,
+    h: usize,
+    style: Style,
+) {
+    let inner = match inner {
+        Some(i) => i,
+        None => {
+            buf.set(x, y, '┳', style);
+            buf.set(x + 1, y, '━', style);
+            buf.set(x + 2, y, '┳', style);
+            buf.set(x, y + 1, '┃', style);
+            buf.set(x + 2, y + 1, '┃', style);
+            return;
+        }
+    };
+
+    let w_pi = if h <= 2 { 3 } else { (h / 2 + 2).max(3) };
+
+    buf.set(x, y, '┳', style);
+    if w_pi > 2 {
+        buf.fill_row(y, x + 1, x + w_pi - 1, '━', style);
+    }
+    buf.set(x + w_pi - 1, y, '┳', style);
+
+    for row in 1..h {
+        buf.set(x, y + row, '┃', style);
+        buf.set(x + w_pi - 1, y + row, '┃', style);
+    }
+
+    let inner_y = y + (h.saturating_sub(inner.height)) / 2;
+    render_inner(inner, buf, x + w_pi + 1, inner_y, style);
+}
+
+fn render_integral(
+    inner: Option<&LayoutNode>,
+    buf: &mut impl RenderTarget,
+    x: usize,
+    y: usize,
+    _h: usize,
+    style: Style,
+) {
+    let inner = match inner {
+        Some(i) => i,
+        None => {
+            buf.set(x, y, '⎛', style);
+            buf.set(x, y + 1, '⎜', style);
+            buf.set(x, y + 2, '⎠', style);
+            return;
+        }
+    };
+
+    if inner.height <= 3 {
+        buf.set(x, y, '⎛', style);
+        buf.set(x, y + 1, '⎜', style);
+        buf.set(x, y + 2, '⎠', style);
+        let inner_y = if inner.height == 1 { y + 1 } else { y };
+        render_inner(inner, buf, x + 2, inner_y, style);
+    } else {
+        buf.set(x, y, '⎛', style);
+        for row in 1..inner.height - 1 {
+            buf.set(x, y + row, '⎜', style);
+        }
+        buf.set(x, y + inner.height - 1, '⎠', style);
+        render_inner(inner, buf, x + 2, y, style);
+    }
+}
+
+fn render_matrix(
+    node: &LayoutNode,
+    buf: &mut impl RenderTarget,
+    x: usize,
+    y: usize,
+    inherited: Style,
+) {
+    let NodeKind::Matrix { name: _, rows } = &node.kind else {
+        return;
+    };
+
+    if rows.is_empty() || rows[0].is_empty() {
+        return;
+    }
+
+    let num_rows = rows.len();
+
+    let mut row_max_depths = vec![0; num_rows];
+    let mut row_max_baselines = vec![0; num_rows];
+    let mut max_item_width = 0;
+
+    for (i, row) in rows.iter().enumerate() {
+        let mut max_b = 0;
+        let mut max_d = 0;
+        for item in row {
+            max_item_width = max_item_width.max(item.width);
+            max_b = max_b.max(item.baseline);
+            max_d = max_d.max(item.height.saturating_sub(item.baseline));
+        }
+        row_max_baselines[i] = max_b;
+        row_max_depths[i] = max_d;
+    }
+
+    let cell_width = max_item_width;
+    let mut cell_height = 0;
+    for i in 0..num_rows {
+        let row_content_height = row_max_baselines[i] + row_max_depths[i];
+        cell_height = cell_height.max(row_content_height);
+    }
+
+    let row_padding = 1;
+    cell_height = cell_height.max(1);
+
+    let active_cell_height = if num_rows > 1 {
+        cell_height + row_padding
+    } else {
+        cell_height
+    };
+
+    let hspacing = 4;
+
+    let inner_x = x;
+    let inner_y = y;
+
+    for (i, row) in rows.iter().enumerate() {
+        let row_content_height = row_max_baselines[i] + row_max_depths[i];
+        let row_padding_top = (active_cell_height - row_content_height) / 2;
+        let row_cell_baseline = row_padding_top + row_max_baselines[i];
+
+        for (j, item) in row.iter().enumerate() {
+            let cell_x = inner_x + j * (cell_width + hspacing);
+            let cell_y = inner_y + i * active_cell_height;
+
+            let item_x_in_cell = (cell_width - item.width) / 2;
+            let item_y_in_cell = row_cell_baseline - item.baseline;
+
+            render_inner(
+                item,
+                buf,
+                cell_x + item_x_in_cell,
+                cell_y + item_y_in_cell,
+                inherited,
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::render_node;
+    use crate::backend::RenderTarget;
+    use crate::style::{Color, Style};
+
+    struct StyleBuf {
+        cells: Vec<(char, Style)>,
+        width: usize,
+    }
+
+    impl StyleBuf {
+        fn new(width: usize, height: usize) -> Self {
+            Self {
+                cells: vec![(' ', Style::new()); width * height],
+                width,
+            }
+        }
+    }
+
+    impl RenderTarget for StyleBuf {
+        fn set(&mut self, x: usize, y: usize, ch: char, style: Style) {
+            let index = y * self.width + x;
+            self.cells[index] = (ch, style);
+        }
+
+        fn fill_row(&mut self, y: usize, x_start: usize, x_end: usize, ch: char, style: Style) {
+            for x in x_start..x_end {
+                self.set(x, y, ch, style);
+            }
+        }
+    }
+
+    #[test]
+    fn current_color_reaches_generated_renderer_cells() {
+        for input in [
+            r"\color{red}{x+y}",
+            r"\color{red}{-x}",
+            r"\color{red}{x'}",
+            r"\color{red}{\int_a^b{f'\left(x\right) dx}}",
+        ] {
+            let tree = crate::layout(input).unwrap();
+            let mut buf = StyleBuf::new(tree.width, tree.height);
+            render_node(&tree, &mut buf, 0, 0);
+
+            let uncolored: String = buf
+                .cells
+                .iter()
+                .filter(|(ch, style)| *ch != ' ' && Color::new(style.fg_color()) != Color::RED)
+                .map(|(ch, _)| *ch)
+                .collect();
+
+            assert!(
+                uncolored.is_empty(),
+                "expected all cells in {input:?} to be red, uncolored: {uncolored:?}"
+            );
+        }
+    }
+}
diff --git a/vendor/txm/src/backends/mod.rs b/vendor/txm/src/backends/mod.rs
new file mode 100644
index 0000000..83d5c73
--- /dev/null
+++ b/vendor/txm/src/backends/mod.rs
@@ -0,0 +1,2 @@
+pub(crate) mod generic_backend;
+pub mod terminal;
diff --git a/vendor/txm/src/backends/terminal.rs b/vendor/txm/src/backends/terminal.rs
new file mode 100644
index 0000000..c1ea5f3
--- /dev/null
+++ b/vendor/txm/src/backends/terminal.rs
@@ -0,0 +1,104 @@
+use std::fmt;
+use std::fmt::Write;
+
+use crate::backend::Backend;
+use crate::backend::RenderTarget;
+use crate::layout_tree::LayoutNode;
+use crate::style::Style;
+
+use super::generic_backend;
+
+pub struct TerminalBackend;
+
+impl TerminalBackend {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for TerminalBackend {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Backend for TerminalBackend {
+    type Output = String;
+    type Error = fmt::Error;
+
+    fn render(&self, tree: &LayoutNode) -> Result<String, fmt::Error> {
+        let mut buf = CharBuf::new(tree.width, tree.height);
+        generic_backend::render_node(tree, &mut buf, 0, 0);
+        Ok(buf.to_string())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct CharBuf {
+    pub data: Vec<char>,
+    pub styles: Vec<Style>,
+    pub width: usize,
+    pub height: usize,
+}
+
+impl CharBuf {
+    pub fn new(width: usize, height: usize) -> Self {
+        Self {
+            data: vec![' '; width * height],
+            styles: vec![Style::default(); width * height],
+            width,
+            height,
+        }
+    }
+}
+
+impl fmt::Display for CharBuf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let style_rows = self.styles.chunks_exact(self.width).take(self.height);
+        let data_rows = self.data.chunks_exact(self.width).take(self.height);
+
+        for (style_row, data_row) in style_rows.zip(data_rows) {
+            let mut active_style: Option<&Style> = None;
+
+            for (style, &data) in style_row.iter().zip(data_row.iter()) {
+                if Some(style) != active_style {
+                    if active_style.is_some_and(|s| !s.is_empty()) {
+                        f.write_str("\x1b[0m")?;
+                    }
+
+                    if !style.is_empty() {
+                        style.write_ansi_prefix(f)?;
+                    }
+
+                    active_style = Some(style);
+                }
+
+                f.write_char(data)?;
+            }
+
+            if active_style.is_some_and(|s| !s.is_empty()) {
+                f.write_str("\x1b[0m")?;
+            }
+
+            writeln!(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl RenderTarget for CharBuf {
+    fn set(&mut self, x: usize, y: usize, ch: char, style: Style) {
+        if x < self.width && y < self.height {
+            let i = y * self.width + x;
+            self.data[i] = ch;
+            self.styles[i] = style;
+        }
+    }
+
+    fn fill_row(&mut self, y: usize, x_start: usize, x_end: usize, ch: char, style: Style) {
+        for x in x_start..x_end.min(self.width) {
+            self.set(x, y, ch, style);
+        }
+    }
+}
diff --git a/vendor/txm/src/error.rs b/vendor/txm/src/error.rs
new file mode 100644
index 0000000..bbcfe92
--- /dev/null
+++ b/vendor/txm/src/error.rs
@@ -0,0 +1,92 @@
+use std::ops::Range;
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseError {
+    #[error("invalid token at byte {byte}")]
+    InvalidToken { byte: usize },
+
+    #[error("unexpected end of input")]
+    UnexpectedEof,
+
+    #[error("unexpected token at position {position}: {token}")]
+    UnexpectedToken { position: usize, token: String },
+
+    #[error("unexpected whitespace")]
+    UnexpectedWhitespace,
+
+    #[error("unexpected \\right without matching \\left")]
+    UnexpectedRightWithoutLeft,
+
+    #[error("expected {expected}")]
+    ExpectedToken { expected: String },
+
+    #[error("expected {expected}, got {got}")]
+    ExpectedTokenGot { expected: String, got: String },
+
+    #[error("expected a string")]
+    ExpectedString,
+
+    #[error("expected a delimiter after \\{side}")]
+    ExpectedDelimiter { side: &'static str },
+
+    #[error("mismatched delimiters: \\left{left} and \\right{right}")]
+    MismatchedDelimiters { left: char, right: char },
+
+    #[error("unclosed \\left ... \\right pair")]
+    UnclosedLeftRight,
+
+    #[error("unclosed \\begin{{{name}}}")]
+    UnclosedEnvironment { name: String },
+
+    #[error("mismatched \\begin{{{begin}}} and \\end{{{end}}}")]
+    MismatchedEnvironment { begin: String, end: String },
+
+    #[error("unknown matrix environment: {name}")]
+    UnknownEnvironment { name: String },
+
+    #[error("expected a color name")]
+    ExpectedColorName,
+
+    #[error("invalid color name: {name}")]
+    InvalidColor { name: String },
+
+    #[error("matrix rows have different lengths")]
+    MismatchedMatrixRows,
+
+    #[error("internal parser error: {0}")]
+    Internal(String),
+
+    #[error("{msg} near '{snippet}' at byte {byte}")]
+    Located {
+        msg: String,
+        snippet: String,
+        byte: usize,
+    },
+
+    #[error("{msg} but reached end of input near '{snippet}'")]
+    LocatedEof { msg: String, snippet: String },
+}
+
+impl ParseError {
+    pub fn at(self, span: Range<usize>, input: &str) -> Self {
+        let snippet = input[span.clone()].to_string();
+        ParseError::Located {
+            msg: self.to_string(),
+            snippet,
+            byte: span.start,
+        }
+    }
+
+    pub fn at_eof(self, input: &str) -> Self {
+        if input.is_empty() {
+            return self;
+        }
+
+        let n = input.len();
+        let snippet = input[n.saturating_sub(5)..].to_string();
+        ParseError::LocatedEof {
+            msg: self.to_string(),
+            snippet,
+        }
+    }
+}
diff --git a/vendor/txm/src/glyph.rs b/vendor/txm/src/glyph.rs
new file mode 100644
index 0000000..5b1798d
--- /dev/null
+++ b/vendor/txm/src/glyph.rs
@@ -0,0 +1,537 @@
+use crate::ParseError;
+use crate::ast::Expr;
+use crate::layout_tree::{LayoutNode, NodeKind};
+use crate::style::Style;
+use std::collections::HashMap;
+use std::fmt::Debug;
+
+#[derive(Debug, Default, Clone, Copy)]
+pub struct RenderCtx {
+    pub depth: usize,
+    pub current_style: Style,
+}
+
+pub trait Glyph: Debug + Send + Sync {
+    fn required_args(&self) -> usize {
+        0
+    }
+
+    fn has_optional(&self) -> bool {
+        false
+    }
+
+    fn has_limits(&self) -> bool {
+        false
+    }
+
+    fn takes_string_arg(&self) -> bool {
+        false
+    }
+
+    fn render_macro(
+        &self,
+        args: &[Expr],
+        opts: &[Expr],
+        ctx: &mut RenderCtx,
+        eval: &mut dyn FnMut(&Expr, &mut RenderCtx) -> Result<LayoutNode, ParseError>,
+    ) -> Result<LayoutNode, ParseError> {
+        let mut rendered_args = Vec::with_capacity(args.len());
+        for arg in args {
+            rendered_args.push(eval(arg, ctx)?);
+        }
+
+        let mut rendered_opts = Vec::with_capacity(opts.len());
+        for opt in opts {
+            rendered_opts.push(eval(opt, ctx)?);
+        }
+
+        Ok(self.render(&rendered_args, &rendered_opts, ctx))
+    }
+
+    fn render(&self, _args: &[LayoutNode], _opts: &[LayoutNode], _ctx: &RenderCtx) -> LayoutNode {
+        LayoutNode::empty()
+    }
+}
+
+pub struct SymbolRegistry {
+    map: HashMap<String, Box<dyn Glyph>>,
+}
+
+impl SymbolRegistry {
+    pub fn new() -> Self {
+        Self {
+            map: HashMap::new(),
+        }
+    }
+
+    pub fn register(&mut self, name: impl Into<String>, glyph: impl Glyph + 'static) {
+        self.map.insert(name.into(), Box::new(glyph));
+    }
+
+    pub fn get(&self, name: &str) -> Option<&dyn Glyph> {
+        self.map.get(name).map(|g| g.as_ref())
+    }
+}
+
+#[derive(Debug)]
+pub struct LimitGlyph;
+
+impl Glyph for LimitGlyph {
+    fn render(&self, _args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let mut node = LayoutNode::text_str("lim");
+        node.style = ctx.current_style.un_italic();
+        node
+    }
+
+    fn required_args(&self) -> usize {
+        0
+    }
+
+    fn has_limits(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Debug)]
+pub struct UnicodeGlyph(pub char);
+
+impl Glyph for UnicodeGlyph {
+    fn render(&self, _args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        LayoutNode::text_with_style(vec![self.0], ctx.current_style.un_italic())
+    }
+}
+
+#[derive(Debug)]
+pub struct TextGlyph(pub &'static str);
+
+impl Glyph for TextGlyph {
+    fn render(&self, _args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        LayoutNode::text_with_style(self.0.chars().collect(), ctx.current_style.un_italic())
+    }
+}
+
+#[derive(Debug)]
+pub struct BinomGlyph;
+
+impl Glyph for BinomGlyph {
+    fn required_args(&self) -> usize {
+        2
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let inner = LayoutNode::vstack(
+            args[0].clone(),
+            args[1].clone(),
+            crate::layout_tree::LineStyle::None,
+            ctx.current_style,
+        );
+
+        LayoutNode::stretchy_delim(inner, '(', ')', false, ctx.current_style.un_italic())
+    }
+}
+
+#[derive(Debug)]
+pub struct FracGlyph;
+
+impl Glyph for FracGlyph {
+    fn required_args(&self) -> usize {
+        2
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        LayoutNode::vstack(
+            args[0].clone(),
+            args[1].clone(),
+            crate::layout_tree::LineStyle::Solid,
+            ctx.current_style,
+        )
+    }
+}
+
+#[derive(Debug)]
+pub struct SqrtGlyph;
+
+impl Glyph for SqrtGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn has_optional(&self) -> bool {
+        true
+    }
+
+    fn render(&self, args: &[LayoutNode], opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let index = opts.first().cloned();
+        let mut node = LayoutNode::sqrt(args[0].clone(), index);
+        node.style = ctx.current_style;
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct SummationGlyph;
+impl Glyph for SummationGlyph {
+    fn has_optional(&self) -> bool {
+        true
+    }
+
+    fn has_limits(&self) -> bool {
+        true
+    }
+
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let inner = if args.is_empty() {
+            None
+        } else {
+            Some(args[0].clone())
+        };
+        let mut node = LayoutNode::summation(inner);
+        node.style = ctx.current_style;
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct ProductGlyph;
+impl Glyph for ProductGlyph {
+    fn has_limits(&self) -> bool {
+        true
+    }
+
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let inner = if args.is_empty() {
+            None
+        } else {
+            Some(args[0].clone())
+        };
+        let mut node = LayoutNode::product(inner);
+        node.style = ctx.current_style;
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct IntegralGlyph;
+
+impl Glyph for IntegralGlyph {
+    fn has_limits(&self) -> bool {
+        true
+    }
+
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let inner = if args.is_empty() {
+            None
+        } else {
+            Some(args[0].clone())
+        };
+
+        let mut node = LayoutNode::integral(inner);
+        node.style = ctx.current_style;
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct AlphabetGlyph(pub fn(char) -> char);
+
+impl Glyph for AlphabetGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let src = &args[0];
+        match &src.kind {
+            crate::layout_tree::NodeKind::Text { content } => {
+                let mapped: Vec<char> = content.iter().map(|&c| (self.0)(c)).collect();
+                LayoutNode {
+                    width: src.width,
+                    height: src.height,
+                    baseline: src.baseline,
+                    style: ctx.current_style.merge(src.style),
+                    kind: crate::layout_tree::NodeKind::Text { content: mapped },
+                }
+            }
+            _ => {
+                let mut node = src.clone();
+                node.style = ctx.current_style.merge(node.style);
+                node
+            }
+        }
+    }
+}
+
+fn shift(c: char, base: u32, off: u32) -> char {
+    char::from_u32(base + off).unwrap_or(c)
+}
+
+pub fn to_bold(c: char) -> char {
+    match c {
+        'A'..='Z' => shift(c, 0x1D400, c as u32 - 'A' as u32),
+        'a'..='z' => shift(c, 0x1D41A, c as u32 - 'a' as u32),
+        '0'..='9' => shift(c, 0x1D7CE, c as u32 - '0' as u32),
+        // Italic uppercase → bold italic uppercase
+        '\u{1D434}'..='\u{1D44D}' => shift(c, 0x1D468, c as u32 - 0x1D434),
+        // Italic lowercase → bold italic lowercase
+        '\u{1D44E}'..='\u{1D467}' => shift(c, 0x1D482, c as u32 - 0x1D44E),
+        _ => c,
+    }
+}
+
+pub fn to_bb(c: char) -> char {
+    match c {
+        'C' => 'ℂ',
+        'H' => 'ℍ',
+        'N' => 'ℕ',
+        'P' => 'ℙ',
+        'Q' => 'ℚ',
+        'R' => 'ℝ',
+        'Z' => 'ℤ',
+        'A'..='Z' => shift(c, 0x1D538, c as u32 - 'A' as u32),
+        'a'..='z' => shift(c, 0x1D552, c as u32 - 'a' as u32),
+        '0'..='9' => shift(c, 0x1D7D8, c as u32 - '0' as u32),
+        // Italic uppercase → double-struck (with special cases for common letters)
+        '\u{1D436}' => 'ℂ', // italic C
+        '\u{1D43B}' => 'ℍ', // italic H
+        '\u{1D441}' => 'ℕ', // italic N
+        '\u{1D443}' => 'ℙ', // italic P
+        '\u{1D444}' => 'ℚ', // italic Q
+        '\u{1D445}' => 'ℝ', // italic R
+        '\u{1D44D}' => 'ℤ', // italic Z
+        '\u{1D434}'..='\u{1D44D}' => shift(c, 0x1D538, c as u32 - 0x1D434),
+        // Italic lowercase → double-struck lowercase
+        '\u{1D44E}'..='\u{1D467}' => shift(c, 0x1D552, c as u32 - 0x1D44E),
+        _ => c,
+    }
+}
+
+pub fn to_upright(c: char) -> char {
+    c
+}
+
+pub fn to_italic(c: char) -> char {
+    match c {
+        'h' => 'ℎ',
+        'A'..='Z' => shift(c, 0x1D434, c as u32 - 'A' as u32),
+        'a'..='z' => shift(c, 0x1D44E, c as u32 - 'a' as u32),
+        _ => c,
+    }
+}
+
+#[allow(dead_code)]
+pub fn to_bold_italic(c: char) -> char {
+    match c {
+        'A'..='Z' => shift(c, 0x1D468, c as u32 - 'A' as u32),
+        'a'..='z' => shift(c, 0x1D482, c as u32 - 'a' as u32),
+        // Italic uppercase → bold italic uppercase
+        '\u{1D434}'..='\u{1D44D}' => shift(c, 0x1D468, c as u32 - 0x1D434),
+        // Italic lowercase → bold italic lowercase
+        '\u{1D44E}'..='\u{1D467}' => shift(c, 0x1D482, c as u32 - 0x1D44E),
+        _ => c,
+    }
+}
+
+pub fn to_sans(c: char) -> char {
+    match c {
+        'A'..='Z' => shift(c, 0x1D5A0, c as u32 - 'A' as u32),
+        'a'..='z' => shift(c, 0x1D5BA, c as u32 - 'a' as u32),
+        '0'..='9' => shift(c, 0x1D7E2, c as u32 - '0' as u32),
+        // Italic uppercase → sans-serif italic uppercase
+        '\u{1D434}'..='\u{1D44D}' => shift(c, 0x1D5A0 + 0x60, c as u32 - 0x1D434),
+        // Italic lowercase → sans-serif italic lowercase
+        '\u{1D44E}'..='\u{1D467}' => shift(c, 0x1D5BA + 0x60, c as u32 - 0x1D44E),
+        _ => c,
+    }
+}
+
+#[derive(Debug)]
+pub struct AbsGlyph;
+
+impl Glyph for AbsGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let mut node = LayoutNode::stretchy_delim(
+            args[0].clone(),
+            '|',
+            '|',
+            false,
+            ctx.current_style.un_italic(),
+        );
+
+        node.style = ctx.current_style;
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct AccentGlyph {
+    pub mark: char,
+    pub stretch: bool,
+}
+
+impl Glyph for AccentGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render(&self, args: &[LayoutNode], _opts: &[LayoutNode], ctx: &RenderCtx) -> LayoutNode {
+        let mut node = LayoutNode::accent(args[0].clone(), self.mark, self.stretch);
+        node.style = ctx.current_style.un_italic();
+        node
+    }
+}
+
+#[derive(Debug)]
+pub struct TextColorGlyph;
+
+impl Glyph for TextColorGlyph {
+    fn required_args(&self) -> usize {
+        2
+    }
+
+    fn takes_string_arg(&self) -> bool {
+        true
+    }
+
+    fn render_macro(
+        &self,
+        args: &[Expr],
+        _opts: &[Expr],
+        ctx: &mut RenderCtx,
+        eval: &mut dyn FnMut(&Expr, &mut RenderCtx) -> Result<LayoutNode, ParseError>,
+    ) -> Result<LayoutNode, ParseError> {
+        let color_str = if let Expr::Ident(c) = &args[0] {
+            c.as_str()
+        } else {
+            return Err(ParseError::ExpectedColorName);
+        };
+
+        let prev_style = ctx.current_style;
+        ctx.current_style = ctx.current_style.fg(crate::style::parse_color(color_str)?);
+
+        let result = eval(&args[1], ctx);
+
+        ctx.current_style = prev_style;
+        result
+    }
+}
+
+#[derive(Debug)]
+pub struct StyleModifierGlyph {
+    pub modify: fn(Style) -> Style,
+}
+
+impl Glyph for StyleModifierGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn takes_string_arg(&self) -> bool {
+        true
+    }
+
+    fn render_macro(
+        &self,
+        args: &[Expr],
+        _opts: &[Expr],
+        ctx: &mut RenderCtx,
+        eval: &mut dyn FnMut(&Expr, &mut RenderCtx) -> Result<LayoutNode, ParseError>,
+    ) -> Result<LayoutNode, ParseError> {
+        let prev = ctx.current_style;
+        ctx.current_style = (self.modify)(ctx.current_style);
+        let result = eval(&args[0], ctx);
+        ctx.current_style = prev;
+        result
+    }
+}
+
+#[derive(Debug)]
+pub struct MappedStyleGlyph {
+    pub modify: fn(Style) -> Style,
+    pub map: fn(char) -> char,
+}
+
+impl Glyph for MappedStyleGlyph {
+    fn required_args(&self) -> usize {
+        1
+    }
+
+    fn render_macro(
+        &self,
+        args: &[Expr],
+        _opts: &[Expr],
+        ctx: &mut RenderCtx,
+        eval: &mut dyn FnMut(&Expr, &mut RenderCtx) -> Result<LayoutNode, ParseError>,
+    ) -> Result<LayoutNode, ParseError> {
+        let prev = ctx.current_style;
+        ctx.current_style = (self.modify)(ctx.current_style);
+        let mut result = eval(&args[0], ctx)?;
+        ctx.current_style = prev;
+        map_node_chars(&mut result, self.map);
+        Ok(result)
+    }
+}
+
+fn map_node_chars(node: &mut LayoutNode, map: fn(char) -> char) {
+    match &mut node.kind {
+        NodeKind::Text { content } => {
+            for c in content.iter_mut() {
+                *c = map(*c);
+            }
+        }
+        NodeKind::HStack { children, .. } => {
+            for child in children.iter_mut() {
+                map_node_chars(child, map);
+            }
+        }
+        _ => {}
+    }
+}
+
+#[derive(Debug)]
+pub struct BgColorGlyph;
+
+impl Glyph for BgColorGlyph {
+    fn required_args(&self) -> usize {
+        2
+    }
+
+    fn takes_string_arg(&self) -> bool {
+        true
+    }
+
+    fn render_macro(
+        &self,
+        args: &[Expr],
+        _opts: &[Expr],
+        ctx: &mut RenderCtx,
+        eval: &mut dyn FnMut(&Expr, &mut RenderCtx) -> Result<LayoutNode, ParseError>,
+    ) -> Result<LayoutNode, ParseError> {
+        let color_str = if let Expr::Ident(c) = &args[0] {
+            c.as_str()
+        } else {
+            return Err(ParseError::ExpectedColorName);
+        };
+
+        let prev = ctx.current_style;
+        ctx.current_style = ctx.current_style.bg(crate::style::parse_color(color_str)?);
+        let result = eval(&args[1], ctx);
+        ctx.current_style = prev;
+        result
+    }
+}
diff --git a/vendor/txm/src/layout_tree.rs b/vendor/txm/src/layout_tree.rs
new file mode 100644
index 0000000..3be27da
--- /dev/null
+++ b/vendor/txm/src/layout_tree.rs
@@ -0,0 +1,697 @@
+use crate::ast::BinOp;
+use crate::style::Style;
+
+#[derive(Debug, Clone)]
+pub struct LayoutNode {
+    pub width: usize,
+    pub height: usize,
+    pub baseline: usize,
+    pub style: Style,
+    pub kind: NodeKind,
+}
+
+#[derive(Debug, Clone)]
+pub enum NodeKind {
+    Text {
+        content: Vec<char>,
+    },
+
+    HStack {
+        children: Vec<LayoutNode>,
+        spacing: usize,
+    },
+
+    VStack {
+        top: Box<LayoutNode>,
+        bottom: Box<LayoutNode>,
+        line: LineStyle,
+    },
+
+    Infix {
+        lhs: Box<LayoutNode>,
+        op: BinOp,
+        rhs: Box<LayoutNode>,
+    },
+
+    Superscript {
+        inline: bool,
+        base: Box<LayoutNode>,
+        exp: Box<LayoutNode>,
+    },
+
+    Subscript {
+        inline: bool,
+        base: Box<LayoutNode>,
+        sub: Box<LayoutNode>,
+    },
+
+    BothScripts {
+        base: Box<LayoutNode>,
+        sub: Box<LayoutNode>,
+        sup: Box<LayoutNode>,
+    },
+
+    StretchyDelim {
+        inner: Box<LayoutNode>,
+        left: char,
+        right: char,
+        fill: bool,
+    },
+
+    Accent {
+        inner: Box<LayoutNode>,
+        mark: char,
+        stretch: bool,
+    },
+
+    Limits {
+        base: Box<LayoutNode>,
+        lower: Box<LayoutNode>,
+        upper: Box<LayoutNode>,
+    },
+
+    Sqrt {
+        inner: Box<LayoutNode>,
+        index: Option<Box<LayoutNode>>,
+    },
+
+    Matrix {
+        name: String,
+        rows: Vec<Vec<LayoutNode>>,
+    },
+
+    Summation {
+        inner: Option<Box<LayoutNode>>,
+    },
+
+    Product {
+        inner: Option<Box<LayoutNode>>,
+    },
+
+    Integral {
+        inner: Option<Box<LayoutNode>>,
+    },
+
+    Neg {
+        inner: Box<LayoutNode>,
+    },
+
+    Prime {
+        base: Box<LayoutNode>,
+        count: usize,
+    },
+
+    Empty,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LineStyle {
+    Solid,
+    None,
+}
+
+impl LayoutNode {
+    pub fn empty() -> Self {
+        Self {
+            width: 0,
+            height: 0,
+            baseline: 0,
+            style: Style::new(),
+            kind: NodeKind::Empty,
+        }
+    }
+
+    pub fn text(content: Vec<char>) -> Self {
+        let width = content.len();
+        Self {
+            width,
+            height: 1,
+            baseline: 0,
+            style: Style::new(),
+            kind: NodeKind::Text { content },
+        }
+    }
+
+    pub fn text_with_style(content: Vec<char>, style: Style) -> Self {
+        let width = content.len();
+        Self {
+            width,
+            height: 1,
+            baseline: 0,
+            style,
+            kind: NodeKind::Text { content },
+        }
+    }
+
+    pub fn from_char(c: char) -> Self {
+        Self::text(vec![c])
+    }
+
+    pub fn text_str(s: &str) -> Self {
+        Self::text(s.chars().collect())
+    }
+
+    pub fn hstack(children: &[LayoutNode], spacing: usize) -> Self {
+        if children.is_empty() {
+            return Self::empty();
+        }
+        if children.len() == 1 {
+            return children[0].clone();
+        }
+
+        let baseline = children.iter().map(|n| n.baseline).max().unwrap_or(0);
+        let height = children
+            .iter()
+            .map(|n| {
+                let below = n.height.saturating_sub(n.baseline);
+                baseline + below
+            })
+            .max()
+            .unwrap_or(0);
+
+        let total_width: usize =
+            children.iter().map(|n| n.width).sum::<usize>() + spacing * (children.len() - 1);
+
+        Self {
+            width: total_width,
+            height,
+            baseline,
+            style: Style::new(),
+            kind: NodeKind::HStack {
+                children: children.to_vec(),
+                spacing,
+            },
+        }
+    }
+
+    pub fn vstack(top: LayoutNode, bottom: LayoutNode, line: LineStyle, style: Style) -> Self {
+        let inner_w = top.width.max(bottom.width);
+        let pad = 1;
+        let max_h = top.height.max(bottom.height);
+        let w = inner_w + 2 * pad;
+        let h = max_h * 2 + 1;
+        let baseline = max_h;
+
+        Self {
+            width: w,
+            height: h,
+            baseline,
+            style,
+            kind: NodeKind::VStack {
+                top: Box::new(top),
+                bottom: Box::new(bottom),
+                line,
+            },
+        }
+    }
+
+    pub fn infix(lhs: LayoutNode, op: BinOp, rhs: LayoutNode) -> Self {
+        let baseline = lhs.baseline.max(rhs.baseline);
+        let lhs_y = baseline - lhs.baseline;
+        let rhs_y = baseline - rhs.baseline;
+
+        let width = lhs.width + 3 + rhs.width;
+        let height = (lhs_y + lhs.height).max(rhs_y + rhs.height);
+
+        Self {
+            width,
+            height,
+            baseline,
+            style: Style::new(),
+            kind: NodeKind::Infix {
+                lhs: Box::new(lhs),
+                op,
+                rhs: Box::new(rhs),
+            },
+        }
+    }
+
+    pub fn superscript(base: LayoutNode, exp: LayoutNode, style: Style) -> Self {
+        if exp.height == 1
+            && let converted = map_content(&exp.kind, to_superscript_char)
+            && converted.len() == exp.width
+        {
+            return Self {
+                width: base.width + exp.width,
+                height: base.height,
+                baseline: base.baseline,
+                style,
+                kind: NodeKind::Superscript {
+                    inline: true,
+                    base: Box::new(base),
+                    exp: Box::new(LayoutNode::text_with_style(converted, Style::new())),
+                },
+            };
+        }
+
+        let height = exp.height + base.height;
+        let width = exp.width + base.width;
+        let baseline = base.baseline + exp.height;
+        let inline = false;
+
+        Self {
+            width,
+            height,
+            baseline,
+            style,
+            kind: NodeKind::Superscript {
+                inline,
+                base: Box::new(base),
+                exp: Box::new(exp),
+            },
+        }
+    }
+
+    pub fn subscript(base: LayoutNode, sub: LayoutNode, style: Style) -> Self {
+        if sub.height == 1
+            && let converted = map_content(&sub.kind, to_subscript_char)
+            && converted.len() == sub.width
+        {
+            return Self {
+                width: base.width + sub.width,
+                height: base.height,
+                baseline: base.baseline,
+                style,
+                kind: NodeKind::Subscript {
+                    inline: true,
+                    base: Box::new(base),
+                    sub: Box::new(LayoutNode::text_with_style(converted, style)),
+                },
+            };
+        }
+
+        let height = base.height + sub.height;
+        let width = base.width + sub.width;
+        let inline = false;
+
+        Self {
+            width,
+            height,
+            baseline: base.baseline,
+            style,
+            kind: NodeKind::Subscript {
+                inline,
+                base: Box::new(base),
+                sub: Box::new(sub),
+            },
+        }
+    }
+
+    pub fn both_scripts(
+        base: LayoutNode,
+        sub: LayoutNode,
+        sup: LayoutNode,
+        style: Style,
+    ) -> LayoutNode {
+        let sup_h = sup.height;
+        let height = sup_h + sub.height + base.height;
+        let width = base.width + sub.width.max(sup.width);
+        let baseline = base.baseline + sup_h;
+
+        Self {
+            width,
+            height,
+            baseline,
+            style,
+            kind: NodeKind::BothScripts {
+                base: Box::new(base),
+                sub: Box::new(sub),
+                sup: Box::new(sup),
+            },
+        }
+    }
+
+    pub fn stretchy_delim(
+        inner: LayoutNode,
+        left: char,
+        right: char,
+        fill: bool,
+        style: Style,
+    ) -> Self {
+        if inner.height <= 1 {
+            let w = inner.width + 2;
+            return Self {
+                width: w,
+                height: 1,
+                baseline: 0,
+                style,
+                kind: NodeKind::StretchyDelim {
+                    inner: Box::new(inner),
+                    left,
+                    right,
+                    fill,
+                },
+            };
+        }
+
+        let h = inner.height;
+        let w = inner.width + 4;
+
+        Self {
+            width: w,
+            height: h,
+            baseline: inner.baseline,
+            style,
+            kind: NodeKind::StretchyDelim {
+                inner: Box::new(inner),
+                left,
+                right,
+                fill,
+            },
+        }
+    }
+
+    pub fn accent(inner: LayoutNode, mark: char, stretch: bool) -> Self {
+        let width = inner.width.max(1);
+        let height = inner.height + 1;
+
+        Self {
+            width,
+            height,
+            baseline: inner.baseline + 1,
+            style: Style::new(),
+            kind: NodeKind::Accent {
+                inner: Box::new(inner),
+                mark,
+                stretch,
+            },
+        }
+    }
+
+    pub fn limits(base: LayoutNode, lower: LayoutNode, upper: LayoutNode) -> Self {
+        let max_h = upper.height.max(lower.height);
+        let w = base.width.max(lower.width).max(upper.width) + 1;
+        let h = base.height + 2 * max_h;
+
+        Self {
+            width: w,
+            height: h,
+            baseline: max_h + base.baseline,
+            style: Style::new(),
+            kind: NodeKind::Limits {
+                base: Box::new(base),
+                lower: Box::new(lower),
+                upper: Box::new(upper),
+            },
+        }
+    }
+
+    pub fn sqrt(inner: LayoutNode, index: Option<LayoutNode>) -> Self {
+        let h = inner.height + 1;
+        let w = inner.width + 3;
+        let baseline = inner.baseline + 1;
+
+        Self {
+            width: w,
+            height: h,
+            baseline,
+            style: Style::new(),
+            kind: NodeKind::Sqrt {
+                inner: Box::new(inner),
+                index: index.map(Box::new),
+            },
+        }
+    }
+
+    pub fn summation(inner: Option<LayoutNode>) -> Self {
+        match &inner {
+            None => Self {
+                width: 5,
+                height: 3,
+                baseline: 1,
+                style: Style::new(),
+                kind: NodeKind::Summation { inner: None },
+            },
+            Some(inner) if inner.height <= 2 => {
+                let width = inner.width + 5; // 4 sigma + 1 space
+                Self {
+                    width,
+                    height: 3,
+                    baseline: 1,
+                    style: Style::new(),
+                    kind: NodeKind::Summation {
+                        inner: Some(Box::new(inner.clone())),
+                    },
+                }
+            }
+            Some(inner) => {
+                let h = inner.height;
+                let w_sigma = ((1.5 * h as f32) as usize).max(h / 2 + 2);
+                let w = w_sigma + 1 + inner.width;
+                Self {
+                    width: w,
+                    height: h,
+                    baseline: inner.baseline,
+                    style: Style::new(),
+                    kind: NodeKind::Summation {
+                        inner: Some(Box::new(inner.clone())),
+                    },
+                }
+            }
+        }
+    }
+
+    pub fn product(inner: Option<LayoutNode>) -> Self {
+        match &inner {
+            None => Self {
+                width: 4,
+                height: 2,
+                baseline: 1,
+                style: Style::new(),
+                kind: NodeKind::Product { inner: None },
+            },
+            Some(inner) => {
+                let height = inner.height.max(3);
+                let w_pi = if height <= 2 {
+                    3
+                } else {
+                    (height / 2 + 2).max(3)
+                };
+
+                let width = w_pi + 1 + inner.width;
+                let height_diff = height.saturating_sub(inner.height);
+                let baseline = inner.baseline + (height_diff / 2);
+
+                Self {
+                    width,
+                    height,
+                    baseline,
+                    style: Style::new(),
+                    kind: NodeKind::Product {
+                        inner: Some(Box::new(inner.clone())),
+                    },
+                }
+            }
+        }
+    }
+
+    pub fn integral(inner: Option<LayoutNode>) -> Self {
+        match &inner {
+            None => Self {
+                width: 2,
+                height: 3,
+                baseline: 1,
+                style: Style::new(),
+                kind: NodeKind::Integral { inner: None },
+            },
+            Some(inner) if inner.height <= 3 => {
+                let w = inner.width + 1;
+                Self {
+                    width: w,
+                    height: 3,
+                    baseline: 1,
+                    style: Style::new(),
+                    kind: NodeKind::Integral {
+                        inner: Some(Box::new(inner.clone())),
+                    },
+                }
+            }
+            Some(inner) => {
+                let h = inner.height;
+                let w = inner.width + 2;
+                Self {
+                    width: w,
+                    height: h,
+                    baseline: inner.baseline,
+                    style: Style::new(),
+                    kind: NodeKind::Integral {
+                        inner: Some(Box::new(inner.clone())),
+                    },
+                }
+            }
+        }
+    }
+
+    pub fn negate(inner: LayoutNode) -> Self {
+        let width = inner.width + 1;
+        let height = inner.height;
+        let baseline = inner.baseline;
+
+        Self {
+            width,
+            height,
+            baseline,
+            style: Style::new(),
+            kind: NodeKind::Neg {
+                inner: Box::new(inner),
+            },
+        }
+    }
+
+    pub fn prime(base: LayoutNode, count: usize) -> Self {
+        Self {
+            width: base.width + count,
+            height: base.height,
+            baseline: base.baseline,
+            style: Style::new(),
+            kind: NodeKind::Prime {
+                base: Box::new(base),
+                count,
+            },
+        }
+    }
+
+    pub fn matrix(
+        name: &str,
+        rows: &[Vec<LayoutNode>],
+        style: Style,
+    ) -> Result<LayoutNode, crate::error::ParseError> {
+        if rows.is_empty() || rows[0].is_empty() {
+            return Ok(Self::empty());
+        }
+
+        let num_rows = rows.len();
+        let num_cols = rows[0].len();
+
+        let mut row_max_depths = vec![0; num_rows];
+        let mut row_max_baselines = vec![0; num_rows];
+        let mut max_item_width = 0;
+
+        for (i, row) in rows.iter().enumerate() {
+            let mut max_b = 0;
+            let mut max_d = 0;
+            for item in row {
+                max_item_width = max_item_width.max(item.width);
+                max_b = max_b.max(item.baseline);
+                max_d = max_d.max(item.height.saturating_sub(item.baseline));
+            }
+            row_max_baselines[i] = max_b;
+            row_max_depths[i] = max_d;
+        }
+
+        let cell_width = max_item_width;
+        let mut cell_height = 0;
+        for i in 0..num_rows {
+            let row_content_height = row_max_baselines[i] + row_max_depths[i];
+            cell_height = cell_height.max(row_content_height);
+        }
+
+        let hspacing = 4;
+        let vspacing = 1;
+
+        let mut matrix_layout_height = num_rows * cell_height + (num_rows - 1) * vspacing;
+        let matrix_layout_width = num_cols * cell_width + (num_cols - 1) * hspacing;
+
+        if matrix_layout_height.is_multiple_of(2) {
+            matrix_layout_height += 1;
+        }
+
+        let baseline = matrix_layout_height / 2;
+
+        let (left_delim, right_delim) = match name {
+            "matrix" => (' ', ' '),
+            "bmatrix" => ('[', ']'),
+            "pmatrix" => ('(', ')'),
+            _ => {
+                return Err(crate::error::ParseError::UnknownEnvironment {
+                    name: name.to_string(),
+                });
+            }
+        };
+
+        let inner = Self {
+            width: matrix_layout_width,
+            height: matrix_layout_height,
+            baseline,
+            style: Style::new(),
+            kind: NodeKind::Matrix {
+                name: name.to_string(),
+                rows: rows.to_vec(),
+            },
+        };
+
+        Ok(Self::stretchy_delim(
+            inner,
+            left_delim,
+            right_delim,
+            true,
+            style,
+        ))
+    }
+}
+
+#[rustfmt::skip]
+fn to_superscript_char(c: char) -> Option<char> {
+    Some (match c {
+        '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' => 'ᶻ',
+        'A' => 'ᴬ', 'B' => 'ᴮ', 'D' => 'ᴰ', 'E' => 'ᴱ', 'G' => 'ᴳ',
+        'H' => 'ᴴ', 'I' => 'ᴵ', 'J' => 'ᴶ', 'M' => 'ᴹ', 'N' => 'ᴺ',
+        'O' => 'ᴼ', 'P' => 'ᴾ', 'R' => 'ᴿ', 'T' => 'ᵀ', 'U' => 'ᵁ',
+        'W' => 'ᵂ', '+' => '⁺', '-' => '⁻', '=' => '⁼', '(' => '⁽',
+        ')' => '⁾',
+
+        _ => return None,
+    })
+}
+
+#[rustfmt::skip]
+fn to_subscript_char(c: char) -> Option<char> {
+    Some(match c {
+        '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' => 'ₓ', 'y' => 'ᵧ', '+' => '₊', '-' => '₋', '=' => '₌',
+        '(' => '₍', ')' => '₎',
+
+        _ => return None,
+    })
+}
+
+fn map_content<F>(node: &NodeKind, f: F) -> Vec<char>
+where
+    F: Fn(char) -> Option<char>,
+{
+    fn map_content_internal<F: Fn(char) -> Option<char>>(
+        node: &NodeKind,
+        f: &F,
+        vec: &mut Vec<char>,
+    ) {
+        match node {
+            NodeKind::Text { content } => vec.extend(content.iter().map_while(|&c| f(c))),
+
+            NodeKind::HStack { children, spacing } => {
+                let n = children.len();
+                for (i, node) in children.iter().enumerate() {
+                    map_content_internal(&node.kind, f, vec);
+                    if i + 1 != n {
+                        vec.extend(std::iter::repeat_n(' ', *spacing));
+                    }
+                }
+            }
+
+            _ => {}
+        }
+    }
+
+    let mut vec = vec![];
+    map_content_internal(node, &f, &mut vec);
+    vec
+}
diff --git a/vendor/txm/src/lib.rs b/vendor/txm/src/lib.rs
new file mode 100644
index 0000000..05bcddd
--- /dev/null
+++ b/vendor/txm/src/lib.rs
@@ -0,0 +1,256 @@
+use crate::backend::Backend;
+use crate::glyph::*;
+use crate::parser::Parser;
+use crate::render::render as render_expr;
+use crate::token::tokenize;
+
+use std::sync::OnceLock;
+
+mod ast;
+mod error;
+mod glyph;
+mod layout_tree;
+mod parser;
+mod render;
+mod style;
+mod token;
+
+pub use error::ParseError;
+pub use layout_tree::{LayoutNode, LineStyle, NodeKind};
+pub use style::Style;
+
+pub mod backend;
+pub mod backends;
+
+#[cfg(feature = "ratatui")]
+pub mod ratatui;
+
+const COMPACT_SIMPLE_FRACTIONAL_EXPONENTS: bool = false;
+
+/// Renders a math expression to a `LayoutNode` tree.
+pub fn layout(input: &str) -> Result<LayoutNode, ParseError> {
+    let tokens = tokenize(input)?;
+    let reg = registry();
+    let mut parser = Parser::new(input, &tokens, reg);
+    let expr = parser.parse_expr()?;
+    let mut ctx = RenderCtx {
+        depth: 0,
+        current_style: Style::new().italic(),
+    };
+    render_expr(&expr, reg, &mut ctx)
+}
+
+/// Renders a math expression to a plain text string with ANSI styling.
+pub fn render(input: &str) -> Result<String, ParseError> {
+    let tree = layout(input)?;
+    let backend = backends::terminal::TerminalBackend::new();
+    Ok(backend.render(&tree).unwrap())
+}
+
+fn registry() -> &'static SymbolRegistry {
+    static REGISTRY: OnceLock<SymbolRegistry> = OnceLock::new();
+    REGISTRY.get_or_init(build_registry)
+}
+
+fn build_registry() -> SymbolRegistry {
+    let mut r = SymbolRegistry::new();
+
+    for (cmd, ch) in [
+        ("alpha", 'α'),
+        ("beta", 'β'),
+        ("gamma", 'γ'),
+        ("delta", 'δ'),
+        ("epsilon", 'ε'),
+        ("zeta", 'ζ'),
+        ("eta", 'η'),
+        ("theta", 'θ'),
+        ("iota", 'ι'),
+        ("kappa", 'κ'),
+        ("lambda", 'λ'),
+        ("mu", 'μ'),
+        ("nu", 'ν'),
+        ("xi", 'ξ'),
+        ("omicron", 'ο'),
+        ("pi", 'π'),
+        ("rho", 'ρ'),
+        ("sigma", 'σ'),
+        ("tau", 'τ'),
+        ("upsilon", 'υ'),
+        ("phi", 'φ'),
+        ("chi", 'χ'),
+        ("psi", 'ψ'),
+        ("omega", 'ω'),
+        ("vee", '∨'),
+        ("wedge", '∧'),
+    ] {
+        r.register(cmd, UnicodeGlyph(ch));
+    }
+
+    for (cmd, ch) in [
+        ("Gamma", 'Γ'),
+        ("Delta", 'Δ'),
+        ("Theta", 'Θ'),
+        ("Lambda", 'Λ'),
+        ("Xi", 'Ξ'),
+        ("Pi", 'Π'),
+        ("Sigma", 'Σ'),
+        ("Phi", 'Φ'),
+        ("Psi", 'Ψ'),
+        ("Omega", 'Ω'),
+    ] {
+        r.register(cmd, UnicodeGlyph(ch));
+    }
+
+    for name in &[
+        "sin", "cos", "tan", "cot", "sec", "csc", "arcsin", "arccos", "arctan", "sinh", "cosh",
+        "coth", "tanh", "log", "ln", "lg", "det", "dim", "hom", "ker", "exp", "deg", "gcd", "lcm",
+        "sup", "inf", "max", "min", "arg", "Pr", "mod", "adj",
+    ] {
+        r.register(*name, TextGlyph(name));
+    }
+
+    r.register("binom", BinomGlyph);
+    r.register("frac", FracGlyph);
+    r.register("sqrt", SqrtGlyph);
+    r.register("lim", LimitGlyph);
+    r.register("int", IntegralGlyph);
+    r.register("sum", SummationGlyph);
+    r.register("prod", ProductGlyph);
+
+    r.register("color", TextColorGlyph);
+
+    for (cmd, ch) in [
+        ("infty", '∞'),
+        ("partial", '∂'),
+        ("nabla", '∇'),
+        ("forall", '∀'),
+        ("exists", '∃'),
+        ("neg", '¬'),
+        ("emptyset", '∅'),
+        ("triangle", '△'),
+        ("angle", '∠'),
+        ("therefore", '∴'),
+        ("because", '∵'),
+        ("cdot", '·'),
+        ("times", '×'),
+        ("div", '÷'),
+        ("pm", '±'),
+        ("mp", '∓'),
+        ("circ", '∘'),
+        ("bullet", '∙'),
+        ("star", '⋆'),
+        ("le", '≤'),
+        ("ge", '≥'),
+        ("ne", '≠'),
+        ("approx", '≈'),
+        ("equiv", '≡'),
+        ("sim", '∼'),
+        ("simeq", '≃'),
+        ("cong", '≅'),
+        ("propto", '∝'),
+        ("perp", '⊥'),
+        ("parallel", '∥'),
+        ("to", '→'),
+        ("rightarrow", '→'),
+        ("Rightarrow", '⇒'),
+        ("leftarrow", '←'),
+        ("Leftarrow", '⇐'),
+        ("mapsto", '↦'),
+        ("implies", '⇒'),
+        ("iff", '⇔'),
+        ("in", '∈'),
+        ("notin", '∉'),
+        ("subset", '⊂'),
+        ("supset", '⊃'),
+        ("subseteq", '⊆'),
+        ("supseteq", '⊇'),
+        ("cup", '∪'),
+        ("cap", '∩'),
+        ("lvert", '|'),
+        ("rvert", '|'),
+        ("langle", '⟨'),
+        ("rangle", '⟩'),
+        ("lfloor", '⌊'),
+        ("rfloor", '⌋'),
+        ("lceil", '⌈'),
+        ("rceil", '⌉'),
+        ("quad", ' '),
+        ("dots", '⋯'),
+        ("ldots", '…'),
+        ("vdots", '⋮'),
+        ("ddots", '⋱'),
+        ("aleph", 'ℵ'),
+        ("hbar", 'ℏ'),
+        ("ell", 'ℓ'),
+        ("wp", '℘'),
+        ("oplus", '⊕'),
+        ("ominus", '⊖'),
+        ("otimes", '⊗'),
+        ("oslash", '⊘'),
+    ] {
+        r.register(cmd, UnicodeGlyph(ch));
+    }
+
+    r.register("abs", AbsGlyph);
+    r.register("|", AbsGlyph);
+
+    r.register("mathbb", AlphabetGlyph(to_bb as fn(char) -> char));
+
+    for (cmd, modify, map) in [
+        (
+            "mathbf",
+            (|s| s.un_italic().bold()) as fn(Style) -> Style,
+            to_bold as fn(char) -> char,
+        ),
+        ("mathrm", Style::un_italic, to_upright),
+        ("mathsf", Style::un_italic, to_sans),
+        ("mathit", Style::italic, to_italic),
+        ("boldsymbol", (|s| s.bold()) as fn(Style) -> Style, to_bold),
+    ] {
+        r.register(cmd, MappedStyleGlyph { modify, map });
+    }
+
+    for (cmd, modify) in [
+        ("text", Style::un_italic as fn(Style) -> Style),
+        ("textbf", (|s| s.un_italic().bold()) as fn(Style) -> Style),
+        ("textit", Style::italic as fn(Style) -> Style),
+        ("textrm", Style::un_italic as fn(Style) -> Style),
+    ] {
+        r.register(cmd, StyleModifierGlyph { modify });
+    }
+
+    r.register("colorbox", BgColorGlyph);
+
+    for (cmd, mark) in [
+        ("hat", '^'),
+        ("tilde", '~'),
+        ("bar", '‾'),
+        ("vec", '→'),
+        ("dot", '˙'),
+        ("ddot", '¨'),
+        ("acute", '´'),
+        ("grave", '`'),
+        ("check", 'ˇ'),
+        ("breve", '˘'),
+    ] {
+        r.register(
+            cmd,
+            AccentGlyph {
+                mark,
+                stretch: false,
+            },
+        );
+    }
+
+    for (cmd, mark) in [("overline", '─'), ("widehat", '^'), ("widetilde", '~')] {
+        r.register(
+            cmd,
+            AccentGlyph {
+                mark,
+                stretch: true,
+            },
+        );
+    }
+
+    r
+}
diff --git a/vendor/txm/src/main.rs b/vendor/txm/src/main.rs
new file mode 100644
index 0000000..2fbd330
--- /dev/null
+++ b/vendor/txm/src/main.rs
@@ -0,0 +1,185 @@
+use std::{env, fs, process};
+use unicode_width::UnicodeWidthStr;
+
+struct Flag {
+    name: &'static str,
+    desc: &'static str,
+}
+
+struct Config {
+    unboxed: bool,
+    expression: String,
+}
+
+enum Cli {
+    Help,
+    Version,
+    Run(Config),
+}
+
+fn main() {
+    let flags = [
+        Flag {
+            name: "--help",
+            desc: "Print this help message and exit",
+        },
+        Flag {
+            name: "--version",
+            desc: "Print version information and exit",
+        },
+        Flag {
+            name: "--unboxed",
+            desc: "Render without the decorative box border",
+        },
+        Flag {
+            name: "--file <FILE>",
+            desc: "Render specified file (- for stdin)",
+        },
+    ];
+
+    let program =
+        std::fs::canonicalize(std::env::args().next().unwrap_or_default()).unwrap_or_default();
+    let program = program
+        .strip_prefix(std::env::current_dir().unwrap_or_default())
+        .unwrap_or(std::path::Path::new(""));
+    let program = program.to_str().unwrap_or_default();
+
+    match parse_args() {
+        Ok(Cli::Help) => print!("{}", help(program, &flags)),
+        Ok(Cli::Version) => println!("txm {}", env!("CARGO_PKG_VERSION")),
+        Ok(Cli::Run(config)) => match txm::render(&config.expression) {
+            Ok(rendered) => {
+                if config.unboxed {
+                    print!("{rendered}");
+                } else {
+                    boxed(&rendered, &mut std::io::stdout());
+                }
+            }
+            Err(e) => {
+                eprintln!("error: {e}");
+                std::process::exit(1);
+            }
+        },
+        Err(msg) if msg == "missing expression" => print!("{}", help(program, &flags)),
+        Err(msg) => {
+            eprintln!("error: {msg}");
+            eprintln!("\nFor more information, try '--help'.");
+            process::exit(2);
+        }
+    }
+}
+
+fn parse_args() -> Result<Cli, String> {
+    let mut args = env::args().skip(1);
+    let mut unboxed = false;
+    let mut expression: Option<String> = None;
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--help" => return Ok(Cli::Help),
+            "--version" => return Ok(Cli::Version),
+            "--unboxed" => unboxed = true,
+            "--file" => {
+                let path_arg = args
+                    .next()
+                    .ok_or_else(|| "missing file path after '--file'".to_string())?;
+
+                let path = if path_arg == "-" {
+                    "/dev/stdin"
+                } else {
+                    &path_arg
+                };
+
+                let contents = fs::read_to_string(path)
+                    .map_err(|err| format!("unable to open file '{path_arg}': {err}"))?;
+
+                if expression.replace(contents).is_some() {
+                    return Err(format!("unexpected extra argument '{path_arg}'"));
+                }
+            }
+            s if s.starts_with("--") => return Err(format!("unknown flag '{s}'")),
+            s => {
+                if expression.replace(s.to_string()).is_some() {
+                    return Err(format!("unexpected extra argument '{s}'"));
+                }
+            }
+        }
+    }
+
+    let expression = expression.ok_or_else(|| "missing expression".to_string())?;
+    Ok(Cli::Run(Config {
+        unboxed,
+        expression,
+    }))
+}
+
+fn help(program: &str, flags: &[Flag]) -> String {
+    let max_len = flags.iter().map(|f| f.name.len()).max().unwrap_or(0);
+
+    let opts: String = flags
+        .iter()
+        .map(|f| {
+            let gap = " ".repeat(max_len - f.name.len() + 2);
+            format!("  {}{gap}{}", f.name, f.desc)
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    format!(
+        "Usage: {program} [OPTIONS] [EXPRESSION]
+
+Terminal Math Rendering Engine - renders LaTeX math expressions in your terminal.
+
+OPTIONS:
+{opts}
+
+EXAMPLES:
+  {program} \"E = mc^2\"
+  {program}  \"\\lim_{{x\\,\\to\\,\\infty}}\\,\\int_0^x{{\\frac{{\\sin\\, t^2}}{{1 + t^4}}}}\\, dt = L\"
+"
+    )
+}
+
+#[allow(unused)]
+fn strip_ansi(s: &str) -> String {
+    let mut result = String::with_capacity(s.len());
+    let mut chars = s.chars();
+    while let Some(c) = chars.next() {
+        if c == '\x1b' {
+            // Skip until 'm' (SGR sequence end)
+            for c in chars.by_ref() {
+                if c == 'm' {
+                    break;
+                }
+            }
+        } else {
+            result.push(c);
+        }
+    }
+
+    result
+}
+
+#[allow(unused)]
+fn boxed(rendered: &str, f: &mut impl std::io::Write) {
+    let lines: Vec<&str> = rendered.lines().collect();
+    let width = lines
+        .iter()
+        .map(|line| strip_ansi(line).width())
+        .max()
+        .unwrap_or(0);
+
+    let border = "─".repeat(width + 2);
+
+    _ = writeln!(f, "┌{border}┐");
+    _ = writeln!(f, "│ {:width$} │", "", width = width);
+
+    for line in lines {
+        let visible = strip_ansi(line);
+        let padding = width - visible.width();
+        _ = writeln!(f, "│ {line}{:padding$} │", "", padding = padding);
+    }
+
+    _ = writeln!(f, "│ {:width$} │", "", width = width);
+    _ = writeln!(f, "└{border}┘");
+}
diff --git a/vendor/txm/src/parser.rs b/vendor/txm/src/parser.rs
new file mode 100644
index 0000000..2ea06f4
--- /dev/null
+++ b/vendor/txm/src/parser.rs
@@ -0,0 +1,678 @@
+use std::ops::Range;
+
+use crate::ParseError;
+use crate::ast::*;
+use crate::glyph::SymbolRegistry;
+use crate::token::SpannedToken;
+use crate::token::Token;
+
+pub struct Parser<'a> {
+    tokens: &'a [SpannedToken<'a>],
+    input: &'a str,
+    pos: usize,
+    registry: &'a SymbolRegistry,
+}
+
+impl<'a> Parser<'a> {
+    pub fn new(
+        input: &'a str,
+        tokens: &'a [SpannedToken<'a>],
+        registry: &'a SymbolRegistry,
+    ) -> Self {
+        Self {
+            input,
+            tokens,
+            pos: 0,
+            registry,
+        }
+    }
+
+    fn peek(&self) -> Option<&Token<'_>> {
+        self.tokens.get(self.pos).map(|(i, _)| i)
+    }
+
+    fn current_span(&self) -> Option<&Range<usize>> {
+        self.tokens.get(self.pos).map(|(_, j)| j)
+    }
+
+    fn advance(&mut self) -> Token<'a> {
+        let t = self.tokens[self.pos].clone();
+        self.pos += 1;
+        t.0
+    }
+
+    fn expect(&mut self, tok: Token) -> Result<(), ParseError> {
+        match self.peek() {
+            None => Err(ParseError::ExpectedToken {
+                expected: format!("{tok:?}"),
+            }
+            .at_eof(self.input)),
+            Some(actual) if *actual == tok => {
+                self.advance();
+                Ok(())
+            }
+            Some(actual) => Err(ParseError::ExpectedTokenGot {
+                expected: format!("{tok:?}"),
+                got: format!("{actual:?}"),
+            }
+            .at(self.current_span().unwrap().clone(), self.input)),
+        }
+    }
+
+    /// For input = "xyz", the tokenizer returns:
+    /// `[(Ident("x"), 0..1), (Ident("y"), 1..2), (Ident("z"), 2..3)]`
+    ///
+    /// This function takes that stream of tokens and returns Ok("xyz")
+    /// if those tokens are continuous. If the input string had whitespaces,
+    /// for example, "x y z", the tokenizer returns:
+    /// `[(Ident("x"), 0..1), (Ident("y"), 2..3), (Ident("z"), 4..5)]`
+    /// it returns an error.
+    fn parse_continuous_string(&mut self, deliminted_by: Token) -> Result<String, ParseError> {
+        let mut name = String::new();
+        let mut last_end: Option<usize> = None;
+
+        loop {
+            if let Some(Token::Ident(segment)) = self.peek() {
+                let span = self.current_span().ok_or(ParseError::UnexpectedEof)?;
+
+                if let Some(prev_end) = last_end
+                    && prev_end != span.start
+                {
+                    return Err(ParseError::UnexpectedWhitespace.at(span.clone(), self.input));
+                }
+
+                name.push_str(segment);
+                last_end = Some(span.end);
+                self.advance();
+            } else if self.peek() == Some(&deliminted_by) {
+                break;
+            } else {
+                return Err(ParseError::ExpectedString.at(
+                    self.current_span()
+                        .ok_or(ParseError::UnexpectedEof)?
+                        .clone(),
+                    self.input,
+                ));
+            }
+        }
+
+        Ok(name)
+    }
+
+    fn parse_string_arg(&mut self) -> Result<String, ParseError> {
+        self.expect(Token::LBrace)?;
+        let mut name = String::new();
+        let mut last_end: Option<usize> = None;
+
+        loop {
+            match self.peek() {
+                Some(Token::Ident(segment)) | Some(Token::Number(segment)) => {
+                    let span = self.current_span().ok_or(ParseError::UnexpectedEof)?;
+
+                    if let Some(prev_end) = last_end
+                        && prev_end != span.start
+                    {
+                        name.push(' ');
+                    }
+
+                    name.push_str(segment);
+                    last_end = Some(span.end);
+                    self.advance();
+                }
+                Some(Token::RBrace) => break,
+                Some(tok) if tok.text_char().is_some() => {
+                    let span = self.current_span().ok_or(ParseError::UnexpectedEof)?;
+
+                    if let Some(prev_end) = last_end
+                        && prev_end != span.start
+                    {
+                        name.push(' ');
+                    }
+
+                    name.push(tok.text_char().unwrap());
+                    last_end = Some(span.end);
+                    self.advance();
+                }
+                _ => {
+                    return Err(ParseError::ExpectedString.at(
+                        self.current_span()
+                            .ok_or(ParseError::UnexpectedEof)?
+                            .clone(),
+                        self.input,
+                    ));
+                }
+            }
+        }
+
+        self.advance(); // eat RBrace
+        Ok(name)
+    }
+
+    pub fn parse_expr(&mut self) -> Result<Expr, ParseError> {
+        self.parse_binop()
+    }
+
+    fn parse_binop(&mut self) -> Result<Expr, ParseError> {
+        let mut lhs = self.parse_juxtapose()?;
+        loop {
+            match self.peek() {
+                Some(Token::Plus) => {
+                    self.advance();
+                    let rhs = self.parse_juxtapose()?;
+                    lhs = Expr::BinOp(Box::new(lhs), BinOp::Add, Box::new(rhs));
+                }
+                Some(Token::Minus) => {
+                    self.advance();
+                    let rhs = self.parse_juxtapose()?;
+                    lhs = Expr::BinOp(Box::new(lhs), BinOp::Sub, Box::new(rhs));
+                }
+                Some(Token::Equals) => {
+                    self.advance();
+                    let rhs = self.parse_juxtapose()?;
+                    lhs = Expr::BinOp(Box::new(lhs), BinOp::Eq, Box::new(rhs));
+                }
+                Some(Token::Star) => {
+                    self.advance();
+                    let rhs = self.parse_juxtapose()?;
+                    lhs = Expr::BinOp(Box::new(lhs), BinOp::Mul, Box::new(rhs));
+                }
+                _ => break,
+            }
+        }
+        Ok(lhs)
+    }
+
+    fn can_start_atom(&self) -> bool {
+        matches!(
+            self.peek(),
+            Some(Token::LBrace)
+                | Some(Token::LParen)
+                | Some(Token::RParen)
+                | Some(Token::LBracket)
+                | Some(Token::RBracket)
+                | Some(Token::Number(_))
+                | Some(Token::Ident(_))
+                | Some(Token::Command(_))
+                | Some(Token::Escape(_))
+                | Some(Token::Bang)
+                | Some(Token::Pipe)
+                | Some(Token::Minus)
+                | Some(Token::Plus)
+                | Some(Token::Ampersand)
+                | Some(Token::Slash)
+                | Some(Token::Comma)
+                | Some(Token::Dot)
+                | Some(Token::Colon)
+                | Some(Token::Semicolon)
+                | Some(Token::Less)
+                | Some(Token::Greater)
+                | Some(Token::Question)
+                | Some(Token::At)
+                | Some(Token::Hash)
+                | Some(Token::Dollar)
+                | Some(Token::Percent)
+                | Some(Token::Tilde)
+                | Some(Token::Quote)
+                | Some(Token::Backtick)
+        )
+    }
+
+    fn parse_juxtapose(&mut self) -> Result<Expr, ParseError> {
+        if !self.can_start_atom() {
+            return Ok(Expr::Empty);
+        }
+
+        let mut exprs = Vec::new();
+        exprs.push(self.parse_scripted()?);
+
+        while let Some(Token::LBrace)
+        | Some(Token::LParen)
+        | Some(Token::RParen)
+        | Some(Token::LBracket)
+        | Some(Token::RBracket)
+        | Some(Token::Number(_))
+        | Some(Token::Ident(_))
+        | Some(Token::Command(_))
+        | Some(Token::Escape(_))
+        | Some(Token::Bang)
+        | Some(Token::Ampersand)
+        | Some(Token::Slash)
+        | Some(Token::Comma)
+        | Some(Token::Dot)
+        | Some(Token::Colon)
+        | Some(Token::Semicolon)
+        | Some(Token::Less)
+        | Some(Token::Greater)
+        | Some(Token::Question)
+        | Some(Token::At)
+        | Some(Token::Hash)
+        | Some(Token::Dollar)
+        | Some(Token::Percent)
+        | Some(Token::Tilde)
+        | Some(Token::Quote)
+        | Some(Token::Backtick) = self.peek()
+        {
+            exprs.push(self.parse_scripted()?);
+        }
+
+        if exprs.len() == 1 {
+            Ok(exprs.into_iter().next().unwrap())
+        } else {
+            Ok(Expr::Juxtapose(exprs))
+        }
+    }
+
+    fn parse_scripted(&mut self) -> Result<Expr, ParseError> {
+        let base = self.parse_atom()?;
+        let mut sub: Option<Box<Expr>> = None;
+        let mut sup: Option<Box<Expr>> = None;
+        let mut primes: usize = 0;
+
+        loop {
+            match self.peek() {
+                Some(Token::Underscore) if sub.is_none() => {
+                    self.advance();
+                    sub = Some(Box::new(self.parse_atom()?));
+                }
+                Some(Token::Caret) if sup.is_none() => {
+                    self.advance();
+                    sup = Some(Box::new(self.parse_atom()?));
+                }
+                Some(Token::Prime) => {
+                    self.advance();
+                    primes += 1;
+                }
+                _ => break,
+            }
+        }
+
+        // i want to parse things like `\int_a^b{argument}`
+        // we've already parsed the base: `\int`, scripts: `_a^b`
+        // now we check if the base was present in symbol registry and
+        // has_limits = true and if the next symbol after parsing scripts
+        // was LBrace, it is an argument
+
+        let mut result = if let Expr::Command {
+            name,
+            opts: _,
+            args,
+        } = &base
+            && let Some(glyph) = self.registry.get(name)
+            && glyph.has_limits()
+            && self.peek() == Some(&Token::LBrace)
+            && args.len() < glyph.required_args()
+        {
+            // move
+            let Expr::Command { name, mut args, .. } = base else {
+                return Err(ParseError::Internal(
+                    "limits argument base was not a command".into(),
+                ));
+            };
+
+            self.advance(); // eat {
+            let body = self.parse_expr()?;
+            self.expect(Token::RBrace)?;
+            args.push(body);
+
+            Expr::Command {
+                name,
+                opts: Vec::new(),
+                args,
+            }
+        } else {
+            base
+        };
+
+        if primes > 0 {
+            result = Expr::Prime(Box::new(result), primes);
+        }
+
+        match (sub, sup) {
+            (None, None) => Ok(result),
+            (Some(s), None) => Ok(Expr::Subscript(Box::new(result), s)),
+            (None, Some(s)) => Ok(Expr::Superscript(Box::new(result), s)),
+            (Some(s), Some(p)) => Ok(Expr::BothScripts(Box::new(result), s, p)),
+        }
+    }
+
+    fn parse_atom(&mut self) -> Result<Expr, ParseError> {
+        let next = self.advance().clone();
+        match next {
+            Token::Number(s) => {
+                let s = s.to_string();
+                Ok(Expr::Number(s))
+            }
+            Token::Ident(s) => {
+                let s = s.to_string();
+                Ok(Expr::Ident(s))
+            }
+            Token::LBrace => {
+                let inner = self.parse_expr()?;
+                self.expect(Token::RBrace)?;
+                Ok(inner)
+            }
+            Token::LParen => Ok(Expr::Ident("(".into())),
+            Token::RParen => Ok(Expr::Ident(")".into())),
+            Token::LBracket => Ok(Expr::Ident("[".into())),
+            Token::RBracket => Ok(Expr::Ident("]".into())),
+            Token::Command(name) => {
+                let name = name.to_string();
+                if name == "begin" {
+                    self.parse_begin()
+                } else if name == "left" {
+                    self.parse_left_delimited()
+                } else if name == "right" {
+                    Err(ParseError::UnexpectedRightWithoutLeft)
+                } else {
+                    self.parse_command(&name)
+                }
+            }
+            Token::Escape(s) => {
+                let s = s.to_string();
+                Ok(Expr::Escape(s))
+            }
+            Token::Pipe => {
+                let inner = self.parse_expr()?;
+                self.expect(Token::Pipe)?;
+                Ok(Expr::Command {
+                    name: "|".into(),
+                    opts: vec![],
+                    args: vec![inner],
+                })
+            }
+            Token::Minus => {
+                // Unary minus if an operand follows (`-x`), otherwise a bare
+                // symbol (`\pm`-style groups, `x^{-}`).
+                if self.can_start_atom() {
+                    Ok(Expr::Neg(Box::new(self.parse_atom()?)))
+                } else {
+                    Ok(Expr::Ident("-".into()))
+                }
+            }
+            Token::Bang => Ok(Expr::Ident("!".into())),
+            Token::Ampersand => Ok(Expr::Ident("&".into())),
+            Token::Plus => Ok(Expr::Ident("+".into())),
+            // Punctuation and relations that carry no special layout: render the
+            // literal symbol. Without these the tokens are dropped or collide
+            // with a closing-delimiter expectation (e.g. `(3,0)`, `x^{a/b}`).
+            Token::Slash => Ok(Expr::Ident("/".into())),
+            Token::Comma => Ok(Expr::Ident(",".into())),
+            Token::Dot => Ok(Expr::Ident(".".into())),
+            Token::Colon => Ok(Expr::Ident(":".into())),
+            Token::Semicolon => Ok(Expr::Ident(";".into())),
+            Token::Less => Ok(Expr::Ident("<".into())),
+            Token::Greater => Ok(Expr::Ident(">".into())),
+            Token::Question => Ok(Expr::Ident("?".into())),
+            Token::At => Ok(Expr::Ident("@".into())),
+            Token::Hash => Ok(Expr::Ident("#".into())),
+            Token::Dollar => Ok(Expr::Ident("$".into())),
+            Token::Percent => Ok(Expr::Ident("%".into())),
+            Token::Tilde => Ok(Expr::Ident("~".into())),
+            Token::Quote => Ok(Expr::Ident("\"".into())),
+            Token::Backtick => Ok(Expr::Ident("`".into())),
+            other => Err(ParseError::UnexpectedToken {
+                position: self.pos - 1,
+                token: format!("{other:?}"),
+            }),
+        }
+    }
+
+    fn parse_left_delimited(&mut self) -> Result<Expr, ParseError> {
+        // Peek left and convert it back to it's character representation
+        let left = self
+            .peek()
+            .and_then(|tok| tok.as_char())
+            .ok_or(ParseError::ExpectedDelimiter { side: "left" })?;
+
+        let inner_start = self.pos;
+        let mut depth = 0usize;
+        let mut match_idx = None;
+
+        for (idx, (token, _)) in self.tokens[inner_start..].iter().enumerate() {
+            match token {
+                Token::Command(name) if *name == "left" => depth += 1,
+                Token::Command(name) if *name == "right" => {
+                    if depth == 0 {
+                        match_idx = Some(inner_start + idx);
+                        break;
+                    }
+                    depth -= 1;
+                }
+                _ => {}
+            }
+        }
+
+        let Some(match_idx) = match_idx else {
+            return Err(ParseError::UnclosedLeftRight);
+        };
+
+        let Some((Token::Command(name), _)) = self.tokens.get(match_idx) else {
+            return Err(ParseError::Internal("missing \\right command".into()));
+        };
+        if *name != "right" {
+            return Err(ParseError::Internal("mismatched delimiter scan".into()));
+        }
+
+        // Convert the token after the matched index back into it's character representation
+        let right = self
+            .tokens
+            .get(match_idx + 1)
+            .and_then(|(t, _)| t.as_char())
+            .ok_or(ParseError::ExpectedDelimiter { side: "right" })?;
+
+        // Expect left and right delimiters to match
+        // TODO: this should probably get it's own strongly-typed error variant. it's not really
+        // unreachable code, and this branch could reasonably be called in production, resulting in
+        // a hard panic.
+        let expected_right = match left {
+            '(' => ')',
+            '[' => ']',
+            '{' => '}',
+            '|' => '|',
+            _ => unreachable!("unsupported left delimiter"),
+        };
+        if right != expected_right {
+            return Err(ParseError::MismatchedDelimiters { left, right });
+        }
+
+        let inner = self.parse_tokens(&self.tokens[inner_start..match_idx])?;
+        self.pos = match_idx + 2;
+        Ok(Expr::Delimiter {
+            left,
+            right,
+            inner: Box::new(inner),
+        })
+    }
+
+    fn parse_delimited_arg(&mut self, close: Token) -> Result<Expr, ParseError> {
+        self.advance();
+        let inner_start = self.pos;
+        let mut depth = 1usize;
+        let mut match_idx = None;
+        for (idx, (token, _)) in self.tokens[inner_start..].iter().enumerate() {
+            if Self::is_opener_for(token, &close) {
+                depth += 1;
+            } else if Self::token_eq(token, &close) {
+                if depth == 1 {
+                    match_idx = Some(inner_start + idx);
+                    break;
+                }
+                depth -= 1;
+            }
+        }
+        match match_idx {
+            Some(idx) => {
+                let arg_tokens = &self.tokens[inner_start..idx];
+                self.pos = idx + 1;
+                self.parse_tokens(arg_tokens)
+            }
+            None => Err(ParseError::UnclosedLeftRight),
+        }
+    }
+
+    fn is_opener_for(token: &Token, close: &Token) -> bool {
+        matches!(
+            (token, close),
+            (Token::LBrace, Token::RBrace)
+                | (Token::LParen, Token::RParen)
+                | (Token::LBracket, Token::RBracket)
+        )
+    }
+
+    fn token_eq(a: &Token, b: &Token) -> bool {
+        matches!(
+            (a, b),
+            (Token::RBrace, Token::RBrace)
+                | (Token::RParen, Token::RParen)
+                | (Token::RBracket, Token::RBracket)
+        )
+    }
+
+    fn parse_command(&mut self, name: &str) -> Result<Expr, ParseError> {
+        let glyph = self.registry.get(name);
+        let has_opt = glyph.is_some_and(|g| g.has_optional());
+        let mut n_req = glyph.map_or(0, |g| g.required_args());
+        let has_limits = glyph.is_some_and(|g| g.has_limits());
+        let takes_str = glyph.is_some_and(|g| g.takes_string_arg());
+        let mut opts = Vec::new();
+        let mut args = Vec::new();
+
+        if has_opt && self.peek() == Some(&Token::LBracket) {
+            let opt = self.parse_delimited_arg(Token::RBracket)?;
+            opts.push(opt);
+        }
+
+        if !has_limits {
+            if takes_str {
+                let text = self.parse_string_arg()?;
+                args.push(Expr::Ident(text));
+                n_req -= 1;
+            }
+
+            for _ in 0..n_req {
+                let arg = match self.peek() {
+                    Some(Token::LBrace) => self.parse_delimited_arg(Token::RBrace)?,
+                    Some(Token::LParen) => self.parse_delimited_arg(Token::RParen)?,
+                    Some(Token::LBracket) => self.parse_delimited_arg(Token::RBracket)?,
+                    _ => self.parse_atom()?,
+                };
+                args.push(arg);
+            }
+        }
+
+        Ok(Expr::Command {
+            name: name.to_string(),
+            opts,
+            args,
+        })
+    }
+
+    fn parse_begin(&mut self) -> Result<Expr, ParseError> {
+        self.expect(Token::LBrace)?;
+
+        let env_name = self.parse_continuous_string(Token::RBrace)?;
+        self.expect(Token::RBrace)?;
+
+        if !matches!(env_name.as_str(), "matrix" | "bmatrix" | "pmatrix") {
+            return Err(ParseError::UnknownEnvironment { name: env_name });
+        }
+
+        let body_start = self.pos;
+        let mut depth = 0u32;
+        let end_pos = loop {
+            match self.tokens.get(self.pos) {
+                None => return Err(ParseError::UnclosedEnvironment { name: env_name }),
+                Some((Token::Command(name), _)) if *name == "begin" => {
+                    depth += 1;
+                    self.pos += 1;
+                }
+                Some((Token::Command(name), _)) if *name == "end" => {
+                    if depth == 0 {
+                        break self.pos;
+                    }
+                    depth -= 1;
+                    self.pos += 1;
+                }
+                Some(_) => {
+                    self.pos += 1;
+                }
+            }
+        };
+
+        let body = &self.tokens[body_start..end_pos];
+        let rows = self.parse_matrix_body(body)?;
+
+        self.advance();
+        self.expect(Token::LBrace)?;
+
+        let end_name = self.parse_continuous_string(Token::RBrace)?;
+        if *end_name != env_name {
+            return Err(ParseError::MismatchedEnvironment {
+                begin: env_name,
+                end: end_name,
+            });
+        }
+
+        self.expect(Token::RBrace)?;
+
+        Ok(Expr::Matrix {
+            name: env_name,
+            rows,
+        })
+    }
+
+    fn parse_matrix_body(&self, tokens: &'a [SpannedToken]) -> Result<Vec<Vec<Expr>>, ParseError> {
+        let mut rows: Vec<Vec<Expr>> = Vec::new();
+        let mut current_row: Vec<Expr> = Vec::new();
+        let mut cell_start: usize = 0;
+        let mut depth: u32 = 0;
+        let mut env_depth: u32 = 0;
+
+        for (i, (token, _)) in tokens.iter().enumerate() {
+            match token {
+                Token::LBrace | Token::LBracket | Token::LParen => depth += 1,
+                Token::RBrace | Token::RBracket | Token::RParen => depth = depth.saturating_sub(1),
+                Token::Command(name) if *name == "begin" => env_depth += 1,
+                Token::Command(name) if *name == "end" => env_depth = env_depth.saturating_sub(1),
+                Token::Ampersand if depth == 0 && env_depth == 0 => {
+                    let cell = self.parse_tokens(&tokens[cell_start..i])?;
+                    current_row.push(cell);
+                    cell_start = i + 1;
+                }
+                Token::Escape(s) if *s == "\\" && depth == 0 && env_depth == 0 => {
+                    let cell = self.parse_tokens(&tokens[cell_start..i])?;
+                    current_row.push(cell);
+                    rows.push(current_row);
+                    current_row = Vec::new();
+                    cell_start = i + 1;
+                }
+                _ => {}
+            }
+        }
+
+        if cell_start < tokens.len() {
+            let cell = self.parse_tokens(&tokens[cell_start..])?;
+            current_row.push(cell);
+        }
+        if !current_row.is_empty() || rows.is_empty() {
+            rows.push(current_row);
+        }
+
+        Ok(rows)
+    }
+
+    fn parse_tokens(&self, tokens: &'a [SpannedToken]) -> Result<Expr, ParseError> {
+        if tokens.is_empty() {
+            return Ok(Expr::Empty);
+        }
+
+        let mut sub = Parser {
+            input: self.input,
+            tokens,
+            pos: 0,
+            registry: self.registry,
+        };
+
+        sub.parse_expr()
+    }
+}
diff --git a/vendor/txm/src/ratatui.rs b/vendor/txm/src/ratatui.rs
new file mode 100644
index 0000000..427d8c5
--- /dev/null
+++ b/vendor/txm/src/ratatui.rs
@@ -0,0 +1,286 @@
+use ratatui_core::{
+    buffer::Buffer,
+    layout::{HorizontalAlignment, Rect, Size, VerticalAlignment},
+    style::Style,
+    widgets::Widget,
+};
+use unicode_width::UnicodeWidthChar;
+
+use crate::backends::generic_backend::render_node;
+use crate::backends::terminal::CharBuf;
+use crate::layout_tree::LayoutNode;
+
+#[derive(Debug, Clone)]
+pub struct Math {
+    mem: CharBuf,
+    style: Style,
+    horizontal_alignment: HorizontalAlignment,
+    vertical_alignment: VerticalAlignment,
+    display_width: u16,
+}
+
+fn compute_display_width(mem: &CharBuf) -> u16 {
+    mem.data
+        .chunks_exact(mem.width)
+        .take(mem.height)
+        .map(|row| {
+            row.iter()
+                .map(|&ch| UnicodeWidthChar::width(ch).unwrap_or(0) as u16)
+                .sum()
+        })
+        .max()
+        .unwrap_or(0)
+}
+
+impl Math {
+    pub fn new(input: &str) -> Result<Self, crate::ParseError> {
+        let tree = crate::layout(input)?;
+        let mut mem = CharBuf::new(tree.width, tree.height);
+        render_node(&tree, &mut mem, 0, 0);
+
+        let display_width = compute_display_width(&mem);
+
+        Ok(Self {
+            mem,
+            style: Style::default(),
+            horizontal_alignment: HorizontalAlignment::Left,
+            vertical_alignment: VerticalAlignment::Top,
+            display_width,
+        })
+    }
+
+    pub fn from_tree(tree: &LayoutNode) -> Self {
+        let mut mem = CharBuf::new(tree.width, tree.height);
+        render_node(tree, &mut mem, 0, 0);
+
+        let display_width = compute_display_width(&mem);
+
+        Self {
+            mem,
+            style: Style::default(),
+            horizontal_alignment: HorizontalAlignment::Left,
+            vertical_alignment: VerticalAlignment::Top,
+            display_width,
+        }
+    }
+
+    pub fn size(&self) -> Size {
+        Rect::new(0, 0, self.display_width, self.mem.height as u16).as_size()
+    }
+
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    pub fn horizontal_alignment(mut self, alignment: HorizontalAlignment) -> Self {
+        self.horizontal_alignment = alignment;
+        self
+    }
+
+    pub fn vertical_alignment(mut self, alignment: VerticalAlignment) -> Self {
+        self.vertical_alignment = alignment;
+        self
+    }
+}
+
+impl Widget for &Math {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.width == 0 || area.height == 0 {
+            return;
+        }
+
+        let render_width = self.display_width;
+        let render_height = self.mem.height as u16;
+        if render_width == 0 || render_height == 0 {
+            return;
+        }
+
+        for y in area.y..area.y.saturating_add(area.height) {
+            for x in area.x..area.x.saturating_add(area.width) {
+                buf[(x, y)].reset();
+            }
+        }
+
+        let (content_x, draw_x) =
+            align_horizontal_span(render_width, area.width, self.horizontal_alignment);
+        let (content_y, draw_y, visible_height) =
+            align_vertical_span(render_height, area.height, self.vertical_alignment);
+
+        let visible_data_rows = self
+            .mem
+            .data
+            .chunks_exact(self.mem.width)
+            .skip(content_y as usize)
+            .take(visible_height as usize);
+
+        let visible_style_rows = self
+            .mem
+            .styles
+            .chunks_exact(self.mem.width)
+            .skip(content_y as usize)
+            .take(visible_height as usize);
+
+        let target_rows = draw_y as usize..draw_y as usize + visible_height as usize;
+
+        for ((data_row, style_row), target_row) in
+            visible_data_rows.zip(visible_style_rows).zip(target_rows)
+        {
+            let mut col = 0u16;
+            let mut content_col = 0u16;
+            let mut cell_buf = [0u8; 4];
+
+            for (&ch, &cell_style) in data_row.iter().zip(style_row.iter()) {
+                let cell_width = UnicodeWidthChar::width(ch).unwrap_or(0) as u16;
+                // Skip characters before content_x
+                if content_col < content_x {
+                    content_col += cell_width;
+                    continue;
+                }
+
+                let x = area.x.saturating_add(draw_x).saturating_add(col);
+                let y = area.y.saturating_add(target_row as u16);
+
+                if x >= area.x + area.width {
+                    break;
+                }
+
+                if x + cell_width > area.x + area.width {
+                    break;
+                }
+
+                // Convert our style to ratatui's style
+                // TODO(perf-rataui): map underline/dim/fg_color/bg_color from txm::Style
+                let mut tui_style = ratatui_core::style::Style::default();
+                if cell_style.is_bold() {
+                    tui_style = tui_style.add_modifier(ratatui_core::style::Modifier::BOLD);
+                }
+                if cell_style.is_italic() {
+                    tui_style = tui_style.add_modifier(ratatui_core::style::Modifier::ITALIC);
+                }
+                tui_style = self.style.patch(tui_style);
+
+                let cell_str = ch.encode_utf8(&mut cell_buf);
+                buf.set_stringn(x, y, cell_str, cell_width as usize, tui_style);
+
+                col += cell_width;
+                content_col += cell_width;
+            }
+        }
+    }
+}
+
+fn align_horizontal_span(content: u16, area: u16, alignment: HorizontalAlignment) -> (u16, u16) {
+    if content <= area {
+        let draw = match alignment {
+            HorizontalAlignment::Left => 0,
+            HorizontalAlignment::Center => (area - content) / 2,
+            HorizontalAlignment::Right => area - content,
+        };
+        (0, draw)
+    } else {
+        let content_start = match alignment {
+            HorizontalAlignment::Left => 0,
+            HorizontalAlignment::Center => (content - area) / 2,
+            HorizontalAlignment::Right => content - area,
+        };
+        (content_start, 0)
+    }
+}
+
+fn align_vertical_span(content: u16, area: u16, alignment: VerticalAlignment) -> (u16, u16, u16) {
+    let visible = content.min(area);
+
+    if content <= area {
+        let draw = match alignment {
+            VerticalAlignment::Top => 0,
+            VerticalAlignment::Center => (area - content) / 2,
+            VerticalAlignment::Bottom => area - content,
+        };
+        (0, draw, visible)
+    } else {
+        let content_start = match alignment {
+            VerticalAlignment::Top => 0,
+            VerticalAlignment::Center => (content - area) / 2,
+            VerticalAlignment::Bottom => content - area,
+        };
+        (content_start, 0, visible)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Math;
+    use ratatui_core::{
+        buffer::Buffer,
+        layout::{HorizontalAlignment, Rect, VerticalAlignment},
+        style::Style,
+        widgets::Widget,
+    };
+
+    #[test]
+    fn render_clears_short_rows_before_writing() {
+        let tree = {
+            use crate::layout_tree::{LayoutNode, NodeKind};
+            use crate::style::Style as TxmStyle;
+            LayoutNode {
+                width: 2,
+                height: 2,
+                baseline: 0,
+                style: TxmStyle::new(),
+                kind: NodeKind::HStack {
+                    children: vec![LayoutNode::from_char('a'), LayoutNode::from_char('b')],
+                    spacing: 0,
+                },
+            }
+        };
+
+        let math = Math::from_tree(&tree);
+        let area = Rect::new(0, 0, 2, 2);
+        let mut buffer = Buffer::empty(area);
+        for y in 0..area.height {
+            for x in 0..area.width {
+                buffer[(x, y)].set_symbol("x");
+            }
+        }
+
+        (&math).render(area, &mut buffer);
+
+        assert_eq!(buffer[(0, 0)].symbol(), "a");
+        assert_eq!(buffer[(1, 0)].symbol(), "b");
+    }
+
+    #[test]
+    fn render_clears_alignment_padding() {
+        let tree = {
+            use crate::layout_tree::{LayoutNode, NodeKind};
+            use crate::style::Style as TxmStyle;
+            LayoutNode {
+                width: 1,
+                height: 1,
+                baseline: 0,
+                style: TxmStyle::new(),
+                kind: NodeKind::Text { content: vec!['a'] },
+            }
+        };
+
+        let math = Math::from_tree(&tree)
+            .style(Style::default())
+            .horizontal_alignment(HorizontalAlignment::Center)
+            .vertical_alignment(VerticalAlignment::Center);
+
+        let area = Rect::new(0, 0, 3, 3);
+        let mut buffer = Buffer::empty(area);
+        for y in 0..area.height {
+            for x in 0..area.width {
+                buffer[(x, y)].set_symbol("x");
+            }
+        }
+
+        (&math).render(area, &mut buffer);
+
+        assert_eq!(buffer[(0, 0)].symbol(), " ");
+        assert_eq!(buffer[(1, 1)].symbol(), "a");
+        assert_eq!(buffer[(2, 2)].symbol(), " ");
+    }
+}
diff --git a/vendor/txm/src/render.rs b/vendor/txm/src/render.rs
new file mode 100644
index 0000000..cb1c7a6
--- /dev/null
+++ b/vendor/txm/src/render.rs
@@ -0,0 +1,241 @@
+use crate::ast::*;
+use crate::error::ParseError;
+use crate::glyph::{RenderCtx, SymbolRegistry};
+use crate::layout_tree::LayoutNode;
+
+pub fn render(
+    expr: &Expr,
+    reg: &SymbolRegistry,
+    ctx: &mut RenderCtx,
+) -> Result<LayoutNode, ParseError> {
+    match expr {
+        Expr::Ident(s) => {
+            let mut node = LayoutNode::text(s.chars().collect());
+
+            // un-italic if it is a delimiter
+            node.style = if matches!(s.as_str(), "(" | ")" | "[" | "]") {
+                ctx.current_style.un_italic()
+            } else {
+                ctx.current_style
+            };
+
+            Ok(node)
+        }
+
+        Expr::Number(s) => {
+            let mut node = LayoutNode::text_str(s);
+            node.style = ctx.current_style.un_italic();
+            Ok(node)
+        }
+
+        Expr::Delimiter { left, right, inner } => {
+            let inner = render(inner, reg, ctx)?;
+            Ok(LayoutNode::stretchy_delim(
+                inner,
+                *left,
+                *right,
+                false,
+                ctx.current_style.un_italic(),
+            ))
+        }
+
+        Expr::Neg(inner) => {
+            let inner = render(inner, reg, ctx)?;
+            let mut node = LayoutNode::negate(inner);
+            node.style = ctx.current_style;
+            Ok(node)
+        }
+
+        Expr::Command { name, opts, args } => {
+            if let Some(glyph) = reg.get(name) {
+                let mut eval =
+                    |expr: &Expr, eval_ctx: &mut RenderCtx| -> Result<LayoutNode, ParseError> {
+                        render(expr, reg, eval_ctx)
+                    };
+
+                ctx.depth += 1;
+                let rendered_node = glyph.render_macro(args, opts, ctx, &mut eval);
+                ctx.depth -= 1;
+
+                rendered_node
+            } else {
+                let mut node = LayoutNode::text_str(name);
+                node.style = ctx.current_style;
+                Ok(node)
+            }
+        }
+
+        Expr::Superscript(base, sup) => {
+            if let Expr::Command { name, .. } = base.as_ref()
+                && let Some(glyph) = reg.get(name)
+                && glyph.has_limits()
+            {
+                let base_r = render(base, reg, ctx)?;
+                let sup_r = render(sup, reg, ctx)?;
+                return Ok(LayoutNode::limits(base_r, LayoutNode::empty(), sup_r));
+            }
+
+            let base = render(base, reg, ctx)?;
+            render_power(base, sup, reg, ctx)
+        }
+
+        Expr::Subscript(base, sub) => {
+            if let Expr::Command { name, .. } = base.as_ref()
+                && let Some(glyph) = reg.get(name)
+                && glyph.has_limits()
+            {
+                let base_r = render(base, reg, ctx)?;
+                let sub_r = render(sub, reg, ctx)?;
+                return Ok(LayoutNode::limits(base_r, sub_r, LayoutNode::empty()));
+            }
+
+            let base = render(base, reg, ctx)?;
+            let sub = render(sub, reg, ctx)?;
+            Ok(LayoutNode::subscript(base, sub, ctx.current_style))
+        }
+
+        Expr::BothScripts(base, sub, sup) => {
+            if let Expr::Command { name, .. } = base.as_ref()
+                && let Some(glyph) = reg.get(name)
+                && glyph.has_limits()
+            {
+                let base_r = render(base, reg, ctx)?;
+                let sub_r = render(sub, reg, ctx)?;
+                let sup_r = render(sup, reg, ctx)?;
+                return Ok(LayoutNode::limits(base_r, sub_r, sup_r));
+            }
+
+            let base_rendered = render(base, reg, ctx)?;
+            let sub_rendered = render(sub, reg, ctx)?;
+            let sup_rendered = render(sup, reg, ctx)?;
+
+            Ok(LayoutNode::both_scripts(
+                base_rendered,
+                sub_rendered,
+                sup_rendered,
+                ctx.current_style,
+            ))
+        }
+
+        Expr::Prime(base, n) => {
+            let base = render(base, reg, ctx)?;
+            let mut node = LayoutNode::prime(base, *n);
+            node.style = ctx.current_style;
+            Ok(node)
+        }
+
+        Expr::BinOp(lhs, op, rhs) => {
+            let lhs = render(lhs, reg, ctx)?;
+            let rhs = render(rhs, reg, ctx)?;
+            let mut node = LayoutNode::infix(lhs, *op, rhs);
+            node.style = ctx.current_style;
+            Ok(node)
+        }
+
+        Expr::Escape(s) => {
+            let mut node = match s.as_str() {
+                " " => LayoutNode::text(vec![' '; 4]),
+                "," => LayoutNode::text(vec![' ']),
+                ":" => LayoutNode::text(vec![':'; 2]),
+                ";" => LayoutNode::text(vec![';'; 3]),
+                "!" => LayoutNode::empty(),
+                _ => LayoutNode::text_str(s),
+            };
+            node.style = ctx.current_style;
+            Ok(node)
+        }
+
+        Expr::Juxtapose(exprs) => {
+            let nodes: Vec<LayoutNode> = exprs
+                .iter()
+                .map(|e| render(e, reg, ctx))
+                .collect::<Result<_, _>>()?;
+            Ok(LayoutNode::hstack(&nodes, 0))
+        }
+
+        Expr::Empty => Ok(LayoutNode::empty()),
+
+        Expr::Matrix { name, rows } => {
+            if rows.is_empty() {
+                return Ok(LayoutNode::empty());
+            }
+
+            let mut rendered_rows: Vec<Vec<LayoutNode>> = Vec::new();
+
+            let num_cols = rows[0].len();
+            for row in rows {
+                if row.len() != num_cols {
+                    return Err(ParseError::MismatchedMatrixRows);
+                }
+
+                let mut rendered_row: Vec<LayoutNode> = Vec::new();
+                for item in row {
+                    let rendered_item = render(item, reg, ctx)?;
+                    rendered_row.push(rendered_item);
+                }
+
+                rendered_rows.push(rendered_row);
+            }
+
+            LayoutNode::matrix(name, &rendered_rows, ctx.current_style.un_italic())
+        }
+    }
+}
+
+fn render_power(
+    base: LayoutNode,
+    exp: &Expr,
+    reg: &SymbolRegistry,
+    ctx: &mut RenderCtx,
+) -> Result<LayoutNode, ParseError> {
+    if crate::COMPACT_SIMPLE_FRACTIONAL_EXPONENTS
+        && let Expr::Command { name, args, .. } = exp
+        && name == "frac"
+        && args.len() == 2
+        && let (Expr::Number(n), Expr::Number(d)) = (&args[0], &args[1])
+    {
+        let exp_str = format!("{n}/{d}");
+        let exp_node = LayoutNode::text_str(&exp_str);
+        return Ok(LayoutNode::superscript(base, exp_node, ctx.current_style));
+    }
+
+    let rendered_exp = render(exp, reg, ctx)?;
+    Ok(LayoutNode::superscript(
+        base,
+        rendered_exp,
+        ctx.current_style,
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::render;
+    use crate::glyph::{RenderCtx, SqrtGlyph, SymbolRegistry};
+    use crate::parser::Parser;
+    use crate::token::tokenize;
+
+    #[test]
+    fn sqrt_optional_index_keeps_radicand() {
+        let mut registry = SymbolRegistry::new();
+        registry.register("sqrt", SqrtGlyph);
+        let input = r"\sqrt[3]{8}";
+        let tokens = tokenize(input).unwrap();
+        let expr = Parser::new(input, &tokens, &registry).parse_expr().unwrap();
+        let node = render(&expr, &registry, &mut RenderCtx::default()).unwrap();
+
+        // The sqrt node should have an index
+        match &node.kind {
+            crate::layout_tree::NodeKind::Sqrt { index, .. } => {
+                assert!(index.is_some());
+                let index = index.as_ref().unwrap();
+                match &index.kind {
+                    crate::layout_tree::NodeKind::Text { content } => {
+                        assert_eq!(content, &vec!['3']);
+                    }
+                    _ => panic!("expected text node for index"),
+                }
+            }
+            _ => panic!("expected sqrt node"),
+        }
+    }
+}
diff --git a/vendor/txm/src/style.rs b/vendor/txm/src/style.rs
new file mode 100644
index 0000000..47a3c8c
--- /dev/null
+++ b/vendor/txm/src/style.rs
@@ -0,0 +1,299 @@
+use std::fmt::{self, Debug};
+
+use crate::ParseError;
+
+#[derive(Default, Clone, Copy, PartialEq, Eq)]
+pub struct Style(u32);
+
+impl Debug for Style {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut fmt = f.debug_tuple("Style");
+
+        if self.is_bold() {
+            fmt.field(&"bold");
+        }
+        if self.is_italic() {
+            fmt.field(&"italic");
+        }
+        if self.is_underline() {
+            fmt.field(&"underline");
+        }
+        if self.is_dim() {
+            fmt.field(&"dim");
+        }
+        if self.fg_color() != 0 {
+            fmt.field(&self.fg_color());
+        }
+        if self.bg_color() != 0 {
+            fmt.field(&self.bg_color());
+        }
+
+        fmt.finish()
+    }
+}
+
+const BOLD: u32 = 1 << 0;
+const ITALIC: u32 = 1 << 1;
+const UNDERLINE: u32 = 1 << 2;
+const DIM: u32 = 1 << 3;
+
+const FG_MASK: u32 = 0x000FF0;
+const BG_MASK: u32 = 0x0FF000;
+
+const LOCK_BOLD: u32 = 1 << 20;
+const LOCK_ITALIC: u32 = 1 << 21;
+const LOCK_UNDERLINE: u32 = 1 << 22;
+const LOCK_DIM: u32 = 1 << 23;
+const LOCK_FG: u32 = 1 << 24;
+const LOCK_BG: u32 = 1 << 25;
+
+const ATTR_MASK: u32 = BOLD | ITALIC | UNDERLINE | DIM;
+
+impl Style {
+    pub const fn new() -> Self {
+        Style(0)
+    }
+
+    pub const fn bold(mut self) -> Self {
+        self.0 |= BOLD | LOCK_BOLD;
+        self
+    }
+
+    pub const fn italic(mut self) -> Self {
+        self.0 |= ITALIC | LOCK_ITALIC;
+        self
+    }
+
+    pub const fn underline(mut self) -> Self {
+        self.0 |= UNDERLINE | LOCK_UNDERLINE;
+        self
+    }
+
+    pub const fn dim(mut self) -> Self {
+        self.0 |= DIM | LOCK_DIM;
+        self
+    }
+
+    pub const fn un_bold(mut self) -> Self {
+        self.0 = (self.0 & !BOLD) | LOCK_BOLD;
+        self
+    }
+
+    pub const fn un_italic(mut self) -> Self {
+        self.0 = (self.0 & !ITALIC) | LOCK_ITALIC;
+        self
+    }
+
+    pub const fn un_underline(mut self) -> Self {
+        self.0 = (self.0 & !UNDERLINE) | LOCK_UNDERLINE;
+        self
+    }
+
+    pub const fn un_dim(mut self) -> Self {
+        self.0 = (self.0 & !DIM) | LOCK_DIM;
+        self
+    }
+
+    pub const fn fg(mut self, color: Color) -> Self {
+        self.0 = (self.0 & !FG_MASK) | ((color.0 as u32) << 4) | LOCK_FG;
+        self
+    }
+
+    pub const fn bg(mut self, color: Color) -> Self {
+        self.0 = (self.0 & !BG_MASK) | ((color.0 as u32) << 12) | LOCK_BG;
+        self
+    }
+
+    pub const fn is_bold(self) -> bool {
+        self.0 & BOLD != 0
+    }
+
+    pub const fn is_italic(self) -> bool {
+        self.0 & ITALIC != 0
+    }
+
+    pub const fn is_underline(self) -> bool {
+        self.0 & UNDERLINE != 0
+    }
+
+    pub const fn is_dim(self) -> bool {
+        self.0 & DIM != 0
+    }
+
+    pub const fn fg_color(self) -> u8 {
+        ((self.0 & FG_MASK) >> 4) as u8
+    }
+
+    pub const fn bg_color(self) -> u8 {
+        ((self.0 & BG_MASK) >> 12) as u8
+    }
+
+    pub const fn merge(self, other: Style) -> Style {
+        let combined_lock = self.0 | other.0;
+
+        let bold = if other.0 & LOCK_BOLD != 0 {
+            other.0 & BOLD
+        } else if self.0 & LOCK_BOLD != 0 {
+            self.0 & BOLD
+        } else {
+            (self.0 | other.0) & BOLD
+        };
+
+        let italic = if other.0 & LOCK_ITALIC != 0 {
+            other.0 & ITALIC
+        } else if self.0 & LOCK_ITALIC != 0 {
+            self.0 & ITALIC
+        } else {
+            (self.0 | other.0) & ITALIC
+        };
+
+        let underline = if other.0 & LOCK_UNDERLINE != 0 {
+            other.0 & UNDERLINE
+        } else if self.0 & LOCK_UNDERLINE != 0 {
+            self.0 & UNDERLINE
+        } else {
+            (self.0 | other.0) & UNDERLINE
+        };
+
+        let dim = if other.0 & LOCK_DIM != 0 {
+            other.0 & DIM
+        } else if self.0 & LOCK_DIM != 0 {
+            self.0 & DIM
+        } else {
+            (self.0 | other.0) & DIM
+        };
+
+        let fg = if other.0 & LOCK_FG != 0 {
+            other.0 & FG_MASK
+        } else if self.0 & LOCK_FG != 0 {
+            self.0 & FG_MASK
+        } else {
+            let other_fg = other.0 & FG_MASK;
+            if other_fg != 0 {
+                other_fg
+            } else {
+                self.0 & FG_MASK
+            }
+        };
+
+        let bg = if other.0 & LOCK_BG != 0 {
+            other.0 & BG_MASK
+        } else if self.0 & LOCK_BG != 0 {
+            self.0 & BG_MASK
+        } else {
+            let other_bg = other.0 & BG_MASK;
+            if other_bg != 0 {
+                other_bg
+            } else {
+                self.0 & BG_MASK
+            }
+        };
+
+        let lock_part = combined_lock
+            & (LOCK_BOLD | LOCK_ITALIC | LOCK_UNDERLINE | LOCK_DIM | LOCK_FG | LOCK_BG);
+        Style(lock_part | bold | italic | underline | dim | fg | bg)
+    }
+
+    pub const fn is_empty(self) -> bool {
+        self.0 & (ATTR_MASK | FG_MASK | BG_MASK) == 0
+    }
+
+    pub fn write_ansi_prefix(&self, f: &mut impl fmt::Write) -> fmt::Result {
+        if self.is_empty() {
+            return Ok(());
+        }
+
+        write!(f, "\x1b[")?;
+        let mut first = true;
+
+        if self.is_bold() {
+            write!(f, "1")?;
+            first = false;
+        }
+        if self.is_italic() {
+            write!(f, "{}3", if first { "" } else { ";" })?;
+            first = false;
+        }
+        if self.is_underline() {
+            write!(f, "{}4", if first { "" } else { ";" })?;
+            first = false;
+        }
+        if self.is_dim() {
+            write!(f, "{}2", if first { "" } else { ";" })?;
+            first = false;
+        }
+
+        let fg = self.fg_color();
+        let bg = self.bg_color();
+
+        if fg != 0 {
+            write!(f, "{}38;5;{}", if first { "" } else { ";" }, fg)?;
+            first = false;
+        }
+
+        if bg != 0 {
+            write!(f, "{}48;5;{}", if first { "" } else { ";" }, bg)?;
+        }
+
+        write!(f, "m")?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Color(u8);
+
+impl Color {
+    pub const NONE: Color = Color(0);
+    pub const BLACK: Color = Color(1);
+    pub const RED: Color = Color(2);
+    pub const GREEN: Color = Color(3);
+    pub const YELLOW: Color = Color(4);
+    pub const BLUE: Color = Color(5);
+    pub const MAGENTA: Color = Color(6);
+    pub const CYAN: Color = Color(7);
+    pub const WHITE: Color = Color(8);
+    pub const BRIGHT_BLACK: Color = Color(9);
+    pub const BRIGHT_RED: Color = Color(10);
+    pub const BRIGHT_GREEN: Color = Color(11);
+    pub const BRIGHT_YELLOW: Color = Color(12);
+    pub const BRIGHT_BLUE: Color = Color(13);
+    pub const BRIGHT_MAGENTA: Color = Color(14);
+    pub const BRIGHT_CYAN: Color = Color(15);
+    pub const BRIGHT_WHITE: Color = Color(16);
+
+    pub const fn new(n: u8) -> Self {
+        Color(n)
+    }
+
+    pub const fn value(self) -> u8 {
+        self.0
+    }
+}
+
+pub fn parse_color(s: &str) -> Result<Color, ParseError> {
+    Ok(match s {
+        "black" => Color::BLACK,
+        "red" => Color::RED,
+        "green" => Color::GREEN,
+        "yellow" => Color::YELLOW,
+        "blue" => Color::BLUE,
+        "magenta" => Color::MAGENTA,
+        "cyan" => Color::CYAN,
+        "white" => Color::WHITE,
+        "brightblack" | "gray" | "grey" => Color::BRIGHT_BLACK,
+        "brightred" => Color::BRIGHT_RED,
+        "brightgreen" => Color::BRIGHT_GREEN,
+        "brightyellow" => Color::BRIGHT_YELLOW,
+        "brightblue" => Color::BRIGHT_BLUE,
+        "brightmagenta" => Color::BRIGHT_MAGENTA,
+        "brightcyan" => Color::BRIGHT_CYAN,
+        "brightwhite" => Color::BRIGHT_WHITE,
+
+        _ => {
+            return Err(ParseError::InvalidColor {
+                name: s.to_string(),
+            });
+        }
+    })
+}
diff --git a/vendor/txm/src/token.rs b/vendor/txm/src/token.rs
new file mode 100644
index 0000000..b91b213
--- /dev/null
+++ b/vendor/txm/src/token.rs
@@ -0,0 +1,156 @@
+use std::ops::Range;
+
+use logos::Logos;
+
+use crate::error::ParseError;
+
+pub type SpannedToken<'a> = (Token<'a>, Range<usize>);
+
+#[derive(Logos, Debug, Clone, PartialEq)]
+pub enum Token<'a> {
+    #[token("{")]
+    LBrace,
+    #[token("}")]
+    RBrace,
+    #[token("[")]
+    LBracket,
+    #[token("]")]
+    RBracket,
+    #[token("^")]
+    Caret,
+    #[token("_")]
+    Underscore,
+    #[token("'")]
+    Prime,
+    #[token("|")]
+    Pipe,
+    #[token("!")]
+    Bang,
+    #[token("+")]
+    Plus,
+    #[token("-")]
+    Minus,
+    #[token("=")]
+    Equals,
+    #[token("*")]
+    Star,
+    #[token(",")]
+    Comma,
+    #[token("(")]
+    LParen,
+    #[token(")")]
+    RParen,
+    #[token(".")]
+    Dot,
+    #[token(":")]
+    Colon,
+    #[token(";")]
+    Semicolon,
+    #[token("<")]
+    Less,
+    #[token(">")]
+    Greater,
+    #[token("/")]
+    Slash,
+
+    #[token("&")]
+    Ampersand,
+
+    #[token("?")]
+    Question,
+    #[token("@")]
+    At,
+    #[token("#")]
+    Hash,
+    #[token("$")]
+    Dollar,
+    #[token("%")]
+    Percent,
+    #[token("~")]
+    Tilde,
+    #[token("\"")]
+    Quote,
+    #[token("`")]
+    Backtick,
+
+    #[regex(r"\\[a-zA-Z]+", |lex| &lex.slice()[1..])]
+    Command(&'a str),
+
+    #[regex(r"\\[^a-zA-Z]", |lex| &lex.slice()[1..])]
+    Escape(&'a str),
+
+    #[regex(r"[0-9]+")]
+    Number(&'a str),
+
+    // can also be without a capture group but with is a bit nicer
+    #[regex(r"([a-zA-Z]|[^ -~\s])")]
+    Ident(&'a str),
+
+    #[regex(r"\s+", logos::skip)]
+    Whitespace,
+}
+
+impl<'a> Token<'a> {
+    pub fn text_char(&self) -> Option<char> {
+        match self {
+            Token::Bang => Some('!'),
+            Token::Question => Some('?'),
+            Token::Comma => Some(','),
+            Token::Dot => Some('.'),
+            Token::Colon => Some(':'),
+            Token::Semicolon => Some(';'),
+            Token::Slash => Some('/'),
+            Token::Less => Some('<'),
+            Token::Greater => Some('>'),
+            Token::Plus => Some('+'),
+            Token::Minus => Some('-'),
+            Token::Equals => Some('='),
+            Token::Star => Some('*'),
+            Token::Pipe => Some('|'),
+            Token::Ampersand => Some('&'),
+            Token::LParen => Some('('),
+            Token::RParen => Some(')'),
+            Token::LBracket => Some('['),
+            Token::RBracket => Some(']'),
+            Token::LBrace => Some('{'),
+            Token::RBrace => Some('}'),
+            Token::Prime => Some('\''),
+            Token::Caret => Some('^'),
+            Token::Underscore => Some('_'),
+            Token::At => Some('@'),
+            Token::Hash => Some('#'),
+            Token::Dollar => Some('$'),
+            Token::Percent => Some('%'),
+            Token::Tilde => Some('~'),
+            Token::Quote => Some('"'),
+            Token::Backtick => Some('`'),
+            Token::Ident(s) => s.chars().next(),
+            Token::Number(s) if s.len() == 1 => s.chars().next(),
+            Token::Escape(s) => s.chars().next(),
+            _ => None,
+        }
+    }
+
+    pub fn as_char(&self) -> Option<char> {
+        match self {
+            Token::LParen | Token::Escape("(") => Some('('),
+            Token::RParen | Token::Escape(")") => Some(')'),
+            Token::LBracket | Token::Escape("[") => Some('['),
+            Token::RBracket | Token::Escape("]") => Some(']'),
+            Token::LBrace | Token::Escape("{") => Some('{'),
+            Token::RBrace | Token::Escape("}") => Some('}'),
+            Token::Pipe | Token::Escape("|") => Some('|'),
+            _ => None,
+        }
+    }
+}
+
+pub fn tokenize(input: &str) -> Result<Vec<SpannedToken<'_>>, ParseError> {
+    Token::lexer(input)
+        .spanned()
+        .map(|(i, span)| {
+            i.map(|i| (i, span.clone()))
+                .map_err(|_| ParseError::InvalidToken { byte: span.start })
+        })
+        .collect()
+}
diff --git a/vendor/txm/tests/ratatui.rs b/vendor/txm/tests/ratatui.rs
new file mode 100644
index 0000000..2440b5b
--- /dev/null
+++ b/vendor/txm/tests/ratatui.rs
@@ -0,0 +1,53 @@
+#![cfg(feature = "ratatui")]
+
+use ratatui_core::{
+    buffer::Buffer,
+    layout::{HorizontalAlignment, Rect, VerticalAlignment},
+    style::{Color, Style},
+    widgets::Widget,
+};
+
+#[test]
+fn math_renders_centered_text_and_reports_size() {
+    let math = txm::ratatui::Math::new("abcd").expect("math creation failed");
+    let math = math
+        .style(Style::default().fg(Color::Red))
+        .horizontal_alignment(HorizontalAlignment::Center)
+        .vertical_alignment(VerticalAlignment::Center);
+    let area = Rect::new(2, 1, 2, 1);
+    let mut buffer = Buffer::empty(area);
+
+    assert_eq!(math.size().width, 4);
+    assert_eq!(math.size().height, 1);
+
+    (&math).render(area, &mut buffer);
+
+    assert_eq!(buffer[(2, 1)].symbol(), "b");
+    assert_eq!(buffer[(3, 1)].symbol(), "c");
+    assert_eq!(buffer[(2, 1)].fg, Color::Red);
+}
+
+#[test]
+fn math_reports_display_width_for_wide_characters() {
+    let math = txm::ratatui::Math::new("你你").expect("math creation failed");
+
+    assert_eq!(math.size().width, 4);
+    assert_eq!(math.size().height, 1);
+}
+
+#[test]
+fn math_renders_default_left_alignment_when_content_fits() {
+    let math = txm::ratatui::Math::new("ab").expect("math creation failed");
+    let area = Rect::new(0, 0, 4, 1);
+    let mut buffer = Buffer::empty(area);
+
+    (&math).render(area, &mut buffer);
+
+    assert_eq!(buffer[(0, 0)].symbol(), "a");
+    assert_eq!(buffer[(1, 0)].symbol(), "b");
+}
+
+#[test]
+fn math_returns_error_for_invalid_input() {
+    assert!(txm::ratatui::Math::new("{x").is_err());
+}
diff --git a/vendor/txm/tests/smoke.rs b/vendor/txm/tests/smoke.rs
new file mode 100644
index 0000000..8a90b6a
--- /dev/null
+++ b/vendor/txm/tests/smoke.rs
@@ -0,0 +1,239 @@
+use std::process::Command;
+
+#[test]
+fn prints_usage_without_arguments() {
+    let output = Command::new(env!("CARGO_BIN_EXE_txm"))
+        .output()
+        .expect("failed to run txm");
+
+    assert!(output.status.success());
+    assert!(String::from_utf8_lossy(&output.stdout).contains("Usage:"));
+}
+
+#[test]
+fn boxes_simple_identifier() {
+    let output = Command::new(env!("CARGO_BIN_EXE_txm"))
+        .arg("x")
+        .output()
+        .expect("failed to run txm");
+
+    assert!(output.status.success());
+    let rendered = String::from_utf8_lossy(&output.stdout).to_string();
+    // The box should contain the italic x character (rendered via ANSI escape)
+    assert!(
+        rendered.contains('x'),
+        "expected italic x in box: {rendered:?}"
+    );
+    assert!(
+        rendered.starts_with('┌'),
+        "should start with box border: {rendered:?}"
+    );
+}
+
+#[test]
+fn boxes_wide_identifier() {
+    let output = Command::new(env!("CARGO_BIN_EXE_txm"))
+        .arg("你")
+        .output()
+        .expect("failed to run txm");
+
+    assert!(output.status.success());
+    let rendered = String::from_utf8_lossy(&output.stdout).to_string();
+    // CJK characters don't have italic variants, so 你 stays as 你
+    assert!(rendered.contains('你'), "expected 你 in box: {rendered:?}");
+    assert!(
+        rendered.starts_with('┌'),
+        "should start with box border: {rendered:?}"
+    );
+}
+
+#[test]
+fn boxes_adjacent_wide_identifiers() {
+    let output = Command::new(env!("CARGO_BIN_EXE_txm"))
+        .arg("你你")
+        .output()
+        .expect("failed to run txm");
+
+    assert!(output.status.success());
+    let rendered = String::from_utf8_lossy(&output.stdout).to_string();
+    assert!(rendered.contains('你'), "expected 你 in box: {rendered:?}");
+    assert!(
+        rendered.starts_with('┌'),
+        "should start with box border: {rendered:?}"
+    );
+}
+
+#[test]
+fn render_returns_raw_lines_for_simple_identifier() {
+    let rendered = txm::render("x").expect("render failed");
+
+    // x should be rendered as italic via ANSI escape codes
+    assert!(rendered.contains('x'), "expected italic x: {rendered:?}");
+}
+
+#[test]
+fn braces_group_invisibly() {
+    let rendered = txm::render("{x}").unwrap();
+    assert!(rendered.contains('x'), "expected x: {rendered:?}");
+    assert!(
+        !rendered.contains('{'),
+        "should not contain literal {{: {rendered:?}"
+    );
+}
+
+#[test]
+fn render_returns_error_for_invalid_lexer_input() {
+    assert!(txm::render("\\").is_err());
+}
+
+#[test]
+fn render_returns_error_for_unknown_matrix_environment() {
+    assert!(txm::render(r"\begin{unknown}x\end{unknown}").is_err());
+}
+
+#[test]
+fn render_returns_error_for_ragged_matrix() {
+    assert!(txm::render(r"\begin{matrix}a&b\\c\end{matrix}").is_err());
+}
+
+#[test]
+fn cli_reports_render_errors_without_panicking() {
+    let output = Command::new(env!("CARGO_BIN_EXE_txm"))
+        .arg(r"\begin{unknown}x\end{unknown}")
+        .output()
+        .expect("failed to run txm");
+
+    assert!(!output.status.success());
+    assert_eq!(
+        String::from_utf8_lossy(&output.stderr),
+        "error: unknown matrix environment: unknown\n"
+    );
+}
+
+#[test]
+fn mathbf_maps_to_bold_alphabet() {
+    let rendered = txm::render(r"\mathbf{x}").unwrap();
+    // \mathbf applies to_bold on italic x → produces bold italic x
+    assert!(
+        rendered.contains('𝐱') || rendered.contains('𝐱'),
+        "expected bold math x: {rendered:?}"
+    );
+}
+
+#[test]
+fn mathbb_uses_letterlike_specials() {
+    let rendered = txm::render(r"\mathbb{R}").unwrap();
+    assert!(
+        rendered.contains('ℝ'),
+        "expected blackboard bold R: {rendered:?}"
+    );
+}
+
+#[test]
+fn single_token_argument_needs_no_braces() {
+    let rendered = txm::render(r"\mathbf n").unwrap();
+    assert!(
+        rendered.contains('𝐧') || rendered.contains('𝐧'),
+        "expected bold math n: {rendered:?}"
+    );
+}
+
+#[test]
+fn accent_stacks_mark_above_argument() {
+    let rendered = txm::render(r"\hat{x}").unwrap();
+    assert!(rendered.contains('^'), "expected hat mark: {rendered:?}");
+    assert!(rendered.contains('x'), "expected italic x: {rendered:?}");
+}
+
+#[test]
+fn latex_style_parentheses_render_as_paired_delimiters() {
+    let rendered = txm::render(r"\left( x \right)").unwrap();
+
+    assert!(rendered.contains('(') || rendered.contains('⎛'));
+    assert!(rendered.contains(')') || rendered.contains('⎠'));
+    assert!(rendered.contains('x'), "expected italic x: {rendered:?}");
+}
+
+#[test]
+fn latex_style_brackets_render_fraction_inside() {
+    let rendered = txm::render(r"\left[ \frac{1}{2} \right]").unwrap();
+
+    assert!(rendered.contains('[') || rendered.contains('⎡'));
+    assert!(rendered.contains(']') || rendered.contains('⎤'));
+    assert!(rendered.contains('1'));
+    assert!(rendered.contains('2'));
+}
+
+#[test]
+fn unmatched_latex_delimiters_fail_gracefully() {
+    assert!(txm::render(r"\left( x ").is_err());
+}
+
+#[test]
+fn inline_punctuation_renders_literally() {
+    let rendered = txm::render(r"(3,0)").unwrap();
+    // Numbers stay upright, comma stays literal
+    assert!(rendered.contains('3'), "expected 3: {rendered:?}");
+    assert!(rendered.contains(','), "expected comma: {rendered:?}");
+    assert!(rendered.contains('0'), "expected 0: {rendered:?}");
+}
+
+#[test]
+fn stretchy_brackets_use_side_correct_extensions() {
+    let rendered = txm::render(r"\begin{bmatrix}a\\b\\c\end{bmatrix}").unwrap();
+    let lines: Vec<&str> = rendered.lines().collect();
+    assert!(lines.len() >= 3, "expected tall bracket: {rendered:?}");
+    assert!(
+        lines[1].starts_with('⎢') && lines[1].ends_with('⎥'),
+        "middle row should use left/right bracket pieces: {:?}",
+        lines[1]
+    );
+}
+
+#[test]
+fn pipe_delimiters_render_like_abs() {
+    assert_eq!(
+        txm::render("|x|").unwrap(),
+        txm::render(r"\abs{x}").unwrap()
+    );
+
+    let rendered = txm::render("|x|").unwrap();
+    assert!(rendered.contains('x'), "expected italic x: {rendered:?}");
+    assert!(
+        rendered.contains('│'),
+        "expected pipe delimiters: {rendered:?}"
+    );
+}
+
+#[test]
+fn text_mode_produces_upright_text() {
+    let rendered = txm::render(r"\text{x}").unwrap();
+    // \text should produce upright x, not italic
+    assert!(rendered.contains('x'), "expected upright x: {rendered:?}");
+    assert!(
+        !rendered.contains('𝑥'),
+        "should not contain italic x: {rendered:?}"
+    );
+}
+
+#[test]
+fn textbf_produces_bold_upright() {
+    let rendered = txm::render(r"\textbf{hello}").unwrap();
+    assert!(rendered.contains('h'), "expected upright h: {rendered:?}");
+    assert!(
+        !rendered.contains('ℎ'),
+        "should not contain italic h: {rendered:?}"
+    );
+}
+
+#[test]
+fn color_applies_to_fraction_line() {
+    let rendered = txm::render(r"\color{red}{\frac{x}{y}}").unwrap();
+    // Both the fraction line and content should be colored
+    assert!(
+        rendered.contains('─'),
+        "expected fraction line: {rendered:?}"
+    );
+    assert!(rendered.contains('x'), "expected numerator: {rendered:?}");
+    assert!(rendered.contains('y'), "expected denominator: {rendered:?}");
+}