tex2typst 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/util.ts
+// src/utils.ts
 function isalpha(char) {
   return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
 }
@@ -574,7 +574,8 @@ var TEX_UNARY_COMMANDS = [
   "mathinner",
   "mathrel",
   "mathbin",
-  "mathop"
+  "mathop",
+  "not"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -762,19 +763,7 @@ var LatexParser = class {
     this.newline_sensitive = newline_sensitive;
   }
   parse(tokens) {
-    const token_displaystyle = new TexToken(2 /* COMMAND */, "\\displaystyle");
-    const idx = array_find(tokens, token_displaystyle);
-    if (idx === -1) {
-      return this.parseGroup(tokens.slice(0));
-    } else if (idx === 0) {
-      const tree = this.parseGroup(tokens.slice(1));
-      return new TexFuncCall(token_displaystyle, [tree]);
-    } else {
-      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]);
-    }
+    return this.parseGroup(tokens.slice(0));
   }
   parseGroup(tokens) {
     const [tree, _] = this.parseClosure(tokens, 0, null);
@@ -804,11 +793,12 @@ var LatexParser = class {
     if (pos >= tokens.length && closingToken !== null) {
       return [EMPTY_NODE, -1];
     }
+    const styledResults = this.applyStyleCommands(results);
     let node;
-    if (results.length === 1) {
-      node = results[0];
+    if (styledResults.length === 1) {
+      node = styledResults[0];
     } else {
-      node = new TexGroup(results);
+      node = new TexGroup(styledResults);
     }
     return [node, pos + 1];
   }
@@ -1066,51 +1056,53 @@ 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;
+    let closure;
+    [closure, pos] = this.parseClosure(tokens, pos, closingToken);
+    if (pos === -1) {
+      return [[], -1];
+    }
+    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();
       }
-      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;
+      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];
+  }
+  applyStyleCommands(nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const styleToken = this.getStyleToken(nodes[i]);
+      if (styleToken) {
+        const before = this.applyStyleCommands(nodes.slice(0, i));
+        const after = this.applyStyleCommands(nodes.slice(i + 1));
+        let body;
+        if (after.length === 0) {
+          body = EMPTY_NODE;
+        } else if (after.length === 1) {
+          body = after[0];
+        } else {
+          body = new TexGroup(after);
         }
-      }
-      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);
+        const funcCall = new TexFuncCall(styleToken, [body]);
+        return before.concat(funcCall);
       }
     }
