tex2typst 0.2.13 → 0.2.16

package/dist/index.js

@@ -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"],
@@ -1034,7 +1034,73 @@ for (const [key, value] of map_from_official_docs) {
   }
 }
 
-// src/parser.ts
+// src/types.ts
+class TexNode {
+  type;
+  content;
+  args;
+  data;
+  constructor(type, content, args, data) {
+    this.type = type;
+    this.content = content;
+    this.args = args;
+    this.data = data;
+  }
+  eq_shallow(other) {
+    return this.type === other.type && this.content === other.content;
+  }
+  toString() {
+    switch (this.type) {
+      case "text":
+        return `\\text{${this.content}}`;
+      default:
+        throw new Error(`toString() is not implemented for type ${this.type}`);
+    }
+  }
+}
+class TypstToken {
+  type;
+  content;
+  constructor(type, content) {
+    this.type = type;
+    this.content = content;
+  }
+  eq(other) {
+    return this.type === other.type && this.content === other.content;
+  }
+  isOneOf(tokens) {
+    let found = false;
+    for (const token of tokens) {
+      if (this.eq(token)) {
+        found = true;
+        break;
+      }
+    }
+    return found;
+  }
+}
+
+class TypstNode {
+  type;
+  content;
+  args;
+  data;
+  options;
+  constructor(type, content, args, data) {
+    this.type = type;
+    this.content = content;
+    this.args = args;
+    this.data = data;
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  eq_shallow(other) {
+    return this.type === other.type && this.content === other.content;
+  }
+}
+
+// src/tex-parser.ts
 function assert(condition, message = "") {
   if (!condition) {
     throw new LatexParserError(message);
@@ -1091,7 +1157,7 @@ function isdigit(char) {
 }
 function eat_whitespaces(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && [4 /* WHITESPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
+  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
     pos++;
   }
   return tokens.slice(start, pos);
@@ -1108,7 +1174,7 @@ function eat_parenthesis(tokens, start) {
 }
 function eat_primes(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new Token(0 /* ELEMENT */, "'"))) {
+  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
     pos += 1;
   }
   return pos - start;
@@ -1185,7 +1251,7 @@ function tokenize(latex) {
         while (newPos < latex.length && latex[newPos] !== "\n") {
           newPos += 1;
         }
-        token = new Token(3 /* COMMENT */, latex.slice(pos + 1, newPos));
+        token = new TexToken(3 /* COMMENT */, latex.slice(pos + 1, newPos));
         pos = newPos;
         break;
       }
@@ -1194,19 +1260,19 @@ function tokenize(latex) {
       case "_":
       case "^":
       case "&":
-        token = new Token(6 /* CONTROL */, firstChar);
+        token = new TexToken(6 /* CONTROL */, firstChar);
         pos++;
         break;
       case "\n":
-        token = new Token(5 /* NEWLINE */, firstChar);
+        token = new TexToken(5 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
         if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
-          token = new Token(5 /* NEWLINE */, "\n");
+          token = new TexToken(5 /* NEWLINE */, "\n");
           pos += 2;
         } else {
-          token = new Token(5 /* NEWLINE */, "\n");
+          token = new TexToken(5 /* NEWLINE */, "\n");
           pos++;
         }
         break;
@@ -1216,7 +1282,7 @@ function tokenize(latex) {
         while (newPos < latex.length && latex[newPos] === " ") {
           newPos += 1;
         }
-        token = new Token(4 /* WHITESPACE */, latex.slice(pos, newPos));
+        token = new TexToken(4 /* SPACE */, latex.slice(pos, newPos));
         pos = newPos;
         break;
       }
@@ -1226,12 +1292,12 @@ function tokenize(latex) {
         }
         const firstTwoChars = latex.slice(pos, pos + 2);
         if (["\\\\", "\\,"].includes(firstTwoChars)) {
-          token = new Token(6 /* CONTROL */, firstTwoChars);
+          token = new TexToken(6 /* CONTROL */, firstTwoChars);
         } else if (["\\{", "\\}", "\\%", "\\$", "\\&", "\\#", "\\_", "\\|"].includes(firstTwoChars)) {
-          token = new Token(0 /* ELEMENT */, firstTwoChars);
+          token = new TexToken(0 /* ELEMENT */, firstTwoChars);
         } else {
           const command = eat_command_name(latex, pos + 1);
-          token = new Token(1 /* COMMAND */, "\\" + command);
+          token = new TexToken(1 /* COMMAND */, "\\" + command);
         }
         pos += token.value.length;
         break;
@@ -1242,13 +1308,13 @@ function tokenize(latex) {
           while (newPos < latex.length && isdigit(latex[newPos])) {
             newPos += 1;
           }
-          token = new Token(0 /* ELEMENT */, latex.slice(pos, newPos));
+          token = new TexToken(0 /* ELEMENT */, latex.slice(pos, newPos));
         } else if (isalpha(firstChar)) {
-          token = new Token(0 /* ELEMENT */, firstChar);
+          token = new TexToken(0 /* ELEMENT */, firstChar);
         } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
-          token = new Token(0 /* ELEMENT */, firstChar);
+          token = new TexToken(0 /* ELEMENT */, firstChar);
         } else {
-          token = new Token(7 /* UNKNOWN */, firstChar);
+          token = new TexToken(7 /* UNKNOWN */, firstChar);
         }
         pos += token.value.length;
       }
@@ -1258,7 +1324,7 @@ function tokenize(latex) {
       if (pos >= latex.length || latex[pos] !== "{") {
         throw new LatexParserError(`No content for ${token.value} command`);
       }
-      tokens.push(new Token(6 /* CONTROL */, "{"));
+      tokens.push(new TexToken(6 /* CONTROL */, "{"));
       const posClosingBracket = find_closing_curly_bracket_char(latex, pos);
       pos++;
       let textInside = latex.slice(pos, posClosingBracket);
@@ -1266,8 +1332,8 @@ function tokenize(latex) {
       for (const char of chars) {
         textInside = textInside.replaceAll("\\" + char, char);
       }
-      tokens.push(new Token(2 /* TEXT */, textInside));
-      tokens.push(new Token(6 /* CONTROL */, "}"));
+      tokens.push(new TexToken(2 /* TEXT */, textInside));
+      tokens.push(new TexToken(6 /* CONTROL */, "}"));
       pos = posClosingBracket + 1;
     }
   }
@@ -1277,10 +1343,10 @@ function passIgnoreWhitespaceBeforeScriptMark(tokens) {
   const is_script_mark = (token) => token.eq(SUB_SYMBOL) || token.eq(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])) {
+    if (tokens[i].type === 4 /* SPACE */ && 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])) {
+    if (tokens[i].type === 4 /* SPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
       continue;
     }
     out_tokens.push(tokens[i]);
@@ -1346,7 +1412,7 @@ var BINARY_COMMANDS = [
   "overset"
 ];
 
-class Token {
+class TexToken {
   type;
   value;
   constructor(type, value) {
@@ -1357,15 +1423,15 @@ class Token {
     return this.type === token.type && this.value === token.value;
   }
 }
-var EMPTY_NODE = { type: "empty", content: "" };
-var LEFT_CURLY_BRACKET = new Token(6 /* CONTROL */, "{");
-var RIGHT_CURLY_BRACKET = new Token(6 /* CONTROL */, "}");
-var LEFT_SQUARE_BRACKET = new Token(0 /* ELEMENT */, "[");
-var RIGHT_SQUARE_BRACKET = new Token(0 /* ELEMENT */, "]");
-var LEFT_COMMAND = new Token(1 /* COMMAND */, "\\left");
-var RIGHT_COMMAND = new Token(1 /* COMMAND */, "\\right");
-var BEGIN_COMMAND = new Token(1 /* COMMAND */, "\\begin");
-var END_COMMAND = new Token(1 /* COMMAND */, "\\end");
+var EMPTY_NODE = new TexNode("empty", "");
+var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
+var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
+var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
+var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
+var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
+var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
+var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
+var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
 
 class LatexParserError extends Error {
   constructor(message) {
@@ -1373,8 +1439,8 @@ class LatexParserError extends Error {
     this.name = "LatexParserError";
   }
 }
-var SUB_SYMBOL = new Token(6 /* CONTROL */, "_");
-var SUP_SYMBOL = new Token(6 /* CONTROL */, "^");
+var SUB_SYMBOL = new TexToken(6 /* CONTROL */, "_");
+var SUP_SYMBOL = new TexToken(6 /* CONTROL */, "^");
 
 class LatexParser {
   space_sensitive;
@@ -1392,11 +1458,13 @@ class LatexParser {
       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 === "whitespace") {
+          if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+            continue;
+          }
+          if (!this.newline_sensitive && res.content === "\n") {
+            continue;
+          }
         }
         if (res.type === "control" && res.content === "&") {
           throw new LatexParserError("Unexpected & outside of an alignment");
@@ -1408,7 +1476,7 @@ class LatexParser {
       } else if (results2.length === 1) {
         return results2[0];
       } else {
-        return { type: "ordgroup", content: "", args: results2 };
+        return new TexNode("ordgroup", "", results2);
       }
     }
     if (results.length === 0) {
@@ -1416,7 +1484,7 @@ class LatexParser {
     } else if (results.length === 1) {
       return results[0];
     } else {
-      return { type: "ordgroup", content: "", args: results };
+      return new TexNode("ordgroup", "", results);
     }
   }
   parseNextExpr(tokens, start) {
@@ -1454,9 +1522,9 @@ class LatexParser {
         res.sub = sub;
       }
       if (num_prime > 0) {
-        res.sup = { type: "ordgroup", content: "", args: [] };
+        res.sup = new TexNode("ordgroup", "", []);
         for (let i = 0;i < num_prime; i++) {
-          res.sup.args.push({ type: "element", content: "'" });
+          res.sup.args.push(new TexNode("element", "'"));
         }
         if (sup) {
           res.sup.args.push(sup);
@@ -1467,7 +1535,7 @@ class LatexParser {
       } else if (sup) {
         res.sup = sup;
       }
-      return [{ type: "supsub", content: "", data: res }, pos];
+      return [new TexNode("supsub", "", [], res), pos];
     } else {
       return [base, pos];
     }
@@ -1477,15 +1545,14 @@ class LatexParser {
     const tokenType = firstToken.type;
     switch (tokenType) {
       case 0 /* ELEMENT */:
-        return [{ type: "element", content: firstToken.value }, start + 1];
+        return [new TexNode("element", firstToken.value), start + 1];
       case 2 /* TEXT */:
-        return [{ type: "text", content: firstToken.value }, start + 1];
+        return [new TexNode("text", 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];
+        return [new TexNode("comment", firstToken.value), start + 1];
+      case 4 /* SPACE */:
       case 5 /* NEWLINE */:
-        return [{ type: "newline", content: firstToken.value }, start + 1];
+        return [new TexNode("whitespace", firstToken.value), start + 1];
       case 1 /* COMMAND */:
         if (firstToken.eq(BEGIN_COMMAND)) {
           return this.parseBeginEndExpr(tokens, start);
@@ -1504,9 +1571,9 @@ class LatexParser {
           case "}":
             throw new LatexParserError("Unmatched '}'");
           case "\\\\":
-            return [{ type: "control", content: "\\\\" }, start + 1];
+            return [new TexNode("control", "\\\\"), start + 1];
           case "\\,":
-            return [{ type: "control", content: "\\," }, start + 1];
+            return [new TexNode("control", "\\,"), start + 1];
           case "_": {
             return [EMPTY_NODE, start];
           }
@@ -1514,7 +1581,7 @@ class LatexParser {
             return [EMPTY_NODE, start];
           }
           case "&":
-            return [{ type: "control", content: "&" }, start + 1];
+            return [new TexNode("control", "&"), start + 1];
           default:
             throw new LatexParserError("Unknown control sequence");
         }
@@ -1533,9 +1600,9 @@ class LatexParser {
     switch (paramNum) {
       case 0:
         if (!symbolMap.has(command.slice(1))) {
-          return [{ type: "unknownMacro", content: command }, pos];
+          return [new TexNode("unknownMacro", command), pos];
         }
-        return [{ type: "symbol", content: command }, pos];
+        return [new TexNode("symbol", command), pos];
       case 1: {
         if (command === "\\sqrt" && pos < tokens.length && tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
           const posLeftSquareBracket = pos;
@@ -1543,7 +1610,7 @@ class LatexParser {
           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];
+          return [new TexNode("unaryFunc", command, [arg12], exponent), newPos2];
         } else if (command === "\\text") {
           if (pos + 2 >= tokens.length) {
             throw new LatexParserError("Expecting content for \\text command");
@@ -1552,15 +1619,15 @@ class LatexParser {
           assert(tokens[pos + 1].type === 2 /* TEXT */);
           assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
           const text = tokens[pos + 1].value;
-          return [{ type: "text", content: text }, pos + 3];
+          return [new TexNode("text", text), pos + 3];
         }
         let [arg1, newPos] = this.parseNextExprWithoutSupSub(tokens, pos);
-        return [{ type: "unaryFunc", content: command, args: [arg1] }, newPos];
+        return [new TexNode("unaryFunc", command, [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];
+        return [new TexNode("binaryFunc", command, [arg1, arg2]), pos2];
       }
       default:
         throw new Error("Invalid number of parameters");
@@ -1597,11 +1664,11 @@ class LatexParser {
     const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
     const body = this.parse(exprInside);
     const args = [
-      { type: "element", content: leftDelimiter.value },
+      new TexNode("element", leftDelimiter.value),
       body,
-      { type: "element", content: rightDelimiter.value }
+      new TexNode("element", rightDelimiter.value)
     ];
-    const res = { type: "leftright", content: "", args };
+    const res = new TexNode("leftright", "", args);
     return [res, pos];
   }
   parseBeginEndExpr(tokens, start) {
@@ -1628,11 +1695,11 @@ class LatexParser {
     }
     pos += 3;
     const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-    while (exprInside.length > 0 && [4 /* WHITESPACE */, 5 /* NEWLINE */].includes(exprInside[exprInside.length - 1].type)) {
+    while (exprInside.length > 0 && [4 /* SPACE */, 5 /* NEWLINE */].includes(exprInside[exprInside.length - 1].type)) {
       exprInside.pop();
     }
     const body = this.parseAligned(exprInside);
-    const res = { type: "beginend", content: envName, data: body };
+    const res = new TexNode("beginend", envName, [], body);
     return [res, pos];
   }
   parseAligned(tokens) {
@@ -1640,22 +1707,26 @@ class LatexParser {
     const allRows = [];
     let row = [];
     allRows.push(row);
-    let group = { type: "ordgroup", content: "", args: [] };
+    let group = new TexNode("ordgroup", "", []);
     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 === "\\\\") {
+        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+          continue;
+        }
+        if (!this.newline_sensitive && res.content === "\n") {
+          continue;
+        }
+      }
+      if (res.type === "control" && res.content === "\\\\") {
         row = [];
-        group = { type: "ordgroup", content: "", args: [] };
+        group = new TexNode("ordgroup", "", []);
         row.push(group);
         allRows.push(row);
       } else if (res.type === "control" && res.content === "&") {
-        group = { type: "ordgroup", content: "", args: [] };
+        group = new TexNode("ordgroup", "", []);
         row.push(group);
       } else {
         group.args.push(res);
@@ -1669,87 +1740,62 @@ class LatexParser {
 function is_delimiter(c) {
   return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
 }
-function text_node_shallow_eq(a, b) {
-  return a.type === b.type && a.content === b.content;
-}
 function convert_overset(node) {
   const [sup, base] = node.args;
   const is_def = (n) => {
-    if (n.type === "text" && n.content === "def") {
+    if (n.eq_shallow(new TexNode("text", "def"))) {
       return true;
     }
     if (n.type === "ordgroup" && n.args.length === 3) {
       const [a1, a2, a3] = n.args;
-      const d = { type: "element", content: "d" };
-      const e = { type: "element", content: "e" };
-      const f = { type: "element", content: "f" };
-      if (text_node_shallow_eq(a1, d) && text_node_shallow_eq(a2, e) && text_node_shallow_eq(a3, f)) {
+      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)) {
         return true;
       }
     }
     return false;
   };
-  const is_eq = (n) => n.type === "element" && n.content === "=";
+  const is_eq = (n) => n.eq_shallow(new TexNode("element", "="));
   if (is_def(sup) && is_eq(base)) {
-    return {
-      type: "symbol",
-      content: "eq.def"
-    };
+    return new TypstNode("symbol", "eq.def");
   }
-  const op_call = {
-    type: "unaryFunc",
-    content: "op",
-    args: [convertTree(base)],
-    options: { limits: "#true" }
-  };
-  return {
-    type: "supsub",
-    content: "",
-    data: {
-      base: op_call,
-      sup: convertTree(sup)
-    }
-  };
+  const op_call = new TypstNode("unaryFunc", "op", [convertTree(base)]);
+  op_call.setOptions({ limits: "#true" });
+  return new TypstNode("supsub", "", [], {
+    base: op_call,
+    sup: convertTree(sup)
+  });
 }
 function convertTree(node) {
   switch (node.type) {
     case "empty":
+      return new TypstNode("empty", "");
     case "whitespace":
-      return { type: "empty", content: "" };
+      return new TypstNode("whitespace", node.content);
     case "ordgroup":
-      return {
-        type: "group",
-        content: "",
-        args: node.args.map(convertTree)
-      };
+      return new TypstNode("group", "", node.args.map(convertTree));
     case "element":
-      return { type: "atom", content: convertToken(node.content) };
+      return new TypstNode("atom", convertToken(node.content));
     case "symbol":
-      return { type: "symbol", content: convertToken(node.content) };
+      return new TypstNode("symbol", convertToken(node.content));
     case "text":
-      return { type: "text", content: node.content };
+      return new TypstNode("text", node.content);
     case "comment":
-      return { type: "comment", content: node.content };
+      return new TypstNode("comment", 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)]
-        };
+        return new TypstNode("binaryFunc", "overbrace", [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)]
-        };
+        return new TypstNode("binaryFunc", "underbrace", [convertTree(base.args[0]), convertTree(sub)]);
       }
       const data = {
         base: convertTree(base)
       };
       if (data.base.type === "empty") {
-        data.base = { type: "text", content: "" };
+        data.base = new TypstNode("text", "");
       }
       if (sup) {
         data.sup = convertTree(sup);
@@ -1757,19 +1803,11 @@ function convertTree(node) {
       if (sub) {
         data.sub = convertTree(sub);
       }
-      return {
-        type: "supsub",
-        content: "",
-        data
-      };
+      return new TypstNode("supsub", "", [], data);
     }
     case "leftright": {
       const [left, body, right] = node.args;
-      const group = {
-        type: "group",
-        content: "",
-        args: node.args.map(convertTree)
-      };
+      const group = new TypstNode("group", "", node.args.map(convertTree));
       if ([
         "[]",
         "()",
@@ -1780,49 +1818,26 @@ function convertTree(node) {
       ].includes(left.content + right.content)) {
         return group;
       }
-      return {
-        type: "unaryFunc",
-        content: "lr",
-        args: [group]
-      };
+      return new TypstNode("unaryFunc", "lr", [group]);
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
         return convert_overset(node);
       }
-      return {
-        type: "binaryFunc",
-        content: convertToken(node.content),
-        args: node.args.map(convertTree)
-      };
+      return new TypstNode("binaryFunc", 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 {
-          type: "binaryFunc",
-          content: "root",
-          args: [data, arg0]
-        };
+        return new TypstNode("binaryFunc", "root", [data, arg0]);
       }
       if (node.content === "\\mathbf") {
-        const inner = {
-          type: "unaryFunc",
-          content: "bold",
-          args: [arg0]
-        };
-        return {
-          type: "unaryFunc",
-          content: "upright",
-          args: [inner]
-        };
+        const inner = new TypstNode("unaryFunc", "bold", [arg0]);
+        return new TypstNode("unaryFunc", "upright", [inner]);
       }
       if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
-        return {
-          type: "symbol",
-          content: arg0.content + arg0.content
-        };
+        return new TypstNode("symbol", arg0.content + arg0.content);
       }
       if (node.content === "\\operatorname") {
         const body = node.args;
@@ -1831,50 +1846,31 @@ function convertTree(node) {
         }
         const text = body[0].content;
         if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
-          return {
-            type: "symbol",
-            content: text
-          };
+          return new TypstNode("symbol", text);
         } else {
-          return {
-            type: "unaryFunc",
-            content: "op",
-            args: [{ type: "text", content: text }]
-          };
+          return new TypstNode("unaryFunc", "op", [new TypstNode("text", text)]);
         }
       }
-      return {
-        type: "unaryFunc",
-        content: convertToken(node.content),
-        args: node.args.map(convertTree)
-      };
+      return new TypstNode("unaryFunc", convertToken(node.content), 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
-        };
+        return new TypstNode("align", "", [], data);
       } else {
-        return {
-          type: "matrix",
-          content: "mat",
-          data
-        };
+        const res = new TypstNode("matrix", "", [], data);
+        res.setOptions({ delim: "#none" });
+        return res;
       }
     }
     case "unknownMacro":
-      return { type: "unknown", content: convertToken(node.content) };
+      return new TypstNode("unknown", convertToken(node.content));
     case "control":
       if (node.content === "\\\\") {
-        return { type: "symbol", content: "\\" };
+        return new TypstNode("symbol", "\\");
       } else if (node.content === "\\,") {
-        return { type: "symbol", content: "thin" };
+        return new TypstNode("symbol", "thin");
       } else {
         throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
       }
@@ -1889,6 +1885,8 @@ function convertToken(token) {
     return "\\/";
   } else if (token === "\\|") {
     return "parallel";
+  } else if (token === "\\colon") {
+    return ":";
   } else if (token === "\\\\") {
     return "\\";
   } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
@@ -1912,6 +1910,10 @@ 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_NEWLINE = new TypstToken(0 /* SYMBOL */, "\n");
 
 class TypstWriterError extends Error {
   node;
@@ -1925,57 +1927,72 @@ class TypstWriterError extends Error {
 class TypstWriter {
   nonStrict;
   preferTypstIntrinsic;
+  keepSpaces;
   buffer = "";
   queue = [];
-  needSpaceAfterSingleItemScript = false;
   insideFunctionDepth = 0;
-  constructor(nonStrict, preferTypstIntrinsic) {
+  constructor(nonStrict, preferTypstIntrinsic, keepSpaces) {
     this.nonStrict = nonStrict;
     this.preferTypstIntrinsic = preferTypstIntrinsic;
+    this.keepSpaces = keepSpaces;
   }
-  writeBuffer(str) {
-    if (this.needSpaceAfterSingleItemScript && /^[0-9a-zA-Z\(]/.test(str)) {
-      this.buffer += " ";
-    } else {
-      let no_need_space = false;
-      no_need_space ||= /[\(\|]$/.test(this.buffer) && /^\w/.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(this.buffer);
-      if (!no_need_space) {
-        this.buffer += " ";
-      }
+  writeBuffer(token) {
+    const str = token.content;
+    if (str === "") {
+      return;
     }
-    if (this.needSpaceAfterSingleItemScript) {
-      this.needSpaceAfterSingleItemScript = false;
+    let no_need_space = false;
+    no_need_space ||= /[\(\|]$/.test(this.buffer) && /^\w/.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 ||= /[\s_^{\(]$/.test(this.buffer);
+    if (!no_need_space) {
+      this.buffer += " ";
     }
     this.buffer += str;
   }
-  append(node) {
+  serialize(node) {
     switch (node.type) {
       case "empty":
         break;
       case "atom": {
         if (node.content === "," && this.insideFunctionDepth > 0) {
-          this.queue.push({ type: "symbol", content: "comma" });
+          this.queue.push(new TypstToken(0 /* SYMBOL */, "comma"));
         } else {
-          this.queue.push({ type: "atom", content: node.content });
+          this.queue.push(new TypstToken(1 /* ATOM */, node.content));
         }
         break;
       }
       case "symbol":
+        this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
+        break;
       case "text":
+        this.queue.push(new TypstToken(2 /* TEXT */, `"${node.content}"`));
+        break;
       case "comment":
-      case "newline":
-        this.queue.push(node);
+        this.queue.push(new TypstToken(3 /* COMMENT */, `//${node.content}`));
+        break;
+      case "whitespace":
+        for (const c of node.content) {
+          if (c === " ") {
+            if (this.keepSpaces) {
+              this.queue.push(new TypstToken(4 /* SPACE */, c));
+            }
+          } else if (c === "\n") {
+            this.queue.push(new TypstToken(0 /* SYMBOL */, c));
+          } else {
+            throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
+          }
+        }
         break;
       case "group":
         for (const item of node.args) {
-          this.append(item);
+          this.serialize(item);
         }
         break;
       case "supsub": {
@@ -1984,48 +2001,48 @@ class TypstWriter {
         let trailing_space_needed = false;
         const has_prime = sup && sup.type === "atom" && sup.content === "\'";
         if (has_prime) {
-          this.queue.push({ type: "atom", content: "\'" });
+          this.queue.push(new TypstToken(1 /* ATOM */, "\'"));
           trailing_space_needed = false;
         }
         if (sub) {
-          this.queue.push({ type: "atom", content: "_" });
+          this.queue.push(new TypstToken(1 /* ATOM */, "_"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
         }
         if (sup && !has_prime) {
-          this.queue.push({ type: "atom", content: "^" });
+          this.queue.push(new TypstToken(1 /* ATOM */, "^"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
         }
         if (trailing_space_needed) {
-          this.queue.push({ type: "softSpace", content: "" });
+          this.queue.push(new TypstToken(6 /* CONTROL */, " "));
         }
         break;
       }
       case "binaryFunc": {
-        const func_symbol = { type: "symbol", content: node.content };
+        const func_symbol = new TypstToken(0 /* SYMBOL */, 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.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 = { type: "symbol", content: node.content };
+        const func_symbol = new TypstToken(0 /* SYMBOL */, 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(TYPST_LEFT_PARENTHESIS);
+        this.serialize(arg0);
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push({ type: "symbol", content: `, ${key}: ${value}` });
+            this.queue.push(new TypstToken(0 /* SYMBOL */, `, ${key}: ${value}`));
           }
         }
-        this.queue.push({ type: "atom", content: ")" });
+        this.queue.push(TYPST_RIGHT_PARENTHESIS);
         this.insideFunctionDepth--;
         break;
       }
@@ -2034,41 +2051,45 @@ class TypstWriter {
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             if (j > 0) {
-              this.queue.push({ type: "atom", content: "&" });
+              this.queue.push(new TypstToken(1 /* ATOM */, "&"));
             }
-            this.append(cell);
+            this.serialize(cell);
           });
           if (i < matrix.length - 1) {
-            this.queue.push({ type: "symbol", content: "\\" });
+            this.queue.push(new TypstToken(0 /* SYMBOL */, "\\"));
           }
         });
         break;
       }
       case "matrix": {
         const matrix = node.data;
-        this.queue.push({ type: "symbol", content: "mat" });
+        this.queue.push(new TypstToken(0 /* SYMBOL */, "mat"));
         this.insideFunctionDepth++;
-        this.queue.push({ type: "atom", content: "(" });
-        this.queue.push({ type: "symbol", content: "delim: #none, " });
+        this.queue.push(TYPST_LEFT_PARENTHESIS);
+        if (node.options) {
+          for (const [key, value] of Object.entries(node.options)) {
+            this.queue.push(new TypstToken(0 /* SYMBOL */, `${key}: ${value}, `));
+          }
+        }
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
-            this.append(cell);
+            this.serialize(cell);
             if (j < row.length - 1) {
-              this.queue.push({ type: "atom", content: "," });
+              this.queue.push(new TypstToken(1 /* ATOM */, ","));
             } else {
               if (i < matrix.length - 1) {
-                this.queue.push({ type: "atom", content: ";" });
+                this.queue.push(new TypstToken(1 /* ATOM */, ";"));
               }
             }
           });
         });
-        this.queue.push({ type: "atom", content: ")" });
+        this.queue.push(TYPST_RIGHT_PARENTHESIS);
         this.insideFunctionDepth--;
         break;
       }
       case "unknown": {
         if (this.nonStrict) {
-          this.queue.push({ type: "symbol", content: node.content });
+          this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
         } else {
           throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
         }
@@ -2088,41 +2109,28 @@ class TypstWriter {
       }
     }
     if (need_to_wrap) {
-      this.queue.push({ type: "atom", content: "(" });
-      this.append(node);
-      this.queue.push({ type: "atom", content: ")" });
+      this.queue.push(TYPST_LEFT_PARENTHESIS);
+      this.serialize(node);
+      this.queue.push(TYPST_RIGHT_PARENTHESIS);
     } else {
-      this.append(node);
+      this.serialize(node);
     }
     return !need_to_wrap;
   }
   flushQueue() {
-    this.queue.forEach((node) => {
-      let str = "";
-      switch (node.type) {
-        case "atom":
-        case "symbol":
-          str = node.content;
-          break;
-        case "text":
-          str = `"${node.content}"`;
-          break;
-        case "softSpace":
-          this.needSpaceAfterSingleItemScript = true;
-          str = "";
-          break;
-        case "comment":
-          str = `//${node.content}`;
-          break;
-        case "newline":
-          str = "\n";
-          break;
-        default:
-          throw new TypstWriterError(`Unexpected node type to stringify: ${node.type}`, node);
-      }
-      if (str !== "") {
-        this.writeBuffer(str);
+    const SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
+    for (let i = 0;i < this.queue.length; i++) {
+      let token = this.queue[i];
+      if (token.eq(SOFT_SPACE)) {
+        if (i === this.queue.length - 1) {
+          this.queue[i].content = "";
+        } else if (this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE])) {
+          this.queue[i].content = "";
+        }
       }
+    }
+    this.queue.forEach((token) => {
+      this.writeBuffer(token);
     });
     this.queue = [];
   }
@@ -2156,6 +2164,7 @@ function tex2typst(tex, options) {
   const opt = {
     nonStrict: true,
     preferTypstIntrinsic: true,
+    keepSpaces: false,
     customTexMacros: {}
   };
   if (options) {
@@ -2171,8 +2180,8 @@ function tex2typst(tex, options) {
   }
   const texTree = parseTex(tex, opt.customTexMacros);
   const typstTree = convertTree(texTree);
-  const writer2 = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic);
-  writer2.append(typstTree);
+  const writer2 = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
+  writer2.serialize(typstTree);
   return writer2.finalize();
 }
 export {