tex2typst 0.3.21 → 0.3.23

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
   ["displaystyle", "display"],
+  ["hspace", "#h"],
   ["|", "bar.v.double"],
-  ["!", "#h(-math.thin.amount)"],
   [",", "thin"],
   [":", "med"],
   [";", "thick"],
@@ -1056,7 +1056,6 @@ var reverseSymbolMap = /* @__PURE__ */ new Map();
 for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
   reverseSymbolMap.set(value, key);
 }
-reverseSymbolMap.set("dif", "mathrm{d}");
 reverseSymbolMap.set("oo", "infty");
 var typst_to_tex_map = /* @__PURE__ */ new Map([
   ["top", "top"],
@@ -1065,8 +1064,7 @@ var typst_to_tex_map = /* @__PURE__ */ new Map([
   ["hat", "hat"],
   ["upright", "mathrm"],
   ["bold", "boldsymbol"],
-  ["infinity", "infty"],
-  ["hyph.minus", "\\text{-}"]
+  ["infinity", "infty"]
 ]);
 for (const [key, value] of typst_to_tex_map) {
   reverseSymbolMap.set(key, value);
@@ -1108,7 +1106,7 @@ function array_split(array, sep) {
   res.push(current_slice);
   return res;
 }
-function array_join(array, sep) {
+function array_intersperse(array, sep) {
   const res = [];
   for (let i = 0; i < array.length; i++) {
     res.push(array[i]);
@@ -1130,10 +1128,8 @@ var TexToken = class {
   }
   toString() {
     switch (this.type) {
-      case 2 /* TEXT */:
-        return `\\text{${this.value}}`;
       case 3 /* COMMENT */:
-        return `%${this.value}`;
+        return "%" + this.value;
       default:
         return this.value;
     }
@@ -1156,14 +1152,6 @@ var TexNode = class {
   eq(other) {
     return this.type === other.type && this.content === other.content;
   }
-  toString() {
-    switch (this.type) {
-      case "text":
-        return `\\text{${this.content}}`;
-      default:
-        throw new Error(`toString() is not implemented for type ${this.type}`);
-    }
-  }
   serialize() {
     switch (this.type) {
       case "empty":
@@ -1175,8 +1163,15 @@ var TexNode = class {
       }
       case "symbol":
         return [new TexToken(1 /* COMMAND */, this.content)];
+      case "literal":
+        return [new TexToken(2 /* LITERAL */, this.content)];
       case "text":
-        return [new TexToken(2 /* TEXT */, this.content)];
+        return [
+          new TexToken(1 /* COMMAND */, "\\text"),
+          new TexToken(0 /* ELEMENT */, "{"),
+          new TexToken(2 /* LITERAL */, this.content),
+          new TexToken(0 /* ELEMENT */, "}")
+        ];
       case "comment":
         return [new TexToken(3 /* COMMENT */, this.content)];
       case "whitespace": {
@@ -1308,18 +1303,20 @@ var TypstToken = class {
     switch (this.type) {
       case 0 /* NONE */:
         return new TypstNode("none", "#none");
-      case 3 /* TEXT */:
+      case 3 /* LITERAL */:
+        return new TypstNode("literal", this.value);
+      case 4 /* TEXT */:
         return new TypstNode("text", this.value);
-      case 4 /* COMMENT */:
+      case 5 /* COMMENT */:
         return new TypstNode("comment", this.value);
-      case 5 /* SPACE */:
-      case 7 /* NEWLINE */:
+      case 6 /* SPACE */:
+      case 8 /* NEWLINE */:
         return new TypstNode("whitespace", this.value);
       case 2 /* ELEMENT */:
         return new TypstNode("atom", this.value);
       case 1 /* SYMBOL */:
         return new TypstNode("symbol", this.value);
-      case 6 /* CONTROL */: {
+      case 7 /* CONTROL */: {
         const controlChar = this.value;
         switch (controlChar) {
           case "":
@@ -1340,9 +1337,9 @@ var TypstToken = class {
   }
   toString() {
     switch (this.type) {
-      case 3 /* TEXT */:
+      case 4 /* TEXT */:
         return `"${this.value}"`;
-      case 4 /* COMMENT */:
+      case 5 /* COMMENT */:
         return `//${this.value}`;
       default:
         return this.value;
@@ -1387,6 +1384,16 @@ var TypstNode = class {
         return false;
     }
   }
+  toString() {
+    switch (this.type) {
+      case "text":
+        return `"${this.content}"`;
+      case "comment":
+        return `//${this.content}`;
+      default:
+        return this.content;
+    }
+  }
 };
 var TYPST_NONE = new TypstNode("none", "#none");
 
@@ -1403,8 +1410,10 @@ function assert(condition, message = "") {
 // src/jslex.ts
 var EOF = {};
 function matchcompare(m1, m2) {
-  if (m2.len !== m1.len) {
-    return m2.len - m1.len;
+  const m1_len = m1.reMatchArray[0].length;
+  const m2_len = m2.reMatchArray[0].length;
+  if (m2_len !== m1_len) {
+    return m2_len - m1_len;
   } else {
     return m1.index - m2.index;
   }
@@ -1423,6 +1432,7 @@ var Scanner = class {
     this._newstate = null;
     this._text = null;
     this._leng = null;
+    this._reMatchArray = null;
     this._input = input;
     this._lexer = lexer;
     this._state = lexer.states[0];
@@ -1436,6 +1446,9 @@ var Scanner = class {
   leng() {
     return this._leng;
   }
+  reMatchArray() {
+    return this._reMatchArray;
+  }
   /**
    * Position of in stream, line number and column number of match.
    */
@@ -1528,9 +1541,8 @@ var Scanner = class {
       if (mt !== null && mt[0].length > 0) {
         matches.push({
           index: i,
-          text: mt[0],
-          len: mt[0].length,
-          rule
+          rule,
+          reMatchArray: mt
         });
       }
     }
@@ -1540,22 +1552,24 @@ var Scanner = class {
     matches.sort(matchcompare);
     this._go = true;
     let result;
-    let m;
+    let matched_text;
     for (let j = 0, n = matches.length; j < n && this._go; j++) {
       this._offset = 0;
       this._less = null;
       this._go = false;
       this._newstate = null;
-      m = matches[j];
-      this._text = m.text;
-      this._leng = m.len;
+      const m = matches[j];
+      matched_text = m.reMatchArray[0];
+      this._text = matched_text;
+      this._leng = matched_text.length;
+      this._reMatchArray = m.reMatchArray;
       result = m.rule.action(this);
       if (this._newstate && this._newstate != this._state) {
         this._state = this._newstate;
         break;
       }
     }
-    const text = this._less === null ? m.text : m.text.substring(0, this._less);
+    const text = this._less === null ? matched_text : matched_text.substring(0, this._less);
     const len = text.length;
     this._pos += len + this._offset;
     const nlm = text.match(/\n/g);
@@ -1689,16 +1703,30 @@ function unescape(str) {
   return str;
 }
 var rules_map = /* @__PURE__ */ new Map([
+  // math `\begin{array}{cc}`
   [
-    String.raw`\\(text|operatorname|begin|end|hspace){.+?}`,
+    String.raw`\\begin{(array|subarry)}{(.+?)}`,
     (s) => {
-      const text = s.text();
-      const command = text.substring(0, text.indexOf("{"));
-      const text_inside = text.substring(text.indexOf("{") + 1, text.lastIndexOf("}"));
+      const match = s.reMatchArray();
       return [
-        new TexToken(1 /* COMMAND */, command),
+        new TexToken(1 /* COMMAND */, "\\begin"),
         new TexToken(6 /* CONTROL */, "{"),
-        new TexToken(2 /* TEXT */, unescape(text_inside)),
+        new TexToken(2 /* LITERAL */, match[1]),
+        new TexToken(6 /* CONTROL */, "}"),
+        new TexToken(6 /* CONTROL */, "{"),
+        new TexToken(2 /* LITERAL */, match[2]),
+        new TexToken(6 /* CONTROL */, "}")
+      ];
+    }
+  ],
+  [
+    String.raw`\\(text|operatorname|begin|end|hspace|array){(.+?)}`,
+    (s) => {
+      const match = s.reMatchArray();
+      return [
+        new TexToken(1 /* COMMAND */, "\\" + match[1]),
+        new TexToken(6 /* CONTROL */, "{"),
+        new TexToken(2 /* LITERAL */, unescape(match[2])),
         new TexToken(6 /* CONTROL */, "}")
       ];
     }
@@ -1711,10 +1739,7 @@ var rules_map = /* @__PURE__ */ new Map([
   [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
   // e.g. match `\frac13`, `\frac1 b`, `\frac a b`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`, (s) => {
-    const text = s.text();
-    const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`);
-    const match = text.match(regex);
-    assert(match !== null);
+    const match = s.reMatchArray();
     const command = match[1];
     if (TEX_BINARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
@@ -1731,10 +1756,7 @@ var rules_map = /* @__PURE__ */ new Map([
   }],
   // e.g. match `\sqrt3`, `\sqrt a`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
-    const text = s.text();
-    const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`);
-    const match = text.match(regex);
-    assert(match !== null);
+    const match = s.reMatchArray();
     const command = match[1];
     if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
@@ -1747,10 +1769,7 @@ var rules_map = /* @__PURE__ */ new Map([
       return [];
     }
   }],
-  [String.raw`\\[a-zA-Z]+`, (s) => {
-    const command = s.text();
-    return [new TexToken(1 /* COMMAND */, command)];
-  }],
+  [String.raw`\\[a-zA-Z]+`, (s) => new TexToken(1 /* COMMAND */, s.text())],
   // Numbers like "123", "3.14"
   [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
   [String.raw`[a-zA-Z]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
@@ -1959,8 +1978,8 @@ var LatexParser = class {
     switch (firstToken.type) {
       case 0 /* ELEMENT */:
         return [new TexNode("element", firstToken.value), start + 1];
-      case 2 /* TEXT */:
-        return [new TexNode("text", firstToken.value), start + 1];
+      case 2 /* LITERAL */:
+        return [new TexNode("literal", firstToken.value), start + 1];
       case 3 /* COMMENT */:
         return [new TexNode("comment", firstToken.value), start + 1];
       case 4 /* SPACE */:
@@ -2041,7 +2060,7 @@ var LatexParser = class {
             throw new LatexParserError("Expecting content for \\text command");
           }
           assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-          assert(tokens[pos + 1].type === 2 /* TEXT */);
+          assert(tokens[pos + 1].type === 2 /* LITERAL */);
           assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
           const text = tokens[pos + 1].value;
           return [new TexNode("text", text), pos + 3];
@@ -2122,21 +2141,20 @@ var LatexParser = class {
     assert(tokens[start].eq(BEGIN_COMMAND));
     let pos = start + 1;
     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-    assert(tokens[pos + 1].type === 2 /* TEXT */);
+    assert(tokens[pos + 1].type === 2 /* LITERAL */);
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     const envName = tokens[pos + 1].value;
     pos += 3;
     const args = [];
-    while (pos < tokens.length) {
-      const whitespaceCount = eat_whitespaces(tokens, pos).length;
-      pos += whitespaceCount;
+    if (["array", "subarray"].includes(envName)) {
       if (pos >= tokens.length || !tokens[pos].eq(LEFT_CURLY_BRACKET)) {
-        break;
+        throw new LatexParserError(`Missing arg for \\begin{${envName}}`);
       }
       const [arg, newPos] = this.parseNextArg(tokens, pos);
       args.push(arg);
       pos = newPos;
     }
+    pos += eat_whitespaces(tokens, pos).length;
     const exprInsideStart = pos;
     const endIdx = find_closing_end_command(tokens, start);
     if (endIdx === -1) {
@@ -2145,7 +2163,7 @@ var LatexParser = class {
     const exprInsideEnd = endIdx;
     pos = endIdx + 1;
     assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
-    assert(tokens[pos + 1].type === 2 /* TEXT */);
+    assert(tokens[pos + 1].type === 2 /* LITERAL */);
     assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
     if (tokens[pos + 1].value !== envName) {
       throw new LatexParserError("Mismatched \\begin and \\end environments");
@@ -2282,20 +2300,7 @@ var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
 var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
 var TYPST_COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(1 /* SYMBOL */, "\n");
-var SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
-function typst_primitive_to_string(value) {
-  switch (typeof value) {
-    case "string":
-      return `"${value}"`;
-    case "number":
-      return value.toString();
-    case "boolean":
-      return value ? "#true" : "#false";
-    default:
-      assert(value instanceof TypstNode, "Not a valid primitive value");
-      return value.content;
-  }
-}
+var SOFT_SPACE = new TypstToken(7 /* CONTROL */, " ");
 var TypstWriterError = class extends Error {
   constructor(message, node) {
     super(message);
@@ -2364,17 +2369,20 @@ var TypstWriter = class {
         this.queue.push(new TypstToken(1 /* SYMBOL */, content));
         break;
       }
+      case "literal":
+        this.queue.push(new TypstToken(3 /* LITERAL */, node.content));
+        break;
       case "text":
-        this.queue.push(new TypstToken(3 /* TEXT */, node.content));
+        this.queue.push(new TypstToken(4 /* TEXT */, node.content));
         break;
       case "comment":
-        this.queue.push(new TypstToken(4 /* COMMENT */, node.content));
+        this.queue.push(new TypstToken(5 /* COMMENT */, node.content));
         break;
       case "whitespace":
         for (const c of node.content) {
           if (c === " ") {
             if (this.keepSpaces) {
-              this.queue.push(new TypstToken(5 /* SPACE */, c));
+              this.queue.push(new TypstToken(6 /* SPACE */, c));
             }
           } else if (c === "\n") {
             this.queue.push(new TypstToken(1 /* SYMBOL */, c));
@@ -2425,8 +2433,7 @@ var TypstWriter = class {
         }
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            const value_str = typst_primitive_to_string(value);
-            this.queue.push(new TypstToken(1 /* SYMBOL */, `, ${key}: ${value_str}`));
+            this.queue.push(new TypstToken(3 /* LITERAL */, `, ${key}: ${value.toString()}`));
           }
         }
         this.queue.push(TYPST_RIGHT_PARENTHESIS);
@@ -2469,8 +2476,7 @@ var TypstWriter = class {
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            const value_str = typst_primitive_to_string(value);
-            this.queue.push(new TypstToken(1 /* SYMBOL */, `${key}: ${value_str}, `));
+            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
           }
         }
         matrix.forEach((row, i) => {
@@ -2496,8 +2502,7 @@ var TypstWriter = class {
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            const value_str = typst_primitive_to_string(value);
-            this.queue.push(new TypstToken(1 /* SYMBOL */, `${key}: ${value_str}, `));
+            this.queue.push(new TypstToken(3 /* LITERAL */, `${key}: ${value.toString()}, `));
           }
         }
         cases.forEach((row, i) => {
@@ -2529,7 +2534,7 @@ var TypstWriter = class {
     }
   }
   appendWithBracketsIfNeeded(node) {
-    let need_to_wrap = ["group", "supsub", "fraction", "empty"].includes(node.type);
+    let need_to_wrap = ["group", "supsub", "align", "fraction", "empty"].includes(node.type);
     if (node.type === "group") {
       if (node.args.length === 0) {
         need_to_wrap = true;
@@ -2555,7 +2560,7 @@ var TypstWriter = class {
     for (let i = 0; i < this.queue.length; i++) {
       let token = this.queue[i];
       if (token.eq(SOFT_SPACE)) {
-        const to_delete = i === 0 || i === this.queue.length - 1 || this.queue[i - 1].type === 5 /* SPACE */ || this.queue[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS, TYPST_NEWLINE]) || this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
+        const to_delete = i === 0 || i === this.queue.length - 1 || this.queue[i - 1].type === 6 /* SPACE */ || this.queue[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS, TYPST_NEWLINE]) || this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
         if (to_delete) {
           this.queue[i] = dummy_token;
         }
@@ -2669,6 +2674,35 @@ function convert_underset(node, options) {
     sub: convert_tex_node_to_typst(sub, options)
   });
 }
+function convert_tex_array_align_literal(alignLiteral) {
+  const np = {};
+  const alignMap = { l: "#left", c: "#center", r: "#right" };
+  const chars = Array.from(alignLiteral);
+  const vlinePositions = [];
+  let columnIndex = 0;
+  for (const c of chars) {
+    if (c === "|") {
+      vlinePositions.push(columnIndex);
+    } else if (c === "l" || c === "c" || c === "r") {
+      columnIndex++;
+    }
+  }
+  if (vlinePositions.length > 0) {
+    let augment_str;
+    if (vlinePositions.length === 1) {
+      augment_str = `#${vlinePositions[0]}`;
+    } else {
+      augment_str = `#(vline: (${vlinePositions.join(", ")}))`;
+    }
+    np["augment"] = new TypstNode("literal", augment_str);
+  }
+  const alignments = chars.map((c) => alignMap[c]).filter((x) => x !== void 0).map((s) => new TypstNode("literal", s));
+  if (alignments.length > 0) {
+    const all_same = alignments.every((item) => item.eq(alignments[0]));
+    np["align"] = all_same ? alignments[0] : new TypstNode("literal", "#center");
+  }
+  return np;
+}
 function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
     case "empty":
@@ -2695,6 +2729,8 @@ function convert_tex_node_to_typst(node, options = {}) {
       }
       return new TypstNode("text", node.content);
     }
+    case "literal":
+      return new TypstNode("literal", node.content);
     case "comment":
       return new TypstNode("comment", node.content);
     case "supsub": {
@@ -2829,22 +2865,10 @@ function convert_tex_node_to_typst(node, options = {}) {
             return new TypstNode("symbol", arg0.content);
           }
         }
-        return new TypstNode("funcCall", "op", [arg0]);
-      }
-      if (node.content === "\\hspace") {
-        const text = arg0.content;
-        return new TypstNode(
-          "funcCall",
-          "#h",
-          [new TypstNode("symbol", text)]
-        );
+        return new TypstNode("funcCall", "op", [new TypstNode("text", arg0.content)]);
       }
       if (node.content === "\\substack") {
-        return new TypstNode(
-          "group",
-          "",
-          [arg0]
-        );
+        return arg0;
       }
       if (options.optimize) {
         if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
@@ -2871,78 +2895,45 @@ function convert_tex_node_to_typst(node, options = {}) {
       }
       if (node.content === "subarray") {
         const align_node = node.args[0];
-        if (align_node.content == "r") {
-          data.forEach((row) => row[0].args.push(new TypstNode("symbol", "&")));
-        }
-        if (align_node.content == "l") {
-          data.forEach((row) => row[0].args.unshift(new TypstNode("symbol", "&")));
+        switch (align_node.content) {
+          case "r":
+            data.forEach((row) => row[0].args.push(new TypstNode("symbol", "&")));
+            break;
+          case "l":
+            data.forEach((row) => row[0].args.unshift(new TypstNode("symbol", "&")));
+            break;
+          default:
+            break;
         }
-        return new TypstNode(
-          "group",
-          "",
-          [new TypstNode("align", "", [], data)]
-        );
+        return new TypstNode("align", "", [], data);
       }
       if (node.content === "array") {
+        const np = { "delim": TYPST_NONE };
+        assert(node.args.length > 0 && node.args[0].type === "literal");
+        const np_new = convert_tex_array_align_literal(node.args[0].content);
+        Object.assign(np, np_new);
         const res = new TypstNode("matrix", "", [], data);
-        const options2 = { "delim": TYPST_NONE };
-        const align_args = node.args;
-        if (align_args.length > 0) {
-          const align_node = align_args[0];
-          const align_str = (() => {
-            if (align_node.type === "element") return align_node.content;
-            if (align_node.type === "ordgroup") {
-              return align_node.args.map((n) => n.type === "element" ? n.content : "").join("");
-            }
-            return "";
-          })();
-          if (align_str) {
-            const alignMap = { l: "#left", c: "#center", r: "#right" };
-            const chars = Array.from(align_str);
-            const alignments = chars.map((c) => alignMap[c]).filter(Boolean).map((s) => new TypstNode("symbol", s));
-            const vlinePositions = [];
-            let columnIndex = 0;
-            for (const c of chars) {
-              if (c === "|") {
-                vlinePositions.push(columnIndex);
-              } else if (c === "l" || c === "c" || c === "r") {
-                columnIndex++;
-              }
-            }
-            if (vlinePositions.length > 0) {
-              if (vlinePositions.length === 1) {
-                options2["augment"] = new TypstNode("symbol", `#${vlinePositions[0]}`);
-              } else {
-                options2["augment"] = new TypstNode("symbol", `#(vline: (${vlinePositions.join(", ")}))`);
-              }
-            }
-            if (alignments.length > 0) {
-              const first_align = alignments[0].content;
-              const all_same = alignments.every((item) => item.content === first_align);
-              options2["align"] = all_same ? alignments[0] : new TypstNode("symbol", "#center");
-            }
-          }
-        }
-        res.setOptions(options2);
+        res.setOptions(np);
         return res;
       }
       if (node.content.endsWith("matrix")) {
+        const res = new TypstNode("matrix", "", [], data);
         let delim;
         switch (node.content) {
           case "matrix":
             delim = TYPST_NONE;
             break;
           case "pmatrix":
-            delim = "(";
-            break;
+            return res;
+          // typst mat use delim:"(" by default
           case "bmatrix":
-            delim = "[";
+            delim = new TypstNode("text", "[");
             break;
           case "Bmatrix":
-            delim = "{";
+            delim = new TypstNode("text", "{");
             break;
           case "vmatrix":
-            delim = "|";
+            delim = new TypstNode("text", "|");
             break;
           case "Vmatrix": {
             delim = new TypstNode("symbol", "bar.v.double");
@@ -2951,7 +2942,6 @@ function convert_tex_node_to_typst(node, options = {}) {
           default:
             throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
         }
-        const res = new TypstNode("matrix", "", [], data);
         res.setOptions({ "delim": delim });
         return res;
       }
@@ -2962,6 +2952,10 @@ function convert_tex_node_to_typst(node, options = {}) {
     case "control":
       if (node.content === "\\\\") {
         return new TypstNode("symbol", "\\");
+      } else if (node.content === "\\!") {
+        return new TypstNode("funcCall", "#h", [
+          new TypstNode("literal", "-math.thin.amount")
+        ]);
       } else if (symbolMap.has(node.content.substring(1))) {
         const typst_symbol = symbolMap.get(node.content.substring(1));
         return new TypstNode("symbol", typst_symbol);
@@ -2972,34 +2966,6 @@ function convert_tex_node_to_typst(node, options = {}) {
       throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
   }
 }
-var TYPST_UNARY_FUNCTIONS = [
-  "sqrt",
-  "bold",
-  "arrow",
-  "upright",
-  "lr",
-  "op",
-  "macron",
-  "dot",
-  "dot.double",
-  "hat",
-  "tilde",
-  "overline",
-  "underline",
-  "bb",
-  "cal",
-  "frak",
-  "floor",
-  "ceil",
-  "norm",
-  "limits"
-];
-var TYPST_BINARY_FUNCTIONS = [
-  "frac",
-  "root",
-  "overbrace",
-  "underbrace"
-];
 function apply_escape_if_needed2(c) {
   if (["{", "}", "%"].includes(c)) {
     return "\\" + c;
@@ -3029,18 +2995,25 @@ function convert_typst_node_to_tex(node) {
       return new TexNode("whitespace", node.content);
     case "atom":
       return new TexNode("element", node.content);
-    case "symbol":
-      switch (node.content) {
-        // special hook for comma
-        case "comma":
-          return new TexNode("element", ",");
-        // special hook for hyph and hyph.minus
-        case "hyph":
-        case "hyph.minus":
-          return new TexNode("text", "-");
-        default:
-          return new TexNode("symbol", typst_token_to_tex(node.content));
+    case "symbol": {
+      if (node.content === "comma") {
+        return new TexNode("element", ",");
+      }
+      if (node.content === "dif") {
+        return new TexNode("unaryFunc", "\\mathrm", [new TexNode("element", "d")]);
       }
+      if (node.content === "hyph" || node.content === "hyph.minus") {
+        return new TexNode("text", "-");
+      }
+      if (/^([A-Z])\1$/.test(node.content)) {
+        return new TexNode("unaryFunc", "\\mathbb", [
+          new TexNode("element", node.content[0])
+        ]);
+      }
+      return new TexNode("symbol", typst_token_to_tex(node.content));
+    }
+    case "literal":
+      return new TexNode("literal", node.content);
     case "text":
       return new TexNode("text", node.content);
     case "comment":
@@ -3057,68 +3030,67 @@ function convert_typst_node_to_tex(node) {
       return new TexNode("ordgroup", node.content, args);
     }
     case "funcCall": {
-      if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
-        if (node.content === "lr") {
-          const data = node.data;
-          if (data.leftDelim !== null) {
-            let left_delim = apply_escape_if_needed2(data.leftDelim);
-            assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
-            let right_delim = apply_escape_if_needed2(data.rightDelim);
-            return new TexNode("ordgroup", "", [
-              new TexNode("element", "\\left" + left_delim),
-              ...node.args.map(convert_typst_node_to_tex),
-              new TexNode("element", "\\right" + right_delim)
-            ]);
-          } else {
-            return new TexNode("ordgroup", "", node.args.map(convert_typst_node_to_tex));
-          }
-        }
-        if (node.content === "norm") {
-          const arg0 = node.args[0];
-          const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
-          return new TexNode(tex_node_type, "", [
-            new TexNode("symbol", "\\|"),
-            convert_typst_node_to_tex(arg0),
-            new TexNode("symbol", "\\|")
-          ]);
-        }
-        if (node.content === "floor" || node.content === "ceil") {
-          const left = "\\l" + node.content;
-          const right = "\\r" + node.content;
-          const arg0 = node.args[0];
-          const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
-          return new TexNode(tex_node_type, "", [
-            new TexNode("symbol", left),
-            convert_typst_node_to_tex(arg0),
-            new TexNode("symbol", right)
+      if (node.content === "lr") {
+        const data = node.data;
+        if (data.leftDelim !== null) {
+          let left_delim = apply_escape_if_needed2(data.leftDelim);
+          assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
+          let right_delim = apply_escape_if_needed2(data.rightDelim);
+          return new TexNode("ordgroup", "", [
+            new TexNode("element", "\\left" + left_delim),
+            ...node.args.map(convert_typst_node_to_tex),
+            new TexNode("element", "\\right" + right_delim)
           ]);
+        } else {
+          return new TexNode("ordgroup", "", node.args.map(convert_typst_node_to_tex));
         }
-        const command = typst_token_to_tex(node.content);
-        return new TexNode("unaryFunc", command, node.args.map(convert_typst_node_to_tex));
-      } else if (TYPST_BINARY_FUNCTIONS.includes(node.content)) {
-        if (node.content === "root") {
-          const [degree, radicand] = node.args;
-          const data = convert_typst_node_to_tex(degree);
-          return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
-        }
-        if (node.content === "overbrace" || node.content === "underbrace") {
-          const [body, label] = node.args;
-          const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
-          const script = convert_typst_node_to_tex(label);
-          const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
-          return new TexNode("supsub", "", [], data);
-        }
-        const command = typst_token_to_tex(node.content);
-        return new TexNode("binaryFunc", command, node.args.map(convert_typst_node_to_tex));
+      }
+      if (node.content === "norm") {
+        const arg0 = node.args[0];
+        const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
+        return new TexNode(tex_node_type, "", [
+          new TexNode("symbol", "\\|"),
+          convert_typst_node_to_tex(arg0),
+          new TexNode("symbol", "\\|")
+        ]);
+      }
+      if (node.content === "floor" || node.content === "ceil") {
+        const left = "\\l" + node.content;
+        const right = "\\r" + node.content;
+        const arg0 = node.args[0];
+        const tex_node_type = node.isOverHigh() ? "leftright" : "ordgroup";
+        return new TexNode(tex_node_type, "", [
+          new TexNode("symbol", left),
+          convert_typst_node_to_tex(arg0),
+          new TexNode("symbol", right)
+        ]);
+      }
+      if (node.content === "root") {
+        const [degree, radicand] = node.args;
+        const data = convert_typst_node_to_tex(degree);
+        return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
+      }
+      if (node.content === "overbrace" || node.content === "underbrace") {
+        const [body, label] = node.args;
+        const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
+        const script = convert_typst_node_to_tex(label);
+        const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
+        return new TexNode("supsub", "", [], data);
+      }
+      if (node.content === "vec") {
+        const tex_data = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+        return new TexNode("beginend", "pmatrix", [], tex_data);
+      }
+      const func_name_tex = typst_token_to_tex(node.content);
+      if (func_name_tex.length > 0 && TEX_UNARY_COMMANDS.includes(func_name_tex.substring(1))) {
+        return new TexNode("unaryFunc", func_name_tex, node.args.map(convert_typst_node_to_tex));
+      } else if (func_name_tex.length > 0 && TEX_BINARY_COMMANDS.includes(func_name_tex.substring(1))) {
+        return new TexNode("binaryFunc", func_name_tex, node.args.map(convert_typst_node_to_tex));
       } else {
-        if (node.content === "vec") {
-          const tex_data = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
-          return new TexNode("beginend", "pmatrix", [], tex_data);
-        }
         return new TexNode("ordgroup", "", [
           new TexNode("symbol", typst_token_to_tex(node.content)),
           new TexNode("element", "("),
-          ...array_join(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+          ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
           new TexNode("element", ")")
         ]);
       }
@@ -3159,43 +3131,34 @@ function convert_typst_node_to_tex(node) {
       if (node.options) {
         if ("delim" in node.options) {
           const delim = node.options.delim;
-          if (delim instanceof TypstNode) {
-            switch (delim.content) {
-              case "#none":
-                env_type = "matrix";
-                break;
-              case "bar.v.double":
-                env_type = "Vmatrix";
-                break;
-              case "bar":
-              case "bar.v":
-                env_type = "vmatrix";
-                break;
-              default:
-                throw new Error(`Unexpected delimiter ${delim.content}`);
-            }
-          } else {
-            switch (delim) {
-              case "[":
-                env_type = "bmatrix";
-                break;
-              case "]":
-                env_type = "bmatrix";
-                break;
-              case "{":
-                env_type = "Bmatrix";
-                break;
-              case "}":
-                env_type = "Bmatrix";
-                break;
-              case "|":
-                env_type = "vmatrix";
-                break;
-              case ")":
-              case "(":
-              default:
-                env_type = "pmatrix";
-            }
+          switch (delim.content) {
+            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.content}`);
           }
         }
       }
@@ -3241,32 +3204,32 @@ function generate_regex_for_shorthands() {
 }
 var REGEX_SHORTHANDS = generate_regex_for_shorthands();
 var rules_map2 = /* @__PURE__ */ new Map([
-  [String.raw`//[^\n]*`, (s) => new TypstToken(4 /* COMMENT */, s.text().substring(2))],
+  [String.raw`//[^\n]*`, (s) => new TypstToken(5 /* COMMENT */, s.text().substring(2))],
   [String.raw`/`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
-  [String.raw`[_^&]`, (s) => new TypstToken(6 /* CONTROL */, s.text())],
-  [String.raw`\r?\n`, (_s) => new TypstToken(7 /* NEWLINE */, "\n")],
-  [String.raw`\s+`, (s) => new TypstToken(5 /* SPACE */, s.text())],
+  [String.raw`[_^&]`, (s) => new TypstToken(7 /* CONTROL */, s.text())],
+  [String.raw`\r?\n`, (_s) => new TypstToken(8 /* NEWLINE */, "\n")],
+  [String.raw`\s+`, (s) => new TypstToken(6 /* SPACE */, s.text())],
   [String.raw`\\[$&#_]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
   [String.raw`\\\n`, (s) => {
     return [
-      new TypstToken(6 /* CONTROL */, "\\"),
-      new TypstToken(7 /* NEWLINE */, "\n")
+      new TypstToken(7 /* CONTROL */, "\\"),
+      new TypstToken(8 /* NEWLINE */, "\n")
     ];
   }],
   [String.raw`\\\s`, (s) => {
     return [
-      new TypstToken(6 /* CONTROL */, "\\"),
-      new TypstToken(5 /* SPACE */, " ")
+      new TypstToken(7 /* CONTROL */, "\\"),
+      new TypstToken(6 /* SPACE */, " ")
     ];
   }],
   // this backslash is dummy and will be ignored in later stages
-  [String.raw`\\\S`, (_s) => new TypstToken(6 /* CONTROL */, "")],
+  [String.raw`\\\S`, (_s) => new TypstToken(7 /* CONTROL */, "")],
   [
     String.raw`"([^"]|(\\"))*"`,
     (s) => {
       const text = s.text().substring(1, s.text().length - 1);
       text.replaceAll('\\"', '"');
-      return new TypstToken(3 /* TEXT */, text);
+      return new TypstToken(4 /* TEXT */, text);
     }
   ],
   [
@@ -3279,6 +3242,15 @@ var rules_map2 = /* @__PURE__ */ new Map([
   ],
   [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
   [String.raw`[+\-*/=\'<>!.,;?()\[\]|]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
+  [String.raw`#h\((.+?)\)`, (s) => {
+    const match = s.reMatchArray();
+    return [
+      new TypstToken(1 /* SYMBOL */, "#h"),
+      new TypstToken(2 /* ELEMENT */, "("),
+      new TypstToken(3 /* LITERAL */, match[1]),
+      new TypstToken(2 /* ELEMENT */, ")")
+    ];
+  }],
   [String.raw`[a-zA-Z\.]+`, (s) => {
     return new TypstToken(s.text().length === 1 ? 2 /* ELEMENT */ : 1 /* SYMBOL */, s.text());
   }],
@@ -3449,8 +3421,8 @@ var TypstParserError = class extends Error {
     this.name = "TypstParserError";
   }
 };
-var SUB_SYMBOL2 = new TypstToken(6 /* CONTROL */, "_");
-var SUP_SYMBOL2 = new TypstToken(6 /* CONTROL */, "^");
+var SUB_SYMBOL2 = new TypstToken(7 /* CONTROL */, "_");
+var SUP_SYMBOL2 = new TypstToken(7 /* CONTROL */, "^");
 var LEFT_PARENTHESES = new TypstToken(2 /* ELEMENT */, "(");
 var RIGHT_PARENTHESES = new TypstToken(2 /* ELEMENT */, ")");
 var LEFT_BRACKET = new TypstToken(2 /* ELEMENT */, "[");
@@ -3460,7 +3432,7 @@ var RIGHT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "}");
 var VERTICAL_BAR = new TypstToken(2 /* ELEMENT */, "|");
 var COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(2 /* ELEMENT */, ";");
-var SINGLE_SPACE = new TypstToken(5 /* SPACE */, " ");
+var SINGLE_SPACE = new TypstToken(6 /* SPACE */, " ");
 var TypstParser = class {
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
@@ -3637,22 +3609,7 @@ var TypstParser = class {
               if (g.args.length !== 3) {
                 throw new TypstParserError("Invalid number of arguments for delim");
               }
-              switch (g.args[pos_colon + 1].type) {
-                case "text": {
-                  np2["delim"] = g.args[pos_colon + 1].content;
-                  break;
-                }
-                case "none": {
-                  np2["delim"] = TYPST_NONE;
-                  break;
-                }
-                case "symbol": {
-                  np2["delim"] = g.args[pos_colon + 1];
-                  break;
-                }
-                default:
-                  throw new TypstParserError("Not implemented for other types of delim");
-              }
+              np2["delim"] = g.args[pos_colon + 1];
             } else {
               throw new TypstParserError("Not implemented for other named parameters");
             }