tex2typst 0.0.19 → 0.1.20

package/dist/types.d.ts

@@ -19,7 +19,7 @@ export interface TexNode {
     irregularData?: TexSqrtData | TexSupsubData | TexArrayData;
 }
 export interface TypstNode {
-    type: 'atom' | 'symbol' | 'text' | 'softSpace';
+    type: 'atom' | 'symbol' | 'text' | 'softSpace' | 'comment' | 'newline';
     content: string;
     args?: TypstNode[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tex2typst",
-  "version": "0.0.19",
+  "version": "0.1.20",
   "description": "JavaScript library for converting TeX code to Typst",
   "type": "module",
   "main": "dist/index.js",

package/src/parser.ts

@@ -228,6 +228,10 @@ export function katexNodeToTexNode(node: KatexParseNode): TexNode {
                     }
                 }
                 throw new KatexNodeToTexNodeError(`Unknown error type in parsed result:`, node);
+            case 'comment':
+                res.type = 'comment';
+                res.content = node.text!;
+                break;
             default:
                 throw new KatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
                 break;
@@ -238,6 +242,61 @@ export function katexNodeToTexNode(node: KatexParseNode): TexNode {
     }
 }
 
+// Split tex into a list of tex strings and comments.
+// Each item in the returned list is either a tex snippet or a comment.
+// Each comment item is a string starting with '%'.
+function splitTex(tex: string): string[] {
+    const lines = tex.split("\n");
+    const out_tex_list: string[] = [];
+    let current_tex = "";
+    // let inside_begin_depth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // if (line.includes('\\begin{')) {
+            // inside_begin_depth += line.split('\\begin{').length - 1;
+        // }
+
+        let index = -1;
+        while (index + 1 < line.length) {
+            index = line.indexOf('%', index + 1);
+            if (index === -1) {
+                // No comment in this line
+                break;
+            }
+            if (index === 0 || line[index - 1] !== '\\') {
+                // Found a comment
+                break;
+            }
+        }
+        if (index !== -1) {
+            current_tex += line.substring(0, index);
+            const comment = line.substring(index);
+            out_tex_list.push(current_tex);
+            current_tex = "";
+            out_tex_list.push(comment);
+        } else {
+            current_tex += line;
+        }
+        if (i < lines.length - 1) {
+            const has_begin_command = line.includes('\\begin{');
+            const followed_by_end_command = lines[i + 1].includes('\\end{');
+            if(!has_begin_command && !followed_by_end_command) {
+                current_tex += "\\SyMbOlNeWlInE ";
+            }
+        }
+
+        // if (line.includes('\\end{')) {
+            // inside_begin_depth -= line.split('\\end{').length - 1;
+        // }
+    }
+
+    if (current_tex.length > 0) {
+        out_tex_list.push(current_tex);
+    }
+
+    return out_tex_list;
+}
+
 export function parseTex(tex: string, customTexMacros: {[key: string]: string}): TexNode {
     // displayMode=true. Otherwise, "KaTeX parse error: {align*} can be used only in display mode."
     const macros = {
@@ -257,6 +316,7 @@ export function parseTex(tex: string, customTexMacros: {[key: string]: string}):
         '\\slash': '\\operatorname{SyMb01-slash}',
         '\\LaTeX': '\\operatorname{SyMb01-LaTeX}',
         '\\TeX': '\\operatorname{SyMb01-TeX}',
+        '\\SyMbOlNeWlInE': '\\operatorname{SyMb01-newline}',
         ...customTexMacros
     };
     const options = {
@@ -265,7 +325,25 @@ export function parseTex(tex: string, customTexMacros: {[key: string]: string}):
         strict: "ignore",
         throwOnError: false
     };
-    let treeArray = generateParseTree(tex, options);
+
+    const tex_list = splitTex(tex);
+
+    let treeArray: KatexParseNode[] = [];
+
+    for (const tex_item of tex_list) {
+        if (tex_item.startsWith('%')) {
+            const tex_node: KatexParseNode = {
+                type: 'comment',
+                mode: 'math',
+                text: tex_item.substring(1),
+            };
+            treeArray.push(tex_node);
+            continue;
+        }
+        const trees = generateParseTree(tex_item, options);
+        treeArray = treeArray.concat(trees);
+    }
+
     let t =  {
         type: 'ordgroup',
         mode: 'math',

package/src/types.ts

@@ -28,7 +28,7 @@ export interface TexNode {
 }
 
 export interface TypstNode {
-    type: 'atom' | 'symbol' | 'text' | 'softSpace';
+    type: 'atom' | 'symbol' | 'text' | 'softSpace' | 'comment' | 'newline',
     content: string;
     args?: TypstNode[];
 }

package/src/writer.ts

@@ -55,6 +55,8 @@ export class TypstWriter {
             no_need_space ||= /[0-9]$/.test(this.buffer) && /^[0-9]/.test(str);
             // leading sign
             no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
+            // new line
+            no_need_space ||= str.startsWith('\n');
             // buffer is empty
             no_need_space ||= this.buffer === "";
             // other cases
@@ -210,7 +212,12 @@ export class TypstWriter {
                     this.queue.push({ type: 'symbol', content: text});
                 } else if (text.startsWith('SyMb01-')) {
                     // special hacks made in parseTex()
-                    this.queue.push({ type: 'symbol', content: '\\' + text.substring(7)});
+                    const special_symbol = text.substring(7);
+                    if (special_symbol === 'newline') {
+                        this.queue.push({ type: 'newline', content: '\n'});
+                        return;
+                    }
+                    this.queue.push({ type: 'symbol', content: '\\' + special_symbol});
                 } else {
                     this.queue.push({ type: 'symbol', content: 'op' });
                     this.queue.push({ type: 'atom', content: '('});
@@ -249,8 +256,12 @@ export class TypstWriter {
                 row.forEach((cell, j) => {
                     // There is a leading & in row
                     if (cell.type === 'ordgroup' && cell.args!.length === 0) {
+                        this.queue.push({ type: 'atom', content: ',' });
                         return;
                     }
+                    // if (j == 0 && cell.type === 'newline' && cell.content === '\n') {
+                        // return;
+                    // }
                     this.append(cell);
                     // cell.args!.forEach((n) => this.append(n));
                     if (j < row.length - 1) {
@@ -270,6 +281,8 @@ export class TypstWriter {
             } else {
                 throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
             }
+        } else if (node.type === 'comment') {
+            this.queue.push({ type: 'comment', content: node.content });
         } else {
             throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
         }
@@ -292,6 +305,12 @@ export class TypstWriter {
                     this.needSpaceAfterSingleItemScript = true;
                     str = '';
                     break;
+                case 'comment':
+                    str = `//${node.content}`;
+                    break;
+                case 'newline':
+                    str = '\n';
+                    break;
                 default:
                     throw new TypstWriterError(`Unexpected node type to stringify: ${node.type}`, node)
             }
@@ -350,7 +369,9 @@ function convertToken(token: string): string {
     if (/^[a-zA-Z0-9]$/.test(token)) {
         return token;
     } else if (token === '\\\\') {
-        return '\\\n';
+        return '\\';
+    } else if (token == '/') {
+        return '\\/';
     } else if (['\\$', '\\#', '\\&', '\\_'].includes(token)) {
         return token;
     } else if (token.startsWith('\\')) {