tex2typst 0.3.23 → 0.3.25

package/src/generic.ts

@@ -2,25 +2,48 @@ interface IEquatable {
     eq(other: IEquatable): boolean;
 }
 
+export function array_equal<T extends IEquatable>(a: T[], b: T[]): boolean {
+    /*
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (!a[i].eq(b[i])) {
+            return false;
+        }
+    }
+    return true;
+    */
+    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 {
+    /*
     for (let i = start; i < array.length; i++) {
         if (array[i].eq(item)) {
             return i;
         }
     }
     return -1;
+    */
+    const index = array.slice(start).findIndex((x) => x.eq(item));
+    return index === -1 ? -1 : index + start;
 }
 
 export function array_includes<T extends IEquatable>(array: T[], item: T): boolean {
-    for (const i of array) {
-        if (i.eq(item)) {
+    /*
+    for (const x of array) {
+        if (x.eq(item)) {
             return true;
         }
     }
     return false;
+    */
+    return array.some((x) => x.eq(item));
 }
 
+// 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[][] {
     const res: T[][] = [];
     let current_slice: T[] = [];
@@ -39,6 +62,7 @@ export function array_split<T extends IEquatable>(array: T[], sep: T): T[][] {
 // e.g. input array=['a', 'b', 'c'], sep = '+'
 // return ['a','+', 'b', '+','c']
 export function array_intersperse<T>(array: T[], sep: T): T[] {
+    /*
     const res: T[] = [];
     for (let i = 0; i < array.length; i++) {
         res.push(array[i]);
@@ -47,4 +71,6 @@ export function array_intersperse<T>(array: T[], sep: T): T[] {
         }
     }
     return res;
+    */
+    return array.flatMap((x, i) => i !== array.length - 1? [x, sep]: [x]);
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 import { parseTex } from "./tex-parser";
-import type { Tex2TypstOptions } from "./types";
+import type { Tex2TypstOptions } from "./tex-types";
 import { TypstWriter, type TypstWriterOptions } from "./typst-writer";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
 import { symbolMap } from "./map";

package/src/map.ts

@@ -5,6 +5,7 @@ const symbolMap = new Map<string, string>([
     ['|', 'bar.v.double'],
     [',', 'thin'],
     [':', 'med'],
+    [' ', 'med'],
     [';', 'thick'],
 
     /* textual operators */
@@ -21,6 +22,10 @@ const symbolMap = new Map<string, string>([
     ['Xi', 'Xi'],
     ['Upsilon', 'Upsilon'],
     ['lim', 'lim'],
+    ['binom', 'binom'],
+    ['tilde', 'tilde'],
+    ['hat', 'hat'],
+    ['sqrt', 'sqrt'],
 
     ['nonumber', ''],
     ['vec', 'arrow'],

package/src/tex-parser.ts

@@ -1,5 +1,4 @@
-import { symbolMap } from "./map";
-import { TexNode, TexSupsubData, TexToken, TexTokenType } from "./types";
+import { TexBeginEnd, TexFuncCall, TexLeftRight, TexNode, TexGroup, TexSupSub, TexSupsubData, TexText, TexToken, TexTokenType } from "./tex-types";
 import { assert } from "./util";
 import { array_find } from "./generic";
 import { TEX_BINARY_COMMANDS, TEX_UNARY_COMMANDS, tokenize_tex } from "./tex-tokenizer";
@@ -11,7 +10,7 @@ const IGNORED_COMMANDS = [
     'Biggl', 'Biggr',
 ];
 
-const EMPTY_NODE: TexNode = new TexNode('empty', '');
+const EMPTY_NODE: TexNode = TexToken.EMPTY.toNode();
 
 function get_command_param_num(command: string): number {
     if (TEX_UNARY_COMMANDS.includes(command)) {
@@ -120,7 +119,8 @@ export class LatexParser {
     }
 
     parse(tokens: TexToken[]): TexNode {
-        const idx = array_find(tokens, new TexToken(TexTokenType.COMMAND, '\\displaystyle'));
+        const token_displaystyle = new TexToken(TexTokenType.COMMAND, '\\displaystyle');
+        const idx = array_find(tokens, token_displaystyle);
         if (idx === -1) {
             // no \displaystyle, normal execution path
             const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
@@ -128,13 +128,13 @@ export class LatexParser {
         } else if (idx === 0) {
             // \displaystyle at the beginning. Wrap the whole thing in \displaystyle
             const [tree, _] = this.parseGroup(tokens, 1, tokens.length);
-            return new TexNode('unaryFunc', '\\displaystyle', [tree]);
+            return new TexFuncCall(token_displaystyle, [tree]);
         } else {
             // \displaystyle somewhere in the middle. Split the expression to two parts
             const [tree1, _1] = this.parseGroup(tokens, 0, idx);
             const [tree2, _2] = this.parseGroup(tokens, idx + 1, tokens.length);
-            const display = new TexNode('unaryFunc', '\\displaystyle', [tree2]);
-            return new TexNode('ordgroup', '', [tree1, display]);
+            const display = new TexFuncCall(token_displaystyle, [tree2]);
+            return new TexGroup([tree1, display]);
         }
     }
 
@@ -144,15 +144,15 @@ export class LatexParser {
         while (pos < end) {
             const [res, newPos] = this.parseNextExpr(tokens, pos);
             pos = newPos;
-            if(res.type === 'whitespace') {
-                if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
+            if(res.head.type === TexTokenType.SPACE || res.head.type === TexTokenType.NEWLINE) {
+                if (!this.space_sensitive && res.head.value.replace(/ /g, '').length === 0) {
                     continue;
                 }
-                if (!this.newline_sensitive && res.content === '\n') {
+                if (!this.newline_sensitive && res.head.value === '\n') {
                     continue;
                 }
             }
-            if (res.type === 'control' && res.content === '&') {
+            if (res.head.eq(new TexToken(TexTokenType.CONTROL, '&'))) {
                 throw new LatexParserError('Unexpected & outside of an alignment');
             }
             results.push(res);
@@ -162,7 +162,7 @@ export class LatexParser {
         if (results.length === 1) {
             node = results[0];
         } else {
-            node = new TexNode('ordgroup', '', results);
+            node = new TexGroup(results);
         }
         return [node, end + 1];
     }
@@ -199,25 +199,23 @@ export class LatexParser {
         }
 
         if (sub !== null || sup !== null || num_prime > 0) {
-            const res: TexSupsubData = { base };
+            const res: TexSupsubData = { base, sup: null, sub: null };
             if (sub) {
                 res.sub = sub;
             }
             if (num_prime > 0) {
-                res.sup = new TexNode('ordgroup', '',  []);
+                const items: TexNode[] = [];
                 for (let i = 0; i < num_prime; i++) {
-                    res.sup.args!.push(new TexNode('element', "'"));
+                    items.push(new TexToken(TexTokenType.ELEMENT, "'").toNode());
                 }
                 if (sup) {
-                    res.sup.args!.push(sup);
-                }
-                if (res.sup.args!.length === 1) {
-                    res.sup = res.sup.args![0];
+                    items.push(sup);
                 }
+                res.sup = items.length === 1 ? items[0] : new TexGroup(items);
             } else if (sup) {
                 res.sup = sup;
             }
-            return [new TexNode('supsub', '', [], res), pos];
+            return [new TexSupSub(res), pos];
         } else {
             return [base, pos];
         }
@@ -230,14 +228,11 @@ export class LatexParser {
         const firstToken = tokens[start];
         switch (firstToken.type) {
             case TexTokenType.ELEMENT:
-                return [new TexNode('element', firstToken.value), start + 1];
             case TexTokenType.LITERAL:
-                return [new TexNode('literal', firstToken.value), start + 1];
             case TexTokenType.COMMENT:
-                return [new TexNode('comment', firstToken.value), start + 1];
             case TexTokenType.SPACE:
             case TexTokenType.NEWLINE:
-                return [new TexNode('whitespace', firstToken.value), start + 1];
+                return [firstToken.toNode(), start + 1];
             case TexTokenType.COMMAND:
                 const commandName = firstToken.value.slice(1);
                 if (IGNORED_COMMANDS.includes(commandName)) {
@@ -266,14 +261,14 @@ export class LatexParser {
                     case '\\,':
                     case '\\:':
                     case '\\;':
-                        return [new TexNode('control', controlChar), start + 1];
+                        return [firstToken.toNode(), start + 1];
                     case '\\ ':
-                        return [new TexNode('control', '\\:'), start + 1];
+                        return [firstToken.toNode(), start + 1];
                     case '_':
                     case '^':
                         return [ EMPTY_NODE, start];
                     case '&':
-                        return [new TexNode('control', '&'), start + 1];
+                        return [firstToken.toNode(), start + 1];
                     default:
                         throw new LatexParserError('Unknown control sequence');
                 }
@@ -285,7 +280,8 @@ export class LatexParser {
     parseCommandExpr(tokens: TexToken[], start: number): ParseResult {
         assert(tokens[start].type === TexTokenType.COMMAND);
 
-        const command = tokens[start].value; // command name starts with a \
+        const command_token = tokens[start];
+        const command = command_token.value; // command name starts with a \
 
         let pos = start + 1;
 
@@ -297,10 +293,7 @@ export class LatexParser {
         const paramNum = get_command_param_num(command.slice(1));
         switch (paramNum) {
             case 0:
-                if (!symbolMap.has(command.slice(1))) {
-                    return [new TexNode('unknownMacro', command), pos];
-                }
-                return [new TexNode('symbol', command), pos];
+                return [command_token.toNode(), pos];
             case 1: {
                 // TODO: JavaScript gives undefined instead of throwing an error when accessing an index out of bounds,
                 // so index checking like this should be everywhere. This is rough.
@@ -315,7 +308,7 @@ export class LatexParser {
                     }
                     const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
                     const [arg1, newPos] = this.parseNextArg(tokens, posRightSquareBracket + 1);
-                    return [new TexNode('unaryFunc', command, [arg1], exponent), newPos];
+                    return [new TexFuncCall(command_token, [arg1], exponent), newPos];
                 } else if (command === '\\text') {
                     if (pos + 2 >= tokens.length) {
                         throw new LatexParserError('Expecting content for \\text command');
@@ -323,16 +316,16 @@ export class LatexParser {
                     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
                     assert(tokens[pos + 1].type === TexTokenType.LITERAL);
                     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
-                    const text = tokens[pos + 1].value;
-                    return [new TexNode('text', text), pos + 3];
+                    const literal = tokens[pos + 1];
+                    return [new TexText(literal), pos + 3];
                 }
                 let [arg1, newPos] = this.parseNextArg(tokens, pos);
-                return [new TexNode('unaryFunc', command, [arg1]), newPos];
+                return [new TexFuncCall(command_token, [arg1]), newPos];
             }
             case 2: {
                 const [arg1, pos1] = this.parseNextArg(tokens, pos);
                 const [arg2, pos2] = this.parseNextArg(tokens, pos1);
-                return [new TexNode('binaryFunc', command, [arg1, arg2]), pos2];
+                return [new TexFuncCall(command_token, [arg1, arg2]), pos2];
             }
             default:
                 throw new Error( 'Invalid number of parameters');
@@ -342,9 +335,9 @@ export class LatexParser {
     /*
     Extract a non-space argument from the token stream.
     So that `\frac{12} 3` is parsed as
-        TexCommand{ content: '\frac', args: ['12', '3'] }
+        TypstFuncCall{ head: '\frac', args: [ELEMENT_12, ELEMENT_3] }
         rather than
-        TexCommand{ content: '\frac', args: ['12', ' '] }, TexElement{ content: '3' }
+        TypstFuncCall{ head: '\frac', args: [ELEMENT_12, SPACE] }, ELEMENT_3
     */
     parseNextArg(tokens: TexToken[], start: number): ParseResult {
         let pos = start;
@@ -352,7 +345,7 @@ export class LatexParser {
         while (pos < tokens.length) {
             let node: TexNode;
             [node, pos] = this.parseNextExprWithoutSupSub(tokens, pos);
-            if (node.type !== 'whitespace') {
+            if (!(node.head.type === TexTokenType.SPACE || node.head.type === TexTokenType.NEWLINE)) {
                 arg = node;
                 break;
             }
@@ -398,12 +391,9 @@ export class LatexParser {
         pos++;
 
         const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
-        const args: TexNode[] = [
-            new TexNode('element', leftDelimiter.value),
-            body,
-            new TexNode('element', rightDelimiter.value)
-        ]
-        const res = new TexNode('leftright', '', args);
+        const left = leftDelimiter.value === '.'? null: leftDelimiter;
+        const right = rightDelimiter.value === '.'? null: rightDelimiter;
+        const res = new TexLeftRight({body: body, left: left, right: right});
         return [res, pos];
     }
 
@@ -418,14 +408,10 @@ export class LatexParser {
         pos += 3;
 
 
-        const args: TexNode[] = [];
+        let data: TexNode | null = null;
         if(['array', 'subarray'].includes(envName)) {
-            if (pos >= tokens.length || !tokens[pos].eq(LEFT_CURLY_BRACKET)) {
-                throw new LatexParserError(`Missing arg for \\begin{${envName}}`);
-            }
-            const [arg, newPos] = this.parseNextArg(tokens, pos);
-            args.push(arg);
-            pos = newPos;
+            pos += eat_whitespaces(tokens, pos).length;
+            [data, pos] = this.parseNextArg(tokens, pos);
         }
 
         pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
@@ -454,7 +440,7 @@ export class LatexParser {
             exprInside.pop();
         }
         const body = this.parseAligned(exprInside);
-        const res = new TexNode('beginend', envName, args, body);
+        const res = new TexBeginEnd(new TexToken(TexTokenType.LITERAL, envName), body, data);
         return [res, pos];
     }
 
@@ -463,32 +449,32 @@ export class LatexParser {
         const allRows: TexNode[][] = [];
         let row: TexNode[] = [];
         allRows.push(row);
-        let group = new TexNode('ordgroup', '', []);
+        let group = new TexGroup([]);
         row.push(group);
 
         while (pos < tokens.length) {
             const [res, newPos] = this.parseNextExpr(tokens, pos);
             pos = newPos;
 
-            if (res.type === 'whitespace') {
-                if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
+            if (res.head.type === TexTokenType.SPACE || res.head.type === TexTokenType.NEWLINE) {
+                if (!this.space_sensitive && res.head.value.replace(/ /g, '').length === 0) {
                     continue;
                 }
-                if (!this.newline_sensitive && res.content === '\n') {
+                if (!this.newline_sensitive && res.head.value === '\n') {
                     continue;
                 }
             }
 
-            if (res.type === 'control' && res.content === '\\\\') {
+            if (res.head.eq(new TexToken(TexTokenType.CONTROL, '\\\\'))) {
                 row = [];
-                group = new TexNode('ordgroup', '', []);
+                group = new TexGroup([]);
                 row.push(group);
                 allRows.push(row);
-            } else if (res.type === 'control' && res.content === '&') {
-                group = new TexNode('ordgroup', '', []);
+            } else if (res.head.eq(new TexToken(TexTokenType.CONTROL, '&'))) {
+                group = new TexGroup([]);
                 row.push(group);
             } else {
-                group.args!.push(res);
+                group.items.push(res);
             }
         }
         return allRows;

package/src/tex-tokenizer.ts

@@ -1,4 +1,4 @@
-import { TexToken, TexTokenType } from "./types";
+import { TexToken, TexTokenType } from "./tex-types";
 import { JSLex, Scanner } from "./jslex";
 
 export const TEX_UNARY_COMMANDS = [
@@ -46,6 +46,7 @@ export const TEX_BINARY_COMMANDS = [
     'tbinom',
     'overset',
     'underset',
+    'textcolor',
 ]
 
 
@@ -58,7 +59,7 @@ function unescape(str: string): string {
 }
 
 const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[]>([
-    // math `\begin{array}{cc}`
+    // match `\begin{array}{cc}`
     [
         String.raw`\\begin{(array|subarry)}{(.+?)}`, (s) => {
             const match = s.reMatchArray()!;
@@ -74,7 +75,7 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
         }
     ],
     [
-        String.raw`\\(text|operatorname|begin|end|hspace|array){(.+?)}`, (s) => {
+        String.raw`\\(text|operatorname|textcolor|begin|end|hspace|array){(.+?)}`, (s) => {
             const match = s.reMatchArray()!;
             return [
                 new TexToken(TexTokenType.COMMAND, '\\' + match[1]),