tex2typst 0.0.18 → 0.1.20

package/README.md

@@ -7,23 +7,38 @@ A Web UI wrapper is available at [https://qwinsi.github.io/tex2typst-webapp/](ht
 
 ## Installation
 
+## Installing it in a Node.js project
+
 ```bash
 npm install tex2typst
 ```
 
+## Or just loading it in a web page
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/tex2typst@0.1.20/dist/tex2typst.min.js"></script>
+<!-- or  -->
+<script src="https://unpkg.com/tex2typst@0.1.20/dist/tex2typst.min.js"></script>
+```
+
+Replace `0.1.20` with the latest version number in case this README is outdated.
+
 ## Usage
 
 ### Basic usage
 
 ```javascript
-import { parseTex, tex2typst } from 'tex2typst';
+import { tex2typst } from 'tex2typst';
 
 let output = tex2typst("\\zeta(s) = \\sum_{n=1}^{\\infty}\\frac{1}{n^s}");
 console.log(output);
 // zeta(s) = sum_(n = 1)^infinity frac(1, n^s)
 ```
 
-### Advanced settings
+If you are using the library in a web page via a `<script>` tag, you don't need the line of `import`, function `tex2typst` should be available in the global scope.
+
+
+### Advanced options
 
 - custom TeX macros/commands
 
@@ -33,7 +48,7 @@ let macros = {
     "\\sgn": "\\operatorname{sgn}"
 };
 let input = "y = \\sgn(x)";
-const output = tex2typst(input, {customTexMacros: macros});
+let output = tex2typst(input, {customTexMacros: macros});
 console.log(output);
 // y = op("sgn")(x)
 ```

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",
@@ -246,9 +303,6 @@ var symbolMap = new Map([
   ["gets", "arrow.l"],
   ["nonumber", ""],
   ["vec", "arrow"],
-  ["mathbf", "bold"],
-  ["boldsymbol", "bold"],
-  ["mathfrak", "frak"],
   ["neq", "eq.not"],
   ["dot", "dot"],
   ["ddot", "dot.double"],
@@ -266,8 +320,13 @@ var symbolMap = new Map([
   ["overline", "overline"],
   ["underline", "underline"],
   ["bar", "macron"],
+  ["boldsymbol", "bold"],
+  ["mathbf", "bold"],
   ["mathbb", "bb"],
   ["mathcal", "cal"],
+  ["mathfrak", "frak"],
+  ["mathsf", "sans"],
+  ["mathtt", "mono"],
   ["mathrm", "upright"],
   ["rm", "upright"],
   ["pmb", "bold"],
@@ -512,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("\\")) {
@@ -565,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) {
@@ -664,6 +726,19 @@ class TypstWriter {
         this.queue.push({ type: "atom", content: ")" });
         this.insideFunctionDepth--;
         return;
+      } else if (node.content === "\\mathbf") {
+        this.append({ type: "symbol", content: "upright" });
+        this.insideFunctionDepth++;
+        this.queue.push({ type: "atom", content: "(" });
+        this.queue.push(func_symbol);
+        this.insideFunctionDepth++;
+        this.queue.push({ type: "atom", content: "(" });
+        this.append(arg0);
+        this.queue.push({ type: "atom", content: ")" });
+        this.insideFunctionDepth--;
+        this.queue.push({ type: "atom", content: ")" });
+        this.insideFunctionDepth--;
+        return;
       } else if (node.content === "\\mathbb") {
         const body = node.args[0];
         if (body.type === "symbol" && /^[A-Z]$/.test(body.content)) {
@@ -682,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: "(" });
@@ -719,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);
@@ -739,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);
     }
@@ -760,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);
       }
@@ -829,9 +918,6 @@ function tex2typst(tex, options) {
   writer2.append(t);
   return writer2.finalize();
 }
-if (typeof window !== "undefined") {
-  window.tex2typst = tex2typst;
-}
 export {
   tex2typst
 };