tex2typst 0.3.17 → 0.3.18

package/src/convert.ts

@@ -22,9 +22,6 @@ function tex_token_to_typst(token: string): string {
         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)) {
@@ -49,40 +46,52 @@ function tex_token_to_typst(token: string): string {
 function convert_overset(node: TexNode, options: Tex2TypstOptions): 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)) {
+    if (options.optimize) {
+        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');
         }
-        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 limits_call = new TypstNode(
         'funcCall',
         'limits',
         [convert_tex_node_to_typst(base, options)]
     );
-    return new TypstNode(
-        'supsub',
-        '',
-        [],
-        {
+    return new TypstNode('supsub', '', [], {
             base: limits_call,
             sup: convert_tex_node_to_typst(sup, options),
-        }
+    });
+}
+
+// \underset{X}{Y} -> limits(Y)_X
+function convert_underset(node: TexNode, options: Tex2TypstOptions): TypstNode {
+    const [sub, base] = node.args!;
+
+    const limits_call = new TypstNode(
+        'funcCall',
+        'limits',
+        [convert_tex_node_to_typst(base, options)]
     );
+    return new TypstNode('supsub', '', [], {
+            base: limits_call,
+            sub: convert_tex_node_to_typst(sub, options),
+    });
 }
 
 
@@ -117,7 +126,7 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
         case 'supsub': {
             let { base, sup, sub } = node.data as TexSupsubData;
 
-            // Special logic for overbrace
+            // special hook for overbrace
             if (base && base.type === 'unaryFunc' && base.content === '\\overbrace' && sup) {
                 return new TypstNode(
                     'funcCall',
@@ -150,40 +159,61 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
             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(
+            const [left, _body, right] = node.args!;
+            const [typ_left, typ_body, typ_right] = node.args!.map((n) => convert_tex_node_to_typst(n, options));
+
+            if (options.optimize) {
+                // optimization off: "lr(bar.v.double a + 1/2 bar.v.double)"
+                // optimization on : "norm(a + 1/2)"
+                if (left.content === '\\|' && right.content === '\\|') {
+                    return new TypstNode('funcCall', 'norm', [typ_body]);
+                }
+
+                // These pairs will be handled by Typst compiler by default. No need to add lr()
+                if ([
+                    "[]", "()", "\\{\\}",
+                    "\\lfloor\\rfloor",
+                    "\\lceil\\rceil",
+                    "\\lfloor\\rceil",
+                ].includes(left.content + right.content)) {
+                    return new TypstNode('group', '', [typ_left, typ_body, typ_right]);
+                }
+            }
+
+            const group = new TypstNode(
                 'group',
                 '',
-                node.args!.map((n) => convert_tex_node_to_typst(n, options))
+                [typ_left, typ_body, typ_right]
             );
-            if ([
-                "[]", "()", "\\{\\}",
-                "\\lfloor\\rfloor",
-                "\\lceil\\rceil",
-                "\\lfloor\\rceil",
-            ].includes(left.content + right.content)) {
-                return group;
-            }
-            // "\left\{ A \right." -> "{A"
-            // "\left. A \right\}" -> "lr( A} )"
+
+            // "\left\{ a + \frac{1}{3} \right." -> "lr(\{ a + 1/3)"
+            // "\left. a + \frac{1}{3} \right\}" -> "lr( a + \frac{1}{3} \})"
+            // Note that: In lr(), if one side of delimiter doesn't present (i.e. derived from "\\left." or "\\right."),
+            // "(", ")", "{", "[", should be escaped with "\" to be the other side of delimiter.
+            // Simple "lr({ a+1/3)" doesn't compile in Typst.
+            const escape_curly_or_paren = function(s: string): string {
+                if (["(", ")", "{", "["].includes(s)) {
+                    return "\\" + s;
+                } else {
+                    return s;
+                }
+            };
             if (right.content === '.') {
-                group.args!.pop();
-                return group;
+                typ_left.content = escape_curly_or_paren(typ_left.content);
+                group.args = [typ_left, typ_body];
             } else if (left.content === '.') {
-                group.args!.shift();
-                return new TypstNode('funcCall', 'lr', [group]);
+                typ_right.content = escape_curly_or_paren(typ_right.content);
+                group.args = [typ_body, typ_right];
             }
-            return new TypstNode(
-                'funcCall',
-                'lr',
-                [group]
-            );
+            return new TypstNode('funcCall', 'lr', [group]);
         }
         case 'binaryFunc': {
             if (node.content === '\\overset') {
                 return convert_overset(node, options);
             }
+            if (node.content === '\\underset') {
+                return convert_underset(node, options);
+            }
             // \frac{a}{b} -> a / b
             if (node.content === '\\frac') {
                 if (options.fracToSlash) {
@@ -409,6 +439,8 @@ const TYPST_UNARY_FUNCTIONS: string[] = [
     'frak',
     'floor',
     'ceil',
+    'norm',
+    'limits',
 ];
 
 const TYPST_BINARY_FUNCTIONS: string[] = [
@@ -428,8 +460,6 @@ function apply_escape_if_needed(c: string) {
 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)!;
     }
@@ -491,6 +521,8 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
                         let left_delim = apply_escape_if_needed(data.leftDelim);
                         assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
                         let right_delim = apply_escape_if_needed(data.rightDelim!);
+                        // TODO: should be TeXNode('leftright', ...)
+                        // But currently writer will output `\left |` while people commonly prefer `\left|`.
                         return new TexNode('ordgroup', '', [
                             new TexNode('element', '\\left' + left_delim),
                             ...node.args!.map(convert_typst_node_to_tex),
@@ -500,17 +532,29 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
                         return new TexNode('ordgroup', '', node.args!.map(convert_typst_node_to_tex));
                     }
                 }
+                // special hook for norm
+                // `\| a  \|` <- `norm(a)`
+                // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
+                if (node.content === 'norm') {
+                    const arg0 = node.args![0];
+                    const tex_node_type = node.isOverHigh() ? 'leftright' : 'ordgroup';
+                    return new TexNode(tex_node_type, '', [
+                        new TexNode('symbol', "\\|"),
+                        convert_typst_node_to_tex(arg0),
+                        new TexNode('symbol', "\\|")
+                    ]);
+                }
                 // special hook for floor, ceil
-                // Typst "floor(a) + ceil(b)" should converts to Tex "\lfloor a \rfloor + \lceil b \rceil"
+                // `\lfloor a \rfloor` <- `floor(a)`
+                // `\lceil a \rceil` <- `ceil(a)`
+                // `\left\lfloor a \right\rfloor` <- `floor(a)`
+                // `\left\lceil a \right\rceil` <- `ceil(a)`
                 if (node.content === 'floor' || node.content === 'ceil') {
-                    let left = "\\l" + node.content;
-                    let right = "\\r" + node.content;
+                    const left = "\\l" + node.content;
+                    const right = "\\r" + node.content;
                     const arg0 = node.args![0];
-                    if (arg0.isOverHigh()) {
-                        left = "\\left" + left;
-                        right = "\\right" + right;
-                    }
-                    return new TexNode('ordgroup', '', [
+                    const tex_node_type = node.isOverHigh() ? 'leftright' : 'ordgroup';
+                    return new TexNode(tex_node_type, '', [
                         new TexNode('symbol', left),
                         convert_typst_node_to_tex(arg0),
                         new TexNode('symbol', right)
@@ -552,15 +596,34 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
         }
         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);
             }
+
+            // special hook for limits
+            // `limits(+)^a` -> `\overset{a}{+}`
+            // `limits(+)_a` -> `\underset{a}{+}`
+            // `limits(+)_a^b` -> `\overset{b}{\underset{a}{+}}`
+            if (base.eq(new TypstNode('funcCall', 'limits'))) {
+                const body_in_limits = convert_typst_node_to_tex(base.args![0]);
+                if (sup_tex !== undefined && sub_tex === undefined) {
+                    return new TexNode('binaryFunc', '\\overset', [sup_tex, body_in_limits]);
+                } else if (sup_tex === undefined && sub_tex !== undefined) {
+                    return new TexNode('binaryFunc', '\\underset', [sub_tex, body_in_limits]);
+                } else {
+                    const underset_call = new TexNode('binaryFunc', '\\underset', [sub_tex!, body_in_limits]);
+                    return new TexNode('binaryFunc', '\\overset', [sup_tex!, underset_call]);
+                }
+            }
+
+            const base_tex = convert_typst_node_to_tex(base);
+
             const res = new TexNode('supsub', '', [], {
                 base: base_tex,
                 sup: sup_tex,

package/src/index.ts

@@ -16,6 +16,7 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
         keepSpaces: false,
         fracToSlash: true,
         inftyToOo: false,
+        optimize: true,
         nonAsciiWrapper: "",
         customTexMacros: {}
     };

package/src/map.ts

@@ -1,6 +1,8 @@
 const symbolMap = new Map<string, string>([
     ['displaystyle', 'display'],
 
+    ['|', 'bar.v.double'],
+    ['!', '#h(-math.thin.amount)'],
     [',', 'thin'],
     [':', 'med'],
     [';', 'thick'],

package/src/tex-parser.ts

@@ -47,6 +47,7 @@ const BINARY_COMMANDS = [
     'dfrac',
     'tbinom',
     'overset',
+    'underset',
 ]
 
 const IGNORED_COMMANDS = [
@@ -86,7 +87,7 @@ function eat_whitespaces(tokens: TexToken[], start: number): TexToken[] {
 
 function eat_parenthesis(tokens: TexToken[], start: number): TexToken | null {
     const firstToken = tokens[start];
-    if (firstToken.type === TexTokenType.ELEMENT && ['(', ')', '[', ']', '|', '\\{', '\\}', '.'].includes(firstToken.value)) {
+    if (firstToken.type === TexTokenType.ELEMENT && ['(', ')', '[', ']', '|', '\\{', '\\}', '.', '\\|'].includes(firstToken.value)) {
         return firstToken;
     } else if (firstToken.type === TexTokenType.COMMAND && ['lfloor', 'rfloor', 'lceil', 'rceil', 'langle', 'rangle'].includes(firstToken.value.slice(1))) {
         return firstToken;
@@ -166,7 +167,7 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
     ],
     [String.raw`%[^\n]*`, (s) => new TexToken(TexTokenType.COMMENT, s.text()!.substring(1))],
     [String.raw`[{}_^&]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
-    [String.raw`\\[\\,:; ]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
+    [String.raw`\\[\\,:;! ]`, (s) => new TexToken(TexTokenType.CONTROL, s.text()!)],
     [String.raw`\r?\n`, (_s) => new TexToken(TexTokenType.NEWLINE, "\n")],
     [String.raw`\s+`, (s) => new TexToken(TexTokenType.SPACE, s.text()!)],
     [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(TexTokenType.ELEMENT, s.text()!)],
@@ -394,6 +395,7 @@ export class LatexParser {
                     case '}':
                         throw new LatexParserError("Unmatched '}'");
                     case '\\\\':
+                    case '\\!':    
                     case '\\,':
                     case '\\:':
                     case '\\;':

package/src/types.ts

@@ -125,6 +125,13 @@ export class TexNode {
             case 'ordgroup': {
                 return this.args!.map((n) => n.serialize()).flat();
             }
+            case 'leftright': {
+                let tokens = this.args!.map((n) => n.serialize()).flat();
+                tokens.splice(0, 0, new TexToken(TexTokenType.COMMAND, '\\left'));
+                tokens.splice(tokens.length - 1, 0, new TexToken(TexTokenType.COMMAND, '\\right'));
+
+                return tokens;
+            }
             case 'unaryFunc': {
                 let tokens: TexToken[] = [];
                 tokens.push(new TexToken(TexTokenType.COMMAND, this.content));
@@ -382,14 +389,21 @@ export const TYPST_NONE = new TypstNode('none', '#none');
 export const TYPST_TRUE: TypstPrimitiveValue = true;
 export const TYPST_FALSE: TypstPrimitiveValue = false;
 
+/**
+ * ATTENTION:
+ * Don't use any options except those explicitly documented in
+ *   https://github.com/qwinsi/tex2typst/blob/main/docs/api-reference.md
+ * Any undocumented options may break in the future!
+ */
 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
-    nonAsciiWrapper?: string; // default is ""
+    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 */
+    optimize?: boolean; /** default is true */
+    nonAsciiWrapper?: string; /** default is "" */
     customTexMacros?: { [key: string]: string };
     // TODO: custom typst functions
 }

package/src/typst-writer.ts

@@ -40,6 +40,7 @@ export interface TypstWriterOptions {
     preferShorthands: boolean;
     keepSpaces: boolean;
     inftyToOo: boolean;
+    optimize: boolean;
 }
 
 export class TypstWriter {
@@ -47,17 +48,19 @@ export class TypstWriter {
     private preferShorthands: boolean;
     private keepSpaces: boolean;
     private inftyToOo: boolean;
+    private optimize: boolean;
 
     protected buffer: string = "";
     protected queue: TypstToken[] = [];
 
     private insideFunctionDepth = 0;
 
-    constructor(opt: TypstWriterOptions) {
-        this.nonStrict = opt.nonStrict;
-        this.preferShorthands = opt.preferShorthands;
-        this.keepSpaces = opt.keepSpaces;
-        this.inftyToOo = opt.inftyToOo;
+    constructor(options: TypstWriterOptions) {
+        this.nonStrict = options.nonStrict;
+        this.preferShorthands = options.preferShorthands;
+        this.keepSpaces = options.keepSpaces;
+        this.inftyToOo = options.inftyToOo;
+        this.optimize = options.optimize;
     }
 
 
@@ -68,8 +71,6 @@ 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);
@@ -163,7 +164,7 @@ export class TypstWriter {
                     // Put prime symbol before '_'. Because $y_1'$ is not displayed properly in Typst (so far)
                     // e.g.
                     // y_1' -> y'_1
-                    // y_{a_1}' -> y'_{a_1}
+                    // y_{a_1}' -> y'_(a_1)
                     this.queue.push(new TypstToken(TypstTokenType.ELEMENT, '\''));
                     trailing_space_needed = false;
                 }
@@ -375,9 +376,11 @@ export class TypstWriter {
             res = res.replace(/round\(\)/g, 'round("")');
             return res;
         }
-        const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
-        for (const pass of all_passes) {
-            this.buffer = pass(this.buffer);
+        if (this.optimize) {
+            const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
+            for (const pass of all_passes) {
+                this.buffer = pass(this.buffer);
+            }
         }
         return this.buffer;
     }

package/TODO.md

@@ -1 +0,0 @@
-- Typst math `limits(Y)^X` to TeX `\overset{X}{Y}`

package/docs/api-reference.md

@@ -1,64 +0,0 @@
-# API Reference of tex2typst.js
-
-## Basic usage
-
-```javascript
-import { tex2typst, typst2tex } from 'tex2typst';
-
-let tex = "e \\overset{\\text{def}}{=} \\lim_{{n \\to \\infty}} \left(1 + \\frac{1}{n}\\right)^n";
-let typst = tex2typst(tex);
-console.log(typst);
-// e eq.def lim_(n -> infinity)(1 + 1/n)^n
-
-let tex_recovered = typst2tex(typst);
-console.log(tex_recovered);
-// e \overset{\text{def}}{=} \lim_{n \rightarrow \infty} \left(1 + \frac{1}{n} \right)^n
-```
-
-## Advanced options
-
-`tex2typst` function accepts an optional second argument, which is an object containing options to customize the conversion.
-
-```typescript
-interface Tex2TypstOptions {
-    preferShorthands?: boolean;
-    fracToSlash?: boolean;
-    inftyToOo?: boolean;
-}
-```
-
-- `preferShorthands`: If set to `true`, the function will prefer using shorthands in Typst (e.g., `->` instead of `arrow.r`, `<<` instead of `lt.double`) when converting TeX to Typst. Default is `ture`.
-
-```javascript
-let tex = "a \\rightarrow b \\ll c";
-let typst1 = tex2typst(tex, { preferShorthands: false });
-console.log(typst1);
-// a arrow.r b lt.double c
-let typst2 = tex2typst(tex, { preferShorthands: true });
-console.log(typst2);
-// a -> b << c
-```
-
-- `fracToSlash`: If set to `true`, the Typst result will use the slash notation for fractions. Default is `true`.
-
-```javascript
-let tex = "\\frac{a}{b}";
-let tpyst1 = tex2typst(tex, { fracToSlash: false });
-console.log(typst1);
-// frac(a, b)
-let typst2 = tex2typst(tex, { fracToSlash: true });
-console.log(typst2);
-// a / b
-```
-
-- `inftyToOo`: If set to `true`, `\infty` converts to `oo` instead of `infinity`. Default is `false`.
-
-```javascript
-let tex = "\\infty";
-let typst1 = tex2typst(tex, { inftyToOo: false });
-console.log(typst1);
-// infinity
-let typst2 = tex2typst(tex, { inftyToOo: true });
-console.log(typst2);
-// oo
-```

package/tools/make-shorthand-map.py

@@ -1,33 +0,0 @@
-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,35 +0,0 @@
-import urllib.request
-from bs4 import BeautifulSoup
-
-if __name__ == '__main__':
-    symbol_map = {}
-
-    url = "https://typst.app/docs/reference/symbols/sym/"
-    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')
-    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
-
-    # sort the pairs with alphabetical order of latex
-    sorted_keys = sorted(list(symbol_map.keys()), key=str.lower)
-    sorted_symbol_map = [(key, symbol_map[key]) for key in sorted_keys]
-    for latex, typst in sorted_symbol_map:
-        print(f"    ['{latex[1:]}', '{typst}'],")
-        # print(f'{latex[1:]} = "{typst}"')