tex2typst 0.3.27-beta.1 → 0.3.28

package/src/convert.ts

@@ -188,6 +188,41 @@ function convert_tex_array_align_literal(alignLiteral: string): TypstNamedParams
     return np;
 }
 
+const TYPST_LEFT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '(');
+const TYPST_RIGHT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ')');
+
+function is_delimiter(c: TypstNode): boolean {
+    return c.head.type === TypstTokenType.ELEMENT && ['(', ')', '[', ']', '{', '}', '|', '⌊', '⌋', '⌈', '⌉'].includes(c.head.value);
+}
+
+function appendWithBracketsIfNeeded(node: TypstNode): TypstNode {
+    let need_to_wrap = ['group', 'supsub', 'matrixLike', 'fraction','empty'].includes(node.type);
+
+    if (node.type === 'group') {
+        const group = node as TypstGroup;
+        if (group.items.length === 0) {
+            // e.g. TeX `P_{}` converts to Typst `P_()`
+            need_to_wrap = true;
+        } else {
+            const first = group.items[0];
+            const last = group.items[group.items.length - 1];
+            if (is_delimiter(first) && is_delimiter(last)) {
+                need_to_wrap = false;
+            }
+        }
+    }
+
+    if (need_to_wrap) {
+        return new TypstLeftright(null, {
+            left: TYPST_LEFT_PARENTHESIS,
+            right: TYPST_RIGHT_PARENTHESIS,
+            body: node,
+
+        });
+    } else {
+        return node;
+    }
+}
 
 export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions = {}): TypstNode {
     switch (abstractNode.type) {
@@ -197,12 +232,6 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
         }
         case 'text': {
             const node = abstractNode as TexText;
-            if ((/[^\x00-\x7F]+/).test(node.head.value) && options.nonAsciiWrapper !== "") {
-                return new TypstFuncCall(
-                    new TypstToken(TypstTokenType.SYMBOL, options.nonAsciiWrapper!),
-                    [new TypstToken(TypstTokenType.TEXT, node.head.value).toNode()]
-                );
-            }
             return new TypstToken(TypstTokenType.TEXT, node.head.value).toNode();
         }
         case 'ordgroup':
@@ -234,6 +263,14 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
                 sub: sub? convert_tex_node_to_typst(sub, options) : null,
             };
 
+            data.base = appendWithBracketsIfNeeded(data.base);
+            if (data.sup) {
+                data.sup = appendWithBracketsIfNeeded(data.sup);
+            }
+            if (data.sub) {
+                data.sub = appendWithBracketsIfNeeded(data.sub);
+            }
+
             return new TypstSupsub(data);
         }
         case 'leftright': {
@@ -348,12 +385,54 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
                 return res;
             }
 
-            // \substack{a \\ b} -> `a \ b`
+            // \substack{a \\ b} -> a \ b
             // as in translation from \sum_{\substack{a \\ b}} to sum_(a \ b)
             if (node.head.value === '\\substack') {
                 return arg0;
             }
 
+            // \displaylines{...} -> ...
+            if (node.head.value === '\\displaylines') {
+                return arg0;
+            }
+
+            // \mathinner{...} -> ...
+            if (node.head.value === '\\mathinner') {
+                return arg0;
+            }
+
+            // \mathrel{X} -> class("relation", X)
+            if (node.head.value === '\\mathrel') {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'class'),
+                    [new TypstToken(TypstTokenType.TEXT, 'relation').toNode(), arg0]
+                );
+            }
+
+            // \mathbin{X} -> class("binary", X)
+            if (node.head.value === '\\mathbin') {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'class'),
+                    [new TypstToken(TypstTokenType.TEXT, 'binary').toNode(), arg0]
+                );
+            }
+
+            // \mathop{X} -> class("large", X)
+            if (node.head.value === '\\mathop') {
+                return new TypstFuncCall(
+                    new TypstToken(TypstTokenType.SYMBOL, 'class'),
+                    [new TypstToken(TypstTokenType.TEXT, 'large').toNode(), arg0]
+                );
+            }
+
+            // \set{a, b, c} -> {a, b, c}
+            if (node.head.value === '\\set') {
+                return new TypstLeftright(
+                    null,
+                    { body: arg0, left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
+                );
+            }
+
             if (node.head.value === '\\overset') {
                 return convert_overset(node, options);
             }
@@ -364,7 +443,7 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
             // \frac{a}{b} -> a / b
             if (node.head.value === '\\frac') {
                 if (options.fracToSlash) {
-                    return new TypstFraction(node.args.map((n) => convert_tex_node_to_typst(n, options)));
+                    return new TypstFraction(node.args.map((n) => convert_tex_node_to_typst(n, options)).map(appendWithBracketsIfNeeded));
                 }
             }
 
@@ -697,6 +776,31 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     assert(arg0.head.type === TypstTokenType.TEXT);
                     return new TexFuncCall(typst_token_to_tex(node.head), [new TexToken(TexTokenType.LITERAL, arg0.head.value).toNode()]);
                 }
