tex2typst 0.2.7 → 0.2.9

package/dist/index.js

@@ -1,614 +1,3 @@
-// src/parser.ts
-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 "{":
-      case "}":
-      case "_":
-      case "^":
-      case "&":
-        token = { type: "control", value: firstChar };
-        pos++;
-        break;
-      case "\n":
-        token = { type: "newline", value: firstChar };
-        pos++;
-        break;
-      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 " ": {
-        let newPos = pos;
-        while (newPos < latex.length && latex[newPos] === " ") {
-          newPos += 1;
-        }
-        token = { type: "whitespace", value: latex.slice(pos, newPos) };
-        pos = newPos;
-        break;
-      }
-      case "\\": {
-        if (pos + 1 >= latex.length) {
-          throw new LatexParserError("Expecting command name after \\");
-        }
-        const firstTwoChars = latex.slice(pos, pos + 2);
-        if (["\\\\", "\\,"].includes(firstTwoChars)) {
-          token = { type: "control", value: firstTwoChars };
-        } else if (["\\{", "\\}", "\\%", "\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
-          token = { type: "element", value: firstTwoChars };
-        } else {
-          const command = eat_command_name(latex, pos + 1);
-          token = { type: "command", value: "\\" + command };
-        }
-        pos += token.value.length;
-        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 {
-          token = { type: "unknown", value: firstChar };
-        }
-        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 passIgnoreWhitespaceBeforeScriptMark(tokens) {
-  const is_script_mark = (token) => token_eq(token, SUB_SYMBOL) || token_eq(token, SUP_SYMBOL);
-  let out_tokens = [];
-  for (let i = 0;i < tokens.length; i++) {
-    if (tokens[i].type === "whitespace" && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
-      continue;
-    }
-    if (tokens[i].type === "whitespace" && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
-      continue;
-    }
-    out_tokens.push(tokens[i]);
-  }
-  return out_tokens;
-}
-function passExpandCustomTexMacros(tokens, customTexMacros) {
-  let out_tokens = [];
-  for (const token of tokens) {
-    if (token.type === "command" && customTexMacros[token.value]) {
-      const expanded_tokens = tokenize(customTexMacros[token.value]);
-      out_tokens = out_tokens.concat(expanded_tokens);
-    } else {
-      out_tokens.push(token);
-    }
-  }
-  return out_tokens;
-}
-function parseTex(tex, customTexMacros) {
-  const parser = new LatexParser;
-  let tokens = tokenize(tex);
-  tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
-  tokens = passExpandCustomTexMacros(tokens, customTexMacros);
-  return parser.parse(tokens);
-}
-var UNARY_COMMANDS = [
-  "sqrt",
-  "text",
-  "bar",
-  "bold",
-  "boldsymbol",
-  "ddot",
-  "dot",
-  "hat",
-  "mathbb",
-  "mathbf",
-  "mathcal",
-  "mathfrak",
-  "mathit",
-  "mathrm",
-  "mathscr",
-  "mathsf",
-  "mathtt",
-  "operatorname",
-  "overbrace",
-  "overline",
-  "pmb",
-  "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;
-        }
-        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 (results2.length === 0) {
-        return EMPTY_NODE;
-      } else if (results2.length === 1) {
-        return results2[0];
-      } else {
-        return { type: "ordgroup", content: "", args: results2 };
-      }
-    }
-    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");
-        }
-      }
-    } 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 (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" });
-        }
-        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 [{ 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 "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 "\\,":
-            return [{ type: "control", content: "\\," }, start + 1];
-          case "_": {
-            return [EMPTY_NODE, start];
-          }
-          case "^": {
-            return [EMPTY_NODE, start];
-          }
-          case "&":
-            return [{ type: "control", content: "&" }, start + 1];
-          default:
-            throw new LatexParserError("Unknown control sequence");
-        }
-      default:
-        throw new LatexParserError("Unknown token type");
-    }
-  }
-  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);
-    }
-    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");
-    }
-  }
-  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];
-  }
-  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 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];
-  }
-  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;
-  }
-}
-
 // src/map.ts
 var symbolMap = new Map([
   ["nonumber", ""],
@@ -909,7 +298,792 @@ var symbolMap = new Map([
   ["TeX", "#TeX"]
 ]);
 
+// src/parser.ts
+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 && [4 /* WHITESPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
+    pos++;
+  }
+  return tokens.slice(start, pos);
+}
+function eat_parenthesis(tokens, start) {
+  const firstToken = tokens[start];
+  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}"].includes(firstToken.value)) {
+    return firstToken;
+  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+    return firstToken;
+  } else {
+    return null;
+  }
+}
+function eat_primes(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && token_eq(tokens[pos], { type: 0 /* 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: 3 /* COMMENT */, value: latex.slice(pos + 1, newPos) };
+        pos = newPos;
+        break;
+      }
+      case "{":
+      case "}":
+      case "_":
+      case "^":
+      case "&":
+        token = { type: 6 /* CONTROL */, value: firstChar };
+        pos++;
+        break;
+      case "\n":
+        token = { type: 5 /* NEWLINE */, value: firstChar };
+        pos++;
+        break;
+      case "\r": {
+        if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
+          token = { type: 5 /* NEWLINE */, value: "\n" };
+          pos += 2;
+        } else {
+          token = { type: 5 /* NEWLINE */, value: "\n" };
+          pos++;
+        }
+        break;
+      }
+      case " ": {
+        let newPos = pos;
+        while (newPos < latex.length && latex[newPos] === " ") {
+          newPos += 1;
+        }
+        token = { type: 4 /* WHITESPACE */, value: latex.slice(pos, newPos) };
+        pos = newPos;
+        break;
+      }
+      case "\\": {
+        if (pos + 1 >= latex.length) {
+          throw new LatexParserError("Expecting command name after \\");
+        }
+        const firstTwoChars = latex.slice(pos, pos + 2);
+        if (["\\\\", "\\,"].includes(firstTwoChars)) {
+          token = { type: 6 /* CONTROL */, value: firstTwoChars };
+        } else if (["\\{", "\\}", "\\%", "\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
+          token = { type: 0 /* ELEMENT */, value: firstTwoChars };
+        } else {
+          const command = eat_command_name(latex, pos + 1);
+          token = { type: 1 /* COMMAND */, value: "\\" + command };
+        }
+        pos += token.value.length;
+        break;
+      }
+      default: {
+        if (isdigit(firstChar)) {
+          let newPos = pos;
+          while (newPos < latex.length && isdigit(latex[newPos])) {
+            newPos += 1;
+          }
+          token = { type: 0 /* ELEMENT */, value: latex.slice(pos, newPos) };
+        } else if (isalpha(firstChar)) {
+          token = { type: 0 /* ELEMENT */, value: firstChar };
+        } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
+          token = { type: 0 /* ELEMENT */, value: firstChar };
+        } else {
+          token = { type: 7 /* UNKNOWN */, value: firstChar };
+        }
+        pos += token.value.length;
+      }
+    }
+    tokens.push(token);
+    if (token.type === 1 /* COMMAND */ && ["\\text", "\\operatorname", "\\begin", "\\end"].includes(token.value)) {
+      if (pos >= latex.length || latex[pos] !== "{") {
+        throw new LatexParserError(`No content for ${token.value} command`);
+      }
+      tokens.push({ type: 6 /* 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: 2 /* TEXT */, value: textInside });
+      tokens.push({ type: 6 /* CONTROL */, value: "}" });
+      pos = posClosingBracket + 1;
+    }
+  }
+  return tokens;
+}
+function token_eq(token1, token2) {
+  return token1.type == token2.type && token1.value == token2.value;
+}
+function passIgnoreWhitespaceBeforeScriptMark(tokens) {
+  const is_script_mark = (token) => token_eq(token, SUB_SYMBOL) || token_eq(token, SUP_SYMBOL);
+  let out_tokens = [];
+  for (let i = 0;i < tokens.length; i++) {
+    if (tokens[i].type === 4 /* WHITESPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
+      continue;
+    }
+    if (tokens[i].type === 4 /* WHITESPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
+      continue;
+    }
+    out_tokens.push(tokens[i]);
+  }
+  return out_tokens;
+}
+function passExpandCustomTexMacros(tokens, customTexMacros) {
+  let out_tokens = [];
+  for (const token of tokens) {
+    if (token.type === 1 /* COMMAND */ && customTexMacros[token.value]) {
+      const expanded_tokens = tokenize(customTexMacros[token.value]);
+      out_tokens = out_tokens.concat(expanded_tokens);
+    } else {
+      out_tokens.push(token);
+    }
+  }
+  return out_tokens;
+}
+function parseTex(tex, customTexMacros) {
+  const parser = new LatexParser;
+  let tokens = tokenize(tex);
+  tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
+  tokens = passExpandCustomTexMacros(tokens, customTexMacros);
+  return parser.parse(tokens);
+}
+var UNARY_COMMANDS = [
+  "sqrt",
+  "text",
+  "bar",
+  "bold",
+  "boldsymbol",
+  "ddot",
+  "dot",
+  "hat",
+  "mathbb",
+  "mathbf",
+  "mathcal",
+  "mathfrak",
+  "mathit",
+  "mathrm",
+  "mathscr",
+  "mathsf",
+  "mathtt",
+  "operatorname",
+  "overbrace",
+  "overline",
+  "pmb",
+  "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: 6 /* CONTROL */, value: "{" };
+var RIGHT_CURLY_BRACKET = { type: 6 /* CONTROL */, value: "}" };
+var LEFT_SQUARE_BRACKET = { type: 0 /* ELEMENT */, value: "[" };
+var RIGHT_SQUARE_BRACKET = { type: 0 /* ELEMENT */, value: "]" };
+var LEFT_COMMAND = { type: 1 /* COMMAND */, value: "\\left" };
+var RIGHT_COMMAND = { type: 1 /* COMMAND */, value: "\\right" };
+var BEGIN_COMMAND = { type: 1 /* COMMAND */, value: "\\begin" };
+var END_COMMAND = { type: 1 /* COMMAND */, value: "\\end" };
+
+class LatexParserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LatexParserError";
+  }
+}
+var SUB_SYMBOL = { type: 6 /* CONTROL */, value: "_" };
+var SUP_SYMBOL = { type: 6 /* 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;
+        }
+        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 (results2.length === 0) {
+        return EMPTY_NODE;
+      } else if (results2.length === 1) {
+        return results2[0];
+      } else {
+        return { type: "ordgroup", content: "", args: results2 };
+      }
+    }
+    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");
+        }
+      }
+    } 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 (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: "element", content: "'" });
+        }
+        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 [{ type: "supsub", content: "", data: res }, pos];
+    } else {
+      return [base, pos];
+    }
+  }
+  parseNextExprWithoutSupSub(tokens, start) {
+    const firstToken = tokens[start];
+    const tokenType = firstToken.type;
+    switch (tokenType) {
+      case 0 /* ELEMENT */:
+        return [{ type: "element", content: firstToken.value }, start + 1];
+      case 2 /* TEXT */:
+        return [{ type: "text", content: firstToken.value }, start + 1];
+      case 3 /* COMMENT */:
+        return [{ type: "comment", content: firstToken.value }, start + 1];
+      case 4 /* WHITESPACE */:
+        return [{ type: "whitespace", content: firstToken.value }, start + 1];
+      case 5 /* NEWLINE */:
+        return [{ type: "newline", content: firstToken.value }, start + 1];
+      case 1 /* 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 6 /* 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 "\\,":
+            return [{ type: "control", content: "\\," }, start + 1];
+          case "_": {
+            return [EMPTY_NODE, start];
+          }
+          case "^": {
+            return [EMPTY_NODE, start];
+          }
+          case "&":
+            return [{ type: "control", content: "&" }, start + 1];
+          default:
+            throw new LatexParserError("Unknown control sequence");
+        }
+      default:
+        throw new LatexParserError("Unknown token type");
+    }
+  }
+  parseCommandExpr(tokens, start) {
+    assert(tokens[start].type === 1 /* 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);
+    }
+    const paramNum = get_command_param_num(command.slice(1));
+    switch (paramNum) {
+      case 0:
+        if (!symbolMap.has(command.slice(1))) {
+          return [{ type: "unknownMacro", content: command }, pos];
+        }
+        return [{ type: "symbol", content: command }, pos];
+      case 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 === 2 /* 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];
+      }
+      case 2: {
+        const [arg1, pos1] = this.parseNextExprWithoutSupSub(tokens, pos);
+        const [arg2, pos2] = this.parseNextExprWithoutSupSub(tokens, pos1);
+        return [{ type: "binaryFunc", content: command, args: [arg1, arg2] }, pos2];
+      }
+      default:
+        throw new Error("Invalid number of parameters");
+    }
+  }
+  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];
+  }
+  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 === 2 /* 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 exprInsideEnd = endIdx;
+    pos = endIdx + 1;
+    assert(token_eq(tokens[pos], LEFT_CURLY_BRACKET));
+    assert(tokens[pos + 1].type === 2 /* 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 && [4 /* WHITESPACE */, 5 /* 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];
+  }
+  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;
+  }
+}
+
 // src/writer.ts
+function is_delimiter(c) {
+  return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
+}
+function convertTree(node) {
+  switch (node.type) {
+    case "empty":
+    case "whitespace":
+      return { type: "empty", content: "" };
+    case "ordgroup":
+      return {
+        type: "group",
+        content: "",
+        args: node.args.map(convertTree)
+      };
+    case "element":
+      return { type: "atom", content: convertToken(node.content) };
+    case "symbol":
+      return { type: "symbol", content: convertToken(node.content) };
+    case "text":
+      return { type: "text", content: node.content };
+    case "comment":
+      return { type: "comment", content: node.content };
+    case "supsub": {
+      let { base, sup, sub } = node.data;
+      if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
+        return {
+          type: "binaryFunc",
+          content: "overbrace",
+          args: [convertTree(base.args[0]), convertTree(sup)]
+        };
+      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
+        return {
+          type: "binaryFunc",
+          content: "underbrace",
+          args: [convertTree(base.args[0]), convertTree(sub)]
+        };
+      }
+      const data = {
+        base: convertTree(base)
+      };
+      if (data.base.type === "empty") {
+        data.base = { type: "text", content: "" };
+      }
+      if (sup) {
+        data.sup = convertTree(sup);
+      }
+      if (sub) {
+        data.sub = convertTree(sub);
+      }
+      return {
+        type: "supsub",
+        content: "",
+        data
+      };
+    }
+    case "leftright": {
+      const [left, body, right] = node.args;
+      const group = {
+        type: "group",
+        content: "",
+        args: node.args.map(convertTree)
+      };
+      if (["[]", "()", "\\{\\}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
+        return group;
+      }
+      return {
+        type: "unaryFunc",
+        content: "lr",
+        args: [group]
+      };
+    }
+    case "binaryFunc": {
+      return {
+        type: "binaryFunc",
+        content: convertToken(node.content),
+        args: node.args.map(convertTree)
+      };
+    }
+    case "unaryFunc": {
+      const arg0 = convertTree(node.args[0]);
+      if (node.content === "\\sqrt" && node.data) {
+        const data = convertTree(node.data);
+        return {
+          type: "binaryFunc",
+          content: "root",
+          args: [data, arg0]
+        };
+      }
+      if (node.content === "\\mathbf") {
+        const inner = {
+          type: "unaryFunc",
+          content: "bold",
+          args: [arg0]
+        };
+        return {
+          type: "unaryFunc",
+          content: "upright",
+          args: [inner]
+        };
+      }
+      if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
+        return {
+          type: "symbol",
+          content: arg0.content + arg0.content
+        };
+      }
+      if (node.content === "\\operatorname") {
+        const body = node.args;
+        if (body.length !== 1 || body[0].type !== "text") {
+          throw new TypstWriterError(`Expecting body of \\operatorname to be text but got`, node);
+        }
+        const text = body[0].content;
+        if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
+          return {
+            type: "symbol",
+            content: text
+          };
+        } else {
+          return {
+            type: "unaryFunc",
+            content: "op",
+            args: [{ type: "text", content: text }]
+          };
+        }
+      }
+      return {
+        type: "unaryFunc",
+        content: convertToken(node.content),
+        args: node.args.map(convertTree)
+      };
+    }
+    case "newline":
+      return { type: "newline", content: "\n" };
+    case "beginend": {
+      const matrix = node.data;
+      const data = matrix.map((row) => row.map(convertTree));
+      if (node.content.startsWith("align")) {
+        return {
+          type: "align",
+          content: "",
+          data
+        };
+      } else {
+        return {
+          type: "matrix",
+          content: "mat",
+          data
+        };
+      }
+    }
+    case "unknownMacro":
+      return { type: "unknown", content: convertToken(node.content) };
+    case "control":
+      if (node.content === "\\\\") {
+        return { type: "symbol", content: "\\" };
+      } else if (node.content === "\\,") {
+        return { type: "symbol", content: "thin" };
+      } else {
+        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
+      }
+    default:
+      throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
+  }
+}
 function convertToken(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
@@ -971,7 +1145,7 @@ class TypstWriter {
       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);
+      no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
       if (!no_need_space) {
         this.buffer += " ";
       }
@@ -982,142 +1156,75 @@ class TypstWriter {
     this.buffer += str;
   }
   append(node) {
-    if (node.type === "empty" || node.type === "whitespace") {
-      return;
-    } else if (node.type === "ordgroup") {
-      node.args.forEach((arg) => this.append(arg));
-    } else if (node.type === "element") {
-      let content = node.content;
-      if (node.content === "," && this.insideFunctionDepth > 0) {
-        content = "comma";
-      }
-      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.data;
-      if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
-        this.append({ type: "binaryFunc", content: "\\overbrace", args: [base.args[0], sup] });
-        return;
-      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
-        this.append({ type: "binaryFunc", content: "\\underbrace", args: [base.args[0], sub] });
-        return;
+    switch (node.type) {
+      case "empty":
+        break;
+      case "atom": {
+        if (node.content === "," && this.insideFunctionDepth > 0) {
+          this.queue.push({ type: "symbol", content: "comma" });
+        } else {
+          this.queue.push({ type: "atom", content: node.content });
+        }
+        break;
       }
-      if (base.type === "empty") {
-        this.queue.push({ type: "text", content: "" });
-      } else {
+      case "symbol":
+      case "text":
+      case "comment":
+      case "newline":
+        this.queue.push(node);
+        break;
+      case "group":
+        for (const item of node.args) {
+          this.append(item);
+        }
+        break;
+      case "supsub": {
+        let { base, sup, sub } = node.data;
         this.appendWithBracketsIfNeeded(base);
+        let trailing_space_needed = false;
+        const has_prime = sup && sup.type === "atom" && sup.content === "\'";
+        if (has_prime) {
+          this.queue.push({ type: "atom", content: "\'" });
+          trailing_space_needed = false;
+        }
+        if (sub) {
+          this.queue.push({ type: "atom", content: "_" });
+          trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
+        }
+        if (sup && !has_prime) {
+          this.queue.push({ type: "atom", content: "^" });
+          trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
+        }
+        if (trailing_space_needed) {
+          this.queue.push({ type: "softSpace", content: "" });
+        }
+        break;
       }
-      let trailing_space_needed = false;
-      const has_prime = sup && sup.type === "symbol" && sup.content === "\\prime";
-      if (has_prime) {
-        this.queue.push({ type: "atom", content: "\'" });
-        trailing_space_needed = false;
-      }
-      if (sub) {
-        this.queue.push({ type: "atom", content: "_" });
-        trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
-      }
-      if (sup && !has_prime) {
-        this.queue.push({ type: "atom", content: "^" });
-        trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
-      }
-      if (trailing_space_needed) {
-        this.queue.push({ type: "softSpace", content: "" });
-      }
-    } else if (node.type === "leftright") {
-      const [left, body, right] = node.args;
-      if (["[]", "()", "\\{\\}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
-        this.append(left);
-        this.append(body);
-        this.append(right);
-        return;
-      }
-      const func_symbol = { type: "symbol", content: "lr" };
-      this.queue.push(func_symbol);
-      this.insideFunctionDepth++;
-      this.queue.push({ type: "atom", content: "(" });
-      this.append(left);
-      this.append(body);
-      this.append(right);
-      this.queue.push({ type: "atom", content: ")" });
-      this.insideFunctionDepth--;
-    } else if (node.type === "binaryFunc") {
-      const func_symbol = { type: "symbol", content: node.content };
-      const [arg0, arg1] = node.args;
-      this.queue.push(func_symbol);
-      this.insideFunctionDepth++;
-      this.queue.push({ type: "atom", content: "(" });
-      this.append(arg0);
-      this.queue.push({ type: "atom", content: "," });
-      this.append(arg1);
-      this.queue.push({ type: "atom", content: ")" });
-      this.insideFunctionDepth--;
-    } else if (node.type === "unaryFunc") {
-      const func_symbol = { type: "symbol", content: node.content };
-      const arg0 = node.args[0];
-      if (node.content === "\\sqrt" && node.data) {
-        func_symbol.content = "root";
+      case "binaryFunc": {
+        const func_symbol = { type: "symbol", content: node.content };
+        const [arg0, arg1] = node.args;
         this.queue.push(func_symbol);
         this.insideFunctionDepth++;
         this.queue.push({ type: "atom", content: "(" });
-        this.append(node.data);
-        this.queue.push({ type: "atom", content: "," });
         this.append(arg0);
+        this.queue.push({ type: "atom", content: "," });
+        this.append(arg1);
         this.queue.push({ type: "atom", content: ")" });
         this.insideFunctionDepth--;
-        return;
-      } else if (node.content === "\\mathbf") {
-        this.append({ type: "symbol", content: "upright" });
-        this.insideFunctionDepth++;
-        this.queue.push({ type: "atom", content: "(" });
+        break;
+      }
+      case "unaryFunc": {
+        const func_symbol = { type: "symbol", content: node.content };
+        const arg0 = node.args[0];
         this.queue.push(func_symbol);
         this.insideFunctionDepth++;
         this.queue.push({ type: "atom", content: "(" });
         this.append(arg0);
         this.queue.push({ type: "atom", content: ")" });
         this.insideFunctionDepth--;
-        this.queue.push({ type: "atom", content: ")" });
-        this.insideFunctionDepth--;
-        return;
-      } else if (node.content === "\\mathbb") {
-        const body = node.args[0];
-        if (body.type === "element" && /^[A-Z]$/.test(body.content)) {
-          this.queue.push({ type: "symbol", content: body.content + body.content });
-          return;
-        }
-      } else if (node.content === "\\operatorname") {
-        let body = node.args;
-        if (body.length === 1 && body[0].type == "ordgroup") {
-          body = body[0].args;
-        }
-        const text = body.reduce((buff, n) => {
-          buff += convertToken(n.content);
-          return buff;
-        }, "");
-        if (this.preferTypstIntrinsic && TYPST_INTRINSIC_SYMBOLS.includes(text)) {
-          this.queue.push({ type: "symbol", content: text });
-        } else {
-          this.queue.push({ type: "symbol", content: "op" });
-          this.queue.push({ type: "atom", content: "(" });
-          this.queue.push({ type: "text", content: text });
-          this.queue.push({ type: "atom", content: ")" });
-        }
-        return;
+        break;
       }
-      this.queue.push(func_symbol);
-      this.insideFunctionDepth++;
-      this.queue.push({ type: "atom", content: "(" });
-      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 === "beginend") {
-      if (node.content.startsWith("align")) {
+      case "align": {
         const matrix = node.data;
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
@@ -1127,10 +1234,12 @@ class TypstWriter {
             this.append(cell);
           });
           if (i < matrix.length - 1) {
-            this.queue.push({ type: "symbol", content: "\\\\" });
+            this.queue.push({ type: "symbol", content: "\\" });
           }
         });
-      } else {
+        break;
+      }
+      case "matrix": {
         const matrix = node.data;
         this.queue.push({ type: "symbol", content: "mat" });
         this.insideFunctionDepth++;
@@ -1138,10 +1247,6 @@ class TypstWriter {
         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: "," });
@@ -1154,37 +1259,45 @@ class TypstWriter {
         });
         this.queue.push({ type: "atom", content: ")" });
         this.insideFunctionDepth--;
+        break;
       }
-    } 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);
+      case "unknown": {
+        if (this.nonStrict) {
+          this.queue.push({ type: "symbol", content: node.content });
+        } else {
+          throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
+        }
+        break;
       }
-    } else if (node.type === "control") {
-      if (node.content === "\\\\") {
-        this.queue.push({ type: "symbol", content: node.content });
-      } else if (node.content === "\\,") {
-        this.queue.push({ type: "symbol", content: "thin" });
-      } else {
-        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
+      default:
+        throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
+    }
+  }
+  appendWithBracketsIfNeeded(node) {
+    let need_to_wrap = ["group", "supsub", "empty"].includes(node.type);
+    if (node.type === "group") {
+      const first = node.args[0];
+      const last = node.args[node.args.length - 1];
+      if (is_delimiter(first) && is_delimiter(last)) {
+        need_to_wrap = false;
       }
-    } else if (node.type === "comment") {
-      this.queue.push({ type: "comment", content: node.content });
+    }
+    if (need_to_wrap) {
+      this.queue.push({ type: "atom", content: "(" });
+      this.append(node);
+      this.queue.push({ type: "atom", content: ")" });
     } else {
-      throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
+      this.append(node);
     }
+    return !need_to_wrap;
   }
   flushQueue() {
     this.queue.forEach((node) => {
       let str = "";
       switch (node.type) {
         case "atom":
-          str = node.content;
-          break;
         case "symbol":
-          str = convertToken(node.content);
+          str = node.content;
           break;
         case "text":
           str = `"${node.content}"`;
@@ -1208,23 +1321,6 @@ class TypstWriter {
     });
     this.queue = [];
   }
-  appendWithBracketsIfNeeded(node) {
-    const is_single = ["symbol", "element", "unaryFunc", "binaryFunc", "leftright"].includes(node.type);
-    if (is_single) {
-      this.append(node);
-    } else {
-      this.queue.push({
-        type: "atom",
-        content: "("
-      });
-      this.append(node);
-      this.queue.push({
-        type: "atom",
-        content: ")"
-      });
-    }
-    return is_single;
-  }
   finalize() {
     this.flushQueue();
     const smartFloorPass = function(input) {
@@ -1246,7 +1342,7 @@ class TypstWriter {
 // src/index.ts
 function tex2typst(tex, options) {
   const opt = {
-    nonStrict: false,
+    nonStrict: true,
     preferTypstIntrinsic: true,
     customTexMacros: {}
   };
@@ -1261,9 +1357,10 @@ function tex2typst(tex, options) {
       opt.customTexMacros = options.customTexMacros;
     }
   }
-  const t = parseTex(tex, opt.customTexMacros);
+  const texTree = parseTex(tex, opt.customTexMacros);
+  const typstTree = convertTree(texTree);
   const writer2 = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic);
-  writer2.append(t);
+  writer2.append(typstTree);
   return writer2.finalize();
 }
 export {