tex2typst 0.2.16 → 0.3.0-alpha

package/src/tex-parser.ts

@@ -1,5 +1,6 @@
 import { symbolMap } from "./map";
-import { TexNode, TexSupsubData, TexTokenType } from "./types";
+import { TexNode, TexSupsubData, TexToken, TexTokenType } from "./types";
+import { isalpha, isdigit, assert } from "./util";
 
 
 const UNARY_COMMANDS = [
@@ -45,28 +46,9 @@ const BINARY_COMMANDS = [
 ]
 
 
-export class TexToken {
-    type: TexTokenType;
-    value: string;
-
-    constructor(type: TexTokenType, value: string) {
-        this.type = type;
-        this.value = value;
-    }
-
-    public eq(token: TexToken): boolean {
-        return this.type === token.type && this.value === token.value;
-    }
-}
 
 const EMPTY_NODE: TexNode = new TexNode('empty', '');
 
-function assert(condition: boolean, message: string = ''): void {
-    if (!condition) {
-        throw new LatexParserError(message);
-    }
-}
-
 function get_command_param_num(command: string): number {
     if (UNARY_COMMANDS.includes(command)) {
         return 1;
@@ -80,58 +62,10 @@ function get_command_param_num(command: string): number {
 const LEFT_CURLY_BRACKET: TexToken = new TexToken(TexTokenType.CONTROL, '{');
 const RIGHT_CURLY_BRACKET: TexToken = new TexToken(TexTokenType.CONTROL, '}');
 
-function find_closing_curly_bracket(tokens: TexToken[], start: number): number {
-    assert(tokens[start].eq(LEFT_CURLY_BRACKET));
-    let count = 1;
-    let pos = start + 1;
-
-    while (count > 0) {
-        if (pos >= tokens.length) {
-            throw new LatexParserError('Unmatched curly brackets');
-        }
-        if (tokens[pos].eq(LEFT_CURLY_BRACKET)) {
-            count += 1;
-        } else if (tokens[pos].eq(RIGHT_CURLY_BRACKET)) {
-            count -= 1;
-        }
-        pos += 1;
-    }
-
-    return pos - 1;
-}
 
 const LEFT_SQUARE_BRACKET: TexToken = new TexToken(TexTokenType.ELEMENT, '[');
 const RIGHT_SQUARE_BRACKET: TexToken = new TexToken(TexTokenType.ELEMENT, ']');
 
-function find_closing_square_bracket(tokens: TexToken[], start: number): number {
-    assert(tokens[start].eq(LEFT_SQUARE_BRACKET));
-    let count = 1;
-    let pos = start + 1;
-
-    while (count > 0) {
-        if (pos >= tokens.length) {
-            throw new LatexParserError('Unmatched square brackets');
-        }
-        if (tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
-            count += 1;
-        } else if (tokens[pos].eq(RIGHT_SQUARE_BRACKET)) {
-            count -= 1;
-        }
-        pos += 1;
-    }
-
-    return pos - 1;
-}
-
-
-function isalpha(char: string): boolean {
-    return 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.includes(char);
-}
-
-function isdigit(char: string): boolean {
-    return '0123456789'.includes(char);
-}
-
 function eat_whitespaces(tokens: TexToken[], start: number): TexToken[] {
     let pos = start;
     while (pos < tokens.length && [TexTokenType.SPACE, TexTokenType.NEWLINE].includes(tokens[pos].type)) {
@@ -170,20 +104,18 @@ function eat_command_name(latex: string, start: number): string {
 }
 
 
-const LEFT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\left');
-const RIGHT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\right');
-
-function find_closing_right_command(tokens: TexToken[], start: number): number {
+function find_closing_match(tokens: TexToken[], start: number, leftToken: TexToken, rightToken: TexToken): number {
+    assert(tokens[start].eq(leftToken));
     let count = 1;
-    let pos = start;
+    let pos = start + 1;
 
     while (count > 0) {
         if (pos >= tokens.length) {
             return -1;
         }
-        if (tokens[pos].eq(LEFT_COMMAND)) {
+        if (tokens[pos].eq(leftToken)) {
             count += 1;
-        } else if (tokens[pos].eq(RIGHT_COMMAND)) {
+        } else if (tokens[pos].eq(rightToken)) {
             count -= 1;
         }
         pos += 1;
@@ -193,27 +125,20 @@ function find_closing_right_command(tokens: TexToken[], start: number): number {
 }
 
 
+const LEFT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\left');
+const RIGHT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\right');
+
+function find_closing_right_command(tokens: TexToken[], start: number): number {
+    return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
+}
+
+
 const BEGIN_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\begin');
 const END_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\end');
 
 
 function find_closing_end_command(tokens: TexToken[], start: number): number {
-    let count = 1;
-    let pos = start;
-
-    while (count > 0) {
-        if (pos >= tokens.length) {
-            return -1;
-        }
-        if (tokens[pos].eq(BEGIN_COMMAND)) {
-            count += 1;
-        } else if (tokens[pos].eq(END_COMMAND)) {
-            count -= 1;
-        }
-        pos += 1;
-    }
-
-    return pos - 1;
+    return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
 }
 
 function find_closing_curly_bracket_char(latex: string, start: number): number {
@@ -297,6 +222,7 @@ export function tokenize(latex: string): TexToken[] {
                 if (['\\\\', '\\,'].includes(firstTwoChars)) {
                     token = new TexToken(TexTokenType.CONTROL, firstTwoChars);
                 } else if (['\\{','\\}', '\\%', '\\$', '\\&', '\\#', '\\_', '\\|'].includes(firstTwoChars)) {
+                    // \| is double vertical bar, not the same as just |
                     token = new TexToken(TexTokenType.ELEMENT, firstTwoChars);
                 } else {
                     const command = eat_command_name(latex, pos + 1);
@@ -493,7 +419,7 @@ export class LatexParser {
                 const controlChar = firstToken.value;
                 switch (controlChar) {
                     case '{':
-                        const posClosingBracket = find_closing_curly_bracket(tokens, start);
+                        const posClosingBracket = find_closing_match(tokens, start, LEFT_CURLY_BRACKET, RIGHT_CURLY_BRACKET);
                         const exprInside = tokens.slice(start + 1, posClosingBracket);
                         return [this.parse(exprInside), posClosingBracket + 1];
                     case '}':
@@ -502,12 +428,9 @@ export class LatexParser {
                         return [new TexNode('control', '\\\\'), start + 1];
                     case '\\,':
                         return [new TexNode('control', '\\,'), start + 1];
-                    case '_': {
-                        return [ EMPTY_NODE, start];
-                    }
-                    case '^': {
+                    case '_':
+                    case '^':
                         return [ EMPTY_NODE, start];
-                    }
                     case '&':
                         return [new TexNode('control', '&'), start + 1];
                     default:
@@ -540,7 +463,7 @@ export class LatexParser {
             case 1: {
                 if (command === '\\sqrt' && pos < tokens.length && tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
                     const posLeftSquareBracket = pos;
-                    const posRightSquareBracket = find_closing_square_bracket(tokens, pos);
+                    const posRightSquareBracket = find_closing_match(tokens, pos, LEFT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET);
                     const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
                     const exponent = this.parse(exprInside);
                     const [arg1, newPos] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
@@ -584,7 +507,7 @@ export class LatexParser {
         }
         pos++;
         const exprInsideStart = pos;
-        const idx = find_closing_right_command(tokens, pos);
+        const idx = find_closing_right_command(tokens, start);
         if (idx === -1) {
             throw new LatexParserError('No matching \\right');
         }
@@ -627,7 +550,7 @@ export class LatexParser {
         
         const exprInsideStart = pos;
 
-        const endIdx = find_closing_end_command(tokens, pos);
+        const endIdx = find_closing_end_command(tokens, start);
         if (endIdx === -1) {
             throw new LatexParserError('No matching \\end');
         }

package/src/tex-writer.ts

@@ -0,0 +1,249 @@
+import { array_includes, array_split } from "./generic";
+import { reverseSymbolMap } from "./map";
+import { TexNode, TexToken, TexSqrtData, TexSupsubData, TexTokenType, TypstNode, TypstSupsubData } from "./types";
+
+const TYPST_UNARY_FUNCTIONS: string[] = [
+    'sqrt',
+    'bold',
+    'arrow',
+    'upright',
+    'lr',
+    'op',
+    'macron',
+    'dot',
+    'dot.double',
+    'hat',
+    'tilde',
+    'overline',
+    'underline',
+    'bb',
+    'cal',
+    'frak',
+];
+
+const TYPST_BINARY_FUNCTIONS: string[] = [
+    'frac',
+    'root',
+    'overbrace',
+    'underbrace',
+];
+
+function apply_escape_if_needed(c: string) {
+    if (['{', '}', '%'].includes(c)) {
+        return '\\' + c;
+    }
+    return c;
+}
+
+
+export class TexWriter {
+    protected buffer: string = "";
+    queue: TexToken[] = [];
+
+    private writeBuffer(token: TexToken) {
+        const str = token.toString();
+
+        let no_need_space = false;
+        if (token.type === TexTokenType.SPACE) {
+            no_need_space = true;
+        } else {
+            // putting the first token in clause
+            no_need_space ||= /[{\(\[\|]$/.test(this.buffer);
+            // opening a optional [] parameter for a command
+            no_need_space ||= /\\\w+$/.test(this.buffer) && str === '[';
+            // putting a punctuation
+            no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
+            no_need_space ||= ['\\{', '\\}'].includes(str);
+            // putting a prime
+            no_need_space ||= str === "'";
+            // putting a subscript or superscript
+            no_need_space ||= this.buffer.endsWith('_') || this.buffer.endsWith('^');
+            // buffer ends with a whitespace
+            no_need_space ||= /\s$/.test(this.buffer);
+            // token starts with a space
+            no_need_space ||= /^\s/.test(str);
+            // buffer is empty
+            no_need_space ||= this.buffer === '';
+            // leading sign. e.g. produce "+1" instead of " +1"
+            no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === '-' || this.buffer === '+';
+            // "&=" instead of "& ="
+            no_need_space ||= this.buffer.endsWith('&') && str === '=';
+        }
+
+        if (!no_need_space) {
+            this.buffer += ' ';
+        }
+        this.buffer += str;
+    }
+
+    public append(node: TexNode) {
+        const alignment_char = new TexNode('control', '&');
+        const newline_char = new TexNode('control', '\\\\');
+
+        if (node.type === 'ordgroup' && array_includes(node.args!, alignment_char)) {
+            // wrap the whole math formula with \begin{aligned} and \end{aligned}
+            const rows = array_split(node.args!, newline_char);
+            const data: TexNode[][] = [];
+            for(const row of rows) {
+                const cells = array_split(row, alignment_char);
+                data.push(cells.map(cell => new TexNode('ordgroup', '', cell)));
+            }
+            node = new TexNode('beginend', 'aligned', [], data);
+        }
+        this.queue = this.queue.concat(node.serialize());
+    }
+
+    protected flushQueue() {
+        for (let i = 0; i < this.queue.length; i++) {
+            this.writeBuffer(this.queue[i]);
+        }
+        this.queue = [];
+    }
+
+    public finalize(): string {
+        this.flushQueue();
+        return this.buffer;
+    }
+}
+
+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 'empty':
+            return new TexNode('empty', '');
+        case 'whitespace':
+            return new TexNode('whitespace', node.content);
+        case 'atom':
+            // special hook for colon
+            if (node.content === ':') {
+                return new TexNode('symbol', '\\colon');
+            }
+            return new TexNode('element', node.content);
+        case 'symbol':
+            // special hook for comma
+            if (node.content === 'comma') {
+                return new TexNode('element', ',');
+            }
+            return new TexNode('symbol', typst_token_to_tex(node.content));
+        case 'text':
+            return new TexNode('text', node.content);
+        case 'comment':
+            return new TexNode('comment', node.content);
+        case 'group': {
+            const args = node.args!.map(convert_typst_node_to_tex);
+            if(node.content === 'parenthesis') {
+                args.unshift(new TexNode('element', '('));
+                args.push(new TexNode('element', ')'));
+            }
+            return new TexNode('ordgroup', '', 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);
+                        return new TexNode('ordgroup', '', [
+                            new TexNode('element', '\\left' + left_delim),
+                            ...body.args!.slice(1, body.args!.length - 1).map(convert_typst_node_to_tex),
+                            new TexNode('element', '\\right' + right_delim)
+                        ]);
+                    }
+                }
+                const command = typst_token_to_tex(node.content);
+                return new TexNode('unaryFunc', command, node.args!.map(convert_typst_node_to_tex));
+            } else if (TYPST_BINARY_FUNCTIONS.includes(node.content)) {
+                // 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);
+                }
+                const command = typst_token_to_tex(node.content);
+                return new TexNode('binaryFunc', command, 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', '('),
+                    ...node.args!.map(convert_typst_node_to_tex),
+                    new TexNode('element', ')')
+                ])
+            }
+        }
+        case 'supsub': {
+            const { base, sup, sub } = node.data as TypstSupsubData;
+            const base_tex = convert_typst_node_to_tex(base);
+            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 res = new TexNode('supsub', '', [], {
+                base: base_tex,
+                sup: sup_tex,
+                sub: sub_tex
+            });
+            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 matrix = new TexNode('beginend', 'matrix', [], tex_data);
+            return new TexNode('ordgroup', '', [
+                new TexNode('element', '\\left('),
+                matrix,
+                new TexNode('element', '\\right)')
+            ]);
+        }
+        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);
+            }
+        }
+        case 'fraction': {
+            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]);
+        }
+        default:
+            throw new Error('[convert_typst_node_to_tex] Unimplemented type: ' + node.type);
+    }
+}
+
+export function typst_token_to_tex(token: string): string {
+    if (/^[a-zA-Z0-9]$/.test(token)) {
+        return token;
+    } else if (token === 'thin') {
+        return '\\,';
+    } else if (reverseSymbolMap.has(token)) {
+        return '\\' + reverseSymbolMap.get(token)!;
+    }
+    return '\\' + token;
+}

package/src/tex2typst.ts

@@ -2,8 +2,9 @@
  * This file is the entry point for bundling the .js file for the browser.
  */
 
-import { tex2typst } from './index';
+import { tex2typst, typst2tex } from './index';
 
 if(typeof window !== 'undefined') {
     (window as any).tex2typst = tex2typst;
+    (window as any).typst2tex = typst2tex;
 }