tex2typst 0.3.7 → 0.3.9

package/src/convert.ts

@@ -1,6 +1,9 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType } from "./types";
+import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType, TypstLrData } from "./types";
 import { TypstWriterError } from "./typst-writer";
 import { symbolMap, reverseSymbolMap } from "./map";
+import { array_join } from "./generic";
+import { assert } from "./util";
+
 
 // symbols that are supported by Typst but not by KaTeX
 const TYPST_INTRINSIC_SYMBOLS = [
@@ -344,6 +347,8 @@ const TYPST_UNARY_FUNCTIONS: string[] = [
     'bb',
     'cal',
     'frak',
+    'floor',
+    'ceil',
 ];
 
 const TYPST_BINARY_FUNCTIONS: string[] = [
@@ -372,6 +377,7 @@ function typst_token_to_tex(token: string): string {
 }
 
 
+const TEX_NODE_COMMA = new TexNode('element', ',');
 
 export function convert_typst_node_to_tex(node: TypstNode): TexNode {
     // special hook for eq.def
@@ -406,24 +412,48 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
             return new TexNode('comment', node.content);
         case 'group': {
             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));
+            }
             return new TexNode('ordgroup', node.content, args);
         }
         case 'funcCall': {
             if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
                 // special hook for lr
                 if (node.content === 'lr') {
-                    const body = node.args![0];
-                    if (body.type === 'group') {
-                        let left_delim = body.args![0].content;
-                        let right_delim = body.args![body.args!.length - 1].content;
-                        left_delim = apply_escape_if_needed(left_delim);
-                        right_delim = apply_escape_if_needed(right_delim);
+                    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!);
                         return new TexNode('ordgroup', '', [
                             new TexNode('element', '\\left' + left_delim),
-                            ...body.args!.slice(1, body.args!.length - 1).map(convert_typst_node_to_tex),
+                            ...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));
+                    }
+                }
+                // special hook for floor, ceil
+                // Typst "floor(a) + ceil(b)" should converts to Tex "\lfloor a \rfloor + \lceil b \rceil"
+                if (node.content === 'floor' || node.content === 'ceil') {
+                    let left = "\\l" + node.content;
+                    let right = "\\r" + node.content;
+                    const arg0 = node.args![0];
+                    if (arg0.isOverHigh()) {
+                        left = "\\left" + left;
+                        right = "\\right" + right;
                     }
+                    return new TexNode('ordgroup', '', [
+                        new TexNode('symbol', left),
+                        convert_typst_node_to_tex(arg0),
+                        new TexNode('symbol', right)
+                    ]);
                 }
                 const command = typst_token_to_tex(node.content);
                 return new TexNode('unaryFunc', command, node.args!.map(convert_typst_node_to_tex));
@@ -448,7 +478,7 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
                 return new TexNode('ordgroup', '', [
                     new TexNode('symbol', typst_token_to_tex(node.content)),
                     new TexNode('element', '('),
-                    ...node.args!.map(convert_typst_node_to_tex),
+                    ...array_join(node.args!.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
                     new TexNode('element', ')')
                 ]);
             }

package/src/generic.ts

@@ -34,4 +34,17 @@ export function array_split<T extends IEquatable>(array: T[], sep: T): T[][] {
     }
     res.push(current_slice);
     return res;
+}
+
+// e.g. input array=['a', 'b', 'c'], sep = '+'
+// return ['a','+', 'b', '+','c']
+export function array_join<T>(array: T[], sep: T): T[] {
+    const res: T[] = [];
+    for (let i = 0; i < array.length; i++) {
+        res.push(array[i]);
+        if (i != array.length - 1) {
+            res.push(sep);
+        }
+    }
+    return res;
 }

package/src/tex-parser.ts

@@ -175,25 +175,35 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
         const match = text.match(regex);
         assert(match !== null);
         const command = match![1];
