tex2typst 0.3.24 → 0.3.25

package/dist/typst-types.d.ts

@@ -10,7 +10,7 @@ export declare enum TypstTokenType {
     NEWLINE = 8
 }
 export declare class TypstToken {
-    type: TypstTokenType;
+    readonly type: TypstTokenType;
     value: string;
     constructor(type: TypstTokenType, content: string);
     eq(other: TypstToken): boolean;
@@ -25,6 +25,7 @@ export interface TypstSupsubData {
     sub: TypstNode | null;
 }
 export interface TypstLeftRightData {
+    body: TypstNode;
     left: TypstToken | null;
     right: TypstToken | null;
 }
@@ -32,17 +33,17 @@ export interface TypstLeftRightData {
  * fraction: `1/2`, `(x + y)/2`, `(1+x)/(1-x)`
  * group: `a + 1/3`
  * leftright: `(a + 1/3)`, `[a + 1/3)`, `lr(]sum_(x=1)^n])`
+ * markupFunc: `#heading(level: 2)[something]`, `#text(fill: red)[some text and math $x + y$]`
  */
-export type TypstNodeType = 'terminal' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'leftright' | 'align' | 'matrix' | 'cases';
+export type TypstNodeType = 'terminal' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'leftright' | 'matrixLike' | 'markupFunc';
 export type TypstNamedParams = {
     [key: string]: TypstNode;
 };
 export declare abstract class TypstNode {
     readonly type: TypstNodeType;
     head: TypstToken;
-    args?: TypstNode[];
     options?: TypstNamedParams;
-    constructor(type: TypstNodeType, head: TypstToken | null, args?: TypstNode[]);
+    constructor(type: TypstNodeType, head: TypstToken | null);
     abstract isOverHigh(): boolean;
     setOptions(options: TypstNamedParams): void;
     eq(other: TypstNode): boolean;
@@ -54,7 +55,8 @@ export declare class TypstTerminal extends TypstNode {
     toString(): string;
 }
 export declare class TypstGroup extends TypstNode {
-    constructor(args: TypstNode[]);
+    items: TypstNode[];
+    constructor(items: TypstNode[]);
     isOverHigh(): boolean;
 }
 export declare class TypstSupsub extends TypstNode {
@@ -65,31 +67,31 @@ export declare class TypstSupsub extends TypstNode {
     isOverHigh(): boolean;
 }
 export declare class TypstFuncCall extends TypstNode {
+    args: TypstNode[];
     constructor(head: TypstToken, args: TypstNode[]);
     isOverHigh(): boolean;
 }
 export declare class TypstFraction extends TypstNode {
+    args: TypstNode[];
     constructor(args: TypstNode[]);
     isOverHigh(): boolean;
 }
 export declare class TypstLeftright extends TypstNode {
+    body: TypstNode;
     left: TypstToken | null;
     right: TypstToken | null;
-    constructor(head: TypstToken | null, args: TypstNode[], data: TypstLeftRightData);
+    constructor(head: TypstToken | null, data: TypstLeftRightData);
     isOverHigh(): boolean;
 }
-export declare class TypstAlign extends TypstNode {
+export declare class TypstMatrixLike extends TypstNode {
     matrix: TypstNode[][];
-    constructor(data: TypstNode[][]);
+    constructor(head: TypstToken | null, data: TypstNode[][]);
     isOverHigh(): boolean;
+    static readonly MAT: TypstToken;
+    static readonly CASES: TypstToken;
 }
-export declare class TypstMatrix extends TypstNode {
-    matrix: TypstNode[][];
-    constructor(data: TypstNode[][]);
-    isOverHigh(): boolean;
-}
-export declare class TypstCases extends TypstNode {
-    matrix: TypstNode[][];
-    constructor(data: TypstNode[][]);
+export declare class TypstMarkupFunc extends TypstNode {
+    fragments: TypstNode[];
+    constructor(head: TypstToken, fragments: TypstNode[]);
     isOverHigh(): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tex2typst",
-  "version": "0.3.24",
+  "version": "0.3.25",
   "description": "JavaScript library for converting TeX code to Typst",
   "type": "module",
   "main": "dist/index.js",

package/src/convert.ts

@@ -2,7 +2,7 @@ import { TexNode, Tex2TypstOptions,
     TexToken, TexTokenType, TexFuncCall, TexGroup, TexSupSub,
     TexText, TexBeginEnd, TexLeftRight,
     TexTerminal} from "./tex-types";
-import { TypstAlign, TypstCases, TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMatrix, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
+import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMarkupFunc, TypstMatrixLike, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
 import { TypstNamedParams } from "./typst-types";
 import { TypstSupsubData } from "./typst-types";
 import { TypstToken } from "./typst-types";
@@ -116,8 +116,8 @@ function tex_token_to_typst(token: TexToken, options: Tex2TypstOptions): TypstTo
 
 // \overset{X}{Y} -> limits(Y)^X
 // and with special case \overset{\text{def}}{=} -> eq.def
-function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
-    const [sup, base] = node.args!;
+function convert_overset(node: TexFuncCall, options: Tex2TypstOptions): TypstNode {
+    const [sup, base] = node.args;
 
     if (options.optimize) {
         // \overset{\text{def}}{=} or \overset{def}{=} are considered as eq.def
@@ -137,8 +137,8 @@ function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
 }
 
 // \underset{X}{Y} -> limits(Y)_X
-function convert_underset(node: TexNode, options: Tex2TypstOptions): TypstNode {
-    const [sub, base] = node.args!;
+function convert_underset(node: TexFuncCall, options: Tex2TypstOptions): TypstNode {
+    const [sub, base] = node.args;
 
     const limits_call = new TypstFuncCall(
         new TypstToken(TypstTokenType.SYMBOL, 'limits'),
@@ -209,22 +209,23 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
         case 'ordgroup':
             const node = abstractNode as TexGroup;
             return new TypstGroup(
-                node.args!.map((n) => convert_tex_node_to_typst(n, options))
+                node.items.map((n) => convert_tex_node_to_typst(n, options))
             );
         case 'supsub': {
             const node = abstractNode as TexSupSub;
             let { base, sup, sub } = node;
 
             // special hook for overbrace
+            // \overbrace{X}^{Y} -> overbrace(X, Y)
             if (base && base.type === 'funcCall' && base.head.value === '\\overbrace' && sup) {
                 return new TypstFuncCall(
                     new TypstToken(TypstTokenType.SYMBOL, 'overbrace'),
-                    [convert_tex_node_to_typst(base.args![0], options), convert_tex_node_to_typst(sup, options)]
+                    [convert_tex_node_to_typst((base as TexFuncCall).args[0], options), convert_tex_node_to_typst(sup, options)]
                 );
             } else if (base && base.type === 'funcCall' && base.head.value === '\\underbrace' && sub) {
                 return new TypstFuncCall(
                     new TypstToken(TypstTokenType.SYMBOL, 'underbrace'),
-                    [convert_tex_node_to_typst(base.args![0], options), convert_tex_node_to_typst(sub, options)]
+                    [convert_tex_node_to_typst((base as TexFuncCall).args[0], options), convert_tex_node_to_typst(sub, options)]
                 );
             }
 
@@ -239,11 +240,8 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
         case 'leftright': {
             const node = abstractNode as TexLeftRight;
             const { left, right } = node;
-            const [_body] = node.args!;
-            // const [typ_left, typ_body, typ_right] = node.args!.map((n) => convert_tex_node_to_typst(n, options));
-            const typ_body = convert_tex_node_to_typst(_body, options);
-
 
+            const typ_body = convert_tex_node_to_typst(node.body, options);
 
             if (options.optimize) {
                 // optimization off: "lr(bar.v.double a + 1/2 bar.v.double)"
@@ -291,13 +289,12 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
 
             return new TypstLeftright(
                 new TypstToken(TypstTokenType.SYMBOL, 'lr'),
-                [typ_body],
-                { left: typ_left, right: typ_right }
+                { body: typ_body, left: typ_left, right: typ_right }
             );
         }
         case 'funcCall': {
             const node = abstractNode as TexFuncCall;
-            const arg0 = convert_tex_node_to_typst(node.args![0], options);
+            const arg0 = convert_tex_node_to_typst(node.args[0], options);
             // \sqrt[3]{x} -> root(3, x)
             if (node.head.value === '\\sqrt' && node.data) {
                 const data = convert_tex_node_to_typst(node.data, options); // the number of times to take the root
@@ -342,6 +339,16 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
                 return new TypstFuncCall(new TypstToken(TypstTokenType.SYMBOL, 'op'), [new TypstToken(TypstTokenType.TEXT, arg0.head.value).toNode()]);
             }
 
+            // \textcolor{red}{2y} -> #text(fill: red)[$2y$]
+            if (node.head.value === '\\textcolor') {
+                const res = new TypstMarkupFunc(
+                    new TypstToken(TypstTokenType.SYMBOL, `#text`),
+                    [convert_tex_node_to_typst(node.args[1], options)]
+                );
+                res.setOptions({ fill: arg0 });
+                return res;
+            }
+
             // \substack{a \\ b} -> `a \ b`
             // as in translation from \sum_{\substack{a \\ b}} to sum_(a \ b)
             if (node.head.value === '\\substack') {
@@ -358,9 +365,10 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
             // \frac{a}{b} -> a / b
             if (node.head.value === '\\frac') {
                 if (options.fracToSlash) {
-                    return new TypstFraction(node.args!.map((n) => convert_tex_node_to_typst(n, options)));
+                    return new TypstFraction(node.args.map((n) => convert_tex_node_to_typst(n, options)));
                 }
             }
+
             if(options.optimize) {
                 // \mathbb{R} -> RR
                 if (node.head.value === '\\mathbb' && /^\\mathbb{[A-Z]}$/.test(node.toString())) {
@@ -375,47 +383,49 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
             // generic case
             return new TypstFuncCall(
                 tex_token_to_typst(node.head, options),
-                node.args!.map((n) => convert_tex_node_to_typst(n, options))
+                node.args.map((n) => convert_tex_node_to_typst(n, options))
             );
         }
         case 'beginend': {
             const node = abstractNode as TexBeginEnd;
-            const data = node.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
+            const matrix = node.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
 
             if (node.head.value.startsWith('align')) {
                 // align, align*, alignat, alignat*, aligned, etc.
-                return new TypstAlign(data);
+                return new TypstMatrixLike(null, matrix);
             }
             if (node.head.value === 'cases') {
-                return new TypstCases(data);
+                return new TypstMatrixLike(TypstMatrixLike.CASES, matrix);
             }
             if (node.head.value === 'subarray') {
-                const align_node = node.args![0];
-                switch (align_node.head.value) {
-                    case 'r':
-                        data.forEach(row => row[0].args!.push(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
-                        break;
-                    case 'l':
-                        data.forEach(row => row[0].args!.unshift(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
-                        break;
-                    default:
-                        break;
+                if (node.data) {
+                    const align_node = node.data;
+                    switch (align_node.head.value) {
+                        case 'r':
+                            matrix.forEach(row => (row[0] as TypstGroup).items.push(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
+                            break;
+                        case 'l':
+                            matrix.forEach(row => (row[0] as TypstGroup).items.unshift(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
+                            break;
+                        default:
+                            break;
+                    }
                 }
-                return new TypstAlign(data);
+                return new TypstMatrixLike(null, matrix);
             }
             if (node.head.value === 'array') {
                 const np: TypstNamedParams = { 'delim': TYPST_NONE };
 
-                assert(node.args!.length > 0 && node.args![0].head.type === TexTokenType.LITERAL);
-                const np_new = convert_tex_array_align_literal(node.args![0].head.value);
+                assert(node.data !== null && node.head.type === TexTokenType.LITERAL);
+                const np_new = convert_tex_array_align_literal(node.data!.head.value);
                 Object.assign(np, np_new);
 
-                const res = new TypstMatrix(data);
+                const res = new TypstMatrixLike(TypstMatrixLike.MAT, matrix);
                 res.setOptions(np);
                 return res;
             }
             if (node.head.value.endsWith('matrix')) {
-                const res = new TypstMatrix(data);
+                const res = new TypstMatrixLike(TypstMatrixLike.MAT, matrix);
                 let delim: TypstToken;
                 switch (node.head.value) {
                     case 'matrix':
@@ -588,24 +598,24 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
 
         case 'group': {
             const node = abstractNode as TypstGroup;
-            const args = node.args!.map(convert_typst_node_to_tex);
+            const args = node.items.map(convert_typst_node_to_tex);
             const alignment_char = new TexToken(TexTokenType.CONTROL, '&').toNode();
             const newline_char = new TexToken(TexTokenType.CONTROL, '\\\\').toNode();
             if (array_includes(args, alignment_char)) {
                 // wrap the whole math formula with \begin{aligned} and \end{aligned}
                 const rows = array_split(args, newline_char);
-                const data: TexNode[][] = [];
+                const matrix: TexNode[][] = [];
                 for(const row of rows) {
                     const cells = array_split(row, alignment_char);
-                    data.push(cells.map(cell => new TexGroup(cell)));
+                    matrix.push(cells.map(cell => new TexGroup(cell)));
                 }
-                return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'aligned'), [], data);
+                return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'aligned'), matrix);
             }
             return new TexGroup(args);
         }
         case 'leftright': {
             const node = abstractNode as TypstLeftright;
-            const args = node.args!.map(convert_typst_node_to_tex);
+            const body = convert_typst_node_to_tex(node.body);
             let left = node.left? typst_token_to_tex(node.left) : new TexToken(TexTokenType.ELEMENT, '.');
             let right = node.right? typst_token_to_tex(node.right) : new TexToken(TexTokenType.ELEMENT, '.');
             // const is_over_high = node.isOverHigh();
@@ -615,11 +625,9 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 left.value = '\\left' + left.value;
                 right.value = '\\right' + right.value;
             }
-            args.unshift(left.toNode());
-            args.push(right.toNode());
             // TODO: should be TeXLeftRight(...)
             // But currently writer will output `\left |` while people commonly prefer `\left|`.
-            return new TexGroup(args);
+            return new TexGroup([left.toNode(), body, right.toNode()]);
         }
         case 'funcCall': {
             const node = abstractNode as TypstFuncCall;
@@ -628,15 +636,16 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // `\| a  \|` <- `norm(a)`
                 // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
                 case 'norm': {
-                    const arg0 = node.args![0];
-                    const args = [ convert_typst_node_to_tex(arg0) ];
+                    const arg0 = node.args[0];
+                    const body = convert_typst_node_to_tex(arg0);
                     if (node.isOverHigh()) {
-                        return new TexLeftRight(args, {
+                        return new TexLeftRight({
+                            body: body,
                             left: new TexToken(TexTokenType.COMMAND, "\\|"),
                             right: new TexToken(TexTokenType.COMMAND, "\\|")
                         });
                     } else {
-                        return new TexGroup(args);
+                        return body;
                     }
                 }
                 // special hook for floor, ceil
@@ -648,29 +657,30 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 case 'ceil': {
                     const left = "\\l" + node.head.value;
                     const right = "\\r" + node.head.value;
-                    const arg0 = node.args![0];
-                    const typ_arg0 = convert_typst_node_to_tex(arg0);
+                    const arg0 = node.args[0];
+                    const body = convert_typst_node_to_tex(arg0);
                     const left_node = new TexToken(TexTokenType.COMMAND, left);
                     const right_node = new TexToken(TexTokenType.COMMAND, right);
                     if (node.isOverHigh()) {
-                        return new TexLeftRight([typ_arg0], {
+                        return new TexLeftRight({
+                            body: body,
                             left: left_node,
                             right: right_node
                         });
                     } else {
-                        return new TexGroup([left_node.toNode(), typ_arg0, right_node.toNode()]);
+                        return new TexGroup([left_node.toNode(), body, right_node.toNode()]);
                     }
                 }
                 // special hook for root
                 case 'root': {
-                    const [degree, radicand] = node.args!;
+                    const [degree, radicand] = node.args;
                     const data = convert_typst_node_to_tex(degree);
                     return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\sqrt'), [convert_typst_node_to_tex(radicand)], data);
                 }
                 // special hook for overbrace and underbrace
                 case 'overbrace':
                 case 'underbrace': {
-                    const [body, label] = node.args!;
+                    const [body, label] = node.args;
                     const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_typst_node_to_tex(body)]);
                     const script = convert_typst_node_to_tex(label);
                     const data = node.head.value === 'overbrace' ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
@@ -679,12 +689,12 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // special hook for vec
                 // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
                 case 'vec': {
-                    const tex_data = node.args!.map(convert_typst_node_to_tex).map((n) => [n]);
-                    return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'pmatrix'), [], tex_data);
+                    const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+                    return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'pmatrix'), tex_matrix);
                 }
                 // special hook for op
                 case 'op': {
-                    const arg0 = node.args![0];
+                    const arg0 = node.args[0];
                     assert(arg0.head.type === TypstTokenType.TEXT);
                     return new TexFuncCall(typst_token_to_tex(node.head), [new TexToken(TexTokenType.LITERAL, arg0.head.value).toNode()]);
                 }
@@ -694,18 +704,36 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     const is_known_func = TEX_UNARY_COMMANDS.includes(func_name_tex.value.substring(1))
                                             || TEX_BINARY_COMMANDS.includes(func_name_tex.value.substring(1));
                     if (func_name_tex.value.length > 0 && is_known_func) {
-                        return new TexFuncCall(func_name_tex, node.args!.map(convert_typst_node_to_tex));
+                        return new TexFuncCall(func_name_tex, node.args.map(convert_typst_node_to_tex));
                     } else {
                         return new TexGroup([
                             typst_token_to_tex(node.head).toNode(),
                             new TexToken(TexTokenType.ELEMENT, '(').toNode(),
-                            ...array_intersperse(node.args!.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+                            ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
                             new TexToken(TexTokenType.ELEMENT, ')').toNode()
                         ]);
                     }
                 }
             }
         }
+        case 'markupFunc': {
+            const node = abstractNode as TypstMarkupFunc;
+            switch (node.head.value) {
+                case '#text': {
+                    // `\textcolor{red}{2y}` <- `#text(fill: red)[$2 y$]`
+                    if (node.options && node.options['fill']) {
+                        const color = node.options['fill'];
+                        return new TexFuncCall(
+                            new TexToken(TexTokenType.COMMAND, '\\textcolor'),
+                            [convert_typst_node_to_tex(color), convert_typst_node_to_tex(node.fragments[0])]
+                        )
+                    }
+                }
+                case '#heading':
+                default:
+                    throw new Error(`Unimplemented markup function: ${node.head.value}`);
+            }
+        }
         case 'supsub': {
             const node = abstractNode as TypstSupsub;
             const { base, sup, sub } = node;
@@ -717,7 +745,8 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
             // `limits(+)_a` -> `\underset{a}{+}`
             // `limits(+)_a^b` -> `\overset{b}{\underset{a}{+}}`
             if (base.head.eq(new TypstToken(TypstTokenType.SYMBOL, 'limits'))) {
-                const body_in_limits = convert_typst_node_to_tex(base.args![0]);
+                const limits = base as TypstFuncCall;
+                const body_in_limits = convert_typst_node_to_tex(limits.args[0]);
                 if (sup_tex !== null && sub_tex === null) {
                     return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\overset'), [sup_tex, body_in_limits]);
                 } else if (sup_tex === null && sub_tex !== null) {
@@ -737,54 +766,55 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
             });
             return res;
         }
-        case 'matrix': {
-            const node = abstractNode as TypstMatrix;
-            const tex_data = node.matrix.map(row => row.map(convert_typst_node_to_tex));
-            let env_type = 'pmatrix'; // typst mat use delim:"(" by default
-            if (node.options) {
-                if ('delim' in node.options) {
-                    const delim = node.options.delim;
-                    switch (delim.head.value) {
-                        case '#none':
-                            env_type = 'matrix';
-                            break;
-                        case '[':
-                        case ']':
-                            env_type = 'bmatrix';
-                            break;
-                        case '(':
-                        case ')':
-                            env_type = 'pmatrix';
-                            break;
-                        case '{':
-                        case '}':
-                            env_type = 'Bmatrix';
-                            break;
-                        case '|':
-                            env_type = 'vmatrix';
-                            break;
-                        case 'bar':
-                        case 'bar.v':
-                            env_type = 'vmatrix';
-                            break;
-                        case 'bar.v.double':
-                            env_type = 'Vmatrix';
-                            break;
-                        default:
-                            throw new Error(`Unexpected delimiter ${delim.head}`);
+        case 'matrixLike': {
+            const node = abstractNode as TypstMatrixLike;
+            const tex_matrix = node.matrix.map(row => row.map(convert_typst_node_to_tex));
+            if (node.head.eq(TypstMatrixLike.MAT)) {
+                let env_type = 'pmatrix'; // typst mat use delim:"(" by default
+                if (node.options) {
+                    if ('delim' in node.options) {
+                        const delim = node.options.delim;
+                        switch (delim.head.value) {
+                            case '#none':
+                                env_type = 'matrix';
+                                break;
+                            case '[':
+                            case ']':
+                                env_type = 'bmatrix';
+                                break;
+                            case '(':
+                            case ')':
+                                env_type = 'pmatrix';
+                                break;
+                            case '{':
+                            case '}':
+                                env_type = 'Bmatrix';
+                                break;
+                            case '|':
+                                env_type = 'vmatrix';
+                                break;
+                            case 'bar':
+                            case 'bar.v':
+                                env_type = 'vmatrix';
+                                break;
+                            case 'bar.v.double':
+                                env_type = 'Vmatrix';
+                                break;
+                            default:
+                                throw new Error(`Unexpected delimiter ${delim.head}`);
+                        }
                     }
                 }
+                return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, env_type), tex_matrix);
+            } else if (node.head.eq(TypstMatrixLike.CASES)) {
+                return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'cases'), tex_matrix);
+            } else {
+                throw new Error(`Unexpected matrix type ${node.head}`);
             }
-            return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, env_type), [], tex_data);
-        }
-        case 'cases': {
-            const node = abstractNode as TypstCases;
-            const tex_data = node.matrix.map(row => row.map(convert_typst_node_to_tex));
-            return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'cases'), [], tex_data);
         }
         case 'fraction': {
             const node = abstractNode as TypstFraction;
-            const [numerator, denominator] = node.args!;
+            const [numerator, denominator] = node.args;
             const num_tex = convert_typst_node_to_tex(numerator);
             const den_tex = convert_typst_node_to_tex(denominator);
             return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\frac'), [num_tex, den_tex]);

package/src/tex-parser.ts

@@ -204,16 +204,14 @@ export class LatexParser {
                 res.sub = sub;
             }
             if (num_prime > 0) {
-                res.sup = new TexGroup([]);
+                const items: TexNode[] = [];
                 for (let i = 0; i < num_prime; i++) {
-                    res.sup.args!.push(new TexToken(TexTokenType.ELEMENT, "'").toNode());
+                    items.push(new TexToken(TexTokenType.ELEMENT, "'").toNode());
                 }
                 if (sup) {
-                    res.sup.args!.push(sup);
-                }
-                if (res.sup.args!.length === 1) {
-                    res.sup = res.sup.args![0];
+                    items.push(sup);
                 }
+                res.sup = items.length === 1 ? items[0] : new TexGroup(items);
             } else if (sup) {
                 res.sup = sup;
             }
@@ -393,10 +391,9 @@ export class LatexParser {
         pos++;
 
         const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
-        const args = [ body ];
         const left = leftDelimiter.value === '.'? null: leftDelimiter;
         const right = rightDelimiter.value === '.'? null: rightDelimiter;
-        const res = new TexLeftRight(args, {left: left, right: right});
+        const res = new TexLeftRight({body: body, left: left, right: right});
         return [res, pos];
     }
 
@@ -411,12 +408,10 @@ export class LatexParser {
         pos += 3;
 
 
-        const args: TexNode[] = [];
+        let data: TexNode | null = null;
         if(['array', 'subarray'].includes(envName)) {
             pos += eat_whitespaces(tokens, pos).length;
-            const [arg, newPos] = this.parseNextArg(tokens, pos);
-            args.push(arg);
-            pos = newPos;
+            [data, pos] = this.parseNextArg(tokens, pos);
         }
 
         pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
@@ -445,7 +440,7 @@ export class LatexParser {
             exprInside.pop();
         }
         const body = this.parseAligned(exprInside);
-        const res = new TexBeginEnd(new TexToken(TexTokenType.LITERAL, envName), args, body);
+        const res = new TexBeginEnd(new TexToken(TexTokenType.LITERAL, envName), body, data);
         return [res, pos];
     }
 
@@ -479,7 +474,7 @@ export class LatexParser {
                 group = new TexGroup([]);
                 row.push(group);
             } else {
-                group.args!.push(res);
+                group.items.push(res);
             }
         }
         return allRows;

package/src/tex-tokenizer.ts

@@ -46,6 +46,7 @@ export const TEX_BINARY_COMMANDS = [
     'tbinom',
     'overset',
     'underset',
+    'textcolor',
 ]
 
 
@@ -58,7 +59,7 @@ function unescape(str: string): string {
 }
 
 const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[]>([
-    // math `\begin{array}{cc}`
+    // match `\begin{array}{cc}`
     [
         String.raw`\\begin{(array|subarry)}{(.+?)}`, (s) => {
             const match = s.reMatchArray()!;
@@ -74,7 +75,7 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
         }
     ],
     [
-        String.raw`\\(text|operatorname|begin|end|hspace|array){(.+?)}`, (s) => {
+        String.raw`\\(text|operatorname|textcolor|begin|end|hspace|array){(.+?)}`, (s) => {
             const match = s.reMatchArray()!;
             return [
                 new TexToken(TexTokenType.COMMAND, '\\' + match[1]),