tex2typst 0.3.1 → 0.3.2

package/src/convert.ts

@@ -1,7 +1,18 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue } from "./types";
-import { TypstWriterError, TYPST_INTRINSIC_SYMBOLS } from "./typst-writer";
+import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType } from "./types";
+import { TypstWriterError } from "./typst-writer";
 import { symbolMap, reverseSymbolMap } from "./map";
 
+// symbols that are supported by Typst but not by KaTeX
+const TYPST_INTRINSIC_SYMBOLS = [
+    'dim',
+    'id',
+    'im',
+    'mod',
+    'Pr',
+    'sech',
+    'csch',
+    // 'sgn
+];
 
 function tex_token_to_typst(token: string): string {
     if (/^[a-zA-Z0-9]$/.test(token)) {
@@ -260,22 +271,8 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
                         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 ]);
+                        delim = new TypstToken(TypstTokenType.SYMBOL, 'bar.v.double');
+                        break;
                     }
                     default:
                         throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);

package/src/index.ts

@@ -1,6 +1,6 @@
 import { parseTex } from "./tex-parser";
 import type { Tex2TypstOptions } from "./types";
-import { TypstWriter } from "./typst-writer";
+import { TypstWriter, type TypstWriterOptions } from "./typst-writer";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
 import { symbolMap } from "./map";
 import { parseTypst } from "./typst-parser";
@@ -11,27 +11,24 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     const opt: Tex2TypstOptions = {
         nonStrict: true,
         preferTypstIntrinsic: true,
+        preferShorthands: true,
         keepSpaces: false,
         fracToSlash: true,
+        inftyToOo: false,
         customTexMacros: {}
     };