+                case 'class': {
+                    const arg0 = node.args[0];
+                    assert(arg0.head.type === TypstTokenType.TEXT);
+                    let command: string;
+                    switch (arg0.head.value) {
+                        // \mathrel{X} <- class("relation", X)
+                        case 'relation':
+                            command = '\\mathrel';
+                            break;
+                        // \mathbin{X} <- class("binary", X)
+                        case 'binary':
+                            command = '\\mathbin';
+                            break;
+                        // \mathop{X} <- class("large", X)
+                        case 'large':
+                            command = '\\mathop';
+                            break;
+                        default:
+                            throw new Error(`Unimplemented class: ${arg0.head.value}`);
+                    }
+                    return new TexFuncCall(
+                        new TexToken(TexTokenType.COMMAND, command),
+                        [convert_typst_node_to_tex(node.args[1])]
+                    );
+                }
                 // general case
                 default: {
                     const func_name_tex = typst_token_to_tex(node.head);

package/src/exposed-types.ts

@@ -1,24 +1,22 @@
-
-/**
- * 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 be not working at present or break in the future!
- */
-
-export interface Tex2TypstOptions {
-    nonStrict?: 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; };
-}
-
-export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
-export declare function typst2tex(typst: string): string;
-
-export declare const symbolMap: Map<string, string>;
-export declare const shorthandMap: Map<string, string>;
+
+/**
+ * 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 be not working at present or break in the future!
+ */
+export interface Tex2TypstOptions {
+    nonStrict?: 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 */
+    customTexMacros?: { [key: string]: string; };
+}
+
+export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
+export declare function typst2tex(typst: string): string;
+
+export declare const symbolMap: Map<string, string>;
+export declare const shorthandMap: Map<string, string>;

package/src/generic.ts

@@ -59,6 +59,22 @@ export function array_split<T extends IEquatable>(array: T[], sep: T): T[][] {
     return res;
 }
 
+// e.g. input array=[['a', 'b'], ['c'], ['d', 'e']], sep = '+'
+// return ['a', 'b', '+', 'c', '+', 'd', 'e']
+export function array_join<T>(arrays: T[][], sep: T): T[] {
+    /*
+    const res: T[] = [];
+    for (let i = 0; i < arrays.length; i++) {
+        res.push(...arrays[i]);
+        if (i !== arrays.length - 1) {
+            res.push(sep);
+        }
+    }
+    return res;
+    */
+    return arrays.flatMap((arr, i) => i !== arrays.length - 1? [...arr, sep]: arr);
+}
+
 // e.g. input array=['a', 'b', 'c'], sep = '+'
 // return ['a','+', 'b', '+','c']
 export function array_intersperse<T>(array: T[], sep: T): T[] {

package/src/index.ts

@@ -1,6 +1,7 @@
 import { parseTex } from "./tex-parser";
 import type { Tex2TypstOptions } from "./exposed-types";
-import { TypstWriter, type TypstWriterOptions } from "./typst-writer";
+import { TypstWriter } from "./typst-writer";
+import { type TypstWriterOptions } from "./typst-types";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
 import { symbolMap } from "./map";
 import { parseTypst } from "./typst-parser";
@@ -16,14 +17,16 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
         fracToSlash: true,
         inftyToOo: false,
         optimize: true,
-        nonAsciiWrapper: "",
         customTexMacros: {}
     };
 
     if(options !== undefined) {
+        if (typeof options !== 'object') {
+            throw new Error("options must be an object");
+        }
         for (const key in opt) {
-            if (options[key] !== undefined) {
-                opt[key] = options[key];
+            if (key in options) {
+                opt[key as keyof Tex2TypstOptions] = options[key as keyof Tex2TypstOptions] as any;
             }
         }
     }

package/src/jslex.ts

@@ -5,7 +5,7 @@
 
 
 interface ILexSpec<T> {
-    start: Map<string, (arg0: Scanner<T>) => T | T[]>;
+    [key: string]: Map<string, (arg0: Scanner<T>) => T | T[]>;
 }
 
 interface IRule<T> {

package/src/map.ts

@@ -56,6 +56,7 @@ const symbolMap = new Map<string, string>([
     ['mathbb', 'bb'],
     ['mathbf', 'bold'],
     ['mathcal', 'cal'],
+    ['mathscr', 'scr'],
     ['mathit', 'italic'],
     ['mathfrak', 'frak'],
     ['mathrm', 'upright'],
@@ -260,7 +261,6 @@ const symbolMap = new Map<string, string>([
     ['intop', 'limits(integral)'],
     
     // extended
-    ['mathscr', 'scr'],
     ['LaTeX', '#LaTeX'],
     ['TeX', '#TeX'],
 ]);