tex2typst 0.0.19 → 0.2.0

package/dist/index.js

@@ -1,73 +1,201 @@
 // src/parser.ts
-import katex from "katex";
-function katexNodeToTexNode(node) {
-  try {
-    if (node.loc) {
-      delete node.loc;
+function assert(condition, message = "") {
+  if (!condition) {
+    throw new LatexParserError(message);
+  }
+}
+function get_command_param_num(command) {
+  if (UNARY_COMMANDS.includes(command)) {
+    return 1;
+  } else if (BINARY_COMMANDS.includes(command)) {
+    return 2;
+  } else {
+    return 0;
+  }
+}
+function find_closing_curly_bracket(latex, start) {
+  assert(latex[start] === "{");
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= latex.length) {
+      throw new LatexParserError("Unmatched curly brackets");
+    }
+    if (pos + 1 < latex.length && ["\\{", "\\}"].includes(latex.substring(pos, pos + 2))) {
+      pos += 2;
+      continue;
     }
+    if (latex[pos] === "{") {
+      count += 1;
+    } else if (latex[pos] === "}") {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function find_closing_square_bracket(latex, start) {
+  assert(latex[start] === "[");
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= latex.length) {
+      throw new LatexParserError("Unmatched square brackets");
+    }
+    if (latex[pos] === "[") {
+      count += 1;
+    } else if (latex[pos] === "]") {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function isalpha(char) {
+  return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
+}
+function isdigit(char) {
+  return "0123456789".includes(char);
+}
+function find_command(latex, start, command_name) {
+  const len_slash_command = 1 + command_name.length;
+  let pos = start;
+  while (pos < latex.length) {
+    pos = latex.indexOf("\\" + command_name, pos);
+    if (pos === -1) {
+      return -1;
+    }
+    if (pos + len_slash_command >= latex.length || !isalpha(latex[pos + len_slash_command])) {
+      return pos;
+    } else {
+      pos += len_slash_command;
+    }
+  }
+  return -1;
+}
+function find_closing_right_command(latex, start) {
+  let count = 1;
+  let pos = start;
+  while (count > 0) {
+    if (pos >= latex.length) {
+      return -1;
+    }
+    const left_idx = find_command(latex, pos, "left");
+    const right_idx = find_command(latex, pos, "right");
+    if (right_idx === -1) {
+      return -1;
+    }
+    if (left_idx === -1 || left_idx > right_idx) {
+      count -= 1;
+      pos = right_idx + "\\right".length;
+    } else {
+      count += 1;
+      pos = left_idx + "\\left".length;
+    }
+  }
+  return pos - "\\right".length;
+}
+function find_closing_end_command(latex, start) {
+  let count = 1;
+  let pos = start;
+  while (count > 0) {
+    if (pos >= latex.length) {
+      return -1;
+    }
+    const begin_idx = find_command(latex, pos, "begin");
+    const end_idx = find_command(latex, pos, "end");
+    if (end_idx === -1) {
+      return -1;
+    }
+    if (begin_idx === -1 || begin_idx > end_idx) {
+      count -= 1;
+      pos = end_idx + "\\end".length;
+    } else {
+      count += 1;
+      pos = begin_idx + "\\begin".length;
+    }
+  }
+  return pos - "\\end".length;
+}
+function eat_whitespaces(latex, start) {
+  let pos = start;
+  while (pos < latex.length && [" ", "\t", "\n"].includes(latex[pos])) {
+    pos += 1;
+  }
+  return latex.substring(start, pos);
+}
+function eat_command_name(latex, start) {
+  let pos = start;
+  while (pos < latex.length && isalpha(latex[pos])) {
+    pos += 1;
+  }
+  return latex.substring(start, pos);
+}
+function eat_parenthesis(latex, start) {
+  if ("()[]|".includes(latex[start])) {
+    return latex[start];
+  } else if (start + 1 < latex.length && ["\\{", "\\}"].includes(latex.substring(start, start + 2))) {
+    return latex.substring(start, start + 2);
+  } else if (start + 6 < latex.length && ["\\lfloor", "\\rfloor"].includes(latex.substring(start, start + 7))) {
+    return latex.substring(start, start + 7);
+  } else if (start + 5 < latex.length && ["\\lceil", "\\rceil"].includes(latex.substring(start, start + 6))) {
+    return latex.substring(start, start + 6);
+  } else if (start + 6 < latex.length && ["\\langle", "\\rangle"].includes(latex.substring(start, start + 7))) {
+    return latex.substring(start, start + 7);
+  } else {
+    return null;
+  }
+}
+function eat_primes(latex, start) {
+  let pos = start;
+  while (pos < latex.length && latex[pos] === "'") {
+    pos += 1;
+  }
+  return pos - start;
+}
+function latexNodeToTexNode(node) {
+  try {
     let res = {};
     switch (node.type) {
+      case "ordgroup":
+        res.type = "ordgroup";
+        res.args = node.args.map((n) => latexNodeToTexNode(n));
+        if (res.args.length === 1) {
+          res = res.args[0];
+        }
+        break;
+      case "empty":
+        res.type = "empty";
+        res.content = "";
+        break;
       case "atom":
         res.type = "atom";
-        res.content = node.text;
-        if (node.text === "\\{" || node.text === "\\}") {
-          res.content = node.text.substring(1);
-        } else if (node.text.startsWith("\\")) {
-          res.type = "symbol";
-        }
+        res.content = node.content;
         break;
-      case "mathord":
-      case "textord":
-      case "op":
-      case "cr":
+      case "token":
+      case "token-letter-var":
+      case "token-number":
+      case "token-operator":
+      case "token-parenthesis":
         res.type = "symbol";
-        res.content = node.text;
-        if (node.type === "op") {
-          res.content = node["name"];
-        } else if (node.type === "cr") {
-          res.content = "\\\\";
-        }
-        break;
-      case "genfrac":
-        res.type = "binaryFunc";
-        if (node["leftDelim"] === "(" && node["rightDelim"] === ")") {
-          res.content = "\\binom";
-        } else {
-          res.content = "\\frac";
-        }
-        res.args = [
-          katexNodeToTexNode(node["numer"]),
-          katexNodeToTexNode(node["denom"])
-        ];
+        res.content = node.content;
         break;
       case "supsub":
         res.type = "supsub";
         res.irregularData = {};
         if (node["base"]) {
-          res.irregularData.base = katexNodeToTexNode(node["base"]);
+          res.irregularData.base = latexNodeToTexNode(node["base"]);
         }
         if (node["sup"]) {
-          res.irregularData.sup = katexNodeToTexNode(node["sup"]);
+          res.irregularData.sup = latexNodeToTexNode(node["sup"]);
         }
         if (node["sub"]) {
-          res.irregularData.sub = katexNodeToTexNode(node["sub"]);
+          res.irregularData.sub = latexNodeToTexNode(node["sub"]);
         }
         break;
-      case "mclass":
-      case "ordgroup":
-        res.type = "ordgroup";
-        res.args = node.body.map((n) => katexNodeToTexNode(n));
-        if (res.args.length === 1) {
-          res = res.args[0];
-        }
-        break;
-      case "leftright": {
-        const body = katexNodeToTexNode({
-          type: "ordgroup",
-          mode: "math",
-          body: node.body
-        });
+      case "leftright":
         res.type = "leftright";
+        const body = latexNodeToTexNode(node.body);
         let left = node["left"];
         if (left === "\\{") {
           left = "{";
@@ -83,113 +211,68 @@ function katexNodeToTexNode(node) {
           { type: is_atom(right) ? "atom" : "symbol", content: right }
         ];
         break;
-      }
-      case "underline":
-      case "overline":
-        res.type = "unaryFunc";
-        res.content = "\\" + node.type;
-        res.args = [
-          katexNodeToTexNode(node["body"])
-        ];
-        break;
-      case "accent": {
-        res.type = "unaryFunc";
-        res.content = node["label"];
-        res.args = [
-          katexNodeToTexNode(node["base"])
-        ];
-        break;
-      }
-      case "sqrt":
-        if (node["index"]) {
-          res.irregularData = katexNodeToTexNode(node["index"]);
-        }
-      case "font":
-      case "operatorname":
-        res.type = "unaryFunc";
-        res.content = "\\" + node.type;
-        if (node.type === "font") {
-          res.content = "\\" + node["font"];
+      case "beginend":
+        if (node.content?.startsWith("align")) {
+          res.type = "align";
+        } else {
+          res.type = "matrix";
         }
-        if (Array.isArray(node.body)) {
-          const obj = {
-            type: "ordgroup",
-            mode: "math",
-            body: node.body
-          };
+        res.content = node.content;
+        res.irregularData = node.body.map((row) => {
+          return row.map((n) => latexNodeToTexNode(n));
+        });
+        break;
+      case "command":
+        const num_args = get_command_param_num(node.content);
+        res.content = "\\" + node.content;
+        if (num_args === 0) {
+          res.type = "symbol";
+        } else if (num_args === 1) {
+          res.type = "unaryFunc";
           res.args = [
-            katexNodeToTexNode(obj)
+            latexNodeToTexNode(node.arg1)
           ];
-        } else {
+          if (node.content === "sqrt") {
+            if (node.exponent) {
+              res.irregularData = latexNodeToTexNode(node.exponent);
+            }
+          }
+        } else if (num_args === 2) {
+          res.type = "binaryFunc";
           res.args = [
-            katexNodeToTexNode(node.body)
+            latexNodeToTexNode(node.arg1),
+            latexNodeToTexNode(node.arg2)
           ];
-        }
-        break;
-      case "horizBrace":
-        res.type = "unaryFunc";
-        res.content = node["label"];
-        res.args = [
-          katexNodeToTexNode(node["base"])
-        ];
-        break;
-      case "array":
-        if (node["colSeparationType"] === "align") {
-          res.type = "align";
         } else {
-          res.type = "matrix";
+          throw new LatexNodeToTexNodeError("Invalid number of arguments", node);
         }
-        res.irregularData = node.body.map((row) => {
-          return row.map((cell) => {
-            if (cell.type !== "styling" || cell.body.length !== 1) {
-              throw new KatexNodeToTexNodeError("Expecting cell.type==='\\styling' and cell.body.length===1", cell);
-            }
-            return katexNodeToTexNode(cell.body[0]);
-          });
-        });
         break;
-      case "text": {
+      case "text":
         res.type = "text";
-        let str = "";
-        node.body.forEach((n) => {
-          if (n.mode !== "text") {
-            throw new KatexNodeToTexNodeError("Expecting node.mode==='text'", node);
-          }
-          str += n.text;
-        });
-        res.content = str;
+        res.content = node.content;
         break;
-      }
-      case "spacing":
-      case "kern":
+      case "comment":
+        res.type = "comment";
+        res.content = node.content;
+        break;
+      case "whitespace":
         res.type = "empty";
-        res.content = " ";
         break;
-      case "htmlmathml": {
-        const element = node["mathml"][0]["body"][0];
-        if (element && element.type === "textord" && element.text === "\u2260") {
+      case "newline":
+        res.type = "newline";
+        res.content = "\n";
+        break;
+      case "control":
+        if (node.content === "\\\\") {
           res.type = "symbol";
-          res.content = "\\neq";
+          res.content = node.content;
           break;
         } else {
+          throw new LatexNodeToTexNodeError(`Unknown control sequence: ${node.content}`, node);
         }
-      }
-      case "color":
-        if (Array.isArray(node.body) && node.body.length === 1) {
-          const sub_body = node.body[0];
-          if (sub_body.type === "text") {
-            res.type = "unknownMacro";
-            const joined = sub_body.body.map((n) => n.text).join("");
-            if (/^\\[a-zA-Z]+$/.test(joined)) {
-              res.content = joined.substring(1);
-              break;
-            }
-          }
-        }
-        throw new KatexNodeToTexNodeError(`Unknown error type in parsed result:`, node);
-      default:
-        throw new KatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
         break;
+      default:
+        throw new LatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
     }
     return res;
   } catch (e) {
@@ -197,46 +280,365 @@ function katexNodeToTexNode(node) {
   }
 }
 function parseTex(tex, customTexMacros) {
-  const macros = {
-    "\\mod": "\\operatorname{SyMb01-mod}",
-    "\\liminf": "\\operatorname{SyMb01-liminf}",
-    "\\limsup": "\\operatorname{SyMb01-limsup}",
-    "\\qquad": "\\operatorname{SyMb01-qquad}",
-    "\\quad": "\\operatorname{SyMb01-quad}",
-    "\\cdots": "\\operatorname{SyMb01-cdots}",
-    "\\colon": "\\operatorname{SyMb01-colon}",
-    "\\imath": "\\operatorname{SyMb01-imath}",
-    "\\iiiint": "\\operatorname{SyMb01-iiiint}",
-    "\\jmath": "\\operatorname{SyMb01-jmath}",
-    "\\vdots": "\\operatorname{SyMb01-vdots}",
-    "\\notin": "\\operatorname{SyMb01-notin}",
-    "\\slash": "\\operatorname{SyMb01-slash}",
-    "\\LaTeX": "\\operatorname{SyMb01-LaTeX}",
-    "\\TeX": "\\operatorname{SyMb01-TeX}",
-    ...customTexMacros
-  };
-  const options = {
-    macros,
-    displayMode: true,
-    strict: "ignore",
-    throwOnError: false
-  };
-  let treeArray = generateParseTree(tex, options);
-  let t = {
-    type: "ordgroup",
-    mode: "math",
-    body: treeArray,
-    loc: {}
-  };
-  return katexNodeToTexNode(t);
+  const parser = new LatexParser;
+  for (const [macro, replacement] of Object.entries(customTexMacros)) {
+    tex = tex.replaceAll(macro, replacement);
+  }
+  const node = parser.parse(tex);
+  return latexNodeToTexNode(node);
 }
-var generateParseTree = katex.__parse;
+var UNARY_COMMANDS = [
+  "sqrt",
+  "text",
+  "arccos",
+  "arcsin",
+  "arctan",
+  "arg",
+  "bar",
+  "bold",
+  "boldsymbol",
+  "ddot",
+  "det",
+  "dim",
+  "dot",
+  "exp",
+  "gcd",
+  "hat",
+  "ker",
+  "mathbb",
+  "mathbf",
+  "mathcal",
+  "mathscr",
+  "mathsf",
+  "mathtt",
+  "mathrm",
+  "max",
+  "min",
+  "mod",
+  "operatorname",
+  "overbrace",
+  "overline",
+  "pmb",
+  "sup",
+  "rm",
+  "tilde",
+  "underbrace",
+  "underline",
+  "vec",
+  "widehat",
+  "widetilde"
+];
+var BINARY_COMMANDS = [
+  "frac",
+  "tfrac",
+  "binom",
+  "dbinom",
+  "dfrac",
+  "tbinom"
+];
+var EMPTY_NODE = { type: "empty", content: "" };
 
-class KatexNodeToTexNodeError extends Error {
+class LatexParserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LatexParserError";
+  }
+}
+
+class LatexParser {
+  space_sensitive;
+  newline_sensitive;
+  constructor(space_sensitive = false, newline_sensitive = true) {
+    this.space_sensitive = space_sensitive;
+    this.newline_sensitive = newline_sensitive;
+  }
+  parse(latex) {
+    const results = [];
+    let pos = 0;
+    while (pos < latex.length) {
+      const [res, newPos] = this.parseNextExpr(latex, pos);
+      pos = newPos;
+      if (!this.space_sensitive && res.type === "whitespace") {
+        continue;
+      }
+      if (!this.newline_sensitive && res.type === "newline") {
+        continue;
+      }
+      if (res.type === "control" && res.content === "&") {
+        throw new LatexParserError("Unexpected & outside of an alignment");
+      }
+      results.push(res);
+    }
+    if (results.length === 0) {
+      return EMPTY_NODE;
+    } else if (results.length === 1) {
+      return results[0];
+    } else {
+      return { type: "ordgroup", args: results };
+    }
+  }
+  parseNextExpr(latex, start) {
+    let [base, pos] = this.parseNextExprWithoutSupSub(latex, start);
+    let sub = null;
+    let sup = null;
+    let num_prime = 0;
+    num_prime += eat_primes(latex, pos);
+    pos += num_prime;
+    if (pos < latex.length && latex[pos] === "_") {
+      [sub, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
+      num_prime += eat_primes(latex, pos);
+      pos += num_prime;
+      if (pos < latex.length && latex[pos] === "^") {
+        [sup, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
+        if (eat_primes(latex, pos) > 0) {
+          throw new LatexParserError("Double superscript");
+        }
+      }
+    } else if (pos < latex.length && latex[pos] === "^") {
+      [sup, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
+      if (eat_primes(latex, pos) > 0) {
+        throw new LatexParserError("Double superscript");
+      }
+      if (pos < latex.length && latex[pos] === "_") {
+        [sub, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
+        if (eat_primes(latex, pos) > 0) {
+          throw new LatexParserError("Double superscript");
+        }
+      }
+    }
+    if (sub !== null || sup !== null || num_prime > 0) {
+      const res = { type: "supsub", base };
+      if (sub) {
+        res.sub = sub;
+      }
+      if (num_prime > 0) {
+        res.sup = { type: "ordgroup", args: [] };
+        for (let i = 0;i < num_prime; i++) {
+          res.sup.args.push({ type: "command", content: "prime" });
+        }
+        if (sup) {
+          res.sup.args.push(sup);
+        }
+        if (res.sup.args.length === 1) {
+          res.sup = res.sup.args[0];
+        }
+      } else if (sup) {
+        res.sup = sup;
+      }
+      return [res, pos];
+    } else {
+      return [base, pos];
+    }
+  }
+  parseNextExprWithoutSupSub(latex, start) {
+    const firstChar = latex[start];
+    if (firstChar === "{") {
+      const posClosingBracket = find_closing_curly_bracket(latex, start);
+      const exprInside = latex.slice(start + 1, posClosingBracket);
+      return [this.parse(exprInside), posClosingBracket + 1];
+    } else if (firstChar === "\\") {
+      if (start + 1 >= latex.length) {
+        throw new LatexParserError("Expecting command name after \\");
+      }
+      const firstTwoChars = latex.slice(start, start + 2);
+      if (firstTwoChars === "\\\\") {
+        return [{ type: "control", content: "\\\\" }, start + 2];
+      } else if (firstTwoChars === "\\{" || firstTwoChars === "\\}") {
+        return [{ type: "token-parenthesis", content: firstTwoChars }, start + 2];
+      } else if (["\\%", "\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
+        return [{ type: "token", content: firstTwoChars }, start + 2];
+      } else if (latex.slice(start).startsWith("\\begin{")) {
+        return this.parseBeginEndExpr(latex, start);
+      } else if (latex.slice(start).startsWith("\\left") && (start + 5 >= latex.length || !isalpha(latex[start + 5]))) {
+        return this.parseLeftRightExpr(latex, start);
+      } else {
+        return this.parseCommandExpr(latex, start);
+      }
+    } else if (firstChar === "%") {
+      let pos = start + 1;
+      while (pos < latex.length && latex[pos] !== "\n") {
+        pos += 1;
+      }
+      return [{ type: "comment", content: latex.slice(start + 1, pos) }, pos];
+    } else if (isdigit(firstChar)) {
+      let pos = start;
+      while (pos < latex.length && isdigit(latex[pos])) {
+        pos += 1;
+      }
+      return [{ type: "token-number", content: latex.slice(start, pos) }, pos];
+    } else if (isalpha(firstChar)) {
+      return [{ type: "token-letter-var", content: firstChar }, start + 1];
+    } else if ("+-*/=<>!".includes(firstChar)) {
+      return [{ type: "token-operator", content: firstChar }, start + 1];
+    } else if (".,;?".includes(firstChar)) {
+      return [{ type: "atom", content: firstChar }, start + 1];
+    } else if ("()[]".includes(firstChar)) {
+      return [{ type: "token-parenthesis", content: firstChar }, start + 1];
+    } else if (firstChar === "_") {
+      let [sub, pos] = this.parseNextExpr(latex, start + 1);
+      let sup = undefined;
+      if (pos < latex.length && latex[pos] === "^") {
+        [sup, pos] = this.parseNextExpr(latex, pos + 1);
+      }
+      return [{ type: "supsub", base: EMPTY_NODE, sub, sup }, pos];
+    } else if (firstChar === "^") {
+      let [sup, pos] = this.parseNextExpr(latex, start + 1);
+      let sub = undefined;
+      if (pos < latex.length && latex[pos] === "_") {
+        [sub, pos] = this.parseNextExpr(latex, pos + 1);
+      }
+      return [{ type: "supsub", base: EMPTY_NODE, sub, sup }, pos];
+    } else if (firstChar === " ") {
+      let pos = start;
+      while (pos < latex.length && latex[pos] === " ") {
+        pos += 1;
+      }
+      return [{ type: "whitespace", content: latex.slice(start, pos) }, pos];
+    } else if (firstChar === "\n") {
+      return [{ type: "newline", content: "\n" }, start + 1];
+    } else if (firstChar === "\r") {
+      if (start + 1 < latex.length && latex[start + 1] === "\n") {
+        return [{ type: "newline", content: "\n" }, start + 2];
+      } else {
+        return [{ type: "newline", content: "\n" }, start + 1];
+      }
+    } else if (firstChar === "&") {
+      return [{ type: "control", content: "&" }, start + 1];
+    } else {
+      return [{ type: "unknown", content: firstChar }, start + 1];
+    }
+  }
+  parseCommandExpr(latex, start) {
+    assert(latex[start] === "\\");
+    let pos = start + 1;
+    const command = eat_command_name(latex, pos);
+    pos += command.length;
+    const paramNum = get_command_param_num(command);
+    if (paramNum === 0) {
+      return [{ type: "command", content: command }, pos];
+    } else if (paramNum === 1) {
+      if (command === "sqrt" && pos < latex.length && latex[pos] === "[") {
+        const posLeftSquareBracket = pos;
+        const posRightSquareBracket = find_closing_square_bracket(latex, pos);
+        const exprInside = latex.slice(posLeftSquareBracket + 1, posRightSquareBracket);
+        const exponent = this.parse(exprInside);
+        const [arg1, newPos] = this.parseNextExprWithoutSupSub(latex, posRightSquareBracket + 1);
+        return [{ type: "command", content: command, arg1, exponent }, newPos];
+      } else if (command === "text") {
+        assert(latex[pos] === "{");
+        const posClosingBracket = find_closing_curly_bracket(latex, pos);
+        const text = latex.slice(pos + 1, posClosingBracket);
+        return [{ type: "text", content: text }, posClosingBracket + 1];
+      } else {
+        let [arg1, newPos] = this.parseNextExprWithoutSupSub(latex, pos);
+        return [{ type: "command", content: command, arg1 }, newPos];
+      }
+    } else if (paramNum === 2) {
+      const [arg1, pos1] = this.parseNextExprWithoutSupSub(latex, pos);
+      const [arg2, pos2] = this.parseNextExprWithoutSupSub(latex, pos1);
+      return [{ type: "command", content: command, arg1, arg2 }, pos2];
+    } else {
+      throw new Error("Invalid number of parameters");
+    }
+  }
+  parseLeftRightExpr(latex, start) {
+    assert(latex.slice(start, start + 5) === "\\left");
+    let pos = start + "\\left".length;
+    pos += eat_whitespaces(latex, pos).length;
+    if (pos >= latex.length) {
+      throw new LatexParserError("Expecting delimiter after \\left");
+    }
+    const leftDelimiter = eat_parenthesis(latex, pos);
+    if (leftDelimiter === null) {
+      throw new LatexParserError("Invalid delimiter after \\left");
+    }
+    pos += leftDelimiter.length;
+    const exprInsideStart = pos;
+    const idx = find_closing_right_command(latex, pos);
+    if (idx === -1) {
+      throw new LatexParserError("No matching \\right");
+    }
+    const exprInsideEnd = idx;
+    pos = idx + "\\right".length;
+    pos += eat_whitespaces(latex, pos).length;
+    if (pos >= latex.length) {
+      throw new LatexParserError("Expecting delimiter after \\right");
+    }
+    const rightDelimiter = eat_parenthesis(latex, pos);
+    if (rightDelimiter === null) {
+      throw new LatexParserError("Invalid delimiter after \\right");
+    }
+    pos += rightDelimiter.length;
+    const exprInside = latex.slice(exprInsideStart, exprInsideEnd);
+    const body = this.parse(exprInside);
+    const res = { type: "leftright", left: leftDelimiter, right: rightDelimiter, body };
+    return [res, pos];
+  }
+  parseBeginEndExpr(latex, start) {
+    assert(latex.slice(start, start + 7) === "\\begin{");
+    let pos = start + "\\begin".length;
+    const idx = find_closing_curly_bracket(latex, pos);
+    if (idx === -1) {
+      throw new LatexParserError("No matching } after \\begin{");
+    }
+    const envName = latex.slice(pos + 1, idx);
+    pos = idx + 1;
+    pos += eat_whitespaces(latex, pos).length;
+    const exprInsideStart = pos;
+    const endIdx = find_closing_end_command(latex, pos);
+    if (endIdx === -1) {
+      throw new LatexParserError("No matching \\end");
+    }
+    const exprInsideEnd = endIdx;
+    pos = endIdx + "\\end".length;
+    const closingIdx = find_closing_curly_bracket(latex, pos);
+    if (closingIdx === -1) {
+      throw new LatexParserError("No matching } after \\end{");
+    }
+    if (latex.slice(pos + 1, closingIdx) !== envName) {
+      throw new LatexParserError("Mismatched \\begin and \\end environments");
+    }
+    let exprInside = latex.slice(exprInsideStart, exprInsideEnd);
+    exprInside = exprInside.trimEnd();
+    const body = this.parseAligned(exprInside);
+    const res = { type: "beginend", content: envName, body };
+    return [res, closingIdx + 1];
+  }
+  parseAligned(latex) {
+    let pos = 0;
+    const allRows = [];
+    let row = [];
+    allRows.push(row);
+    let group = { type: "ordgroup", args: [] };
+    row.push(group);
+    while (pos < latex.length) {
+      const [res, newPos] = this.parseNextExpr(latex, pos);
+      pos = newPos;
+      if (res.type === "whitespace") {
+        continue;
+      } else if (res.type === "newline" && !this.newline_sensitive) {
+        continue;
+      } else if (res.type === "control" && res.content === "\\\\") {
+        row = [];
+        group = { type: "ordgroup", args: [] };
+        row.push(group);
+        allRows.push(row);
+      } else if (res.type === "control" && res.content === "&") {
+        group = { type: "ordgroup", args: [] };
+        row.push(group);
+      } else {
+        group.args.push(res);
+      }
+    }
+    return allRows;
+  }
+}
+
+class LatexNodeToTexNodeError extends Error {
   node;
   constructor(message, node) {
     super(message);
-    this.name = "KatexNodeToTexNodeError";
+    this.name = "LatexNodeToTexNodeError";
     this.node = node;
   }
 }
@@ -263,6 +665,10 @@ var symbolMap = new Map([
   ["overline", "overline"],
   ["underline", "underline"],
   ["bar", "macron"],
+  ["dbinom", "binom"],
+  ["tbinom", "binom"],
+  ["dfrac", "frac"],
+  ["tfrac", "frac"],
   ["boldsymbol", "bold"],
   ["mathbf", "bold"],
   ["mathbb", "bb"],
@@ -514,7 +920,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 +975,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) {
@@ -602,7 +1011,7 @@ class TypstWriter {
         this.append({ type: "binaryFunc", content: "\\underbrace", args: [base.args[0], sub] });
         return;
       }
-      if (!base) {
+      if (base.type === "empty") {
         this.queue.push({ type: "text", content: "" });
       } else {
         this.appendWithBracketsIfNeeded(base);
@@ -696,8 +1105,6 @@ 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) });
         } else {
           this.queue.push({ type: "symbol", content: "op" });
           this.queue.push({ type: "atom", content: "(" });
@@ -712,6 +1119,9 @@ class TypstWriter {
       this.append(arg0);
       this.queue.push({ type: "atom", content: ")" });
       this.insideFunctionDepth--;
+    } else if (node.type === "newline") {
+      this.queue.push({ type: "newline", content: "\n" });
+      return;
     } else if (node.type === "align") {
       const matrix = node.irregularData;
       matrix.forEach((row, i) => {
@@ -734,6 +1144,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 +1165,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 +1188,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);
       }