tex2typst 0.3.0-beta-4 → 0.3.0-beta-6

package/src/tex-writer.ts

@@ -1,39 +1,6 @@
 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;
-}
+import { TexNode, TexToken, TexSupsubData, TexTokenType } from "./types";
 
 
 export class TexWriter {
@@ -106,184 +73,3 @@ export class TexWriter {
     }
 }
 
-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':
-            return new TexNode('element', node.content);
-        case 'symbol':
-            switch(node.content) {
-                // special hook for comma
-                case 'comma':
-                    return new TexNode('element', ',');
-                // special hook for hyph and hyph.minus
-                case 'hyph':
-                case 'hyph.minus':
-                    return new TexNode('text', '-');
-                default:
-                    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);
-            let left_delim = "\\left(";
-            let right_delim = "\\right)";
-            if (node.options) {
-                if('delim' in node.options) {
-                    switch (node.options.delim) {
-                        case '#none':
-                            return matrix;
-                        case '[':
-                            left_delim = "\\left[";
-                            right_delim = "\\right]";
-                            break;
-                        case ']':
-                            left_delim = "\\left]";
-                            right_delim = "\\right[";
-                            break;
-                        case '{':
-                            left_delim = "\\left\\{";
-                            right_delim = "\\right\\}";
-                            break;
-                        case '}':
-                            left_delim = "\\left\\}";
-                            right_delim = "\\right\\{";
-                            break;
-                        case '|':
-                            left_delim = "\\left|";
-                            right_delim = "\\right|";
-                            break;
-                        case ')':
-                            left_delim = "\\left)";
-                            right_delim = "\\right(";
-                        case '(':
-                        default:
-                            left_delim = "\\left(";
-                            right_delim = "\\right)";
-                            break;
-                    }
-                }
-            }
-            return new TexNode('ordgroup', '', [
-                new TexNode('element', left_delim),
-                matrix,
-                new TexNode('element', right_delim)
-            ]);
-        }
-        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/types.ts

@@ -122,8 +122,17 @@ export class TexNode {
                 }
                 return tokens;
             }
-            case 'ordgroup':
-                return this.args!.map((n) => n.serialize()).flat();
+            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;
+            }
             case 'unaryFunc': {
                 let tokens: TexToken[] = [];
                 tokens.push(new TexToken(TexTokenType.COMMAND, this.content));
@@ -229,6 +238,34 @@ 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 {
@@ -347,6 +384,7 @@ export interface Tex2TypstOptions {
     nonStrict?: boolean; // default is true
     preferTypstIntrinsic?: boolean; // default is true,
     keepSpaces?: boolean; // default is false
+    fracToSlash?: boolean; // default is true
     customTexMacros?: { [key: string]: string };
     // TODO: custom typst functions
 }

package/src/{writer.ts → typst-writer.ts}

@@ -1,9 +1,8 @@
-import { symbolMap } from "./map";
-import { TexNode, TexSqrtData, TexSupsubData, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TexNode, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 
 
 // symbols that are supported by Typst but not by KaTeX
-const TYPST_INTRINSIC_SYMBOLS = [
+export const TYPST_INTRINSIC_SYMBOLS = [
     'dim',
     'id',
     'im',
@@ -20,48 +19,6 @@ function is_delimiter(c: TypstNode): boolean {
 }
 
 
-// \overset{X}{Y} -> op(Y, limits: #true)^X
-// and with special case \overset{\text{def}}{=} -> eq.def
-function convert_overset(node: TexNode): TypstNode {
-    const [sup, base] = node.args!;
-
-    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');
-    }
-    const op_call = new TypstNode(
-        'funcCall',
-        'op',
-        [convertTree(base)]
-    );
-    op_call.setOptions({ limits: '#true' });
-    return new TypstNode(
-        'supsub',
-        '',
-        [],
-        {
-            base: op_call,
-            sup: convertTree(sup),
-        }
-    );
-}
-
 const TYPST_LEFT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '(');
 const TYPST_RIGHT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ')');
 const TYPST_COMMA: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ',');
@@ -106,8 +63,10 @@ export class TypstWriter {
         no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
         // closing a clause
         no_need_space ||= /^[})\]\|]$/.test(str);
