tex2typst 0.3.10 → 0.3.12

package/README.md

@@ -32,7 +32,7 @@ Replace `0.3.0` with the latest version number in case this README is outdated.
 ```javascript
 import { tex2typst, typst2tex } from 'tex2typst';
 
-let tex = "e \overset{\text{def}}{=} \lim_{{n \to \infty}} \left(1 + \frac{1}{n}\right)^n";
+let tex = "e \\overset{\\text{def}}{=} \\lim_{{n \\to \\infty}} \left(1 + \\frac{1}{n}\\right)^n";
 let typst = tex2typst(tex);
 console.log(typst);
 // e eq.def lim_(n -> infinity)(1 + 1/n)^n

package/dist/index.js

@@ -1292,16 +1292,18 @@ var TypstToken = class {
   }
   toNode() {
     switch (this.type) {
-      case 2 /* TEXT */:
+      case 0 /* NONE */:
+        return new TypstNode("none", "#none");
+      case 3 /* TEXT */:
         return new TypstNode("text", this.value);
-      case 3 /* COMMENT */:
+      case 4 /* COMMENT */:
         return new TypstNode("comment", this.value);
-      case 4 /* SPACE */:
+      case 5 /* SPACE */:
       case 7 /* NEWLINE */:
         return new TypstNode("whitespace", this.value);
-      case 1 /* ELEMENT */:
+      case 2 /* ELEMENT */:
         return new TypstNode("atom", this.value);
-      case 0 /* SYMBOL */:
+      case 1 /* SYMBOL */:
         return new TypstNode("symbol", this.value);
       case 6 /* CONTROL */: {
         const controlChar = this.value;
@@ -1309,7 +1311,7 @@ var TypstToken = class {
           case "":
           case "_":
           case "^":
-            return new TypstNode("empty", "");
+            throw new Error(`Should not convert ${controlChar} to a node`);
           case "&":
             return new TypstNode("control", "&");
           case "\\":
@@ -1324,17 +1326,15 @@ var TypstToken = class {
   }
   toString() {
     switch (this.type) {
-      case 2 /* TEXT */:
+      case 3 /* TEXT */:
         return `"${this.value}"`;
-      case 3 /* COMMENT */:
+      case 4 /* COMMENT */:
         return `//${this.value}`;
       default:
         return this.value;
     }
   }
 };
-var TYPST_NULL = null;
-var TYPST_TRUE = true;
 var TypstNode = class {
   constructor(type, content, args, data) {
     this.type = type;
@@ -1374,6 +1374,8 @@ var TypstNode = class {
     }
   }
 };
