tex2typst 0.0.19 → 0.1.20

package/README.md

@@ -16,12 +16,12 @@ npm install tex2typst
 ## Or just loading it in a web page
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/tex2typst@0.0.19/dist/tex2typst.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/tex2typst@0.1.20/dist/tex2typst.min.js"></script>
 <!-- or  -->
-<script src="https://unpkg.com/tex2typst@0.0.19/dist/tex2typst.min.js"></script>
+<script src="https://unpkg.com/tex2typst@0.1.20/dist/tex2typst.min.js"></script>
 ```
 
-Replace `0.0.19` with the latest version number in case this README is outdated.
+Replace `0.1.20` with the latest version number in case this README is outdated.
 
 ## Usage
 

package/dist/index.js

@@ -187,6 +187,10 @@ function katexNodeToTexNode(node) {
           }
         }
         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;
@@ -196,6 +200,44 @@ function katexNodeToTexNode(node) {
     throw e;
   }
 }
+function splitTex(tex) {
+  const lines = tex.split("\n");
+  const out_tex_list = [];
+  let current_tex = "";
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    let index = -1;
+    while (index + 1 < line.length) {
+      index = line.indexOf("%", index + 1);
+      if (index === -1) {
+        break;
+      }
+      if (index === 0 || line[index - 1] !== "\\") {
+        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 (current_tex.length > 0) {
+    out_tex_list.push(current_tex);
+  }
+  return out_tex_list;
+}
 function parseTex(tex, customTexMacros) {
   const macros = {
     "\\mod": "\\operatorname{SyMb01-mod}",
@@ -213,6 +255,7 @@ function parseTex(tex, customTexMacros) {
     "\\slash": "\\operatorname{SyMb01-slash}",
     "\\LaTeX": "\\operatorname{SyMb01-LaTeX}",
     "\\TeX": "\\operatorname{SyMb01-TeX}",
+    "\\SyMbOlNeWlInE": "\\operatorname{SyMb01-newline}",
     ...customTexMacros
   };
   const options = {
@@ -221,7 +264,21 @@ function parseTex(tex, customTexMacros) {
     strict: "ignore",
     throwOnError: false
   };
-  let treeArray = generateParseTree(tex, options);
+  const tex_list = splitTex(tex);
+  let treeArray = [];
+  for (const tex_item of tex_list) {
+    if (tex_item.startsWith("%")) {
+      const tex_node = {
+        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",
@@ -514,7 +571,9 @@ function convertToken(token) {
   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("\\")) {
@@ -567,6 +626,7 @@ class TypstWriter {
       no_need_space ||= str === "'";
       no_need_space ||= /[0-9]$/.test(this.buffer) && /^[0-9]/.test(str);
       no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
+      no_need_space ||= str.startsWith("\n");
       no_need_space ||= this.buffer === "";
       no_need_space ||= /[\s"_^{\(]$/.test(this.buffer);
       if (!no_need_space) {
@@ -697,7 +757,12 @@ class TypstWriter {
         if (this.preferTypstIntrinsic && TYPST_INTRINSIC_SYMBOLS.includes(text)) {
           this.queue.push({ type: "symbol", content: text });
         } else if (text.startsWith("SyMb01-")) {
-          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: "(" });
@@ -734,6 +799,7 @@ class TypstWriter {
       matrix.forEach((row, i) => {
         row.forEach((cell, j) => {
           if (cell.type === "ordgroup" && cell.args.length === 0) {
+            this.queue.push({ type: "atom", content: "," });
             return;
           }
           this.append(cell);
@@ -754,6 +820,8 @@ 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);
     }
@@ -775,6 +843,12 @@ 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);
       }