tex2typst 0.3.0 → 0.3.2

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,29 +1,33 @@
-import { TexNode, TypstNode, 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 { TexNode, TypstNode, TypstPrimitiveValue, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+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, ',');
 const TYPST_NEWLINE: TypstToken = new TypstToken(TypstTokenType.SYMBOL, '\n');
 
+function typst_primitive_to_string(value: TypstPrimitiveValue) {
+    switch (typeof value) {
+        case 'string':
+            return `"${value}"`;
+        case 'number':
+            return (value as number).toString();
+        case 'boolean':
+            return (value as boolean) ? '#true' : '#false';
+        default:
+            if (value === null) {
+                return '#none';
+            } else if (value instanceof TypstToken) {
+                return value.toString();
+            }
+            throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
+    }
+}
+
 export class TypstWriterError extends Error {
     node: TexNode | TypstNode | TypstToken;
 
@@ -34,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;
     }
 
 
@@ -58,6 +71,8 @@ export class TypstWriter {
             return;
         }
 
+        // TODO: "C \frac{xy}{z}" should translate to "C (x y)/z" instead of "C(x y)/z"
+
         let no_need_space = false;
         // putting the first token in clause
         no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
@@ -105,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;
@@ -172,7 +197,8 @@ export class TypstWriter {
                 }
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `, ${key}: ${value}`));
+                        const value_str = typst_primitive_to_string(value);
+                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `, ${key}: ${value_str}`));
                     }
                 }
                 this.queue.push(TYPST_RIGHT_PARENTHESIS);
@@ -220,7 +246,8 @@ export class TypstWriter {
                 this.queue.push(TYPST_LEFT_PARENTHESIS);
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value}, `));
+                        const value_str = typst_primitive_to_string(value);
+                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value_str}, `));
                     }
                 }
                 matrix.forEach((row, i) => {

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')