tex2typst 0.3.29 → 0.4.1

package/src/convert.ts

@@ -1,6 +1,6 @@
 import { TexNode, TexToken, TexTokenType, TexFuncCall, TexGroup, TexSupSub,
     TexText, TexBeginEnd, TexLeftRight, TexTerminal} from "./tex-types";
-import type { Tex2TypstOptions } from "./exposed-types";
+import type { Tex2TypstOptions, Typst2TexOptions } from "./exposed-types";
 import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMarkupFunc, TypstMatrixLike, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
 import { TypstNamedParams } from "./typst-types";
 import { TypstSupsubData } from "./typst-types";
@@ -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";
 
 
@@ -224,7 +224,7 @@ function appendWithBracketsIfNeeded(node: TypstNode): TypstNode {
     }
 }
 
-export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions = {}): TypstNode {
+export function convert_tex_node_to_typst(abstractNode: TexNode, options: Tex2TypstOptions): TypstNode {
     switch (abstractNode.type) {
         case 'terminal': {
             const node = abstractNode as TexTerminal;
@@ -433,6 +433,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 +589,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 +596,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: {
@@ -637,7 +661,9 @@ function typst_token_to_tex(token: TypstToken): TexToken {
 
 const TEX_NODE_COMMA = new TexToken(TexTokenType.ELEMENT, ',').toNode();
 
-export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
+export function convert_typst_node_to_tex(abstractNode: TypstNode, options: Typst2TexOptions): TexNode {
+    const convert_node = (node: TypstNode) => convert_typst_node_to_tex(node, options);
+
     switch (abstractNode.type) {
         case 'terminal': {
             const node = abstractNode as TypstTerminal;
@@ -676,7 +702,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
 
         case 'group': {
             const node = abstractNode as TypstGroup;
-            const args = node.items.map(convert_typst_node_to_tex);
+            const args = node.items.map(convert_node);
             const alignment_char = new TexToken(TexTokenType.CONTROL, '&').toNode();
             const newline_char = new TexToken(TexTokenType.CONTROL, '\\\\').toNode();
             if (array_includes(args, alignment_char)) {
@@ -693,7 +719,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         }
         case 'leftright': {
             const node = abstractNode as TypstLeftright;
-            const body = convert_typst_node_to_tex(node.body);
+            const body = convert_node(node.body);
             let left = node.left? typst_token_to_tex(node.left) : new TexToken(TexTokenType.ELEMENT, '.');
             let right = node.right? typst_token_to_tex(node.right) : new TexToken(TexTokenType.ELEMENT, '.');
             // const is_over_high = node.isOverHigh();
@@ -715,7 +741,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
                 case 'norm': {
                     const arg0 = node.args[0];
-                    const body = convert_typst_node_to_tex(arg0);
+                    const body = convert_node(arg0);
                     if (node.isOverHigh()) {
                         return new TexLeftRight({
                             body: body,
@@ -736,7 +762,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     const left = "\\l" + node.head.value;
                     const right = "\\r" + node.head.value;
                     const arg0 = node.args[0];
-                    const body = convert_typst_node_to_tex(arg0);
+                    const body = convert_node(arg0);
                     const left_node = new TexToken(TexTokenType.COMMAND, left);
                     const right_node = new TexToken(TexTokenType.COMMAND, right);
                     if (node.isOverHigh()) {
@@ -752,22 +778,22 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 // special hook for root
                 case 'root': {
                     const [degree, radicand] = node.args;
-                    const data = convert_typst_node_to_tex(degree);
-                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\sqrt'), [convert_typst_node_to_tex(radicand)], data);
+                    const data = convert_node(degree);
+                    return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\sqrt'), [convert_node(radicand)], data);
                 }
                 // special hook for overbrace and underbrace
                 case 'overbrace':
                 case 'underbrace': {
                     const [body, label] = node.args;
-                    const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_typst_node_to_tex(body)]);
-                    const script = convert_typst_node_to_tex(label);
+                    const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_node(body)]);
+                    const script = convert_node(label);
                     const data = node.head.value === 'overbrace' ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
                     return new TexSupSub(data);
                 }
                 // special hook for vec
                 // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
                 case 'vec': {
-                    const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+                    const tex_matrix = node.args.map(arg => [convert_node(arg)]);
                     return new TexBeginEnd(new TexToken(TexTokenType.LITERAL, 'pmatrix'), tex_matrix);
                 }
                 // special hook for op
@@ -798,21 +824,47 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                     }
                     return new TexFuncCall(
                         new TexToken(TexTokenType.COMMAND, command),
-                        [convert_typst_node_to_tex(node.args[1])]
+                        [convert_node(node.args[1])]
                     );
                 }
+                // display(...) -> \displaystyle ... \textstyle
+                // The postprocessor will remove \textstyle if it is the end of the math code
+                case 'display': {
+                    const arg0 = node.args[0];
+                    const group = new TexGroup([
+                        TexToken.COMMAND_DISPLAYSTYLE.toNode(),
+                        convert_node(arg0),
+                    ]);
+                    if (!options.blockMathMode) {
+                        group.items.push(TexToken.COMMAND_TEXTSTYLE.toNode());
+                    }
+                    return group;
+                }
+                // inline(...) -> \textstyle ... \displaystyle
+                // The postprocessor will remove \displaystyle if it is the end of the math code
+                case 'inline': {
+                    const arg0 = node.args[0];
+                    const group = new TexGroup([
+                        TexToken.COMMAND_TEXTSTYLE.toNode(),
+                        convert_node(arg0),
+                    ]);
+                    if (options.blockMathMode) {
+                        group.items.push(TexToken.COMMAND_DISPLAYSTYLE.toNode());
+                    }
+                    return group;
+                }
                 // general case
                 default: {
                     const func_name_tex = typst_token_to_tex(node.head);
                     const is_known_func = TEX_UNARY_COMMANDS.includes(func_name_tex.value.substring(1))
                                             || TEX_BINARY_COMMANDS.includes(func_name_tex.value.substring(1));
                     if (func_name_tex.value.length > 0 && is_known_func) {
-                        return new TexFuncCall(func_name_tex, node.args.map(convert_typst_node_to_tex));
+                        return new TexFuncCall(func_name_tex, node.args.map(convert_node));
                     } else {
                         return new TexGroup([
                             typst_token_to_tex(node.head).toNode(),
                             new TexToken(TexTokenType.ELEMENT, '(').toNode(),
-                            ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+                            ...array_intersperse(node.args.map(convert_node), TEX_NODE_COMMA),
                             new TexToken(TexTokenType.ELEMENT, ')').toNode()
                         ]);
                     }
@@ -828,7 +880,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                         const color = node.options['fill'];
                         return new TexFuncCall(
                             new TexToken(TexTokenType.COMMAND, '\\textcolor'),
-                            [convert_typst_node_to_tex(color), convert_typst_node_to_tex(node.fragments[0])]
+                            [convert_node(color), convert_node(node.fragments[0])]
                         )
                     }
                 }
@@ -840,8 +892,8 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         case 'supsub': {
             const node = abstractNode as TypstSupsub;
             const { base, sup, sub } = node;
-            const sup_tex = sup? convert_typst_node_to_tex(sup) : null;
-            const sub_tex = sub? convert_typst_node_to_tex(sub) : null;
+            const sup_tex = sup? convert_node(sup) : null;
+            const sub_tex = sub? convert_node(sub) : null;
 
             // special hook for limits
             // `limits(+)^a` -> `\overset{a}{+}`
@@ -849,7 +901,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
             // `limits(+)_a^b` -> `\overset{b}{\underset{a}{+}}`
             if (base.head.eq(new TypstToken(TypstTokenType.SYMBOL, 'limits'))) {
                 const limits = base as TypstFuncCall;
-                const body_in_limits = convert_typst_node_to_tex(limits.args[0]);
+                const body_in_limits = convert_node(limits.args[0]);
                 if (sup_tex !== null && sub_tex === null) {
                     return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\overset'), [sup_tex, body_in_limits]);
                 } else if (sup_tex === null && sub_tex !== null) {
@@ -860,7 +912,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
                 }
             }
 
-            const base_tex = convert_typst_node_to_tex(base);
+            const base_tex = convert_node(base);
 
             const res = new TexSupSub({
                 base: base_tex,
@@ -871,7 +923,7 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         }
         case 'matrixLike': {
             const node = abstractNode as TypstMatrixLike;
-            const tex_matrix = node.matrix.map(row => row.map(convert_typst_node_to_tex));
+            const tex_matrix = node.matrix.map(row => row.map(convert_node));
             if (node.head.eq(TypstMatrixLike.MAT)) {
                 let env_type = 'pmatrix'; // typst mat use delim:"(" by default
                 if (node.options) {
@@ -918,8 +970,8 @@ export function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode {
         case 'fraction': {
             const node = abstractNode as TypstFraction;
             const [numerator, denominator] = node.args;
-            const num_tex = convert_typst_node_to_tex(numerator);
-            const den_tex = convert_typst_node_to_tex(denominator);
+            const num_tex = convert_node(numerator);
+            const den_tex = convert_node(denominator);
             return new TexFuncCall(new TexToken(TexTokenType.COMMAND, '\\frac'), [num_tex, den_tex]);
         }
         default:

package/src/exposed-types.ts

@@ -6,17 +6,21 @@
  * 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; };
+    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 interface Typst2TexOptions {
+    blockMathMode: boolean; /** default is true */
+}
+
+export declare function tex2typst(tex: string, options?: Partial<Tex2TypstOptions>): string;
+export declare function typst2tex(typst: string, options?: Partial<Typst2TexOptions>): string;
 
 export declare const symbolMap: Map<string, string>;
 export declare const shorthandMap: Map<string, string>;

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) {

package/src/index.ts

@@ -1,5 +1,5 @@
 import { parseTex } from "./tex-parser";
-import type { Tex2TypstOptions } from "./exposed-types";
+import type { Tex2TypstOptions, Typst2TexOptions } from "./exposed-types";
 import { TypstWriter } from "./typst-writer";
 import { type TypstWriterOptions } from "./typst-types";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
@@ -9,7 +9,7 @@ import { TexWriter } from "./tex-writer";
 import { shorthandMap } from "./typst-shorthands";
 
 
-export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
+export function tex2typst(tex: string, options: Partial<Tex2TypstOptions> = {}): string {
     const opt: Tex2TypstOptions = {
         nonStrict: true,
         preferShorthands: true,
@@ -20,14 +20,12 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
         customTexMacros: {}
     };
 
-    if(options !== undefined) {
-        if (typeof options !== 'object') {
-            throw new Error("options must be an object");
-        }
-        for (const key in opt) {
-            if (key in options) {
-                opt[key as keyof Tex2TypstOptions] = options[key as keyof Tex2TypstOptions] as any;
-            }
+    if (typeof options !== 'object') {
+        throw new Error("options must be an object");
+    }
+    for (const key in opt) {
+        if (key in options) {
+            opt[key as keyof Tex2TypstOptions] = options[key as keyof Tex2TypstOptions] as any;
         }
     }
 
@@ -38,9 +36,22 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     return writer.finalize();
 }
 
-export function typst2tex(typst: string): string {
+export function typst2tex(typst: string, options: Partial<Typst2TexOptions> = {}): string {
+    const opt: Typst2TexOptions = {
+        blockMathMode: true,
+    };
+
+    if (typeof options !== 'object') {
+        throw new Error("options must be an object");
+    }
+    for (const key in opt) {
+        if (key in options) {
+            opt[key as keyof Typst2TexOptions] = options[key as keyof Typst2TexOptions] as any;
+        }
+    }
+
     const typstTree = parseTypst(typst);
-    const texTree = convert_typst_node_to_tex(typstTree);
+    const texTree = convert_typst_node_to_tex(typstTree, opt);
     const writer = new TexWriter();
     writer.append(texTree);
     return writer.finalize();

package/src/map.ts

@@ -1,5 +1,6 @@
 const symbolMap = new Map<string, string>([
     ['displaystyle', 'display'],
+    ['textstyle', 'inline'],
     ['hspace', '#h'],
 
     ['|', 'bar.v.double'],

package/src/tex-parser.ts

@@ -1,6 +1,6 @@
 import { TexBeginEnd, TexFuncCall, TexLeftRight, TexNode, TexGroup, TexSupSub, TexSupsubData, TexText, TexToken, TexTokenType } from "./tex-types";
-import { assert } from "./util";
-import { array_find, array_join } from "./generic";
+import { assert } from "./utils";
+import { array_find, array_join, array_split } from "./generic";
 import { TEX_BINARY_COMMANDS, TEX_UNARY_COMMANDS, tokenize_tex } from "./tex-tokenizer";
 
 const IGNORED_COMMANDS = [
@@ -446,59 +446,31 @@ export class LatexParser {
         // ignore whitespaces and '\n' after \begin{envName}
         pos += eat_whitespaces(tokens, pos).length;
 
-        const allRows: TexNode[][] = [];
-        let row: TexNode[] = [];
-        allRows.push(row);
-        let group = new TexGroup([]);
-        row.push(group);
+        let closure: TexNode;
+        [closure, pos] = this.parseClosure(tokens, pos, closingToken);
 
-        while (pos < tokens.length) {
-            if (tokens[pos].eq(closingToken)) {
-                break;
-            }
-
-            const [res, newPos] = this.parseNextExpr(tokens, pos);
-            pos = newPos;
-
-            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.head.value === '\n') {
-                    continue;
-                }
-            }
-
-            if (res.head.eq(new TexToken(TexTokenType.CONTROL, '\\\\'))) {
-                row = [];
-                group = new TexGroup([]);
-                row.push(group);
-                allRows.push(row);
-            } else if (res.head.eq(new TexToken(TexTokenType.CONTROL, '&'))) {
-                group = new TexGroup([]);
-                row.push(group);
-            } else {
-                group.items.push(res);
-            }
-        }
-
-        if (pos >= tokens.length) {
+        if (pos === -1) {
             return [[], -1];
         }
 
-        // ignore spaces and '\n' before \end{envName}
-        if (allRows.length > 0 && allRows[allRows.length - 1].length > 0) {
-            const last_cell = allRows[allRows.length - 1][allRows[allRows.length - 1].length - 1];
-            if (last_cell.type === 'ordgroup') {
-                const last_cell_items = (last_cell as TexGroup).items;
-                while(last_cell_items.length > 0 && [TexTokenType.SPACE, TexTokenType.NEWLINE].includes(last_cell_items[last_cell_items.length - 1].head.type)) {
-                    last_cell_items.pop();
-                }
+        let allRows: TexNode[][];
+        if (closure.type === 'ordgroup') {
+            const elements = (closure as TexGroup).items;
+            // ignore spaces and '\n' before \end{envName}
+            while(elements.length > 0 && [TexTokenType.SPACE, TexTokenType.NEWLINE].includes(elements[elements.length - 1].head.type)) {
+                elements.pop();
             }
+            allRows = array_split(elements, new TexToken(TexTokenType.CONTROL, '\\\\').toNode())
+                      .map(row => {
+                          return array_split(row, new TexToken(TexTokenType.CONTROL, '&').toNode())
+                                   .map(arr => new TexGroup(arr));
+                      });
+        } else {
+            allRows = [[closure]];
         }
 
         this.alignmentDepth--;
-        return [allRows, pos + 1];
+        return [allRows, pos];
     }
 }
 

package/src/tex-tokenizer.ts

@@ -41,6 +41,7 @@ export const TEX_UNARY_COMMANDS = [
     'mathrel',
     'mathbin',
     'mathop',
+    'not',
 ]
 
 export const TEX_BINARY_COMMANDS = [

package/src/tex-types.ts

@@ -1,4 +1,4 @@
-import { assert } from "./util";
+import { assert } from "./utils";
 
 /**
  * ELEMENT: 0-9, a-z, A-Z, punctuations such as +-/*,:; etc.
@@ -44,6 +44,8 @@ export class TexToken {
     }
 
     public static readonly EMPTY = new TexToken(TexTokenType.EMPTY, '');
+    public static readonly COMMAND_DISPLAYSTYLE = new TexToken(TexTokenType.COMMAND, '\\displaystyle');
+    public static readonly COMMAND_TEXTSTYLE = new TexToken(TexTokenType.COMMAND, '\\textstyle');
 }
 
 

package/src/tex-writer.ts

@@ -1,4 +1,4 @@
-import { TexNode, TexToken, writeTexTokenBuffer } from "./tex-types";
+import { TexNode, TexToken, TexTokenType, writeTexTokenBuffer } from "./tex-types";
 
 
 
@@ -12,6 +12,15 @@ export class TexWriter {
     }
 
     protected flushQueue() {
+        // remove \textstyle or \displaystyle if it is the end of the math code
+        while (this.queue.length > 0) {
+            const last_token = this.queue[this.queue.length - 1];
+            if (last_token.eq(TexToken.COMMAND_DISPLAYSTYLE) || last_token.eq(TexToken.COMMAND_TEXTSTYLE)) {
+                this.queue.pop();
+            } else {
+                break;
+            }
+        }
         for (let i = 0; i < this.queue.length; i++) {
             this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
         }