tex2typst 0.3.29 → 0.4.1

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/util.ts
+// src/utils.ts
 function isalpha(char) {
   return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
 }
@@ -31,6 +31,8 @@ var TexToken = class _TexToken {
     return new TexTerminal(this);
   }
   static EMPTY = new _TexToken(0 /* EMPTY */, "");
+  static COMMAND_DISPLAYSTYLE = new _TexToken(2 /* COMMAND */, "\\displaystyle");
+  static COMMAND_TEXTSTYLE = new _TexToken(2 /* COMMAND */, "\\textstyle");
 };
 var TexNode = class {
   type;
@@ -572,7 +574,8 @@ var TEX_UNARY_COMMANDS = [
   "mathinner",
   "mathrel",
   "mathbin",
-  "mathop"
+  "mathop",
+  "not"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -1064,51 +1067,25 @@ var LatexParser = class {
     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 */) {
-        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
-          continue;
-        }
-        if (!this.newline_sensitive && res.head.value === "\n") {
-          continue;
-        }
-      }
-      if (res.head.eq(new TexToken(7 /* CONTROL */, "\\\\"))) {
-        row = [];
-        group = new TexGroup([]);
-        row.push(group);
-        allRows.push(row);
-      } else if (res.head.eq(new TexToken(7 /* CONTROL */, "&"))) {
-        group = new TexGroup([]);
-        row.push(group);
-      } else {
-        group.items.push(res);
-      }
-    }
-    if (pos >= tokens.length) {
+    let closure;
+    [closure, pos] = this.parseClosure(tokens, pos, closingToken);
+    if (pos === -1) {
       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();
-        }
+    let allRows;
+    if (closure.type === "ordgroup") {
+      const elements = closure.items;
+      while (elements.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(elements[elements.length - 1].head.type)) {
+        elements.pop();
       }
+      allRows = array_split(elements, new TexToken(7 /* CONTROL */, "\\\\").toNode()).map((row) => {
+        return array_split(row, new TexToken(7 /* CONTROL */, "&").toNode()).map((arr) => new TexGroup(arr));
+      });
+    } else {
+      allRows = [[closure]];
     }
     this.alignmentDepth--;
-    return [allRows, pos + 1];
+    return [allRows, pos];
   }
 };
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
@@ -1659,6 +1636,7 @@ var TypstWriter = class {
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
   ["displaystyle", "display"],
+  ["textstyle", "inline"],
   ["hspace", "#h"],
   ["|", "bar.v.double"],
   [",", "thin"],
@@ -2913,7 +2891,7 @@ function appendWithBracketsIfNeeded(node) {
     return node;
   }
 }
