tex2typst 0.3.17 → 0.3.19

package/README.md

@@ -1,6 +1,6 @@
 # tex2typst.js
 
-JavaScript library for conversion between TeX/LaTeX and Typst math formula code.
+JavaScript library for conversion between TeX/LaTeX and Typst math code.
 
 Despite the name `tex2typst` due to the initial goal of converting TeX to Typst, the library can also convert Typst to TeX since version 0.3.0.
 
@@ -44,7 +44,7 @@ console.log(tex_recovered);
 
 If you are using the library in a web page via a `<script>` tag, you don't need the line of `import`, function `tex2typst` and `typst2tex` should be available in the global scope.
 
-tex2typst.js supports some advanced options to customize the conversion. For more details, please refer to the [API Reference](docs/api-reference.md).
+tex2typst.js supports some advanced options to customize the conversion. For details, please refer to the [API Reference](docs/api-reference.md).
 
 ## Open-source license
 

package/dist/index.js

@@ -1,6 +1,8 @@
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
   ["displaystyle", "display"],
+  ["|", "bar.v.double"],
+  ["!", "#h(-math.thin.amount)"],
   [",", "thin"],
   [":", "med"],
   [";", "thick"],
@@ -1185,6 +1187,12 @@ var TexNode = class {
       case "ordgroup": {
         return this.args.map((n) => n.serialize()).flat();
       }
+      case "leftright": {
+        let tokens = this.args.map((n) => n.serialize()).flat();
+        tokens.splice(0, 0, new TexToken(1 /* COMMAND */, "\\left"));
+        tokens.splice(tokens.length - 1, 0, new TexToken(1 /* COMMAND */, "\\right"));
+        return tokens;
+      }
       case "unaryFunc": {
         let tokens = [];
         tokens.push(new TexToken(1 /* COMMAND */, this.content));
@@ -1625,8 +1633,8 @@ var JSLex = class {
   }
 };
 
-// src/tex-parser.ts
-var UNARY_COMMANDS = [
+// src/tex-tokenizer.ts
+var TEX_UNARY_COMMANDS = [
   "sqrt",
   "text",
   "bar",
@@ -1659,90 +1667,16 @@ var UNARY_COMMANDS = [
   "overrightarrow",
   "hspace"
 ];
-var BINARY_COMMANDS = [
+var TEX_BINARY_COMMANDS = [
   "frac",
   "tfrac",
   "binom",
   "dbinom",
   "dfrac",
   "tbinom",
-  "overset"
-];
-var IGNORED_COMMANDS = [
-  "bigl",
-  "bigr",
-  "biggl",
-  "biggr",
-  "Bigl",
-  "Bigr",
-  "Biggl",
-  "Biggr"
+  "overset",
+  "underset"
 ];
-var EMPTY_NODE = new TexNode("empty", "");
-function get_command_param_num(command) {
-  if (UNARY_COMMANDS.includes(command)) {
-    return 1;
-  } else if (BINARY_COMMANDS.includes(command)) {
-    return 2;
-  } else {
-    return 0;
-  }
-}
-var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
-var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
-var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
-var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
-function eat_whitespaces(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
-    pos++;
-  }
-  return tokens.slice(start, pos);
-}
-function eat_parenthesis(tokens, start) {
-  const firstToken = tokens[start];
-  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", "."].includes(firstToken.value)) {
-    return firstToken;
-  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
-    return firstToken;
-  } else {
-    return null;
-  }
-}
-function eat_primes(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
-    pos += 1;
-  }
-  return pos - start;
-}
-function find_closing_match(tokens, start, leftToken, rightToken) {
-  assert(tokens[start].eq(leftToken));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      return -1;
-    }
-    if (tokens[pos].eq(leftToken)) {
-      count += 1;
-    } else if (tokens[pos].eq(rightToken)) {
-      count -= 1;
-    }
-    pos += 1;
-  }
-  return pos - 1;
-}
-var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
-var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
-function find_closing_right_command(tokens, start) {
-  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
-}
-var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
-var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
-function find_closing_end_command(tokens, start) {
-  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
-}
 function unescape(str) {
   const chars = ["{", "}", "\\", "$", "&", "#", "_", "%"];
   for (const char of chars) {
@@ -1767,17 +1701,18 @@ var rules_map = /* @__PURE__ */ new Map([
   ],
   [String.raw`%[^\n]*`, (s) => new TexToken(3 /* COMMENT */, s.text().substring(1))],
   [String.raw`[{}_^&]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
-  [String.raw`\\[\\,:; ]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
+  [String.raw`\\[\\,:;! ]`, (s) => new TexToken(6 /* CONTROL */, s.text())],
   [String.raw`\r?\n`, (_s) => new TexToken(5 /* NEWLINE */, "\n")],
   [String.raw`\s+`, (s) => new TexToken(4 /* SPACE */, s.text())],
   [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 command = match[1];
-    if (BINARY_COMMANDS.includes(command.substring(1))) {
+    if (TEX_BINARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       const arg2 = match[3];
       return [
@@ -1790,13 +1725,14 @@ var rules_map = /* @__PURE__ */ new Map([
       return [];
     }
   }],
+  // 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 command = match[1];
-    if (UNARY_COMMANDS.includes(command.substring(1))) {
+    if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       return [
         new TexToken(1 /* COMMAND */, command),
@@ -1826,6 +1762,83 @@ function tokenize_tex(input) {
   const lexer = new JSLex(spec);
   return lexer.collect(input);
 }
+
+// src/tex-parser.ts
+var IGNORED_COMMANDS = [
+  "bigl",
+  "bigr",
+  "biggl",
+  "biggr",
+  "Bigl",
+  "Bigr",
+  "Biggl",
+  "Biggr"
+];
+var EMPTY_NODE = new TexNode("empty", "");
+function get_command_param_num(command) {
+  if (TEX_UNARY_COMMANDS.includes(command)) {
+    return 1;
+  } else if (TEX_BINARY_COMMANDS.includes(command)) {
+    return 2;
+  } else {
+    return 0;
+  }
+}
+var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
+var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
+var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
+var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
+function eat_whitespaces(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
+    pos++;
+  }
+  return tokens.slice(start, pos);
+}
+function eat_parenthesis(tokens, start) {
+  const firstToken = tokens[start];
+  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
+    return firstToken;
+  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+    return firstToken;
+  } else {
+    return null;
+  }
+}
+function eat_primes(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
+    pos += 1;
+  }
+  return pos - start;
+}
+function find_closing_match(tokens, start, leftToken, rightToken) {
+  assert(tokens[start].eq(leftToken));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      return -1;
+    }
+    if (tokens[pos].eq(leftToken)) {
+      count += 1;
+    } else if (tokens[pos].eq(rightToken)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
+var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
+function find_closing_right_command(tokens, start) {
+  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
+}
+var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
+var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
+function find_closing_end_command(tokens, start) {
+  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
+}
 var LatexParserError = class extends Error {
   constructor(message) {
     super(message);
@@ -1973,6 +1986,7 @@ var LatexParser = class {
           case "}":
             throw new LatexParserError("Unmatched '}'");
           case "\\\\":
+          case "\\!":
           case "\\,":
           case "\\:":
           case "\\;":
@@ -2264,6 +2278,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":
@@ -2285,14 +2300,15 @@ var TypstWriterError = class extends Error {
   }
 };
 var TypstWriter = class {
-  constructor(opt) {
+  constructor(options) {
     this.buffer = "";
     this.queue = [];
     this.insideFunctionDepth = 0;
-    this.nonStrict = opt.nonStrict;
-    this.preferShorthands = opt.preferShorthands;
-    this.keepSpaces = opt.keepSpaces;
-    this.inftyToOo = opt.inftyToOo;
+    this.nonStrict = options.nonStrict;
+    this.preferShorthands = options.preferShorthands;
+    this.keepSpaces = options.keepSpaces;
+    this.inftyToOo = options.inftyToOo;
+    this.optimize = options.optimize;
   }
   writeBuffer(token) {
     const str = token.toString();
@@ -2386,7 +2402,7 @@ var TypstWriter = class {
           trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
         }
         if (trailing_space_needed) {
-          this.queue.push(new TypstToken(6 /* CONTROL */, " "));
+          this.queue.push(SOFT_SPACE);
         }
         break;
       }
@@ -2417,7 +2433,12 @@ var TypstWriter = class {
       }
       case "fraction": {
         const [numerator, denominator] = node.args;
-        this.appendWithBracketsIfNeeded(numerator);
+        const pos = this.queue.length;
+        const no_wrap = this.appendWithBracketsIfNeeded(numerator);
+        const wrapped = !no_wrap;
+        if (wrapped) {
+          this.queue.splice(pos, 0, SOFT_SPACE);
+        }
         this.queue.push(new TypstToken(2 /* ELEMENT */, "/"));
         this.appendWithBracketsIfNeeded(denominator);
         break;
@@ -2526,17 +2547,17 @@ var TypstWriter = class {
     return !need_to_wrap;
   }
   flushQueue() {
-    const SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
+    const dummy_token = new TypstToken(1 /* SYMBOL */, "");
     for (let i = 0; i < this.queue.length; i++) {
       let token = this.queue[i];
       if (token.eq(SOFT_SPACE)) {
-        if (i === this.queue.length - 1) {
-          this.queue[i].value = "";
-        } else if (this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE])) {
-          this.queue[i].value = "";
+        const to_delete = i === 0 || i === this.queue.length - 1 || this.queue[i - 1].isOneOf([TYPST_NEWLINE]) || this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
+        if (to_delete) {
+          this.queue[i] = dummy_token;
         }
       }
     }
+    this.queue = this.queue.filter((token) => !token.eq(dummy_token));
     this.queue.forEach((token) => {
       this.writeBuffer(token);
     });
@@ -2559,9 +2580,11 @@ var TypstWriter = class {
       res = res.replace(/round\(\)/g, 'round("")');
       return res;
     };
-    const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
-    for (const pass of all_passes) {
-      this.buffer = pass(this.buffer);
+    if (this.optimize) {
+      const all_passes = [smartFloorPass, smartCeilPass, smartRoundPass];
+      for (const pass of all_passes) {
+        this.buffer = pass(this.buffer);
+      }
     }
     return this.buffer;
   }
@@ -2583,8 +2606,6 @@ function tex_token_to_typst(token) {
     return token;
   } else if (token === "/") {
     return "\\/";
-  } else if (token === "\\|") {
-    return "parallel";
   } else if (token === "\\\\") {
     return "\\";
   } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
@@ -2601,39 +2622,48 @@ function tex_token_to_typst(token) {
 }
 function convert_overset(node, options) {
   const [sup, base] = node.args;
-  const is_def = (n) => {
-    if (n.eq(new TexNode("text", "def"))) {
-      return true;
-    }
-    if (n.type === "ordgroup" && n.args.length === 3) {
-      const [a1, a2, a3] = n.args;
-      const d = new TexNode("element", "d");
-      const e = new TexNode("element", "e");
-      const f = new TexNode("element", "f");
-      if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
+  if (options.optimize) {
+    const is_def = (n) => {
+      if (n.eq(new TexNode("text", "def"))) {
         return true;
       }
+      if (n.type === "ordgroup" && n.args.length === 3) {
+        const [a1, a2, a3] = n.args;
+        const d = new TexNode("element", "d");
+        const e = new TexNode("element", "e");
+        const f = new TexNode("element", "f");
+        if (a1.eq(d) && a2.eq(e) && a3.eq(f)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    const is_eq = (n) => n.eq(new TexNode("element", "="));
+    if (is_def(sup) && is_eq(base)) {
+      return new TypstNode("symbol", "eq.def");
     }
-    return false;
-  };
-  const is_eq = (n) => n.eq(new TexNode("element", "="));
-  if (is_def(sup) && is_eq(base)) {
-    return new TypstNode("symbol", "eq.def");
   }
   const limits_call = new TypstNode(
     "funcCall",
     "limits",
     [convert_tex_node_to_typst(base, options)]
   );
-  return new TypstNode(
-    "supsub",
-    "",
-    [],
-    {
-      base: limits_call,
-      sup: convert_tex_node_to_typst(sup, options)
-    }
+  return new TypstNode("supsub", "", [], {
+    base: limits_call,
+    sup: convert_tex_node_to_typst(sup, options)
+  });
+}
+function convert_underset(node, options) {
+  const [sub, base] = node.args;
+  const limits_call = new TypstNode(
+    "funcCall",
+    "limits",
+    [convert_tex_node_to_typst(base, options)]
   );
+  return new TypstNode("supsub", "", [], {
+    base: limits_call,
+    sub: convert_tex_node_to_typst(sub, options)
+  });
 }
 function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
@@ -2693,39 +2723,51 @@ function convert_tex_node_to_typst(node, options = {}) {
       return new TypstNode("supsub", "", [], data);
     }
     case "leftright": {
-      const [left, body, right] = node.args;
+      const [left, _body, right] = node.args;
+      const [typ_left, typ_body, typ_right] = node.args.map((n) => convert_tex_node_to_typst(n, options));
+      if (options.optimize) {
+        if (left.content === "\\|" && right.content === "\\|") {
+          return new TypstNode("funcCall", "norm", [typ_body]);
+        }
+        if ([
+          "[]",
+          "()",
+          "\\{\\}",
+          "\\lfloor\\rfloor",
+          "\\lceil\\rceil",
+          "\\lfloor\\rceil"
+        ].includes(left.content + right.content)) {
+          return new TypstNode("group", "", [typ_left, typ_body, typ_right]);
+        }
+      }
       const group = new TypstNode(
         "group",
         "",
-        node.args.map((n) => convert_tex_node_to_typst(n, options))
+        [typ_left, typ_body, typ_right]
       );
-      if ([
-        "[]",
-        "()",
-        "\\{\\}",
-        "\\lfloor\\rfloor",
-        "\\lceil\\rceil",
-        "\\lfloor\\rceil"
-      ].includes(left.content + right.content)) {
-        return group;
-      }
+      const escape_curly_or_paren = function(s) {
+        if (["(", ")", "{", "["].includes(s)) {
+          return "\\" + s;
+        } else {
+          return s;
+        }
+      };
       if (right.content === ".") {
-        group.args.pop();
-        return group;
+        typ_left.content = escape_curly_or_paren(typ_left.content);
+        group.args = [typ_left, typ_body];
       } else if (left.content === ".") {
-        group.args.shift();
-        return new TypstNode("funcCall", "lr", [group]);
+        typ_right.content = escape_curly_or_paren(typ_right.content);
+        group.args = [typ_body, typ_right];
       }
-      return new TypstNode(
-        "funcCall",
-        "lr",
-        [group]
-      );
+      return new TypstNode("funcCall", "lr", [group]);
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
         return convert_overset(node, options);
       }
+      if (node.content === "\\underset") {
+        return convert_underset(node, options);
+      }
       if (node.content === "\\frac") {
         if (options.fracToSlash) {
           return new TypstNode(
@@ -2781,16 +2823,13 @@ function convert_tex_node_to_typst(node, options = {}) {
         );
       }
       if (node.content === "\\operatorname") {
-        const text = arg0.content;
-        if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
-          return new TypstNode("symbol", text);
-        } else {
-          return new TypstNode(
-            "funcCall",
-            "op",
-            [arg0]
-          );
+        if (options.optimize) {
+          const text = arg0.content;
+          if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
+            return new TypstNode("symbol", text);
+          }
         }
+        return new TypstNode("funcCall", "op", [arg0]);
       }
       if (node.content === "\\hspace") {
         const text = arg0.content;
@@ -2922,7 +2961,9 @@ var TYPST_UNARY_FUNCTIONS = [
   "cal",
   "frak",
   "floor",
-  "ceil"
+  "ceil",
+  "norm",
+  "limits"
 ];
 var TYPST_BINARY_FUNCTIONS = [
   "frac",
@@ -2939,8 +2980,6 @@ function apply_escape_if_needed2(c) {
 function typst_token_to_tex(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
-  } else if (token === "thin") {
-    return "\\,";
   } else if (reverseSymbolMap.has(token)) {
     return "\\" + reverseSymbolMap.get(token);
   }
@@ -3005,15 +3044,21 @@ function convert_typst_node_to_tex(node) {
             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") {
-          let left = "\\l" + node.content;
-          let right = "\\r" + node.content;
+          const left = "\\l" + node.content;
+          const right = "\\r" + node.content;
           const arg0 = node.args[0];
-          if (arg0.isOverHigh()) {
-            left = "\\left" + left;
-            right = "\\right" + right;
-          }
-          return new TexNode("ordgroup", "", [
+          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)
@@ -3051,7 +3096,6 @@ function convert_typst_node_to_tex(node) {
     }
     case "supsub": {
       const { base, sup, sub } = node.data;
-      const base_tex = convert_typst_node_to_tex(base);
       let sup_tex;
       let sub_tex;
       if (sup) {
@@ -3060,6 +3104,18 @@ function convert_typst_node_to_tex(node) {
       if (sub) {
         sub_tex = convert_typst_node_to_tex(sub);
       }
+      if (base.eq(new TypstNode("funcCall", "limits"))) {
+        const body_in_limits = convert_typst_node_to_tex(base.args[0]);
+        if (sup_tex !== void 0 && sub_tex === void 0) {
+          return new TexNode("binaryFunc", "\\overset", [sup_tex, body_in_limits]);
+        } else if (sup_tex === void 0 && sub_tex !== void 0) {
+          return new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
+        } else {
+          const underset_call = new TexNode("binaryFunc", "\\underset", [sub_tex, body_in_limits]);
+          return new TexNode("binaryFunc", "\\overset", [sup_tex, underset_call]);
+        }
+      }
+      const base_tex = convert_typst_node_to_tex(base);
       const res = new TexNode("supsub", "", [], {
         base: base_tex,
         sup: sup_tex,
@@ -3142,15 +3198,8 @@ function convert_typst_node_to_tex(node) {
   }
 }
 
-// src/typst-parser.ts
+// src/typst-tokenizer.ts
 var TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
-function eat_primes2(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TypstToken(2 /* ELEMENT */, "'"))) {
-    pos += 1;
-  }
-  return pos - start;
-}
 function generate_regex_for_shorthands() {
   const regex_list = TYPST_SHORTHANDS.map((s) => {
     s = s.replaceAll("|", "\\|");
@@ -3214,6 +3263,15 @@ function tokenize_typst(input) {
   const lexer = new JSLex(spec2);
   return lexer.collect(input);
 }
+
+// src/typst-parser.ts
+function eat_primes2(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && tokens[pos].eq(new TypstToken(2 /* ELEMENT */, "'"))) {
+    pos += 1;
+  }
+  return pos - start;
+}
 function _find_closing_match(tokens, start, leftBrackets, rightBrackets) {
   assert(tokens[start].isOneOf(leftBrackets));
   let count = 1;
@@ -3684,11 +3742,11 @@ var TexWriter = class {
 function tex2typst(tex, options) {
   const opt = {
     nonStrict: true,
-    preferTypstIntrinsic: true,
     preferShorthands: true,
     keepSpaces: false,
     fracToSlash: true,
     inftyToOo: false,
+    optimize: true,
     nonAsciiWrapper: "",
     customTexMacros: {}
   };

package/dist/tex-parser.d.ts

@@ -1,5 +1,4 @@
 import { TexNode, TexToken } from "./types";
-export declare function tokenize_tex(input: string): TexToken[];
 export declare class LatexParserError extends Error {
     constructor(message: string);
 }

package/dist/tex-tokenizer.d.ts

@@ -0,0 +1,4 @@
+import { TexToken } from "./types";
+export declare const TEX_UNARY_COMMANDS: string[];
+export declare const TEX_BINARY_COMMANDS: string[];
+export declare function tokenize_tex(input: string): TexToken[];