-    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();
-        }
+    return nodes;
+  }
+  getStyleToken(node) {
+    if (node.type === "terminal") {
+      if (node.head.eq(TexToken.COMMAND_DISPLAYSTYLE) || node.head.eq(TexToken.COMMAND_TEXTSTYLE)) {
+        return node.head;
       }
     }
-    this.alignmentDepth--;
-    return [allRows, pos + 1];
+    return null;
   }
 };
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
@@ -1149,6 +1141,7 @@ function parseTex(tex, customTexMacros = {}) {
 
 // src/typst-shorthands.ts
 var shorthandMap = /* @__PURE__ */ new Map([
+  // The following snippet is generated with tools/make-short-hand-map.py
   ["arrow.l.r.double.long", "<==>"],
   ["arrow.l.r.long", "<-->"],
   ["arrow.r.bar", "|->"],
@@ -1163,7 +1156,6 @@ var shorthandMap = /* @__PURE__ */ new Map([
   ["arrow.l.long.squiggly", "<~~"],
   ["arrow.l.tail", "<-<"],
   ["arrow.l.twohead", "<<-"],
-  ["arrow.l.r", "<->"],
   ["arrow.l.r.double", "<=>"],
   ["colon.double.eq", "::="],
   ["dots.h", "..."],
@@ -1175,8 +1167,8 @@ var shorthandMap = /* @__PURE__ */ new Map([
   ["arrow.l", "<-"],
   ["arrow.l.squiggly", "<~"],
   ["bar.v.double", "||"],
-  ["bracket.l.double", "[|"],
-  ["bracket.r.double", "|]"],
+  ["bracket.l.stroked", "[|"],
+  ["bracket.r.stroked", "|]"],
   ["colon.eq", ":="],
   ["eq.colon", "=:"],
   ["eq.not", "!="],
@@ -1186,7 +1178,9 @@ var shorthandMap = /* @__PURE__ */ new Map([
   ["lt.eq", "<="],
   ["ast.op", "*"],
   ["minus", "-"],
-  ["tilde.op", "~"]
+  ["tilde.op", "~"],
+  // Typst's documentation doesn't include this. Wondering why
+  ["arrow.l.r", "<->"]
 ]);
 var reverseShorthandMap = /* @__PURE__ */ new Map();
 for (const [key, value] of shorthandMap.entries()) {
@@ -1231,7 +1225,7 @@ var TypstToken = class _TypstToken {
     new _TypstToken(2 /* ELEMENT */, "["),
     new _TypstToken(2 /* ELEMENT */, "{"),
     new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "angle.l"),
+    new _TypstToken(1 /* SYMBOL */, "chevron.l"),
     new _TypstToken(1 /* SYMBOL */, "paren.l"),
     new _TypstToken(1 /* SYMBOL */, "brace.l")
   ];
@@ -1240,7 +1234,7 @@ var TypstToken = class _TypstToken {
     new _TypstToken(2 /* ELEMENT */, "]"),
     new _TypstToken(2 /* ELEMENT */, "}"),
     new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "angle.r"),
+    new _TypstToken(1 /* SYMBOL */, "chevron.r"),
     new _TypstToken(1 /* SYMBOL */, "paren.r"),
     new _TypstToken(1 /* SYMBOL */, "brace.r")
   ];
@@ -1668,6 +1662,20 @@ var symbolMap = /* @__PURE__ */ new Map([
   [":", "med"],
   [" ", "med"],
   [";", "thick"],
+  ["blacktriangleleft", "triangle.filled.l"],
+  ["blacktriangleright", "triangle.filled.r"],
+  ["clubsuit", "suit.club.filled"],
+  ["hookleftarrow", "arrow.l.hook"],
+  ["hookrightarrow", "arrow.r.hook"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["lgblksquare", "square.filled.big"],
+  ["lgwhtsquare", "square.stroked.big"],
+  ["nearrow", "arrow.tr"],
+  ["nwarrow", "arrow.tl"],
+  ["searrow", "arrow.br"],
+  ["swarrow", "arrow.bl"],
+  ["spadesuit", "suit.spade.filled"],
+  ["updownarrow", "arrow.t.b"],
   /* textual operators */
   ["ln", "ln"],
   ["log", "log"],
@@ -1702,13 +1710,9 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["quad", "quad"],
   ["qquad", "wide"],
   ["overbrace", "overbrace"],
-  // same
   ["underbrace", "underbrace"],
-  // same
   ["overline", "overline"],
-  // same
   ["underline", "underline"],
-  // same
   ["bar", "macron"],
   ["dbinom", "binom"],
   ["tbinom", "binom"],
@@ -1784,7 +1788,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["geq", "gt.eq"],
   ["geqslant", "gt.eq.slant"],
   ["gg", "gt.double"],
-  ["hbar", "planck.reduce"],
+  ["hbar", "planck"],
   ["imath", "dotless.i"],
   ["iiiint", "integral.quad"],
   ["iiint", "integral.triple"],
@@ -1799,7 +1803,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["kappa", "kappa"],
   ["lambda", "lambda"],
   ["land", "and"],
-  ["langle", "angle.l"],
+  ["langle", "chevron.l"],
   ["lbrace", "brace.l"],
   ["lbrack", "bracket.l"],
   ["ldots", "dots.h"],
@@ -1861,7 +1865,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["prod", "product"],
   ["propto", "prop"],
   ["psi", "psi"],
-  ["rangle", "angle.r"],
+  ["rangle", "chevron.r"],
   ["rbrace", "brace.r"],
   ["rbrack", "bracket.r"],
   ["rhd", "triangle"],
@@ -1934,6 +1938,7 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["approxident", "tilde.triple"],
   ["assert", "tack.r.short"],
   ["ast", "ast.op"],
+  ["astrosun", "sun"],
   ["asymp", "asymp"],
   ["awint", "integral.ccw"],
   ["backcong", "tilde.rev.equiv"],
@@ -1989,10 +1994,9 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["bigcup", "union.big"],
   ["bigcupdot", "union.dot.big"],
   ["biginterleave", "interleave.big"],
-  ["bigodot", "dot.circle.big"],
-  ["bigoplus", "plus.circle.big"],
-  // or 'xor.big'
-  ["bigotimes", "times.circle.big"],
+  ["bigodot", "dot.o.big"],
+  ["bigoplus", "plus.o.big"],
+  ["bigotimes", "times.o.big"],
   ["bigsqcap", "inter.sq.big"],
   ["bigsqcup", "union.sq.big"],
   ["bigstar", "star.filled"],
@@ -2009,8 +2013,6 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["blackhourglass", "hourglass.filled"],
   ["blacktriangle", "triangle.filled.small.t"],
   ["blacktriangledown", "triangle.filled.small.b"],
-  ["blacktriangleleft", "triangle.filled.l"],
-  ["blacktriangleright", "triangle.filled.r"],
   ["blkhorzoval", "ellipse.filled.h"],
   ["blkvertoval", "ellipse.filled.v"],
   ["bot", "bot"],
@@ -2027,13 +2029,14 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["cdot", "dot.op"],
   ["cdotp", "dot.c"],
   ["checkmark", "checkmark"],
-  ["circledast", "ast.circle"],
-  ["circledcirc", "circle.nested"],
-  ["circleddash", "dash.circle"],
-  ["circledequal", "eq.circle"],
-  ["circledparallel", "parallel.circle"],
-  ["circledvert", "bar.v.circle"],
-  ["clubsuit", "suit.club.filled"],
+  ["circledast", "ast.op.o"],
+  ["circledbullet", "bullet.o"],
+  ["circledcirc", "compose.o"],
+  ["circleddash", "dash.o"],
+  ["circledequal", "cc.nd"],
+  ["circledparallel", "parallel.o"],
+  ["circledvert", "bar.v.o"],
+  ["circledwhitebullet", "bullet.stroked.o"],
   ["Colon", "colon.double"],
   ["coloneq", "colon.eq"],
   ["Coloneq", "colon.double.eq"],
@@ -2084,6 +2087,7 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["downarrow", "arrow.b"],
   ["Downarrow", "arrow.b.double"],
   ["downarrowbar", "arrow.b.stop"],
+  ["downarrowbarred", "arrow.b.struck"],
   ["downdasharrow", "arrow.b.dashed"],
   ["downdownarrows", "arrows.bb"],
   ["downharpoonleft", "harpoon.bl"],
@@ -2091,7 +2095,6 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["downharpoonright", "harpoon.br"],
   ["downharpoonrightbar", "harpoon.br.stop"],
   ["downharpoonsleftright", "harpoons.blbr"],
-  ["downrightcurvedarrow", "arrow.b.curve"],
   ["downuparrows", "arrows.bt"],
   ["downupharpoonsleftright", "harpoons.bltr"],
   ["downwhitearrow", "arrow.b.stroked"],
@@ -2124,13 +2127,13 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["errbardiamond", "errorbar.diamond.stroked"],
   ["errbarsquare", "errorbar.square.stroked"],
   ["euro", "euro"],
-  ["Exclam", "excl.double"],
   ["exists", "exists"],
   ["fallingdotseq", "eq.dots.down"],
   ["fint", "integral.slash"],
   ["flat", "flat"],
   ["forall", "forall"],
   ["fourvdots", "fence.dotted"],
+  ["frown", "frown"],
   ["fullouterjoin", "join.l.r"],
   ["geq", "gt.eq"],
   ["geqq", "gt.equiv"],
@@ -2154,14 +2157,11 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["hknwarrow", "arrow.tl.hook"],
   ["hksearrow", "arrow.br.hook"],
   ["hkswarrow", "arrow.bl.hook"],
-  ["hookleftarrow", "arrow.l.hook"],
-  ["hookrightarrow", "arrow.r.hook"],
   ["horizbar", "bar.h"],
   ["hourglass", "hourglass.stroked"],
   ["hrectangle", "rect.stroked.h"],
   ["hrectangleblack", "rect.filled.h"],
-  ["hslash", "planck.reduce"],
-  ["hzigzag", "dash.wave.double"],
+  ["hyphenbullet", "bullet.hyph"],
   ["iiiint", "integral.quad"],
   ["iiint", "integral.triple"],
   ["iinfin", "infinity.incomplete"],
@@ -2180,23 +2180,29 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["interleave", "interleave"],
   ["intlarhk", "integral.arrow.hook"],
   ["intx", "integral.times"],
+  ["inversebullet", "bullet.hole"],
   ["Join", "join"],
-  ["langle", "angle.l"],
-  ["lAngle", "angle.l.double"],
-  ["langledot", "angle.l.dot"],
+  ["langle", "chevron.l"],
+  ["lAngle", "chevron.l.double"],
+  ["langledot", "chevron.l.dot"],
   ["lat", "lat"],
   ["late", "lat.eq"],
+  ["lbag", "bag.l"],
+  ["lblkbrbrak", "shell.l.filled"],
   ["lbrace", "brace.l"],
-  ["lBrace", "brace.l.double"],
+  ["lBrace", "brace.l.stroked"],
   ["lbrack", "bracket.l"],
-  ["lBrack", "bracket.l.double"],
+  ["lBrack", "bracket.l.stroked"],
+  ["lbracklltick", "bracket.l.tick.b"],
+  ["lbrackultick", "bracket.l.tick.t"],
   ["lbrbrak", "shell.l"],
-  ["Lbrbrak", "shell.l.double"],
+  ["Lbrbrak", "shell.l.stroked"],
   ["lceil", "ceil.l"],
-  ["lcurvyangle", "angle.l.curly"],
+  ["lcurvyangle", "chevron.l.curly"],
   ["leftarrow", "arrow.l"],
   ["Leftarrow", "arrow.l.double"],
   ["leftarrowtail", "arrow.l.tail"],
+  ["leftarrowtriangle", "arrow.l.open"],
   ["leftdasharrow", "arrow.l.dashed"],
   ["leftdotarrow", "arrow.l.dotted"],
   ["leftdowncurvedarrow", "arrow.l.curve"],
@@ -2207,9 +2213,9 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["leftharpoonupbar", "harpoon.lt.bar"],
   ["leftleftarrows", "arrows.ll"],
   ["leftouterjoin", "join.l"],
-  ["leftrightarrow", "arrow.l.r"],
   ["Leftrightarrow", "arrow.l.r.double"],
   ["leftrightarrows", "arrows.lr"],
+  ["leftrightarrowtriangle", "arrow.l.r.open"],
   ["leftrightharpoondowndown", "harpoon.lb.rb"],
   ["leftrightharpoondownup", "harpoon.lb.rt"],
   ["leftrightharpoons", "harpoons.ltrb"],
@@ -2234,16 +2240,19 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["lesssim", "lt.tilde"],
   ["lfloor", "floor.l"],
   ["lgblkcircle", "circle.filled.big"],
-  ["lgblksquare", "square.filled.big"],
+  ["lgroup", "paren.l.flat"],
   ["lgwhtcircle", "circle.stroked.big"],
-  ["lgwhtsquare", "square.stroked.big"],
   ["ll", "lt.double"],
+  ["llangle", "chevron.l.closed"],
   ["llblacktriangle", "triangle.filled.bl"],
+  ["llcorner", "corner.l.b"],
   ["LLeftarrow", "arrow.l.quad"],
   ["Lleftarrow", "arrow.l.triple"],
   ["lll", "lt.triple"],
   ["lllnest", "lt.triple.nested"],
+  ["llparenthesis", "paren.l.closed"],
   ["lltriangle", "triangle.stroked.bl"],
+  ["lmoustache", "mustache.l"],
   ["lnapprox", "lt.napprox"],
   ["lneq", "lt.neq"],
   ["lneqq", "lt.nequiv"],
@@ -2264,8 +2273,9 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["looparrowleft", "arrow.l.loop"],
   ["looparrowright", "arrow.r.loop"],
   ["lparen", "paren.l"],
-  ["lParen", "paren.l.double"],
+  ["lParen", "paren.l.stroked"],
   ["lrblacktriangle", "triangle.filled.br"],
+  ["lrcorner", "corner.r.b"],
   ["lrtriangle", "triangle.stroked.br"],
   ["ltimes", "times.l"],
   ["lvzigzag", "fence.l"],
@@ -2283,8 +2293,8 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["mathcomma", "comma"],
   ["mathdollar", "dollar"],
   ["mathexclam", "excl"],
-  // ['mathhyphen', 'hyph'], // \mathhyphen is not defined in standard amsmath package
-  ["mathoctothorpe", "hash"],
+  ["mathhyphen", "hyph"],
+  // \mathhyphen is not defined in standard amsmath package
   ["mathparagraph", "pilcrow"],
   ["mathpercent", "percent"],
   ["mathperiod", "dot.basic"],
@@ -2298,7 +2308,6 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["mathyen", "yen"],
   ["mdblkdiamond", "diamond.filled.medium"],
   ["mdblklozenge", "lozenge.filled.medium"],
-  ["mdblksquare", "square.filled.medium"],
   ["mdlgblkcircle", "circle.filled"],
   ["mdlgblkdiamond", "diamond.filled"],
   ["mdlgblklozenge", "lozenge.filled"],
@@ -2308,12 +2317,9 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["mdlgwhtlozenge", "lozenge.stroked"],
   ["mdlgwhtsquare", "square.stroked"],
   ["mdsmblkcircle", "circle.filled.tiny"],
-  ["mdsmblksquare", "square.filled.small"],
   ["mdsmwhtcircle", "circle.stroked.small"],
-  ["mdsmwhtsquare", "square.stroked.small"],
   ["mdwhtdiamond", "diamond.stroked.medium"],
   ["mdwhtlozenge", "lozenge.stroked.medium"],
-  ["mdwhtsquare", "square.stroked.medium"],
   ["measeq", "eq.m"],
   ["measuredangle", "angle.arc"],
   ["measuredangleleft", "angle.arc.rev"],
@@ -2374,6 +2380,7 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ['mupvarpi', 'pi.alt'],
   ['mupvarrho', 'rho.alt'],
   ['mupvarsigma', 'sigma.alt'],
+  ['mupvarTheta', 'Theta.alt'],
   ['mupvartheta', 'theta.alt'],
   ['mupXi', 'Xi'],
   ['mupxi', 'xi'],
@@ -2385,7 +2392,6 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["natural", "natural"],
   ["ncong", "tilde.equiv.not"],
   ["ne", "eq.not"],
-  ["nearrow", "arrow.tr"],
   ["Nearrow", "arrow.tr.double"],
   ["neg", "not"],
   ["nequiv", "equiv.not"],
@@ -2396,7 +2402,9 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["ngtr", "gt.not"],
   ["ngtrless", "gt.lt.not"],
   ["ngtrsim", "gt.tilde.not"],
+  ["nHdownarrow", "arrow.b.dstruck"],
   ["nhpar", "parallel.struck"],
+  ["nHuparrow", "arrow.t.dstruck"],
   ["nhVvert", "interleave.struck"],
   ["ni", "in.rev"],
   ["nLeftarrow", "arrow.l.double.not"],
@@ -2433,36 +2441,62 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["nvdash", "tack.r.not"],
   ["nvDash", "tack.r.double.not"],
   ["nvinfty", "infinity.bar"],
-  ["nwarrow", "arrow.tl"],
+  ["nvLeftarrow", "arrow.l.double.struck"],
+  ["nvleftarrow", "arrow.l.struck"],
+  ["nVleftarrow", "arrow.l.dstruck"],
+  ["nvleftarrowtail", "arrow.l.tail.struck"],
+  ["nVleftarrowtail", "arrow.l.tail.dstruck"],
+  ["nvLeftrightarrow", "arrow.l.r.double.struck"],
+  ["nvleftrightarrow", "arrow.l.r.struck"],
+  ["nVleftrightarrow", "arrow.l.r.dstruck"],
+  ["nvRightarrow", "arrow.r.double.struck"],
+  ["nvrightarrow", "arrow.r.struck"],
+  ["nVrightarrow", "arrow.r.dstruck"],
+  ["nvrightarrowtail", "arrow.r.tail.struck"],
+  ["nVrightarrowtail", "arrow.r.tail.dstruck"],
+  ["nvtwoheadleftarrow", "arrow.l.twohead.struck"],
+  ["nVtwoheadleftarrow", "arrow.l.twohead.dstruck"],
+  ["nvtwoheadleftarrowtail", "arrow.l.twohead.tail.struck"],
+  ["nVtwoheadleftarrowtail", "arrow.l.twohead.tail.dstruck"],
+  ["nvtwoheadrightarrow", "arrow.r.twohead.struck"],
+  ["nVtwoheadrightarrow", "arrow.r.twohead.dstruck"],
+  ["nvtwoheadrightarrowtail", "arrow.r.twohead.tail.struck"],
+  ["nVtwoheadrightarrowtail", "arrow.r.twohead.tail.dstruck"],
   ["Nwarrow", "arrow.tl.double"],
   ["nwsearrow", "arrow.tl.br"],
   ["obrbrak", "shell.t"],
-  ["obslash", "backslash.circle"],
-  ["odiv", "div.circle"],
-  ["odot", "dot.circle"],
-  ["ogreaterthan", "gt.circle"],
+  ["obslash", "backslash.o"],
+  ["odiv", "div.o"],
+  ["odot", "dot.o"],
+  ["odotslashdot", "div.slanted.o"],
+  ["ogreaterthan", "gt.o"],
   ["oiiint", "integral.vol"],
   ["oiint", "integral.surf"],
   ["oint", "integral.cont"],
   ["ointctrclockwise", "integral.cont.ccw"],
-  ["olessthan", "lt.circle"],
-  ["ominus", "minus.circle"],
-  ["operp", "perp.circle"],
-  ["oplus", "plus.circle"],
+  ["olessthan", "lt.o"],
+  ["ominus", "minus.o"],
+  ["operp", "perp.o"],
+  ["oplus", "plus.o"],
+  ["opluslhrim", "plus.o.l"],
+  ["oplusrhrim", "plus.o.r"],
   ["origof", "original"],
-  ["otimes", "times.circle"],
+  ["oslash", "slash.o"],
+  ["otimes", "times.o"],
+  ["otimeshat", "times.o.hat"],
+  ["otimeslhrim", "times.o.l"],
+  ["otimesrhrim", "times.o.r"],
   // ['overbrace', 'brace.t'],
-  ["overbracket", "bracket.t"],
-  ["overparen", "paren.t"],
+  // ['overbracket', 'bracket.t'],
+  // ['overparen', 'paren.t'],
   ["parallel", "parallel"],
   ["parallelogram", "parallelogram.stroked"],
   ["parallelogramblack", "parallelogram.filled"],
   ["parsim", "parallel.tilde"],
-  ["partial", "diff"],
+  ["partial", "partial"],
   ["pentagon", "penta.stroked"],
   ["pentagonblack", "penta.filled"],
   ["perp", "perp"],
-  ["Planckconst", "planck"],
   ["pm", "plus.minus"],
   ["prec", "prec"],
   ["Prec", "prec.double"],
@@ -2483,30 +2517,37 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["quarternote", "note.quarter.alt"],
   ["questeq", "eq.quest"],
   ["Question", "quest.double"],
-  ["rangle", "angle.r"],
-  ["rAngle", "angle.r.double"],
-  ["rangledot", "angle.r.dot"],
+  ["rangle", "chevron.r"],
+  ["rAngle", "chevron.r.double"],
+  ["rangledot", "chevron.r.dot"],
+  ["rangledownzigzagarrow", "angle.azimuth"],
+  ["rbag", "bag.r"],
+  ["rblkbrbrak", "shell.r.filled"],
   ["rbrace", "brace.r"],
-  ["rBrace", "brace.r.double"],
+  ["rBrace", "brace.r.stroked"],
   ["rbrack", "bracket.r"],
-  ["rBrack", "bracket.r.double"],
+  ["rBrack", "bracket.r.stroked"],
+  ["rbracklrtick", "bracket.r.tick.b"],
+  ["rbrackurtick", "bracket.r.tick.t"],
   ["rbrbrak", "shell.r"],
-  ["Rbrbrak", "shell.r.double"],
+  ["Rbrbrak", "shell.r.stroked"],
   ["rceil", "ceil.r"],
-  ["rcurvyangle", "angle.r.curly"],
+  ["rcurvyangle", "chevron.r.curly"],
   ["Re", "Re"],
   ["revangle", "angle.rev"],
   ["revemptyset", "emptyset.rev"],
   ["revnmid", "divides.not.rev"],
   ["rfloor", "floor.r"],
+  ["rgroup", "paren.r.flat"],
   ["rightangle", "angle.right"],
   ["rightanglemdot", "angle.right.dot"],
-  ["rightanglesqr", "angle.right.sq"],
+  ["rightanglesqr", "angle.right.square"],
   ["rightarrow", "arrow.r"],
   ["Rightarrow", "arrow.r.double"],
   ["rightarrowbar", "arrow.r.stop"],
-  ["rightarrowonoplus", "plus.circle.arrow"],
+  ["rightarrowonoplus", "plus.o.arrow"],
   ["rightarrowtail", "arrow.r.tail"],
+  ["rightarrowtriangle", "arrow.r.open"],
   ["rightdasharrow", "arrow.r.dashed"],
   ["rightdotarrow", "arrow.r.dotted"],
   ["rightdowncurvedarrow", "arrow.r.curve"],
@@ -2527,15 +2568,17 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["rightwavearrow", "arrow.r.wave"],
   ["rightwhitearrow", "arrow.r.stroked"],
   ["risingdotseq", "eq.dots.up"],
+  ["rmoustache", "mustache.r"],
   ["rparen", "paren.r"],
-  ["rParen", "paren.r.double"],
+  ["rParen", "paren.r.stroked"],
+  ["rrangle", "chevron.r.closed"],
   ["RRightarrow", "arrow.r.quad"],
   ["Rrightarrow", "arrow.r.triple"],
+  ["rrparenthesis", "paren.r.closed"],
   ["rsolbar", "backslash.not"],
   ["rtimes", "times.r"],
   ["rvzigzag", "fence.r"],
   ["Rvzigzag", "fence.r.double"],
-  ["searrow", "arrow.br"],
   ["Searrow", "arrow.br.double"],
   ["setminus", "without"],
   ["sharp", "sharp"],
@@ -2557,16 +2600,15 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["smblkcircle", "bullet"],
   ["smblkdiamond", "diamond.filled.small"],
   ["smblklozenge", "lozenge.filled.small"],
-  ["smblksquare", "square.filled.tiny"],
   ["smeparsl", "parallel.slanted.eq.tilde"],
+  ["smile", "smile"],
   ["smt", "smt"],
   ["smte", "smt.eq"],
+  ["smwhtcircle", "bullet.stroked"],
   ["smwhtdiamond", "diamond.stroked.small"],
   ["smwhtlozenge", "lozenge.stroked.small"],
-  ["smwhtsquare", "square.stroked.tiny"],
-  ["spadesuit", "suit.spade.filled"],
   ["sphericalangle", "angle.spheric"],
-  ["sphericalangleup", "angle.spheric.top"],
+  ["sphericalangleup", "angle.spheric.t"],
   ["sqcap", "inter.sq"],
   ["Sqcap", "inter.sq.double"],
   ["sqcup", "union.sq"],
@@ -2605,7 +2647,6 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["supsetdot", "supset.dot"],
   ["supseteq", "supset.eq"],
   ["supsetneq", "supset.neq"],
-  ["swarrow", "arrow.bl"],
   ["Swarrow", "arrow.bl.double"],
   ["therefore", "therefore"],
   ["threedangle", "angle.spatial"],
@@ -2628,15 +2669,19 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["tripleplus", "plus.triple"],
   ["trprime", "prime.triple"],
   ["trslash", "slash.triple"],
+  ["turnediota", "iota.inv"],
   ["twoheaddownarrow", "arrow.b.twohead"],
   ["twoheadleftarrow", "arrow.l.twohead"],
+  ["twoheadleftarrowtail", "arrow.l.twohead.tail"],
   ["twoheadmapsfrom", "arrow.l.twohead.bar"],
   ["twoheadmapsto", "arrow.r.twohead.bar"],
   ["twoheadrightarrow", "arrow.r.twohead"],
+  ["twoheadrightarrowtail", "arrow.r.twohead.tail"],
   ["twoheaduparrow", "arrow.t.twohead"],
   ["twonotes", "note.eighth.beamed"],
   ["ubrbrak", "shell.b"],
   ["ulblacktriangle", "triangle.filled.tl"],
+  ["ulcorner", "corner.l.t"],
   ["ultriangle", "triangle.stroked.tl"],
   ["uminus", "union.minus"],
   ["underbrace", "brace.b"],
@@ -2647,8 +2692,11 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["upand", "amp.inv"],
   ["uparrow", "arrow.t"],
   ["Uparrow", "arrow.t.double"],
+  ["uparrowbarred", "arrow.t.struck"],
+  ["upbackepsilon", "epsilon.alt.rev"],
   ["updasharrow", "arrow.t.dashed"],
-  ["updownarrow", "arrow.t.b"],
+  ["upDigamma", "Digamma"],
+  ["updigamma", "digamma"],
   ["Updownarrow", "arrow.t.b.double"],
   ["updownarrows", "arrows.tb"],
   ["updownharpoonleftleft", "harpoon.tl.bl"],
@@ -2662,16 +2710,14 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["upharpoonrightbar", "harpoon.tr.bar"],
   ["upharpoonsleftright", "harpoons.tltr"],
   ["uplus", "union.plus"],
-  ["uprightcurvearrow", "arrow.t.curve"],
   ["upuparrows", "arrows.tt"],
   ["upwhitearrow", "arrow.t.stroked"],
   ["urblacktriangle", "triangle.filled.tr"],
+  ["urcorner", "corner.r.t"],
   ["urtriangle", "triangle.stroked.tr"],
   ["UUparrow", "arrow.t.quad"],
   ["Uuparrow", "arrow.t.triple"],
   ["varclubsuit", "suit.club.stroked"],
-  ["vardiamondsuit", "suit.diamond.filled"],
-  ["varheartsuit", "suit.heart.filled"],
   ["varhexagon", "hexa.stroked"],
   ["varhexagonblack", "hexa.filled"],
   ["varnothing", "emptyset"],
@@ -2696,6 +2742,7 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["vrectangleblack", "rect.filled.v"],
   ["Vvert", "bar.v.triple"],
   ["vysmblkcircle", "circle.filled.small"],
+  // or bullet.op
   ["vysmwhtcircle", "circle.stroked.tiny"],
   // or compose
   ["wedge", "and"],
@@ -2705,7 +2752,7 @@ var map_from_official_docs = /* @__PURE__ */ new Map([
   ["whiteinwhitetriangle", "triangle.stroked.nested"],
   ["whthorzoval", "ellipse.stroked.h"],
   ["whtvertoval", "ellipse.stroked.v"],
-  ["wideangledown", "angle.oblique"],
+  ["wideangledown", "angle.obtuse"],
   ["wr", "wreath"],
   ["xsol", "slash.big"]
 ]);
@@ -2889,23 +2936,8 @@ function convert_tex_array_align_literal(alignLiteral) {
 }
 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,
@@ -2950,7 +2982,6 @@ 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);
       }
@@ -3083,6 +3114,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);
       }
@@ -3182,12 +3227,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 */: {
@@ -3632,32 +3693,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 = [];
@@ -3696,30 +3759,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) {
@@ -3738,13 +3787,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();
@@ -3772,7 +3817,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;
@@ -3785,33 +3829,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);
@@ -3840,12 +3859,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);
     }
@@ -3860,8 +3914,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];
@@ -3909,70 +3967,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;
@@ -3985,26 +4014,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;
   }