tex2typst 0.3.16 → 0.3.18

package/README.md

@@ -1,6 +1,6 @@
 # tex2typst.js
 
-JavaScript library for conversion between TeX/LaTeX and Typst math formula code.
+JavaScript library for conversion between TeX/LaTeX and Typst math code.
 
 Despite the name `tex2typst` due to the initial goal of converting TeX to Typst, the library can also convert Typst to TeX since version 0.3.0.
 
@@ -44,7 +44,7 @@ console.log(tex_recovered);
 
 If you are using the library in a web page via a `<script>` tag, you don't need the line of `import`, function `tex2typst` and `typst2tex` should be available in the global scope.
 
-tex2typst.js supports some advanced options to customize the conversion. For more details, please refer to the [API Reference](docs/api-reference.md).
+tex2typst.js supports some advanced options to customize the conversion. For details, please refer to the [API Reference](docs/api-reference.md).
 
 ## Open-source license
 

package/dist/index.js

@@ -1,6 +1,8 @@
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
   ["displaystyle", "display"],
+  ["|", "bar.v.double"],
+  ["!", "#h(-math.thin.amount)"],
   [",", "thin"],
   [":", "med"],
   [";", "thick"],
@@ -1185,6 +1187,12 @@ var TexNode = class {
       case "ordgroup": {
         return this.args.map((n) => n.serialize()).flat();
       }
+      case "leftright": {
+        let tokens = this.args.map((n) => n.serialize()).flat();
+        tokens.splice(0, 0, new TexToken(1 /* COMMAND */, "\\left"));
+        tokens.splice(tokens.length - 1, 0, new TexToken(1 /* COMMAND */, "\\right"));
+        return tokens;
+      }
       case "unaryFunc": {
         let tokens = [];
         tokens.push(new TexToken(1 /* COMMAND */, this.content));
@@ -1666,7 +1674,8 @@ var BINARY_COMMANDS = [
   "dbinom",
   "dfrac",
   "tbinom",
-  "overset"
+  "overset",
+  "underset"
 ];
 var IGNORED_COMMANDS = [
   "bigl",
@@ -1701,7 +1710,7 @@ function eat_whitespaces(tokens, start) {
 }
 function eat_parenthesis(tokens, start) {
   const firstToken = tokens[start];
-  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", "."].includes(firstToken.value)) {
+  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
     return firstToken;
   } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
     return firstToken;
@@ -1767,7 +1776,7 @@ var rules_map = /* @__PURE__ */ new Map([
   ],
   [String.raw`%[^\n]*`, (s) => new TexToken(3 /* COMMENT */, s.text().substring(1))],
   [String.raw`[{}_^&]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
-  [String.raw`\\[\\,:; ]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
+  [String.raw`\\[\\,:;! ]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
   [String.raw`\r?\n`, (_s) => new TexToken(5 /* NEWLINE */, "\n")],
   [String.raw`\s+`, (s) => new TexToken(4 /* SPACE */, s.text())],
   [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
@@ -1973,6 +1982,7 @@ var LatexParser = class {
           case "}":
             throw new LatexParserError("Unmatched '}'");
           case "\\\\":
+          case "\\!":
           case "\\,":
           case "\\:":
           case "\\;":
@@ -2108,7 +2118,17 @@ var LatexParser = class {
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     const envName = tokens[pos + 1].value;
     pos += 3;
-    pos += eat_whitespaces(tokens, pos).length;
+    const args = [];
+    while (pos < tokens.length) {
+      const whitespaceCount = eat_whitespaces(tokens, pos).length;
+      pos += whitespaceCount;
+      if (pos >= tokens.length || !tokens[pos].eq(LEFT_CURLY_BRACKET)) {
+        break;
+      }
+      const [arg, newPos] = this.parseNextArg(tokens, pos);
+      args.push(arg);
+      pos = newPos;
+    }
     const exprInsideStart = pos;
     const endIdx = find_closing_end_command(tokens, start);
     if (endIdx === -1) {
@@ -2128,7 +2148,7 @@ var LatexParser = class {
       exprInside.pop();
     }
     const body = this.parseAligned(exprInside);
-    const res = new TexNode("beginend", envName, [], body);
+    const res = new TexNode("beginend", envName, args, body);
     return [res, pos];
   }
   parseAligned(tokens) {
@@ -2275,14 +2295,15 @@ var TypstWriterError = class extends Error {
   }
 };
 var TypstWriter = class {
-  constructor(opt) {
+  constructor(options) {
     this.buffer = "";
     this.queue = [];
     this.insideFunctionDepth = 0;
-    this.nonStrict = opt.nonStrict;
-    this.preferShorthands = opt.preferShorthands;
-    this.keepSpaces = opt.keepSpaces;
-    this.inftyToOo = opt.inftyToOo;
+    this.nonStrict = options.nonStrict;
+    this.preferShorthands = options.preferShorthands;
+    this.keepSpaces = options.keepSpaces;
+    this.inftyToOo = options.inftyToOo;
+    this.optimize = options.optimize;
   }
   writeBuffer(token) {
     const str = token.toString();
@@ -2407,21 +2428,9 @@ var TypstWriter = class {
       }
       case "fraction": {
         const [numerator, denominator] = node.args;
-        if (numerator.type === "group") {
-          this.queue.push(TYPST_LEFT_PARENTHESIS);
-          this.serialize(numerator);
-          this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        } else {
-          this.serialize(numerator);
-        }
+        this.appendWithBracketsIfNeeded(numerator);
         this.queue.push(new TypstToken(2 /* ELEMENT */, "/"));
-        if (denominator.type === "group") {
-          this.queue.push(TYPST_LEFT_PARENTHESIS);
-          this.serialize(denominator);
-          this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        } else {
-          this.serialize(denominator);
-        }
+        this.appendWithBracketsIfNeeded(denominator);
         break;
       }
       case "align": {
@@ -2506,7 +2515,7 @@ var TypstWriter = class {
     }
   }
   appendWithBracketsIfNeeded(node) {
-    let need_to_wrap = ["group", "supsub", "empty"].includes(node.type);
+    let need_to_wrap = ["group", "supsub", "fraction", "empty"].includes(node.type);
     if (node.type === "group") {
       if (node.args.length === 0) {
         need_to_wrap = true;
@@ -2561,9 +2570,11 @@ var TypstWriter = class {
       res = res.replace(/round\(\)/g, 'round("")');
       return res;
     };
-    const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
-    for (const pass of all_passes) {
-      this.buffer = pass(this.buffer);
+    if (this.optimize) {
+      const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
+      for (const pass of all_passes) {
+        this.buffer = pass(this.buffer);
+      }
     }
     return this.buffer;
   }
@@ -2585,8 +2596,6 @@ function tex_token_to_typst(token) {
     return token;
   } else if (token === "/") {
     return "\\/";
-  } else if (token === "\\|") {
-    return "parallel";
   } else if (token === "\\\\") {
     return "\\";
   } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
@@ -2603,39 +2612,48 @@ function tex_token_to_typst(token) {
 }
 function convert_overset(node, options) {
   const [sup, base] = node.args;
-  const is_def = (n) => {
-    if (n.eq(new TexNode("text", "def"))) {
-      return true;
-    }
-    if (n.type === "ordgroup" && n.args.length === 3) {
-      const [a1, a2, a3] = n.args;
-      const d = new TexNode("element", "d");
-      const e = new TexNode("element", "e");
-      const f = new TexNode("element", "f");
-      if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
+  if (options.optimize) {
+    const is_def = (n) => {
+      if (n.eq(new TexNode("text", "def"))) {
         return true;
       }
+      if (n.type === "ordgroup" && n.args.length === 3) {
+        const [a1, a2, a3] = n.args;
+        const d = new TexNode("element", "d");
+        const e = new TexNode("element", "e");
+        const f = new TexNode("element", "f");
+        if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const is_eq = (n) => n.eq(new TexNode("element", "="));
+    if (is_def(sup) && is_eq(base)) {
+      return new TypstNode("symbol", "eq.def");
     }
-    return false;
-  };
-  const is_eq = (n) => n.eq(new TexNode("element", "="));
-  if (is_def(sup) && is_eq(base)) {
-    return new TypstNode("symbol", "eq.def");
   }
   const limits_call = new TypstNode(
     "funcCall",
     "limits",
     [convert_tex_node_to_typst(base, options)]
   );
-  return new TypstNode(
-    "supsub",
-    "",
-    [],
-    {
-      base: limits_call,
-      sup: convert_tex_node_to_typst(sup, options)
-    }
+  return new TypstNode("supsub", "", [], {
+    base: limits_call,
+    sup: convert_tex_node_to_typst(sup, options)
+  });
+}
+function convert_underset(node, options) {
+  const [sub, base] = node.args;
+  const limits_call = new TypstNode(
+    "funcCall",
+    "limits",
+    [convert_tex_node_to_typst(base, options)]
   );
+  return new TypstNode("supsub", "", [], {
+    base: limits_call,
+    sub: convert_tex_node_to_typst(sub, options)
+  });
 }
 function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
@@ -2695,39 +2713,51 @@ function convert_tex_node_to_typst(node, options = {}) {
       return new TypstNode("supsub", "", [], data);
     }
     case "leftright": {
-      const [left, body, right] = node.args;
+      const [left, _body, right] = node.args;
+      const [typ_left, typ_body, typ_right] = node.args.map((n) => convert_tex_node_to_typst(n, options));
+      if (options.optimize) {
+        if (left.content === "\\|" && right.content === "\\|") {
+          return new TypstNode("funcCall", "norm", [typ_body]);
+        }
+        if ([
+          "[]",
+          "()",
+          "\\{\\}",
+          "\\lfloor\\rfloor",
+          "\\lceil\\rceil",
+          "\\lfloor\\rceil"
+        ].includes(left.content + right.content)) {
+          return new TypstNode("group", "", [typ_left, typ_body, typ_right]);
+        }
+      }
       const group = new TypstNode(
         "group",
         "",
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
+        [typ_left, typ_body, typ_right]
       );
-      if ([
-        "[]",
-        "()",
-        "\\{\\}",
-        "\\lfloor\\rfloor",
-        "\\lceil\\rceil",
-        "\\lfloor\\rceil"
-      ].includes(left.content + right.content)) {
-        return group;
-      }
+      const escape_curly_or_paren = function(s) {
+        if (["(", ")", "{", "["].includes(s)) {
+          return "\\" + s;
+        } else {
+          return s;
+        }
+      };
       if (right.content === ".") {
-        group.args.pop();
-        return group;
+        typ_left.content = escape_curly_or_paren(typ_left.content);
+        group.args = [typ_left, typ_body];
       } else if (left.content === ".") {
-        group.args.shift();
-        return new TypstNode("funcCall", "lr", [group]);
+        typ_right.content = escape_curly_or_paren(typ_right.content);
+        group.args = [typ_body, typ_right];
       }
-      return new TypstNode(
-        "funcCall",
-        "lr",
-        [group]
-      );
+      return new TypstNode("funcCall", "lr", [group]);
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
         return convert_overset(node, options);
       }
+      if (node.content === "\\underset") {
+        return convert_underset(node, options);
+      }
       if (node.content === "\\frac") {
         if (options.fracToSlash) {
           return new TypstNode(
@@ -2817,6 +2847,49 @@ function convert_tex_node_to_typst(node, options = {}) {
       if (node.content === "cases") {
         return new TypstNode("cases", "", [], data);
       }
+      if (node.content === "array") {
+        const res = new TypstNode("matrix", "", [], data);
+        const options2 = { "delim": TYPST_NONE };
+        const align_args = node.args;
+        if (align_args.length > 0) {
+          const align_node = align_args[0];
+          const align_str = (() => {
+            if (align_node.type === "element") return align_node.content;
+            if (align_node.type === "ordgroup") {
+              return align_node.args.map((n) => n.type === "element" ? n.content : "").join("");
+            }
+            return "";
+          })();
+          if (align_str) {
+            const alignMap = { l: "#left", c: "#center", r: "#right" };
+            const chars = Array.from(align_str);
+            const alignments = chars.map((c) => alignMap[c]).filter(Boolean).map((s) => new TypstNode("symbol", s));
+            const vlinePositions = [];
+            let columnIndex = 0;
+            for (const c of chars) {
+              if (c === "|") {
+                vlinePositions.push(columnIndex);
+              } else if (c === "l" || c === "c" || c === "r") {
+                columnIndex++;
+              }
+            }
+            if (vlinePositions.length > 0) {
+              if (vlinePositions.length === 1) {
+                options2["augment"] = new TypstNode("symbol", `#${vlinePositions[0]}`);
+              } else {
+                options2["augment"] = new TypstNode("symbol", `#(vline: (${vlinePositions.join(", ")}))`);
+              }
+            }
+            if (alignments.length > 0) {
+              const first_align = alignments[0].content;
+              const all_same = alignments.every((item) => item.content === first_align);
+              options2["align"] = all_same ? alignments[0] : new TypstNode("symbol", "#center");
+            }
+          }
+        }
+        res.setOptions(options2);
+        return res;
+      }
       if (node.content.endsWith("matrix")) {
         let delim;
         switch (node.content) {
@@ -2881,7 +2954,9 @@ var TYPST_UNARY_FUNCTIONS = [
   "cal",
   "frak",
   "floor",
-  "ceil"
+  "ceil",
+  "norm",
+  "limits"
 ];
 var TYPST_BINARY_FUNCTIONS = [
   "frac",
@@ -2898,8 +2973,6 @@ function apply_escape_if_needed2(c) {
 function typst_token_to_tex(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
-  } else if (token === "thin") {
-    return "\\,";
   } else if (reverseSymbolMap.has(token)) {
     return "\\" + reverseSymbolMap.get(token);
   }
@@ -2964,15 +3037,21 @@ function convert_typst_node_to_tex(node) {
             return new TexNode("ordgroup", "", node.args.map(convert_typst_node_to_tex));
           }
         }
+        if (node.content === "norm") {
+          const arg0 = node.args[0];
+          const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
+          return new TexNode(tex_node_type, "", [
+            new TexNode("symbol", "\\|"),
+            convert_typst_node_to_tex(arg0),
+            new TexNode("symbol", "\\|")
+          ]);
+        }
         if (node.content === "floor" || node.content === "ceil") {
-          let left = "\\l" + node.content;
-          let right = "\\r" + node.content;
+          const left = "\\l" + node.content;
+          const right = "\\r" + node.content;
           const arg0 = node.args[0];
-          if (arg0.isOverHigh()) {
-            left = "\\left" + left;
-            right = "\\right" + right;
-          }
-          return new TexNode("ordgroup", "", [
+          const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
+          return new TexNode(tex_node_type, "", [
             new TexNode("symbol", left),
             convert_typst_node_to_tex(arg0),
             new TexNode("symbol", right)
@@ -3010,7 +3089,6 @@ function convert_typst_node_to_tex(node) {
     }
     case "supsub": {
       const { base, sup, sub } = node.data;
-      const base_tex = convert_typst_node_to_tex(base);
       let sup_tex;
       let sub_tex;
       if (sup) {
@@ -3019,6 +3097,18 @@ function convert_typst_node_to_tex(node) {
       if (sub) {
         sub_tex = convert_typst_node_to_tex(sub);
       }
+      if (base.eq(new TypstNode("funcCall", "limits"))) {
+        const body_in_limits = convert_typst_node_to_tex(base.args[0]);
+        if (sup_tex !== void 0 && sub_tex === void 0) {
+          return new TexNode("binaryFunc", "\\overset", [sup_tex, body_in_limits]);
+        } else if (sup_tex === void 0 && sub_tex !== void 0) {
+          return new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
+        } else {
+          const underset_call = new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
+          return new TexNode("binaryFunc", "\\overset", [sup_tex, underset_call]);
+        }
+      }
+      const base_tex = convert_typst_node_to_tex(base);
       const res = new TexNode("supsub", "", [], {
         base: base_tex,
         sup: sup_tex,
@@ -3648,6 +3738,7 @@ function tex2typst(tex, options) {
     keepSpaces: false,
     fracToSlash: true,
     inftyToOo: false,
+    optimize: true,
     nonAsciiWrapper: "",
     customTexMacros: {}
   };