tex2typst 0.3.0 → 0.3.1

package/src/convert.ts

@@ -1,4 +1,4 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions } from "./types";
+import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue } from "./types";
 import { TypstWriterError, TYPST_INTRINSIC_SYMBOLS } from "./typst-writer";
 import { symbolMap, reverseSymbolMap } from "./map";
 
@@ -60,7 +60,7 @@ function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
         'op',
         [convert_tex_node_to_typst(base, options)]
     );
-    op_call.setOptions({ limits: '#true' });
+    op_call.setOptions({ limits: TYPST_TRUE });
     return new TypstNode(
         'supsub',
         '',
@@ -240,11 +240,51 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
             if (node.content!.startsWith('align')) {
                 // align, align*, alignat, alignat*, aligned, etc.
                 return new TypstNode('align', '', [], data);
-            } else {
+            }
+            if (node.content!.endsWith('matrix')) {
+                let delim: TypstPrimitiveValue = null;
+                switch (node.content) {
+                    case 'matrix':
+                        delim = TYPST_NONE;
+                        break;
+                    case 'pmatrix':
+                        delim = '(';
+                        break;
+                    case 'bmatrix':
+                        delim = '[';
+                        break;
+                    case 'Bmatrix':
+                        delim = '{';
+                        break;
+                    case 'vmatrix':
+                        delim = '|';
+                        break;
+                    case 'Vmatrix': {
+                        // mat(delim: "||") does not compile in Typst.
+                        // For a workaround, translate
+                        // \begin{Vmatrix}
+                        //   a & b \\
+                        //   c & d
+                        //   \end{Vmatrix}
+                        // to
+                        //  lr(||mat(delim: #none, a, b; c, d)||)
+                        const matrix = new TypstNode('matrix', '', [], data);
+                        matrix.setOptions({ 'delim': TYPST_NONE });
+                        const group = new TypstNode('group', '', [
+                            new TypstNode('symbol', '||'),
+                            matrix,
+                            new TypstNode('symbol', '||'),
+                        ]);
+                        return new TypstNode('funcCall', 'lr', [ group ]);
+                    }
+                    default:
+                        throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+                }
                 const res = new TypstNode('matrix', '', [], data);
-                res.setOptions({ 'delim': '#none' });
+                res.setOptions({ 'delim': delim });
                 return res;
             }
+            throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
         }
         case 'unknownMacro':
             return new TypstNode('unknown', tex_token_to_typst(node.content));
