tex2typst 0.5.4 → 0.5.6

package/src/tex-parser.ts

@@ -40,7 +40,7 @@ function eat_whitespaces(tokens: TexToken[], start: number): TexToken[] {
 
 function eat_parenthesis(tokens: TexToken[], start: number): TexToken | null {
     const firstToken = tokens[start];
-    if (firstToken.type === TexTokenType.ELEMENT && ['(', ')', '[', ']', '|', '\\{', '\\}', '.', '\\|'].includes(firstToken.value)) {
+    if (firstToken.type === TexTokenType.ELEMENT && ['(', ')', '[', ']', '|', '\\{', '\\}', '.', '\\|', '<', '>'].includes(firstToken.value)) {
         return firstToken;
     } else if (firstToken.type === TexTokenType.COMMAND && ['lfloor', 'rfloor', 'lceil', 'rceil', 'langle', 'rangle', 'lparen', 'rparen', 'lbrace', 'rbrace'].includes(firstToken.value.slice(1))) {
         return firstToken;
@@ -58,6 +58,29 @@ function eat_primes(tokens: TexToken[], start: number): number {
 }
 
 
+function process_styled_parts(nodes: TexNode[]): TexNode[] {
+    let style_token: TexToken | null = null;
+    let bucket: TexNode[] = [];
+    let res: TexNode[] = [];
+    let i = 0;
+    while(true) {
+        if (i === nodes.length || nodes[i].head.eq(TexToken.COMMAND_DISPLAYSTYLE) || nodes[i].head.eq(TexToken.COMMAND_TEXTSTYLE)) {
+            if(bucket.length > 0) {
+                const g = (bucket.length === 1)? bucket[0]: new TexGroup(bucket);
+                res.push(style_token? new TexFuncCall(style_token, [g]): g);
+            }
+            if (i === nodes.length) {
+                break;
+            }
+            bucket = [];
+            style_token = nodes[i].head;
+        } else {
+            bucket.push(nodes[i]);
+        }
+        i++;
+    }
+    return res;
+}
 
 const LEFT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\left');
 const RIGHT_COMMAND: TexToken = new TexToken(TexTokenType.COMMAND, '\\right');
@@ -137,7 +160,7 @@ export class LatexParser {
             return [EMPTY_NODE, -1];
         }
 
-        const styledResults = this.applyStyleCommands(results);
+        const styledResults = process_styled_parts(results);
 
         let node: TexNode;
         if (styledResults.length === 1) {
@@ -462,36 +485,6 @@ export class LatexParser {
         this.alignmentDepth--;
         return [allRows, pos];
     }
-
-    private applyStyleCommands(nodes: TexNode[]): TexNode[] {
-        for (let i = 0; i < nodes.length; i++) {
-            const styleToken = this.getStyleToken(nodes[i]);
-            if (styleToken) {
-                const before = this.applyStyleCommands(nodes.slice(0, i));
-                const after = this.applyStyleCommands(nodes.slice(i + 1));
-                let body: TexNode;
-                if (after.length === 0) {
-                    body = EMPTY_NODE;
-                } else if (after.length === 1) {
-                    body = after[0];
-                } else {
-                    body = new TexGroup(after);
-                }
-                const funcCall = new TexFuncCall(styleToken, [body]);
-                return before.concat(funcCall);
-            }
-        }
-        return nodes;
-    }
-
-    private getStyleToken(node: TexNode): TexToken | null {
-        if (node.type === 'terminal') {
-            if (node.head.eq(TexToken.COMMAND_DISPLAYSTYLE) || node.head.eq(TexToken.COMMAND_TEXTSTYLE)) {
-                return node.head;
-            }
-        }
-        return null;
-    }
 }
 
 // Remove all whitespace before or after _ or ^

package/src/tex-tokenizer.ts

@@ -45,6 +45,8 @@ export const TEX_UNARY_COMMANDS = [
     // the braket package
     'bra', 'ket', 'braket', 'set',
     'Bra', 'Ket', 'Braket', 'Set',
+    'pmod',
+    'cancel',
 ]
 
 export const TEX_BINARY_COMMANDS = [

package/src/tex-writer.ts

@@ -12,15 +12,6 @@ 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]);
         }
@@ -29,6 +20,13 @@ export class TexWriter {
 
     public finalize(): string {
         this.flushQueue();
+        // "\displaystyle \displaystyle" -> "\displaystyle"
+        this.buffer = this.buffer.replace(/\\displaystyle \\displaystyle/g, "\\displaystyle");
+        // "\textstyle \textstyle" -> "\textstyle"
+        this.buffer = this.buffer.replace(/\\textstyle \\textstyle/g, "\\textstyle");
+        // remove \textstyle or \displaystyle if it is the end
+        this.buffer = this.buffer.replace(/\s?\\textstyle\s?$/, "");
+        this.buffer = this.buffer.replace(/\s?\\displaystyle\s?$/, "");
         return this.buffer;
     }
 }

package/src/typst-shorthands.ts

@@ -19,6 +19,7 @@ const shorthandMap = new Map<string, string>([
     ['dots.h', '...'],
     ['gt.triple', '>>>'],
     ['lt.triple', '<<<'],
+    ['arrow.l.r', '<->'], // Typst's documentation doesn't include this. Wondering why
     ['arrow.r', '->'],
     ['arrow.r.double', '=>'],
     ['arrow.r.squiggly', '~>'],
@@ -38,8 +39,6 @@ const shorthandMap = new Map<string, string>([
     ['minus', '-'],
     ['tilde.op', '~'],
 
-    // Typst's documentation doesn't include this. Wondering why
-    ['arrow.l.r', '<->'],
 ]);
 
 

package/src/typst-types.ts

@@ -51,6 +51,8 @@ export class TypstToken {
     public static readonly EMPTY = new TypstToken(TypstTokenType.ELEMENT, '');
     public static readonly LEFT_BRACE = new TypstToken(TypstTokenType.ELEMENT, '{');
     public static readonly RIGHT_BRACE = new TypstToken(TypstTokenType.ELEMENT, '}');
+    public static readonly LEFT_PAREN = new TypstToken(TypstTokenType.ELEMENT, '(');
+    public static readonly RIGHT_PAREN = new TypstToken(TypstTokenType.ELEMENT, ')');
     public static readonly LEFT_ANGLE = new TypstToken(TypstTokenType.SYMBOL, 'chevron.l');
     public static readonly RIGHT_ANGLE = new TypstToken(TypstTokenType.SYMBOL, 'chevron.r');
     public static readonly VERTICAL_BAR = new TypstToken(TypstTokenType.ELEMENT, '|');
@@ -60,7 +62,7 @@ export class TypstToken {
 
 
     public static readonly LEFT_DELIMITERS = [
-        new TypstToken(TypstTokenType.ELEMENT, '('),
+        TypstToken.LEFT_PAREN,
         new TypstToken(TypstTokenType.ELEMENT, '['),
         TypstToken.LEFT_BRACE,
         TypstToken.VERTICAL_BAR,
@@ -70,7 +72,7 @@ export class TypstToken {
     ];
 
     public static readonly RIGHT_DELIMITERS = [
-        new TypstToken(TypstTokenType.ELEMENT, ')'),
+        TypstToken.RIGHT_PAREN,
         new TypstToken(TypstTokenType.ELEMENT, ']'),
         TypstToken.RIGHT_BRACE,
         TypstToken.VERTICAL_BAR,
@@ -180,7 +182,7 @@ export class TypstTerminal extends TypstNode {
                 return true;
             case TypstTokenType.SYMBOL:
             case TypstTokenType.ELEMENT: {
-                if(['(', '!', '}', ']'].includes(this.head.value)) {
+                if(['(', '!', ',', ')', '}', ']'].includes(this.head.value)) {
                     return false;
                 }
                 return true;
@@ -214,7 +216,7 @@ export class TypstTerminal extends TypstNode {
     public serialize(env: TypstWriterEnvironment, options: TypstWriterOptions): TypstToken[] {
         if (this.head.type === TypstTokenType.ELEMENT) {
             if (this.head.value === ',' && env.insideFunctionDepth > 0) {
-                return [new TypstToken(TypstTokenType.SYMBOL, 'comma')];
+                return [SOFT_SPACE, new TypstToken(TypstTokenType.SYMBOL, 'comma')];
             }
         } else if (this.head.type === TypstTokenType.SYMBOL) {
             let symbol_name = this.head.value;
@@ -246,6 +248,43 @@ export class TypstTerminal extends TypstNode {
     }
 }
 
+class TypstTokenQueue {
+    private queue: TypstToken[] = [];
+
+    public pushSoftSpace() {
+        if (this.queue.length === 0) {
+            return;
+        } else if (this.queue.at(-1)!.eq(SOFT_SPACE)) {
+            return;
+        } else if (['(', '{', '['].includes(this.queue.at(-1)!.value)) {
+            return;
+        }
+        this.queue.push(SOFT_SPACE);
+    }
+
+    public pushAll(tokens: TypstToken[]) {
+        if (tokens.length == 0) {
+            return;
+        } else if (tokens[0].eq(SOFT_SPACE) && this.queue.length === 0) {
+            this.queue.push(...tokens.slice(1));
+        } else {
+            if ([')', '}', ']'].includes(tokens[0].value)) {
+                while (this.queue.at(-1)?.eq(SOFT_SPACE)) {
+                    this.queue.pop();
+                }
+            }
+            this.queue.push(...tokens);
+        }
+    }
+
+    public getQueue(): TypstToken[] {
+        const res = Array.from(this.queue);
+        while (res.at(-1)?.eq(SOFT_SPACE)) {
+            res.pop();
+        }
+        return res;
+    }
+}
 
 
 export class TypstGroup extends TypstNode {
@@ -277,28 +316,21 @@ export class TypstGroup extends TypstNode {
         if (this.items.length === 0) {
             return [];
         }
-        const queue: TypstToken[] = [];
+
+        const q = new TypstTokenQueue();
         for(let i = 0; i < this.items.length; i++) {
             const n = this.items[i];
             const tokens = n.serialize(env, options);
-            if (n.isLeftSpaceful() && i > 0) {
-                if (queue.length > 0) {
-                    const top = queue.at(-1)!;
-                    let no_need_space = false;
-                    no_need_space ||= top.eq(SOFT_SPACE);
-                    no_need_space ||= ['{', '['].includes(top.value);
-                    if (!no_need_space) {
-                        queue.push(SOFT_SPACE);
-                    }
-                }
+            if (n.isLeftSpaceful()) {
+                q.pushSoftSpace();
             }
-            queue.push(...tokens);
-            if (n.isRightSpaceful() && i < this.items.length - 1) {
-                if(!(queue.at(-1)?.eq(SOFT_SPACE))) {
-                    queue.push(SOFT_SPACE);
-                }
+            q.pushAll(tokens);
+            if (n.isRightSpaceful()) {
+                q.pushSoftSpace();
             }
         }
+
+        const queue = q.getQueue();
         // "- a" -> "-a"
         // "+ a" -> "+a"
         if (queue.length > 0 && (queue[0].eq(TypstToken.MINUS) || queue[0].eq(TypstToken.PLUS))) {
@@ -552,7 +584,9 @@ export class TypstMatrixLike extends TypstNode {
             row.forEach((cell, j) => {
                 queue.push(...cell.serialize(env, options));
                 if (j < row.length - 1) {
-                    queue.push(SOFT_SPACE);
+                    if (cell_sep.value === '&') {
+                        queue.push(SOFT_SPACE);
+                    }
                     queue.push(cell_sep);
                     queue.push(SOFT_SPACE);
                 } else {

package/src/typst-writer.ts

@@ -4,9 +4,6 @@ import { TypstToken } from "./typst-types";
 import { TypstTokenType } from "./typst-types";
 
 
-const TYPST_LEFT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '(');
-const TYPST_RIGHT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ')');
-const TYPST_COMMA: TypstToken = new TypstToken(TypstTokenType.ELEMENT, ',');
 const TYPST_NEWLINE: TypstToken = new TypstToken(TypstTokenType.SYMBOL, '\n');
 
 const SOFT_SPACE = new TypstToken(TypstTokenType.CONTROL, ' ');
@@ -53,7 +50,7 @@ export class TypstWriter {
             qu.push(token);
         }
 
-        // delete soft spaces if they are not needed
+        // delete soft spaces before or after a newline
         const dummy_token = new TypstToken(TypstTokenType.SYMBOL, '');
         for(let i = 0; i < qu.length; i++) {
             let token = qu[i];
@@ -61,18 +58,15 @@ export class TypstWriter {
                 const to_delete = (i === 0)
                                 || (i === qu.length - 1)
                                 || (qu[i - 1].type === TypstTokenType.SPACE)
-                                || qu[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS, TYPST_NEWLINE])
-                                || qu[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
+                                || qu[i - 1].eq(TYPST_NEWLINE)
+                                || qu[i + 1].eq(TYPST_NEWLINE);
                 if (to_delete) {
                     qu[i] = dummy_token;
                 }
             }
         }
 
-        qu = qu.filter((token) => !token.eq(dummy_token));
-
-        for(let i = 0; i < qu.length; i++) {
-            let token = qu[i];
+        for(const token of qu) {
             this.buffer += token.toString();
         }