Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274import { describe, expect, test } from "bun:test"import { parseLatex } from "./parser"import { LatexParseError } from "./types"
describe("parseLatex", () => { test("parses fractions and scripts structurally", () => { expect(parseLatex(String.raw`\frac{x^2+1}{y_0}`)).toMatchObject({ type: "fraction", bar: true, numerator: { type: "row" }, denominator: { type: "scripts" }, }) })
test("parses matrix environments into rows and cells", () => { expect(parseLatex(String.raw`\begin{pmatrix}a & b \\ c & d\end{pmatrix}`)).toMatchObject({ type: "matrix", environment: "pmatrix", rows: [ [ { type: "symbol", value: "a" }, { type: "symbol", value: "b" }, ], [ { type: "symbol", value: "c" }, { type: "symbol", value: "d" }, ], ], }) })
test("accepts array column specs and starred alignment environments", () => { expect(parseLatex(String.raw`\begin{array}{cc}a & b \\ c & d\end{array}`)).toMatchObject({ type: "matrix", environment: "array", columns: "cc", rows: [ [{}, {}], [{}, {}], ], }) expect(parseLatex(String.raw`\begin{align*}a &= b \\ c &= d\end{align*}`)).toMatchObject({ type: "matrix", environment: "align", }) })
test("preserves double norm delimiters without changing single bars", () => { expect(parseLatex(String.raw`\|v\|`, { strict: true })).toMatchObject({ type: "row", body: [{ value: "║" }, { value: "v" }, { value: "║" }], }) expect(parseLatex(String.raw`\left\|v\right\|`, { strict: true })).toMatchObject({ type: "delimited", left: "║", right: "║", }) expect(parseLatex(String.raw`\left|v\right|`, { strict: true })).toMatchObject({ type: "delimited", left: "│", right: "│", }) })
test("matches the whole right command and keeps nested delimiters", () => { expect(parseLatex(String.raw`\left(A\rightarrow B\right)`, { strict: true })).toMatchObject({ type: "delimited", left: "(", body: { type: "row", body: [{ value: "A" }, { value: "→" }, { value: "B" }] }, right: ")", }) expect(parseLatex(String.raw`\left(\left[A\right]\rightharpoonup B\right)`)).toMatchObject({ type: "delimited", body: { type: "row", body: [{ type: "delimited" }, { value: "⇀" }, { value: "B" }] }, }) expect(() => parseLatex(String.raw`\left(A\rightarrow B`, { strict: true })).toThrow(/Missing \\right/) expect(() => parseLatex(String.raw`\left(A\rightward B\right)`, { strict: true })).toThrow( /Unsupported command \\rightward/, ) })
test("accepts empty leading, interior, and trailing environment cells", () => { expect(parseLatex(String.raw`\begin{aligned}&=x\\&=y\end{aligned}`, { strict: true })).toMatchObject({ type: "matrix", environment: "aligned", rows: [ [ { type: "row", body: [] }, { type: "row", body: [{ value: "=" }, { value: "x" }] }, ], [ { type: "row", body: [] }, { type: "row", body: [{ value: "=" }, { value: "y" }] }, ], ], }) expect(parseLatex(String.raw`\begin{matrix}a&&\\&b&\end{matrix}`, { strict: true })).toMatchObject({ type: "matrix", rows: [ [{ value: "a" }, { type: "row", body: [] }, { type: "row", body: [] }], [{ type: "row", body: [] }, { value: "b" }, { type: "row", body: [] }], ], }) expect(parseLatex(String.raw`\begin{matrix}a\\\end{matrix}`)).toMatchObject({ rows: [[{ value: "a" }]] }) expect(parseLatex(String.raw`\begin{matrix}\\\end{matrix}`)).toMatchObject({ rows: [[{ type: "row", body: [] }]] }) })
test("parses displaylines as separate gathered rows", () => { expect(parseLatex(String.raw`\displaylines{x=1\\y=2}`, { strict: true })).toMatchObject({ type: "matrix", environment: "gathered", rows: [ [{ type: "row", body: [{ value: "x" }, { value: "=" }, { value: "1" }] }], [{ type: "row", body: [{ value: "y" }, { value: "=" }, { value: "2" }] }], ], }) expect(parseLatex(String.raw`\displaylines{\frac{1}{2}\\{y}}+z`)).toMatchObject({ type: "row", body: [{ type: "matrix", rows: [[{ type: "fraction" }], [{ value: "y" }]] }, { value: "+" }, { value: "z" }], }) expect(() => parseLatex(String.raw`\displaylines[l]{x\\y}`, { strict: true })).toThrow(LatexParseError) expect(() => parseLatex(String.raw`\displaylines{x\\y`, { strict: true })).toThrow(LatexParseError) })
test.each([ ["", undefined], ["[]", undefined], ["[l]", "left"], ["[r]", "right"], ] as const)("parses continued fraction alignment %s before its arguments", (option, numeratorAlign) => { expect(parseLatex(String.raw`\cfrac${option}{1}{23}`, { strict: true })).toEqual({ type: "fraction", numerator: { type: "symbol", value: "1", role: "ordinary" }, denominator: { type: "row", body: [ { type: "symbol", value: "2", role: "ordinary" }, { type: "symbol", value: "3", role: "ordinary" }, ], }, bar: true, ...(numeratorAlign ? { numeratorAlign } : {}), }) })
test.each(["[c]", "[lr]", "[left]", "[l"])("rejects unsupported continued fraction alignment %s", (option) => { expect(() => parseLatex(String.raw`\cfrac${option}{1}{2}`, { strict: true })).toThrow(LatexParseError) })
test("retains normalized array columns including edge and double rules", () => { expect(parseLatex(String.raw`\begin{array}{ | l || c r | }a&b&c\end{array}`, { strict: true })).toMatchObject({ type: "matrix", environment: "array", columns: "|l||cr|", }) })
test.each(["", "||", "p{2cm}", "*{2}{c}", "c@{}c", "lXr"])("rejects unsupported array columns %s", (columns) => { expect(() => parseLatex(String.raw`\begin{array}{${columns}}a\end{array}`, { strict: true })).toThrow( LatexParseError, ) })
test("requires an array column specification", () => { expect(() => parseLatex(String.raw`\begin{array}a&b\end{array}`, { strict: true })).toThrow(LatexParseError) })
test("emits structural braces while keeping annotations as scripts", () => { expect(parseLatex(String.raw`\overbrace{a+b}^{n}`, { strict: true })).toMatchObject({ type: "scripts", base: { type: "brace", position: "over", body: { type: "row" } }, superscript: { value: "n" }, }) expect(parseLatex(String.raw`\underbrace{x}_{k}`, { strict: true })).toMatchObject({ type: "scripts", base: { type: "brace", position: "under", body: { value: "x" } }, subscript: { value: "k" }, }) })
test("recognizes named braces and rejects unsupported delimiter commands in strict mode", () => { expect(parseLatex(String.raw`\left\lbrace x\right\rbrace`, { strict: true })).toMatchObject({ type: "delimited", left: "{", right: "}", }) expect(parseLatex(String.raw`\lbrace x\rbrace`, { strict: true })).toMatchObject({ type: "row", body: [{ value: "{" }, { value: "x" }, { value: "}" }], }) for (const source of [ String.raw`\left\unknown x\right)`, String.raw`\left(x\right\unknown`, String.raw`\big\unknown`, String.raw`\left(x\middle\unknown y\right)`, ]) { expect(() => parseLatex(source, { strict: true })).toThrow(/Unsupported delimiter \\unknown/) } })
test("expands user macros", () => { expect(parseLatex(String.raw`\R \to \R`, { macros: { "\\R": String.raw`\mathbb{R}` } })).toMatchObject({ type: "row", }) })
test("reports useful strict-mode errors", () => { expect(() => parseLatex(String.raw`\definitelyUnknown{x}`, { strict: true })).toThrow(LatexParseError) })
test("keeps escaped braces inside raw text groups", () => { expect(parseLatex(String.raw`\text{left \{ only}`)).toMatchObject({ type: "text", value: "left { only", }) expect(parseLatex(String.raw`\text{right \} only}`)).toMatchObject({ type: "text", value: "right } only", }) })
test("supports starred named operators and limits modifiers", () => { expect(parseLatex(String.raw`\operatorname*{arg\,max}_{x}`)).toMatchObject({ type: "scripts", base: { type: "operator", value: "arg max", limits: true }, }) expect(parseLatex(String.raw`\int\limits_0^1`)).toMatchObject({ type: "scripts", base: { type: "operator", value: "∫", limits: true }, }) expect(parseLatex(String.raw`\sum\nolimits_{i=1}`)).toMatchObject({ type: "scripts", base: { type: "operator", value: "∑", limits: false }, }) })
test("interprets operator spacing and preserves roman text whitespace", () => { expect(parseLatex(String.raw`\operatorname{arg\,max}`, { strict: true })).toEqual({ type: "operator", value: "arg max", limits: false, }) expect(parseLatex(String.raw`\textrm{ if }`, { strict: true })).toEqual({ type: "variant", variant: "normal", body: { type: "text", value: " if " }, }) })
test("bounds source and recursive macro expansion", () => { expect(() => parseLatex("12345", { maxSourceLength: 4 })).toThrow(/4-character limit/) expect(() => parseLatex(String.raw`\a`, { macros: { a: String.raw`\a\a` }, maxExpandedLength: 64, }), ).toThrow(/64-character limit/) expect(() => parseLatex(String.raw`\a`, { macros: { a: "{{x}}" }, maxDepth: 1 })).toThrow(/1-level limit/) expect(() => parseLatex("x", { maxSourceLength: 0 })).toThrow(RangeError) })
test("fails quickly when malformed environments cannot advance", () => { expect(() => parseLatex(String.raw`\begin{matrix}]`)).toThrow(/Missing \\end{matrix}/) expect(() => parseLatex(String.raw`\begin{matrix}x}`)).toThrow(/Unexpected "}" in matrix/) expect(() => parseLatex(String.raw`\begin{matrix}&}`)).toThrow(/Unexpected "}" in matrix/) })
test("bounds structural nesting with a parse error instead of overflowing the stack", () => { const source = "{".repeat(80) + "x" + "}".repeat(80) expect(() => parseLatex(source, { maxDepth: 64 })).toThrow(/64-level limit/) expect(() => parseLatex(String.raw`\frac`.repeat(80) + "x", { maxDepth: 64 })).toThrow(/64-level limit/) })})