+        // putting the opening '(' for a function
+        no_need_space ||= /[^=]$/.test(this.buffer) && str === '(';
         // putting punctuation
-        no_need_space ||= /^[(_^,;!]$/.test(str);
+        no_need_space ||= /^[_^,;!]$/.test(str);
         // putting a prime
         no_need_space ||= str === "'";
         // continue a number
@@ -122,6 +81,8 @@ export class TypstWriter {
         no_need_space ||= /^\s/.test(str);
         // "&=" instead of "& ="
         no_need_space ||= this.buffer.endsWith('&') && str === '=';
+        // before or after a slash e.g. "a/b" instead of "a / b"
+        no_need_space ||= this.buffer.endsWith('/') || str === '/';
         // other cases
         no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
         if (!no_need_space) {
@@ -218,6 +179,25 @@ export class TypstWriter {
                 this.insideFunctionDepth--;
                 break;
             }
+            case 'fraction': {
+                const [numerator, denominator] = node.args!;
+                if(numerator.type === 'group') {
+                    this.queue.push(TYPST_LEFT_PARENTHESIS);
+                    this.serialize(numerator);
+                    this.queue.push(TYPST_RIGHT_PARENTHESIS);
+                } else {
+                    this.serialize(numerator);
+                }
+                this.queue.push(new TypstToken(TypstTokenType.ELEMENT, '/'));
+                if(denominator.type === 'group') {
+                    this.queue.push(TYPST_LEFT_PARENTHESIS);
+                    this.serialize(denominator);
+                    this.queue.push(TYPST_RIGHT_PARENTHESIS);
+                } else {
+                    this.serialize(denominator);
+                }
+                break;
+            }
             case 'align': {
                 const matrix = node.data as TypstNode[][];
                 matrix.forEach((row, i) => {
@@ -355,210 +335,3 @@ export class TypstWriter {
         return this.buffer;
     }
 }
-
-// Convert a tree of TexNode into a tree of TypstNode
-export function convertTree(node: TexNode): TypstNode {
-    switch (node.type) {
-        case 'empty':
-            return new TypstNode('empty', '');
-        case 'whitespace':
-            return new TypstNode('whitespace', node.content);
-        case 'ordgroup':
-            return new TypstNode(
-                'group',
-                '',
-                node.args!.map(convertTree),
-            );
-        case 'element':
-            return new TypstNode('atom', convertToken(node.content));
-        case 'symbol':
-            return new TypstNode('symbol', convertToken(node.content));
-        case 'text':
-            return new TypstNode('text', node.content);
-        case 'comment':
-            return new TypstNode('comment', node.content);
-        case 'supsub': {
-            let { base, sup, sub } = node.data as TexSupsubData;
-
-            // Special logic for overbrace
-            if (base && base.type === 'unaryFunc' && base.content === '\\overbrace' && sup) {
-                return new TypstNode(
-                    'funcCall',
-                    'overbrace',
-                    [convertTree(base.args![0]), convertTree(sup)],
-                );
-            } else if (base && base.type === 'unaryFunc' && base.content === '\\underbrace' && sub) {
-                return new TypstNode(
-                    'funcCall',
-                    'underbrace',
-                    [convertTree(base.args![0]), convertTree(sub)],
-                );
-            }
-
-            const data: TypstSupsubData = {
-                base: convertTree(base),
-            };
-            if (data.base.type === 'empty') {
-                data.base = new TypstNode('text', '');
-            }
-
-            if (sup) {
-                data.sup = convertTree(sup);
-            }
-
-            if (sub) {
-                data.sub = convertTree(sub);
-            }
-
-            return new TypstNode('supsub', '', [], data);
-        }
-        case 'leftright': {
-            const [left, body, right] = node.args!;
-            // These pairs will be handled by Typst compiler by default. No need to add lr()
-            const group: TypstNode = new TypstNode(
-                'group',
-                '',
-                node.args!.map(convertTree),
-            );
-            if ([
-                "[]", "()", "\\{\\}",
-                "\\lfloor\\rfloor",
-                "\\lceil\\rceil",
-                "\\lfloor\\rceil",
-            ].includes(left.content + right.content)) {
-                return group;
-            }
-            // "\left\{ A \right." -> "{A"
-            // "\left. A \right\}" -> "lr( A} )"
-            if(right.content === '.') {
-                group.args!.pop();
-                return group;
-            } else if(left.content === '.') {
-                group.args!.shift();
-                return new TypstNode( 'funcCall', 'lr', [group]); 
-            }
-            return new TypstNode(
-                'funcCall',
-                'lr',
-                [group],
-            );
-        }
-        case 'binaryFunc': {
-            if (node.content === '\\overset') {
-                return convert_overset(node);
-            }
-            return new TypstNode(
-                'funcCall',
-                convertToken(node.content),
-                node.args!.map(convertTree),
-            );
-        }
-        case 'unaryFunc': {
-            const arg0 = convertTree(node.args![0]);
-            // \sqrt{3}{x} -> root(3, x)
-            if (node.content === '\\sqrt' && node.data) {
-                const data = convertTree(node.data as TexSqrtData); // the number of times to take the root
-                return new TypstNode(
-                    'funcCall',
-                    'root',
-                    [data, arg0],
-                );
-            }
-            // \mathbf{a} -> upright(mathbf(a))
-            if (node.content === '\\mathbf') {
-                const inner: TypstNode = new TypstNode(
-                    'funcCall',
-                    'bold',
-                    [arg0],
-                );
-                return new TypstNode(
-                    'funcCall',
-                    'upright',
-                    [inner],
-                );
-            }
-            // \mathbb{R} -> RR
-            if (node.content === '\\mathbb' && arg0.type === 'atom' && /^[A-Z]$/.test(arg0.content)) {
-                return new TypstNode('symbol', arg0.content + arg0.content);
-            }
-            // \operatorname{opname} -> op("opname")
-            if (node.content === '\\operatorname') {
-                const body = node.args!;
-                if (body.length !== 1 || body[0].type !== 'text') {
-                    throw new TypstWriterError(`Expecting body of \\operatorname to be text but got`, node);
-                }
-                const text = body[0].content;
-
-                if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
-                    return new TypstNode('symbol', text);
-                } else {
-                    return new TypstNode(
-                        'funcCall',
-                        'op',
-                        [new TypstNode('text', text)],
-                    );
-                }
-            }
-
-            // generic case
-            return new TypstNode(
-                'funcCall',
-                convertToken(node.content),
-                node.args!.map(convertTree),
-            );
-        }
-        case 'beginend': {
-            const matrix = node.data as TexNode[][];
-            const data = matrix.map((row) => row.map(convertTree));
-
-            if (node.content!.startsWith('align')) {
-                // align, align*, alignat, alignat*, aligned, etc.
-                return new TypstNode( 'align', '', [], data);
-            } else {
-                const res = new TypstNode('matrix', '', [], data);
-                res.setOptions({'delim': '#none'});
-                return res;
-            }
-        }
-        case 'unknownMacro':
-            return new TypstNode('unknown', convertToken(node.content));
-        case 'control':
-            if (node.content === '\\\\') {
-                return new TypstNode('symbol', '\\');
-            } else if (node.content === '\\,') {
-                return new TypstNode('symbol', 'thin');
-            } else {
-                throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
-            }
-        default:
-            throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
-    }
-}
-
-
-function convertToken(token: string): string {
-    if (/^[a-zA-Z0-9]$/.test(token)) {
-        return token;
-    } else if (token === '/') {
-        return '\\/';
-    } else if (token === '\\|') {
-        // \| in LaTeX is double vertical bar looks like ||
-        return 'parallel';
-    } else if (token === '\\\\') {
-        return '\\';
-    } else if (['\\$', '\\#', '\\&', '\\_'].includes(token)) {
-        return token;
-    } else if (token.startsWith('\\')) {
-        const symbol = token.slice(1);
-        if (symbolMap.has(symbol)) {
-            return symbolMap.get(symbol)!;
-        } else {
-            // 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 token;
-}
-