tex2typst 0.1.20 → 0.2.2

package/dist/index.js

@@ -1,300 +1,615 @@
 // src/parser.ts
-import katex from "katex";
-function katexNodeToTexNode(node) {
-  try {
-    if (node.loc) {
-      delete node.loc;
-    }
-    let res = {};
-    switch (node.type) {
-      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";
+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(tokens, start) {
+  assert(token_eq(tokens[start], LEFT_CURLY_BRACKET));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      throw new LatexParserError("Unmatched curly brackets");
+    }
+    if (token_eq(tokens[pos], LEFT_CURLY_BRACKET)) {
+      count += 1;
+    } else if (token_eq(tokens[pos], RIGHT_CURLY_BRACKET)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function find_closing_square_bracket(tokens, start) {
+  assert(token_eq(tokens[start], LEFT_SQUARE_BRACKET));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      throw new LatexParserError("Unmatched square brackets");
+    }
+    if (token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
+      count += 1;
+    } else if (token_eq(tokens[pos], RIGHT_SQUARE_BRACKET)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function isalpha(char) {
+  return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
+}
+function isdigit(char) {
+  return "0123456789".includes(char);
+}
+function eat_whitespaces(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && ["whitespace", "newline"].includes(tokens[pos].type)) {
+    pos++;
+  }
+  return tokens.slice(start, pos);
+}
+function eat_parenthesis(tokens, start) {
+  const firstToken = tokens[start];
+  if (firstToken.type === "element" && ["(", ")", "[", "]", "|", "\\{", "\\}"].includes(firstToken.value)) {
+    return firstToken;
+  } else if (firstToken.type === "command" && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+    return firstToken;
+  } else {
+    return null;
+  }
+}
+function eat_primes(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && token_eq(tokens[pos], { type: "element", value: "'" })) {
+    pos += 1;
+  }
+  return pos - start;
+}
+function eat_command_name(latex, start) {
+  let pos = start;
+  while (pos < latex.length && isalpha(latex[pos])) {
+    pos += 1;
+  }
+  return latex.substring(start, pos);
+}
+function find_closing_right_command(tokens, start) {
+  let count = 1;
+  let pos = start;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      return -1;
+    }
+    if (token_eq(tokens[pos], LEFT_COMMAND)) {
+      count += 1;
+    } else if (token_eq(tokens[pos], RIGHT_COMMAND)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function find_closing_end_command(tokens, start) {
+  let count = 1;
+  let pos = start;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      return -1;
+    }
+    if (token_eq(tokens[pos], BEGIN_COMMAND)) {
+      count += 1;
+    } else if (token_eq(tokens[pos], END_COMMAND)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function find_closing_curly_bracket_char(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 tokenize(latex) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < latex.length) {
+    const firstChar = latex[pos];
+    let token;
+    switch (firstChar) {
+      case "%": {
+        let newPos = pos + 1;
+        while (newPos < latex.length && latex[newPos] !== "\n") {
+          newPos += 1;
         }
+        token = { type: "comment", value: latex.slice(pos + 1, newPos) };
+        pos = newPos;
         break;
-      case "mathord":
-      case "textord":
-      case "op":
-      case "cr":
-        res.type = "symbol";
-        res.content = node.text;
-        if (node.type === "op") {
-          res.content = node["name"];
-        } else if (node.type === "cr") {
-          res.content = "\\\\";
-        }
+      }
+      case "{":
+      case "}":
+      case "_":
+      case "^":
+      case "&":
+        token = { type: "control", value: firstChar };
+        pos++;
+        break;
+      case "\n":
+        token = { type: "newline", value: firstChar };
+        pos++;
         break;
-      case "genfrac":
-        res.type = "binaryFunc";
-        if (node["leftDelim"] === "(" && node["rightDelim"] === ")") {
-          res.content = "\\binom";
+      case "\r": {
+        if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
+          token = { type: "newline", value: "\n" };
+          pos += 2;
         } else {
-          res.content = "\\frac";
+          token = { type: "newline", value: "\n" };
+          pos++;
         }
-        res.args = [
-          katexNodeToTexNode(node["numer"]),
-          katexNodeToTexNode(node["denom"])
-        ];
         break;
-      case "supsub":
-        res.type = "supsub";
-        res.irregularData = {};
-        if (node["base"]) {
-          res.irregularData.base = katexNodeToTexNode(node["base"]);
+      }
+      case " ": {
+        let newPos = pos;
+        while (newPos < latex.length && latex[newPos] === " ") {
+          newPos += 1;
         }
-        if (node["sup"]) {
-          res.irregularData.sup = katexNodeToTexNode(node["sup"]);
+        token = { type: "whitespace", value: latex.slice(pos, newPos) };
+        pos = newPos;
+        break;
+      }
+      case "\\": {
+        if (pos + 1 >= latex.length) {
+          throw new LatexParserError("Expecting command name after \\");
         }
-        if (node["sub"]) {
-          res.irregularData.sub = katexNodeToTexNode(node["sub"]);
+        const firstTwoChars = latex.slice(pos, pos + 2);
+        if (firstTwoChars === "\\\\") {
+          token = { type: "control", value: "\\\\" };
+          pos += 2;
+        } else if (["\\{", "\\}", "\\%", "\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
+          token = { type: "element", value: firstTwoChars };
+          pos += 2;
+        } else {
+          const command = eat_command_name(latex, pos + 1);
+          token = { type: "command", value: "\\" + command };
+          pos += 1 + command.length;
         }
         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];
+      }
+      default: {
+        if (isdigit(firstChar)) {
+          let newPos = pos;
+          while (newPos < latex.length && isdigit(latex[newPos])) {
+            newPos += 1;
+          }
+          token = { type: "element", value: latex.slice(pos, newPos) };
+        } else if (isalpha(firstChar)) {
+          token = { type: "element", value: firstChar };
+        } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
+          token = { type: "element", value: firstChar };
+        } else {
+          token = { type: "unknown", value: firstChar };
         }
-        break;
-      case "leftright": {
-        const body = katexNodeToTexNode({
-          type: "ordgroup",
-          mode: "math",
-          body: node.body
-        });
-        res.type = "leftright";
-        let left = node["left"];
-        if (left === "\\{") {
-          left = "{";
+        pos += token.value.length;
+      }
+    }
+    tokens.push(token);
+    if (token.type === "command" && ["\\text", "\\begin", "\\end"].includes(token.value)) {
+      if (pos >= latex.length || latex[pos] !== "{") {
+        throw new LatexParserError(`No content for ${token.value} command`);
+      }
+      tokens.push({ type: "control", value: "{" });
+      const posClosingBracket = find_closing_curly_bracket_char(latex, pos);
+      pos++;
+      let textInside = latex.slice(pos, posClosingBracket);
+      const chars = ["{", "}", "\\", "$", "&", "#", "_", "%"];
+      for (const char of chars) {
+        textInside = textInside.replaceAll("\\" + char, char);
+      }
+      tokens.push({ type: "text", value: textInside });
+      tokens.push({ type: "control", value: "}" });
+      pos = posClosingBracket + 1;
+    }
+  }
+  return tokens;
+}
+function token_eq(token1, token2) {
+  return token1.type == token2.type && token1.value == token2.value;
+}
+function parseTex(tex, customTexMacros) {
+  const parser = new LatexParser;
+  const original_tokens = tokenize(tex);
+  let processed_tokens = [];
+  for (const token of original_tokens) {
+    if (token.type === "command" && customTexMacros[token.value]) {
+      const expanded_tokens = tokenize(customTexMacros[token.value]);
+      processed_tokens = processed_tokens.concat(expanded_tokens);
+    } else {
+      processed_tokens.push(token);
+    }
+  }
+  return parser.parse(processed_tokens);
+}
+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: "" };
+var LEFT_CURLY_BRACKET = { type: "control", value: "{" };
+var RIGHT_CURLY_BRACKET = { type: "control", value: "}" };
+var LEFT_SQUARE_BRACKET = { type: "element", value: "[" };
+var RIGHT_SQUARE_BRACKET = { type: "element", value: "]" };
+var LEFT_COMMAND = { type: "command", value: "\\left" };
+var RIGHT_COMMAND = { type: "command", value: "\\right" };
+var BEGIN_COMMAND = { type: "command", value: "\\begin" };
+var END_COMMAND = { type: "command", value: "\\end" };
+
+class LatexParserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LatexParserError";
+  }
+}
+var SUB_SYMBOL = { type: "control", value: "_" };
+var SUP_SYMBOL = { type: "control", value: "^" };
+
+class LatexParser {
+  space_sensitive;
+  newline_sensitive;
+  constructor(space_sensitive = false, newline_sensitive = true) {
+    this.space_sensitive = space_sensitive;
+    this.newline_sensitive = newline_sensitive;
+  }
+  parse(tokens) {
+    const results = [];
+    let pos = 0;
+    while (pos < tokens.length) {
+      const results2 = [];
+      let pos2 = 0;
+      while (pos2 < tokens.length) {
+        const [res, newPos] = this.parseNextExpr(tokens, pos2);
+        pos2 = newPos;
+        if (!this.space_sensitive && res.type === "whitespace") {
+          continue;
         }
-        let right = node["right"];
-        if (right === "\\}") {
-          right = "}";
+        if (!this.newline_sensitive && res.type === "newline") {
+          continue;
         }
-        const is_atom = (str) => ["(", ")", "[", "]", "{", "}"].includes(str);
-        res.args = [
-          { type: is_atom(left) ? "atom" : "symbol", content: left },
-          body,
-          { type: is_atom(right) ? "atom" : "symbol", content: right }
-        ];
-        break;
+        if (res.type === "control" && res.content === "&") {
+          throw new LatexParserError("Unexpected & outside of an alignment");
+        }
+        results2.push(res);
       }
-      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;
+      if (results2.length === 0) {
+        return EMPTY_NODE;
+      } else if (results2.length === 1) {
+        return results2[0];
+      } else {
+        return { type: "ordgroup", content: "", args: results2 };
       }
-      case "sqrt":
-        if (node["index"]) {
-          res.irregularData = katexNodeToTexNode(node["index"]);
+    }
+    if (results.length === 0) {
+      return EMPTY_NODE;
+    } else if (results.length === 1) {
+      return results[0];
+    } else {
+      return { type: "ordgroup", content: "", args: results };
+    }
+  }
+  parseNextExpr(tokens, start) {
+    let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
+    let sub = null;
+    let sup = null;
+    let num_prime = 0;
+    num_prime += eat_primes(tokens, pos);
+    pos += num_prime;
+    if (pos < tokens.length && token_eq(tokens[pos], SUB_SYMBOL)) {
+      [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+      num_prime += eat_primes(tokens, pos);
+      pos += num_prime;
+      if (pos < tokens.length && token_eq(tokens[pos], SUP_SYMBOL)) {
+        [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+        if (eat_primes(tokens, pos) > 0) {
+          throw new LatexParserError("Double superscript");
         }
-      case "font":
-      case "operatorname":
-        res.type = "unaryFunc";
-        res.content = "\\" + node.type;
-        if (node.type === "font") {
-          res.content = "\\" + node["font"];
+      }
+    } else if (pos < tokens.length && token_eq(tokens[pos], SUP_SYMBOL)) {
+      [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+      if (eat_primes(tokens, pos) > 0) {
+        throw new LatexParserError("Double superscript");
+      }
+      if (pos < tokens.length && token_eq(tokens[pos], SUB_SYMBOL)) {
+        [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+        if (eat_primes(tokens, pos) > 0) {
+          throw new LatexParserError("Double superscript");
         }
-        if (Array.isArray(node.body)) {
-          const obj = {
-            type: "ordgroup",
-            mode: "math",
-            body: node.body
-          };
-          res.args = [
-            katexNodeToTexNode(obj)
-          ];
-        } else {
-          res.args = [
-            katexNodeToTexNode(node.body)
-          ];
+      }
+    }
+    if (sub !== null || sup !== null || num_prime > 0) {
+      const res = { base };
+      if (sub) {
+        res.sub = sub;
+      }
+      if (num_prime > 0) {
+        res.sup = { type: "ordgroup", content: "", args: [] };
+        for (let i = 0;i < num_prime; i++) {
+          res.sup.args.push({ type: "symbol", content: "\\prime" });
         }
-        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";
+        if (sup) {
+          res.sup.args.push(sup);
         }
-        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": {
-        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;
-        break;
+        if (res.sup.args.length === 1) {
+          res.sup = res.sup.args[0];
+        }
+      } else if (sup) {
+        res.sup = sup;
       }
-      case "spacing":
-      case "kern":
-        res.type = "empty";
-        res.content = " ";
-        break;
-      case "htmlmathml": {
-        const element = node["mathml"][0]["body"][0];
-        if (element && element.type === "textord" && element.text === "\u2260") {
-          res.type = "symbol";
-          res.content = "\\neq";
-          break;
+      return [{ type: "supsub", content: "", data: res }, pos];
+    } else {
+      return [base, pos];
+    }
+  }
+  parseNextExprWithoutSupSub(tokens, start) {
+    const firstToken = tokens[start];
+    const tokenType = firstToken.type;
+    switch (tokenType) {
+      case "element":
+      case "text":
+      case "comment":
+      case "whitespace":
+      case "newline":
+        return [{ type: tokenType, content: firstToken.value }, start + 1];
+      case "command":
+        if (token_eq(firstToken, BEGIN_COMMAND)) {
+          return this.parseBeginEndExpr(tokens, start);
+        } else if (token_eq(firstToken, LEFT_COMMAND)) {
+          return this.parseLeftRightExpr(tokens, start);
         } else {
+          return this.parseCommandExpr(tokens, start);
         }
-      }
-      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;
+      case "control":
+        const controlChar = firstToken.value;
+        switch (controlChar) {
+          case "{":
+            const posClosingBracket = find_closing_curly_bracket(tokens, start);
+            const exprInside = tokens.slice(start + 1, posClosingBracket);
+            return [this.parse(exprInside), posClosingBracket + 1];
+          case "}":
+            throw new LatexParserError("Unmatched '}'");
+          case "\\\\":
+            return [{ type: "control", content: "\\\\" }, start + 1];
+          case "_": {
+            let [sub, pos] = this.parseNextExpr(tokens, start + 1);
+            let sup = undefined;
+            if (pos < tokens.length && token_eq(tokens[pos], SUP_SYMBOL)) {
+              [sup, pos] = this.parseNextExpr(tokens, pos + 1);
             }
+            const subData = { base: EMPTY_NODE, sub, sup };
+            return [{ type: "supsub", content: "", data: subData }, pos];
           }
+          case "^": {
+            let [sup, pos] = this.parseNextExpr(tokens, start + 1);
+            let sub = undefined;
+            if (pos < tokens.length && token_eq(tokens[pos], SUB_SYMBOL)) {
+              [sub, pos] = this.parseNextExpr(tokens, pos + 1);
+            }
+            const supData = { base: EMPTY_NODE, sub, sup };
+            return [{ type: "supsub", content: "", data: supData }, pos];
+          }
+          case "&":
+            return [{ type: "control", content: "&" }, start + 1];
+          default:
+            throw new LatexParserError("Unknown control sequence");
         }
-        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;
+        throw new LatexParserError("Unknown token type");
     }
-    return res;
-  } catch (e) {
-    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;
-      }
+  parseCommandExpr(tokens, start) {
+    assert(tokens[start].type === "command");
+    const command = tokens[start].value;
+    let pos = start + 1;
+    if (["left", "right", "begin", "end"].includes(command.slice(1))) {
+      throw new LatexParserError("Unexpected command: " + command);
     }
-    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 ";
+    const paramNum = get_command_param_num(command.slice(1));
+    if (paramNum === 0) {
+      return [{ type: "symbol", content: command }, pos];
+    } else if (paramNum === 1) {
+      if (command === "\\sqrt" && pos < tokens.length && token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
+        const posLeftSquareBracket = pos;
+        const posRightSquareBracket = find_closing_square_bracket(tokens, pos);
+        const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
+        const exponent = this.parse(exprInside);
+        const [arg12, newPos2] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
+        return [{ type: "unaryFunc", content: command, args: [arg12], data: exponent }, newPos2];
+      } else if (command === "\\text") {
+        if (pos + 2 >= tokens.length) {
+          throw new LatexParserError("Expecting content for \\text command");
+        }
+        assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+        assert(tokens[pos + 1].type === "text");
+        assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+        const text = tokens[pos + 1].value;
+        return [{ type: "text", content: text }, pos + 3];
       }
+      let [arg1, newPos] = this.parseNextExprWithoutSupSub(tokens, pos);
+      return [{ type: "unaryFunc", content: command, args: [arg1] }, newPos];
+    } else if (paramNum === 2) {
+      const [arg1, pos1] = this.parseNextExprWithoutSupSub(tokens, pos);
+      const [arg2, pos2] = this.parseNextExprWithoutSupSub(tokens, pos1);
+      return [{ type: "binaryFunc", content: command, args: [arg1, arg2] }, pos2];
+    } else {
+      throw new Error("Invalid number of parameters");
     }
   }
-  if (current_tex.length > 0) {
-    out_tex_list.push(current_tex);
+  parseLeftRightExpr(tokens, start) {
+    assert(token_eq(tokens[start], LEFT_COMMAND));
+    let pos = start + 1;
+    pos += eat_whitespaces(tokens, pos).length;
+    if (pos >= tokens.length) {
+      throw new LatexParserError("Expecting delimiter after \\left");
+    }
+    const leftDelimiter = eat_parenthesis(tokens, pos);
+    if (leftDelimiter === null) {
+      throw new LatexParserError("Invalid delimiter after \\left");
+    }
+    pos++;
+    const exprInsideStart = pos;
+    const idx = find_closing_right_command(tokens, pos);
+    if (idx === -1) {
+      throw new LatexParserError("No matching \\right");
+    }
+    const exprInsideEnd = idx;
+    pos = idx + 1;
+    pos += eat_whitespaces(tokens, pos).length;
+    if (pos >= tokens.length) {
+      throw new LatexParserError("Expecting \\right after \\left");
+    }
+    const rightDelimiter = eat_parenthesis(tokens, pos);
+    if (rightDelimiter === null) {
+      throw new LatexParserError("Invalid delimiter after \\right");
+    }
+    pos++;
+    const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
+    const body = this.parse(exprInside);
+    const args = [
+      { type: "element", content: leftDelimiter.value },
+      body,
+      { type: "element", content: rightDelimiter.value }
+    ];
+    const res = { type: "leftright", content: "", args };
+    return [res, pos];
   }
-  return out_tex_list;
-}
-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}",
-    "\\SyMbOlNeWlInE": "\\operatorname{SyMb01-newline}",
-    ...customTexMacros
-  };
-  const options = {
-    macros,
-    displayMode: true,
-    strict: "ignore",
-    throwOnError: false
-  };
-  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;
+  parseBeginEndExpr(tokens, start) {
+    assert(token_eq(tokens[start], BEGIN_COMMAND));
+    let pos = start + 1;
+    assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+    assert(tokens[pos + 1].type === "text");
+    assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+    const envName = tokens[pos + 1].value;
+    pos += 3;
+    pos += eat_whitespaces(tokens, pos).length;
+    const exprInsideStart = pos;
+    const endIdx = find_closing_end_command(tokens, pos);
+    if (endIdx === -1) {
+      throw new LatexParserError("No matching \\end");
     }
-    const trees = generateParseTree(tex_item, options);
-    treeArray = treeArray.concat(trees);
+    const exprInsideEnd = endIdx;
+    pos = endIdx + 1;
+    assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+    assert(tokens[pos + 1].type === "text");
+    assert(token_eq(tokens[pos + 2], RIGHT_CURLY_BRACKET));
+    if (tokens[pos + 1].value !== envName) {
+      throw new LatexParserError("Mismatched \\begin and \\end environments");
+    }
+    pos += 3;
+    const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
+    while (exprInside.length > 0 && ["whitespace", "newline"].includes(exprInside[exprInside.length - 1].type)) {
+      exprInside.pop();
+    }
+    const body = this.parseAligned(exprInside);
+    const res = { type: "beginend", content: envName, data: body };
+    return [res, pos];
   }
-  let t = {
-    type: "ordgroup",
-    mode: "math",
-    body: treeArray,
-    loc: {}
-  };
-  return katexNodeToTexNode(t);
-}
-var generateParseTree = katex.__parse;
-
-class KatexNodeToTexNodeError extends Error {
-  node;
-  constructor(message, node) {
-    super(message);
-    this.name = "KatexNodeToTexNodeError";
-    this.node = node;
+  parseAligned(tokens) {
+    let pos = 0;
+    const allRows = [];
+    let row = [];
+    allRows.push(row);
+    let group = { type: "ordgroup", content: "", args: [] };
+    row.push(group);
+    while (pos < tokens.length) {
+      const [res, newPos] = this.parseNextExpr(tokens, 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", content: "", args: [] };
+        row.push(group);
+        allRows.push(row);
+      } else if (res.type === "control" && res.content === "&") {
+        group = { type: "ordgroup", content: "", args: [] };
+        row.push(group);
+      } else {
+        group.args.push(res);
+      }
+    }
+    return allRows;
   }
 }
 
@@ -320,6 +635,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"],
@@ -639,22 +958,22 @@ class TypstWriter {
     this.buffer += str;
   }
   append(node) {
-    if (node.type === "empty") {
+    if (node.type === "empty" || node.type === "whitespace") {
       return;
     } else if (node.type === "ordgroup") {
       node.args.forEach((arg) => this.append(arg));
-    } else if (node.type === "atom") {
+    } else if (node.type === "element") {
       let content = node.content;
       if (node.content === "," && this.insideFunctionDepth > 0) {
         content = "comma";
       }
-      this.queue.push({ type: "atom", content });
+      this.queue.push({ type: "symbol", content });
     } else if (node.type === "symbol") {
       this.queue.push({ type: "symbol", content: node.content });
     } else if (node.type === "text") {
       this.queue.push(node);
     } else if (node.type === "supsub") {
-      let { base, sup, sub } = node.irregularData;
+      let { base, sup, sub } = node.data;
       if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
         this.append({ type: "binaryFunc", content: "\\overbrace", args: [base.args[0], sup] });
         return;
@@ -662,7 +981,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);
@@ -686,7 +1005,7 @@ class TypstWriter {
       }
     } else if (node.type === "leftright") {
       const [left, body, right] = node.args;
-      if (["[]", "()", "{}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
+      if (["[]", "()", "\\{\\}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
         this.append(left);
         this.append(body);
         this.append(right);
@@ -715,12 +1034,12 @@ class TypstWriter {
     } else if (node.type === "unaryFunc") {
       const func_symbol = { type: "symbol", content: node.content };
       const arg0 = node.args[0];
-      if (node.content === "\\sqrt" && node.irregularData) {
+      if (node.content === "\\sqrt" && node.data) {
         func_symbol.content = "root";
         this.queue.push(func_symbol);
         this.insideFunctionDepth++;
         this.queue.push({ type: "atom", content: "(" });
-        this.append(node.irregularData);
+        this.append(node.data);
         this.queue.push({ type: "atom", content: "," });
         this.append(arg0);
         this.queue.push({ type: "atom", content: ")" });
@@ -741,7 +1060,7 @@ class TypstWriter {
         return;
       } else if (node.content === "\\mathbb") {
         const body = node.args[0];
-        if (body.type === "symbol" && /^[A-Z]$/.test(body.content)) {
+        if (body.type === "element" && /^[A-Z]$/.test(body.content)) {
           this.queue.push({ type: "symbol", content: body.content + body.content });
           return;
         }
@@ -756,13 +1075,6 @@ class TypstWriter {
         }, "");
         if (this.preferTypstIntrinsic && TYPST_INTRINSIC_SYMBOLS.includes(text)) {
           this.queue.push({ type: "symbol", content: text });
-        } else if (text.startsWith("SyMb01-")) {
-          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: "(" });
@@ -777,49 +1089,61 @@ class TypstWriter {
       this.append(arg0);
       this.queue.push({ type: "atom", content: ")" });
       this.insideFunctionDepth--;
-    } else if (node.type === "align") {
-      const matrix = node.irregularData;
-      matrix.forEach((row, i) => {
-        row.forEach((cell, j) => {
-          if (j > 0) {
-            this.queue.push({ type: "atom", content: "&" });
+    } else if (node.type === "newline") {
+      this.queue.push({ type: "newline", content: "\n" });
+      return;
+    } else if (node.type === "beginend") {
+      if (node.content.startsWith("align")) {
+        const matrix = node.data;
+        matrix.forEach((row, i) => {
+          row.forEach((cell, j) => {
+            if (j > 0) {
+              this.queue.push({ type: "atom", content: "&" });
+            }
+            this.append(cell);
+          });
+          if (i < matrix.length - 1) {
+            this.queue.push({ type: "symbol", content: "\\\\" });
           }
-          this.append(cell);
         });
-        if (i < matrix.length - 1) {
-          this.queue.push({ type: "symbol", content: "\\\\" });
-        }
-      });
-    } else if (node.type === "matrix") {
-      const matrix = node.irregularData;
-      this.queue.push({ type: "symbol", content: "mat" });
-      this.insideFunctionDepth++;
-      this.queue.push({ type: "atom", content: "(" });
-      this.queue.push({ type: "symbol", content: "delim: #none, " });
-      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);
-          if (j < row.length - 1) {
-            this.queue.push({ type: "atom", content: "," });
-          } else {
-            if (i < matrix.length - 1) {
-              this.queue.push({ type: "atom", content: ";" });
+      } else {
+        const matrix = node.data;
+        this.queue.push({ type: "symbol", content: "mat" });
+        this.insideFunctionDepth++;
+        this.queue.push({ type: "atom", content: "(" });
+        this.queue.push({ type: "symbol", content: "delim: #none, " });
+        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);
+            if (j < row.length - 1) {
+              this.queue.push({ type: "atom", content: "," });
+            } else {
+              if (i < matrix.length - 1) {
+                this.queue.push({ type: "atom", content: ";" });
+              }
+            }
+          });
         });
-      });
-      this.queue.push({ type: "atom", content: ")" });
-      this.insideFunctionDepth--;
+        this.queue.push({ type: "atom", content: ")" });
+        this.insideFunctionDepth--;
+      }
+    } else if (node.type === "matrix") {
     } else if (node.type === "unknownMacro") {
       if (this.nonStrict) {
         this.queue.push({ type: "symbol", content: node.content });
       } else {
         throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
       }
+    } else if (node.type === "control") {
+      if (node.content === "\\\\") {
+        this.queue.push({ type: "symbol", content: node.content });
+      } else {
+        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
+      }
     } else if (node.type === "comment") {
       this.queue.push({ type: "comment", content: node.content });
     } else {
@@ -859,9 +1183,7 @@ class TypstWriter {
     this.queue = [];
   }
   appendWithBracketsIfNeeded(node) {
-    const is_single_atom = node.type === "atom";
-    const is_single_function = node.type === "unaryFunc" || node.type === "binaryFunc" || node.type === "leftright";
-    const is_single = ["atom", "symbol", "unaryFunc", "binaryFunc", "leftright"].includes(node.type);
+    const is_single = ["symbol", "element", "unaryFunc", "binaryFunc", "leftright"].includes(node.type);
     if (is_single) {
       this.append(node);
     } else {