tex2typst 0.3.28 → 0.4.0

package/src/convert.ts

@@ -1,6 +1,6 @@
 import { TexNode, TexToken, TexTokenType, TexFuncCall, TexGroup, TexSupSub,
     TexText, TexBeginEnd, TexLeftRight, TexTerminal} from "./tex-types";
-import type { Tex2TypstOptions } from "./exposed-types";
+import type { Tex2TypstOptions, Typst2TexOptions } from "./exposed-types";
 import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMarkupFunc, TypstMatrixLike, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
 import { TypstNamedParams } from "./typst-types";
 import { TypstSupsubData } from "./typst-types";
@@ -224,7 +224,7 @@ function appendWithBracketsIfNeeded(node: TypstNode): TypstNode {
     }
 }
 
-export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions = {}): TypstNode {
+export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions): TypstNode {
     switch (abstractNode.type) {
         case 'terminal': {
             const node = abstractNode as TexTerminal;
@@ -637,7 +637,9 @@ function typst_token_to_tex(token: TypstToken): TexToken {
 
 const TEX_NODE_COMMA = new TexToken(TexTokenType.ELEMENT, ',').toNode();
 
-export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
+export function convert_typst_node_to_tex(abstractNode: TypstNode, options: Typst2TexOptions): TexNode {
+    const convert_node = (node: TypstNode) => convert_typst_node_to_tex(node, options);
+
     switch (abstractNode.type) {
         case 'terminal': {
             const node = abstractNode as TypstTerminal;
@@ -676,7 +678,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
 
         case 'group': {
             const node = abstractNode as TypstGroup;
-            const args = node.items.map(convert_typst_node_to_tex);
+            const args = node.items.map(convert_node);
             const alignment_char = new TexToken(TexTokenType.CONTROL, '&').toNode();
             const newline_char = new TexToken(TexTokenType.CONTROL, '\\\\').toNode();
             if (array_includes(args, alignment_char)) {
@@ -693,7 +695,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         }
         case 'leftright': {
             const node = abstractNode as TypstLeftright;
-            const body = convert_typst_node_to_tex(node.body);
+            const body = convert_node(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();
@@ -715,7 +717,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
                 case 'norm': {
                     const arg0 = node.args[0];
-                    const body = convert_typst_node_to_tex(arg0);
+                    const body = convert_node(arg0);
                     if (node.isOverHigh()) {
                         return new TexLeftRight({
                             body: body,
@@ -736,7 +738,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     const left = "\\l" + node.head.value;
                     const right = "\\r" + node.head.value;
                     const arg0 = node.args[0];
-                    const body = convert_typst_node_to_tex(arg0);
+                    const body = convert_node(arg0);
                     const left_node = new TexToken(TexTokenType.COMMAND, left);
                     const right_node = new TexToken(TexTokenType.COMMAND, right);
                     if (node.isOverHigh()) {
@@ -752,22 +754,22 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // special hook for root
                 case 'root': {
                     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);
+                    const data = convert_node(degree);
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\sqrt'), [convert_node(radicand)], data);
                 }
                 // special hook for overbrace and underbrace
                 case 'overbrace':
                 case 'underbrace': {
                     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 base = new TexFuncCall(typst_token_to_tex(node.head), [convert_node(body)]);
+                    const script = convert_node(label);
                     const data = node.head.value === 'overbrace' ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
                     return new TexSupSub(data);
                 }
                 // special hook for vec
                 // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
                 case 'vec': {
-                    const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+                    const tex_matrix = node.args.map(arg => [convert_node(arg)]);
                     return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'pmatrix'), tex_matrix);
                 }
                 // special hook for op
@@ -798,21 +800,47 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     }
                     return new TexFuncCall(
                         new TexToken(TexTokenType.COMMAND, command),
-                        [convert_typst_node_to_tex(node.args[1])]
+                        [convert_node(node.args[1])]
                     );
                 }
+                // display(...) -> \displaystyle ... \textstyle
+                // The postprocessor will remove \textstyle if it is the end of the math code
+                case 'display': {
+                    const arg0 = node.args[0];
+                    const group = new TexGroup([
+                        TexToken.COMMAND_DISPLAYSTYLE.toNode(),
+                        convert_node(arg0),
+                    ]);
+                    if (!options.blockMathMode) {
+                        group.items.push(TexToken.COMMAND_TEXTSTYLE.toNode());
+                    }
+                    return group;
+                }
+                // inline(...) -> \textstyle ... \displaystyle
+                // The postprocessor will remove \displaystyle if it is the end of the math code
+                case 'inline': {
+                    const arg0 = node.args[0];
+                    const group = new TexGroup([
+                        TexToken.COMMAND_TEXTSTYLE.toNode(),
+                        convert_node(arg0),
+                    ]);
+                    if (options.blockMathMode) {
+                        group.items.push(TexToken.COMMAND_DISPLAYSTYLE.toNode());
+                    }
+                    return group;
+                }
                 // general case
                 default: {
                     const func_name_tex = typst_token_to_tex(node.head);
                     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_node));
                     } 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_node), TEX_NODE_COMMA),
                             new TexToken(TexTokenType.ELEMENT, ')').toNode()
                         ]);
                     }
@@ -828,7 +856,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                         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])]
+                            [convert_node(color), convert_node(node.fragments[0])]
                         )
                     }
                 }
