tex2typst 0.3.24 → 0.3.26

package/dist/index.js

@@ -33,10 +33,9 @@ var TexToken = class _TexToken {
   }
 };
 var TexNode = class {
-  constructor(type, head, args) {
+  constructor(type, head) {
     this.type = type;
     this.head = head ? head : TexToken.EMPTY;
-    this.args = args;
   }
   // Note that this is only shallow equality.
   eq(other) {
@@ -91,16 +90,17 @@ var TexText = class extends TexNode {
   }
 };
 var TexGroup = class extends TexNode {
-  constructor(args) {
-    super("ordgroup", TexToken.EMPTY, args);
+  constructor(items) {
+    super("ordgroup", TexToken.EMPTY);
+    this.items = items;
   }
   serialize() {
-    return this.args.map((n) => n.serialize()).flat();
+    return this.items.map((n) => n.serialize()).flat();
   }
 };
 var TexSupSub = class extends TexNode {
   constructor(data) {
-    super("supsub", TexToken.EMPTY, []);
+    super("supsub", TexToken.EMPTY);
     this.base = data.base;
     this.sup = data.sup;
     this.sub = data.sub;
@@ -143,7 +143,8 @@ var TexSupSub = class extends TexNode {
 };
 var TexFuncCall = class extends TexNode {
   constructor(head, args, data = null) {
-    super("funcCall", head, args);
+    super("funcCall", head);
+    this.args = args;
     this.data = data;
   }
   serialize() {
@@ -163,8 +164,9 @@ var TexFuncCall = class extends TexNode {
   }
 };
 var TexLeftRight = class extends TexNode {
-  constructor(args, data) {
-    super("leftright", TexToken.EMPTY, args);
+  constructor(data) {
+    super("leftright", TexToken.EMPTY);
+    this.body = data.body;
     this.left = data.left;
     this.right = data.right;
   }
@@ -172,17 +174,18 @@ var TexLeftRight = class extends TexNode {
     let tokens = [];
     tokens.push(new TexToken(2 /* COMMAND */, "\\left"));
     tokens.push(new TexToken(1 /* ELEMENT */, this.left ? this.left.value : "."));
-    tokens = tokens.concat(this.args.map((n) => n.serialize()).flat());
+    tokens = tokens.concat(this.body.serialize());
     tokens.push(new TexToken(2 /* COMMAND */, "\\right"));
     tokens.push(new TexToken(1 /* ELEMENT */, this.right ? this.right.value : "."));
     return tokens;
   }
 };
 var TexBeginEnd = class extends TexNode {
-  constructor(head, args, data) {
+  constructor(head, matrix, data = null) {
     assert(head.type === 3 /* LITERAL */);
-    super("beginend", head, args);
-    this.matrix = data;
+    super("beginend", head);
+    this.matrix = matrix;
+    this.data = data;
   }
   serialize() {
     let tokens = [];
@@ -230,6 +233,7 @@ function writeTexTokenBuffer(buffer, token) {
     no_need_space ||= buffer === "";
     no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(buffer) || buffer === "-" || buffer === "+";
     no_need_space ||= buffer.endsWith("&") && str === "=";
+    no_need_space ||= /\d$/.test(buffer) && /^[a-zA-Z]$/.test(str);
   }
   if (!no_need_space) {
     buffer += " ";
@@ -549,7 +553,8 @@ var TEX_BINARY_COMMANDS = [
   "dfrac",
   "tbinom",
   "overset",
-  "underset"
+  "underset",
+  "textcolor"
 ];
 function unescape(str) {
   const chars = ["{", "}", "\\", "$", "&", "#", "_", "%"];
@@ -559,7 +564,7 @@ function unescape(str) {
   return str;
 }
 var rules_map = /* @__PURE__ */ new Map([
-  // math `\begin{array}{cc}`
+  // match `\begin{array}{cc}`
   [
     String.raw`\\begin{(array|subarry)}{(.+?)}`,
     (s) => {
@@ -576,7 +581,7 @@ var rules_map = /* @__PURE__ */ new Map([
     }
   ],
   [
-    String.raw`\\(text|operatorname|begin|end|hspace|array){(.+?)}`,
+    String.raw`\\(text|operatorname|textcolor|begin|end|hspace|array){(.+?)}`,
     (s) => {
       const match = s.reMatchArray();
       return [
@@ -646,12 +651,16 @@ function tokenize_tex(input) {
 var IGNORED_COMMANDS = [
   "bigl",
   "bigr",
+  "bigm",
   "biggl",
   "biggr",
+  "biggm",
   "Bigl",
   "Bigr",
+  "Bigm",
   "Biggl",
-  "Biggr"
+  "Biggr",
+  "Biggm"
 ];
 var EMPTY_NODE = TexToken.EMPTY.toNode();
 function get_command_param_num(command) {
@@ -809,16 +818,14 @@ var LatexParser = class {
         res.sub = sub;
       }
       if (num_prime > 0) {
-        res.sup = new TexGroup([]);
+        const items = [];
         for (let i = 0; i < num_prime; i++) {
-          res.sup.args.push(new TexToken(1 /* ELEMENT */, "'").toNode());
+          items.push(new TexToken(1 /* ELEMENT */, "'").toNode());
         }
         if (sup) {
-          res.sup.args.push(sup);
-        }
-        if (res.sup.args.length === 1) {
-          res.sup = res.sup.args[0];
+          items.push(sup);
         }
+        res.sup = items.length === 1 ? items[0] : new TexGroup(items);
       } else if (sup) {
         res.sup = sup;
       }
@@ -981,10 +988,9 @@ var LatexParser = class {
     }
     pos++;
     const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
-    const args = [body];
     const left = leftDelimiter.value === "." ? null : leftDelimiter;
     const right = rightDelimiter.value === "." ? null : rightDelimiter;
-    const res = new TexLeftRight(args, { left, right });
+    const res = new TexLeftRight({ body, left, right });
     return [res, pos];
   }
   parseBeginEndExpr(tokens, start) {
@@ -995,12 +1001,10 @@ var LatexParser = class {
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     const envName = tokens[pos + 1].value;
     pos += 3;
-    const args = [];
+    let data = null;
     if (["array", "subarray"].includes(envName)) {
       pos += eat_whitespaces(tokens, pos).length;
-      const [arg, newPos] = this.parseNextArg(tokens, pos);
-      args.push(arg);
-      pos = newPos;
+      [data, pos] = this.parseNextArg(tokens, pos);
     }
     pos += eat_whitespaces(tokens, pos).length;
     const exprInsideStart = pos;
@@ -1022,7 +1026,7 @@ var LatexParser = class {
       exprInside.pop();
     }
     const body = this.parseAligned(exprInside);
-    const res = new TexBeginEnd(new TexToken(3 /* LITERAL */, envName), args, body);
+    const res = new TexBeginEnd(new TexToken(3 /* LITERAL */, envName), body, data);
     return [res, pos];
   }
   parseAligned(tokens) {
@@ -1052,7 +1056,7 @@ var LatexParser = class {
         group = new TexGroup([]);
         row.push(group);
       } else {
-        group.args.push(res);
+        group.items.push(res);
       }
     }
     return allRows;
@@ -1120,12 +1124,14 @@ var TypstToken = class _TypstToken {
   static {
     this.NONE = new _TypstToken(0 /* NONE */, "#none");
   }
+  static {
+    this.EMPTY = new _TypstToken(2 /* ELEMENT */, "");
+  }
 };
 var TypstNode = class {
-  constructor(type, head, args) {
+  constructor(type, head) {
     this.type = type;
     this.head = head ? head : TypstToken.NONE;
-    this.args = args;
   }
   setOptions(options) {
     this.options = options;
@@ -1150,16 +1156,17 @@ var TypstTerminal = class extends TypstNode {
   }
 };
 var TypstGroup = class extends TypstNode {
-  constructor(args) {
-    super("group", TypstToken.NONE, args);
+  constructor(items) {
+    super("group", TypstToken.NONE);
+    this.items = items;
   }
   isOverHigh() {
-    return this.args.some((n) => n.isOverHigh());
+    return this.items.some((n) => n.isOverHigh());
   }
 };
 var TypstSupsub = class extends TypstNode {
   constructor(data) {
-    super("supsub", TypstToken.NONE, []);
+    super("supsub", TypstToken.NONE);
     this.base = data.base;
     this.sup = data.sup;
     this.sub = data.sub;
@@ -1170,7 +1177,8 @@ var TypstSupsub = class extends TypstNode {
 };
 var TypstFuncCall = class extends TypstNode {
   constructor(head, args) {
-    super("funcCall", head, args);
+    super("funcCall", head);
+    this.args = args;
   }
   isOverHigh() {
     if (this.head.value === "frac") {
@@ -1181,47 +1189,48 @@ var TypstFuncCall = class extends TypstNode {
 };
 var TypstFraction = class extends TypstNode {
   constructor(args) {
-    super("fraction", TypstToken.NONE, args);
+    super("fraction", TypstToken.NONE);
+    this.args = args;
   }
   isOverHigh() {
     return true;
   }
 };
 var TypstLeftright = class extends TypstNode {
-  constructor(head, args, data) {
-    super("leftright", head, args);
+  // head is either null or 'lr'
+  constructor(head, data) {
+    super("leftright", head);
+    this.body = data.body;
     this.left = data.left;
     this.right = data.right;
   }
   isOverHigh() {
-    return this.args.some((n) => n.isOverHigh());
+    return this.body.isOverHigh();
   }
 };
-var TypstAlign = class extends TypstNode {
-  constructor(data) {
-    super("align", TypstToken.NONE, []);
+var TypstMatrixLike = class extends TypstNode {
+  // head is 'mat', 'cases' or null
+  constructor(head, data) {
+    super("matrixLike", head);
     this.matrix = data;
   }
   isOverHigh() {
     return true;
   }
-};
-var TypstMatrix = class extends TypstNode {
-  constructor(data) {
-    super("matrix", TypstToken.NONE, []);
-    this.matrix = data;
+  static {
+    this.MAT = new TypstToken(1 /* SYMBOL */, "mat");
   }
-  isOverHigh() {
-    return true;
+  static {
+    this.CASES = new TypstToken(1 /* SYMBOL */, "cases");
   }
 };
-var TypstCases = class extends TypstNode {
-  constructor(data) {
-    super("cases", TypstToken.NONE, []);
-    this.matrix = data;
+var TypstMarkupFunc = class extends TypstNode {
+  constructor(head, fragments) {
+    super("markupFunc", head);
+    this.fragments = fragments;
   }
   isOverHigh() {
-    return true;
+    return this.fragments.some((n) => n.isOverHigh());
   }
 };
 
@@ -1300,7 +1309,7 @@ var TypstWriter = class {
     this.inftyToOo = options.inftyToOo;
     this.optimize = options.optimize;
   }
-  writeBuffer(token) {
+  writeBuffer(previousToken, token) {
     const str = token.toString();
     if (str === "") {
       return;
@@ -1317,7 +1326,11 @@ var TypstWriter = class {
     no_need_space ||= /^\s/.test(str);
     no_need_space ||= this.buffer.endsWith("&") && str === "=";
     no_need_space ||= this.buffer.endsWith("/") || str === "/";
+    no_need_space ||= token.type === 3 /* LITERAL */;
     no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
+    if (previousToken !== null) {
+      no_need_space ||= previousToken.type === 3 /* LITERAL */;
+    }
     if (!no_need_space) {
       this.buffer += " ";
     }
@@ -1367,7 +1380,7 @@ var TypstWriter = class {
       }
       case "group": {
         const node = abstractNode;
-        for (const item of node.args) {
+        for (const item of node.items) {
           this.serialize(item);
         }
         break;
@@ -1383,9 +1396,7 @@ var TypstWriter = class {
         if (left) {
           this.queue.push(left);
         }
-        for (const item of node.args) {
-          this.serialize(item);
-        }
+        this.serialize(node.body);
         if (right) {
           this.queue.push(right);
         }
@@ -1451,74 +1462,71 @@ var TypstWriter = class {
         this.appendWithBracketsIfNeeded(denominator);
         break;
       }
-      case "align": {
+      case "matrixLike": {
         const node = abstractNode;
         const matrix = node.matrix;
-        matrix.forEach((row, i) => {
-          row.forEach((cell, j) => {
-            if (j > 0) {
-              this.queue.push(new TypstToken(2 /* ELEMENT */, "&"));
+        let cell_sep;
+        let row_sep;
+        if (node.head.eq(TypstMatrixLike.MAT)) {
+          cell_sep = new TypstToken(2 /* ELEMENT */, ",");
+          row_sep = new TypstToken(2 /* ELEMENT */, ";");
+        } else if (node.head.eq(TypstMatrixLike.CASES)) {
+          cell_sep = new TypstToken(2 /* ELEMENT */, "&");
+          row_sep = new TypstToken(2 /* ELEMENT */, ",");
+        } else if (node.head.eq(TypstToken.NONE)) {
+          cell_sep = new TypstToken(2 /* ELEMENT */, "&");
+          row_sep = new TypstToken(1 /* SYMBOL */, "\\");
+        }
+        if (!node.head.eq(TypstToken.NONE)) {
+          this.queue.push(node.head);
+          this.insideFunctionDepth++;
+          this.queue.push(TYPST_LEFT_PARENTHESIS);
+          if (node.options) {
+            for (const [key, value] of Object.entries(node.options)) {
+              this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
             }
-            this.serialize(cell);
-          });
-          if (i < matrix.length - 1) {
-            this.queue.push(new TypstToken(1 /* SYMBOL */, "\\"));
-          }
-        });
-        break;
-      }
-      case "matrix": {
-        const node = abstractNode;
-        const matrix = node.matrix;
-        this.queue.push(new TypstToken(1 /* SYMBOL */, "mat"));
-        this.insideFunctionDepth++;
-        this.queue.push(TYPST_LEFT_PARENTHESIS);
-        if (node.options) {
-          for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
           }
         }
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             this.serialize(cell);
             if (j < row.length - 1) {
-              this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
+              this.queue.push(cell_sep);
             } else {
               if (i < matrix.length - 1) {
-                this.queue.push(new TypstToken(2 /* ELEMENT */, ";"));
+                this.queue.push(row_sep);
               }
             }
           });
         });
-        this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.insideFunctionDepth--;
+        if (!node.head.eq(TypstToken.NONE)) {
+          this.queue.push(TYPST_RIGHT_PARENTHESIS);
+          this.insideFunctionDepth--;
+        }
         break;
       }
-      case "cases": {
+      case "markupFunc": {
         const node = abstractNode;
-        const cases = node.matrix;
-        this.queue.push(new TypstToken(1 /* SYMBOL */, "cases"));
-        this.insideFunctionDepth++;
+        this.queue.push(node.head);
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         if (node.options) {
-          for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
+          const entries = Object.entries(node.options);
+          for (let i = 0; i < entries.length; i++) {
+            const [key, value] = entries[i];
+            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}`));
+            if (i < entries.length - 1) {
+              this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
+            }
           }
         }
-        cases.forEach((row, i) => {
-          row.forEach((cell, j) => {
-            this.serialize(cell);
-            if (j < row.length - 1) {
-              this.queue.push(new TypstToken(2 /* ELEMENT */, "&"));
-            } else {
-              if (i < cases.length - 1) {
-                this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
-              }
-            }
-          });
-        });
         this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.insideFunctionDepth--;
+        this.queue.push(new TypstToken(3 /* LITERAL */, "["));
+        for (const frag of node.fragments) {
+          this.queue.push(new TypstToken(3 /* LITERAL */, "$"));
+          this.serialize(frag);
+          this.queue.push(new TypstToken(3 /* LITERAL */, "$"));
+        }
+        this.queue.push(new TypstToken(3 /* LITERAL */, "]"));
         break;
       }
       default:
@@ -1526,13 +1534,14 @@ var TypstWriter = class {
     }
   }
   appendWithBracketsIfNeeded(node) {
-    let need_to_wrap = ["group", "supsub", "align", "fraction", "empty"].includes(node.type);
+    let need_to_wrap = ["group", "supsub", "matrixLike", "fraction", "empty"].includes(node.type);
     if (node.type === "group") {
-      if (node.args.length === 0) {
+      const group = node;
+      if (group.items.length === 0) {
         need_to_wrap = true;
       } else {
-        const first = node.args[0];
-        const last = node.args[node.args.length - 1];
+        const first = group.items[0];
+        const last = group.items[group.items.length - 1];
         if (is_delimiter(first) && is_delimiter(last)) {
           need_to_wrap = false;
         }
@@ -1559,9 +1568,11 @@ var TypstWriter = class {
       }
     }
     this.queue = this.queue.filter((token) => !token.eq(dummy_token));
-    this.queue.forEach((token) => {
-      this.writeBuffer(token);
-    });
+    for (let i = 0; i < this.queue.length; i++) {
+      let token = this.queue[i];
+      let previous_token = i === 0 ? null : this.queue[i - 1];
+      this.writeBuffer(previous_token, token);
+    }
     this.queue = [];
   }
   finalize() {
@@ -1849,6 +1860,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["xi", "xi"],
   ["yen", "yen"],
   ["zeta", "zeta"],
+  ["intop", "limits(integral)"],
   // extended
   ["mathscr", "scr"],
   ["LaTeX", "#LaTeX"],
@@ -2836,7 +2848,7 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
     case "ordgroup":
       const node = abstractNode;
       return new TypstGroup(
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
+        node.items.map((n) => convert_tex_node_to_typst(n, options))
       );
     case "supsub": {
       const node2 = abstractNode;
@@ -2862,8 +2874,7 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
     case "leftright": {
       const node2 = abstractNode;
       const { left, right } = node2;
-      const [_body] = node2.args;
-      const typ_body = convert_tex_node_to_typst(_body, options);
+      const typ_body = convert_tex_node_to_typst(node2.body, options);
       if (options.optimize) {
         if (left !== null && right !== null) {
           const typ_left2 = tex_token_to_typst(left, options);
@@ -2900,8 +2911,7 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
       }
       return new TypstLeftright(
         new TypstToken(1 /* SYMBOL */, "lr"),
-        [typ_body],
-        { left: typ_left, right: typ_right }
+        { body: typ_body, left: typ_left, right: typ_right }
       );
     }
     case "funcCall": {
@@ -2944,6 +2954,14 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
         }
         return new TypstFuncCall(new TypstToken(1 /* SYMBOL */, "op"), [new TypstToken(4 /* TEXT */, arg0.head.value).toNode()]);
       }
+      if (node2.head.value === "\\textcolor") {
+        const res = new TypstMarkupFunc(
+          new TypstToken(1 /* SYMBOL */, `#text`),
+          [convert_tex_node_to_typst(node2.args[1], options)]
+        );
+        res.setOptions({ fill: arg0 });
+        return res;
+      }
       if (node2.head.value === "\\substack") {
         return arg0;
       }
@@ -2973,38 +2991,40 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
     }
     case "beginend": {
       const node2 = abstractNode;
-      const data = node2.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
+      const matrix = node2.matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
       if (node2.head.value.startsWith("align")) {
-        return new TypstAlign(data);
+        return new TypstMatrixLike(null, matrix);
       }
       if (node2.head.value === "cases") {
-        return new TypstCases(data);
+        return new TypstMatrixLike(TypstMatrixLike.CASES, matrix);
       }
       if (node2.head.value === "subarray") {
-        const align_node = node2.args[0];
-        switch (align_node.head.value) {
-          case "r":
-            data.forEach((row) => row[0].args.push(new TypstToken(7 /* CONTROL */, "&").toNode()));
-            break;
-          case "l":
-            data.forEach((row) => row[0].args.unshift(new TypstToken(7 /* CONTROL */, "&").toNode()));
-            break;
-          default:
-            break;
+        if (node2.data) {
+          const align_node = node2.data;
+          switch (align_node.head.value) {
+            case "r":
+              matrix.forEach((row) => row.push(TypstToken.EMPTY.toNode()));
+              break;
+            case "l":
+              matrix.forEach((row) => row.unshift(TypstToken.EMPTY.toNode()));
+              break;
+            default:
+              break;
+          }
         }
-        return new TypstAlign(data);
+        return new TypstMatrixLike(null, matrix);
       }
       if (node2.head.value === "array") {
         const np = { "delim": TYPST_NONE };
-        assert(node2.args.length > 0 && node2.args[0].head.type === 3 /* LITERAL */);
-        const np_new = convert_tex_array_align_literal(node2.args[0].head.value);
+        assert(node2.data !== null && node2.head.type === 3 /* LITERAL */);
+        const np_new = convert_tex_array_align_literal(node2.data.head.value);
         Object.assign(np, np_new);
-        const res = new TypstMatrix(data);
+        const res = new TypstMatrixLike(TypstMatrixLike.MAT, matrix);
         res.setOptions(np);
         return res;
       }
       if (node2.head.value.endsWith("matrix")) {
-        const res = new TypstMatrix(data);
+        const res = new TypstMatrixLike(TypstMatrixLike.MAT, matrix);
         let delim;
         switch (node2.head.value) {
           case "matrix":
@@ -3123,32 +3143,30 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "group": {
       const node = abstractNode;
-      const args = node.args.map(convert_typst_node_to_tex);
+      const args = node.items.map(convert_typst_node_to_tex);
       const alignment_char = new TexToken(7 /* CONTROL */, "&").toNode();
       const newline_char = new TexToken(7 /* CONTROL */, "\\\\").toNode();
       if (array_includes(args, alignment_char)) {
         const rows = array_split(args, newline_char);
-        const data = [];
+        const matrix = [];
         for (const row of rows) {
           const cells = array_split(row, alignment_char);
-          data.push(cells.map((cell) => new TexGroup(cell)));
+          matrix.push(cells.map((cell) => new TexGroup(cell)));
         }
-        return new TexBeginEnd(new TexToken(3 /* LITERAL */, "aligned"), [], data);
+        return new TexBeginEnd(new TexToken(3 /* LITERAL */, "aligned"), matrix);
       }
       return new TexGroup(args);
     }
     case "leftright": {
       const node = abstractNode;
-      const args = node.args.map(convert_typst_node_to_tex);
+      const body = convert_typst_node_to_tex(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()) {
         left.value = "\\left" + left.value;
         right.value = "\\right" + right.value;
       }
-      args.unshift(left.toNode());
-      args.push(right.toNode());
-      return new TexGroup(args);
+      return new TexGroup([left.toNode(), body, right.toNode()]);
     }
     case "funcCall": {
       const node = abstractNode;
@@ -3158,14 +3176,15 @@ 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 args = [convert_typst_node_to_tex(arg0)];
+          const body = convert_typst_node_to_tex(arg0);
           if (node.isOverHigh()) {
-            return new TexLeftRight(args, {
+            return new TexLeftRight({
+              body,
               left: new TexToken(2 /* COMMAND */, "\\|"),
               right: new TexToken(2 /* COMMAND */, "\\|")
             });
           } else {
-            return new TexGroup(args);
+            return body;
           }
         }
         // special hook for floor, ceil
@@ -3178,16 +3197,17 @@ 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 typ_arg0 = convert_typst_node_to_tex(arg0);
+          const body = convert_typst_node_to_tex(arg0);
           const left_node = new TexToken(2 /* COMMAND */, left);
           const right_node = new TexToken(2 /* COMMAND */, right);
           if (node.isOverHigh()) {
-            return new TexLeftRight([typ_arg0], {
+            return new TexLeftRight({
+              body,
               left: left_node,
               right: right_node
             });
           } else {
-            return new TexGroup([left_node.toNode(), typ_arg0, right_node.toNode()]);
+            return new TexGroup([left_node.toNode(), body, right_node.toNode()]);
           }
         }
         // special hook for root
@@ -3208,8 +3228,8 @@ function convert_typst_node_to_tex(abstractNode) {
         // special hook for vec
         // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
         case "vec": {
-          const tex_data = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
-          return new TexBeginEnd(new TexToken(3 /* LITERAL */, "pmatrix"), [], tex_data);
+          const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+          return new TexBeginEnd(new TexToken(3 /* LITERAL */, "pmatrix"), tex_matrix);
         }
         // special hook for op
         case "op": {
@@ -3234,13 +3254,31 @@ function convert_typst_node_to_tex(abstractNode) {
         }
       }
     }
+    case "markupFunc": {
+      const node = abstractNode;
+      switch (node.head.value) {
+        case "#text": {
+          if (node.options && node.options["fill"]) {
+            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])]
+            );
+          }
+        }
+        case "#heading":
+        default:
+          throw new Error(`Unimplemented markup function: ${node.head.value}`);
+      }
+    }
     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;
       if (base.head.eq(new TypstToken(1 /* SYMBOL */, "limits"))) {
-        const body_in_limits = convert_typst_node_to_tex(base.args[0]);
+        const limits = base;
+        const body_in_limits = convert_typst_node_to_tex(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) {
@@ -3258,50 +3296,51 @@ function convert_typst_node_to_tex(abstractNode) {
       });
       return res;
     }
-    case "matrix": {
+    case "matrixLike": {
       const node = abstractNode;
-      const tex_data = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
-      let env_type = "pmatrix";
-      if (node.options) {
-        if ("delim" in node.options) {
-          const delim = node.options.delim;
-          switch (delim.head.value) {
-            case "#none":
-              env_type = "matrix";
-              break;
-            case "[":
-            case "]":
-              env_type = "bmatrix";
-              break;
-            case "(":
-            case ")":
-              env_type = "pmatrix";
-              break;
-            case "{":
-            case "}":
-              env_type = "Bmatrix";
-              break;
-            case "|":
-              env_type = "vmatrix";
-              break;
-            case "bar":
-            case "bar.v":
-              env_type = "vmatrix";
-              break;
-            case "bar.v.double":
-              env_type = "Vmatrix";
-              break;
-            default:
-              throw new Error(`Unexpected delimiter ${delim.head}`);
+      const tex_matrix = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
+      if (node.head.eq(TypstMatrixLike.MAT)) {
+        let env_type = "pmatrix";
+        if (node.options) {
+          if ("delim" in node.options) {
+            const delim = node.options.delim;
+            switch (delim.head.value) {
+              case "#none":
+                env_type = "matrix";
+                break;
+              case "[":
+              case "]":
+                env_type = "bmatrix";
+                break;
+              case "(":
+              case ")":
+                env_type = "pmatrix";
+                break;
+              case "{":
+              case "}":
+                env_type = "Bmatrix";
+                break;
+              case "|":
+                env_type = "vmatrix";
+                break;
+              case "bar":
+              case "bar.v":
+                env_type = "vmatrix";
+                break;
+              case "bar.v.double":
+                env_type = "Vmatrix";
+                break;
+              default:
+                throw new Error(`Unexpected delimiter ${delim.head}`);
+            }
           }
         }
+        return new TexBeginEnd(new TexToken(3 /* LITERAL */, env_type), tex_matrix);
+      } else if (node.head.eq(TypstMatrixLike.CASES)) {
+        return new TexBeginEnd(new TexToken(3 /* LITERAL */, "cases"), tex_matrix);
+      } else {
+        throw new Error(`Unexpected matrix type ${node.head}`);
       }
-      return new TexBeginEnd(new TexToken(3 /* LITERAL */, env_type), [], tex_data);
-    }
-    case "cases": {
-      const node = abstractNode;
-      const tex_data = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
-      return new TexBeginEnd(new TexToken(3 /* LITERAL */, "cases"), [], tex_data);
     }
     case "fraction": {
       const node = abstractNode;
@@ -3376,10 +3415,10 @@ var rules_map2 = /* @__PURE__ */ new Map([
       new TypstToken(2 /* ELEMENT */, ")")
     ];
   }],
-  [String.raw`[a-zA-Z\.]+`, (s) => {
+  [String.raw`#none`, (s) => new TypstToken(0 /* NONE */, s.text())],
+  [String.raw`#?[a-zA-Z\.]+`, (s) => {
     return new TypstToken(s.text().length === 1 ? 2 /* ELEMENT */ : 1 /* SYMBOL */, s.text());
   }],
-  [String.raw`#none`, (s) => new TypstToken(0 /* NONE */, s.text())],
   [String.raw`.`, (s) => new TypstToken(2 /* ELEMENT */, s.text())]
 ]);
 var spec2 = {
@@ -3518,10 +3557,10 @@ function process_operators(nodes, parenthesis = false) {
         }
         let numerator = args.pop();
         if (denominator.type === "leftright") {
-          denominator = new TypstGroup(denominator.args);
+          denominator = denominator.body;
         }
         if (numerator.type === "leftright") {
-          numerator = new TypstGroup(numerator.args);
+          numerator = numerator.body;
         }
         args.push(new TypstFraction([numerator, denominator]));
         stack.pop();
@@ -3530,16 +3569,23 @@ function process_operators(nodes, parenthesis = false) {
       }
     }
   }
+  const body = args.length === 1 ? args[0] : new TypstGroup(args);
   if (parenthesis) {
-    return new TypstLeftright(null, args, { left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
+    return new TypstLeftright(null, { body, left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
   } else {
-    if (args.length === 1) {
-      return args[0];
-    } else {
-      return new TypstGroup(args);
-    }
+    return body;
   }
 }
+function parse_named_params(groups) {
+  const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
+  const np = {};
+  for (const group of groups) {
+    assert(group.items.length == 3);
+    assert(group.items[1].eq(COLON));
+    np[group.items[0].toString()] = new TypstTerminal(new TypstToken(3 /* LITERAL */, group.items[2].toString()));
+  }
+  return np;
+}
 var TypstParserError = class extends Error {
   constructor(message) {
     super(message);
@@ -3653,19 +3699,31 @@ var TypstParser = class {
       if (start + 1 < tokens.length && tokens[start + 1].eq(LEFT_PARENTHESES)) {
         if (firstToken.value === "mat") {
           const [matrix, named_params, newPos2] = this.parseMatrix(tokens, start + 1, SEMICOLON, COMMA);
-          const mat = new TypstMatrix(matrix);
+          const mat = new TypstMatrixLike(firstToken, matrix);
           mat.setOptions(named_params);
           return [mat, newPos2];
         }
         if (firstToken.value === "cases") {
           const [cases, named_params, newPos2] = this.parseMatrix(tokens, start + 1, COMMA, CONTROL_AND);
-          const casesNode = new TypstCases(cases);
+          const casesNode = new TypstMatrixLike(firstToken, cases);
           casesNode.setOptions(named_params);
           return [casesNode, newPos2];
         }
         if (firstToken.value === "lr") {
           return this.parseLrArguments(tokens, start + 1);
         }
+        if (["#heading", "#text"].includes(firstToken.value)) {
+          const [args2, newPos2] = this.parseArguments(tokens, start + 1);
+          const named_params = parse_named_params(args2);
+          assert(tokens[newPos2].eq(LEFT_BRACKET));
+          const DOLLAR = new TypstToken(2 /* ELEMENT */, "$");
+          const end = _find_closing_match(tokens, newPos2 + 1, [DOLLAR], [DOLLAR]);
+          const [group, _] = this.parseGroup(tokens, newPos2 + 2, end);
+          assert(tokens[end + 1].eq(RIGHT_BRACKET));
+          const markup_func = new TypstMarkupFunc(firstToken, [group]);
+          markup_func.setOptions(named_params);
+          return [markup_func, end + 2];
+        }
         const [args, newPos] = this.parseArguments(tokens, start + 1);
         const func_call = new TypstFuncCall(firstToken, args);
         return [func_call, newPos];
@@ -3687,13 +3745,13 @@ var TypstParser = class {
       const inner_end = find_closing_delim(tokens, inner_start);
       const inner_args = this.parseArgumentsWithSeparator(tokens, inner_start + 1, inner_end, COMMA);
       return [
-        new TypstLeftright(lr_token, inner_args, { left: tokens[inner_start], right: tokens[inner_end] }),
+        new TypstLeftright(lr_token, { body: new TypstGroup(inner_args), left: tokens[inner_start], right: tokens[inner_end] }),
         end + 1
       ];
     } else {
       const [args, end] = this.parseArguments(tokens, start);
       return [
-        new TypstLeftright(lr_token, args, { left: null, right: null }),
+        new TypstLeftright(lr_token, { body: new TypstGroup(args), left: null, right: null }),
         end
       ];
     }
@@ -3716,17 +3774,17 @@ var TypstParser = class {
               continue;
             }
             const g = arr[i];
-            const pos_colon = array_find(g.args, COLON);
+            const pos_colon = array_find(g.items, COLON);
             if (pos_colon === -1 || pos_colon === 0) {
               continue;
             }
             to_delete.push(i);
-            const param_name = g.args[pos_colon - 1];
+            const param_name = g.items[pos_colon - 1];
             if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
-              if (g.args.length !== 3) {
+              if (g.items.length !== 3) {
                 throw new TypstParserError("Invalid number of arguments for delim");
               }
-              np2["delim"] = g.args[pos_colon + 1];
+              np2["delim"] = g.items[pos_colon + 1];
             } else {
               throw new TypstParserError("Not implemented for other named parameters");
             }