tex2typst 0.3.27 → 0.3.28

package/dist/index.d.ts

@@ -12,7 +12,6 @@ export interface Tex2TypstOptions {
     fracToSlash?: boolean; /** default is true */
     inftyToOo?: boolean; /** default is false */
     optimize?: boolean; /** default is true */
-    nonAsciiWrapper?: string; /** default is "" */
     customTexMacros?: { [key: string]: string; };
 }
 

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]);
 }
@@ -564,7 +567,12 @@ var TEX_UNARY_COMMANDS = [
   "overrightarrow",
   "hspace",
   "substack",
-  "set"
+  "set",
+  "displaylines",
+  "mathinner",
+  "mathrel",
+  "mathbin",
+  "mathop"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -708,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;
@@ -721,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;
@@ -767,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 */) {
@@ -793,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);
@@ -813,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");
+          }
         }
       }
     }
@@ -859,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) {
@@ -876,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);
         }
@@ -885,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 "\\,":
@@ -904,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");
@@ -917,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:
@@ -929,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) {
@@ -946,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];
@@ -987,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 });
@@ -1029,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 */) {
@@ -1082,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) {
@@ -1111,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);
@@ -1686,6 +1712,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["mathbb", "bb"],
   ["mathbf", "bold"],
   ["mathcal", "cal"],
+  ["mathscr", "scr"],
   ["mathit", "italic"],
   ["mathfrak", "frak"],
   ["mathrm", "upright"],
@@ -1886,7 +1913,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["zeta", "zeta"],
   ["intop", "limits(integral)"],
   // extended
-  ["mathscr", "scr"],
   ["LaTeX", "#LaTeX"],
   ["TeX", "#TeX"]
 ]);
@@ -2891,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":
@@ -3026,6 +3046,30 @@ 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,
@@ -3304,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);
@@ -3521,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,
@@ -3741,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);
@@ -3757,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])) {
@@ -3801,13 +3870,13 @@ 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];
-    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);
@@ -3826,7 +3895,7 @@ var TypstParser = class {
   }
   // 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 = {};
@@ -3940,7 +4009,6 @@ function tex2typst(tex, options) {
     fracToSlash: true,
     inftyToOo: false,
     optimize: true,
-    nonAsciiWrapper: "",
     customTexMacros: {}
   };
   if (options !== void 0) {