@@ -840,8 +868,8 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         case 'supsub': {
             const node = abstractNode as TypstSupsub;
             const { base, sup, sub } = node;
-            const sup_tex = sup? convert_typst_node_to_tex(sup) : null;
-            const sub_tex = sub? convert_typst_node_to_tex(sub) : null;
+            const sup_tex = sup? convert_node(sup) : null;
+            const sub_tex = sub? convert_node(sub) : null;
 
             // special hook for limits
             // `limits(+)^a` -> `\overset{a}{+}`
@@ -849,7 +877,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
             // `limits(+)_a^b` -> `\overset{b}{\underset{a}{+}}`
             if (base.head.eq(new TypstToken(TypstTokenType.SYMBOL, 'limits'))) {
                 const limits = base as TypstFuncCall;
-                const body_in_limits = convert_typst_node_to_tex(limits.args[0]);
+                const body_in_limits = convert_node(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) {
@@ -860,7 +888,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 }
             }
 
-            const base_tex = convert_typst_node_to_tex(base);
+            const base_tex = convert_node(base);
 
             const res = new TexSupSub({
                 base: base_tex,
@@ -871,7 +899,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         }
         case 'matrixLike': {
             const node = abstractNode as TypstMatrixLike;
-            const tex_matrix = node.matrix.map(row => row.map(convert_typst_node_to_tex));
+            const tex_matrix = node.matrix.map(row => row.map(convert_node));
             if (node.head.eq(TypstMatrixLike.MAT)) {
                 let env_type = 'pmatrix'; // typst mat use delim:"(" by default
                 if (node.options) {
@@ -918,8 +946,8 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         case 'fraction': {
             const node = abstractNode as TypstFraction;
             const [numerator, denominator] = node.args;
-            const num_tex = convert_typst_node_to_tex(numerator);
-            const den_tex = convert_typst_node_to_tex(denominator);
+            const num_tex = convert_node(numerator);
+            const den_tex = convert_node(denominator);
             return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\frac'), [num_tex, den_tex]);
         }
         default:

package/src/exposed-types.ts

@@ -6,17 +6,21 @@
  * Any undocumented options may be not working at present or break in the future!
  */
 export interface Tex2TypstOptions {
-    nonStrict?: boolean; /** default is true */
-    preferShorthands?: boolean; /** default is true */
-    keepSpaces?: boolean; /** default is false */
-    fracToSlash?: boolean; /** default is true */
-    inftyToOo?: boolean; /** default is false */
-    optimize?: boolean; /** default is true */
-    customTexMacros?: { [key: string]: string; };
+    nonStrict: boolean; /** default is true */
+    preferShorthands: boolean; /** default is true */
+    keepSpaces: boolean; /** default is false */
+    fracToSlash: boolean; /** default is true */
+    inftyToOo: boolean; /** default is false */
+    optimize: boolean; /** default is true */
+    customTexMacros: { [key: string]: string; };
 }
 
-export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
-export declare function typst2tex(typst: string): string;
+export interface Typst2TexOptions {
+    blockMathMode: boolean; /** default is true */
+}
+
+export declare function tex2typst(tex: string, options?: Partial<Tex2TypstOptions>): string;
+export declare function typst2tex(typst: string, options?: Partial<Typst2TexOptions>): string;
 
 export declare const symbolMap: Map<string, string>;
 export declare const shorthandMap: Map<string, string>;

package/src/index.ts

@@ -1,5 +1,5 @@
 import { parseTex } from "./tex-parser";
-import type { Tex2TypstOptions } from "./exposed-types";
+import type { Tex2TypstOptions, Typst2TexOptions } from "./exposed-types";
 import { TypstWriter } from "./typst-writer";
 import { type TypstWriterOptions } from "./typst-types";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
@@ -9,7 +9,7 @@ import { TexWriter } from "./tex-writer";
 import { shorthandMap } from "./typst-shorthands";
 
 
-export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
+export function tex2typst(tex: string, options: Partial<Tex2TypstOptions> = {}): string {
     const opt: Tex2TypstOptions = {
         nonStrict: true,
         preferShorthands: true,
@@ -20,14 +20,12 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
         customTexMacros: {}
     };
 
-    if(options !== undefined) {
-        if (typeof options !== 'object') {
-            throw new Error("options must be an object");
-        }
-        for (const key in opt) {
-            if (key in options) {
-                opt[key as keyof Tex2TypstOptions] = options[key as keyof Tex2TypstOptions] as any;
-            }
+    if (typeof options !== 'object') {
+        throw new Error("options must be an object");
+    }
+    for (const key in opt) {
+        if (key in options) {
+            opt[key as keyof Tex2TypstOptions] = options[key as keyof Tex2TypstOptions] as any;
         }
     }
 
@@ -38,9 +36,22 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     return writer.finalize();
 }
 
-export function typst2tex(typst: string): string {
+export function typst2tex(typst: string, options: Partial<Typst2TexOptions> = {}): string {
+    const opt: Typst2TexOptions = {
+        blockMathMode: true,
+    };
+
+    if (typeof options !== 'object') {
+        throw new Error("options must be an object");
+    }
+    for (const key in opt) {
+        if (key in options) {
+            opt[key as keyof Typst2TexOptions] = options[key as keyof Typst2TexOptions] as any;
+        }
+    }
+
     const typstTree = parseTypst(typst);
-    const texTree = convert_typst_node_to_tex(typstTree);
+    const texTree = convert_typst_node_to_tex(typstTree, opt);
     const writer = new TexWriter();
     writer.append(texTree);
     return writer.finalize();

package/src/map.ts

@@ -1,5 +1,6 @@
 const symbolMap = new Map<string, string>([
     ['displaystyle', 'display'],
+    ['textstyle', 'inline'],
     ['hspace', '#h'],
 
     ['|', 'bar.v.double'],

package/src/tex-types.ts

@@ -44,6 +44,8 @@ export class TexToken {
     }
 
     public static readonly EMPTY = new TexToken(TexTokenType.EMPTY, '');
+    public static readonly COMMAND_DISPLAYSTYLE = new TexToken(TexTokenType.COMMAND, '\\displaystyle');
+    public static readonly COMMAND_TEXTSTYLE = new TexToken(TexTokenType.COMMAND, '\\textstyle');
 }
 
 

package/src/tex-writer.ts

@@ -1,4 +1,4 @@
-import { TexNode, TexToken, writeTexTokenBuffer } from "./tex-types";
+import { TexNode, TexToken, TexTokenType, writeTexTokenBuffer } from "./tex-types";
 
 
 
@@ -12,6 +12,15 @@ export class TexWriter {
     }
 
     protected flushQueue() {
+        // remove \textstyle or \displaystyle if it is the end of the math code
+        while (this.queue.length > 0) {
+            const last_token = this.queue[this.queue.length - 1];
+            if (last_token.eq(TexToken.COMMAND_DISPLAYSTYLE) || last_token.eq(TexToken.COMMAND_TEXTSTYLE)) {
+                this.queue.pop();
+            } else {
+                break;
+            }
+        }
         for (let i = 0; i < this.queue.length; i++) {
             this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
         }

package/src/typst-types.ts

@@ -58,6 +58,8 @@ export class TypstToken {
         new TypstToken(TypstTokenType.ELEMENT, '{'),
         new TypstToken(TypstTokenType.ELEMENT, '|'),
         new TypstToken(TypstTokenType.SYMBOL, 'angle.l'),
+        new TypstToken(TypstTokenType.SYMBOL, 'paren.l'),
+        new TypstToken(TypstTokenType.SYMBOL, 'brace.l'),
     ];
 
     public static readonly RIGHT_DELIMITERS = [
@@ -66,6 +68,8 @@ export class TypstToken {
         new TypstToken(TypstTokenType.ELEMENT, '}'),
         new TypstToken(TypstTokenType.ELEMENT, '|'),
         new TypstToken(TypstTokenType.SYMBOL, 'angle.r'),
+        new TypstToken(TypstTokenType.SYMBOL, 'paren.r'),
+        new TypstToken(TypstTokenType.SYMBOL, 'brace.r'),
     ];
 }
 

package/tests/struct-bidirection.yaml

@@ -156,6 +156,12 @@ cases:
   - title: left right angles
     tex: \left\langle \frac{1}{2} \right\rangle
     typst: lr(angle.l 1/2 angle.r)
+  - title: lparen rparen
+    tex: \left\lparen \frac{1}{3} \right\rparen
+    typst: lr(paren.l 1/3 paren.r)
+  - title: lbrace rbrace
+    tex: \left\lbrace \frac{1}{3} \right\rbrace
+    typst: lr(brace.l 1/3 brace.r)
   - title: fractions as function argument
     tex: g(\frac{1}{2})
     typst: g(1/2)
@@ -185,4 +191,13 @@ cases:
     typst: a class("binary", X) b
   - title: mathop
     tex: a \mathop{X} b
-    typst: a class("large", X) b
+    typst: a class("large", X) b
+  - title: display style
+    tex: a = \displaystyle \sum_i x_i
+    typst: a = display(sum_i x_i)
+  - title: display style, case 3
+    tex: \displaystyle \lim_x F(x) = 0, \lim_x F(x) = 1
+    typst: display(lim_x F(x) = 0 comma lim_x F(x) = 1)
+  - title: display style, case 4
+    tex:  \lim_x F(x) = 0, \displaystyle \lim_x F(x) = 1
+    typst: lim_x F(x) = 0, display(lim_x F(x) = 1)

package/tests/struct-tex2typst.yaml

@@ -56,12 +56,6 @@ cases:
   - title: paired delimiter commands
     tex: \left(\bigl[\biggl\{a\biggr\}\bigr]\right)
     typst: '([ {a}])'
-  - title: lparen rparen
-    tex: \left\lparen \frac{1}{3} \right\rparen
-    typst: lr(paren.l 1/3 paren.r)
-  - title: lbrace rbrace
-    tex: \left\lbrace \frac{1}{3} \right\rbrace
-    typst: lr(brace.l 1/3 brace.r)
   - title: operatorname
     tex: '\operatorname{diag} \text{diag}'
     typst: 'op("diag") "diag"'
@@ -412,12 +406,6 @@ cases:
   - title: Backslash space
     tex: a \ b
     typst: a med b
-  - title: display style
-    tex: \displaystyle \lim_{x \to -\infty} F(x) = 0, \lim_{x \to +\infty} F(x) = 1
-    typst: display(lim_(x -> - infinity) F(x) = 0 comma lim_(x -> + infinity) F(x) = 1)
-  - title: display style 2
-    tex:  \lim_{x \to -\infty} F(x) = 0, \displaystyle \lim_{x \to +\infty} F(x) = 1
-    typst: lim_(x -> - infinity) F(x) = 0, display(lim_(x -> + infinity) F(x) = 1)
   # this test the typst formatter. Old bad implementation translated it to "C(x y)/z"
   - title: parenthesis in fraction
     tex: C \frac{xy}{z}

package/tests/tex-to-typst.test.ts

@@ -103,7 +103,7 @@ caseFiles.forEach((ymlFilename) => {
         let tex_node: null | TexNode = null;
         let result: null | string = null;
         try {
-          const settings: Tex2TypstOptions = {
+          const settings: Partial<Tex2TypstOptions> = {
             nonStrict: c.nonStrict? c.nonStrict: false,
             preferShorthands: c.preferShorthands !== undefined? c.preferShorthands: true,
             inftyToOo: c.inftyToOo !== undefined? c.inftyToOo: false,

package/tests/typst-to-tex.test.ts

@@ -1,48 +1,72 @@
 
-import { describe, it, test, expect } from 'vitest';
+import { describe, test, expect } from 'vitest';
 import { parseTypst } from '../src/typst-parser';
 import { TexWriter } from '../src/tex-writer';
 import { convert_typst_node_to_tex } from '../src/convert';
 import { loadTestCases, TestCase  } from './test-common';
+import { Typst2TexOptions } from '../src/exposed-types';
+import { typst2tex } from '../src';
 
-
+const options: Typst2TexOptions = {
+    blockMathMode: true,
+};
 
 describe('examples', () => {
-    it('a + b', function () {
+    test('a + b', function () {
         const typst_node = parseTypst('a + b');
-        const tex_node = convert_typst_node_to_tex(typst_node);
+        const tex_node = convert_typst_node_to_tex(typst_node, options);
         const writer = new TexWriter();
         writer.append(tex_node);
         const res = writer.finalize();
         expect(res).toEqual('a + b');
     });
 
-    it('sqrt(x)', function () {
+    test('sqrt(x)', function () {
         const typst_node = parseTypst('sqrt(x)');
-        const tex_node = convert_typst_node_to_tex(typst_node);
+        const tex_node = convert_typst_node_to_tex(typst_node, options);
         const writer = new TexWriter();
         writer.append(tex_node);
         const res = writer.finalize();
         expect(res).toEqual('\\sqrt{x}');
     });
 
-    it('integral_a^b f(x) dif x', function () {
+    test('integral_a^b f(x) dif x', function () {
         const typst_node = parseTypst('integral_a^b f(x) dif x');
-        const tex_node = convert_typst_node_to_tex(typst_node);
+        const tex_node = convert_typst_node_to_tex(typst_node, options);
         const writer = new TexWriter();
         writer.append(tex_node);
         const res = writer.finalize();
         expect(res).toEqual('\\int_a^b f(x) \\mathrm{d} x');
     });
 
-    it('lr({a + 1/3))', function () {
+    test('lr({a + 1/3))', function () {
         const typst_node = parseTypst('lr({a + 1/3))');
-        const tex_node = convert_typst_node_to_tex(typst_node);
+        const tex_node = convert_typst_node_to_tex(typst_node, options);
         const writer = new TexWriter();
         writer.append(tex_node);
         const res = writer.finalize();
         expect(res).toEqual('\\left\\{a + \\frac{1}{3} \\right)');
     });
+
+    test('blockMathMode = false', function () {
+        const typst_code_1 = "a = display(sum_i x_i) b";
+        const res1 = typst2tex(typst_code_1, { blockMathMode: false });
+        expect(res1).toEqual(String.raw`a = \displaystyle \sum_i x_i \textstyle b`);
+
+        const typst_code_2 = "a = inline(sum_i x_i) b";
+        const res2 = typst2tex(typst_code_2, { blockMathMode: false });
+        expect(res2).toEqual(String.raw`a = \textstyle \sum_i x_i b`);
+    });
+
+    test('blockMathMode = true', function () {
+        const typst_code_1 = "a = inline(sum_i x_i) b";
+        const res1 = typst2tex(typst_code_1, { blockMathMode: true });
+        expect(res1).toEqual(String.raw`a = \textstyle \sum_i x_i \displaystyle b`);
+
+        const typst_code_2 = "a = display(sum_i x_i) b";
+        const res2 = typst2tex(typst_code_2, { blockMathMode: true });
+        expect(res2).toEqual(String.raw`a = \displaystyle \sum_i x_i b`);
+    });
 });
 
 
@@ -52,7 +76,7 @@ describe('struct-typst2tex.yaml', function () {
     suite.cases.forEach((c: TestCase) => {
         test(c.title, function () {
             const typst_node = parseTypst(c.typst);
-            const tex_node = convert_typst_node_to_tex(typst_node);
+            const tex_node = convert_typst_node_to_tex(typst_node, options);
             const writer = new TexWriter();
             writer.append(tex_node);
             const res = writer.finalize();
@@ -66,7 +90,7 @@ describe('struct-bidirection.yaml', function () {
     suite.cases.forEach((c: TestCase) => {
         test(c.title, function () {
             const typst_node = parseTypst(c.typst);
-            const tex_node = convert_typst_node_to_tex(typst_node);
+            const tex_node = convert_typst_node_to_tex(typst_node, options);
             const writer = new TexWriter();
             writer.append(tex_node);
             const res = writer.finalize();