tex2typst 0.2.0 → 0.2.2

package/dist/index.js

@@ -13,38 +13,34 @@ function get_command_param_num(command) {
     return 0;
   }
 }
-function find_closing_curly_bracket(latex, start) {
-  assert(latex[start] === "{");
+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 >= latex.length) {
+    if (pos >= tokens.length) {
       throw new LatexParserError("Unmatched curly brackets");
     }
-    if (pos + 1 < latex.length && ["\\{", "\\}"].includes(latex.substring(pos, pos + 2))) {
-      pos += 2;
-      continue;
-    }
-    if (latex[pos] === "{") {
+    if (token_eq(tokens[pos], LEFT_CURLY_BRACKET)) {
       count += 1;
-    } else if (latex[pos] === "}") {
+    } else if (token_eq(tokens[pos], RIGHT_CURLY_BRACKET)) {
       count -= 1;
     }
     pos += 1;
   }
   return pos - 1;
 }
-function find_closing_square_bracket(latex, start) {
-  assert(latex[start] === "[");
+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 >= latex.length) {
+    if (pos >= tokens.length) {
       throw new LatexParserError("Unmatched square brackets");
     }
-    if (latex[pos] === "[") {
+    if (token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
       count += 1;
-    } else if (latex[pos] === "]") {
+    } else if (token_eq(tokens[pos], RIGHT_SQUARE_BRACKET)) {
       count -= 1;
     }
     pos += 1;
@@ -57,235 +53,208 @@ function isalpha(char) {
 function isdigit(char) {
   return "0123456789".includes(char);
 }
-function find_command(latex, start, command_name) {
-  const len_slash_command = 1 + command_name.length;
+function eat_whitespaces(tokens, start) {
   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;
-    }
+  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 -1;
+  return latex.substring(start, pos);
 }
-function find_closing_right_command(latex, start) {
+function find_closing_right_command(tokens, 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) {
+    if (pos >= tokens.length) {
       return -1;
     }
-    if (left_idx === -1 || left_idx > right_idx) {
-      count -= 1;
-      pos = right_idx + "\\right".length;
-    } else {
+    if (token_eq(tokens[pos], LEFT_COMMAND)) {
       count += 1;
-      pos = left_idx + "\\left".length;
+    } else if (token_eq(tokens[pos], RIGHT_COMMAND)) {
+      count -= 1;
     }
+    pos += 1;
   }
-  return pos - "\\right".length;
+  return pos - 1;
 }
-function find_closing_end_command(latex, start) {
+function find_closing_end_command(tokens, start) {
   let count = 1;
   let pos = start;
   while (count > 0) {
-    if (pos >= latex.length) {
+    if (pos >= tokens.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 {
+    if (token_eq(tokens[pos], BEGIN_COMMAND)) {
       count += 1;
-      pos = begin_idx + "\\begin".length;
+    } else if (token_eq(tokens[pos], END_COMMAND)) {
+      count -= 1;
     }
-  }
-  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;
-  }
+  return pos - 1;
 }
-function eat_primes(latex, start) {
-  let pos = start;
-  while (pos < latex.length && latex[pos] === "'") {
+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 - start;
+  return pos - 1;
 }
-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];
+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 "empty":
-        res.type = "empty";
-        res.content = "";
-        break;
-      case "atom":
-        res.type = "atom";
-        res.content = node.content;
+      }
+      case "{":
+      case "}":
+      case "_":
+      case "^":
+      case "&":
+        token = { type: "control", value: firstChar };
+        pos++;
         break;
-      case "token":
-      case "token-letter-var":
-      case "token-number":
-      case "token-operator":
-      case "token-parenthesis":
-        res.type = "symbol";
-        res.content = node.content;
+      case "\n":
+        token = { type: "newline", value: firstChar };
+        pos++;
         break;
-      case "supsub":
-        res.type = "supsub";
-        res.irregularData = {};
-        if (node["base"]) {
-          res.irregularData.base = latexNodeToTexNode(node["base"]);
-        }
-        if (node["sup"]) {
-          res.irregularData.sup = latexNodeToTexNode(node["sup"]);
-        }
-        if (node["sub"]) {
-          res.irregularData.sub = latexNodeToTexNode(node["sub"]);
+      case "\r": {
+        if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
+          token = { type: "newline", value: "\n" };
+          pos += 2;
+        } else {
+          token = { type: "newline", value: "\n" };
+          pos++;
         }
         break;
-      case "leftright":
-        res.type = "leftright";
-        const body = latexNodeToTexNode(node.body);
-        let left = node["left"];
-        if (left === "\\{") {
-          left = "{";
-        }
-        let right = node["right"];
-        if (right === "\\}") {
-          right = "}";
+      }
+      case " ": {
+        let newPos = pos;
+        while (newPos < latex.length && latex[newPos] === " ") {
+          newPos += 1;
         }
-        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 }
-        ];
+        token = { type: "whitespace", value: latex.slice(pos, newPos) };
+        pos = newPos;
         break;
-      case "beginend":
-        if (node.content?.startsWith("align")) {
-          res.type = "align";
-        } else {
-          res.type = "matrix";
+      }
+      case "\\": {
+        if (pos + 1 >= latex.length) {
+          throw new LatexParserError("Expecting command name after \\");
         }
-        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 = [
-            latexNodeToTexNode(node.arg1)
-          ];
-          if (node.content === "sqrt") {
-            if (node.exponent) {
-              res.irregularData = latexNodeToTexNode(node.exponent);
-            }
-          }
-        } else if (num_args === 2) {
-          res.type = "binaryFunc";
-          res.args = [
-            latexNodeToTexNode(node.arg1),
-            latexNodeToTexNode(node.arg2)
-          ];
+        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 {
-          throw new LatexNodeToTexNodeError("Invalid number of arguments", node);
+          const command = eat_command_name(latex, pos + 1);
+          token = { type: "command", value: "\\" + command };
+          pos += 1 + command.length;
         }
         break;
-      case "text":
-        res.type = "text";
-        res.content = node.content;
-        break;
-      case "comment":
-        res.type = "comment";
-        res.content = node.content;
-        break;
-      case "whitespace":
-        res.type = "empty";
-        break;
-      case "newline":
-        res.type = "newline";
-        res.content = "\n";
-        break;
-      case "control":
-        if (node.content === "\\\\") {
-          res.type = "symbol";
-          res.content = node.content;
-          break;
+      }
+      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 {
-          throw new LatexNodeToTexNodeError(`Unknown control sequence: ${node.content}`, node);
+          token = { type: "unknown", value: firstChar };
         }
-        break;
-      default:
-        throw new LatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
+        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 res;
-  } catch (e) {
-    throw e;
   }
+  return tokens;
+}
+function token_eq(token1, token2) {
+  return token1.type == token2.type && token1.value == token2.value;
 }
 function parseTex(tex, customTexMacros) {
   const parser = new LatexParser;
-  for (const [macro, replacement] of Object.entries(customTexMacros)) {
-    tex = tex.replaceAll(macro, replacement);
+  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);
+    }
   }
-  const node = parser.parse(tex);
-  return latexNodeToTexNode(node);
+  return parser.parse(processed_tokens);
 }
 var UNARY_COMMANDS = [
   "sqrt",
@@ -337,6 +306,14 @@ var BINARY_COMMANDS = [
   "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) {
@@ -344,6 +321,8 @@ class LatexParserError extends Error {
     this.name = "LatexParserError";
   }
 }
+var SUB_SYMBOL = { type: "control", value: "_" };
+var SUP_SYMBOL = { type: "control", value: "^" };
 
 class LatexParser {
   space_sensitive;
@@ -352,69 +331,80 @@ class LatexParser {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
   }
-  parse(latex) {
+  parse(tokens) {
     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;
+    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;
+        }
+        if (!this.newline_sensitive && res.type === "newline") {
+          continue;
+        }
+        if (res.type === "control" && res.content === "&") {
+          throw new LatexParserError("Unexpected & outside of an alignment");
+        }
+        results2.push(res);
       }
-      if (res.type === "control" && res.content === "&") {
-        throw new LatexParserError("Unexpected & outside of an alignment");
+      if (results2.length === 0) {
+        return EMPTY_NODE;
+      } else if (results2.length === 1) {
+        return results2[0];
+      } else {
+        return { type: "ordgroup", content: "", args: results2 };
       }
-      results.push(res);
     }
     if (results.length === 0) {
       return EMPTY_NODE;
     } else if (results.length === 1) {
       return results[0];
     } else {
-      return { type: "ordgroup", args: results };
+      return { type: "ordgroup", content: "", args: results };
     }
   }
-  parseNextExpr(latex, start) {
-    let [base, pos] = this.parseNextExprWithoutSupSub(latex, start);
+  parseNextExpr(tokens, start) {
+    let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
     let sub = null;
     let sup = null;
     let num_prime = 0;
-    num_prime += eat_primes(latex, pos);
+    num_prime += eat_primes(tokens, pos);
     pos += num_prime;
-    if (pos < latex.length && latex[pos] === "_") {
-      [sub, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
-      num_prime += eat_primes(latex, pos);
+    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 < latex.length && latex[pos] === "^") {
-        [sup, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
-        if (eat_primes(latex, pos) > 0) {
+      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");
         }
       }
-    } else if (pos < latex.length && latex[pos] === "^") {
-      [sup, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
-      if (eat_primes(latex, pos) > 0) {
+    } 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 < latex.length && latex[pos] === "_") {
-        [sub, pos] = this.parseNextExprWithoutSupSub(latex, pos + 1);
-        if (eat_primes(latex, pos) > 0) {
+      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 (sub !== null || sup !== null || num_prime > 0) {
-      const res = { type: "supsub", base };
+      const res = { base };
       if (sub) {
         res.sub = sub;
       }
       if (num_prime > 0) {
-        res.sup = { type: "ordgroup", args: [] };
+        res.sup = { type: "ordgroup", content: "", args: [] };
         for (let i = 0;i < num_prime; i++) {
-          res.sup.args.push({ type: "command", content: "prime" });
+          res.sup.args.push({ type: "symbol", content: "\\prime" });
         }
         if (sup) {
           res.sup.args.push(sup);
@@ -425,194 +415,183 @@ class LatexParser {
       } else if (sup) {
         res.sup = sup;
       }
-      return [res, pos];
+      return [{ type: "supsub", content: "", data: 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];
+  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 "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");
+        }
+      default:
+        throw new LatexParserError("Unknown token type");
     }
   }
-  parseCommandExpr(latex, start) {
-    assert(latex[start] === "\\");
+  parseCommandExpr(tokens, start) {
+    assert(tokens[start].type === "command");
+    const command = tokens[start].value;
     let pos = start + 1;
-    const command = eat_command_name(latex, pos);
-    pos += command.length;
-    const paramNum = get_command_param_num(command);
+    if (["left", "right", "begin", "end"].includes(command.slice(1))) {
+      throw new LatexParserError("Unexpected command: " + command);
+    }
+    const paramNum = get_command_param_num(command.slice(1));
     if (paramNum === 0) {
-      return [{ type: "command", content: command }, pos];
+      return [{ type: "symbol", content: command }, pos];
     } else if (paramNum === 1) {
-      if (command === "sqrt" && pos < latex.length && latex[pos] === "[") {
+      if (command === "\\sqrt" && pos < tokens.length && token_eq(tokens[pos], LEFT_SQUARE_BRACKET)) {
         const posLeftSquareBracket = pos;
-        const posRightSquareBracket = find_closing_square_bracket(latex, pos);
-        const exprInside = latex.slice(posLeftSquareBracket + 1, posRightSquareBracket);
+        const posRightSquareBracket = find_closing_square_bracket(tokens, pos);
+        const exprInside = tokens.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];
+        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(latex, pos);
-      const [arg2, pos2] = this.parseNextExprWithoutSupSub(latex, pos1);
-      return [{ type: "command", content: command, arg1, arg2 }, pos2];
+      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");
     }
   }
-  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) {
+  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(latex, pos);
+    const leftDelimiter = eat_parenthesis(tokens, pos);
     if (leftDelimiter === null) {
       throw new LatexParserError("Invalid delimiter after \\left");
     }
-    pos += leftDelimiter.length;
+    pos++;
     const exprInsideStart = pos;
-    const idx = find_closing_right_command(latex, pos);
+    const idx = find_closing_right_command(tokens, 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");
+    pos = idx + 1;
+    pos += eat_whitespaces(tokens, pos).length;
+    if (pos >= tokens.length) {
+      throw new LatexParserError("Expecting \\right after \\left");
     }
-    const rightDelimiter = eat_parenthesis(latex, pos);
+    const rightDelimiter = eat_parenthesis(tokens, pos);
     if (rightDelimiter === null) {
       throw new LatexParserError("Invalid delimiter after \\right");
     }
-    pos += rightDelimiter.length;
-    const exprInside = latex.slice(exprInsideStart, exprInsideEnd);
+    pos++;
+    const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
     const body = this.parse(exprInside);
-    const res = { type: "leftright", left: leftDelimiter, right: rightDelimiter, body };
+    const args = [
+      { type: "element", content: leftDelimiter.value },
+      body,
+      { type: "element", content: rightDelimiter.value }
+    ];
+    const res = { type: "leftright", content: "", args };
     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;
+  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(latex, pos);
+    const endIdx = find_closing_end_command(tokens, 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) {
+    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");
     }
-    let exprInside = latex.slice(exprInsideStart, exprInsideEnd);
-    exprInside = exprInside.trimEnd();
+    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, body };
-    return [res, closingIdx + 1];
+    const res = { type: "beginend", content: envName, data: body };
+    return [res, pos];
   }
-  parseAligned(latex) {
+  parseAligned(tokens) {
     let pos = 0;
     const allRows = [];
     let row = [];
     allRows.push(row);
-    let group = { type: "ordgroup", args: [] };
+    let group = { type: "ordgroup", content: "", args: [] };
     row.push(group);
-    while (pos < latex.length) {
-      const [res, newPos] = this.parseNextExpr(latex, pos);
+    while (pos < tokens.length) {
+      const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
       if (res.type === "whitespace") {
         continue;
@@ -620,11 +599,11 @@ class LatexParser {
         continue;
       } else if (res.type === "control" && res.content === "\\\\") {
         row = [];
-        group = { type: "ordgroup", args: [] };
+        group = { type: "ordgroup", content: "", args: [] };
         row.push(group);
         allRows.push(row);
       } else if (res.type === "control" && res.content === "&") {
-        group = { type: "ordgroup", args: [] };
+        group = { type: "ordgroup", content: "", args: [] };
         row.push(group);
       } else {
         group.args.push(res);
@@ -634,15 +613,6 @@ class LatexParser {
   }
 }
 
-class LatexNodeToTexNodeError extends Error {
-  node;
-  constructor(message, node) {
-    super(message);
-    this.name = "LatexNodeToTexNodeError";
-    this.node = node;
-  }
-}
-
 // src/map.ts
 var symbolMap = new Map([
   ["gets", "arrow.l"],
@@ -988,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;
@@ -1035,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);
@@ -1064,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: ")" });
@@ -1090,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;
         }
@@ -1122,49 +1092,58 @@ class TypstWriter {
     } 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) => {
-        row.forEach((cell, j) => {
-          if (j > 0) {
-            this.queue.push({ type: "atom", content: "&" });
+    } 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 {
@@ -1204,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 {