tex2typst 0.2.11 → 0.2.13

package/src/parser.ts

@@ -41,6 +41,7 @@ const BINARY_COMMANDS = [
     'dbinom',
     'dfrac',
     'tbinom',
+    'overset',
 ]
 
 
@@ -295,7 +296,7 @@ export function tokenize(latex: string): Token[] {
                 const firstTwoChars = latex.slice(pos, pos + 2);
                 if (['\\\\', '\\,'].includes(firstTwoChars)) {
                     token = new Token(TokenType.CONTROL, firstTwoChars);
-                } else if (['\\{','\\}', '\\%', '\\$', '\\&', '\\#', '\\_'].includes(firstTwoChars)) {
+                } else if (['\\{','\\}', '\\%', '\\$', '\\&', '\\#', '\\_', '\\|'].includes(firstTwoChars)) {
                     token = new Token(TokenType.ELEMENT, firstTwoChars);
                 } else {
                     const command = eat_command_name(latex, pos + 1);

package/src/types.ts

@@ -47,6 +47,8 @@ export interface TypstNode {
     content: string;
     args?: TypstNode[];
     data?: TypstSupsubData | TypstArrayData;
+    // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
+    options?: { [key: string]: string };
 }
 
 export interface Tex2TypstOptions {

package/src/writer.ts

@@ -19,6 +19,54 @@ function is_delimiter(c: TypstNode): boolean {
     return c.type === 'atom' && ['(', ')', '[', ']', '{', '}', '|', '⌊', '⌋', '⌈', '⌉'].includes(c.content);
 }
 
+function text_node_shallow_eq(a: TexNode, b: TexNode): boolean {
+    return (a.type === b.type) && (a.content === b.content);
+}
+
+// \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.type === 'text' && n.content === '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: TexNode = { type: 'element', content: 'd' };
+            const e: TexNode = { type: 'element', content: 'e' };
+            const f: TexNode = { type: 'element', content: 'f' };
+            if(text_node_shallow_eq(a1, d) && text_node_shallow_eq(a2, e) && text_node_shallow_eq(a3, f)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const is_eq = (n: TexNode): boolean => (n.type === 'element' && n.content === '=');
+    if(is_def(sup) && is_eq(base)) {
+        return {
+            type: 'symbol',
+            content: 'eq.def',
+        };
+    }
+    const op_call: TypstNode = {
+        type: 'unaryFunc',
+        content: 'op',
+        args: [convertTree(base)],
+        options: { limits: '#true' },
+    };
+    return {
+        type: 'supsub',
+        content: '',
+        data: {
+            base: op_call,
+            sup: convertTree(sup),
+        },
+    }
+}
+
 export class TypstWriterError extends Error {
     node: TexNode | TypstNode;
 
@@ -148,6 +196,11 @@ export class TypstWriter {
                 this.insideFunctionDepth ++;
                 this.queue.push({ type: 'atom', content: '('});
                 this.append(arg0);
+                if(node.options) {
+                    for (const [key, value] of Object.entries(node.options)) {
+                        this.queue.push({ type: 'symbol', content: `, ${key}: ${value}`});
+                    }
+                }
                 this.queue.push({ type: 'atom', content: ')'});
                 this.insideFunctionDepth --;
                 break;
@@ -267,22 +320,22 @@ export class TypstWriter {
     public finalize(): string {
         this.flushQueue();
         const smartFloorPass = function (input: string): string {
-            // Use regex to replace all "⌊ xxx ⌋" with "floor(xxx)"
-            let res = input.replace(/⌊\s*(.*?)\s*⌋/g, "floor($1)");
+            // Use regex to replace all "floor.l xxx floor.r" with "floor(xxx)"
+            let res = input.replace(/floor\.l\s*(.*?)\s*floor\.r/g, "floor($1)");
             // Typst disallow "floor()" with empty argument, so add am empty string inside if it's empty.
             res = res.replace(/floor\(\)/g, 'floor("")');
             return res;
         };
         const smartCeilPass = function (input: string): string {
-            // Use regex to replace all "⌈ xxx ⌉" with "ceil(xxx)"
-            let res = input.replace(/⌈\s*(.*?)\s*⌉/g, "ceil($1)");
+            // Use regex to replace all "ceil.l xxx ceil.r" with "ceil(xxx)"
+            let res = input.replace(/ceil\.l\s*(.*?)\s*ceil\.r/g, "ceil($1)");
             // Typst disallow "ceil()" with empty argument, so add an empty string inside if it's empty.
             res = res.replace(/ceil\(\)/g, 'ceil("")');
             return res;
         }
         const smartRoundPass = function (input: string): string {
-            // Use regex to replace all "⌊ xxx ⌉" with "round(xxx)"
-            let res = input.replace(/⌊\s*(.*?)\s*⌉/g, "round($1)");
+            // Use regex to replace all "floor.l xxx ceil.r" with "round(xxx)"
+            let res = input.replace(/floor\.l\s*(.*?)\s*ceil\.r/g, "round($1)");
             // Typst disallow "round()" with empty argument, so add an empty string inside if it's empty.
             res = res.replace(/round\(\)/g, 'round("")');
             return res;
@@ -376,6 +429,9 @@ export function convertTree(node: TexNode): TypstNode {
             };
         }
         case 'binaryFunc': {
+            if (node.content === '\\overset') {
+                return convert_overset(node);
+            }
             return {
                 type: 'binaryFunc',
                 content: convertToken(node.content),
@@ -482,10 +538,13 @@ export function convertTree(node: TexNode): TypstNode {
 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 (token == '/') {
-        return '\\/';
     } else if (['\\$', '\\#', '\\&', '\\_'].includes(token)) {
         return token;
     } else if (token.startsWith('\\')) {

package/tools/make-symbol-map.py

@@ -0,0 +1,29 @@
+import requests
+from bs4 import BeautifulSoup
+
+
+if __name__ == '__main__':
+    symbol_map = {}
+
+    url = "https://typst.app/docs/reference/symbols/sym/"
+    html_text = requests.get(url).text
+    soup = BeautifulSoup(html_text, 'html.parser')
+    # <ul class="symbol-grid">
+    ul = soup.find('ul', class_='symbol-grid')
+    li_list = ul.find_all('li')
+    for li in li_list:
+        # e.g. <li id="symbol-brace.r.double" data-latex-name="\rBrace" data-codepoint="10628"><button>...</button></li>
+        # ==> latex = rBrace
+        # ==> typst = brace.r.double
+        # ==> unicode = 10628 = \u2984
+        latex = li.get('data-latex-name', None)
+        typst = li['id'][7:]
+        unicode = int(li['data-codepoint'])
+        if latex is not None:
+            # some latex macro can be associated with multiple typst
+            # e.g. \equiv can be mapped to equal or equiv.triple
+            # We only keep the first one
+            if latex not in symbol_map:
+                symbol_map[latex] = typst
+                # print(f"    ['{latex[1:]}', '{typst}'],")
+                print(f'{latex[1:]} = "{typst}"')