tex2typst 0.4.0 → 0.5.0

package/src/convert.ts

@@ -8,7 +8,7 @@ import { TypstToken } from "./typst-types";
 import { TypstTokenType } from "./typst-types";
 import { symbolMap, reverseSymbolMap } from "./map";
 import { array_includes, array_intersperse, array_split } from "./generic";
-import { assert } from "./util";
+import { assert } from "./utils";
 import { TEX_BINARY_COMMANDS, TEX_UNARY_COMMANDS } from "./tex-tokenizer";
 
 
@@ -191,27 +191,10 @@ function convert_tex_array_align_literal(alignLiteral: string): TypstNamedParams
 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,
@@ -263,7 +246,6 @@ 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);
             }
@@ -433,6 +415,22 @@ export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2Ty
                 );
             }
 
+            // \not X -> X.not
+            if (node.head.value === '\\not') {
+                const sym = convert_tex_node_to_typst(node.args[0], options);
+                assert(sym.type === "terminal");
+                if(sym.head.type === TypstTokenType.SYMBOL) {
+                    return new TypstToken(TypstTokenType.SYMBOL, sym.head.value + '.not').toNode();
+                } else {
+                    switch(sym.head.value) {
+                        case '=':
+                            return new TypstToken(TypstTokenType.SYMBOL, 'eq.not').toNode();
+                        default:
+                            throw new Error(`Not supported: \\not ${sym.head.value}`);
+                    }
+                }
+            }
+
             if (node.head.value === '\\overset') {
                 return convert_overset(node, options);
             }
@@ -573,14 +571,6 @@ const TYPST_BINARY_FUNCTIONS: string[] = [
 ];
 */
 
-function apply_escape_if_needed(c: TexToken): TexToken {
-    if (['{', '}', '%'].includes(c.value)) {
-        return new TexToken(TexTokenType.ELEMENT, '\\' + c.value);
-    }
-    return c;
-}
-
-
 function typst_token_to_tex(token: TypstToken): TexToken {
     switch (token.type) {
         case TypstTokenType.NONE:
@@ -588,12 +578,28 @@ function typst_token_to_tex(token: TypstToken): TexToken {
             return TexToken.EMPTY;
         case TypstTokenType.SYMBOL: {
             const _typst_symbol_to_tex = function(symbol: string): string {
-                if (reverseSymbolMap.has(symbol)) {
-                    return '\\' + reverseSymbolMap.get(symbol)!;
-                } else {
-                    return '\\' + symbol;
+                switch(symbol) {
+                    case 'eq':
+                        return '=';
+                    case 'plus':
+                        return '+';
+                    case 'minus':
+                        return '-';
+                    case 'percent':
+                        return '%';
+                    default: {
+                        if (reverseSymbolMap.has(symbol)) {
+                            return '\\' + reverseSymbolMap.get(symbol);
+                        } else {
+                            return '\\' + symbol;
+                        }
+                    }
                 }
             }
+            if (token.value.endsWith('.not')) {
+                const sym = _typst_symbol_to_tex(token.value.slice(0, -4));
+                return new TexToken(TexTokenType.COMMAND, sym.startsWith('\\') ? `\\not${sym}` : `\\not ${sym}`);
+            }
             return new TexToken(TexTokenType.COMMAND, _typst_symbol_to_tex(token.value));
         }
         case TypstTokenType.ELEMENT: {
@@ -954,4 +960,3 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode, options: Typs
             throw new Error('[convert_typst_node_to_tex] Unimplemented type: ' + abstractNode.type);
     }
 }
-

package/src/generic.ts

@@ -1,8 +1,8 @@
-interface IEquatable {
-    eq(other: IEquatable): boolean;
+interface IEquatable<T> {
+    eq(other: T): boolean;
 }
 
-export function array_equal<T extends IEquatable>(a: T[], b: T[]): boolean {
+export function array_equal<T extends IEquatable<T>>(a: T[], b: T[]): boolean {
     /*
     if (a.length !== b.length) {
         return false;
@@ -17,7 +17,7 @@ export function array_equal<T extends IEquatable>(a: T[], b: T[]): boolean {
     return a.length === b.length && a.every((x, i) => x.eq(b[i]));
 }
 
-export function array_find<T extends IEquatable>(array: T[], item: T, start: number = 0): number {
+export function array_find<T extends IEquatable<T>>(array: T[], item: T, start: number = 0): number {
     /*
     for (let i = start; i < array.length; i++) {
         if (array[i].eq(item)) {
@@ -30,7 +30,7 @@ export function array_find<T extends IEquatable>(array: T[], item: T, start: num
     return index === -1 ? -1 : index + start;
 }
 
-export function array_includes<T extends IEquatable>(array: T[], item: T): boolean {
+export function array_includes<T extends IEquatable<T>>(array: T[], item: T): boolean {
     /*
     for (const x of array) {
         if (x.eq(item)) {
@@ -44,7 +44,7 @@ export function array_includes<T extends IEquatable>(array: T[], item: T): boole
 
 // e.g. input array=['a', 'b', '+', 'c', '+', 'd', 'e'], sep = '+'
 // return [['a', 'b'], ['c'], ['d', 'e']]
-export function array_split<T extends IEquatable>(array: T[], sep: T): T[][] {
+export function array_split<T extends IEquatable<T>>(array: T[], sep: T): T[][] {
     const res: T[][] = [];
     let current_slice: T[] = [];
     for (const i of array) {