-        const arg1 = match![2].trimStart();
-        const arg2 = match![3];
-        return [
-            new TexToken(TexTokenType.COMMAND, command),
-            new TexToken(TexTokenType.ELEMENT, arg1),
-            new TexToken(TexTokenType.ELEMENT, arg2),
-        ];
-    }],
+        if (BINARY_COMMANDS.includes(command.substring(1))) {
+            const arg1 = match![2].trimStart();
+            const arg2 = match![3];
+            return [
+                new TexToken(TexTokenType.COMMAND, command),
+                new TexToken(TexTokenType.ELEMENT, arg1),
+                new TexToken(TexTokenType.ELEMENT, arg2),
+            ];
+        } else {
+            s.reject();
+            return [];
+        }
+   }],
     [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
         const text = s.text()!;
         const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`);
         const match = text.match(regex);
         assert(match !== null);
         const command = match![1];
-        const arg1 = match![2].trimStart();
-        return [
-            new TexToken(TexTokenType.COMMAND, command),
-            new TexToken(TexTokenType.ELEMENT, arg1),
-        ];
+        if (UNARY_COMMANDS.includes(command.substring(1))) {
+            const arg1 = match![2].trimStart();
+            return [
+                new TexToken(TexTokenType.COMMAND, command),
+                new TexToken(TexTokenType.ELEMENT, arg1),
+            ];
+        } else {
+            s.reject();
+            return [];
+        }
     }],
     [String.raw`\\[a-zA-Z]+`, (s) => {
         const command = s.text()!;

package/src/types.ts

@@ -123,15 +123,7 @@ export class TexNode {
                 return tokens;
             }
             case 'ordgroup': {
-                let tokens =  this.args!.map((n) => n.serialize()).flat();
-                if(this.content === 'parenthesis') {
-                    const is_over_high = this.isOverHigh();
-                    const left_delim = is_over_high ? '\\left(' : '(';
-                    const right_delim = is_over_high ? '\\right)' : ')';
-                    tokens.unshift(new TexToken(TexTokenType.ELEMENT, left_delim));
-                    tokens.push(new TexToken(TexTokenType.ELEMENT, right_delim));
-                }
-                return tokens;
+                return this.args!.map((n) => n.serialize()).flat();
             }
             case 'unaryFunc': {
                 let tokens: TexToken[] = [];
@@ -238,34 +230,6 @@ export class TexNode {
                 throw new Error('[TexNode.serialize] Unimplemented type: ' + this.type);
         }
     }
-
-    // whether the node is over high so that if it's wrapped in braces, \left and \right should be used.
-    // e.g. \frac{1}{2} is over high, "2" is not.
-    public isOverHigh(): boolean {
-        switch (this.type) {
-            case 'element':
-            case 'symbol':
-            case 'text':
-            case 'control':
-            case 'empty':
-                    return false;
-            case 'binaryFunc':
-                if(this.content === '\\frac') {
-                    return true;
-                }
-                // fall through
-            case 'unaryFunc':
-            case 'ordgroup':
-                return this.args!.some((n) => n.isOverHigh());
-            case 'supsub': {
-                return (this.data as TexSupsubData).base.isOverHigh();
-            }
-            case 'beginend':
-                return true;
-            default:
-                return false;
-        }
-    }
 }
 
 export enum TypstTokenType {
@@ -348,6 +312,10 @@ export interface TypstSupsubData {
 }
 
 export type TypstArrayData = TypstNode[][];
+export interface TypstLrData {
+    leftDelim: string | null;
+    rightDelim: string | null;
+}
 
 type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace'
             | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'cases' | 'unknown';
@@ -364,12 +332,12 @@ export class TypstNode {
     type: TypstNodeType;
     content: string;
     args?: TypstNode[];
-    data?: TypstSupsubData | TypstArrayData;
+    data?: TypstSupsubData | TypstArrayData | TypstLrData;
     // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
     options?: TypstNamedParams;
 
     constructor(type: TypstNodeType, content: string, args?: TypstNode[],
-            data?: TypstSupsubData | TypstArrayData) {
+            data?: TypstSupsubData | TypstArrayData| TypstLrData) {
         this.type = type;
         this.content = content;
         this.args = args;
@@ -384,6 +352,31 @@ export class TypstNode {
     public eq(other: TypstNode): boolean {
         return this.type === other.type && this.content === other.content;
     }
+
+    // whether the node is over high so that if it's wrapped in braces, \left and \right should be used in its TeX form
+    // e.g. 1/2 is over high, "2" is not.
+    public isOverHigh(): boolean {
+        switch (this.type) {
+            case 'fraction':
+                return true;
+            case 'funcCall': {
+                if (this.content === 'frac') {
+                    return true;
+                }
+                return this.args!.some((n) => n.isOverHigh());
+            }
+            case 'group':
+                return this.args!.some((n) => n.isOverHigh());
+            case 'supsub':
+                return (this.data as TypstSupsubData).base.isOverHigh();
+            case 'align':
+            case 'cases':
+            case 'matrix':
+                return true;
+            default:
+                return false;
+        }
+    }
 }
 
 export interface Tex2TypstOptions {

package/src/typst-parser.ts

@@ -1,6 +1,6 @@
 
 import { array_find } from "./generic";
-import { TYPST_NONE, TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TYPST_NONE, TypstLrData, TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 import { assert, isalpha } from "./util";
 import { reverseShorthandMap } from "./typst-shorthands";
 import { JSLex, Scanner } from "./jslex";
@@ -91,8 +91,9 @@ export function tokenize_typst(input: string): TypstToken[] {
 }
 
 
-function find_closing_match(tokens: TypstToken[], start: number): number {
-    assert(tokens[start].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET]));
+function _find_closing_match(tokens: TypstToken[], start: number,
+        leftBrackets: TypstToken[], rightBrackets: TypstToken[]): number {
+    assert(tokens[start].isOneOf(leftBrackets));
     let count = 1;
     let pos = start + 1;
 
@@ -100,10 +101,10 @@ function find_closing_match(tokens: TypstToken[], start: number): number {
         if (pos >= tokens.length) {
             throw new Error('Unmatched brackets');
         }
-        if (tokens[pos].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET])) {
-            count += 1;
-        } else if (tokens[pos].isOneOf([RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET])) {
+        if (tokens[pos].isOneOf(rightBrackets)) {
             count -= 1;
+        }else if (tokens[pos].isOneOf(leftBrackets)) {
+            count += 1;
         }
         pos += 1;
     }
@@ -111,6 +112,25 @@ function find_closing_match(tokens: TypstToken[], start: number): number {
     return pos - 1;
 }
 
+function find_closing_match(tokens: TypstToken[], start: number): number {
+    return _find_closing_match(
+        tokens,
+        start,
+        [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET],
+        [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET]
+    );
+}
+
+function find_closing_delim(tokens: TypstToken[], start: number): number {
+    return _find_closing_match(
+        tokens,
+        start,
+        [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET, VERTICAL_BAR],
+        [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET, VERTICAL_BAR]
+    );
+}
+
+
 
 function find_closing_parenthesis(nodes: TypstNode[], start: number): number {
     const left_parenthesis = new TypstNode('atom', '(');
@@ -261,6 +281,7 @@ const LEFT_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '[');
 const RIGHT_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ']');
 const LEFT_CURLY_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '{');
 const RIGHT_CURLY_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '}');
+const VERTICAL_BAR = new TypstToken(TypstTokenType.ELEMENT, '|');
 const COMMA = new TypstToken(TypstTokenType.ELEMENT, ',');
 const SEMICOLON = new TypstToken(TypstTokenType.ELEMENT, ';');
 const SINGLE_SPACE = new TypstToken(TypstTokenType.SPACE, ' ');
@@ -389,9 +410,13 @@ export class TypstParser {
                     casesNode.setOptions(named_params);
                     return [casesNode, newPos];
                 }
+                if (firstToken.value === 'lr') {
+                    const [args, newPos, lrData] = this.parseLrArguments(tokens, start + 1);
+                    const func_call = new TypstNode('funcCall', firstToken.value, args, lrData);
+                    return [func_call, newPos];
+                }
                 const [args, newPos] = this.parseArguments(tokens, start + 1);
-                const func_call = new TypstNode('funcCall', firstToken.value);
-                func_call.args = args;
+                const func_call = new TypstNode('funcCall', firstToken.value, args);
                 return [func_call, newPos];
             }
         }
@@ -405,6 +430,28 @@ export class TypstParser {
         return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
     }
 
+    // start: the position of the left parentheses
+    parseLrArguments(tokens: TypstToken[], start: number): [TypstNode[], number, TypstLrData] {
+        if (tokens[start + 1].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET, VERTICAL_BAR])) {
+            const end = find_closing_match(tokens, start);
+            const inner_start = start + 1;
+            const inner_end = find_closing_delim(tokens, inner_start);
+            const inner_args= this.parseCommaSeparatedArguments(tokens, inner_start + 1, inner_end);
+            return [
+                inner_args,
+                end + 1,
+                {leftDelim: tokens[inner_start].value, rightDelim: tokens[inner_end].value} as TypstLrData
+            ];
+        } else {
+            const [args, end] = this.parseArguments(tokens, start);
+            return [
+                args,
+                end,
+                {leftDelim: null, rightDelim: null} as TypstLrData,
+            ];
+        }
+    }
+
     // start: the position of the left parentheses
     parseGroupsOfArguments(tokens: TypstToken[], start: number, newline_token = SEMICOLON): [TypstNode[][], TypstNamedParams, number] {
         const end = find_closing_match(tokens, start);
@@ -472,7 +519,7 @@ export class TypstParser {
                 pos = next_stop + 1;
             }
         }
-        
+
         return [matrix, named_params, end + 1];
     }
 
@@ -481,8 +528,7 @@ export class TypstParser {
         const args: TypstNode[] = [];
         let pos = start;
         while (pos < end) {
-            let arg = new TypstNode('group', '', []);
-
+            let nodes: TypstNode[] = [];
             while(pos < end) {
                 if(tokens[pos].eq(COMMA)) {
                     pos += 1;
@@ -493,14 +539,18 @@ export class TypstParser {
                 }
                 const [argItem, newPos] = this.parseNextExpr(tokens, pos);
                 pos = newPos;
-                arg.args!.push(argItem);
+                nodes.push(argItem);
             }
 
-            if(arg.args!.length === 0) {
+            let arg: TypstNode;
+            if (nodes.length === 0) {
                 arg = TYPST_EMPTY_NODE;
-            } else if (arg.args!.length === 1) {
-                arg = arg.args![0];
+            } else if (nodes.length === 1) {
+                arg = nodes[0];
+            } else {
+                arg = process_operators(nodes);
             }
+
             args.push(arg);
         }
         return args;