tex2typst 0.3.26 → 0.3.27

package/dist/index.js

@@ -10,6 +10,8 @@ function assert(condition, message = "Assertion failed.") {
 
 // src/tex-types.ts
 var TexToken = class _TexToken {
+  type;
+  value;
   constructor(type, value) {
     this.type = type;
     this.value = value;
@@ -28,11 +30,11 @@ var TexToken = class _TexToken {
   toNode() {
     return new TexTerminal(this);
   }
-  static {
-    this.EMPTY = new _TexToken(0 /* EMPTY */, "");
-  }
+  static EMPTY = new _TexToken(0 /* EMPTY */, "");
 };
 var TexNode = class {
+  type;
+  head;
   constructor(type, head) {
     this.type = type;
     this.head = head ? head : TexToken.EMPTY;
@@ -90,6 +92,7 @@ var TexText = class extends TexNode {
   }
 };
 var TexGroup = class extends TexNode {
+  items;
   constructor(items) {
     super("ordgroup", TexToken.EMPTY);
     this.items = items;
@@ -99,6 +102,9 @@ var TexGroup = class extends TexNode {
   }
 };
 var TexSupSub = class extends TexNode {
+  base;
+  sup;
+  sub;
   constructor(data) {
     super("supsub", TexToken.EMPTY);
     this.base = data.base;
@@ -142,6 +148,9 @@ var TexSupSub = class extends TexNode {
   }
 };
 var TexFuncCall = class extends TexNode {
+  args;
+  // For type="sqrt", it's additional argument wrapped square bracket. e.g. 3 in \sqrt[3]{x}
+  data;
   constructor(head, args, data = null) {
     super("funcCall", head);
     this.args = args;
@@ -164,6 +173,9 @@ var TexFuncCall = class extends TexNode {
   }
 };
 var TexLeftRight = class extends TexNode {
+  body;
+  left;
+  right;
   constructor(data) {
     super("leftright", TexToken.EMPTY);
     this.body = data.body;
@@ -181,6 +193,9 @@ var TexLeftRight = class extends TexNode {
   }
 };
 var TexBeginEnd = class extends TexNode {
+  matrix;
+  // for environment="array" or "subarray", there's additional data like {c|c} right after \begin{env}
+  data;
   constructor(head, matrix, data = null) {
     assert(head.type === 3 /* LITERAL */);
     super("beginend", head);
@@ -279,20 +294,23 @@ function matchcompare(m1, m2) {
   }
 }
 var Scanner = class {
+  _input;
+  _lexer;
+  // position within input stream
+  _pos = 0;
+  // current line number
+  _line = 0;
+  // current column number
+  _col = 0;
+  _offset = 0;
+  _less = null;
+  _go = false;
+  _newstate = null;
+  _state;
+  _text = null;
+  _leng = null;
+  _reMatchArray = null;
   constructor(input, lexer) {
-    // position within input stream
-    this._pos = 0;
-    // current line number
-    this._line = 0;
-    // current column number
-    this._col = 0;
-    this._offset = 0;
-    this._less = null;
-    this._go = false;
-    this._newstate = null;
-    this._text = null;
-    this._leng = null;
-    this._reMatchArray = null;
     this._input = input;
     this._lexer = lexer;
     this._state = lexer.states[0];
@@ -443,6 +461,8 @@ var Scanner = class {
   }
 };
 var JSLex = class {
+  states;
+  specification;
   constructor(spec3) {
     this.states = Object.keys(spec3);
     this.specification = {};
@@ -543,7 +563,8 @@ var TEX_UNARY_COMMANDS = [
   "overleftarrow",
   "overrightarrow",
   "hspace",
-  "substack"
+  "substack",
+  "set"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -736,6 +757,8 @@ var LatexParserError = class extends Error {
 var SUB_SYMBOL = new TexToken(7 /* CONTROL */, "_");
 var SUP_SYMBOL = new TexToken(7 /* CONTROL */, "^");
 var LatexParser = class {
+  space_sensitive;
+  newline_sensitive;
   constructor(space_sensitive = false, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -1096,8 +1119,58 @@ 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;
+  value;
   constructor(type, content) {
     this.type = type;
     this.value = content;
@@ -1121,14 +1194,39 @@ var TypstToken = class _TypstToken {
         return this.value;
     }
   }
-  static {
-    this.NONE = new _TypstToken(0 /* NONE */, "#none");
-  }
-  static {
-    this.EMPTY = new _TypstToken(2 /* ELEMENT */, "");
+  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;
+  // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
+  options;
   constructor(type, head) {
     this.type = type;
     this.head = head ? head : TypstToken.NONE;
@@ -1154,8 +1252,42 @@ 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;
   constructor(items) {
     super("group", TypstToken.NONE);
     this.items = items;
@@ -1163,8 +1295,21 @@ 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;
+  sup;
+  sub;
   constructor(data) {
     super("supsub", TypstToken.NONE);
     this.base = data.base;
@@ -1174,8 +1319,28 @@ 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;
   constructor(head, args) {
     super("funcCall", head);
     this.args = args;
@@ -1186,8 +1351,30 @@ 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;
   constructor(args) {
     super("fraction", TypstToken.NONE);
     this.args = args;
@@ -1195,8 +1382,23 @@ 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;
+  right;
   // head is either null or 'lr'
   constructor(head, data) {
     super("leftright", head);
@@ -1207,8 +1409,29 @@ 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) {
     super("matrixLike", head);
@@ -1217,14 +1440,60 @@ var TypstMatrixLike = class extends TypstNode {
   isOverHigh() {
     return true;
   }
-  static {
-    this.MAT = new TypstToken(1 /* SYMBOL */, "mat");
-  }
-  static {
-    this.CASES = new TypstToken(1 /* SYMBOL */, "cases");
+  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");
 };
 var TypstMarkupFunc = class extends TypstNode {
+  /*
+  In idealized situations, for `#heading([some text and math $x + y$ example])`,
+  fragments would be [TypstMarkup{"some text and math "}, TypstNode{"x + y"}, TypstMarkup{" example"}]
+  At present, we haven't implemented anything about TypstMarkup.
+  So only pattens like `#heading(level: 2)[$x+y$]`, `#text(fill: red)[$x + y$]` are supported.
+  Therefore, fragments is always a list containing exactly 1 TypstNode in well-working situations.
+  */
+  fragments;
   constructor(head, fragments) {
     super("markupFunc", head);
     this.fragments = fragments;
@@ -1232,82 +1501,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 {
-  constructor(message, node) {
-    super(message);
-    this.name = "TypstWriterError";
-    this.node = node;
-  }
-};
+var SOFT_SPACE2 = new TypstToken(7 /* CONTROL */, " ");
 var TypstWriter = class {
+  buffer = "";
+  queue = [];
+  options;
   constructor(options) {
-    this.buffer = "";
-    this.queue = [];
-    this.insideFunctionDepth = 0;
-    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();
@@ -1323,7 +1555,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 */;
@@ -1338,239 +1570,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 = [];
@@ -1592,7 +1616,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);
@@ -2687,6 +2711,7 @@ for (const [key, value] of texAliasMap) {
 
 // src/convert.ts
 var ConverterError = class extends Error {
+  node;
   constructor(message, node = null) {
     super(message);
     this.name = "ConverterError";
@@ -2829,6 +2854,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": {
@@ -2869,6 +2923,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": {
@@ -2965,6 +3026,12 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
       if (node2.head.value === "\\substack") {
         return 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);
       }
@@ -2973,7 +3040,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) {
@@ -3466,8 +3533,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) {
@@ -3600,12 +3667,13 @@ 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 */, " ");
 var CONTROL_AND = new TypstToken(7 /* CONTROL */, "&");
 var TypstParser = class {
+  space_sensitive;
+  newline_sensitive;
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -3739,20 +3807,20 @@ var TypstParser = class {
   // 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_match2(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
       ];
     }
   }
@@ -3846,10 +3914,8 @@ function parseTypst(typst) {
 
 // src/tex-writer.ts
 var TexWriter = class {
-  constructor() {
-    this.buffer = "";
-    this.queue = [];
-  }
+  buffer = "";
+  queue = [];
   append(node) {
     this.queue = this.queue.concat(node.serialize());
   }
@@ -3878,8 +3944,11 @@ function tex2typst(tex, options) {
     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];
       }
     }