tex2typst 0.2.15 → 0.3.0-alpha

package/dist/index.js

@@ -7,7 +7,6 @@ var symbolMap = new Map([
   ["ddot", "dot.double"],
   ["doteq", "dot(eq)"],
   ["dots", "dots.h"],
-  ["ldots", "dots.h"],
   ["vdots", "dots.v"],
   ["ddots", "dots.down"],
   ["widehat", "hat"],
@@ -23,6 +22,7 @@ var symbolMap = new Map([
   ["tbinom", "binom"],
   ["dfrac", "frac"],
   ["tfrac", "frac"],
+  ["operatorname", "op"],
   ["boldsymbol", "bold"],
   ["mathbb", "bb"],
   ["mathbf", "bold"],
@@ -160,7 +160,7 @@ var symbolMap = new Map([
   ["langle", "angle.l"],
   ["lbrace", "brace.l"],
   ["lbrack", "bracket.l"],
-  ["ldots", "dots.l"],
+  ["ldots", "dots.h"],
   ["le", "lt.eq"],
   ["leadsto", "arrow.squiggly"],
   ["leftarrow", "arrow.l"],
@@ -937,62 +937,6 @@ var map_from_official_docs = new Map([
   ["barV", "tack.b.double"],
   ["shortdowntack", "tack.b.short"],
   ["dashVdash", "tack.l.r"],
-  ["mupalpha", "alpha"],
-  ["mupbeta", "beta"],
-  ["mupchi", "chi"],
-  ["mupdelta", "delta"],
-  ["mupvarepsilon", "epsilon"],
-  ["mupepsilon", "epsilon.alt"],
-  ["mupeta", "eta"],
-  ["mupgamma", "gamma"],
-  ["mupiota", "iota"],
-  ["mupkappa", "kappa"],
-  ["mupvarkappa", "kappa.alt"],
-  ["muplambda", "lambda"],
-  ["mupmu", "mu"],
-  ["mupnu", "nu"],
-  ["mho", "ohm.inv"],
-  ["mupomega", "omega"],
-  ["mupomicron", "omicron"],
-  ["mupvarphi", "phi"],
-  ["mupphi", "phi.alt"],
-  ["muppi", "pi"],
-  ["mupvarpi", "pi.alt"],
-  ["muppsi", "psi"],
-  ["muprho", "rho"],
-  ["mupvarrho", "rho.alt"],
-  ["mupsigma", "sigma"],
-  ["mupvarsigma", "sigma.alt"],
-  ["muptau", "tau"],
-  ["muptheta", "theta"],
-  ["mupvartheta", "theta.alt"],
-  ["mupupsilon", "upsilon"],
-  ["mupxi", "xi"],
-  ["mupzeta", "zeta"],
-  ["mupAlpha", "Alpha"],
-  ["mupBeta", "Beta"],
-  ["mupChi", "Chi"],
-  ["mupDelta", "Delta"],
-  ["mupEpsilon", "Epsilon"],
-  ["mupEta", "Eta"],
-  ["mupGamma", "Gamma"],
-  ["mupIota", "Iota"],
-  ["mupKappa", "Kappa"],
-  ["mupLambda", "Lambda"],
-  ["mupMu", "Mu"],
-  ["mupNu", "Nu"],
-  ["mupOmega", "Omega"],
-  ["mupOmicron", "Omicron"],
-  ["mupPhi", "Phi"],
-  ["mupPi", "Pi"],
-  ["mupPsi", "Psi"],
-  ["mupRho", "Rho"],
-  ["mupSigma", "Sigma"],
-  ["mupTau", "Tau"],
-  ["mupTheta", "Theta"],
-  ["mupUpsilon", "Upsilon"],
-  ["mupXi", "Xi"],
-  ["mupZeta", "Zeta"],
   ["BbbA", "AA"],
   ["BbbB", "BB"],
   ["BbbC", "CC"],
@@ -1033,8 +977,84 @@ for (const [key, value] of map_from_official_docs) {
     symbolMap.set(key, value);
   }
 }
+var reverseSymbolMap = new Map;
+for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
+  reverseSymbolMap.set(value, key);
+}
+reverseSymbolMap.set("dif", "mathrm{d}");
+var typst_to_tex_map = new Map([
+  ["top", "top"],
+  ["frac", "frac"],
+  ["tilde", "tilde"],
+  ["hat", "hat"],
+  ["upright", "mathrm"],
+  ["bold", "boldsymbol"]
+]);
+for (const [key, value] of typst_to_tex_map) {
+  reverseSymbolMap.set(key, value);
+}
+
+// src/generic.ts
+function array_find(array, item, start = 0) {
+  for (let i = start;i < array.length; i++) {
+    if (array[i].eq(item)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function array_includes(array, item) {
+  for (const i of array) {
+    if (i.eq(item)) {
+      return true;
+    }
+  }
+  return false;
+}
+function array_split(array, sep) {
+  const res = [];
+  let current_slice = [];
+  for (const i of array) {
+    if (i.eq(sep)) {
+      res.push(current_slice);
+      current_slice = [];
+    } else {
+      current_slice.push(i);
+    }
+  }
+  res.push(current_slice);
+  return res;
+}
 
 // src/types.ts
+function apply_escape_if_needed(c) {
+  if (["{", "}", "%"].includes(c)) {
+    return "\\" + c;
+  }
+  return c;
+}
+class TexToken {
+  type;
+  value;
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+  }
+  eq(token) {
+    return this.type === token.type && this.value === token.value;
+  }
+  toString() {
+    switch (this.type) {
+      case 2 /* TEXT */:
+        return `\\text{${this.value}}`;
+      case 3 /* COMMENT */:
+        return `%${this.value}`;
+      default:
+        return this.value;
+    }
+  }
+}
+
 class TexNode {
   type;
   content;
@@ -1046,7 +1066,7 @@ class TexNode {
     this.args = args;
     this.data = data;
   }
-  eq_shallow(other) {
+  eq(other) {
     return this.type === other.type && this.content === other.content;
   }
   toString() {
@@ -1057,26 +1077,172 @@ class TexNode {
         throw new Error(`toString() is not implemented for type ${this.type}`);
     }
   }
+  serialize() {
+    switch (this.type) {
+      case "empty":
+        return [];
+      case "element": {
+        let c = this.content;
+        c = apply_escape_if_needed(c);
+        return [new TexToken(0 /* ELEMENT */, c)];
+      }
+      case "symbol":
+        return [new TexToken(1 /* COMMAND */, this.content)];
+      case "text":
+        return [new TexToken(2 /* TEXT */, this.content)];
+      case "comment":
+        return [new TexToken(3 /* COMMENT */, this.content)];
+      case "whitespace": {
+        const tokens = [];
+        for (const c of this.content) {
+          const token_type = c === " " ? 4 /* SPACE */ : 5 /* NEWLINE */;
+          tokens.push(new TexToken(token_type, c));
+        }
+        return tokens;
+      }
+      case "ordgroup":
+        return this.args.map((n) => n.serialize()).flat();
+      case "unaryFunc": {
+        let tokens = [];
+        tokens.push(new TexToken(1 /* COMMAND */, this.content));
+        if (this.content === "\\sqrt" && this.data) {
+          tokens.push(new TexToken(0 /* ELEMENT */, "["));
+          tokens = tokens.concat(this.data.serialize());
+          tokens.push(new TexToken(0 /* ELEMENT */, "]"));
+        }
+        if (this.content === "\\operatorname" && this.args.length === 1 && this.args[0].type === "text") {
+          const text = this.args[0].content;
+          tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+          tokens.push(new TexToken(1 /* COMMAND */, text));
+          tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+          return tokens;
+        }
+        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+        tokens = tokens.concat(this.args[0].serialize());
+        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+        return tokens;
+      }
+      case "binaryFunc": {
+        let tokens = [];
+        tokens.push(new TexToken(1 /* COMMAND */, this.content));
+        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+        tokens = tokens.concat(this.args[0].serialize());
+        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+        tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+        tokens = tokens.concat(this.args[1].serialize());
+        tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+        return tokens;
+      }
+      case "supsub": {
+        let tokens = [];
+        const { base, sup, sub } = this.data;
+        tokens = tokens.concat(base.serialize());
+        if (sub) {
+          tokens.push(new TexToken(6 /* CONTROL */, "_"));
+          if (sub.type === "ordgroup" || sub.type === "supsub" || sub.type === "empty") {
+            tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+            tokens = tokens.concat(sub.serialize());
+            tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+          } else {
+            tokens = tokens.concat(sub.serialize());
+          }
+        }
+        if (sup) {
+          tokens.push(new TexToken(6 /* CONTROL */, "^"));
+          if (sup.type === "ordgroup" || sup.type === "supsub" || sup.type === "empty") {
+            tokens.push(new TexToken(0 /* ELEMENT */, "{"));
+            tokens = tokens.concat(sup.serialize());
+            tokens.push(new TexToken(0 /* ELEMENT */, "}"));
+          } else {
+            tokens = tokens.concat(sup.serialize());
+          }
+        }
+        return tokens;
+      }
+      case "control": {
+        return [new TexToken(6 /* CONTROL */, this.content)];
+      }
+      case "beginend": {
+        let tokens = [];
+        const matrix = this.data;
+        tokens.push(new TexToken(1 /* COMMAND */, `\\begin{${this.content}}`));
+        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
+        for (let i = 0;i < matrix.length; i++) {
+          const row = matrix[i];
+          for (let j = 0;j < row.length; j++) {
+            const cell = row[j];
+            tokens = tokens.concat(cell.serialize());
+            if (j !== row.length - 1) {
+              tokens.push(new TexToken(6 /* CONTROL */, "&"));
+            }
+          }
+          if (i !== matrix.length - 1) {
+            tokens.push(new TexToken(6 /* CONTROL */, "\\\\"));
+          }
+        }
+        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
+        tokens.push(new TexToken(1 /* COMMAND */, `\\end{${this.content}}`));
+        return tokens;
+      }
+      default:
+        throw new Error("[TexNode.serialize] Unimplemented type: " + this.type);
+    }
+  }
 }
 class TypstToken {
   type;
-  content;
+  value;
   constructor(type, content) {
     this.type = type;
-    this.content = content;
+    this.value = content;
   }
   eq(other) {
-    return this.type === other.type && this.content === other.content;
+    return this.type === other.type && this.value === other.value;
   }
   isOneOf(tokens) {
-    let found = false;
-    for (const token of tokens) {
-      if (this.eq(token)) {
-        found = true;
-        break;
+    return array_includes(tokens, this);
+  }
+  toNode() {
+    switch (this.type) {
+      case 2 /* TEXT */:
+        return new TypstNode("text", this.value);
+      case 3 /* COMMENT */:
+        return new TypstNode("comment", this.value);
+      case 4 /* SPACE */:
+      case 7 /* NEWLINE */:
+        return new TypstNode("whitespace", this.value);
+      case 1 /* ELEMENT */:
+        return new TypstNode("atom", this.value);
+      case 0 /* SYMBOL */:
+        return new TypstNode("symbol", this.value);
+      case 6 /* CONTROL */: {
+        const controlChar = this.value;
+        switch (controlChar) {
+          case "":
+          case "_":
+          case "^":
+            return new TypstNode("empty", "");
+          case "&":
+            return new TypstNode("control", "&");
+          case "\\":
+            return new TypstNode("control", "\\");
+          default:
+            throw new Error(`Unexpected control character ${controlChar}`);
+        }
       }
+      default:
+        throw new Error(`Unexpected token type ${this.type}`);
+    }
+  }
+  toString() {
+    switch (this.type) {
+      case 2 /* TEXT */:
+        return `"${this.value}"`;
+      case 3 /* COMMENT */:
+        return `//${this.value}`;
+      default:
+        return this.value;
     }
-    return found;
   }
 }
 
@@ -1095,17 +1261,25 @@ class TypstNode {
   setOptions(options) {
     this.options = options;
   }
-  eq_shallow(other) {
+  eq(other) {
     return this.type === other.type && this.content === other.content;
   }
 }
 
-// src/tex-parser.ts
+// src/util.ts
+function isalpha(char) {
+  return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
+}
+function isdigit(char) {
+  return "0123456789".includes(char);
+}
 function assert(condition, message = "") {
   if (!condition) {
-    throw new LatexParserError(message);
+    throw new Error(message);
   }
 }
+
+// src/tex-parser.ts
 function get_command_param_num(command) {
   if (UNARY_COMMANDS.includes(command)) {
     return 1;
@@ -1115,46 +1289,6 @@ function get_command_param_num(command) {
     return 0;
   }
 }
-function find_closing_curly_bracket(tokens, start) {
-  assert(tokens[start].eq(LEFT_CURLY_BRACKET));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      throw new LatexParserError("Unmatched curly brackets");
-    }
-    if (tokens[pos].eq(LEFT_CURLY_BRACKET)) {
-      count += 1;
-    } else if (tokens[pos].eq(RIGHT_CURLY_BRACKET)) {
-      count -= 1;
-    }
-    pos += 1;
-  }
-  return pos - 1;
-}
-function find_closing_square_bracket(tokens, start) {
-  assert(tokens[start].eq(LEFT_SQUARE_BRACKET));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      throw new LatexParserError("Unmatched square brackets");
-    }
-    if (tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
-      count += 1;
-    } else if (tokens[pos].eq(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 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
@@ -1186,37 +1320,28 @@ function eat_command_name(latex, start) {
   }
   return latex.substring(start, pos);
 }
-function find_closing_right_command(tokens, start) {
+function find_closing_match(tokens, start, leftToken, rightToken) {
+  assert(tokens[start].eq(leftToken));
   let count = 1;
-  let pos = start;
+  let pos = start + 1;
   while (count > 0) {
     if (pos >= tokens.length) {
       return -1;
     }
-    if (tokens[pos].eq(LEFT_COMMAND)) {
+    if (tokens[pos].eq(leftToken)) {
       count += 1;
-    } else if (tokens[pos].eq(RIGHT_COMMAND)) {
+    } else if (tokens[pos].eq(rightToken)) {
       count -= 1;
     }
     pos += 1;
   }
   return pos - 1;
 }
+function find_closing_right_command(tokens, start) {
+  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
+}
 function find_closing_end_command(tokens, start) {
-  let count = 1;
-  let pos = start;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      return -1;
-    }
-    if (tokens[pos].eq(BEGIN_COMMAND)) {
-      count += 1;
-    } else if (tokens[pos].eq(END_COMMAND)) {
-      count -= 1;
-    }
-    pos += 1;
-  }
-  return pos - 1;
+  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
 }
 function find_closing_curly_bracket_char(latex, start) {
   assert(latex[start] === "{");
@@ -1411,18 +1536,6 @@ var BINARY_COMMANDS = [
   "tbinom",
   "overset"
 ];
-
-class TexToken {
-  type;
-  value;
-  constructor(type, value) {
-    this.type = type;
-    this.value = value;
-  }
-  eq(token) {
-    return this.type === token.type && this.value === token.value;
-  }
-}
 var EMPTY_NODE = new TexNode("empty", "");
 var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
 var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
@@ -1565,7 +1678,7 @@ class LatexParser {
         const controlChar = firstToken.value;
         switch (controlChar) {
           case "{":
-            const posClosingBracket = find_closing_curly_bracket(tokens, start);
+            const posClosingBracket = find_closing_match(tokens, start, LEFT_CURLY_BRACKET, RIGHT_CURLY_BRACKET);
             const exprInside = tokens.slice(start + 1, posClosingBracket);
             return [this.parse(exprInside), posClosingBracket + 1];
           case "}":
@@ -1574,12 +1687,9 @@ class LatexParser {
             return [new TexNode("control", "\\\\"), start + 1];
           case "\\,":
             return [new TexNode("control", "\\,"), start + 1];
-          case "_": {
-            return [EMPTY_NODE, start];
-          }
-          case "^": {
+          case "_":
+          case "^":
             return [EMPTY_NODE, start];
-          }
           case "&":
             return [new TexNode("control", "&"), start + 1];
           default:
@@ -1606,7 +1716,7 @@ class LatexParser {
       case 1: {
         if (command === "\\sqrt" && pos < tokens.length && tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
           const posLeftSquareBracket = pos;
-          const posRightSquareBracket = find_closing_square_bracket(tokens, pos);
+          const posRightSquareBracket = find_closing_match(tokens, pos, LEFT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET);
           const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
           const exponent = this.parse(exprInside);
           const [arg12, newPos2] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
@@ -1646,7 +1756,7 @@ class LatexParser {
     }
     pos++;
     const exprInsideStart = pos;
-    const idx = find_closing_right_command(tokens, pos);
+    const idx = find_closing_right_command(tokens, start);
     if (idx === -1) {
       throw new LatexParserError("No matching \\right");
     }
@@ -1681,7 +1791,7 @@ class LatexParser {
     pos += 3;
     pos += eat_whitespaces(tokens, pos).length;
     const exprInsideStart = pos;
-    const endIdx = find_closing_end_command(tokens, pos);
+    const endIdx = find_closing_end_command(tokens, start);
     if (endIdx === -1) {
       throw new LatexParserError("No matching \\end");
     }
@@ -1743,7 +1853,7 @@ function is_delimiter(c) {
 function convert_overset(node) {
   const [sup, base] = node.args;
   const is_def = (n) => {
-    if (n.eq_shallow(new TexNode("text", "def"))) {
+    if (n.eq(new TexNode("text", "def"))) {
       return true;
     }
     if (n.type === "ordgroup" && n.args.length === 3) {
@@ -1751,17 +1861,17 @@ function convert_overset(node) {
       const d = new TexNode("element", "d");
       const e = new TexNode("element", "e");
       const f = new TexNode("element", "f");
-      if (a1.eq_shallow(d) && a2.eq_shallow(e) && a3.eq_shallow(f)) {
+      if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
         return true;
       }
     }
     return false;
   };
-  const is_eq = (n) => n.eq_shallow(new TexNode("element", "="));
+  const is_eq = (n) => n.eq(new TexNode("element", "="));
   if (is_def(sup) && is_eq(base)) {
     return new TypstNode("symbol", "eq.def");
   }
-  const op_call = new TypstNode("unaryFunc", "op", [convertTree(base)]);
+  const op_call = new TypstNode("funcCall", "op", [convertTree(base)]);
   op_call.setOptions({ limits: "#true" });
   return new TypstNode("supsub", "", [], {
     base: op_call,
@@ -1787,9 +1897,9 @@ function convertTree(node) {
     case "supsub": {
       let { base, sup, sub } = node.data;
       if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
-        return new TypstNode("binaryFunc", "overbrace", [convertTree(base.args[0]), convertTree(sup)]);
+        return new TypstNode("funcCall", "overbrace", [convertTree(base.args[0]), convertTree(sup)]);
       } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
-        return new TypstNode("binaryFunc", "underbrace", [convertTree(base.args[0]), convertTree(sub)]);
+        return new TypstNode("funcCall", "underbrace", [convertTree(base.args[0]), convertTree(sub)]);
       }
       const data = {
         base: convertTree(base)
@@ -1818,23 +1928,23 @@ function convertTree(node) {
       ].includes(left.content + right.content)) {
         return group;
       }
-      return new TypstNode("unaryFunc", "lr", [group]);
+      return new TypstNode("funcCall", "lr", [group]);
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
         return convert_overset(node);
       }
-      return new TypstNode("binaryFunc", convertToken(node.content), node.args.map(convertTree));
+      return new TypstNode("funcCall", convertToken(node.content), node.args.map(convertTree));
     }
     case "unaryFunc": {
       const arg0 = convertTree(node.args[0]);
       if (node.content === "\\sqrt" && node.data) {
         const data = convertTree(node.data);
-        return new TypstNode("binaryFunc", "root", [data, arg0]);
+        return new TypstNode("funcCall", "root", [data, arg0]);
       }
       if (node.content === "\\mathbf") {
-        const inner = new TypstNode("unaryFunc", "bold", [arg0]);
-        return new TypstNode("unaryFunc", "upright", [inner]);
+        const inner = new TypstNode("funcCall", "bold", [arg0]);
+        return new TypstNode("funcCall", "upright", [inner]);
       }
       if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
         return new TypstNode("symbol", arg0.content + arg0.content);
@@ -1848,10 +1958,10 @@ function convertTree(node) {
         if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
           return new TypstNode("symbol", text);
         } else {
-          return new TypstNode("unaryFunc", "op", [new TypstNode("text", text)]);
+          return new TypstNode("funcCall", "op", [new TypstNode("text", text)]);
         }
       }
-      return new TypstNode("unaryFunc", convertToken(node.content), node.args.map(convertTree));
+      return new TypstNode("funcCall", convertToken(node.content), node.args.map(convertTree));
     }
     case "beginend": {
       const matrix = node.data;
@@ -1910,9 +2020,9 @@ var TYPST_INTRINSIC_SYMBOLS = [
   "sech",
   "csch"
 ];
-var TYPST_LEFT_PARENTHESIS = new TypstToken(1 /* ATOM */, "(");
-var TYPST_RIGHT_PARENTHESIS = new TypstToken(1 /* ATOM */, ")");
-var TYPST_COMMA = new TypstToken(1 /* ATOM */, ",");
+var TYPST_LEFT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, "(");
+var TYPST_RIGHT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, ")");
+var TYPST_COMMA = new TypstToken(1 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(0 /* SYMBOL */, "\n");
 
 class TypstWriterError extends Error {
@@ -1937,19 +2047,21 @@ class TypstWriter {
     this.keepSpaces = keepSpaces;
   }
   writeBuffer(token) {
-    const str = token.content;
+    const str = token.toString();
     if (str === "") {
       return;
     }
     let no_need_space = false;
-    no_need_space ||= /[\(\|]$/.test(this.buffer) && /^\w/.test(str);
-    no_need_space ||= /^[}()_^,;!\|]$/.test(str);
+    no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
+    no_need_space ||= /^[})\]\|]$/.test(str);
+    no_need_space ||= /^[(_^,;!]$/.test(str);
     no_need_space ||= str === "'";
     no_need_space ||= /[0-9]$/.test(this.buffer) && /^[0-9]/.test(str);
     no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
     no_need_space ||= str.startsWith("\n");
     no_need_space ||= this.buffer === "";
     no_need_space ||= /^\s/.test(str);
+    no_need_space ||= this.buffer.endsWith("&") && str === "=";
     no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
     if (!no_need_space) {
       this.buffer += " ";
@@ -1964,7 +2076,7 @@ class TypstWriter {
         if (node.content === "," && this.insideFunctionDepth > 0) {
           this.queue.push(new TypstToken(0 /* SYMBOL */, "comma"));
         } else {
-          this.queue.push(new TypstToken(1 /* ATOM */, node.content));
+          this.queue.push(new TypstToken(1 /* ELEMENT */, node.content));
         }
         break;
       }
@@ -1972,10 +2084,10 @@ class TypstWriter {
         this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
         break;
       case "text":
-        this.queue.push(new TypstToken(2 /* TEXT */, `"${node.content}"`));
+        this.queue.push(new TypstToken(2 /* TEXT */, node.content));
         break;
       case "comment":
-        this.queue.push(new TypstToken(3 /* COMMENT */, `//${node.content}`));
+        this.queue.push(new TypstToken(3 /* COMMENT */, node.content));
         break;
       case "whitespace":
         for (const c of node.content) {
@@ -2001,15 +2113,15 @@ class TypstWriter {
         let trailing_space_needed = false;
         const has_prime = sup && sup.type === "atom" && sup.content === "\'";
         if (has_prime) {
-          this.queue.push(new TypstToken(1 /* ATOM */, "\'"));
+          this.queue.push(new TypstToken(1 /* ELEMENT */, "\'"));
           trailing_space_needed = false;
         }
         if (sub) {
-          this.queue.push(new TypstToken(1 /* ATOM */, "_"));
+          this.queue.push(new TypstToken(1 /* ELEMENT */, "_"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
         }
         if (sup && !has_prime) {
-          this.queue.push(new TypstToken(1 /* ATOM */, "^"));
+          this.queue.push(new TypstToken(1 /* ELEMENT */, "^"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
         }
         if (trailing_space_needed) {
@@ -2017,26 +2129,17 @@ class TypstWriter {
         }
         break;
       }
-      case "binaryFunc": {
+      case "funcCall": {
         const func_symbol = new TypstToken(0 /* SYMBOL */, node.content);
-        const [arg0, arg1] = node.args;
         this.queue.push(func_symbol);
         this.insideFunctionDepth++;
         this.queue.push(TYPST_LEFT_PARENTHESIS);
-        this.serialize(arg0);
-        this.queue.push(new TypstToken(1 /* ATOM */, ","));
-        this.serialize(arg1);
-        this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.insideFunctionDepth--;
-        break;
-      }
-      case "unaryFunc": {
-        const func_symbol = new TypstToken(0 /* SYMBOL */, node.content);
-        const arg0 = node.args[0];
-        this.queue.push(func_symbol);
-        this.insideFunctionDepth++;
-        this.queue.push(TYPST_LEFT_PARENTHESIS);
-        this.serialize(arg0);
+        for (let i = 0;i < node.args.length; i++) {
+          this.serialize(node.args[i]);
+          if (i < node.args.length - 1) {
+            this.queue.push(new TypstToken(1 /* ELEMENT */, ","));
+          }
+        }
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
             this.queue.push(new TypstToken(0 /* SYMBOL */, `, ${key}: ${value}`));
@@ -2051,7 +2154,7 @@ class TypstWriter {
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             if (j > 0) {
-              this.queue.push(new TypstToken(1 /* ATOM */, "&"));
+              this.queue.push(new TypstToken(1 /* ELEMENT */, "&"));
             }
             this.serialize(cell);
           });
@@ -2075,10 +2178,10 @@ class TypstWriter {
           row.forEach((cell, j) => {
             this.serialize(cell);
             if (j < row.length - 1) {
-              this.queue.push(new TypstToken(1 /* ATOM */, ","));
+              this.queue.push(new TypstToken(1 /* ELEMENT */, ","));
             } else {
               if (i < matrix.length - 1) {
-                this.queue.push(new TypstToken(1 /* ATOM */, ";"));
+                this.queue.push(new TypstToken(1 /* ELEMENT */, ";"));
               }
             }
           });
@@ -2123,9 +2226,9 @@ class TypstWriter {
       let token = this.queue[i];
       if (token.eq(SOFT_SPACE)) {
         if (i === this.queue.length - 1) {
-          this.queue[i].content = "";
+          this.queue[i].value = "";
         } else if (this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE])) {
-          this.queue[i].content = "";
+          this.queue[i].value = "";
         }
       }
     }
@@ -2159,6 +2262,663 @@ class TypstWriter {
   }
 }
 
+// src/typst-parser.ts
+function eat_primes2(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && tokens[pos].eq(new TypstToken(1 /* ELEMENT */, "'"))) {
+    pos += 1;
+  }
+  return pos - start;
+}
+function eat_identifier_name(typst, start) {
+  let pos = start;
+  while (pos < typst.length && (isalpha(typst[pos]) || typst[pos] === ".")) {
+    pos += 1;
+  }
+  return typst.substring(start, pos);
+}
+function tokenize_typst(typst) {
+  const tokens = [];
+  let pos = 0;
+  while (pos < typst.length) {
+    const firstChar = typst[pos];
+    let token;
+    switch (firstChar) {
+      case "_":
+      case "^":
+      case "&":
+        token = new TypstToken(6 /* CONTROL */, firstChar);
+        pos++;
+        break;
+      case "\n":
+        token = new TypstToken(7 /* NEWLINE */, firstChar);
+        pos++;
+        break;
+      case "\r": {
+        if (pos + 1 < typst.length && typst[pos + 1] === "\n") {
+          token = new TypstToken(7 /* NEWLINE */, "\n");
+          pos += 2;
+        } else {
+          token = new TypstToken(7 /* NEWLINE */, "\n");
+          pos++;
+        }
+        break;
+      }
+      case " ": {
+        let newPos = pos;
+        while (newPos < typst.length && typst[newPos] === " ") {
+          newPos++;
+        }
+        token = new TypstToken(4 /* SPACE */, typst.substring(pos, newPos));
+        pos = newPos;
+        break;
+      }
+      case "/": {
+        if (pos < typst.length && typst[pos + 1] === "/") {
+          let newPos = pos + 2;
+          while (newPos < typst.length && typst[newPos] !== "\n") {
+            newPos++;
+          }
+          token = new TypstToken(3 /* COMMENT */, typst.slice(pos + 2, newPos));
+          pos = newPos;
+        } else {
+          token = new TypstToken(1 /* ELEMENT */, "/");
+          pos++;
+        }
+        break;
+      }
+      case "\\": {
+        if (pos + 1 >= typst.length) {
+          throw new Error("Expecting a character after \\");
+        }
+        const firstTwoChars = typst.substring(pos, pos + 2);
+        if (["\\$", "\\&", "\\#", "\\_"].includes(firstTwoChars)) {
+          token = new TypstToken(1 /* ELEMENT */, firstTwoChars);
+          pos += 2;
+        } else if (firstTwoChars === "\\\n") {
+          token = new TypstToken(6 /* CONTROL */, "\\");
+          pos += 1;
+        } else {
+          token = new TypstToken(6 /* CONTROL */, "");
+          pos++;
+        }
+        break;
+      }
+      case '"': {
+        let newPos = pos + 1;
+        while (newPos < typst.length) {
+          if (typst[newPos] === '"' && typst[newPos - 1] !== "\\") {
+            break;
+          }
+          newPos++;
+        }
+        let text = typst.substring(pos + 1, newPos);
+        const chars = ['"', "\\"];
+        for (const char of chars) {
+          text = text.replaceAll("\\" + char, char);
+        }
+        token = new TypstToken(2 /* TEXT */, text);
+        pos = newPos + 1;
+        break;
+      }
+      default: {
+        if (isdigit(firstChar)) {
+          let newPos = pos;
+          while (newPos < typst.length && isdigit(typst[newPos])) {
+            newPos += 1;
+          }
+          token = new TypstToken(1 /* ELEMENT */, typst.slice(pos, newPos));
+        } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
+          token = new TypstToken(1 /* ELEMENT */, firstChar);
+        } else if (isalpha(firstChar)) {
+          const identifier = eat_identifier_name(typst, pos);
+          const _type = identifier.length === 1 ? 1 /* ELEMENT */ : 0 /* SYMBOL */;
+          token = new TypstToken(_type, identifier);
+        } else {
+          token = new TypstToken(1 /* ELEMENT */, firstChar);
+        }
+        pos += token.value.length;
+      }
+    }
+    tokens.push(token);
+  }
+  return tokens;
+}
+function find_closing_match2(tokens, start) {
+  assert(tokens[start].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2]));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      throw new Error("Unmatched brackets");
+    }
+    if (tokens[pos].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2])) {
+      count += 1;
+    } else if (tokens[pos].isOneOf([RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2])) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function find_closing_parenthesis(nodes, start) {
+  const left_parenthesis = new TypstNode("atom", "(");
+  const right_parenthesis = new TypstNode("atom", ")");
+  assert(nodes[start].eq(left_parenthesis));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= nodes.length) {
+      throw new Error("Unmatched brackets");
+    }
+    if (nodes[pos].eq(left_parenthesis)) {
+      count += 1;
+    } else if (nodes[pos].eq(right_parenthesis)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+function primes(num) {
+  const res = [];
+  for (let i = 0;i < num; i++) {
+    res.push(new TypstNode("atom", "'"));
+  }
+  return res;
+}
+function next_non_whitespace(nodes, start) {
+  let pos = start;
+  while (pos < nodes.length && nodes[pos].type === "whitespace") {
+    pos++;
+  }
+  return pos === nodes.length ? TYPST_EMPTY_NODE : nodes[pos];
+}
+function trim_whitespace_around_operators(nodes) {
+  let after_operator = false;
+  const res = [];
+  for (let i = 0;i < nodes.length; i++) {
+    const current = nodes[i];
+    if (current.type === "whitespace") {
+      if (after_operator) {
+        continue;
+      }
+      if (next_non_whitespace(nodes, i + 1).eq(DIV)) {
+        continue;
+      }
+    }
+    if (current.eq(DIV)) {
+      after_operator = true;
+    } else {
+      after_operator = false;
+    }
+    res.push(current);
+  }
+  return res;
+}
+function process_operators(nodes, parenthesis = false) {
+  nodes = trim_whitespace_around_operators(nodes);
+  const opening_bracket = new TypstNode("atom", "(");
+  const closing_bracket = new TypstNode("atom", ")");
+  const stack = [];
+  const args = [];
+  let pos = 0;
+  while (pos < nodes.length) {
+    const current = nodes[pos];
+    if (current.eq(closing_bracket)) {
+      throw new TypstParserError("Unexpected ')'");
+    } else if (current.eq(DIV)) {
+      stack.push(current);
+      pos++;
+    } else {
+      let current_tree;
+      if (current.eq(opening_bracket)) {
+        const pos_closing = find_closing_parenthesis(nodes, pos);
+        current_tree = process_operators(nodes.slice(pos + 1, pos_closing), true);
+        pos = pos_closing + 1;
+      } else {
+        current_tree = current;
+        pos++;
+      }
+      if (stack.length > 0 && stack[stack.length - 1].eq(DIV)) {
+        const denominator = current_tree;
+        if (args.length === 0) {
+          throw new TypstParserError("Unexpected '/' operator, no numerator before it");
+        }
+        const numerator = args.pop();
+        if (denominator.type === "group" && denominator.content === "parenthesis") {
+          denominator.content = "";
+        }
+        if (numerator.type === "group" && numerator.content === "parenthesis") {
+          numerator.content = "";
+        }
+        args.push(new TypstNode("fraction", "", [numerator, denominator]));
+        stack.pop();
+      } else {
+        args.push(current_tree);
+      }
+    }
+  }
+  if (parenthesis) {
+    return new TypstNode("group", "parenthesis", args);
+  } else {
+    if (args.length === 0) {
+      return TYPST_EMPTY_NODE;
+    } else if (args.length === 1) {
+      return args[0];
+    } else {
+      return new TypstNode("group", "", args);
+    }
+  }
+}
+function parseTypst(typst) {
+  const parser = new TypstParser;
+  let tokens = tokenize_typst(typst);
+  return parser.parse(tokens);
+}
+var TYPST_EMPTY_NODE = new TypstNode("empty", "");
+var DIV = new TypstNode("atom", "/");
+
+class TypstParserError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TypstParserError";
+  }
+}
+var SUB_SYMBOL2 = new TypstToken(6 /* CONTROL */, "_");
+var SUP_SYMBOL2 = new TypstToken(6 /* CONTROL */, "^");
+var LEFT_PARENTHESES = new TypstToken(1 /* ELEMENT */, "(");
+var RIGHT_PARENTHESES = new TypstToken(1 /* ELEMENT */, ")");
+var LEFT_BRACKET = new TypstToken(1 /* ELEMENT */, "[");
+var RIGHT_BRACKET = new TypstToken(1 /* ELEMENT */, "]");
+var LEFT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "{");
+var RIGHT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "}");
+var COMMA = new TypstToken(1 /* ELEMENT */, ",");
+var SEMICOLON = new TypstToken(1 /* ELEMENT */, ";");
+var SINGLE_SPACE = new TypstToken(4 /* SPACE */, " ");
+
+class TypstParser {
+  space_sensitive;
+  newline_sensitive;
+  constructor(space_sensitive = true, newline_sensitive = true) {
+    this.space_sensitive = space_sensitive;
+    this.newline_sensitive = newline_sensitive;
+  }
+  parse(tokens) {
+    const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
+    return tree;
+  }
+  parseGroup(tokens, start, end, parentheses = false) {
+    const results = [];
+    let pos = start;
+    while (pos < end) {
+      const [res, newPos] = this.parseNextExpr(tokens, pos);
+      pos = newPos;
+      if (res.type === "whitespace") {
+        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+          continue;
+        }
+        if (!this.newline_sensitive && res.content === "\n") {
+          continue;
+        }
+      }
+      results.push(res);
+    }
+    let node;
+    if (parentheses) {
+      node = process_operators(results, true);
+    } else {
+      if (results.length === 0) {
+        node = TYPST_EMPTY_NODE;
+      } else if (results.length === 1) {
+        node = results[0];
+      } else {
+        node = process_operators(results);
+      }
+    }
+    return [node, end + 1];
+  }
+  parseNextExpr(tokens, start) {
+    let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
+    let sub = null;
+    let sup = null;
+    const num_base_prime = eat_primes2(tokens, pos);
+    if (num_base_prime > 0) {
+      base = new TypstNode("group", "", [base].concat(primes(num_base_prime)));
+      pos += num_base_prime;
+    }
+    if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL2)) {
+      [sub, pos] = this.parseSupOrSub(tokens, pos + 1);
+      if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL2)) {
+        [sup, pos] = this.parseSupOrSub(tokens, pos + 1);
+      }
+    } else if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL2)) {
+      [sup, pos] = this.parseSupOrSub(tokens, pos + 1);
+      if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL2)) {
+        [sub, pos] = this.parseSupOrSub(tokens, pos + 1);
+      }
+    }
+    if (sub !== null || sup !== null) {
+      const res = { base };
+      if (sub) {
+        res.sub = sub;
+      }
+      if (sup) {
+        res.sup = sup;
+      }
+      return [new TypstNode("supsub", "", [], res), pos];
+    } else {
+      return [base, pos];
+    }
+  }
+  parseSupOrSub(tokens, start) {
+    let node;
+    let end;
+    if (tokens[start].eq(LEFT_PARENTHESES)) {
+      const pos_closing = find_closing_match2(tokens, start);
+      [node, end] = this.parseGroup(tokens, start + 1, pos_closing);
+    } else {
+      [node, end] = this.parseNextExprWithoutSupSub(tokens, start);
+    }
+    const num_prime = eat_primes2(tokens, end);
+    if (num_prime > 0) {
+      node = new TypstNode("group", "", [node].concat(primes(num_prime)));
+      end += num_prime;
+    }
+    return [node, end];
+  }
+  parseNextExprWithoutSupSub(tokens, start) {
+    const firstToken = tokens[start];
+    const node = firstToken.toNode();
+    if (firstToken.eq(LEFT_PARENTHESES)) {
+      const pos_closing = find_closing_match2(tokens, start);
+      return this.parseGroup(tokens, start + 1, pos_closing, true);
+    }
+    if (firstToken.type === 1 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
+      return [node, start + 1];
+    }
+    if ([1 /* ELEMENT */, 0 /* SYMBOL */].includes(firstToken.type)) {
+      if (start + 1 < tokens.length && tokens[start + 1].eq(LEFT_PARENTHESES)) {
+        if (firstToken.value === "mat") {
+          const [matrix, newPos2] = this.parseGroupsOfArguments(tokens, start + 1);
+          const mat = new TypstNode("matrix", "", [], matrix);
+          return [mat, newPos2];
+        }
+        const [args, newPos] = this.parseArguments(tokens, start + 1);
+        const func_call = new TypstNode("funcCall", firstToken.value);
+        func_call.args = args;
+        return [func_call, newPos];
+      }
+    }
+    return [node, start + 1];
+  }
+  parseArguments(tokens, start) {
+    const end = find_closing_match2(tokens, start);
+    return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
+  }
+  parseGroupsOfArguments(tokens, start) {
+    const end = find_closing_match2(tokens, start);
+    const matrix = [];
+    let pos = start + 1;
+    while (pos < end) {
+      while (pos < end) {
+        let next_stop = array_find(tokens, SEMICOLON, pos);
+        if (next_stop === -1) {
+          next_stop = end;
+        }
+        const row = this.parseCommaSeparatedArguments(tokens, pos, next_stop);
+        matrix.push(row);
+        pos = next_stop + 1;
+      }
+    }
+    return [matrix, end + 1];
+  }
+  parseCommaSeparatedArguments(tokens, start, end) {
+    const args = [];
+    let pos = start;
+    while (pos < end) {
+      let arg = new TypstNode("group", "", []);
+      while (pos < end) {
+        if (tokens[pos].eq(COMMA)) {
+          pos += 1;
+          break;
+        } else if (tokens[pos].eq(SINGLE_SPACE)) {
+          pos += 1;
+          continue;
+        }
+        const [argItem, newPos] = this.parseNextExpr(tokens, pos);
+        pos = newPos;
+        arg.args.push(argItem);
+      }
+      if (arg.args.length === 0) {
+        arg = TYPST_EMPTY_NODE;
+      } else if (arg.args.length === 1) {
+        arg = arg.args[0];
+      }
+      args.push(arg);
+    }
+    return args;
+  }
+}
+
+// src/tex-writer.ts
+function apply_escape_if_needed2(c) {
+  if (["{", "}", "%"].includes(c)) {
+    return "\\" + c;
+  }
+  return c;
+}
+function convert_typst_node_to_tex(node) {
+  if (node.eq(new TypstNode("symbol", "eq.def"))) {
+    return new TexNode("binaryFunc", "\\overset", [
+      new TexNode("text", "def"),
+      new TexNode("element", "=")
+    ]);
+  }
+  switch (node.type) {
+    case "empty":
+      return new TexNode("empty", "");
+    case "whitespace":
+      return new TexNode("whitespace", node.content);
+    case "atom":
+      if (node.content === ":") {
+        return new TexNode("symbol", "\\colon");
+      }
+      return new TexNode("element", node.content);
+    case "symbol":
+      if (node.content === "comma") {
+        return new TexNode("element", ",");
+      }
+      return new TexNode("symbol", typst_token_to_tex(node.content));
+    case "text":
+      return new TexNode("text", node.content);
+    case "comment":
+      return new TexNode("comment", node.content);
+    case "group": {
+      const args = node.args.map(convert_typst_node_to_tex);
+      if (node.content === "parenthesis") {
+        args.unshift(new TexNode("element", "("));
+        args.push(new TexNode("element", ")"));
+      }
+      return new TexNode("ordgroup", "", args);
+    }
+    case "funcCall": {
+      if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
+        if (node.content === "lr") {
+          const body = node.args[0];
+          if (body.type === "group") {
+            let left_delim = body.args[0].content;
+            let right_delim = body.args[body.args.length - 1].content;
+            left_delim = apply_escape_if_needed2(left_delim);
+            right_delim = apply_escape_if_needed2(right_delim);
+            return new TexNode("ordgroup", "", [
+              new TexNode("element", "\\left" + left_delim),
+              ...body.args.slice(1, body.args.length - 1).map(convert_typst_node_to_tex),
+              new TexNode("element", "\\right" + right_delim)
+            ]);
+          }
+        }
+        const command = typst_token_to_tex(node.content);
+        return new TexNode("unaryFunc", command, node.args.map(convert_typst_node_to_tex));
+      } else if (TYPST_BINARY_FUNCTIONS.includes(node.content)) {
+        if (node.content === "root") {
+          const [degree, radicand] = node.args;
+          const data = convert_typst_node_to_tex(degree);
+          return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
+        }
+        if (node.content === "overbrace" || node.content === "underbrace") {
+          const [body, label] = node.args;
+          const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
+          const script = convert_typst_node_to_tex(label);
+          const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
+          return new TexNode("supsub", "", [], data);
+        }
+        const command = typst_token_to_tex(node.content);
+        return new TexNode("binaryFunc", command, node.args.map(convert_typst_node_to_tex));
+      } else {
+        return new TexNode("ordgroup", "", [
+          new TexNode("symbol", typst_token_to_tex(node.content)),
+          new TexNode("element", "("),
+          ...node.args.map(convert_typst_node_to_tex),
+          new TexNode("element", ")")
+        ]);
+      }
+    }
+    case "supsub": {
+      const { base, sup, sub } = node.data;
+      const base_tex = convert_typst_node_to_tex(base);
+      let sup_tex;
+      let sub_tex;
+      if (sup) {
+        sup_tex = convert_typst_node_to_tex(sup);
+      }
+      if (sub) {
+        sub_tex = convert_typst_node_to_tex(sub);
+      }
+      const res = new TexNode("supsub", "", [], {
+        base: base_tex,
+        sup: sup_tex,
+        sub: sub_tex
+      });
+      return res;
+    }
+    case "matrix": {
+      const typst_data = node.data;
+      const tex_data = typst_data.map((row) => row.map(convert_typst_node_to_tex));
+      const matrix = new TexNode("beginend", "matrix", [], tex_data);
+      return new TexNode("ordgroup", "", [
+        new TexNode("element", "\\left("),
+        matrix,
+        new TexNode("element", "\\right)")
+      ]);
+    }
+    case "control": {
+      switch (node.content) {
+        case "\\":
+          return new TexNode("control", "\\\\");
+        case "&":
+          return new TexNode("control", "&");
+        default:
+          throw new Error("[convert_typst_node_to_tex] Unimplemented control: " + node.content);
+      }
+    }
+    case "fraction": {
+      const [numerator, denominator] = node.args;
+      const num_tex = convert_typst_node_to_tex(numerator);
+      const den_tex = convert_typst_node_to_tex(denominator);
+      return new TexNode("binaryFunc", "\\frac", [num_tex, den_tex]);
+    }
+    default:
+      throw new Error("[convert_typst_node_to_tex] Unimplemented type: " + node.type);
+  }
+}
+function typst_token_to_tex(token) {
+  if (/^[a-zA-Z0-9]$/.test(token)) {
+    return token;
+  } else if (token === "thin") {
+    return "\\,";
+  } else if (reverseSymbolMap.has(token)) {
+    return "\\" + reverseSymbolMap.get(token);
+  }
+  return "\\" + token;
+}
+var TYPST_UNARY_FUNCTIONS = [
+  "sqrt",
+  "bold",
+  "arrow",
+  "upright",
+  "lr",
+  "op",
+  "macron",
+  "dot",
+  "dot.double",
+  "hat",
+  "tilde",
+  "overline",
+  "underline",
+  "bb",
+  "cal",
+  "frak"
+];
+var TYPST_BINARY_FUNCTIONS = [
+  "frac",
+  "root",
+  "overbrace",
+  "underbrace"
+];
+
+class TexWriter {
+  buffer = "";
+  queue = [];
+  writeBuffer(token) {
+    const str = token.toString();
+    let no_need_space = false;
+    if (token.type === 4 /* SPACE */) {
+      no_need_space = true;
+    } else {
+      no_need_space ||= /[{\(\[\|]$/.test(this.buffer);
+      no_need_space ||= /\\\w+$/.test(this.buffer) && str === "[";
+      no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
+      no_need_space ||= ["\\{", "\\}"].includes(str);
+      no_need_space ||= str === "'";
+      no_need_space ||= this.buffer.endsWith("_") || this.buffer.endsWith("^");
+      no_need_space ||= /\s$/.test(this.buffer);
+      no_need_space ||= /^\s/.test(str);
+      no_need_space ||= this.buffer === "";
+      no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
+      no_need_space ||= this.buffer.endsWith("&") && str === "=";
+    }
+    if (!no_need_space) {
+      this.buffer += " ";
+    }
+    this.buffer += str;
+  }
+  append(node) {
+    const alignment_char = new TexNode("control", "&");
+    const newline_char = new TexNode("control", "\\\\");
+    if (node.type === "ordgroup" && array_includes(node.args, alignment_char)) {
+      const rows = array_split(node.args, newline_char);
+      const data = [];
+      for (const row of rows) {
+        const cells = array_split(row, alignment_char);
+        data.push(cells.map((cell) => new TexNode("ordgroup", "", cell)));
+      }
+      node = new TexNode("beginend", "aligned", [], data);
+    }
+    this.queue = this.queue.concat(node.serialize());
+  }
+  flushQueue() {
+    for (let i = 0;i < this.queue.length; i++) {
+      this.writeBuffer(this.queue[i]);
+    }
+    this.queue = [];
+  }
+  finalize() {
+    this.flushQueue();
+    return this.buffer;
+  }
+}
+
 // src/index.ts
 function tex2typst(tex, options) {
   const opt = {
@@ -2184,7 +2944,15 @@ function tex2typst(tex, options) {
   writer2.serialize(typstTree);
   return writer2.finalize();
 }
+function typst2tex(typst) {
+  const typstTree = parseTypst(typst);
+  const texTree = convert_typst_node_to_tex(typstTree);
+  const writer2 = new TexWriter;
+  writer2.append(texTree);
+  return writer2.finalize();
+}
 export {
+  typst2tex,
   tex2typst,
   symbolMap
 };