+var TYPST_NONE = new TypstNode("none", "#none");
+var TYPST_TRUE = true;
 
 // src/util.ts
 function isalpha(char) {
@@ -1807,9 +1809,12 @@ var rules_map = /* @__PURE__ */ new Map([
     const command = s.text();
     return [new TexToken(1 /* COMMAND */, command)];
   }],
-  [String.raw`[0-9]+`, (s) => new TexToken(0 /* ELEMENT */, 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())],
   [String.raw`[+\-*/='<>!.,;:?()\[\]|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
+  // non-ASCII characters
+  [String.raw`[^\x00-\x7F]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
   [String.raw`.`, (s) => new TexToken(7 /* UNKNOWN */, s.text())]
 ]);
 var spec = {
@@ -1856,9 +1861,7 @@ var LatexParser = class {
       results.push(res);
     }
     let node;
-    if (results.length === 0) {
-      node = EMPTY_NODE;
-    } else if (results.length === 1) {
+    if (results.length === 1) {
       node = results[0];
     } else {
       node = new TexNode("ordgroup", "", results);
@@ -2232,10 +2235,10 @@ for (const [key, value] of shorthandMap.entries()) {
 function is_delimiter(c) {
   return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
 }
-var TYPST_LEFT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, "(");
-var TYPST_RIGHT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, ")");
-var TYPST_COMMA = new TypstToken(1 /* ELEMENT */, ",");
-var TYPST_NEWLINE = new TypstToken(0 /* SYMBOL */, "\n");
+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");
 function typst_primitive_to_string(value) {
   switch (typeof value) {
     case "string":
@@ -2245,12 +2248,8 @@ function typst_primitive_to_string(value) {
     case "boolean":
       return value ? "#true" : "#false";
     default:
-      if (value === null) {
-        return "#none";
-      } else if (value instanceof TypstToken) {
-        return value.toString();
-      }
-      throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
+      assert(value instanceof TypstNode, "Not a valid primitive value");
+      return value.content;
   }
 }
 var TypstWriterError = class extends Error {
@@ -2296,13 +2295,14 @@ var TypstWriter = class {
   // Serialize a tree of TypstNode into a list of TypstToken
   serialize(node) {
     switch (node.type) {
-      case "empty":
+      case "none":
+        this.queue.push(new TypstToken(0 /* NONE */, "#none"));
         break;
       case "atom": {
         if (node.content === "," && this.insideFunctionDepth > 0) {
-          this.queue.push(new TypstToken(0 /* SYMBOL */, "comma"));
+          this.queue.push(new TypstToken(1 /* SYMBOL */, "comma"));
         } else {
-          this.queue.push(new TypstToken(1 /* ELEMENT */, node.content));
+          this.queue.push(new TypstToken(2 /* ELEMENT */, node.content));
         }
         break;
       }
@@ -2316,23 +2316,23 @@ var TypstWriter = class {
         if (this.inftyToOo && content === "infinity") {
           content = "oo";
         }
-        this.queue.push(new TypstToken(0 /* SYMBOL */, content));
+        this.queue.push(new TypstToken(1 /* SYMBOL */, content));
         break;
       }
       case "text":
-        this.queue.push(new TypstToken(2 /* TEXT */, node.content));
+        this.queue.push(new TypstToken(3 /* TEXT */, node.content));
         break;
       case "comment":
-        this.queue.push(new TypstToken(3 /* COMMENT */, node.content));
+        this.queue.push(new TypstToken(4 /* COMMENT */, node.content));
         break;
       case "whitespace":
         for (const c of node.content) {
           if (c === " ") {
             if (this.keepSpaces) {
-              this.queue.push(new TypstToken(4 /* SPACE */, c));
+              this.queue.push(new TypstToken(5 /* SPACE */, c));
             }
           } else if (c === "\n") {
-            this.queue.push(new TypstToken(0 /* SYMBOL */, c));
+            this.queue.push(new TypstToken(1 /* SYMBOL */, c));
           } else {
             throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
           }
@@ -2349,15 +2349,15 @@ var TypstWriter = class {
         let trailing_space_needed = false;
         const has_prime = sup && sup.type === "atom" && sup.content === "'";
         if (has_prime) {
-          this.queue.push(new TypstToken(1 /* ELEMENT */, "'"));
+          this.queue.push(new TypstToken(2 /* ELEMENT */, "'"));
           trailing_space_needed = false;
         }
         if (sub) {
-          this.queue.push(new TypstToken(1 /* ELEMENT */, "_"));
+          this.queue.push(new TypstToken(2 /* ELEMENT */, "_"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
         }
         if (sup && !has_prime) {
-          this.queue.push(new TypstToken(1 /* ELEMENT */, "^"));
+          this.queue.push(new TypstToken(2 /* ELEMENT */, "^"));
           trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
         }
         if (trailing_space_needed) {
@@ -2366,24 +2366,28 @@ var TypstWriter = class {
         break;
       }
       case "funcCall": {
-        const func_symbol = new TypstToken(0 /* SYMBOL */, node.content);
+        const func_symbol = new TypstToken(1 /* SYMBOL */, node.content);
         this.queue.push(func_symbol);
-        this.insideFunctionDepth++;
+        if (node.content !== "lr") {
+          this.insideFunctionDepth++;
+        }
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         for (let i = 0; i < node.args.length; i++) {
           this.serialize(node.args[i]);
           if (i < node.args.length - 1) {
-            this.queue.push(new TypstToken(1 /* ELEMENT */, ","));
+            this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
           }
         }
         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(0 /* SYMBOL */, `, ${key}: ${value_str}`));
+            this.queue.push(new TypstToken(1 /* SYMBOL */, `, ${key}: ${value_str}`));
           }
         }
         this.queue.push(TYPST_RIGHT_PARENTHESIS);
-        this.insideFunctionDepth--;
+        if (node.content !== "lr") {
+          this.insideFunctionDepth--;
+        }
         break;
       }
       case "fraction": {
@@ -2395,7 +2399,7 @@ var TypstWriter = class {
         } else {
           this.serialize(numerator);
         }
-        this.queue.push(new TypstToken(1 /* ELEMENT */, "/"));
+        this.queue.push(new TypstToken(2 /* ELEMENT */, "/"));
         if (denominator.type === "group") {
           this.queue.push(TYPST_LEFT_PARENTHESIS);
           this.serialize(denominator);
@@ -2410,35 +2414,35 @@ var TypstWriter = class {
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             if (j > 0) {
-              this.queue.push(new TypstToken(1 /* ELEMENT */, "&"));
+              this.queue.push(new TypstToken(2 /* ELEMENT */, "&"));
             }
             this.serialize(cell);
           });
           if (i < matrix.length - 1) {
-            this.queue.push(new TypstToken(0 /* SYMBOL */, "\\"));
+            this.queue.push(new TypstToken(1 /* SYMBOL */, "\\"));
           }
         });
         break;
       }
       case "matrix": {
         const matrix = node.data;
-        this.queue.push(new TypstToken(0 /* SYMBOL */, "mat"));
+        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)) {
             const value_str = typst_primitive_to_string(value);
-            this.queue.push(new TypstToken(0 /* SYMBOL */, `${key}: ${value_str}, `));
+            this.queue.push(new TypstToken(1 /* SYMBOL */, `${key}: ${value_str}, `));
           }
         }
         matrix.forEach((row, i) => {
           row.forEach((cell, j) => {
             this.serialize(cell);
             if (j < row.length - 1) {
-              this.queue.push(new TypstToken(1 /* ELEMENT */, ","));
+              this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
             } else {
               if (i < matrix.length - 1) {
-                this.queue.push(new TypstToken(1 /* ELEMENT */, ";"));
+                this.queue.push(new TypstToken(2 /* ELEMENT */, ";"));
               }
             }
           });
@@ -2449,23 +2453,23 @@ var TypstWriter = class {
       }
       case "cases": {
         const cases = node.data;
-        this.queue.push(new TypstToken(0 /* SYMBOL */, "cases"));
+        this.queue.push(new TypstToken(1 /* SYMBOL */, "cases"));
         this.insideFunctionDepth++;
         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(0 /* SYMBOL */, `${key}: ${value_str}, `));
+            this.queue.push(new TypstToken(1 /* SYMBOL */, `${key}: ${value_str}, `));
           }
         }
         cases.forEach((row, i) => {
           row.forEach((cell, j) => {
             this.serialize(cell);
             if (j < row.length - 1) {
-              this.queue.push(new TypstToken(1 /* ELEMENT */, "&"));
+              this.queue.push(new TypstToken(2 /* ELEMENT */, "&"));
             } else {
               if (i < cases.length - 1) {
-                this.queue.push(new TypstToken(1 /* ELEMENT */, ","));
+                this.queue.push(new TypstToken(2 /* ELEMENT */, ","));
               }
             }
           });
@@ -2476,7 +2480,7 @@ var TypstWriter = class {
       }
       case "unknown": {
         if (this.nonStrict) {
-          this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
+          this.queue.push(new TypstToken(1 /* SYMBOL */, node.content));
         } else {
           throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
         }
@@ -2489,10 +2493,14 @@ var TypstWriter = class {
   appendWithBracketsIfNeeded(node) {
     let need_to_wrap = ["group", "supsub", "empty"].includes(node.type);
     if (node.type === "group") {
-      const first = node.args[0];
-      const last = node.args[node.args.length - 1];
-      if (is_delimiter(first) && is_delimiter(last)) {
-        need_to_wrap = false;
+      if (node.args.length === 0) {
+        need_to_wrap = true;
+      } else {
+        const first = node.args[0];
+        const last = node.args[node.args.length - 1];
+        if (is_delimiter(first) && is_delimiter(last)) {
+          need_to_wrap = false;
+        }
       }
     }
     if (need_to_wrap) {
@@ -2618,7 +2626,7 @@ function convert_overset(node, options) {
 function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
     case "empty":
-      return new TypstNode("empty", "");
+      return TYPST_NONE;
     case "whitespace":
       return new TypstNode("whitespace", node.content);
     case "ordgroup":
@@ -2631,8 +2639,16 @@ function convert_tex_node_to_typst(node, options = {}) {
       return new TypstNode("atom", tex_token_to_typst(node.content));
     case "symbol":
       return new TypstNode("symbol", tex_token_to_typst(node.content));
-    case "text":
+    case "text": {
+      if (/[^\x00-\x7F]+/.test(node.content) && options.nonAsciiWrapper !== "") {
+        return new TypstNode(
+          "funcCall",
+          options.nonAsciiWrapper,
+          [new TypstNode("text", node.content)]
+        );
+      }
       return new TypstNode("text", node.content);
+    }
     case "comment":
       return new TypstNode("comment", node.content);
     case "supsub": {
@@ -2653,8 +2669,8 @@ function convert_tex_node_to_typst(node, options = {}) {
       const data = {
         base: convert_tex_node_to_typst(base, options)
       };
-      if (data.base.type === "empty") {
-        data.base = new TypstNode("text", "");
+      if (data.base.type === "none") {
+        data.base = new TypstNode("none", "");
       }
       if (sup) {
         data.sup = convert_tex_node_to_typst(sup, options);
@@ -2788,10 +2804,10 @@ function convert_tex_node_to_typst(node, options = {}) {
         return new TypstNode("cases", "", [], data);
       }
       if (node.content.endsWith("matrix")) {
-        let delim = null;
+        let delim;
         switch (node.content) {
           case "matrix":
-            delim = TYPST_NULL;
+            delim = TYPST_NONE;
             break;
           case "pmatrix":
             delim = "(";
@@ -2806,7 +2822,7 @@ function convert_tex_node_to_typst(node, options = {}) {
             delim = "|";
             break;
           case "Vmatrix": {
-            delim = new TypstToken(0 /* SYMBOL */, "bar.v.double");
+            delim = new TypstNode("symbol", "bar.v.double");
             break;
           }
           default:
@@ -2884,7 +2900,7 @@ function convert_typst_node_to_tex(node) {
     ]);
   }
   switch (node.type) {
-    case "empty":
+    case "none":
       return new TexNode("empty", "");
     case "whitespace":
       return new TexNode("whitespace", node.content);
@@ -3002,29 +3018,44 @@ function convert_typst_node_to_tex(node) {
       let env_type = "pmatrix";
       if (node.options) {
         if ("delim" in node.options) {
-          switch (node.options.delim) {
-            case TYPST_NULL:
-              env_type = "matrix";
-              break;
-            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";
+          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";
+            }
           }
         }
       }
@@ -3057,11 +3088,10 @@ function convert_typst_node_to_tex(node) {
 }
 
 // src/typst-parser.ts
-var TYPST_EMPTY_NODE = new TypstNode("empty", "");
 var TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
 function eat_primes2(tokens, start) {
   let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TypstToken(1 /* ELEMENT */, "'"))) {
+  while (pos < tokens.length && tokens[pos].eq(new TypstToken(2 /* ELEMENT */, "'"))) {
     pos += 1;
   }
   return pos - start;
@@ -3078,12 +3108,12 @@ function generate_regex_for_shorthands() {
 }
 var REGEX_SHORTHANDS = generate_regex_for_shorthands();
 var rules_map2 = /* @__PURE__ */ new Map([
-  [String.raw`//[^\n]*`, (s) => new TypstToken(3 /* COMMENT */, s.text().substring(2))],
-  [String.raw`/`, (s) => new TypstToken(1 /* ELEMENT */, s.text())],
+  [String.raw`//[^\n]*`, (s) => new TypstToken(4 /* 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(4 /* SPACE */, s.text())],
-  [String.raw`\\[$&#_]`, (s) => new TypstToken(1 /* ELEMENT */, s.text())],
+  [String.raw`\s+`, (s) => new TypstToken(5 /* SPACE */, s.text())],
+  [String.raw`\\[$&#_]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
   [String.raw`\\\n`, (s) => {
     return [
       new TypstToken(6 /* CONTROL */, "\\"),
@@ -3093,7 +3123,7 @@ var rules_map2 = /* @__PURE__ */ new Map([
   [String.raw`\\\s`, (s) => {
     return [
       new TypstToken(6 /* CONTROL */, "\\"),
-      new TypstToken(4 /* SPACE */, " ")
+      new TypstToken(5 /* SPACE */, " ")
     ];
   }],
   // this backslash is dummy and will be ignored in later stages
@@ -3103,7 +3133,7 @@ var rules_map2 = /* @__PURE__ */ new Map([
     (s) => {
       const text = s.text().substring(1, s.text().length - 1);
       text.replaceAll('\\"', '"');
-      return new TypstToken(2 /* TEXT */, text);
+      return new TypstToken(3 /* TEXT */, text);
     }
   ],
   [
@@ -3111,15 +3141,16 @@ var rules_map2 = /* @__PURE__ */ new Map([
     (s) => {
       const shorthand = s.text();
       const symbol = reverseShorthandMap.get(shorthand);
-      return new TypstToken(0 /* SYMBOL */, symbol);
+      return new TypstToken(1 /* SYMBOL */, symbol);
     }
   ],
-  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TypstToken(1 /* ELEMENT */, s.text())],
-  [String.raw`[+\-*/=\'<>!.,;?()\[\]|]`, (s) => new TypstToken(1 /* ELEMENT */, s.text())],
+  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
+  [String.raw`[+\-*/=\'<>!.,;?()\[\]|]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
   [String.raw`[a-zA-Z\.]+`, (s) => {
-    return new TypstToken(s.text().length === 1 ? 1 /* ELEMENT */ : 0 /* SYMBOL */, s.text());
+    return new TypstToken(s.text().length === 1 ? 2 /* ELEMENT */ : 1 /* SYMBOL */, s.text());
   }],
-  [String.raw`.`, (s) => new TypstToken(1 /* ELEMENT */, s.text())]
+  [String.raw`#none`, (s) => new TypstToken(0 /* NONE */, s.text())],
+  [String.raw`.`, (s) => new TypstToken(2 /* ELEMENT */, s.text())]
 ]);
 var spec2 = {
   "start": rules_map2
@@ -3193,7 +3224,7 @@ function next_non_whitespace(nodes, start) {
   while (pos < nodes.length && nodes[pos].type === "whitespace") {
     pos++;
   }
-  return pos === nodes.length ? TYPST_EMPTY_NODE : nodes[pos];
+  return pos === nodes.length ? null : nodes[pos];
 }
 function trim_whitespace_around_operators(nodes) {
   let after_operator = false;
@@ -3204,7 +3235,7 @@ function trim_whitespace_around_operators(nodes) {
       if (after_operator) {
         continue;
       }
-      if (next_non_whitespace(nodes, i + 1).eq(DIV)) {
+      if (next_non_whitespace(nodes, i + 1)?.eq(DIV)) {
         continue;
       }
     }
@@ -3263,9 +3294,7 @@ function process_operators(nodes, parenthesis = false) {
   if (parenthesis) {
     return new TypstNode("group", "parenthesis", args);
   } else {
-    if (args.length === 0) {
-      return TYPST_EMPTY_NODE;
-    } else if (args.length === 1) {
+    if (args.length === 1) {
       return args[0];
     } else {
       return new TypstNode("group", "", args);
@@ -3280,16 +3309,16 @@ var TypstParserError = class extends Error {
 };
 var SUB_SYMBOL2 = new TypstToken(6 /* CONTROL */, "_");
 var SUP_SYMBOL2 = new TypstToken(6 /* CONTROL */, "^");
-var LEFT_PARENTHESES = new TypstToken(1 /* ELEMENT */, "(");
-var RIGHT_PARENTHESES = new TypstToken(1 /* ELEMENT */, ")");
-var LEFT_BRACKET = new TypstToken(1 /* ELEMENT */, "[");
-var RIGHT_BRACKET = new TypstToken(1 /* ELEMENT */, "]");
-var LEFT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "{");
-var RIGHT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "}");
-var VERTICAL_BAR = new TypstToken(1 /* ELEMENT */, "|");
-var COMMA = new TypstToken(1 /* ELEMENT */, ",");
-var SEMICOLON = new TypstToken(1 /* ELEMENT */, ";");
-var SINGLE_SPACE = new TypstToken(4 /* SPACE */, " ");
+var LEFT_PARENTHESES = new TypstToken(2 /* ELEMENT */, "(");
+var RIGHT_PARENTHESES = new TypstToken(2 /* ELEMENT */, ")");
+var LEFT_BRACKET = new TypstToken(2 /* ELEMENT */, "[");
+var RIGHT_BRACKET = new TypstToken(2 /* ELEMENT */, "]");
+var LEFT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "{");
+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 TypstParser = class {
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
@@ -3319,9 +3348,7 @@ var TypstParser = class {
     if (parentheses) {
       node = process_operators(results, true);
     } else {
-      if (results.length === 0) {
-        node = TYPST_EMPTY_NODE;
-      } else if (results.length === 1) {
+      if (results.length === 1) {
         node = results[0];
       } else {
         node = process_operators(results);
@@ -3385,10 +3412,10 @@ var TypstParser = class {
       const pos_closing = find_closing_match2(tokens, start);
       return this.parseGroup(tokens, start + 1, pos_closing, true);
     }
-    if (firstToken.type === 1 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
+    if (firstToken.type === 2 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
       return [node, start + 1];
     }
-    if ([1 /* ELEMENT */, 0 /* SYMBOL */].includes(firstToken.type)) {
+    if ([2 /* ELEMENT */, 1 /* SYMBOL */].includes(firstToken.type)) {
       if (start + 1 < tokens.length && tokens[start + 1].eq(LEFT_PARENTHESES)) {
         if (firstToken.value === "mat") {
           const [matrix, named_params, newPos2] = this.parseGroupsOfArguments(tokens, start + 1);
@@ -3465,18 +3492,24 @@ var TypstParser = class {
             to_delete.push(i);
             const param_name = g.args[pos_colon - 1];
             if (param_name.eq(new TypstNode("symbol", "delim"))) {
-              if (g.args[pos_colon + 1].type === "text") {
-                np2["delim"] = g.args[pos_colon + 1].content;
-                if (g.args.length !== 3) {
-                  throw new TypstParserError("Invalid number of arguments for delim");
+              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;
                 }
-              } else if (g.args[pos_colon + 1].eq(new TypstNode("atom", "#"))) {
-                if (g.args.length !== 4 || !g.args[pos_colon + 2].eq(new TypstNode("symbol", "none"))) {
-                  throw new TypstParserError("Invalid number of arguments for delim");
+                case "symbol": {
+                  np2["delim"] = g.args[pos_colon + 1];
+                  break;
                 }
-                np2["delim"] = TYPST_NULL;
-              } else {
-                throw new TypstParserError("Not implemented for other types of delim");
+                default:
+                  throw new TypstParserError("Not implemented for other types of delim");
               }
             } else {
               throw new TypstParserError("Not implemented for other named parameters");
@@ -3521,9 +3554,7 @@ var TypstParser = class {
         nodes.push(argItem);
       }
       let arg;
-      if (nodes.length === 0) {
-        arg = TYPST_EMPTY_NODE;
-      } else if (nodes.length === 1) {
+      if (nodes.length === 1) {
         arg = nodes[0];
       } else {
         arg = process_operators(nodes);
@@ -3603,6 +3634,7 @@ function tex2typst(tex, options) {
     keepSpaces: false,
     fracToSlash: true,
     inftyToOo: false,
+    nonAsciiWrapper: "",
     customTexMacros: {}
   };
   if (options !== void 0) {