tex2typst 0.3.23 → 0.3.24

package/src/convert.ts

@@ -1,11 +1,30 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TypstLrData, TexArrayData, TypstNamedParams } from "./types";
-import { TypstWriterError } from "./typst-writer";
+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 { TypstNamedParams } from "./typst-types";
+import { TypstSupsubData } from "./typst-types";
+import { TypstToken } from "./typst-types";
+import { TypstTokenType } from "./typst-types";
 import { symbolMap, reverseSymbolMap } from "./map";
-import { array_intersperse } from "./generic";
+import { array_includes, array_intersperse, array_split } from "./generic";
 import { assert } from "./util";
 import { TEX_BINARY_COMMANDS, TEX_UNARY_COMMANDS } from "./tex-tokenizer";
 
 
+export class ConverterError extends Error {
+    node: TexNode | TypstNode | TexToken | TypstToken | null;
+
+    constructor(message: string, node: TexNode | TypstNode | TexToken | TypstToken | null = null) {
+        super(message);
+        this.name = "ConverterError";
+        this.node = node;
+    }
+}
+
+const TYPST_NONE = TypstToken.NONE.toNode();
+
 // native textual operators in Typst
 const TYPST_INTRINSIC_OP = [
     'dim',
@@ -18,13 +37,13 @@ const TYPST_INTRINSIC_OP = [
     // 'sgn
 ];
 
-function tex_token_to_typst(token: string): string {
+function _tex_token_str_to_typst(token: string): string | null {
     if (/^[a-zA-Z0-9]$/.test(token)) {
         return token;
     } else if (token === '/') {
         return '\\/';
-    } else if (token === '\\\\') {
-        return '\\';
+    } else if (['\\\\', '\\{', '\\}', '\\%'].includes(token)) {
+        return token.substring(1);
     } else if (['\\$', '\\#', '\\&', '\\_'].includes(token)) {
         return token;
     } else if (token.startsWith('\\')) {
@@ -35,12 +54,65 @@ function tex_token_to_typst(token: string): string {
             // Fall back to the original macro.
             // This works for \alpha, \beta, \gamma, etc.
             // If this.nonStrict is true, this also works for all unknown macros.
-            return symbol;
+            return null;
         }
     }
     return token;
 }
 
+function tex_token_to_typst(token: TexToken, options: Tex2TypstOptions): TypstToken {
+    let token_type: TypstTokenType;
+    switch (token.type) {
+        case TexTokenType.EMPTY:
+            return TypstToken.NONE;
+        case TexTokenType.COMMAND:
+            token_type = TypstTokenType.SYMBOL;
+            break;
+        case TexTokenType.ELEMENT:
+            token_type = TypstTokenType.ELEMENT;
+            break;
+        case TexTokenType.LITERAL:
+            // This happens, for example, node={type: 'literal', content: 'myop'} as in `\operatorname{myop}`
+            token_type = TypstTokenType.LITERAL;
+            break;
+        case TexTokenType.COMMENT:
+            token_type = TypstTokenType.COMMENT;
+            break;
+        case TexTokenType.SPACE:
+            token_type = TypstTokenType.SPACE;
+            break;
+        case TexTokenType.NEWLINE:
+            token_type = TypstTokenType.NEWLINE;
+            break;
+        case TexTokenType.CONTROL: {
+            if (token.value === '\\\\') {
+                // \\ -> \
+                return new TypstToken(TypstTokenType.CONTROL, '\\');
+            } else if (token.value === '\\!') {
+                // \! -> #h(-math.thin.amount)
+                return new TypstToken(TypstTokenType.SYMBOL, '#h(-math.thin.amount)');
+            } else if (symbolMap.has(token.value.substring(1))) {
+                // node.content is one of \, \: \;
+                const typst_symbol = symbolMap.get(token.value.substring(1))!;
+                return new TypstToken(TypstTokenType.SYMBOL, typst_symbol);
+            } else {
+                throw new Error(`Unknown control sequence: ${token.value}`);
+            }
+        }
+        default:
+            throw Error(`Unknown token type: ${token.type}`);
+    }
+
+    const typst_str = _tex_token_str_to_typst(token.value);
+    if (typst_str === null) {
+        if (options.nonStrict) {
+            return new TypstToken(token_type, token.value.substring(1));
+        } else {
+            throw new ConverterError(`Unknown token: ${token.value}`, token);
+        }
+    }
+    return new TypstToken(token_type, typst_str);
+}
 
 // \overset{X}{Y} -> limits(Y)^X
 // and with special case \overset{\text{def}}{=} -> eq.def
@@ -48,35 +120,19 @@ function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
     const [sup, base] = node.args!;
 
     if (options.optimize) {
-        const is_def = (n: TexNode): boolean => {
-            if (n.eq(new TexNode('text', 'def'))) {
-                return true;
-            }
-            // \overset{def}{=} is also considered as eq.def
-            if (n.type === 'ordgroup' && n.args!.length === 3) {
-                const [a1, a2, a3] = n.args!;
-                const d = new TexNode('element', 'd');
-                const e = new TexNode('element', 'e');
-                const f = new TexNode('element', 'f');
-                if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        const is_eq = (n: TexNode): boolean => n.eq(new TexNode('element', '='));
-        if (is_def(sup) && is_eq(base)) {
-            return new TypstNode('symbol', 'eq.def');
+        // \overset{\text{def}}{=} or \overset{def}{=} are considered as eq.def
+        if (["\\overset{\\text{def}}{=}", "\\overset{d e f}{=}"].includes(node.toString())) {
+            return new TypstToken(TypstTokenType.SYMBOL, 'eq.def').toNode();
         }
     }
-    const limits_call = new TypstNode(
-        'funcCall',
-        'limits',
+    const limits_call = new TypstFuncCall(
+        new TypstToken(TypstTokenType.SYMBOL, 'limits'),
         [convert_tex_node_to_typst(base, options)]
     );
-    return new TypstNode('supsub', '', [], {
+    return new TypstSupsub({
             base: limits_call,
             sup: convert_tex_node_to_typst(sup, options),
+            sub: null,
     });
 }
 
@@ -84,14 +140,14 @@ function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
 function convert_underset(node: TexNode, options: Tex2TypstOptions): TypstNode {
     const [sub, base] = node.args!;
 
-    const limits_call = new TypstNode(
-        'funcCall',
-        'limits',
+    const limits_call = new TypstFuncCall(
+        new TypstToken(TypstTokenType.SYMBOL, 'limits'),
         [convert_tex_node_to_typst(base, options)]
     );
-    return new TypstNode('supsub', '', [], {
+    return new TypstSupsub({
             base: limits_call,
             sub: convert_tex_node_to_typst(sub, options),
+            sup: null,
     });
 }
 
@@ -118,323 +174,280 @@ function convert_tex_array_align_literal(alignLiteral: string): TypstNamedParams
             augment_str = `#(vline: (${vlinePositions.join(', ')}))`;
         }
 
-        np['augment'] = new TypstNode('literal', augment_str);
+        np['augment'] = new TypstToken(TypstTokenType.LITERAL, augment_str).toNode();
     }
 
     const alignments = chars
         .map(c => alignMap[c])
         .filter((x) => x !== undefined)
-        .map(s => new TypstNode('literal', s!));
+        .map(s => new TypstToken(TypstTokenType.LITERAL, s!).toNode());
 
     if (alignments.length > 0) {
         const all_same = alignments.every(item => item.eq(alignments[0]));
-        np['align'] = all_same ? alignments[0] : new TypstNode('literal', '#center');
+        np['align'] = all_same ? alignments[0] : new TypstToken(TypstTokenType.LITERAL, '#center').toNode();
     }
     return np;
 }
 
 
-export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptions = {}): TypstNode {
-    switch (node.type) {
-        case 'empty':
-            return TYPST_NONE;
-        case 'whitespace':
-            return new TypstNode('whitespace', node.content);
-        case 'ordgroup':
-            return new TypstNode(
-                'group',
-                '',
-                node.args!.map((n) => convert_tex_node_to_typst(n, options))
-            );
-        case 'element':
-            return new TypstNode('atom', tex_token_to_typst(node.content));
-        case 'symbol':
-            return new TypstNode('symbol', tex_token_to_typst(node.content));
+export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions = {}): TypstNode {
+    switch (abstractNode.type) {
+        case 'terminal': {
+            const node = abstractNode as TexTerminal;
+            return tex_token_to_typst(node.head, options).toNode();
+        }
         case 'text': {
-            if ((/[^\x00-\x7F]+/).test(node.content) && options.nonAsciiWrapper !== "") {
-                return new TypstNode(
-                    'funcCall',
-                    options.nonAsciiWrapper!,
-                    [new TypstNode('text', node.content)]
+            const node = abstractNode as TexText;
+            if ((/[^\x00-\x7F]+/).test(node.head.value) && options.nonAsciiWrapper !== "") {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, options.nonAsciiWrapper!),
+                    [new TypstToken(TypstTokenType.TEXT, node.head.value).toNode()]
                 );
             }
-            return new TypstNode('text', node.content);
+            return new TypstToken(TypstTokenType.TEXT, node.head.value).toNode();
         }
-        case 'literal':
-            // This happens, for example, node={type: 'literal', content: 'myop'} as in `\operatorname{myop}`
-            return new TypstNode('literal', node.content);
-        case 'comment':
-            return new TypstNode('comment', node.content);
+        case 'ordgroup':
+            const node = abstractNode as TexGroup;
+            return new TypstGroup(
+                node.args!.map((n) => convert_tex_node_to_typst(n, options))
+            );
         case 'supsub': {
-            let { base, sup, sub } = node.data as TexSupsubData;
+            const node = abstractNode as TexSupSub;
+            let { base, sup, sub } = node;
 
             // special hook for overbrace
-            if (base && base.type === 'unaryFunc' && base.content === '\\overbrace' && sup) {
-                return new TypstNode(
-                    'funcCall',
-                    'overbrace',
+            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)]
                 );
-            } else if (base && base.type === 'unaryFunc' && base.content === '\\underbrace' && sub) {
-                return new TypstNode(
-                    'funcCall',
-                    'underbrace',
+            } 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)]
                 );
             }
 
             const data: TypstSupsubData = {
                 base: convert_tex_node_to_typst(base, options),
+                sup: sup? convert_tex_node_to_typst(sup, options) : null,
+                sub: sub? convert_tex_node_to_typst(sub, options) : null,
             };
-            if (data.base.type === 'none') {
-                data.base = new TypstNode('none', '');
-            }
-
-            if (sup) {
-                data.sup = convert_tex_node_to_typst(sup, options);
-            }
 
-            if (sub) {
-                data.sub = convert_tex_node_to_typst(sub, options);
-            }
-
-            return new TypstNode('supsub', '', [], data);
+            return new TypstSupsub(data);
         }
         case 'leftright': {
-            const [left, _body, right] = node.args!;
-            const [typ_left, typ_body, typ_right] = node.args!.map((n) => convert_tex_node_to_typst(n, options));
+            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);
+
+
 
             if (options.optimize) {
                 // optimization off: "lr(bar.v.double a + 1/2 bar.v.double)"
                 // optimization on : "norm(a + 1/2)"
-                if (left.content === '\\|' && right.content === '\\|') {
-                    return new TypstNode('funcCall', 'norm', [typ_body]);
-                }
+                if (left !== null && right !== null) {
+                    const typ_left = tex_token_to_typst(left, options);
+                    const typ_right = tex_token_to_typst(right, options);
+                    if (left.value === '\\|' && right.value === '\\|') {
+                        return new TypstFuncCall(new TypstToken(TypstTokenType.SYMBOL, 'norm'), [typ_body]);
+                    }
 
-                // These pairs will be handled by Typst compiler by default. No need to add lr()
-                if ([
-                    "[]", "()", "\\{\\}",
-                    "\\lfloor\\rfloor",
-                    "\\lceil\\rceil",
-                    "\\lfloor\\rceil",
-                ].includes(left.content + right.content)) {
-                    return new TypstNode('group', '', [typ_left, typ_body, typ_right]);
+                    // These pairs will be handled by Typst compiler by default. No need to add lr()
+                    if ([
+                        "[]", "()", "\\{\\}",
+                        "\\lfloor\\rfloor",
+                        "\\lceil\\rceil",
+                        "\\lfloor\\rceil",
+                    ].includes(left.value + right.value)) {
+                        return new TypstGroup([typ_left.toNode(), typ_body, typ_right.toNode()]);
+                    }
                 }
             }
 
-            const group = new TypstNode(
-                'group',
-                '',
-                [typ_left, typ_body, typ_right]
-            );
-
             // "\left\{ a + \frac{1}{3} \right." -> "lr(\{ a + 1/3)"
-            // "\left. a + \frac{1}{3} \right\}" -> "lr( a + \frac{1}{3} \})"
+            // "\left. a + \frac{1}{3} \right\}" -> "lr( a + 1/3 \})"
             // Note that: In lr(), if one side of delimiter doesn't present (i.e. derived from "\\left." or "\\right."),
             // "(", ")", "{", "[", should be escaped with "\" to be the other side of delimiter.
             // Simple "lr({ a+1/3)" doesn't compile in Typst.
-            const escape_curly_or_paren = function(s: string): string {
-                if (["(", ")", "{", "["].includes(s)) {
-                    return "\\" + s;
+            const escape_curly_or_paren = function(s: TypstToken): TypstToken {
+                if (["(", ")", "{", "["].includes(s.value)) {
+                    return new TypstToken(TypstTokenType.ELEMENT, "\\" + s.value);
                 } else {
                     return s;
                 }
             };
-            if (right.content === '.') {
-                typ_left.content = escape_curly_or_paren(typ_left.content);
-                group.args = [typ_left, typ_body];
-            } else if (left.content === '.') {
-                typ_right.content = escape_curly_or_paren(typ_right.content);
-                group.args = [typ_body, typ_right];
-            }
-            return new TypstNode('funcCall', 'lr', [group]);
-        }
-        case 'binaryFunc': {
-            if (node.content === '\\overset') {
-                return convert_overset(node, options);
-            }
-            if (node.content === '\\underset') {
-                return convert_underset(node, options);
+
+            let typ_left = left? tex_token_to_typst(left, options) : null;
+            let typ_right = right? tex_token_to_typst(right, options) : null;
+            if (typ_left === null && typ_right !== null) { // left.
+                typ_right = escape_curly_or_paren(typ_right);
             }
-            // \frac{a}{b} -> a / b
-            if (node.content === '\\frac') {
-                if (options.fracToSlash) {
-                    return new TypstNode(
-                        'fraction',
-                        '',
-                        node.args!.map((n) => convert_tex_node_to_typst(n, options))
-                    );
-                }
+            if (typ_right === null && typ_left !== null) { // right.
+                typ_left = escape_curly_or_paren(typ_left);
             }
-            return new TypstNode(
-                'funcCall',
-                tex_token_to_typst(node.content),
-                node.args!.map((n) => convert_tex_node_to_typst(n, options))
+
+            return new TypstLeftright(
+                new TypstToken(TypstTokenType.SYMBOL, 'lr'),
+                [typ_body],
+                { left: typ_left, right: typ_right }
             );
         }
-        case 'unaryFunc': {
+        case 'funcCall': {
+            const node = abstractNode as TexFuncCall;
             const arg0 = convert_tex_node_to_typst(node.args![0], options);
-            // \sqrt{3}{x} -> root(3, x)
-            if (node.content === '\\sqrt' && node.data) {
-                const data = convert_tex_node_to_typst(node.data as TexSqrtData, options); // the number of times to take the root
-                return new TypstNode(
-                    'funcCall',
-                    'root',
+            // \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
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'root'),
                     [data, arg0]
                 );
             }
             // \mathbf{a} -> upright(bold(a))
-            if (node.content === '\\mathbf') {
-                const inner: TypstNode = new TypstNode(
-                    'funcCall',
-                    'bold',
+            if (node.head.value === '\\mathbf') {
+                const inner: TypstNode = new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'bold'),
                     [arg0]
                 );
-                return new TypstNode(
-                    'funcCall',
-                    'upright',
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'upright'),
                     [inner]
                 );
             }
             // \overrightarrow{AB} -> arrow(A B)
-            if (node.content === '\\overrightarrow') {
-                return new TypstNode(
-                    'funcCall',
-                    'arrow',
+            if (node.head.value === '\\overrightarrow') {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'arrow'),
                     [arg0]
                 );
             }
             // \overleftarrow{AB} -> accent(A B, arrow.l)
-            if (node.content === '\\overleftarrow') {
-                return new TypstNode(
-                    'funcCall',
-                    'accent',
-                    [arg0, new TypstNode('symbol', 'arrow.l')]
+            if (node.head.value === '\\overleftarrow') {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'accent'),
+                    [arg0, new TypstToken(TypstTokenType.SYMBOL, 'arrow.l').toNode()]
                 );
             }
             // \operatorname{opname} -> op("opname")
-            if (node.content === '\\operatorname') {
+            if (node.head.value === '\\operatorname') {
                 // arg0 must be of type 'literal' in this situation
                 if (options.optimize) {
-                    if (TYPST_INTRINSIC_OP.includes(arg0.content)) {
-                        return new TypstNode('symbol', arg0.content);
+                    if (TYPST_INTRINSIC_OP.includes(arg0.head.value)) {
+                        return new TypstToken(TypstTokenType.SYMBOL, arg0.head.value).toNode();
                     }
                 }
-                return new TypstNode('funcCall', 'op', [new TypstNode('text', arg0.content)]);
+                return new TypstFuncCall(new TypstToken(TypstTokenType.SYMBOL, 'op'), [new TypstToken(TypstTokenType.TEXT, arg0.head.value).toNode()]);
             }
 
             // \substack{a \\ b} -> `a \ b`
             // as in translation from \sum_{\substack{a \\ b}} to sum_(a \ b)
-            if (node.content === '\\substack') {
+            if (node.head.value === '\\substack') {
                 return arg0;
             }
 
+            if (node.head.value === '\\overset') {
+                return convert_overset(node, options);
+            }
+            if (node.head.value === '\\underset') {
+                return convert_underset(node, options);
+            }
+
+            // \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)));
+                }
+            }
             if(options.optimize) {
                 // \mathbb{R} -> RR
-                if (node.content === '\\mathbb' && arg0.type === 'atom' && /^[A-Z]$/.test(arg0.content)) {
-                    return new TypstNode('symbol', arg0.content + arg0.content);
+                if (node.head.value === '\\mathbb' && /^\\mathbb{[A-Z]}$/.test(node.toString())) {
+                    return new TypstToken(TypstTokenType.SYMBOL, arg0.head.value.repeat(2)).toNode();
                 }
                 // \mathrm{d} -> dif
-                if (node.content === '\\mathrm' && arg0.eq(new TypstNode('atom', 'd'))) {
-                    return new TypstNode('symbol', 'dif');
+                if (node.head.value === '\\mathrm' && node.toString() === '\\mathrm{d}') {
+                    return new TypstToken(TypstTokenType.SYMBOL, 'dif').toNode();
                 }
             }
 
             // generic case
-            return new TypstNode(
-                'funcCall',
-                tex_token_to_typst(node.content),
+            return new TypstFuncCall(
+                tex_token_to_typst(node.head, options),
                 node.args!.map((n) => convert_tex_node_to_typst(n, options))
             );
         }
         case 'beginend': {
-            const matrix = node.data as TexNode[][];
-            const data = matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
+            const node = abstractNode as TexBeginEnd;
+            const data = node.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
 
-            if (node.content.startsWith('align')) {
+            if (node.head.value.startsWith('align')) {
                 // align, align*, alignat, alignat*, aligned, etc.
-                return new TypstNode('align', '', [], data);
+                return new TypstAlign(data);
             }
-            if (node.content === 'cases') {
-                return new TypstNode('cases', '', [], data);
+            if (node.head.value === 'cases') {
+                return new TypstCases(data);
             }
-            if (node.content === 'subarray') {
+            if (node.head.value === 'subarray') {
                 const align_node = node.args![0];
-                switch (align_node.content) {
+                switch (align_node.head.value) {
                     case 'r':
-                        data.forEach(row => row[0].args!.push(new TypstNode('symbol', '&')));
+                        data.forEach(row => row[0].args!.push(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
                         break;
                     case 'l':
-                        data.forEach(row => row[0].args!.unshift(new TypstNode('symbol', '&')));
+                        data.forEach(row => row[0].args!.unshift(new TypstToken(TypstTokenType.CONTROL, '&').toNode()));
                         break;
                     default:
                         break;
                 }
-                return new TypstNode('align', '', [], data);
+                return new TypstAlign(data);
             }
-            if (node.content === 'array') {
+            if (node.head.value === 'array') {
                 const np: TypstNamedParams = { 'delim': TYPST_NONE };
 
-                assert(node.args!.length > 0 && node.args![0].type === 'literal');
-                const np_new = convert_tex_array_align_literal(node.args![0].content);
+                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);
                 Object.assign(np, np_new);
 
-                const res = new TypstNode('matrix', '', [], data);
+                const res = new TypstMatrix(data);
                 res.setOptions(np);
                 return res;
             }
-            if (node.content.endsWith('matrix')) {
-                const res = new TypstNode('matrix', '', [], data);
-                let delim: TypstNode;
-                switch (node.content) {
+            if (node.head.value.endsWith('matrix')) {
+                const res = new TypstMatrix(data);
+                let delim: TypstToken;
+                switch (node.head.value) {
                     case 'matrix':
-                        delim = TYPST_NONE;
+                        delim = TypstToken.NONE;
                         break;
                     case 'pmatrix':
-                        // delim = new TypstNode('text', '(');
+                        // delim = new TypstToken(TypstTokenType.TEXT, '(');
                         // break;
                         return res; // typst mat use delim:"(" by default
                     case 'bmatrix':
-                        delim = new TypstNode('text', '[');
+                        delim = new TypstToken(TypstTokenType.TEXT, '[');
                         break;
                     case 'Bmatrix':
-                        delim = new TypstNode('text', '{');
+                        delim = new TypstToken(TypstTokenType.TEXT, '{');
                         break;
                     case 'vmatrix':
-                        delim = new TypstNode('text', '|');
+                        delim = new TypstToken(TypstTokenType.TEXT, '|');
                         break;
                     case 'Vmatrix': {
-                        delim = new TypstNode('symbol', 'bar.v.double');
+                        delim = new TypstToken(TypstTokenType.SYMBOL, 'bar.v.double');
                         break;
                     }
                     default:
-                        throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+                        throw new ConverterError(`Unimplemented beginend: ${node.head}`, node);
                 }
-                res.setOptions({ 'delim': delim });
+                res.setOptions({ 'delim': delim.toNode()});
                 return res;
             }
-            throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+            throw new ConverterError(`Unimplemented beginend: ${node.head}`, node);
         }
-        case 'unknownMacro':
-            return new TypstNode('unknown', tex_token_to_typst(node.content));
-        case 'control':
-            if (node.content === '\\\\') {
-                // \\ -> \
-                return new TypstNode('symbol', '\\');
-            } else if (node.content === '\\!') {
-                // \! -> #h(-math.thin.amount)
-                return new TypstNode('funcCall', '#h', [
-                    new TypstNode('literal', '-math.thin.amount')
-                ]);
-            } else if (symbolMap.has(node.content.substring(1))) {
-                // node.content is one of \, \: \;
-                const typst_symbol = symbolMap.get(node.content.substring(1))!;
-                return new TypstNode('symbol', typst_symbol);
-            } else {
-                throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
-            }
         default:
-            throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
+            throw new ConverterError(`Unimplemented node type: ${abstractNode.type}`, abstractNode);
     }
 }
 
@@ -472,194 +485,252 @@ const TYPST_BINARY_FUNCTIONS: string[] = [
 ];
 */
 
-function apply_escape_if_needed(c: string) {
-    if (['{', '}', '%'].includes(c)) {
-        return '\\' + c;
+function apply_escape_if_needed(c: TexToken): TexToken {
+    if (['{', '}', '%'].includes(c.value)) {
+        return new TexToken(TexTokenType.ELEMENT, '\\' + c.value);
     }
     return c;
 }
 
-function typst_token_to_tex(token: string): string {
-    if (/^[a-zA-Z0-9]$/.test(token)) {
-        return token;
-    } else if (reverseSymbolMap.has(token)) {
-        return '\\' + reverseSymbolMap.get(token)!;
+
+function typst_token_to_tex(token: TypstToken): TexToken {
+    switch (token.type) {
+        case TypstTokenType.NONE:
+            // e.g. Typst `#none^2` is converted to TeX `^2`
+            return TexToken.EMPTY;
+        case TypstTokenType.SYMBOL: {
+            const _typst_symbol_to_tex = function(symbol: string): string {
+                if (reverseSymbolMap.has(symbol)) {
+                    return '\\' + reverseSymbolMap.get(symbol)!;
+                } else {
+                    return '\\' + symbol;
+                }
+            }
+            return new TexToken(TexTokenType.COMMAND, _typst_symbol_to_tex(token.value));
+        }
+        case TypstTokenType.ELEMENT: {
+            let value: string;
+            if (['{', '}', '%'].includes(token.value)) {
+                value = '\\' + token.value;
+            } else {
+                value = token.value;
+            }
+            return new TexToken(TexTokenType.ELEMENT, value);
+        }
+        case TypstTokenType.LITERAL:
+            return new TexToken(TexTokenType.LITERAL, token.value);
+        case TypstTokenType.TEXT:
+            return new TexToken(TexTokenType.LITERAL, token.value);
+        case TypstTokenType.COMMENT:
+            return new TexToken(TexTokenType.COMMENT, token.value);
+        case TypstTokenType.SPACE:
+            return new TexToken(TexTokenType.SPACE, token.value);
+        case TypstTokenType.CONTROL: {
+            let value: string;
+            switch(token.value) {
+                case '\\':
+                    value = '\\\\';
+                    break;
+                case '&':
+                    value = '&';
+                    break;
+                default:
+                        throw new Error(`[typst_token_to_tex]Unimplemented control sequence: ${token.value}`);
+            }
+            return new TexToken(TexTokenType.CONTROL, value);
+        }
+        case TypstTokenType.NEWLINE:
+            return new TexToken(TexTokenType.NEWLINE, token.value);
+        default:
+            throw new Error(`Unimplemented token type: ${token.type}`);
     }
-    return '\\' + token;
 }
 
 
-const TEX_NODE_COMMA = new TexNode('element', ',');
+const TEX_NODE_COMMA = new TexToken(TexTokenType.ELEMENT, ',').toNode();
 
-export function convert_typst_node_to_tex(node: TypstNode): TexNode {
-    // special hook for eq.def
-    if (node.eq(new TypstNode('symbol', 'eq.def'))) {
-        return new TexNode('binaryFunc', '\\overset', [
-            new TexNode('text', 'def'),
-            new TexNode('element', '=')
-        ]);
-    }
-    switch (node.type) {
-        case 'none':
-            // e.g. Typst `#none^2` is converted to TeX `^2`
-            return new TexNode('empty', '');
-        case 'whitespace':
-            return new TexNode('whitespace', node.content);
-        case 'atom':
-            return new TexNode('element', node.content);
-        case 'symbol': {
-            // special hook for comma
-            if(node.content === 'comma') {
-                return new TexNode('element', ',');
-            }
-            // special hook for dif
-            if(node.content === 'dif') {
-                return new TexNode('unaryFunc', '\\mathrm', [new TexNode('element', 'd')]);
-            }
-            // special hook for hyph and hyph.minus
-            if(node.content === 'hyph' || node.content === 'hyph.minus') {
-                return new TexNode('text', '-');
+export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
+    switch (abstractNode.type) {
+        case 'terminal': {
+            const node = abstractNode as TypstTerminal;
+            if (node.head.type === TypstTokenType.SYMBOL) {
+                // special hook for eq.def
+                if (node.head.value === 'eq.def') {
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\overset'), [
+                        new TexText(new TexToken(TexTokenType.LITERAL, 'def')),
+                        new TexToken(TexTokenType.ELEMENT, '=').toNode()
+                    ]);
+                }
+                // special hook for comma
+                if(node.head.value === 'comma') {
+                    return new TexToken(TexTokenType.ELEMENT, ',').toNode();
+                }
+                // special hook for dif
+                if(node.head.value === 'dif') {
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\mathrm'), [new TexToken(TexTokenType.ELEMENT, 'd').toNode()]);
+                }
+                // special hook for hyph and hyph.minus
+                if(node.head.value === 'hyph' || node.head.value === 'hyph.minus') {
+                    return new TexText(new TexToken(TexTokenType.LITERAL, '-'));
+                }
+                // special hook for mathbb{R} <-- RR
+                if(/^([A-Z])\1$/.test(node.head.value)) {
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\mathbb'), [
+                        new TexToken(TexTokenType.ELEMENT, node.head.value[0]).toNode()
+                    ]);
+                }
             }
-            // special hook for mathbb{R} <-- RR
-            if(/^([A-Z])\1$/.test(node.content)) {
-                return new TexNode('unaryFunc', '\\mathbb', [
-                    new TexNode('element', node.content[0])
-                ]);
+            if (node.head.type === TypstTokenType.TEXT) {
+                return new TexText(new TexToken(TexTokenType.LITERAL, node.head.value));
             }
-            return new TexNode('symbol', typst_token_to_tex(node.content));
+            return typst_token_to_tex(node.head).toNode();
         }
-        case 'literal':
-            return new TexNode('literal', node.content);
-        case 'text':
-            return new TexNode('text', node.content);
-        case 'comment':
-            return new TexNode('comment', node.content);
+
         case 'group': {
+            const node = abstractNode as TypstGroup;
             const args = node.args!.map(convert_typst_node_to_tex);
-            if (node.content === 'parenthesis') {
-                const is_over_high = node.isOverHigh();
-                const left_delim = is_over_high ? '\\left(' : '(';
-                const right_delim = is_over_high ? '\\right)' : ')';
-                args.unshift(new TexNode('element', left_delim));
-                args.push(new TexNode('element', right_delim));
+            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[][] = [];
+                for(const row of rows) {
+                    const cells = array_split(row, alignment_char);
+                    data.push(cells.map(cell => new TexGroup(cell)));
+                }
+                return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'aligned'), [], data);
             }
-            return new TexNode('ordgroup', node.content, args);
+            return new TexGroup(args);
+        }
+        case 'leftright': {
+            const node = abstractNode as TypstLeftright;
+            const args = node.args!.map(convert_typst_node_to_tex);
+            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();
+            // const left_delim = is_over_high ? '\\left(' : '(';
+            // const right_delim = is_over_high ? '\\right)' : ')';
+            if (node.isOverHigh()) {
+                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);
         }
         case 'funcCall': {
-            // special hook for lr
-            if (node.content === 'lr') {
-                const data = node.data as TypstLrData;
-                if (data.leftDelim !== null) {
-                    let left_delim = apply_escape_if_needed(data.leftDelim);
-                    assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
-                    let right_delim = apply_escape_if_needed(data.rightDelim!);
-                    // TODO: should be TeXNode('leftright', ...)
-                    // But currently writer will output `\left |` while people commonly prefer `\left|`.
-                    return new TexNode('ordgroup', '', [
-                        new TexNode('element', '\\left' + left_delim),
-                        ...node.args!.map(convert_typst_node_to_tex),
-                        new TexNode('element', '\\right' + right_delim)
-                    ]);
-                } else {
-                    return new TexNode('ordgroup', '', node.args!.map(convert_typst_node_to_tex));
+            const node = abstractNode as TypstFuncCall;
+            switch (node.head.value) {
+                // special hook for norm
+                // `\| 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) ];
+                    if (node.isOverHigh()) {
+                        return new TexLeftRight(args, {
+                            left: new TexToken(TexTokenType.COMMAND, "\\|"),
+                            right: new TexToken(TexTokenType.COMMAND, "\\|")
+                        });
+                    } else {
+                        return new TexGroup(args);
+                    }
+                }
+                // special hook for floor, ceil
+                // `\lfloor a \rfloor` <- `floor(a)`
+                // `\lceil a \rceil` <- `ceil(a)`
+                // `\left\lfloor a \right\rfloor` <- `floor(a)`
+                // `\left\lceil a \right\rceil` <- `ceil(a)`
+                case 'floor':
+                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 left_node = new TexToken(TexTokenType.COMMAND, left);
+                    const right_node = new TexToken(TexTokenType.COMMAND, right);
+                    if (node.isOverHigh()) {
+                        return new TexLeftRight([typ_arg0], {
+                            left: left_node,
+                            right: right_node
+                        });
+                    } else {
+                        return new TexGroup([left_node.toNode(), typ_arg0, right_node.toNode()]);
+                    }
+                }
+                // 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);
+                }
+                // 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 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_data = node.args!.map(convert_typst_node_to_tex).map((n) => [n]);
+                    return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'pmatrix'), [], tex_data);
+                }
+                // special hook for op
+                case 'op': {
+                    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()]);
+                }
+                // 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));
+                    } 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),
+                            new TexToken(TexTokenType.ELEMENT, ')').toNode()
+                        ]);
+                    }
                 }
-            }
-            // special hook for norm
-            // `\| a  \|` <- `norm(a)`
-            // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
-            if (node.content === 'norm') {
-                const arg0 = node.args![0];
-                const tex_node_type = node.isOverHigh() ? 'leftright' : 'ordgroup';
-                return new TexNode(tex_node_type, '', [
-                    new TexNode('symbol', "\\|"),
-                    convert_typst_node_to_tex(arg0),
-                    new TexNode('symbol', "\\|")
-                ]);
-            }
-            // special hook for floor, ceil
-            // `\lfloor a \rfloor` <- `floor(a)`
-            // `\lceil a \rceil` <- `ceil(a)`
-            // `\left\lfloor a \right\rfloor` <- `floor(a)`
-            // `\left\lceil a \right\rceil` <- `ceil(a)`
-            if (node.content === 'floor' || node.content === 'ceil') {
-                const left = "\\l" + node.content;
-                const right = "\\r" + node.content;
-                const arg0 = node.args![0];
-                const tex_node_type = node.isOverHigh() ? 'leftright' : 'ordgroup';
-                return new TexNode(tex_node_type, '', [
-                    new TexNode('symbol', left),
-                    convert_typst_node_to_tex(arg0),
-                    new TexNode('symbol', right)
-                ]);
-            }
-            // special hook for root
-            if (node.content === 'root') {
-                const [degree, radicand] = node.args!;
-                const data: TexSqrtData = convert_typst_node_to_tex(degree);
-                return new TexNode('unaryFunc', '\\sqrt', [convert_typst_node_to_tex(radicand)], data);
-            }
-            // special hook for overbrace and underbrace
-            if (node.content === 'overbrace' || node.content === 'underbrace') {
-                const [body, label] = node.args!;
-                const base = new TexNode('unaryFunc', '\\' + node.content, [convert_typst_node_to_tex(body)]);
-                const script = convert_typst_node_to_tex(label);
-                const data = node.content === 'overbrace' ? { base, sup: script } : { base, sub: script };
-                return new TexNode('supsub', '', [], data);
-            }
-
-            // special hook for vec
-            // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
-            if (node.content === 'vec') {
-                const tex_data = node.args!.map(convert_typst_node_to_tex).map((n) => [n]) as TexArrayData;
-                return new TexNode('beginend', 'pmatrix', [], tex_data);
-            }
-
-            // general case
-            const func_name_tex = typst_token_to_tex(node.content);
-            if (func_name_tex.length > 0 && TEX_UNARY_COMMANDS.includes(func_name_tex.substring(1))) {
-                return new TexNode('unaryFunc', func_name_tex, node.args!.map(convert_typst_node_to_tex));
-            } else if (func_name_tex.length > 0 && TEX_BINARY_COMMANDS.includes(func_name_tex.substring(1))) {
-                return new TexNode('binaryFunc', func_name_tex, node.args!.map(convert_typst_node_to_tex));
-            } else {
-                return new TexNode('ordgroup', '', [
-                    new TexNode('symbol', typst_token_to_tex(node.content)),
-                    new TexNode('element', '('),
-                    ...array_intersperse(node.args!.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
-                    new TexNode('element', ')')
-                ]);
             }
         }
         case 'supsub': {
-            const { base, sup, sub } = node.data as TypstSupsubData;
-            let sup_tex: TexNode | undefined;
-            let sub_tex: TexNode | undefined;
-
-            if (sup) {
-                sup_tex = convert_typst_node_to_tex(sup);
-            }
-            if (sub) {
-                sub_tex = convert_typst_node_to_tex(sub);
-            }
+            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;
 
             // special hook for limits
             // `limits(+)^a` -> `\overset{a}{+}`
             // `limits(+)_a` -> `\underset{a}{+}`
             // `limits(+)_a^b` -> `\overset{b}{\underset{a}{+}}`
-            if (base.eq(new TypstNode('funcCall', 'limits'))) {
+            if (base.head.eq(new TypstToken(TypstTokenType.SYMBOL, 'limits'))) {
                 const body_in_limits = convert_typst_node_to_tex(base.args![0]);
-                if (sup_tex !== undefined && sub_tex === undefined) {
-                    return new TexNode('binaryFunc', '\\overset', [sup_tex, body_in_limits]);
-                } else if (sup_tex === undefined && sub_tex !== undefined) {
-                    return new TexNode('binaryFunc', '\\underset', [sub_tex, body_in_limits]);
+                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) {
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\underset'), [sub_tex, body_in_limits]);
                 } else {
-                    const underset_call = new TexNode('binaryFunc', '\\underset', [sub_tex!, body_in_limits]);
-                    return new TexNode('binaryFunc', '\\overset', [sup_tex!, underset_call]);
+                    const underset_call = new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\underset'), [sub_tex!, body_in_limits]);
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\overset'), [sup_tex!, underset_call]);
                 }
             }
 
             const base_tex = convert_typst_node_to_tex(base);
 
-            const res = new TexNode('supsub', '', [], {
+            const res = new TexSupSub({
                 base: base_tex,
                 sup: sup_tex,
                 sub: sub_tex
@@ -667,13 +738,13 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
             return res;
         }
         case 'matrix': {
-            const typst_data = node.data as TypstNode[][];
-            const tex_data = typst_data.map(row => row.map(convert_typst_node_to_tex));
+            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.content) {
+                    switch (delim.head.value) {
                         case '#none':
                             env_type = 'matrix';
                             break;
@@ -700,35 +771,26 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
                             env_type = 'Vmatrix';
                             break;
                         default:
-                            throw new Error(`Unexpected delimiter ${delim.content}`);
+                            throw new Error(`Unexpected delimiter ${delim.head}`);
                     }
                 }
             }
-            return new TexNode('beginend', env_type, [], tex_data);
+            return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, env_type), [], tex_data);
         }
         case 'cases': {
-            const typst_data = node.data as TypstNode[][];
-            const tex_data = typst_data.map(row => row.map(convert_typst_node_to_tex));
-            return new TexNode('beginend', 'cases', [], tex_data);
-        }
-        case 'control': {
-            switch (node.content) {
-                case '\\':
-                    return new TexNode('control', '\\\\');
-                case '&':
-                    return new TexNode('control', '&');
-                default:
-                    throw new Error('[convert_typst_node_to_tex] Unimplemented control: ' + node.content);
-            }
+            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 num_tex = convert_typst_node_to_tex(numerator);
             const den_tex = convert_typst_node_to_tex(denominator);
-            return new TexNode('binaryFunc', '\\frac', [num_tex, den_tex]);
+            return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\frac'), [num_tex, den_tex]);
         }
         default:
-            throw new Error('[convert_typst_node_to_tex] Unimplemented type: ' + node.type);
+            throw new Error('[convert_typst_node_to_tex] Unimplemented type: ' + abstractNode.type);
     }
 }