-    if (options) {
-        if (options.nonStrict) {
-            opt.nonStrict = options.nonStrict;
-        }
-        if (options.preferTypstIntrinsic) {
-            opt.preferTypstIntrinsic = options.preferTypstIntrinsic;
-        }
-        if (options.customTexMacros) {
-            opt.customTexMacros = options.customTexMacros;
-        }
-        if (options.fracToSlash !== undefined) {
-            opt.fracToSlash = options.fracToSlash;
+
+    if(options !== undefined) {
+        for (const key in opt) {
+            if (options[key] !== undefined) {
+                opt[key] = options[key];
+            }
         }
     }
+
     const texTree = parseTex(tex, opt.customTexMacros!);
     const typstTree = convert_tex_node_to_typst(texTree, opt);
-    const writer = new TypstWriter(opt.nonStrict!, opt.preferTypstIntrinsic!, opt.keepSpaces!);
+    const writer = new TypstWriter(opt as TypstWriterOptions);
     writer.serialize(typstTree);
     return writer.finalize();
 }

package/src/map.ts

@@ -1,4 +1,16 @@
 const symbolMap = new Map<string, string>([
+    ['cos', 'cos'],
+    ['sin', 'sin'],
+    ['tan', 'tan'],
+    ['cot', 'cot'],
+    ['sec', 'sec'],
+    ['csc', 'csc'],
+    ['mod', 'mod'],
+    ['omicron', 'omicron'],
+    ['Xi', 'Xi'],
+    ['Upsilon', 'Upsilon'],
+    ['lim', 'lim'],
+
     ['nonumber', ''],
     ['vec', 'arrow'],
     ['neq', 'eq.not'],
@@ -59,37 +71,11 @@ const symbolMap = new Map<string, string>([
 
     /* arrows */
     ['gets', 'arrow.l'],
-    ['hookleftarrow', 'arrow.l.hook'],
-    ['leftharpoonup', 'harpoon.lt'],
-    ['leftharpoondown', 'harpoon.lb'],
-    ['rightleftharpoons', 'harpoons.rtlb'],
-    ['longleftarrow', 'arrow.l.long'],
-    ['longrightarrow', 'arrow.r.long'],
-    ['longleftrightarrow', 'arrow.l.r.long'],
-    ['Longleftarrow', 'arrow.l.double.long'],
-    ['Longrightarrow', 'arrow.r.double.long'],
-    ['Longleftrightarrow', 'arrow.l.r.double.long'],
     // ['longmapsto', 'arrow.r.bar'],
-    ['hookrightarrow', 'arrow.r.hook'],
-    ['rightharpoonup', 'harpoon.rt'],
-    ['rightharpoondown', 'harpoon.rb'],
     ['iff', 'arrow.l.r.double.long'],
     ['implies', 'arrow.r.double.long'],
-    ['uparrow', 'arrow.t'],
-    ['downarrow', 'arrow.b'],
-    ['updownarrow', 'arrow.t.b'],
-    ['Uparrow', 'arrow.t.double'],
-    ['Downarrow', 'arrow.b.double'],
-    ['Updownarrow', 'arrow.t.b.double'],
-    ['nearrow', 'arrow.tr'],
-    ['searrow', 'arrow.br'],
-    ['swarrow', 'arrow.bl'],
-    ['nwarrow', 'arrow.tl'],
     ['leadsto', 'arrow.squiggly'],
 
-    ['leftleftarrows', 'arrows.ll'],
-    ['rightrightarrows', 'arrows.rr'],
-
 
     ['Cap', 'sect.double'], 
     ['Cup', 'union.double'], 
@@ -97,9 +83,6 @@ const symbolMap = new Map<string, string>([
     ['Gamma', 'Gamma'], 
     ['Join', 'join'], 
     ['Lambda', 'Lambda'], 
-    ['Leftarrow', 'arrow.l.double'],
-    ['Leftrightarrow', 'arrow.l.r.double'],
-    ['Longrightarrow', 'arrow.r.double.long'], 
     ['Omega', 'Omega'], 
     ['P', 'pilcrow'], 
     ['Phi', 'Phi'], 
@@ -153,7 +136,6 @@ const symbolMap = new Map<string, string>([
     ['div', 'div'], 
     ['divideontimes', 'times.div'], 
     ['dotplus', 'plus.dot'], 
-    ['downarrow', 'arrow.b'], 
     ['ell', 'ell'], 
     ['emptyset', 'nothing'], 
     ['epsilon', 'epsilon.alt'], 
@@ -186,8 +168,6 @@ const symbolMap = new Map<string, string>([
     ['lbrack', 'bracket.l'], 
     ['ldots', 'dots.h'], 
     ['le', 'lt.eq'], 
-    ['leadsto', 'arrow.squiggly'], 
-    ['leftarrow', 'arrow.l'], 
     ['leftthreetimes', 'times.three.l'], 
     ['leftrightarrow', 'arrow.l.r'], 
     ['leq', 'lt.eq'], 
@@ -224,7 +204,6 @@ const symbolMap = new Map<string, string>([
     ['nu', 'nu'], 
     ['ntriangleleft', 'lt.tri.not'],
     ['ntriangleright', 'gt.tri.not'],
-    ['nwarrow', 'arrow.tl'],
     ['odot', 'dot.circle'], 
     ['oint', 'integral.cont'], 
     ['oiint', 'integral.surf'],
@@ -277,7 +256,6 @@ const symbolMap = new Map<string, string>([
     ['supset', 'supset'], 
     ['supseteq', 'supset.eq'], 
     ['supsetneq', 'supset.neq'], 
-    ['swarrow', 'arrow.bl'], 
     ['tau', 'tau'], 
     ['theta', 'theta'], 
     ['times', 'times'], 
@@ -288,8 +266,6 @@ const symbolMap = new Map<string, string>([
     // ['triangleleft', 'triangle.l.small'], 
     // ['triangleright', 'triangle.r.small'], 
     ['twoheadrightarrow', 'arrow.r.twohead'], 
-    ['uparrow', 'arrow.t'], 
-    ['updownarrow', 'arrow.t.b'], 
     ['upharpoonright', 'harpoon.tr'], 
     ['uplus', 'union.plus'], 
     ['upsilon', 'upsilon'], 
@@ -1086,6 +1062,7 @@ for(const [key, value] of Array.from(symbolMap.entries()).reverse()) {
     reverseSymbolMap.set(value, key);
 }
 reverseSymbolMap.set('dif', 'mathrm{d}');
+reverseSymbolMap.set('oo', 'infty');
 
 // force override some one-to-multiple mappings
 const typst_to_tex_map = new Map<string, string>([

package/src/types.ts

@@ -352,7 +352,7 @@ export type TypstArrayData = TypstNode[][];
 type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace'
             | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'unknown';
 
-export type TypstPrimitiveValue = string | boolean | null;
+export type TypstPrimitiveValue = string | boolean | null | TypstToken;
 export type TypstNamedParams = { [key: string]: TypstPrimitiveValue };
 
 // #none
@@ -389,8 +389,10 @@ export class TypstNode {
 export interface Tex2TypstOptions {
     nonStrict?: boolean; // default is true
     preferTypstIntrinsic?: boolean; // default is true,
+    preferShorthands?: boolean; // default is true
     keepSpaces?: boolean; // default is false
     fracToSlash?: boolean; // default is true
+    inftyToOo?: boolean; // default is false
     customTexMacros?: { [key: string]: string };
     // TODO: custom typst functions
 }

package/src/typst-parser.ts

@@ -2,6 +2,13 @@
 import { array_find } from "./generic";
 import { TYPST_NONE, TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 import { assert, isalpha, isdigit } from "./util";
+import { reverseShorthandMap } from "./typst-shorthands";
+
+
+
+const TYPST_EMPTY_NODE = new TypstNode('empty', '');
+
+const TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
 
 // TODO: In Typst, y' ' is not the same as y''.
 // The parser should be able to parse the former correctly.
@@ -22,8 +29,14 @@ function eat_identifier_name(typst: string, start: number): string {
     return typst.substring(start, pos);
 }
 
-
-const TYPST_EMPTY_NODE = new TypstNode('empty', '');
+function try_eat_shorthand(typst: string, start: number): string | null {
+    for (const shorthand of TYPST_SHORTHANDS) {
+        if (typst.startsWith(shorthand, start)) {
+            return shorthand;
+        }
+    }
+    return null;
+}
 
 
 export function tokenize_typst(typst: string): TypstToken[] {
@@ -115,6 +128,13 @@ export function tokenize_typst(typst: string): TypstToken[] {
                 break;
             }
             default: {
+                const shorthand = try_eat_shorthand(typst, pos);
+                if (shorthand !== null) {
+                    token = new TypstToken(TypstTokenType.SYMBOL, reverseShorthandMap.get(shorthand)!);
+                    pos += shorthand.length;
+                    break;
+                }
+
                 if (isdigit(firstChar)) {
                     let newPos = pos;
                     while (newPos < typst.length && isdigit(typst[newPos])) {

package/src/typst-shorthands.ts

@@ -0,0 +1,51 @@
+const shorthandMap = new Map<string, string>([
+    ['arrow.l.r.double.long', '<==>'],
+    ['arrow.l.r.long', '<-->'],
+    ['arrow.r.bar', '|->'],
+    ['arrow.r.double.bar', '|=>'],
+    ['arrow.r.double.long', '==>'],
+    ['arrow.r.long', '-->'],
+    ['arrow.r.long.squiggly', '~~>'],
+    ['arrow.r.tail', '>->'],
+    ['arrow.r.twohead', '->>'],
+    ['arrow.l.double.long', '<=='],
+    ['arrow.l.long', '<--'],
+    ['arrow.l.long.squiggly', '<~~'],
+    ['arrow.l.tail', '<-<'],
+    ['arrow.l.twohead', '<<-'],
+    ['arrow.l.r', '<->'],
+    ['arrow.l.r.double', '<=>'],
+    ['colon.double.eq', '::='],
+    ['dots.h', '...'],
+    ['gt.triple', '>>>'],
+    ['lt.triple', '<<<'],
+    ['arrow.r', '->'],
+    ['arrow.r.double', '=>'],
+    ['arrow.r.squiggly', '~>'],
+    ['arrow.l', '<-'],
+    ['arrow.l.squiggly', '<~'],
+    ['bar.v.double', '||'],
+    ['bracket.l.double', '[|'],
+    ['bracket.r.double', '|]'],
+    ['colon.eq', ':='],
+    ['eq.colon', '=:'],
+    ['eq.not', '!='],
+    ['gt.double', '>>'],
+    ['gt.eq', '>='],
+    ['lt.double', '<<'],
+    ['lt.eq', '<='],
+    ['ast.op', '*'],
+    ['minus', '-'],
+    ['tilde.op', '~'],
+]);
+
+
+const reverseShorthandMap = new Map<string, string>();
+for (const [key, value] of shorthandMap.entries()) {
+    // filter out single character values ('-', '~', '*')
+    if(value.length > 1) {
+        reverseShorthandMap.set(value, key);
+    }
+}
+
+export { shorthandMap, reverseShorthandMap };

package/src/typst-writer.ts

@@ -1,24 +1,10 @@
 import { TexNode, TypstNode, TypstPrimitiveValue, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
-
-
-// symbols that are supported by Typst but not by KaTeX
-export const TYPST_INTRINSIC_SYMBOLS = [
-    'dim',
-    'id',
-    'im',
-    'mod',
-    'Pr',
-    'sech',
-    'csch',
-    // 'sgn
-];
-
+import { shorthandMap } from "./typst-shorthands";
 
 function is_delimiter(c: TypstNode): boolean {
     return c.type === 'atom' && ['(', ')', '[', ']', '{', '}', '|', '⌊', '⌋', '⌈', '⌉'].includes(c.content);
 }
 
-
 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, ',');
@@ -35,6 +21,8 @@ function typst_primitive_to_string(value: TypstPrimitiveValue) {
         default:
             if (value === null) {
                 return '#none';
+            } else if (value instanceof TypstToken) {
+                return value.toString();
             }
             throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
     }
@@ -50,20 +38,29 @@ export class TypstWriterError extends Error {
     }
 }
 
+export interface TypstWriterOptions {
+    nonStrict: boolean;
+    preferShorthands: boolean;
+    keepSpaces: boolean;
+    inftyToOo: boolean;
+}
+
 export class TypstWriter {
     private nonStrict: boolean;
-    private preferTypstIntrinsic: boolean;
+    private preferShorthands: boolean;
     private keepSpaces: boolean;
+    private inftyToOo: boolean;
 
     protected buffer: string = "";
     protected queue: TypstToken[] = [];
 
     private insideFunctionDepth = 0;
 
-    constructor(nonStrict: boolean, preferTypstIntrinsic: boolean, keepSpaces: boolean) {
-        this.nonStrict = nonStrict;
-        this.preferTypstIntrinsic = preferTypstIntrinsic;
-        this.keepSpaces = keepSpaces;
+    constructor(opt: TypstWriterOptions) {
+        this.nonStrict = opt.nonStrict;
+        this.preferShorthands = opt.preferShorthands;
+        this.keepSpaces = opt.keepSpaces;
+        this.inftyToOo = opt.inftyToOo;
     }
 
 
@@ -123,9 +120,19 @@ export class TypstWriter {
                 }
                 break;
             }
-            case 'symbol':
-                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, node.content));
+            case 'symbol': {
+                let content = node.content;
+                if(this.preferShorthands) {
+                    if (shorthandMap.has(content)) {
+                        content = shorthandMap.get(content)!;
+                    }
+                }
+                if (this.inftyToOo && content === 'infinity') {
+                    content = 'oo';
+                }
+                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, content));
                 break;
+            }
             case 'text':
                 this.queue.push(new TypstToken(TypstTokenType.TEXT, node.content));
                 break;

package/tools/make-shorthand-map.py

@@ -0,0 +1,33 @@
+import urllib.request
+import html
+from bs4 import BeautifulSoup
+
+
+if __name__ == '__main__':
+    shorthand_map = []
+
+
+    url = "https://typst.app/docs/reference/symbols/"
+    with urllib.request.urlopen(url) as response:
+        html_text = response.read().decode('utf-8')
+
+    soup = BeautifulSoup(html_text, 'html.parser')
+
+    # <ul class="symbol-grid">
+    ul_list = soup.find_all('ul', class_='symbol-grid')
+    # ul_shorthands_markup = ul_list[0]
+    ul_shorthands_math = ul_list[1]
+
+    li_list = ul_shorthands_math.find_all('li')
+    for li in li_list:
+        # e.g. <li id="symbol-arrow.r" data-math-shorthand="-&gt;"><button>...</button></li>
+        # ==> typst = "arrow.r"
+        # ==> shorthand = "->"
+        typst = li['id'][7:]
+        shorthand = html.unescape(li['data-math-shorthand'])
+        shorthand_map.append((typst, shorthand))
+
+    # Sort by length of shorthand, order from longest to shortest
+    shorthand_map.sort(key=lambda x: len(x[1]), reverse=True)
+    for typst, shorthand in shorthand_map:
+        print(f"['{typst}', '{shorthand}'],")

package/tools/make-symbol-map.py

@@ -1,12 +1,13 @@
-import requests
+import urllib.request
 from bs4 import BeautifulSoup
 
-
 if __name__ == '__main__':
     symbol_map = {}
 
     url = "https://typst.app/docs/reference/symbols/sym/"
-    html_text = requests.get(url).text
+    with urllib.request.urlopen(url) as response:
+        html_text = response.read().decode('utf-8')
+
     soup = BeautifulSoup(html_text, 'html.parser')
     # <ul class="symbol-grid">
     ul = soup.find('ul', class_='symbol-grid')