tex2typst 0.3.27-beta.1 → 0.3.28

package/dist/index.js

@@ -278,6 +278,9 @@ function array_split(array, sep) {
   res.push(current_slice);
   return res;
 }
+function array_join(arrays, sep) {
+  return arrays.flatMap((arr, i) => i !== arrays.length - 1 ? [...arr, sep] : arr);
+}
 function array_intersperse(array, sep) {
   return array.flatMap((x, i) => i !== array.length - 1 ? [x, sep] : [x]);
 }
@@ -563,7 +566,13 @@ var TEX_UNARY_COMMANDS = [
   "overleftarrow",
   "overrightarrow",
   "hspace",
-  "substack"
+  "substack",
+  "set",
+  "displaylines",
+  "mathinner",
+  "mathrel",
+  "mathbin",
+  "mathop"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -707,7 +716,7 @@ function eat_parenthesis(tokens, start) {
   const firstToken = tokens[start];
   if (firstToken.type === 1 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
     return firstToken;
-  } else if (firstToken.type === 2 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+  } else if (firstToken.type === 2 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle", "lparen", "rparen", "lbrace", "rbrace"].includes(firstToken.value.slice(1))) {
     return firstToken;
   } else {
     return null;
@@ -720,44 +729,32 @@ function eat_primes(tokens, start) {
   }
   return pos - start;
 }
-function find_closing_match(tokens, start, leftToken, rightToken) {
-  assert(tokens[start].eq(leftToken));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      return -1;
-    }
-    if (tokens[pos].eq(leftToken)) {
-      count += 1;
-    } else if (tokens[pos].eq(rightToken)) {
-      count -= 1;
-    }
-    pos += 1;
-  }
-  return pos - 1;
-}
 var LEFT_COMMAND = new TexToken(2 /* COMMAND */, "\\left");
 var RIGHT_COMMAND = new TexToken(2 /* COMMAND */, "\\right");
-function find_closing_right_command(tokens, start) {
-  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
-}
 var BEGIN_COMMAND = new TexToken(2 /* COMMAND */, "\\begin");
 var END_COMMAND = new TexToken(2 /* COMMAND */, "\\end");
