tex2typst 0.3.27-beta.1 → 0.3.27

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) {
@@ -234,6 +269,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 +391,20 @@ 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;
             }
 
+            // \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 +415,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));
                 }
             }
 

package/src/exposed-types.ts

@@ -1,24 +1,23 @@
-
-/**
- * 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 */
+    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>;

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";
@@ -21,9 +22,12 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     };
 
     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/tex-tokenizer.ts

@@ -35,6 +35,7 @@ export const TEX_UNARY_COMMANDS = [
     'overrightarrow',
     'hspace',
     'substack',
+    'set',
 ]
 
 export const TEX_BINARY_COMMANDS = [

package/src/tex2typst.ts

@@ -4,7 +4,5 @@
 
 import { tex2typst, typst2tex } from './index';
 
-if(typeof window !== 'undefined') {
-    (window as any).tex2typst = tex2typst;
-    (window as any).typst2tex = typst2tex;
-}
+(window as any).tex2typst = tex2typst;
+(window as any).typst2tex = typst2tex;

package/src/typst-parser.ts

@@ -53,8 +53,8 @@ function find_closing_delim(tokens: TypstToken[], start: number): number {
     return _find_closing_match(
         tokens,
         start,
-        [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET, VERTICAL_BAR],
-        [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET, VERTICAL_BAR]
+        TypstToken.LEFT_DELIMITERS,
+        TypstToken.RIGHT_DELIMITERS
     );
 }
 
@@ -218,7 +218,6 @@ const LEFT_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '[');
 const RIGHT_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ']');
 const LEFT_CURLY_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '{');
 const RIGHT_CURLY_BRACKET: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '}');
-const VERTICAL_BAR = new TypstToken(TypstTokenType.ELEMENT, '|');
 const COMMA = new TypstToken(TypstTokenType.ELEMENT, ',');
 const SEMICOLON = new TypstToken(TypstTokenType.ELEMENT, ';');
 const SINGLE_SPACE = new TypstToken(TypstTokenType.SPACE, ' ');
@@ -373,20 +372,20 @@ export class TypstParser {
     // start: the position of the left parentheses
     parseLrArguments(tokens: TypstToken[], start: number): [TypstNode, number] {
         const lr_token = tokens[start];
-        if (tokens[start + 1].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET, VERTICAL_BAR])) {
-            const end = find_closing_match(tokens, start);
+        const end = find_closing_match(tokens, start);
+        if (tokens[start + 1].isOneOf(TypstToken.LEFT_DELIMITERS)) {
             const inner_start = start + 1;
             const inner_end = find_closing_delim(tokens, inner_start);
-            const inner_args= this.parseArgumentsWithSeparator(tokens, inner_start + 1, inner_end, COMMA);
+            const [inner_args, _]= this.parseGroup(tokens, inner_start + 1, inner_end);
             return [
-                new TypstLeftright(lr_token, { body: new TypstGroup(inner_args), left: tokens[inner_start], right: tokens[inner_end]}),
+                new TypstLeftright(lr_token, { body: inner_args, left: tokens[inner_start], right: tokens[inner_end]}),
                 end + 1,
             ];
         } else {
-            const [args, end] = this.parseArguments(tokens, start);
+            const [inner_args, _] = this.parseGroup(tokens, start + 1, end - 1);
             return [
-                new TypstLeftright(lr_token, { body: new TypstGroup(args), left: null, right: null }),
-                end,
+                new TypstLeftright(lr_token, { body: inner_args, left: null, right: null }),
+                end + 1,
             ];
         }
     }