tex2typst 0.3.16 → 0.3.18

package/src/convert.ts

@@ -1,4 +1,4 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType, TypstLrData, TexArrayData } from "./types";
+import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType, TypstLrData, TexArrayData, TypstNamedParams } from "./types";
 import { TypstWriterError } from "./typst-writer";
 import { symbolMap, reverseSymbolMap } from "./map";
 import { array_join } from "./generic";
@@ -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,43 +159,64 @@ 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) {
+                if (options.fracToSlash) {
                     return new TypstNode(
                         'fraction',
                         '',
@@ -287,6 +317,59 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
             if (node.content! === 'cases') {
                 return new TypstNode('cases', '', [], data);
             }
+            if (node.content! === 'array') {
+                const res = new TypstNode('matrix', '', [], data);
+                const options: TypstNamedParams = { 'delim': TYPST_NONE };
+
+                const align_args = node.args!;
+                if (align_args.length > 0) {
+                    const align_node = align_args[0];
+                    const align_str = (() => {
+                        if (align_node.type === 'element') return align_node.content;
+                        if (align_node.type === 'ordgroup') {
+                            return align_node.args!.map(n => n.type === 'element' ? n.content : '').join('');
+                        }
+                        return '';
+                    })();
+
+                    if (align_str) {
+                        const alignMap: Record<string, string> = { l: '#left', c: '#center', r: '#right' };
+                        const chars = Array.from(align_str);
+
+                        const alignments = chars
+                            .map(c => alignMap[c])
+                            .filter(Boolean)
+                            .map(s => new TypstNode('symbol', s!));
+
+                        const vlinePositions: number[] = [];
+                        let columnIndex = 0;
+                        for (const c of chars) {
+                            if (c === '|') {
+                                vlinePositions.push(columnIndex);
+                            } else if (c === 'l' || c === 'c' || c === 'r') {
+                                columnIndex++;
+                            }
+                        }
+
+                        if (vlinePositions.length > 0) {
+                            if (vlinePositions.length === 1) {
+                                options['augment'] = new TypstNode('symbol', `#${vlinePositions[0]}`);
+                            } else {
+                                options['augment'] = new TypstNode('symbol', `#(vline: (${vlinePositions.join(', ')}))`);
+                            }
+                        }
+
+                        if (alignments.length > 0) {
+                            const first_align = alignments[0].content;
+                            const all_same = alignments.every(item => item.content === first_align);
+                            options['align'] = all_same ? alignments[0] : new TypstNode('symbol', '#center');
+                        }
+                    }
+                }
+
+                res.setOptions(options);
+                return res;
+            }
             if (node.content!.endsWith('matrix')) {
                 let delim: TypstPrimitiveValue;
                 switch (node.content) {
@@ -356,6 +439,8 @@ const TYPST_UNARY_FUNCTIONS: string[] = [
     'frak',
     'floor',
     'ceil',
+    'norm',
+    'limits',
 ];
 
 const TYPST_BINARY_FUNCTIONS: string[] = [
@@ -375,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)!;
     }
@@ -438,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),
@@ -447,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)
@@ -499,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 '\\;':
@@ -548,7 +550,18 @@ export class LatexParser {
         const envName = tokens[pos + 1].value;
         pos += 3;
 
-        pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
+        const args: TexNode[] = [];
+        while (pos < tokens.length) {
+            const whitespaceCount = eat_whitespaces(tokens, pos).length;
+            pos += whitespaceCount;
+            
+            if (pos >= tokens.length || !tokens[pos].eq(LEFT_CURLY_BRACKET)) {
+                break;
+            }
+            const [arg, newPos] = this.parseNextArg(tokens, pos);
+            args.push(arg);
+            pos = newPos;
+        }
 
         const exprInsideStart = pos;
 
@@ -573,7 +586,7 @@ export class LatexParser {
             exprInside.pop();
         }
         const body = this.parseAligned(exprInside);
-        const res = new TexNode('beginend', envName, [], body);
+        const res = new TexNode('beginend', envName, args, body);
         return [res, pos];
     }
 

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;
                 }
@@ -207,21 +208,9 @@ export class TypstWriter {
             }
             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.appendWithBracketsIfNeeded(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);
-                }
+                this.appendWithBracketsIfNeeded(denominator);
                 break;
             }
             case 'align': {
@@ -316,7 +305,7 @@ export class TypstWriter {
     }
 
     private appendWithBracketsIfNeeded(node: TypstNode): boolean {
-        let need_to_wrap = ['group', 'supsub', 'empty'].includes(node.type);
+        let need_to_wrap = ['group', 'supsub', 'fraction','empty'].includes(node.type);
 
         if (node.type === 'group') {
             if (node.args!.length === 0) {
@@ -387,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 @@
-- Tex math `\frac{X}{\frac{Y}{2}}` should converts to Typst `X/(Y/2)`, not `X/Y/2`.

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
-```