-function convert_tex_node_to_typst(abstractNode, options = {}) {
+function convert_tex_node_to_typst(abstractNode, options) {
   switch (abstractNode.type) {
     case "terminal": {
       const node2 = abstractNode;
@@ -3080,6 +3058,20 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
           { body: arg0, left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
         );
       }
+      if (node2.head.value === "\\not") {
+        const sym = convert_tex_node_to_typst(node2.args[0], options);
+        assert(sym.type === "terminal");
+        if (sym.head.type === 1 /* SYMBOL */) {
+          return new TypstToken(1 /* SYMBOL */, sym.head.value + ".not").toNode();
+        } else {
+          switch (sym.head.value) {
+            case "=":
+              return new TypstToken(1 /* SYMBOL */, "eq.not").toNode();
+            default:
+              throw new Error(`Not supported: \\not ${sym.head.value}`);
+          }
+        }
+      }
       if (node2.head.value === "\\overset") {
         return convert_overset(node2, options);
       }
@@ -3179,12 +3171,28 @@ function typst_token_to_tex(token) {
       return TexToken.EMPTY;
     case 1 /* SYMBOL */: {
       const _typst_symbol_to_tex = function(symbol) {
-        if (reverseSymbolMap.has(symbol)) {
-          return "\\" + reverseSymbolMap.get(symbol);
-        } else {
-          return "\\" + symbol;
+        switch (symbol) {
+          case "eq":
+            return "=";
+          case "plus":
+            return "+";
+          case "minus":
+            return "-";
+          case "percent":
+            return "%";
+          default: {
+            if (reverseSymbolMap.has(symbol)) {
+              return "\\" + reverseSymbolMap.get(symbol);
+            } else {
+              return "\\" + symbol;
+            }
+          }
         }
       };
+      if (token.value.endsWith(".not")) {
+        const sym = _typst_symbol_to_tex(token.value.slice(0, -4));
+        return new TexToken(2 /* COMMAND */, sym.startsWith("\\") ? `\\not${sym}` : `\\not ${sym}`);
+      }
       return new TexToken(2 /* COMMAND */, _typst_symbol_to_tex(token.value));
     }
     case 2 /* ELEMENT */: {
@@ -3225,7 +3233,8 @@ function typst_token_to_tex(token) {
   }
 }
 var TEX_NODE_COMMA = new TexToken(1 /* ELEMENT */, ",").toNode();
-function convert_typst_node_to_tex(abstractNode) {
+function convert_typst_node_to_tex(abstractNode, options) {
+  const convert_node = (node) => convert_typst_node_to_tex(node, options);
   switch (abstractNode.type) {
     case "terminal": {
       const node = abstractNode;
@@ -3258,7 +3267,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "group": {
       const node = abstractNode;
-      const args = node.items.map(convert_typst_node_to_tex);
+      const args = node.items.map(convert_node);
       const alignment_char = new TexToken(7 /* CONTROL */, "&").toNode();
       const newline_char = new TexToken(7 /* CONTROL */, "\\\\").toNode();
       if (array_includes(args, alignment_char)) {
@@ -3274,7 +3283,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "leftright": {
       const node = abstractNode;
-      const body = convert_typst_node_to_tex(node.body);
+      const body = convert_node(node.body);
       let left = node.left ? typst_token_to_tex(node.left) : new TexToken(1 /* ELEMENT */, ".");
       let right = node.right ? typst_token_to_tex(node.right) : new TexToken(1 /* ELEMENT */, ".");
       if (node.isOverHigh()) {
@@ -3291,7 +3300,7 @@ function convert_typst_node_to_tex(abstractNode) {
         // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
         case "norm": {
           const arg0 = node.args[0];
-          const body = convert_typst_node_to_tex(arg0);
+          const body = convert_node(arg0);
           if (node.isOverHigh()) {
             return new TexLeftRight({
               body,
@@ -3312,7 +3321,7 @@ function convert_typst_node_to_tex(abstractNode) {
           const left = "\\l" + node.head.value;
           const right = "\\r" + node.head.value;
           const arg0 = node.args[0];
-          const body = convert_typst_node_to_tex(arg0);
+          const body = convert_node(arg0);
           const left_node = new TexToken(2 /* COMMAND */, left);
           const right_node = new TexToken(2 /* COMMAND */, right);
           if (node.isOverHigh()) {
@@ -3328,22 +3337,22 @@ function convert_typst_node_to_tex(abstractNode) {
         // special hook for root
         case "root": {
           const [degree, radicand] = node.args;
-          const data = convert_typst_node_to_tex(degree);
-          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\sqrt"), [convert_typst_node_to_tex(radicand)], data);
+          const data = convert_node(degree);
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\sqrt"), [convert_node(radicand)], data);
         }
         // special hook for overbrace and underbrace
         case "overbrace":
         case "underbrace": {
           const [body, label] = node.args;
-          const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_typst_node_to_tex(body)]);
-          const script = convert_typst_node_to_tex(label);
+          const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_node(body)]);
+          const script = convert_node(label);
           const data = node.head.value === "overbrace" ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
           return new TexSupSub(data);
         }
         // special hook for vec
         // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
         case "vec": {
-          const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+          const tex_matrix = node.args.map((arg) => [convert_node(arg)]);
           return new TexBeginEnd(new TexToken(3 /* LITERAL */, "pmatrix"), tex_matrix);
         }
         // special hook for op
@@ -3374,20 +3383,46 @@ function convert_typst_node_to_tex(abstractNode) {
           }
           return new TexFuncCall(
             new TexToken(2 /* COMMAND */, command),
-            [convert_typst_node_to_tex(node.args[1])]
+            [convert_node(node.args[1])]
           );
         }
+        // display(...) -> \displaystyle ... \textstyle
+        // The postprocessor will remove \textstyle if it is the end of the math code
+        case "display": {
+          const arg0 = node.args[0];
+          const group = new TexGroup([
+            TexToken.COMMAND_DISPLAYSTYLE.toNode(),
+            convert_node(arg0)
+          ]);
+          if (!options.blockMathMode) {
+            group.items.push(TexToken.COMMAND_TEXTSTYLE.toNode());
+          }
+          return group;
+        }
+        // inline(...) -> \textstyle ... \displaystyle
+        // The postprocessor will remove \displaystyle if it is the end of the math code
+        case "inline": {
+          const arg0 = node.args[0];
+          const group = new TexGroup([
+            TexToken.COMMAND_TEXTSTYLE.toNode(),
+            convert_node(arg0)
+          ]);
+          if (options.blockMathMode) {
+            group.items.push(TexToken.COMMAND_DISPLAYSTYLE.toNode());
+          }
+          return group;
+        }
         // general case
         default: {
           const func_name_tex = typst_token_to_tex(node.head);
           const is_known_func = TEX_UNARY_COMMANDS.includes(func_name_tex.value.substring(1)) || TEX_BINARY_COMMANDS.includes(func_name_tex.value.substring(1));
           if (func_name_tex.value.length > 0 && is_known_func) {
-            return new TexFuncCall(func_name_tex, node.args.map(convert_typst_node_to_tex));
+            return new TexFuncCall(func_name_tex, node.args.map(convert_node));
           } else {
             return new TexGroup([
               typst_token_to_tex(node.head).toNode(),
               new TexToken(1 /* ELEMENT */, "(").toNode(),
-              ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+              ...array_intersperse(node.args.map(convert_node), TEX_NODE_COMMA),
               new TexToken(1 /* ELEMENT */, ")").toNode()
             ]);
           }
@@ -3402,7 +3437,7 @@ function convert_typst_node_to_tex(abstractNode) {
             const color = node.options["fill"];
             return new TexFuncCall(
               new TexToken(2 /* COMMAND */, "\\textcolor"),
-              [convert_typst_node_to_tex(color), convert_typst_node_to_tex(node.fragments[0])]
+              [convert_node(color), convert_node(node.fragments[0])]
             );
           }
         }
@@ -3414,11 +3449,11 @@ function convert_typst_node_to_tex(abstractNode) {
     case "supsub": {
       const node = abstractNode;
       const { base, sup, sub } = node;
-      const sup_tex = sup ? convert_typst_node_to_tex(sup) : null;
-      const sub_tex = sub ? convert_typst_node_to_tex(sub) : null;
+      const sup_tex = sup ? convert_node(sup) : null;
+      const sub_tex = sub ? convert_node(sub) : null;
       if (base.head.eq(new TypstToken(1 /* SYMBOL */, "limits"))) {
         const limits = base;
-        const body_in_limits = convert_typst_node_to_tex(limits.args[0]);
+        const body_in_limits = convert_node(limits.args[0]);
         if (sup_tex !== null && sub_tex === null) {
           return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, body_in_limits]);
         } else if (sup_tex === null && sub_tex !== null) {
@@ -3428,7 +3463,7 @@ function convert_typst_node_to_tex(abstractNode) {
           return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, underset_call]);
         }
       }
-      const base_tex = convert_typst_node_to_tex(base);
+      const base_tex = convert_node(base);
       const res = new TexSupSub({
         base: base_tex,
         sup: sup_tex,
@@ -3438,7 +3473,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "matrixLike": {
       const node = abstractNode;
-      const tex_matrix = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
+      const tex_matrix = node.matrix.map((row) => row.map(convert_node));
       if (node.head.eq(TypstMatrixLike.MAT)) {
         let env_type = "pmatrix";
         if (node.options) {
@@ -3485,8 +3520,8 @@ function convert_typst_node_to_tex(abstractNode) {
     case "fraction": {
       const node = abstractNode;
       const [numerator, denominator] = node.args;
-      const num_tex = convert_typst_node_to_tex(numerator);
-      const den_tex = convert_typst_node_to_tex(denominator);
+      const num_tex = convert_node(numerator);
+      const den_tex = convert_node(denominator);
       return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\frac"), [num_tex, den_tex]);
     }
     default:
@@ -3602,32 +3637,34 @@ function find_closing_match(tokens, start) {
     [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2]
   );
 }
-function find_closing_delim(tokens, start) {
-  return _find_closing_match(
-    tokens,
-    start,
-    TypstToken.LEFT_DELIMITERS,
-    TypstToken.RIGHT_DELIMITERS
-  );
-}
-function find_closing_parenthesis(nodes, start) {
-  const left_parenthesis = new TypstToken(2 /* ELEMENT */, "(").toNode();
-  const right_parenthesis = new TypstToken(2 /* ELEMENT */, ")").toNode();
-  assert(nodes[start].eq(left_parenthesis));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= nodes.length) {
-      throw new Error("Unmatched '('");
+function extract_named_params(arr) {
+  const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
+  const np = {};
+  const to_delete = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i].type !== "group") {
+      continue;
     }
-    if (nodes[pos].eq(left_parenthesis)) {
-      count += 1;
-    } else if (nodes[pos].eq(right_parenthesis)) {
-      count -= 1;
+    const g = arr[i];
+    const pos_colon = array_find(g.items, COLON);
+    if (pos_colon === -1 || pos_colon === 0) {
+      continue;
+    }
+    to_delete.push(i);
+    const param_name = g.items[pos_colon - 1];
+    if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
+      if (g.items.length !== 3) {
+        throw new TypstParserError("Invalid number of arguments for delim");
+      }
+      np["delim"] = g.items[pos_colon + 1];
+    } else {
+      throw new TypstParserError("Not implemented for other named parameters");
     }
-    pos += 1;
   }
-  return pos - 1;
+  for (let i = to_delete.length - 1; i >= 0; i--) {
+    arr.splice(to_delete[i], 1);
+  }
+  return [arr, np];
 }
 function primes(num) {
   const res = [];
@@ -3666,30 +3703,16 @@ function trim_whitespace_around_operators(nodes) {
   }
   return res;
 }
-function process_operators(nodes, parenthesis = false) {
+function process_operators(nodes) {
   nodes = trim_whitespace_around_operators(nodes);
-  const opening_bracket = LEFT_PARENTHESES.toNode();
-  const closing_bracket = RIGHT_PARENTHESES.toNode();
   const stack = [];
   const args = [];
   let pos = 0;
   while (pos < nodes.length) {
-    const current = nodes[pos];
-    if (current.eq(closing_bracket)) {
-      throw new TypstParserError("Unexpected ')'");
-    } else if (current.eq(DIV)) {
-      stack.push(current);
-      pos++;
+    const current_tree = nodes[pos];
+    if (current_tree.eq(DIV)) {
+      stack.push(current_tree);
     } else {
-      let current_tree;
-      if (current.eq(opening_bracket)) {
-        const pos_closing = find_closing_parenthesis(nodes, pos);
-        current_tree = process_operators(nodes.slice(pos + 1, pos_closing), true);
-        pos = pos_closing + 1;
-      } else {
-        current_tree = current;
-        pos++;
-      }
       if (stack.length > 0 && stack[stack.length - 1].eq(DIV)) {
         let denominator = current_tree;
         if (args.length === 0) {
@@ -3708,13 +3731,9 @@ function process_operators(nodes, parenthesis = false) {
         args.push(current_tree);
       }
     }
+    pos++;
   }
-  const body = args.length === 1 ? args[0] : new TypstGroup(args);
-  if (parenthesis) {
-    return new TypstLeftright(null, { body, left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
-  } else {
-    return body;
-  }
+  return args.length === 1 ? args[0] : new TypstGroup(args);
 }
 function parse_named_params(groups) {
   const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
@@ -3742,7 +3761,6 @@ var LEFT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "{");
 var RIGHT_CURLY_BRACKET2 = 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;
@@ -3755,33 +3773,8 @@ var TypstParser = class {
     const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
     return tree;
   }
-  parseGroup(tokens, start, end, parentheses = false) {
-    const results = [];
-    let pos = start;
-    while (pos < end) {
-      const [res, newPos] = this.parseNextExpr(tokens, pos);
-      pos = newPos;
-      if (res.head.type === 6 /* SPACE */ || res.head.type === 8 /* NEWLINE */) {
-        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
-          continue;
-        }
-        if (!this.newline_sensitive && res.head.value === "\n") {
-          continue;
-        }
-      }
-      results.push(res);
-    }
-    let node;
-    if (parentheses) {
-      node = process_operators(results, true);
-    } else {
-      if (results.length === 1) {
-        node = results[0];
-      } else {
-        node = process_operators(results);
-      }
-    }
-    return [node, end + 1];
+  parseGroup(tokens, start, end) {
+    return this.parseUntil(tokens.slice(start, end), 0, null);
   }
   parseNextExpr(tokens, start) {
     let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
@@ -3810,12 +3803,47 @@ var TypstParser = class {
       return [base, pos];
     }
   }
+  // return pos: (position of stopToken) + 1
+  // pos will be -1 if stopToken is not found
+  parseUntil(tokens, start, stopToken, env = {}) {
+    if (env.spaceSensitive === void 0) {
+      env.spaceSensitive = this.space_sensitive;
+    }
+    if (env.newlineSensitive === void 0) {
+      env.newlineSensitive = this.newline_sensitive;
+    }
+    const results = [];
+    let pos = start;
+    while (pos < tokens.length) {
+      if (stopToken !== null && tokens[pos].eq(stopToken)) {
+        break;
+      }
+      const [res, newPos] = this.parseNextExpr(tokens, pos);
+      pos = newPos;
+      if (res.head.type === 6 /* SPACE */ || res.head.type === 8 /* NEWLINE */) {
+        if (!env.spaceSensitive && res.head.value.replace(/ /g, "").length === 0) {
+          continue;
+        }
+        if (!env.newlineSensitive && res.head.value === "\n") {
+          continue;
+        }
+      }
+      results.push(res);
+    }
+    if (pos >= tokens.length && stopToken !== null) {
+      return [TypstToken.NONE.toNode(), -1];
+    }
+    const node = process_operators(results);
+    return [node, pos + 1];
+  }
   parseSupOrSub(tokens, start) {
     let node;
     let end;
     if (tokens[start].eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match(tokens, start);
-      [node, end] = this.parseGroup(tokens, start + 1, pos_closing);
+      [node, end] = this.parseUntil(tokens, start + 1, RIGHT_PARENTHESES);
+      if (end === -1) {
+        throw new Error("Unmatched '('");
+      }
     } else {
       [node, end] = this.parseNextExprWithoutSupSub(tokens, start);
     }
@@ -3830,8 +3858,12 @@ var TypstParser = class {
     const firstToken = tokens[start];
     const node = firstToken.toNode();
     if (firstToken.eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match(tokens, start);
-      return this.parseGroup(tokens, start + 1, pos_closing, true);
+      const [body, end] = this.parseUntil(tokens, start + 1, RIGHT_PARENTHESES);
+      if (end === -1) {
+        throw new Error("Unmatched '('");
+      }
+      const res = new TypstLeftright(null, { body, left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
+      return [res, end];
     }
     if (firstToken.type === 2 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
       return [node, start + 1];
@@ -3879,70 +3911,41 @@ var TypstParser = class {
   }
   // start: the position of the left parentheses
   parseLrArguments(tokens, start) {
-    const lr_token = tokens[start];
+    const lr_token = new TypstToken(1 /* SYMBOL */, "lr");
     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.parseGroup(tokens, inner_start + 1, inner_end);
-      return [
-        new TypstLeftright(lr_token, { body: inner_args, left: tokens[inner_start], right: tokens[inner_end] }),
-        end + 1
-      ];
-    } else {
-      const [inner_args, _] = this.parseGroup(tokens, start + 1, end - 1);
-      return [
-        new TypstLeftright(lr_token, { body: inner_args, left: null, right: null }),
-        end + 1
-      ];
-    }
+    let left = null;
+    let right = null;
+    let inner_start = start + 1;
+    let inner_end = end;
+    if (inner_end > inner_start && tokens[inner_start].isOneOf(TypstToken.LEFT_DELIMITERS)) {
+      left = tokens[inner_start];
+      inner_start += 1;
+    }
+    if (inner_end - 1 > inner_start && tokens[inner_end - 1].isOneOf(TypstToken.RIGHT_DELIMITERS)) {
+      right = tokens[inner_end - 1];
+      inner_end -= 1;
+    }
+    const [inner_args, _] = this.parseGroup(tokens, inner_start, inner_end);
+    return [
+      new TypstLeftright(lr_token, { body: inner_args, left, right }),
+      end + 1
+    ];
   }
   // start: the position of the left parentheses
   parseMatrix(tokens, start, rowSepToken, cellSepToken) {
     const end = find_closing_match(tokens, start);
-    tokens = tokens.slice(0, end);
     const matrix = [];
     let named_params = {};
     let pos = start + 1;
     while (pos < end) {
       while (pos < end) {
-        let extract_named_params2 = function(arr) {
-          const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
-          const np2 = {};
-          const to_delete = [];
-          for (let i = 0; i < arr.length; i++) {
-            if (arr[i].type !== "group") {
-              continue;
-            }
-            const g = arr[i];
-            const pos_colon = array_find(g.items, COLON);
-            if (pos_colon === -1 || pos_colon === 0) {
-              continue;
-            }
-            to_delete.push(i);
-            const param_name = g.items[pos_colon - 1];
-            if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
-              if (g.items.length !== 3) {
-                throw new TypstParserError("Invalid number of arguments for delim");
-              }
-              np2["delim"] = g.items[pos_colon + 1];
-            } else {
-              throw new TypstParserError("Not implemented for other named parameters");
-            }
-          }
-          for (let i = to_delete.length - 1; i >= 0; i--) {
-            arr.splice(to_delete[i], 1);
-          }
-          return [arr, np2];
-        };
-        var extract_named_params = extract_named_params2;
         let next_stop = array_find(tokens, rowSepToken, pos);
-        if (next_stop === -1) {
+        if (next_stop === -1 || next_stop > end) {
           next_stop = end;
         }
         let row = this.parseArgumentsWithSeparator(tokens, pos, next_stop, cellSepToken);
         let np = {};
-        [row, np] = extract_named_params2(row);
+        [row, np] = extract_named_params(row);
         matrix.push(row);
         Object.assign(named_params, np);
         pos = next_stop + 1;
@@ -3955,26 +3958,15 @@ var TypstParser = class {
     const args = [];
     let pos = start;
     while (pos < end) {
-      let nodes = [];
-      while (pos < end) {
-        if (tokens[pos].eq(sepToken)) {
-          pos += 1;
-          break;
-        } else if (tokens[pos].eq(SINGLE_SPACE)) {
-          pos += 1;
-          continue;
-        }
-        const [argItem, newPos] = this.parseNextExpr(tokens, pos);
-        pos = newPos;
-        nodes.push(argItem);
-      }
       let arg;
-      if (nodes.length === 1) {
-        arg = nodes[0];
-      } else {
-        arg = process_operators(nodes);
+      let newPos;
+      const env = { spaceSensitive: false, newlineSensitive: true };
+      [arg, newPos] = this.parseUntil(tokens.slice(0, end), pos, sepToken, env);
+      if (newPos == -1) {
+        [arg, newPos] = this.parseUntil(tokens.slice(0, end), pos, null, env);
       }
       args.push(arg);
+      pos = newPos;
     }
     return args;
   }
@@ -3993,6 +3985,14 @@ var TexWriter = class {
     this.queue = this.queue.concat(node.serialize());
   }
   flushQueue() {
+    while (this.queue.length > 0) {
+      const last_token = this.queue[this.queue.length - 1];
+      if (last_token.eq(TexToken.COMMAND_DISPLAYSTYLE) || last_token.eq(TexToken.COMMAND_TEXTSTYLE)) {
+        this.queue.pop();
+      } else {
+        break;
+      }
+    }
     for (let i = 0; i < this.queue.length; i++) {
       this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
     }
@@ -4005,7 +4005,7 @@ var TexWriter = class {
 };
 
 // src/index.ts
-function tex2typst(tex, options) {
+function tex2typst(tex, options = {}) {
   const opt = {
     nonStrict: true,
     preferShorthands: true,
@@ -4015,14 +4015,12 @@ function tex2typst(tex, options) {
     optimize: true,
     customTexMacros: {}
   };
-  if (options !== void 0) {
-    if (typeof options !== "object") {
-      throw new Error("options must be an object");
-    }
-    for (const key in opt) {
-      if (key in options) {
-        opt[key] = options[key];
-      }
+  if (typeof options !== "object") {
+    throw new Error("options must be an object");
+  }
+  for (const key in opt) {
+    if (key in options) {
+      opt[key] = options[key];
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
@@ -4031,9 +4029,20 @@ function tex2typst(tex, options) {
   writer.serialize(typstTree);
   return writer.finalize();
 }
-function typst2tex(typst) {
+function typst2tex(typst, options = {}) {
+  const opt = {
+    blockMathMode: true
+  };
+  if (typeof options !== "object") {
+    throw new Error("options must be an object");
+  }
+  for (const key in opt) {
+    if (key in options) {
+      opt[key] = options[key];
+    }
+  }
   const typstTree = parseTypst(typst);
-  const texTree = convert_typst_node_to_tex(typstTree);
+  const texTree = convert_typst_node_to_tex(typstTree, opt);
   const writer = new TexWriter();
   writer.append(texTree);
   return writer.finalize();