-function find_closing_end_command(tokens, start) {
-  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
-}
-var LatexParserError = class extends Error {
+var CONTROL_LINEBREAK = new TexToken(7 /* CONTROL */, "\\\\");
+var LatexParserError = class _LatexParserError extends Error {
   constructor(message) {
     super(message);
     this.name = "LatexParserError";
   }
+  static UNMATCHED_LEFT_BRACE = new _LatexParserError("Unmatched '\\{'");
+  static UNMATCHED_RIGHT_BRACE = new _LatexParserError("Unmatched '\\}'");
+  static UNMATCHED_LEFT_BRACKET = new _LatexParserError("Unmatched '\\['");
+  static UNMATCHED_RIGHT_BRACKET = new _LatexParserError("Unmatched '\\]'");
+  static UNMATCHED_COMMAND_BEGIN = new _LatexParserError("Unmatched '\\begin'");
+  static UNMATCHED_COMMAND_END = new _LatexParserError("Unmatched '\\end'");
+  static UNMATCHED_COMMAND_LEFT = new _LatexParserError("Unmatched '\\left'");
+  static UNMATCHED_COMMAND_RIGHT = new _LatexParserError("Unmatched '\\right'");
 };
 var SUB_SYMBOL = new TexToken(7 /* CONTROL */, "_");
 var SUP_SYMBOL = new TexToken(7 /* CONTROL */, "^");
 var LatexParser = class {
   space_sensitive;
   newline_sensitive;
+  // how many levels of \begin{...} \end{...} are we currently in
+  alignmentDepth = 0;
   constructor(space_sensitive = false, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -766,22 +763,30 @@ var LatexParser = class {
     const token_displaystyle = new TexToken(2 /* COMMAND */, "\\displaystyle");
     const idx = array_find(tokens, token_displaystyle);
     if (idx === -1) {
-      const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
-      return tree;
+      return this.parseGroup(tokens.slice(0));
     } else if (idx === 0) {
-      const [tree, _] = this.parseGroup(tokens, 1, tokens.length);
+      const tree = this.parseGroup(tokens.slice(1));
       return new TexFuncCall(token_displaystyle, [tree]);
     } else {
-      const [tree1, _1] = this.parseGroup(tokens, 0, idx);
-      const [tree2, _2] = this.parseGroup(tokens, idx + 1, tokens.length);
+      const tree1 = this.parseGroup(tokens.slice(0, idx));
+      const tree2 = this.parseGroup(tokens.slice(idx + 1, tokens.length));
       const display = new TexFuncCall(token_displaystyle, [tree2]);
       return new TexGroup([tree1, display]);
     }
   }
-  parseGroup(tokens, start, end) {
+  parseGroup(tokens) {
+    const [tree, _] = this.parseClosure(tokens, 0, null);
+    return tree;
+  }
+  // return pos: (position of closingToken) + 1
+  // pos will be -1 if closingToken is not found
+  parseClosure(tokens, start, closingToken) {
     const results = [];
     let pos = start;
-    while (pos < end) {
+    while (pos < tokens.length) {
+      if (closingToken !== null && tokens[pos].eq(closingToken)) {
+        break;
+      }
       const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
       if (res.head.type === 5 /* SPACE */ || res.head.type === 6 /* NEWLINE */) {
@@ -792,18 +797,18 @@ var LatexParser = class {
           continue;
         }
       }
-      if (res.head.eq(new TexToken(7 /* CONTROL */, "&"))) {
-        throw new LatexParserError("Unexpected & outside of an alignment");
-      }
       results.push(res);
     }
+    if (pos >= tokens.length && closingToken !== null) {
+      return [EMPTY_NODE, -1];
+    }
     let node;
     if (results.length === 1) {
       node = results[0];
     } else {
       node = new TexGroup(results);
     }
-    return [node, end + 1];
+    return [node, pos + 1];
   }
   parseNextExpr(tokens, start) {
     let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
@@ -812,25 +817,28 @@ var LatexParser = class {
     let num_prime = 0;
     num_prime += eat_primes(tokens, pos);
     pos += num_prime;
-    if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL)) {
-      [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
-      num_prime += eat_primes(tokens, pos);
-      pos += num_prime;
-      if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL)) {
+    if (pos < tokens.length) {
+      const next_token = tokens[pos];
+      if (next_token.eq(SUB_SYMBOL)) {
+        [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+        num_prime += eat_primes(tokens, pos);
+        pos += num_prime;
+        if (pos < tokens.length && tokens[pos].eq(SUP_SYMBOL)) {
+          [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+          if (eat_primes(tokens, pos) > 0) {
+            throw new LatexParserError("Double superscript");
+          }
+        }
+      } else if (next_token.eq(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 && tokens[pos].eq(SUP_SYMBOL)) {
-      [sup, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
-      if (eat_primes(tokens, pos) > 0) {
-        throw new LatexParserError("Double superscript");
-      }
-      if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL)) {
-        [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
-        if (eat_primes(tokens, pos) > 0) {
-          throw new LatexParserError("Double superscript");
+        if (pos < tokens.length && tokens[pos].eq(SUB_SYMBOL)) {
+          [sub, pos] = this.parseNextExprWithoutSupSub(tokens, pos + 1);
+          if (eat_primes(tokens, pos) > 0) {
+            throw new LatexParserError("Double superscript");
+          }
         }
       }
     }
@@ -858,7 +866,7 @@ var LatexParser = class {
   }
   parseNextExprWithoutSupSub(tokens, start) {
     if (start >= tokens.length) {
-      return [EMPTY_NODE, start];
+      throw new LatexParserError("Unexpected end of input");
     }
     const firstToken = tokens[start];
     switch (firstToken.type) {
@@ -875,8 +883,12 @@ var LatexParser = class {
         }
         if (firstToken.eq(BEGIN_COMMAND)) {
           return this.parseBeginEndExpr(tokens, start);
+        } else if (firstToken.eq(END_COMMAND)) {
+          throw LatexParserError.UNMATCHED_COMMAND_END;
         } else if (firstToken.eq(LEFT_COMMAND)) {
           return this.parseLeftRightExpr(tokens, start);
+        } else if (firstToken.eq(RIGHT_COMMAND)) {
+          throw LatexParserError.UNMATCHED_COMMAND_RIGHT;
         } else {
           return this.parseCommandExpr(tokens, start);
         }
@@ -884,13 +896,13 @@ var LatexParser = class {
         const controlChar = firstToken.value;
         switch (controlChar) {
           case "{":
-            const posClosingBracket = find_closing_match(tokens, start, LEFT_CURLY_BRACKET, RIGHT_CURLY_BRACKET);
-            if (posClosingBracket === -1) {
-              throw new LatexParserError("Unmatched '{'");
+            const [group, newPos] = this.parseClosure(tokens, start + 1, RIGHT_CURLY_BRACKET);
+            if (newPos === -1) {
+              throw LatexParserError.UNMATCHED_LEFT_BRACE;
             }
-            return this.parseGroup(tokens, start + 1, posClosingBracket);
+            return [group, newPos];
           case "}":
-            throw new LatexParserError("Unmatched '}'");
+            throw LatexParserError.UNMATCHED_RIGHT_BRACE;
           case "\\\\":
           case "\\!":
           case "\\,":
@@ -903,6 +915,9 @@ var LatexParser = class {
           case "^":
             return [EMPTY_NODE, start];
           case "&":
+            if (this.alignmentDepth <= 0) {
+              throw new LatexParserError("Unexpected & outside of an alignment");
+            }
             return [firstToken.toNode(), start + 1];
           default:
             throw new LatexParserError("Unknown control sequence");
@@ -916,9 +931,6 @@ var LatexParser = class {
     const command_token = tokens[start];
     const command = command_token.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:
@@ -928,13 +940,11 @@ var LatexParser = class {
           throw new LatexParserError("Expecting argument for " + command);
         }
         if (command === "\\sqrt" && pos < tokens.length && tokens[pos].eq(LEFT_SQUARE_BRACKET)) {
-          const posLeftSquareBracket = pos;
-          const posRightSquareBracket = find_closing_match(tokens, pos, LEFT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET);
-          if (posRightSquareBracket === -1) {
-            throw new LatexParserError("No matching right square bracket for [");
+          const [exponent, newPos1] = this.parseClosure(tokens, pos + 1, RIGHT_SQUARE_BRACKET);
+          if (newPos1 === -1) {
+            throw LatexParserError.UNMATCHED_LEFT_BRACKET;
           }
-          const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
-          const [arg12, newPos2] = this.parseNextArg(tokens, posRightSquareBracket + 1);
+          const [arg12, newPos2] = this.parseNextArg(tokens, newPos1);
           return [new TexFuncCall(command_token, [arg12], exponent), newPos2];
         } else if (command === "\\text") {
           if (pos + 2 >= tokens.length) {
@@ -945,6 +955,14 @@ var LatexParser = class {
           assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
           const literal = tokens[pos + 1];
           return [new TexText(literal), pos + 3];
+        } else if (command === "\\displaylines") {
+          assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
+          const [matrix, newPos2] = this.parseAligned(tokens, pos + 1, RIGHT_CURLY_BRACKET);
+          if (newPos2 === -1) {
+            throw LatexParserError.UNMATCHED_LEFT_BRACE;
+          }
+          const group = new TexGroup(array_join(matrix, CONTROL_LINEBREAK.toNode()));
+          return [new TexFuncCall(command_token, [group]), newPos2];
         }
         let [arg1, newPos] = this.parseNextArg(tokens, pos);
         return [new TexFuncCall(command_token, [arg1]), newPos];
@@ -986,30 +1004,27 @@ var LatexParser = class {
     let pos = start + 1;
     pos += eat_whitespaces(tokens, pos).length;
     if (pos >= tokens.length) {
-      throw new LatexParserError("Expecting delimiter after \\left");
+      throw new LatexParserError("Expecting a 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, start);
+    const [body, idx] = this.parseClosure(tokens, pos, RIGHT_COMMAND);
     if (idx === -1) {
-      throw new LatexParserError("No matching \\right");
+      throw LatexParserError.UNMATCHED_COMMAND_LEFT;
     }
-    const exprInsideEnd = idx;
-    pos = idx + 1;
+    pos = idx;
     pos += eat_whitespaces(tokens, pos).length;
     if (pos >= tokens.length) {
-      throw new LatexParserError("Expecting \\right after \\left");
+      throw new LatexParserError("Expecting a delimiter after \\right");
     }
     const rightDelimiter = eat_parenthesis(tokens, pos);
     if (rightDelimiter === null) {
       throw new LatexParserError("Invalid delimiter after \\right");
     }
     pos++;
-    const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
     const left = leftDelimiter.value === "." ? null : leftDelimiter;
     const right = rightDelimiter.value === "." ? null : rightDelimiter;
     const res = new TexLeftRight({ body, left, right });
@@ -1028,37 +1043,36 @@ var LatexParser = class {
       pos += eat_whitespaces(tokens, pos).length;
       [data, pos] = this.parseNextArg(tokens, pos);
     }
-    pos += eat_whitespaces(tokens, pos).length;
-    const exprInsideStart = pos;
-    const endIdx = find_closing_end_command(tokens, start);
+    const [body, endIdx] = this.parseAligned(tokens, pos, END_COMMAND);
     if (endIdx === -1) {
-      throw new LatexParserError("No matching \\end");
+      throw LatexParserError.UNMATCHED_COMMAND_BEGIN;
     }
-    const exprInsideEnd = endIdx;
-    pos = endIdx + 1;
+    pos = endIdx;
     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
     assert(tokens[pos + 1].type === 3 /* LITERAL */);
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     if (tokens[pos + 1].value !== envName) {
-      throw new LatexParserError("Mismatched \\begin and \\end environments");
+      throw new LatexParserError("\\begin and \\end environments mismatch");
     }
     pos += 3;
-    const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-    while (exprInside.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(exprInside[exprInside.length - 1].type)) {
-      exprInside.pop();
-    }
-    const body = this.parseAligned(exprInside);
     const res = new TexBeginEnd(new TexToken(3 /* LITERAL */, envName), body, data);
     return [res, pos];
   }
-  parseAligned(tokens) {
-    let pos = 0;
+  // return pos: (position of closingToken) + 1
+  // pos will be -1 if closingToken is not found
+  parseAligned(tokens, start, closingToken) {
+    this.alignmentDepth++;
+    let pos = start;
+    pos += eat_whitespaces(tokens, pos).length;
     const allRows = [];
     let row = [];
     allRows.push(row);
     let group = new TexGroup([]);
     row.push(group);
     while (pos < tokens.length) {
+      if (tokens[pos].eq(closingToken)) {
+        break;
+      }
       const [res, newPos] = this.parseNextExpr(tokens, pos);
       pos = newPos;
       if (res.head.type === 5 /* SPACE */ || res.head.type === 6 /* NEWLINE */) {
@@ -1081,7 +1095,20 @@ var LatexParser = class {
         group.items.push(res);
       }
     }
-    return allRows;
+    if (pos >= tokens.length) {
+      return [[], -1];
+    }
+    if (allRows.length > 0 && allRows[allRows.length - 1].length > 0) {
+      const last_cell = allRows[allRows.length - 1][allRows[allRows.length - 1].length - 1];
+      if (last_cell.type === "ordgroup") {
+        const last_cell_items = last_cell.items;
+        while (last_cell_items.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(last_cell_items[last_cell_items.length - 1].head.type)) {
+          last_cell_items.pop();
+        }
+      }
+    }
+    this.alignmentDepth--;
+    return [allRows, pos + 1];
   }
 };
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
@@ -1110,7 +1137,7 @@ function passExpandCustomTexMacros(tokens, customTexMacros) {
   }
   return out_tokens;
 }
-function parseTex(tex, customTexMacros) {
+function parseTex(tex, customTexMacros = {}) {
   const parser = new LatexParser();
   let tokens = tokenize_tex(tex);
   tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
@@ -1118,6 +1145,54 @@ function parseTex(tex, customTexMacros) {
   return parser.parse(tokens);
 }
 
+// src/typst-shorthands.ts
+var shorthandMap = /* @__PURE__ */ new Map([
+  ["arrow.l.r.double.long", "<==>"],
+  ["arrow.l.r.long", "<-->"],
+  ["arrow.r.bar", "|->"],
+  ["arrow.r.double.bar", "|=>"],
+  ["arrow.r.double.long", "==>"],
+  ["arrow.r.long", "-->"],
+  ["arrow.r.long.squiggly", "~~>"],
+  ["arrow.r.tail", ">->"],
+  ["arrow.r.twohead", "->>"],
+  ["arrow.l.double.long", "<=="],
+  ["arrow.l.long", "<--"],
+  ["arrow.l.long.squiggly", "<~~"],
+  ["arrow.l.tail", "<-<"],
+  ["arrow.l.twohead", "<<-"],
+  ["arrow.l.r", "<->"],
+  ["arrow.l.r.double", "<=>"],
+  ["colon.double.eq", "::="],
+  ["dots.h", "..."],
+  ["gt.triple", ">>>"],
+  ["lt.triple", "<<<"],
+  ["arrow.r", "->"],
+  ["arrow.r.double", "=>"],
+  ["arrow.r.squiggly", "~>"],
+  ["arrow.l", "<-"],
+  ["arrow.l.squiggly", "<~"],
+  ["bar.v.double", "||"],
+  ["bracket.l.double", "[|"],
+  ["bracket.r.double", "|]"],
+  ["colon.eq", ":="],
+  ["eq.colon", "=:"],
+  ["eq.not", "!="],
+  ["gt.double", ">>"],
+  ["gt.eq", ">="],
+  ["lt.double", "<<"],
+  ["lt.eq", "<="],
+  ["ast.op", "*"],
+  ["minus", "-"],
+  ["tilde.op", "~"]
+]);
+var reverseShorthandMap = /* @__PURE__ */ new Map();
+for (const [key, value] of shorthandMap.entries()) {
+  if (value.length > 1) {
+    reverseShorthandMap.set(value, key);
+  }
+}
+
 // src/typst-types.ts
 var TypstToken = class _TypstToken {
   type;
@@ -1147,7 +1222,32 @@ var TypstToken = class _TypstToken {
   }
   static NONE = new _TypstToken(0 /* NONE */, "#none");
   static EMPTY = new _TypstToken(2 /* ELEMENT */, "");
+  static LEFT_BRACE = new _TypstToken(2 /* ELEMENT */, "{");
+  static RIGHT_BRACE = new _TypstToken(2 /* ELEMENT */, "}");
+  static LEFT_DELIMITERS = [
+    new _TypstToken(2 /* ELEMENT */, "("),
+    new _TypstToken(2 /* ELEMENT */, "["),
+    new _TypstToken(2 /* ELEMENT */, "{"),
+    new _TypstToken(2 /* ELEMENT */, "|"),
+    new _TypstToken(1 /* SYMBOL */, "angle.l")
+  ];
+  static RIGHT_DELIMITERS = [
+    new _TypstToken(2 /* ELEMENT */, ")"),
+    new _TypstToken(2 /* ELEMENT */, "]"),
+    new _TypstToken(2 /* ELEMENT */, "}"),
+    new _TypstToken(2 /* ELEMENT */, "|"),
+    new _TypstToken(1 /* SYMBOL */, "angle.r")
+  ];
 };
+var TypstWriterError = class extends Error {
+  node;
+  constructor(message, node) {
+    super(message);
+    this.name = "TypstWriterError";
+    this.node = node;
+  }
+};
+var SOFT_SPACE = new TypstToken(7 /* CONTROL */, " ");
 var TypstNode = class {
   type;
   head;
@@ -1178,6 +1278,39 @@ var TypstTerminal = class extends TypstNode {
   toString() {
     return this.head.toString();
   }
+  serialize(env, options) {
+    if (this.head.type === 2 /* ELEMENT */) {
+      if (this.head.value === "," && env.insideFunctionDepth > 0) {
+        return [new TypstToken(1 /* SYMBOL */, "comma")];
+      }
+    } else if (this.head.type === 1 /* SYMBOL */) {
+      let symbol_name = this.head.value;
+      if (options.preferShorthands) {
+        if (shorthandMap.has(symbol_name)) {
+          symbol_name = shorthandMap.get(symbol_name);
+        }
+      }
+      if (options.inftyToOo && symbol_name === "infinity") {
+        symbol_name = "oo";
+      }
+      return [new TypstToken(1 /* SYMBOL */, symbol_name)];
+    } else if (this.head.type === 6 /* SPACE */ || this.head.type === 8 /* NEWLINE */) {
+      const queue = [];
+      for (const c of this.head.value) {
+        if (c === " ") {
+          if (options.keepSpaces) {
+            queue.push(new TypstToken(6 /* SPACE */, c));
+          }
+        } else if (c === "\n") {
+          queue.push(new TypstToken(1 /* SYMBOL */, c));
+        } else {
+          throw new TypstWriterError(`Unexpected whitespace character: ${c}`, this);
+        }
+      }
+      return queue;
+    }
+    return [this.head];
+  }
 };
 var TypstGroup = class extends TypstNode {
   items;
@@ -1188,6 +1321,16 @@ var TypstGroup = class extends TypstNode {
   isOverHigh() {
     return this.items.some((n) => n.isOverHigh());
   }
+  serialize(env, options) {
+    const queue = this.items.flatMap((n) => n.serialize(env, options));
+    if (queue.length > 0 && queue[0].eq(SOFT_SPACE)) {
+      queue.shift();
+    }
+    if (queue.length > 0 && queue[queue.length - 1].eq(SOFT_SPACE)) {
+      queue.pop();
+    }
+    return queue;
+  }
 };
 var TypstSupsub = class extends TypstNode {
   base;
@@ -1202,6 +1345,25 @@ var TypstSupsub = class extends TypstNode {
   isOverHigh() {
     return this.base.isOverHigh();
   }
+  serialize(env, options) {
+    const queue = [];
+    let { base, sup, sub } = this;
+    queue.push(...base.serialize(env, options));
+    const has_prime = sup && sup.head.eq(new TypstToken(2 /* ELEMENT */, "'"));
+    if (has_prime) {
+      queue.push(new TypstToken(2 /* ELEMENT */, "'"));
+    }
+    if (sub) {
+      queue.push(new TypstToken(2 /* ELEMENT */, "_"));
+      queue.push(...sub.serialize(env, options));
+    }
+    if (sup && !has_prime) {
+      queue.push(new TypstToken(2 /* ELEMENT */, "^"));
+      queue.push(...sup.serialize(env, options));
+    }
+    queue.push(SOFT_SPACE);
+    return queue;
+  }
 };
 var TypstFuncCall = class extends TypstNode {
   args;
@@ -1215,6 +1377,27 @@ var TypstFuncCall = class extends TypstNode {
     }
     return this.args.some((n) => n.isOverHigh());
   }
+  serialize(env, options) {
+    const queue = [];
+    const func_symbol = this.head;
+    queue.push(func_symbol);
+    env.insideFunctionDepth++;
+    queue.push(TYPST_LEFT_PARENTHESIS);
+    for (let i = 0; i < this.args.length; i++) {
+      queue.push(...this.args[i].serialize(env, options));
+      if (i < this.args.length - 1) {
+        queue.push(new TypstToken(2 /* ELEMENT */, ","));
+      }
+    }
+    if (this.options) {
+      for (const [key, value] of Object.entries(this.options)) {
+        queue.push(new TypstToken(3 /* LITERAL */, `, ${key}: ${value.toString()}`));
+      }
+    }
+    queue.push(TYPST_RIGHT_PARENTHESIS);
+    env.insideFunctionDepth--;
+    return queue;
+  }
 };
 var TypstFraction = class extends TypstNode {
   args;
@@ -1225,7 +1408,19 @@ var TypstFraction = class extends TypstNode {
   isOverHigh() {
     return true;
   }
+  serialize(env, options) {
+    const queue = [];
+    const [numerator, denominator] = this.args;
+    queue.push(SOFT_SPACE);
+    queue.push(...numerator.serialize(env, options));
+    queue.push(new TypstToken(2 /* ELEMENT */, "/"));
+    queue.push(...denominator.serialize(env, options));
+    queue.push(SOFT_SPACE);
+    return queue;
+  }
 };
+var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
+var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
 var TypstLeftright = class extends TypstNode {
   body;
   left;
@@ -1240,8 +1435,28 @@ var TypstLeftright = class extends TypstNode {
   isOverHigh() {
     return this.body.isOverHigh();
   }
+  serialize(env, options) {
+    const queue = [];
+    const LR = new TypstToken(1 /* SYMBOL */, "lr");
+    const { left, right } = this;
+    if (this.head.eq(LR)) {
+      queue.push(LR);
+      queue.push(TYPST_LEFT_PARENTHESIS);
+    }
+    if (left) {
+      queue.push(left);
+    }
+    queue.push(...this.body.serialize(env, options));
+    if (right) {
+      queue.push(right);
+    }
+    if (this.head.eq(LR)) {
+      queue.push(TYPST_RIGHT_PARENTHESIS);
+    }
+    return queue;
+  }
 };
-var TypstMatrixLike = class extends TypstNode {
+var TypstMatrixLike = class _TypstMatrixLike extends TypstNode {
   matrix;
   // head is 'mat', 'cases' or null
   constructor(head, data) {
@@ -1251,6 +1466,48 @@ var TypstMatrixLike = class extends TypstNode {
   isOverHigh() {
     return true;
   }
+  serialize(env, options) {
+    const queue = [];
+    let cell_sep;
+    let row_sep;
+    if (this.head.eq(_TypstMatrixLike.MAT)) {
+      cell_sep = new TypstToken(2 /* ELEMENT */, ",");
+      row_sep = new TypstToken(2 /* ELEMENT */, ";");
+    } else if (this.head.eq(_TypstMatrixLike.CASES)) {
+      cell_sep = new TypstToken(2 /* ELEMENT */, "&");
+      row_sep = new TypstToken(2 /* ELEMENT */, ",");
+    } else if (this.head.eq(TypstToken.NONE)) {
+      cell_sep = new TypstToken(2 /* ELEMENT */, "&");
+      row_sep = new TypstToken(1 /* SYMBOL */, "\\");
+    }
+    if (!this.head.eq(TypstToken.NONE)) {
+      queue.push(this.head);
+      env.insideFunctionDepth++;
+      queue.push(TYPST_LEFT_PARENTHESIS);
+      if (this.options) {
+        for (const [key, value] of Object.entries(this.options)) {
+          queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
+        }
+      }
+    }
+    this.matrix.forEach((row, i) => {
+      row.forEach((cell, j) => {
+        queue.push(...cell.serialize(env, options));
+        if (j < row.length - 1) {
+          queue.push(cell_sep);
+        } else {
+          if (i < this.matrix.length - 1) {
+            queue.push(row_sep);
+          }
+        }
+      });
+    });
+    if (!this.head.eq(TypstToken.NONE)) {
+      queue.push(TYPST_RIGHT_PARENTHESIS);
+      env.insideFunctionDepth--;
+    }
+    return queue;
+  }
   static MAT = new TypstToken(1 /* SYMBOL */, "mat");
   static CASES = new TypstToken(1 /* SYMBOL */, "cases");
 };
@@ -1270,88 +1527,45 @@ var TypstMarkupFunc = class extends TypstNode {
   isOverHigh() {
     return this.fragments.some((n) => n.isOverHigh());
   }
-};
-
-// src/typst-shorthands.ts
-var shorthandMap = /* @__PURE__ */ new Map([
-  ["arrow.l.r.double.long", "<==>"],
-  ["arrow.l.r.long", "<-->"],
-  ["arrow.r.bar", "|->"],
-  ["arrow.r.double.bar", "|=>"],
-  ["arrow.r.double.long", "==>"],
-  ["arrow.r.long", "-->"],
-  ["arrow.r.long.squiggly", "~~>"],
-  ["arrow.r.tail", ">->"],
-  ["arrow.r.twohead", "->>"],
-  ["arrow.l.double.long", "<=="],
-  ["arrow.l.long", "<--"],
-  ["arrow.l.long.squiggly", "<~~"],
-  ["arrow.l.tail", "<-<"],
-  ["arrow.l.twohead", "<<-"],
-  ["arrow.l.r", "<->"],
-  ["arrow.l.r.double", "<=>"],
-  ["colon.double.eq", "::="],
-  ["dots.h", "..."],
-  ["gt.triple", ">>>"],
-  ["lt.triple", "<<<"],
-  ["arrow.r", "->"],
-  ["arrow.r.double", "=>"],
-  ["arrow.r.squiggly", "~>"],
-  ["arrow.l", "<-"],
-  ["arrow.l.squiggly", "<~"],
-  ["bar.v.double", "||"],
-  ["bracket.l.double", "[|"],
-  ["bracket.r.double", "|]"],
-  ["colon.eq", ":="],
-  ["eq.colon", "=:"],
-  ["eq.not", "!="],
-  ["gt.double", ">>"],
-  ["gt.eq", ">="],
-  ["lt.double", "<<"],
-  ["lt.eq", "<="],
-  ["ast.op", "*"],
-  ["minus", "-"],
-  ["tilde.op", "~"]
-]);
-var reverseShorthandMap = /* @__PURE__ */ new Map();
-for (const [key, value] of shorthandMap.entries()) {
-  if (value.length > 1) {
-    reverseShorthandMap.set(value, key);
+  serialize(env, options) {
+    const queue = [];
+    queue.push(this.head);
+    env.insideFunctionDepth++;
+    queue.push(TYPST_LEFT_PARENTHESIS);
+    if (this.options) {
+      const entries = Object.entries(this.options);
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i];
+        queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}`));
+        if (i < entries.length - 1) {
+          queue.push(new TypstToken(2 /* ELEMENT */, ","));
+        }
+      }
+    }
+    queue.push(TYPST_RIGHT_PARENTHESIS);
+    queue.push(new TypstToken(3 /* LITERAL */, "["));
+    for (const frag of this.fragments) {
+      queue.push(new TypstToken(3 /* LITERAL */, "$"));
+      queue.push(...frag.serialize(env, options));
+      queue.push(new TypstToken(3 /* LITERAL */, "$"));
+    }
+    queue.push(new TypstToken(3 /* LITERAL */, "]"));
+    return queue;
   }
-}
+};
 
 // src/typst-writer.ts
-function is_delimiter(c) {
-  return c.head.type === 2 /* ELEMENT */ && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.head.value);
-}
-var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
-var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
+var TYPST_LEFT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, "(");
+var TYPST_RIGHT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, ")");
 var TYPST_COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(1 /* SYMBOL */, "\n");
-var SOFT_SPACE = new TypstToken(7 /* CONTROL */, " ");
-var TypstWriterError = class extends Error {
-  node;
-  constructor(message, node) {
-    super(message);
-    this.name = "TypstWriterError";
-    this.node = node;
-  }
-};
+var SOFT_SPACE2 = new TypstToken(7 /* CONTROL */, " ");
 var TypstWriter = class {
-  nonStrict;
-  preferShorthands;
-  keepSpaces;
-  inftyToOo;
-  optimize;
   buffer = "";
   queue = [];
-  insideFunctionDepth = 0;
+  options;
   constructor(options) {
-    this.nonStrict = options.nonStrict;
-    this.preferShorthands = options.preferShorthands;
-    this.keepSpaces = options.keepSpaces;
-    this.inftyToOo = options.inftyToOo;
-    this.optimize = options.optimize;
+    this.options = options;
   }
   writeBuffer(previousToken, token) {
     const str = token.toString();
@@ -1367,7 +1581,7 @@ var TypstWriter = class {
     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) || /^\s/.test(str);
     no_need_space ||= this.buffer.endsWith("&") && str === "=";
     no_need_space ||= this.buffer.endsWith("/") || str === "/";
     no_need_space ||= token.type === 3 /* LITERAL */;
@@ -1382,239 +1596,31 @@ var TypstWriter = class {
   }
   // Serialize a tree of TypstNode into a list of TypstToken
   serialize(abstractNode) {
-    switch (abstractNode.type) {
-      case "terminal": {
-        const node = abstractNode;
-        if (node.head.type === 2 /* ELEMENT */) {
-          if (node.head.value === "," && this.insideFunctionDepth > 0) {
-            this.queue.push(new TypstToken(1 /* SYMBOL */, "comma"));
-          } else {
-            this.queue.push(node.head);
-          }
-          break;
-        } else if (node.head.type === 1 /* SYMBOL */) {
-          let symbol_name = node.head.value;
-          if (this.preferShorthands) {
-            if (shorthandMap.has(symbol_name)) {
-              symbol_name = shorthandMap.get(symbol_name);
-            }
-          }
-          if (this.inftyToOo && symbol_name === "infinity") {
-            symbol_name = "oo";
-          }
-          this.queue.push(new TypstToken(1 /* SYMBOL */, symbol_name));
-          break;
-        } else if (node.head.type === 6 /* SPACE */ || node.head.type === 8 /* NEWLINE */) {
-          for (const c of node.head.value) {
-            if (c === " ") {
-              if (this.keepSpaces) {
-                this.queue.push(new TypstToken(6 /* SPACE */, c));
-              }
-            } else if (c === "\n") {
-              this.queue.push(new TypstToken(1 /* SYMBOL */, c));
-            } else {
-              throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
-            }
-          }
-          break;
-        } else {
-          this.queue.push(node.head);
-          break;
-        }
-      }
-      case "group": {
-        const node = abstractNode;
-        for (const item of node.items) {
-          this.serialize(item);
-        }
-        break;
-      }
-      case "leftright": {
-        const node = abstractNode;
-        const LR = new TypstToken(1 /* SYMBOL */, "lr");
-        const { left, right } = node;
-        if (node.head.eq(LR)) {
-          this.queue.push(LR);
-          this.queue.push(TYPST_LEFT_PARENTHESIS);
-        }
-        if (left) {
-          this.queue.push(left);
-        }
-        this.serialize(node.body);
-        if (right) {
-          this.queue.push(right);
-        }
-        if (node.head.eq(LR)) {
-          this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        }
-        break;
-      }
-      case "supsub": {
-        const node = abstractNode;
-        let { base, sup, sub } = node;
-        this.appendWithBracketsIfNeeded(base);
-        let trailing_space_needed = false;
-        const has_prime = sup && sup.head.eq(new TypstToken(2 /* ELEMENT */, "'"));
-        if (has_prime) {
-          this.queue.push(new TypstToken(2 /* ELEMENT */, "'"));
-          trailing_space_needed = false;
-        }
-        if (sub) {
-          this.queue.push(new TypstToken(2 /* ELEMENT */, "_"));
-          trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
-        }
-        if (sup && !has_prime) {
-          this.queue.push(new TypstToken(2 /* ELEMENT */, "^"));
-          trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
-        }
-        if (trailing_space_needed) {
-          this.queue.push(SOFT_SPACE);
-        }
-        break;
-      }
-      case "funcCall": {
-        const node = abstractNode;
-        const func_symbol = node.head;
-        this.queue.push(func_symbol);
-        this.insideFunctionDepth++;
-        this.queue.push(TYPST_LEFT_PARENTHESIS);
-        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(2 /* ELEMENT */, ","));
-          }
-        }
-        if (node.options) {
-          for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push(new TypstToken(3 /* LITERAL */, `, ${key}: ${value.toString()}`));
-          }
-        }
-        this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.insideFunctionDepth--;
-        break;
-      }
-      case "fraction": {
-        const node = abstractNode;
-        const [numerator, denominator] = node.args;
-        const pos = this.queue.length;
-        const no_wrap = this.appendWithBracketsIfNeeded(numerator);
-        const wrapped = !no_wrap;
-        if (wrapped) {
-          this.queue.splice(pos, 0, SOFT_SPACE);
-        }
-        this.queue.push(new TypstToken(2 /* ELEMENT */, "/"));
-        this.appendWithBracketsIfNeeded(denominator);
-        break;
-      }
-      case "matrixLike": {
-        const node = abstractNode;
-        const matrix = node.matrix;
-        let cell_sep;
-        let row_sep;
-        if (node.head.eq(TypstMatrixLike.MAT)) {
-          cell_sep = new TypstToken(2 /* ELEMENT */, ",");
-          row_sep = new TypstToken(2 /* ELEMENT */, ";");
-        } else if (node.head.eq(TypstMatrixLike.CASES)) {
-          cell_sep = new TypstToken(2 /* ELEMENT */, "&");
-          row_sep = new TypstToken(2 /* ELEMENT */, ",");
-        } else if (node.head.eq(TypstToken.NONE)) {
-          cell_sep = new TypstToken(2 /* ELEMENT */, "&");
-          row_sep = new TypstToken(1 /* SYMBOL */, "\\");
-        }
-        if (!node.head.eq(TypstToken.NONE)) {
-          this.queue.push(node.head);
-          this.insideFunctionDepth++;
-          this.queue.push(TYPST_LEFT_PARENTHESIS);
-          if (node.options) {
-            for (const [key, value] of Object.entries(node.options)) {
-              this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
-            }
-          }
-        }
-        matrix.forEach((row, i) => {
-          row.forEach((cell, j) => {
-            this.serialize(cell);
-            if (j < row.length - 1) {
-              this.queue.push(cell_sep);
-            } else {
-              if (i < matrix.length - 1) {
-                this.queue.push(row_sep);
-              }
-            }
-          });
-        });
-        if (!node.head.eq(TypstToken.NONE)) {
-          this.queue.push(TYPST_RIGHT_PARENTHESIS);
-          this.insideFunctionDepth--;
-        }
-        break;
-      }
-      case "markupFunc": {
-        const node = abstractNode;
-        this.queue.push(node.head);
-        this.queue.push(TYPST_LEFT_PARENTHESIS);
-        if (node.options) {
-          const entries = Object.entries(node.options);
-          for (let i = 0; i < entries.length; i++) {
-            const [key, value] = entries[i];
-            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}`));
-            if (i < entries.length - 1) {
-              this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
-            }
-          }
-        }
-        this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.queue.push(new TypstToken(3 /* LITERAL */, "["));
-        for (const frag of node.fragments) {
-          this.queue.push(new TypstToken(3 /* LITERAL */, "$"));
-          this.serialize(frag);
-          this.queue.push(new TypstToken(3 /* LITERAL */, "$"));
-        }
-        this.queue.push(new TypstToken(3 /* LITERAL */, "]"));
-        break;
-      }
-      default:
-        throw new TypstWriterError(`Unimplemented node type to append: ${abstractNode.type}`, abstractNode);
-    }
+    const env = { insideFunctionDepth: 0 };
+    this.queue.push(...abstractNode.serialize(env, this.options));
   }
-  appendWithBracketsIfNeeded(node) {
-    let need_to_wrap = ["group", "supsub", "matrixLike", "fraction", "empty"].includes(node.type);
-    if (node.type === "group") {
-      const group = node;
-      if (group.items.length === 0) {
-        need_to_wrap = true;
-      } else {
-        const first = group.items[0];
-        const last = group.items[group.items.length - 1];
-        if (is_delimiter(first) && is_delimiter(last)) {
-          need_to_wrap = false;
-        }
+  flushQueue() {
+    let qu = [];
+    for (const token of this.queue) {
+      if (token.eq(SOFT_SPACE2) && qu.length > 0 && qu[qu.length - 1].eq(SOFT_SPACE2)) {
+        continue;
       }
+      qu.push(token);
     }
-    if (need_to_wrap) {
-      this.queue.push(TYPST_LEFT_PARENTHESIS);
-      this.serialize(node);
-      this.queue.push(TYPST_RIGHT_PARENTHESIS);
-    } else {
-      this.serialize(node);
-    }
-    return !need_to_wrap;
-  }
-  flushQueue() {
     const dummy_token = new TypstToken(1 /* SYMBOL */, "");
-    for (let i = 0; i < this.queue.length; i++) {
-      let token = this.queue[i];
-      if (token.eq(SOFT_SPACE)) {
-        const to_delete = i === 0 || i === this.queue.length - 1 || this.queue[i - 1].type === 6 /* SPACE */ || this.queue[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS, TYPST_NEWLINE]) || this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
+    for (let i = 0; i < qu.length; i++) {
+      let token = qu[i];
+      if (token.eq(SOFT_SPACE2)) {
+        const to_delete = i === 0 || i === qu.length - 1 || qu[i - 1].type === 6 /* SPACE */ || qu[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS2, TYPST_NEWLINE]) || qu[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS2, TYPST_COMMA, TYPST_NEWLINE]);
         if (to_delete) {
-          this.queue[i] = dummy_token;
+          qu[i] = dummy_token;
         }
       }
     }
-    this.queue = this.queue.filter((token) => !token.eq(dummy_token));
-    for (let i = 0; i < this.queue.length; i++) {
-      let token = this.queue[i];
-      let previous_token = i === 0 ? null : this.queue[i - 1];
+    qu = qu.filter((token) => !token.eq(dummy_token));
+    for (let i = 0; i < qu.length; i++) {
+      let token = qu[i];
+      let previous_token = i === 0 ? null : qu[i - 1];
       this.writeBuffer(previous_token, token);
     }
     this.queue = [];
@@ -1636,7 +1642,7 @@ var TypstWriter = class {
       res = res.replace(/round\(\)/g, 'round("")');
       return res;
     };
-    if (this.optimize) {
+    if (this.options.optimize) {
       const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
       for (const pass of all_passes) {
         this.buffer = pass(this.buffer);
@@ -1706,6 +1712,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["mathbb", "bb"],
   ["mathbf", "bold"],
   ["mathcal", "cal"],
+  ["mathscr", "scr"],
   ["mathit", "italic"],
   ["mathfrak", "frak"],
   ["mathrm", "upright"],
@@ -1906,7 +1913,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["zeta", "zeta"],
   ["intop", "limits(integral)"],
   // extended
-  ["mathscr", "scr"],
   ["LaTeX", "#LaTeX"],
   ["TeX", "#TeX"]
 ]);
@@ -2874,6 +2880,35 @@ function convert_tex_array_align_literal(alignLiteral) {
   }
   return np;
 }
+var TYPST_LEFT_PARENTHESIS3 = new TypstToken(2 /* ELEMENT */, "(");
+var TYPST_RIGHT_PARENTHESIS3 = new TypstToken(2 /* ELEMENT */, ")");
+function is_delimiter(c) {
+  return c.head.type === 2 /* ELEMENT */ && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.head.value);
+}
+function appendWithBracketsIfNeeded(node) {
+  let need_to_wrap = ["group", "supsub", "matrixLike", "fraction", "empty"].includes(node.type);
+  if (node.type === "group") {
+    const group = node;
+    if (group.items.length === 0) {
+      need_to_wrap = true;
+    } else {
+      const first = group.items[0];
+      const last = group.items[group.items.length - 1];
+      if (is_delimiter(first) && is_delimiter(last)) {
+        need_to_wrap = false;
+      }
+    }
+  }
+  if (need_to_wrap) {
+    return new TypstLeftright(null, {
+      left: TYPST_LEFT_PARENTHESIS3,
+      right: TYPST_RIGHT_PARENTHESIS3,
+      body: node
+    });
+  } else {
+    return node;
+  }
+}
 function convert_tex_node_to_typst(abstractNode, options = {}) {
   switch (abstractNode.type) {
     case "terminal": {
@@ -2882,12 +2917,6 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
     }
     case "text": {
       const node2 = abstractNode;
-      if (/[^\x00-\x7F]+/.test(node2.head.value) && options.nonAsciiWrapper !== "") {
-        return new TypstFuncCall(
-          new TypstToken(1 /* SYMBOL */, options.nonAsciiWrapper),
-          [new TypstToken(4 /* TEXT */, node2.head.value).toNode()]
-        );
-      }
       return new TypstToken(4 /* TEXT */, node2.head.value).toNode();
     }
     case "ordgroup":
@@ -2914,6 +2943,13 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
         sup: sup ? convert_tex_node_to_typst(sup, options) : null,
         sub: sub ? convert_tex_node_to_typst(sub, options) : null
       };
+      data.base = appendWithBracketsIfNeeded(data.base);
+      if (data.sup) {
+        data.sup = appendWithBracketsIfNeeded(data.sup);
+      }
+      if (data.sub) {
+        data.sub = appendWithBracketsIfNeeded(data.sub);
+      }
       return new TypstSupsub(data);
     }
     case "leftright": {
@@ -3010,6 +3046,36 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
       if (node2.head.value === "\\substack") {
         return arg0;
       }
+      if (node2.head.value === "\\displaylines") {
+        return arg0;
+      }
+      if (node2.head.value === "\\mathinner") {
+        return arg0;
+      }
+      if (node2.head.value === "\\mathrel") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "class"),
+          [new TypstToken(4 /* TEXT */, "relation").toNode(), arg0]
+        );
+      }
+      if (node2.head.value === "\\mathbin") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "class"),
+          [new TypstToken(4 /* TEXT */, "binary").toNode(), arg0]
+        );
+      }
+      if (node2.head.value === "\\mathop") {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "class"),
+          [new TypstToken(4 /* TEXT */, "large").toNode(), arg0]
+        );
+      }
+      if (node2.head.value === "\\set") {
+        return new TypstLeftright(
+          null,
+          { body: arg0, left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
+        );
+      }
       if (node2.head.value === "\\overset") {
         return convert_overset(node2, options);
       }
@@ -3018,7 +3084,7 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
       }
       if (node2.head.value === "\\frac") {
         if (options.fracToSlash) {
-          return new TypstFraction(node2.args.map((n) => convert_tex_node_to_typst(n, options)));
+          return new TypstFraction(node2.args.map((n) => convert_tex_node_to_typst(n, options)).map(appendWithBracketsIfNeeded));
         }
       }
       if (options.optimize) {
@@ -3282,6 +3348,31 @@ function convert_typst_node_to_tex(abstractNode) {
           assert(arg0.head.type === 4 /* TEXT */);
           return new TexFuncCall(typst_token_to_tex(node.head), [new TexToken(3 /* LITERAL */, arg0.head.value).toNode()]);
         }
+        case "class": {
+          const arg0 = node.args[0];
+          assert(arg0.head.type === 4 /* TEXT */);
+          let command;
+          switch (arg0.head.value) {
+            // \mathrel{X} <- class("relation", X)
+            case "relation":
+              command = "\\mathrel";
+              break;
+            // \mathbin{X} <- class("binary", X)
+            case "binary":
+              command = "\\mathbin";
+              break;
+            // \mathop{X} <- class("large", X)
+            case "large":
+              command = "\\mathop";
+              break;
+            default:
+              throw new Error(`Unimplemented class: ${arg0.head.value}`);
+          }
+          return new TexFuncCall(
+            new TexToken(2 /* COMMAND */, command),
+            [convert_typst_node_to_tex(node.args[1])]
+          );
+        }
         // general case
         default: {
           const func_name_tex = typst_token_to_tex(node.head);
@@ -3499,7 +3590,7 @@ function _find_closing_match(tokens, start, leftBrackets, rightBrackets) {
   }
   return pos - 1;
 }
-function find_closing_match2(tokens, start) {
+function find_closing_match(tokens, start) {
   return _find_closing_match(
     tokens,
     start,
@@ -3511,8 +3602,8 @@ function find_closing_delim(tokens, start) {
   return _find_closing_match(
     tokens,
     start,
-    [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2, VERTICAL_BAR],
-    [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2, VERTICAL_BAR]
+    TypstToken.LEFT_DELIMITERS,
+    TypstToken.RIGHT_DELIMITERS
   );
 }
 function find_closing_parenthesis(nodes, start) {
@@ -3645,7 +3736,6 @@ var LEFT_BRACKET = new TypstToken(2 /* ELEMENT */, "[");
 var RIGHT_BRACKET = new TypstToken(2 /* ELEMENT */, "]");
 var LEFT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "{");
 var RIGHT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "}");
-var VERTICAL_BAR = new TypstToken(2 /* ELEMENT */, "|");
 var COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(2 /* ELEMENT */, ";");
 var SINGLE_SPACE = new TypstToken(6 /* SPACE */, " ");
@@ -3720,7 +3810,7 @@ var TypstParser = class {
     let node;
     let end;
     if (tokens[start].eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match2(tokens, start);
+      const pos_closing = find_closing_match(tokens, start);
       [node, end] = this.parseGroup(tokens, start + 1, pos_closing);
     } else {
       [node, end] = this.parseNextExprWithoutSupSub(tokens, start);
@@ -3736,7 +3826,7 @@ var TypstParser = class {
     const firstToken = tokens[start];
     const node = firstToken.toNode();
     if (firstToken.eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match2(tokens, start);
+      const pos_closing = find_closing_match(tokens, start);
       return this.parseGroup(tokens, start + 1, pos_closing, true);
     }
     if (firstToken.type === 2 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
@@ -3780,32 +3870,32 @@ var TypstParser = class {
   }
   // start: the position of the left parentheses
   parseArguments(tokens, start) {
-    const end = find_closing_match2(tokens, start);
+    const end = find_closing_match(tokens, start);
     return [this.parseArgumentsWithSeparator(tokens, start + 1, end, COMMA), end + 1];
   }
   // start: the position of the left parentheses
   parseLrArguments(tokens, start) {
     const lr_token = tokens[start];
-    if (tokens[start + 1].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2, VERTICAL_BAR])) {
-      const end = find_closing_match2(tokens, start);
+    const end = find_closing_match(tokens, start);
+    if (tokens[start + 1].isOneOf(TypstToken.LEFT_DELIMITERS)) {
       const inner_start = start + 1;
       const inner_end = find_closing_delim(tokens, inner_start);
-      const inner_args = this.parseArgumentsWithSeparator(tokens, inner_start + 1, inner_end, COMMA);
+      const [inner_args, _] = this.parseGroup(tokens, inner_start + 1, inner_end);
       return [
-        new TypstLeftright(lr_token, { body: new TypstGroup(inner_args), left: tokens[inner_start], right: tokens[inner_end] }),
+        new TypstLeftright(lr_token, { body: inner_args, left: tokens[inner_start], right: tokens[inner_end] }),
         end + 1
       ];
     } else {
-      const [args, end] = this.parseArguments(tokens, start);
+      const [inner_args, _] = this.parseGroup(tokens, start + 1, end - 1);
       return [
-        new TypstLeftright(lr_token, { body: new TypstGroup(args), left: null, right: null }),
-        end
+        new TypstLeftright(lr_token, { body: inner_args, left: null, right: null }),
+        end + 1
       ];
     }
   }
   // start: the position of the left parentheses
   parseMatrix(tokens, start, rowSepToken, cellSepToken) {
-    const end = find_closing_match2(tokens, start);
+    const end = find_closing_match(tokens, start);
     tokens = tokens.slice(0, end);
     const matrix = [];
     let named_params = {};
@@ -3919,12 +4009,14 @@ function tex2typst(tex, options) {
     fracToSlash: true,
     inftyToOo: false,
     optimize: true,
-    nonAsciiWrapper: "",
     customTexMacros: {}
   };
   if (options !== void 0) {
+    if (typeof options !== "object") {
+      throw new Error("options must be an object");
+    }
     for (const key in opt) {
-      if (options[key] !== void 0) {
+      if (key in options) {
         opt[key] = options[key];
       }
     }