@@ -416,7 +456,7 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
             if (node.options) {
                 if ('delim' in node.options) {
                     switch (node.options.delim) {
-                        case '#none':
+                        case TYPST_NONE:
                             return matrix;
                         case '[':
                             left_delim = "\\left[";

package/src/index.ts

@@ -1,5 +1,5 @@
 import { parseTex } from "./tex-parser";
-import { Tex2TypstOptions } from "./types";
+import type { Tex2TypstOptions } from "./types";
 import { TypstWriter } from "./typst-writer";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
 import { symbolMap } from "./map";

package/src/tex-parser.ts

@@ -296,46 +296,39 @@ export class LatexParser {
     }
 
     parse(tokens: TexToken[]): TexNode {
+        const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
+        return tree;
+    }
+
+    parseGroup(tokens: TexToken[], start: number, end: number): ParseResult {
         const results: TexNode[] = [];
-        let pos = 0;
-        while (pos < tokens.length) {
-            const results: TexNode[] = [];
-            let pos = 0;
-    
-            while (pos < tokens.length) {
-                const [res, newPos] = this.parseNextExpr(tokens, pos);
-                pos = newPos;
-                if(res.type === 'whitespace') {
-                    if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
-                        continue;
-                    }
-                    if (!this.newline_sensitive && res.content === '\n') {
-                        continue;
-                    }
+        let pos = start;
+        while (pos < end) {
+            const [res, newPos] = this.parseNextExpr(tokens, pos);
+            pos = newPos;
+            if(res.type === 'whitespace') {
+                if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
+                    continue;
                 }
-                if (res.type === 'control' && res.content === '&') {
-                    throw new LatexParserError('Unexpected & outside of an alignment');
+                if (!this.newline_sensitive && res.content === '\n') {
+                    continue;
                 }
-                results.push(res);
             }
-    
-            if (results.length === 0) {
-                return EMPTY_NODE;
-            } else if (results.length === 1) {
-                return results[0];
-            } else {
-                return new TexNode('ordgroup', '', results);
+            if (res.type === 'control' && res.content === '&') {
+                throw new LatexParserError('Unexpected & outside of an alignment');
             }
+            results.push(res);
         }
 
-
+        let node: TexNode;
         if (results.length === 0) {
-            return EMPTY_NODE;
+            node = EMPTY_NODE;
         } else if (results.length === 1) {
-            return results[0];
+            node = results[0];
         } else {
-            return new TexNode('ordgroup', '', results);
+            node = new TexNode('ordgroup', '', results);
         }
+        return [node, end + 1];
     }
 
     parseNextExpr(tokens: TexToken[], start: number): ParseResult {
@@ -396,8 +389,7 @@ export class LatexParser {
 
     parseNextExprWithoutSupSub(tokens: TexToken[], start: number): ParseResult {
         const firstToken = tokens[start];
-        const tokenType = firstToken.type;
-        switch (tokenType) {
+        switch (firstToken.type) {
             case TexTokenType.ELEMENT:
                 return [new TexNode('element', firstToken.value), start + 1];
             case TexTokenType.TEXT:
@@ -423,8 +415,7 @@ export class LatexParser {
                         if(posClosingBracket === -1) {
                             throw new LatexParserError("Unmatched '{'");
                         }
-                        const exprInside = tokens.slice(start + 1, posClosingBracket);
-                        return [this.parse(exprInside), posClosingBracket + 1];
+                        return this.parseGroup(tokens, start + 1, posClosingBracket);
                     case '}':
                         throw new LatexParserError("Unmatched '}'");
                     case '\\\\':
@@ -453,7 +444,7 @@ export class LatexParser {
 
         if (['left', 'right', 'begin', 'end'].includes(command.slice(1))) {
             throw new LatexParserError('Unexpected command: ' + command);
-        } 
+        }
 
 
         const paramNum = get_command_param_num(command.slice(1));
@@ -475,8 +466,7 @@ export class LatexParser {
                     if (posRightSquareBracket === -1) {
                         throw new LatexParserError('No matching right square bracket for [');
                     }
-                    const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
-                    const exponent = this.parse(exprInside);
+                    const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
                     const [arg1, newPos] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
                     return [new TexNode('unaryFunc', command, [arg1], exponent), newPos];
                 } else if (command === '\\text') {
@@ -529,15 +519,14 @@ export class LatexParser {
         if (pos >= tokens.length) {
             throw new LatexParserError('Expecting \\right after \\left');
         }
-        
+
         const rightDelimiter = eat_parenthesis(tokens, pos);
         if (rightDelimiter === null) {
             throw new LatexParserError('Invalid delimiter after \\right');
         }
         pos++;
 
-        const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-        const body = this.parse(exprInside);
+        const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
         const args: TexNode[] = [
             new TexNode('element', leftDelimiter.value),
             body,
@@ -556,9 +545,9 @@ export class LatexParser {
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
         const envName = tokens[pos + 1].value;
         pos += 3;
-        
+
         pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
-        
+
         const exprInsideStart = pos;
 
         const endIdx = find_closing_end_command(tokens, start);
@@ -567,7 +556,7 @@ export class LatexParser {
         }
         const exprInsideEnd = endIdx;
         pos = endIdx + 1;
-        
+
         assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
         assert(tokens[pos + 1].type === TexTokenType.TEXT);
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
@@ -575,7 +564,7 @@ export class LatexParser {
             throw new LatexParserError('Mismatched \\begin and \\end environments');
         }
         pos += 3;
-    
+
         const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
         // ignore spaces and '\n' before \end{envName}
         while(exprInside.length > 0 && [TexTokenType.SPACE, TexTokenType.NEWLINE].includes(exprInside[exprInside.length - 1].type)) {
@@ -606,7 +595,7 @@ export class LatexParser {
                     continue;
                 }
             }
-            
+
             if (res.type === 'control' && res.content === '\\\\') {
                 row = [];
                 group = new TexNode('ordgroup', '', []);

package/src/tex-writer.ts

@@ -1,5 +1,4 @@
 import { array_includes, array_split } from "./generic";
-import { reverseSymbolMap } from "./map";
 import { TexNode, TexToken, TexSupsubData, TexTokenType } from "./types";
 
 

package/src/types.ts

@@ -352,7 +352,13 @@ export type TypstArrayData = TypstNode[][];
 type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace'
             | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'unknown';
 
-export type TypstNamedParams = { [key: string]: string };
+export type TypstPrimitiveValue = string | boolean | null;
+export type TypstNamedParams = { [key: string]: TypstPrimitiveValue };
+
+// #none
+export const TYPST_NONE: TypstPrimitiveValue = null;
+export const TYPST_TRUE: TypstPrimitiveValue = true;
+export const TYPST_FALSE: TypstPrimitiveValue = false;
 
 export class TypstNode {
     type: TypstNodeType;
@@ -370,7 +376,7 @@ export class TypstNode {
         this.data = data;
     }
 
-    public setOptions(options: { [key: string]: string }) {
+    public setOptions(options: TypstNamedParams) {
         this.options = options;
     }
 

package/src/typst-parser.ts

@@ -1,6 +1,6 @@
 
 import { array_find } from "./generic";
-import { TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TYPST_NONE, TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 import { assert, isalpha, isdigit } from "./util";
 
 // TODO: In Typst, y' ' is not the same as y''.
@@ -450,7 +450,6 @@ export class TypstParser {
     // start: the position of the left parentheses
     parseArguments(tokens: TypstToken[], start: number): [TypstNode[], number] {
         const end = find_closing_match(tokens, start);
-        
         return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
     }
 
@@ -501,7 +500,7 @@ export class TypstParser {
                                 if(g.args!.length !== 4 || !g.args![pos_colon + 2].eq(new TypstNode('symbol', 'none'))) { 
                                     throw new TypstParserError('Invalid number of arguments for delim');
                                 }
-                                np['delim'] = "#none";
+                                np['delim'] = TYPST_NONE;
                             } else {
                                 throw new TypstParserError('Not implemented for other types of delim');
                             }

package/src/typst-writer.ts

@@ -1,4 +1,4 @@
-import { TexNode, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TexNode, TypstNode, TypstPrimitiveValue, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 
 
 // symbols that are supported by Typst but not by KaTeX
@@ -24,6 +24,22 @@ const TYPST_RIGHT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMEN
 const TYPST_COMMA: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ',');
 const TYPST_NEWLINE: TypstToken = new TypstToken(TypstTokenType.SYMBOL, '\n');
 
+function typst_primitive_to_string(value: TypstPrimitiveValue) {
+    switch (typeof value) {
+        case 'string':
+            return `"${value}"`;
+        case 'number':
+            return (value as number).toString();
+        case 'boolean':
+            return (value as boolean) ? '#true' : '#false';
+        default:
+            if (value === null) {
+                return '#none';
+            }
+            throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
+    }
+}
+
 export class TypstWriterError extends Error {
     node: TexNode | TypstNode | TypstToken;
 
@@ -58,6 +74,8 @@ export class TypstWriter {
             return;
         }
 
+        // TODO: "C \frac{xy}{z}" should translate to "C (x y)/z" instead of "C(x y)/z"
+
         let no_need_space = false;
         // putting the first token in clause
         no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
@@ -172,7 +190,8 @@ export class TypstWriter {
                 }
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `, ${key}: ${value}`));
+                        const value_str = typst_primitive_to_string(value);
+                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `, ${key}: ${value_str}`));
                     }
                 }
                 this.queue.push(TYPST_RIGHT_PARENTHESIS);
@@ -220,7 +239,8 @@ export class TypstWriter {
                 this.queue.push(TYPST_LEFT_PARENTHESIS);
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value}, `));
+                        const value_str = typst_primitive_to_string(value);
+                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value_str}, `));
                     }
                 }
                 matrix.forEach((row, i) => {