tex2typst 0.3.22 → 0.3.24

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[] = [];
@@ -38,7 +61,8 @@ 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_join<T>(array: T[], sep: T): T[] {
+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_join<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/jslex.ts

@@ -15,9 +15,8 @@ interface IRule<T> {
 
 interface IMatch<T> {
     index: number;
-    text: string;
-    len: number;
     rule: IRule<T>;
+    reMatchArray: RegExpMatchArray;
 }
 
 
@@ -31,8 +30,10 @@ const EOF = {};
  * @return {int} Difference between the matches.
  */
 function matchcompare<T>(m1: IMatch<T>, m2: IMatch<T>): number {
-    if(m2.len !== m1.len) {
-        return m2.len - m1.len;
+    const m1_len = m1.reMatchArray[0].length;
+    const m2_len = m2.reMatchArray[0].length;
+    if(m2_len !== m1_len) {
+        return m2_len - m1_len;
     } else {
         return m1.index - m2.index;
     }
@@ -59,6 +60,7 @@ export class Scanner<T> {
 
     private _text: string | null = null;
     private _leng: number | null = null;
+    private _reMatchArray: RegExpMatchArray | null = null;
 
     constructor(input: string, lexer: JSLex<T>) {
         this._input = input;
@@ -77,6 +79,10 @@ export class Scanner<T> {
         return this._leng;
     }
 
+    public reMatchArray(): RegExpMatchArray | null {
+        return this._reMatchArray;
+    }
+
     /**
      * Position of in stream, line number and column number of match.
      */
@@ -180,9 +186,8 @@ export class Scanner<T> {
             if (mt !== null && mt[0].length > 0) {
                 matches.push({
                     index: i,
-                    text: mt[0],
-                    len: mt[0].length,
-                    rule: rule
+                    rule: rule,
+                    reMatchArray: mt,
                 });
             }
         }
@@ -193,22 +198,24 @@ export class Scanner<T> {
         this._go = true;
 
         let result: T | T[];
-        let m: IMatch<T>;
+        let matched_text: string;
         for (let j = 0, n = matches.length; j < n && this._go; j++) {
             this._offset = 0;
             this._less = null;
             this._go = false;
             this._newstate = null;
-            m = matches[j];
-            this._text = m.text;
-            this._leng = m.len;
+            const m = matches[j];
+            matched_text = m.reMatchArray[0];
+            this._text = matched_text;
+            this._leng = matched_text.length;
+            this._reMatchArray = m.reMatchArray;
             result = m.rule.action(this);
             if (this._newstate && this._newstate != this._state) {
                 this._state = this._newstate;
                 break;
             }
         }
-        const text = this._less === null ? m!.text : m!.text.substring(0, this._less);
+        const text = this._less === null ? matched_text! : matched_text!.substring(0, this._less);
         const len = text.length;
         this._pos += len + this._offset;
 

package/src/map.ts

@@ -1,10 +1,11 @@
 const symbolMap = new Map<string, string>([
     ['displaystyle', 'display'],
+    ['hspace', '#h'],
 
     ['|', 'bar.v.double'],
-    ['!', '#h(-math.thin.amount)'],
     [',', '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'],
@@ -1066,7 +1071,6 @@ const reverseSymbolMap = new Map<string, string>();
 for(const [key, value] of Array.from(symbolMap.entries()).reverse()) {
     reverseSymbolMap.set(value, key);
 }
-reverseSymbolMap.set('dif', 'mathrm{d}');
 reverseSymbolMap.set('oo', 'infty');
 
 // force override some one-to-multiple mappings
@@ -1078,8 +1082,6 @@ const typst_to_tex_map = new Map<string, string>([
     ['upright', 'mathrm'],
     ['bold', 'boldsymbol'],
     ['infinity', 'infty'],
-
-    ['hyph.minus', '\\text{-}'],
 ]);
 
 for(const [key, value] of typst_to_tex_map) {

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,14 +199,14 @@ 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', '',  []);
+                res.sup = new TexGroup([]);
                 for (let i = 0; i < num_prime; i++) {
-                    res.sup.args!.push(new TexNode('element', "'"));
+                    res.sup.args!.push(new TexToken(TexTokenType.ELEMENT, "'").toNode());
                 }
                 if (sup) {
                     res.sup.args!.push(sup);
@@ -217,7 +217,7 @@ export class LatexParser {
             } else if (sup) {
                 res.sup = sup;
             }
-            return [new TexNode('supsub', '', [], res), pos];
+            return [new TexSupSub(res), pos];
         } else {
             return [base, pos];
         }
@@ -230,14 +230,11 @@ export class LatexParser {
         const firstToken = tokens[start];
         switch (firstToken.type) {
             case TexTokenType.ELEMENT:
-                return [new TexNode('element', firstToken.value), start + 1];
-            case TexTokenType.TEXT:
-                return [new TexNode('text', firstToken.value), start + 1];
+            case TexTokenType.LITERAL:
             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 +263,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 +282,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 +295,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,24 +310,24 @@ 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');
                     }
                     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-                    assert(tokens[pos + 1].type === TexTokenType.TEXT);
+                    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 +337,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 +347,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 +393,10 @@ 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 args = [ body ];
+        const left = leftDelimiter.value === '.'? null: leftDelimiter;
+        const right = rightDelimiter.value === '.'? null: rightDelimiter;
+        const res = new TexLeftRight(args, {left: left, right: right});
         return [res, pos];
     }
 
@@ -412,24 +405,23 @@ export class LatexParser {
 
         let pos = start + 1;
         assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-        assert(tokens[pos + 1].type === TexTokenType.TEXT);
+        assert(tokens[pos + 1].type === TexTokenType.LITERAL);
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
         const envName = tokens[pos + 1].value;
         pos += 3;
 
-        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 args: TexNode[] = [];
+        if(['array', 'subarray'].includes(envName)) {
+            pos += eat_whitespaces(tokens, pos).length;
             const [arg, newPos] = this.parseNextArg(tokens, pos);
             args.push(arg);
             pos = newPos;
         }
 
+        pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
+
+
         const exprInsideStart = pos;
 
         const endIdx = find_closing_end_command(tokens, start);
@@ -440,7 +432,7 @@ export class LatexParser {
         pos = endIdx + 1;
 
         assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-        assert(tokens[pos + 1].type === TexTokenType.TEXT);
+        assert(tokens[pos + 1].type === TexTokenType.LITERAL);
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
         if (tokens[pos + 1].value !== envName) {
             throw new LatexParserError('Mismatched \\begin and \\end environments');
@@ -453,7 +445,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), args, body);
         return [res, pos];
     }
 
@@ -462,29 +454,29 @@ 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);

package/src/tex-tokenizer.ts

@@ -1,5 +1,4 @@
-import { TexToken, TexTokenType } from "./types";
-import { assert } from "./util";
+import { TexToken, TexTokenType } from "./tex-types";
 import { JSLex, Scanner } from "./jslex";
 
 export const TEX_UNARY_COMMANDS = [
@@ -59,15 +58,28 @@ function unescape(str: string): string {
 }
 
 const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[]>([
+    // math `\begin{array}{cc}`
     [
-        String.raw`\\(text|operatorname|begin|end|hspace){.+?}`, (s) => {
-            const text = s.text()!;
-            const command = text.substring(0, text.indexOf('{'));
-            const text_inside = text.substring(text.indexOf('{') + 1, text.lastIndexOf('}'));
+        String.raw`\\begin{(array|subarry)}{(.+?)}`, (s) => {
+            const match = s.reMatchArray()!;
             return [
-                new TexToken(TexTokenType.COMMAND, command),
+                new TexToken(TexTokenType.COMMAND, '\\begin'),
+                new TexToken(TexTokenType.CONTROL, '{'),
+                new TexToken(TexTokenType.LITERAL, match[1]),
+                new TexToken(TexTokenType.CONTROL, '}'),
+                new TexToken(TexTokenType.CONTROL, '{'),
+                new TexToken(TexTokenType.LITERAL, match[2]),
+                new TexToken(TexTokenType.CONTROL, '}'),
+            ]
+        }
+    ],
+    [
+        String.raw`\\(text|operatorname|begin|end|hspace|array){(.+?)}`, (s) => {
+            const match = s.reMatchArray()!;
+            return [
+                new TexToken(TexTokenType.COMMAND, '\\' + match[1]),
                 new TexToken(TexTokenType.CONTROL, '{'),
-                new TexToken(TexTokenType.TEXT, unescape(text_inside)),
+                new TexToken(TexTokenType.LITERAL, unescape(match[2])),
                 new TexToken(TexTokenType.CONTROL, '}')
             ]
         }
@@ -80,14 +92,11 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
     [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(TexTokenType.ELEMENT, s.text()!)],
     // e.g. match `\frac13`, `\frac1 b`, `\frac a b`
     [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`, (s) => {
-        const text = s.text()!;
-        const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`);
-        const match = text.match(regex);
-        assert(match !== null);
+        const match = s.reMatchArray()!;
         const command = match![1];
         if (TEX_BINARY_COMMANDS.includes(command.substring(1))) {
-            const arg1 = match![2].trimStart();
-            const arg2 = match![3];
+            const arg1 = match[2].trimStart();
+            const arg2 = match[3];
             return [
                 new TexToken(TexTokenType.COMMAND, command),
                 new TexToken(TexTokenType.ELEMENT, arg1),
@@ -100,13 +109,10 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
     }],
     // e.g. match `\sqrt3`, `\sqrt a`
     [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
-        const text = s.text()!;
-        const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`);
-        const match = text.match(regex);
-        assert(match !== null);
-        const command = match![1];
+        const match = s.reMatchArray()!;
+        const command = match[1];
         if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
-            const arg1 = match![2].trimStart();
+            const arg1 = match[2].trimStart();
             return [
                 new TexToken(TexTokenType.COMMAND, command),
                 new TexToken(TexTokenType.ELEMENT, arg1),
@@ -116,10 +122,7 @@ const rules_map = new Map<string, (a: Scanner<TexToken>) => TexToken | TexToken[
             return [];
         }
     }],
-    [String.raw`\\[a-zA-Z]+`, (s) => {
-        const command = s.text()!;
-        return [ new TexToken(TexTokenType.COMMAND, command), ];
-    }],
+    [String.raw`\\[a-zA-Z]+`, (s) => new TexToken(TexTokenType.COMMAND, s.text()!)],
     // Numbers like "123", "3.14"
     [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TexToken(TexTokenType.ELEMENT, s.text()!)],
     [String.raw`[a-zA-Z]`, (s) => new TexToken(TexTokenType.ELEMENT, s.text()!)],