tex2typst 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,5 +1,16 @@
 // src/map.ts
-var symbolMap = new Map([
+var symbolMap = /* @__PURE__ */ new Map([
+  ["cos", "cos"],
+  ["sin", "sin"],
+  ["tan", "tan"],
+  ["cot", "cot"],
+  ["sec", "sec"],
+  ["csc", "csc"],
+  ["mod", "mod"],
+  ["omicron", "omicron"],
+  ["Xi", "Xi"],
+  ["Upsilon", "Upsilon"],
+  ["lim", "lim"],
   ["nonumber", ""],
   ["vec", "arrow"],
   ["neq", "eq.not"],
@@ -10,13 +21,19 @@ var symbolMap = new Map([
   ["vdots", "dots.v"],
   ["ddots", "dots.down"],
   ["widehat", "hat"],
+  // Ideally, the result of \widehat should be longer than \hat. But it is not implemented now.
   ["widetilde", "tilde"],
+  // Ideally, the result of \widetilde should be longer than \tilde. But it is not implemented now.
   ["quad", "quad"],
   ["qquad", "wide"],
   ["overbrace", "overbrace"],
+  // same
   ["underbrace", "underbrace"],
+  // same
   ["overline", "overline"],
+  // same
   ["underline", "underline"],
+  // same
   ["bar", "macron"],
   ["dbinom", "binom"],
   ["tbinom", "binom"],
@@ -33,56 +50,36 @@ var symbolMap = new Map([
   ["mathsf", "sans"],
   ["mathtt", "mono"],
   ["rm", "upright"],
+  // TODO: \pmb need special logic to handle but it is not implemented now. See the commented test case.
   ["pmb", "bold"],
+  /* variants of plus,minus,times,divide */
   ["pm", "plus.minus"],
   ["mp", "minus.plus"],
   ["boxplus", "plus.square"],
   ["otimes", "times.circle"],
   ["boxtimes", "times.square"],
+  /* wave */
+  // tex: \sim \approx \cong \simeq \asymp \equiv \propto
+  // typst: tilde.op approx tilde.equiv tilde.eq ≍ equiv prop
   ["approx", "approx"],
   ["cong", "tilde.equiv"],
   ["simeq", "tilde.eq"],
-  ["asymp", "≍"],
+  ["asymp", "\u224D"],
+  // just use the unicode character :-)
   ["equiv", "equiv"],
   ["propto", "prop"],
+  /* arrows */
   ["gets", "arrow.l"],
-  ["hookleftarrow", "arrow.l.hook"],
-  ["leftharpoonup", "harpoon.lt"],
-  ["leftharpoondown", "harpoon.lb"],
-  ["rightleftharpoons", "harpoons.rtlb"],
-  ["longleftarrow", "arrow.l.long"],
-  ["longrightarrow", "arrow.r.long"],
-  ["longleftrightarrow", "arrow.l.r.long"],
-  ["Longleftarrow", "arrow.l.double.long"],
-  ["Longrightarrow", "arrow.r.double.long"],
-  ["Longleftrightarrow", "arrow.l.r.double.long"],
-  ["hookrightarrow", "arrow.r.hook"],
-  ["rightharpoonup", "harpoon.rt"],
-  ["rightharpoondown", "harpoon.rb"],
+  // ['longmapsto', 'arrow.r.bar'],
   ["iff", "arrow.l.r.double.long"],
   ["implies", "arrow.r.double.long"],
-  ["uparrow", "arrow.t"],
-  ["downarrow", "arrow.b"],
-  ["updownarrow", "arrow.t.b"],
-  ["Uparrow", "arrow.t.double"],
-  ["Downarrow", "arrow.b.double"],
-  ["Updownarrow", "arrow.t.b.double"],
-  ["nearrow", "arrow.tr"],
-  ["searrow", "arrow.br"],
-  ["swarrow", "arrow.bl"],
-  ["nwarrow", "arrow.tl"],
   ["leadsto", "arrow.squiggly"],
-  ["leftleftarrows", "arrows.ll"],
-  ["rightrightarrows", "arrows.rr"],
   ["Cap", "sect.double"],
   ["Cup", "union.double"],
   ["Delta", "Delta"],
   ["Gamma", "Gamma"],
   ["Join", "join"],
   ["Lambda", "Lambda"],
-  ["Leftarrow", "arrow.l.double"],
-  ["Leftrightarrow", "arrow.l.r.double"],
-  ["Longrightarrow", "arrow.r.double.long"],
   ["Omega", "Omega"],
   ["P", "pilcrow"],
   ["Phi", "Phi"],
@@ -94,26 +91,34 @@ var symbolMap = new Map([
   ["Theta", "Theta"],
   ["aleph", "alef"],
   ["alpha", "alpha"],
+  // ['amalg', 'product.co'], 
   ["angle", "angle"],
   ["approx", "approx"],
   ["approxeq", "approx.eq"],
+  // ['ast', 'ast'], 
   ["beta", "beta"],
   ["bigcap", "sect.big"],
   ["bigcirc", "circle.big"],
   ["bigcup", "union.big"],
   ["bigodot", "dot.circle.big"],
+  // ['bigoplus', 'xor.big'], // or "plus.circle.big"
   ["bigotimes", "times.circle.big"],
   ["bigsqcup", "union.sq.big"],
+  // ['bigtriangledown', 'triangle.b'], 
+  // ['bigtriangleup', 'triangle.t'], 
   ["biguplus", "union.plus.big"],
   ["bigvee", "or.big"],
   ["bigwedge", "and.big"],
+  // ['bowtie', 'join'], 
   ["bullet", "bullet"],
   ["cap", "sect"],
   ["cdot", "dot.op"],
+  // 'dot.op' or 'dot.c'
   ["cdots", "dots.c"],
   ["checkmark", "checkmark"],
   ["chi", "chi"],
   ["circ", "circle.small"],
+  // 'circle.small' or 'compose'
   ["colon", "colon"],
   ["cong", "tilde.equiv"],
   ["coprod", "product.co"],
@@ -130,7 +135,6 @@ var symbolMap = new Map([
   ["div", "div"],
   ["divideontimes", "times.div"],
   ["dotplus", "plus.dot"],
-  ["downarrow", "arrow.b"],
   ["ell", "ell"],
   ["emptyset", "nothing"],
   ["epsilon", "epsilon.alt"],
@@ -138,6 +142,7 @@ var symbolMap = new Map([
   ["eta", "eta"],
   ["exists", "exists"],
   ["forall", "forall"],
+  // ['frown', 'paren.t'], 
   ["gamma", "gamma"],
   ["ge", "gt.eq"],
   ["geq", "gt.eq"],
@@ -152,6 +157,7 @@ var symbolMap = new Map([
   ["infty", "infinity"],
   ["int", "integral"],
   ["intercal", "top"],
+  // 'top' or 'tack.b'
   ["iota", "iota"],
   ["jmath", "dotless.j"],
   ["kappa", "kappa"],
@@ -162,21 +168,23 @@ var symbolMap = new Map([
   ["lbrack", "bracket.l"],
   ["ldots", "dots.h"],
   ["le", "lt.eq"],
-  ["leadsto", "arrow.squiggly"],
-  ["leftarrow", "arrow.l"],
   ["leftthreetimes", "times.three.l"],
   ["leftrightarrow", "arrow.l.r"],
   ["leq", "lt.eq"],
   ["leqslant", "lt.eq.slant"],
   ["lhd", "triangle.l"],
   ["ll", "lt.double"],
+  // ['longmapsto', 'arrow.bar.long'], 
+  // ['longrightarrow', 'arrow.long'], 
   ["lor", "or"],
   ["ltimes", "times.l"],
+  // ['mapsto', 'arrow.bar'], 
   ["measuredangle", "angle.arc"],
   ["mid", "divides"],
   ["models", "models"],
   ["mp", "minus.plus"],
   ["mu", "mu"],
+  // ['nRightarrow', 'arrow.double.not'], 
   ["nabla", "nabla"],
   ["ncong", "tilde.equiv.not"],
   ["ne", "eq.not"],
@@ -190,18 +198,20 @@ var symbolMap = new Map([
   ["ngeq", "gt.eq.not"],
   ["nmid", "divides.not"],
   ["notin", "in.not"],
+  // ['nrightarrow', 'arrow.not'], 
   ["nsim", "tilde.not"],
   ["nsubseteq", "subset.eq.not"],
   ["nu", "nu"],
   ["ntriangleleft", "lt.tri.not"],
   ["ntriangleright", "gt.tri.not"],
-  ["nwarrow", "arrow.tl"],
   ["odot", "dot.circle"],
   ["oint", "integral.cont"],
   ["oiint", "integral.surf"],
   ["oiiint", "integral.vol"],
   ["omega", "omega"],
+  // ['omicron', 'omicron'], 
   ["ominus", "minus.circle"],
+  // ['oplus', 'xor'], // or 'plus.circle'
   ["otimes", "times.circle"],
   ["parallel", "parallel"],
   ["partial", "diff"],
@@ -230,11 +240,13 @@ var symbolMap = new Map([
   ["simeq", "tilde.eq"],
   ["slash", "slash"],
   ["smallsetminus", "without"],
+  // ['smile', 'paren.b'], 
   ["spadesuit", "suit.spade"],
   ["sqcap", "sect.sq"],
   ["sqcup", "union.sq"],
   ["sqsubseteq", "subset.eq.sq"],
   ["sqsupseteq", "supset.eq.sq"],
+  // ['star', 'star'], 
   ["subset", "subset"],
   ["subseteq", "subset.eq"],
   ["subsetneq", "subset.neq"],
@@ -244,21 +256,22 @@ var symbolMap = new Map([
   ["supset", "supset"],
   ["supseteq", "supset.eq"],
   ["supsetneq", "supset.neq"],
-  ["swarrow", "arrow.bl"],
   ["tau", "tau"],
   ["theta", "theta"],
   ["times", "times"],
   ["to", "arrow.r"],
   ["top", "top"],
   ["triangle", "triangle.t"],
+  // ['triangledown', 'triangle.b.small'], 
+  // ['triangleleft', 'triangle.l.small'], 
+  // ['triangleright', 'triangle.r.small'], 
   ["twoheadrightarrow", "arrow.r.twohead"],
-  ["uparrow", "arrow.t"],
-  ["updownarrow", "arrow.t.b"],
   ["upharpoonright", "harpoon.tr"],
   ["uplus", "union.plus"],
   ["upsilon", "upsilon"],
   ["varepsilon", "epsilon"],
   ["varnothing", "diameter"],
+  // empty set
   ["varphi", "phi"],
   ["varpi", "pi.alt"],
   ["varrho", "rho.alt"],
@@ -272,11 +285,12 @@ var symbolMap = new Map([
   ["xi", "xi"],
   ["yen", "yen"],
   ["zeta", "zeta"],
+  // extended
   ["mathscr", "scr"],
   ["LaTeX", "#LaTeX"],
   ["TeX", "#TeX"]
 ]);
-var map_from_official_docs = new Map([
+var map_from_official_docs = /* @__PURE__ */ new Map([
   ["lparen", "paren.l"],
   ["lParen", "paren.l.double"],
   ["rparen", "paren.r"],
@@ -287,6 +301,7 @@ var map_from_official_docs = new Map([
   ["lBrace", "brace.l.double"],
   ["rbrace", "brace.r"],
   ["rBrace", "brace.r.double"],
+  // ['overbrace', 'brace.t'],
   ["underbrace", "brace.b"],
   ["lbrack", "bracket.l"],
   ["lBrack", "bracket.l.double"],
@@ -367,6 +382,7 @@ var map_from_official_docs = new Map([
   ["mathquestion", "quest"],
   ["Question", "quest.double"],
   ["mathoctothorpe", "hash"],
+  // ['mathhyphen', 'hyph'],
   ["mathpercent", "percent"],
   ["mathparagraph", "pilcrow"],
   ["mathsection", "section"],
@@ -435,6 +451,8 @@ var map_from_official_docs = new Map([
   ["stareq", "eq.star"],
   ["circledequal", "eq.circle"],
   ["eqcolon", "eq.colon"],
+  // \usepackage{mathtools} defines \eqdef
+  // https://tex.stackexchange.com/questions/28836/typesetting-the-define-equals-symbol
   ["eqdef", "eq.def"],
   ["triangleq", "eq.delta"],
   ["veeeq", "eq.equi"],
@@ -936,6 +954,64 @@ var map_from_official_docs = new Map([
   ["barV", "tack.b.double"],
   ["shortdowntack", "tack.b.short"],
   ["dashVdash", "tack.l.r"],
+  /*
+  ['mupalpha', 'alpha'],
+  ['mupbeta', 'beta'],
+  ['mupchi', 'chi'],
+  ['mupdelta', 'delta'],
+  ['mupvarepsilon', 'epsilon'],
+  ['mupepsilon', 'epsilon.alt'],
+  ['mupeta', 'eta'],
+  ['mupgamma', 'gamma'],
+  ['mupiota', 'iota'],
+  ['mupkappa', 'kappa'],
+  ['mupvarkappa', 'kappa.alt'],
+  ['muplambda', 'lambda'],
+  ['mupmu', 'mu'],
+  ['mupnu', 'nu'],
+  ['mho', 'ohm.inv'],
+  ['mupomega', 'omega'],
+  ['mupomicron', 'omicron'],
+  ['mupvarphi', 'phi'],
+  ['mupphi', 'phi.alt'],
+  ['muppi', 'pi'],
+  ['mupvarpi', 'pi.alt'],
+  ['muppsi', 'psi'],
+  ['muprho', 'rho'],
+  ['mupvarrho', 'rho.alt'],
+  ['mupsigma', 'sigma'],
+  ['mupvarsigma', 'sigma.alt'],
+  ['muptau', 'tau'],
+  ['muptheta', 'theta'],
+  ['mupvartheta', 'theta.alt'],
+  ['mupupsilon', 'upsilon'],
+  ['mupxi', 'xi'],
+  ['mupzeta', 'zeta'],
+  ['mupAlpha', 'Alpha'],
+  ['mupBeta', 'Beta'],
+  ['mupChi', 'Chi'],
+  ['mupDelta', 'Delta'],
+  ['mupEpsilon', 'Epsilon'],
+  ['mupEta', 'Eta'],
+  ['mupGamma', 'Gamma'],
+  ['mupIota', 'Iota'],
+  ['mupKappa', 'Kappa'],
+  ['mupLambda', 'Lambda'],
+  ['mupMu', 'Mu'],
+  ['mupNu', 'Nu'],
+  ['mupOmega', 'Omega'],
+  ['mupOmicron', 'Omicron'],
+  ['mupPhi', 'Phi'],
+  ['mupPi', 'Pi'],
+  ['mupPsi', 'Psi'],
+  ['mupRho', 'Rho'],
+  ['mupSigma', 'Sigma'],
+  ['mupTau', 'Tau'],
+  ['mupTheta', 'Theta'],
+  ['mupUpsilon', 'Upsilon'],
+  ['mupXi', 'Xi'],
+  ['mupZeta', 'Zeta'],
+  */
   ["BbbA", "AA"],
   ["BbbB", "BB"],
   ["BbbC", "CC"],
@@ -976,12 +1052,13 @@ for (const [key, value] of map_from_official_docs) {
     symbolMap.set(key, value);
   }
 }
-var reverseSymbolMap = new Map;
+var reverseSymbolMap = /* @__PURE__ */ new Map();
 for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
   reverseSymbolMap.set(value, key);
 }
 reverseSymbolMap.set("dif", "mathrm{d}");
-var typst_to_tex_map = new Map([
+reverseSymbolMap.set("oo", "infty");
+var typst_to_tex_map = /* @__PURE__ */ new Map([
   ["top", "top"],
   ["frac", "frac"],
   ["tilde", "tilde"],
@@ -996,7 +1073,7 @@ for (const [key, value] of typst_to_tex_map) {
 
 // src/generic.ts
 function array_find(array, item, start = 0) {
-  for (let i = start;i < array.length; i++) {
+  for (let i = start; i < array.length; i++) {
     if (array[i].eq(item)) {
       return i;
     }
@@ -1027,9 +1104,7 @@ function array_split(array, sep) {
 }
 
 // src/types.ts
-class TexToken {
-  type;
-  value;
+var TexToken = class {
   constructor(type, value) {
     this.type = type;
     this.value = value;
@@ -1047,25 +1122,21 @@ class TexToken {
         return this.value;
     }
   }
-}
+};
 function apply_escape_if_needed(c) {
   if (["{", "}", "%"].includes(c)) {
     return "\\" + c;
   }
   return c;
 }
-
-class TexNode {
-  type;
-  content;
-  args;
-  data;
+var TexNode = class {
   constructor(type, content, args, data) {
     this.type = type;
     this.content = content;
     this.args = args;
     this.data = data;
   }
+  // Note that this is only shallow equality.
   eq(other) {
     return this.type === other.type && this.content === other.content;
   }
@@ -1143,7 +1214,7 @@ class TexNode {
         return tokens;
       }
       case "supsub": {
-        let should_wrap_in_braces = function(node) {
+        let should_wrap_in_braces2 = function(node) {
           if (node.type === "ordgroup" || node.type === "supsub" || node.type === "empty") {
             return true;
           } else if (node.type === "element" && /\d+(\.\d+)?/.test(node.content) && node.content.length > 1) {
@@ -1152,12 +1223,13 @@ class TexNode {
             return false;
           }
         };
+        var should_wrap_in_braces = should_wrap_in_braces2;
         let tokens = [];
         const { base, sup, sub } = this.data;
         tokens = tokens.concat(base.serialize());
         if (sub) {
           tokens.push(new TexToken(6 /* CONTROL */, "_"));
-          if (should_wrap_in_braces(sub)) {
+          if (should_wrap_in_braces2(sub)) {
             tokens.push(new TexToken(0 /* ELEMENT */, "{"));
             tokens = tokens.concat(sub.serialize());
             tokens.push(new TexToken(0 /* ELEMENT */, "}"));
@@ -1167,7 +1239,7 @@ class TexNode {
         }
         if (sup) {
           tokens.push(new TexToken(6 /* CONTROL */, "^"));
-          if (should_wrap_in_braces(sup)) {
+          if (should_wrap_in_braces2(sup)) {
             tokens.push(new TexToken(0 /* ELEMENT */, "{"));
             tokens = tokens.concat(sup.serialize());
             tokens.push(new TexToken(0 /* ELEMENT */, "}"));
@@ -1184,11 +1256,10 @@ class TexNode {
         let tokens = [];
         const matrix = this.data;
         tokens.push(new TexToken(1 /* COMMAND */, `\\begin{${this.content}}`));
-        tokens.push(new TexToken(5 /* NEWLINE */, `
-`));
-        for (let i = 0;i < matrix.length; i++) {
+        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
+        for (let i = 0; i < matrix.length; i++) {
           const row = matrix[i];
-          for (let j = 0;j < row.length; j++) {
+          for (let j = 0; j < row.length; j++) {
             const cell = row[j];
             tokens = tokens.concat(cell.serialize());
             if (j !== row.length - 1) {
@@ -1199,8 +1270,7 @@ class TexNode {
             tokens.push(new TexToken(6 /* CONTROL */, "\\\\"));
           }
         }
-        tokens.push(new TexToken(5 /* NEWLINE */, `
-`));
+        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
         tokens.push(new TexToken(1 /* COMMAND */, `\\end{${this.content}}`));
         return tokens;
       }
@@ -1208,6 +1278,8 @@ class TexNode {
         throw new Error("[TexNode.serialize] Unimplemented type: " + this.type);
     }
   }
+  // whether the node is over high so that if it's wrapped in braces, \left and \right should be used.
+  // e.g. \frac{1}{2} is over high, "2" is not.
   isOverHigh() {
     switch (this.type) {
       case "element":
@@ -1220,6 +1292,7 @@ class TexNode {
         if (this.content === "\\frac") {
           return true;
         }
+      // fall through
       case "unaryFunc":
       case "ordgroup":
         return this.args.some((n) => n.isOverHigh());
@@ -1232,10 +1305,8 @@ class TexNode {
         return false;
     }
   }
-}
-class TypstToken {
-  type;
-  value;
+};
+var TypstToken = class {
   constructor(type, content) {
     this.type = type;
     this.value = content;
@@ -1288,14 +1359,10 @@ class TypstToken {
         return this.value;
     }
   }
-}
-
-class TypstNode {
-  type;
-  content;
-  args;
-  data;
-  options;
+};
+var TYPST_NONE = null;
+var TYPST_TRUE = true;
+var TypstNode = class {
   constructor(type, content, args, data) {
     this.type = type;
     this.content = content;
@@ -1305,10 +1372,11 @@ class TypstNode {
   setOptions(options) {
     this.options = options;
   }
+  // Note that this is only shallow equality.
   eq(other) {
     return this.type === other.type && this.content === other.content;
   }
-}
+};
 
 // src/util.ts
 function isalpha(char) {
@@ -1465,8 +1533,7 @@ function tokenize(latex) {
     switch (firstChar) {
       case "%": {
         let newPos = pos + 1;
-        while (newPos < latex.length && latex[newPos] !== `
-`) {
+        while (newPos < latex.length && latex[newPos] !== "\n") {
           newPos += 1;
         }
         token = new TexToken(3 /* COMMENT */, latex.slice(pos + 1, newPos));
@@ -1481,20 +1548,16 @@ function tokenize(latex) {
         token = new TexToken(6 /* CONTROL */, firstChar);
         pos++;
         break;
-      case `
-`:
+      case "\n":
         token = new TexToken(5 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
-        if (pos + 1 < latex.length && latex[pos + 1] === `
-`) {
-          token = new TexToken(5 /* NEWLINE */, `
-`);
+        if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
+          token = new TexToken(5 /* NEWLINE */, "\n");
           pos += 2;
         } else {
-          token = new TexToken(5 /* NEWLINE */, `
-`);
+          token = new TexToken(5 /* NEWLINE */, "\n");
           pos++;
         }
         break;
@@ -1561,61 +1624,51 @@ function tokenize(latex) {
   }
   return tokens;
 }
-
-class LatexParserError extends Error {
+var LatexParserError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "LatexParserError";
   }
-}
+};
 var SUB_SYMBOL = new TexToken(6 /* CONTROL */, "_");
 var SUP_SYMBOL = new TexToken(6 /* CONTROL */, "^");
-
-class LatexParser {
-  space_sensitive;
-  newline_sensitive;
+var LatexParser = class {
   constructor(space_sensitive = false, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
   }
   parse(tokens) {
+    const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
+    return tree;
+  }
+  parseGroup(tokens, start, end) {
     const results = [];
-    let pos = 0;
-    while (pos < tokens.length) {
-      const results2 = [];
-      let pos2 = 0;
-      while (pos2 < tokens.length) {
-        const [res, newPos] = this.parseNextExpr(tokens, pos2);
-        pos2 = newPos;
-        if (res.type === "whitespace") {
-          if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
-            continue;
-          }
-          if (!this.newline_sensitive && res.content === `
-`) {
-            continue;
-          }
+    let pos = start;
+    while (pos < end) {
+      const [res, newPos] = this.parseNextExpr(tokens, pos);
+      pos = newPos;
+      if (res.type === "whitespace") {
+        if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
+          continue;
         }
-        if (res.type === "control" && res.content === "&") {
-          throw new LatexParserError("Unexpected & outside of an alignment");
+        if (!this.newline_sensitive && res.content === "\n") {
+          continue;
         }
-        results2.push(res);
       }
-      if (results2.length === 0) {
-        return EMPTY_NODE;
-      } else if (results2.length === 1) {
-        return results2[0];
-      } else {
-        return new TexNode("ordgroup", "", results2);
+      if (res.type === "control" && res.content === "&") {
+        throw new LatexParserError("Unexpected & outside of an alignment");
       }
+      results.push(res);
     }
+    let node;
     if (results.length === 0) {
-      return EMPTY_NODE;
+      node = EMPTY_NODE;
     } else if (results.length === 1) {
-      return results[0];
+      node = results[0];
     } else {
-      return new TexNode("ordgroup", "", results);
+      node = new TexNode("ordgroup", "", results);
     }
+    return [node, end + 1];
   }
   parseNextExpr(tokens, start) {
     let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
@@ -1653,7 +1706,7 @@ class LatexParser {
       }
       if (num_prime > 0) {
         res.sup = new TexNode("ordgroup", "", []);
-        for (let i = 0;i < num_prime; i++) {
+        for (let i = 0; i < num_prime; i++) {
           res.sup.args.push(new TexNode("element", "'"));
         }
         if (sup) {
@@ -1672,8 +1725,7 @@ class LatexParser {
   }
   parseNextExprWithoutSupSub(tokens, start) {
     const firstToken = tokens[start];
-    const tokenType = firstToken.type;
-    switch (tokenType) {
+    switch (firstToken.type) {
       case 0 /* ELEMENT */:
         return [new TexNode("element", firstToken.value), start + 1];
       case 2 /* TEXT */:
@@ -1699,8 +1751,7 @@ class LatexParser {
             if (posClosingBracket === -1) {
               throw new LatexParserError("Unmatched '{'");
             }
-            const exprInside = tokens.slice(start + 1, posClosingBracket);
-            return [this.parse(exprInside), posClosingBracket + 1];
+            return this.parseGroup(tokens, start + 1, posClosingBracket);
           case "}":
             throw new LatexParserError("Unmatched '}'");
           case "\\\\":
@@ -1743,8 +1794,7 @@ class LatexParser {
           if (posRightSquareBracket === -1) {
             throw new LatexParserError("No matching right square bracket for [");
           }
-          const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
-          const exponent = this.parse(exprInside);
+          const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
           const [arg12, newPos2] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
           return [new TexNode("unaryFunc", command, [arg12], exponent), newPos2];
         } else if (command === "\\text") {
@@ -1797,8 +1847,7 @@ class LatexParser {
       throw new LatexParserError("Invalid delimiter after \\right");
     }
     pos++;
-    const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-    const body = this.parse(exprInside);
+    const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
     const args = [
       new TexNode("element", leftDelimiter.value),
       body,
@@ -1852,8 +1901,7 @@ class LatexParser {
         if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === `
-`) {
+        if (!this.newline_sensitive && res.content === "\n") {
           continue;
         }
       }
@@ -1871,11 +1919,11 @@ class LatexParser {
     }
     return allRows;
   }
-}
+};
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
   const is_script_mark = (token) => token.eq(SUB_SYMBOL) || token.eq(SUP_SYMBOL);
   let out_tokens = [];
-  for (let i = 0;i < tokens.length; i++) {
+  for (let i = 0; i < tokens.length; i++) {
     if (tokens[i].type === 4 /* SPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
       continue;
     }
@@ -1899,52 +1947,102 @@ function passExpandCustomTexMacros(tokens, customTexMacros) {
   return out_tokens;
 }
 function parseTex(tex, customTexMacros) {
-  const parser = new LatexParser;
+  const parser = new LatexParser();
   let tokens = tokenize(tex);
   tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
   tokens = passExpandCustomTexMacros(tokens, customTexMacros);
   return parser.parse(tokens);
 }
 
+// src/typst-shorthands.ts
+var shorthandMap = /* @__PURE__ */ new Map([
+  ["arrow.l.r.double.long", "<==>"],
+  ["arrow.l.r.long", "<-->"],
+  ["arrow.r.bar", "|->"],
+  ["arrow.r.double.bar", "|=>"],
+  ["arrow.r.double.long", "==>"],
+  ["arrow.r.long", "-->"],
+  ["arrow.r.long.squiggly", "~~>"],
+  ["arrow.r.tail", ">->"],
+  ["arrow.r.twohead", "->>"],
+  ["arrow.l.double.long", "<=="],
+  ["arrow.l.long", "<--"],
+  ["arrow.l.long.squiggly", "<~~"],
+  ["arrow.l.tail", "<-<"],
+  ["arrow.l.twohead", "<<-"],
+  ["arrow.l.r", "<->"],
+  ["arrow.l.r.double", "<=>"],
+  ["colon.double.eq", "::="],
+  ["dots.h", "..."],
+  ["gt.triple", ">>>"],
+  ["lt.triple", "<<<"],
+  ["arrow.r", "->"],
+  ["arrow.r.double", "=>"],
+  ["arrow.r.squiggly", "~>"],
+  ["arrow.l", "<-"],
+  ["arrow.l.squiggly", "<~"],
+  ["bar.v.double", "||"],
+  ["bracket.l.double", "[|"],
+  ["bracket.r.double", "|]"],
+  ["colon.eq", ":="],
+  ["eq.colon", "=:"],
+  ["eq.not", "!="],
+  ["gt.double", ">>"],
+  ["gt.eq", ">="],
+  ["lt.double", "<<"],
+  ["lt.eq", "<="],
+  ["ast.op", "*"],
+  ["minus", "-"],
+  ["tilde.op", "~"]
+]);
+var reverseShorthandMap = /* @__PURE__ */ new Map();
+for (const [key, value] of shorthandMap.entries()) {
+  if (value.length > 1) {
+    reverseShorthandMap.set(value, key);
+  }
+}
+
 // src/typst-writer.ts
-var TYPST_INTRINSIC_SYMBOLS = [
-  "dim",
-  "id",
-  "im",
-  "mod",
-  "Pr",
-  "sech",
-  "csch"
-];
 function is_delimiter(c) {
-  return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "⌊", "⌋", "⌈", "⌉"].includes(c.content);
+  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 */, `
-`);
-
-class TypstWriterError extends Error {
-  node;
+var TYPST_NEWLINE = new TypstToken(0 /* SYMBOL */, "\n");
+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:
+      if (value === null) {
+        return "#none";
+      } else if (value instanceof TypstToken) {
+        return value.toString();
+      }
+      throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
+  }
+}
+var TypstWriterError = class extends Error {
   constructor(message, node) {
     super(message);
     this.name = "TypstWriterError";
     this.node = node;
   }
-}
-
-class TypstWriter {
-  nonStrict;
-  preferTypstIntrinsic;
-  keepSpaces;
-  buffer = "";
-  queue = [];
-  insideFunctionDepth = 0;
-  constructor(nonStrict, preferTypstIntrinsic, keepSpaces) {
-    this.nonStrict = nonStrict;
-    this.preferTypstIntrinsic = preferTypstIntrinsic;
-    this.keepSpaces = keepSpaces;
+};
+var TypstWriter = class {
+  constructor(opt) {
+    this.buffer = "";
+    this.queue = [];
+    this.insideFunctionDepth = 0;
+    this.nonStrict = opt.nonStrict;
+    this.preferShorthands = opt.preferShorthands;
+    this.keepSpaces = opt.keepSpaces;
+    this.inftyToOo = opt.inftyToOo;
   }
   writeBuffer(token) {
     const str = token.toString();
@@ -1959,8 +2057,7 @@ class TypstWriter {
     no_need_space ||= str === "'";
     no_need_space ||= /[0-9]$/.test(this.buffer) && /^[0-9]/.test(str);
     no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
-    no_need_space ||= str.startsWith(`
-`);
+    no_need_space ||= str.startsWith("\n");
     no_need_space ||= this.buffer === "";
     no_need_space ||= /^\s/.test(str);
     no_need_space ||= this.buffer.endsWith("&") && str === "=";
@@ -1971,6 +2068,7 @@ class TypstWriter {
     }
     this.buffer += str;
   }
+  // Serialize a tree of TypstNode into a list of TypstToken
   serialize(node) {
     switch (node.type) {
       case "empty":
@@ -1983,9 +2081,19 @@ class TypstWriter {
         }
         break;
       }
-      case "symbol":
-        this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
+      case "symbol": {
+        let content = node.content;
+        if (this.preferShorthands) {
+          if (shorthandMap.has(content)) {
+            content = shorthandMap.get(content);
+          }
+        }
+        if (this.inftyToOo && content === "infinity") {
+          content = "oo";
+        }
+        this.queue.push(new TypstToken(0 /* SYMBOL */, content));
         break;
+      }
       case "text":
         this.queue.push(new TypstToken(2 /* TEXT */, node.content));
         break;
@@ -1998,8 +2106,7 @@ class TypstWriter {
             if (this.keepSpaces) {
               this.queue.push(new TypstToken(4 /* SPACE */, c));
             }
-          } else if (c === `
-`) {
+          } else if (c === "\n") {
             this.queue.push(new TypstToken(0 /* SYMBOL */, c));
           } else {
             throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
@@ -2038,7 +2145,7 @@ class TypstWriter {
         this.queue.push(func_symbol);
         this.insideFunctionDepth++;
         this.queue.push(TYPST_LEFT_PARENTHESIS);
-        for (let i = 0;i < node.args.length; i++) {
+        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 */, ","));
@@ -2046,7 +2153,8 @@ class TypstWriter {
         }
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push(new TypstToken(0 /* SYMBOL */, `, ${key}: ${value}`));
+            const value_str = typst_primitive_to_string(value);
+            this.queue.push(new TypstToken(0 /* SYMBOL */, `, ${key}: ${value_str}`));
           }
         }
         this.queue.push(TYPST_RIGHT_PARENTHESIS);
@@ -2094,7 +2202,8 @@ class TypstWriter {
         this.queue.push(TYPST_LEFT_PARENTHESIS);
         if (node.options) {
           for (const [key, value] of Object.entries(node.options)) {
-            this.queue.push(new TypstToken(0 /* SYMBOL */, `${key}: ${value}, `));
+            const value_str = typst_primitive_to_string(value);
+            this.queue.push(new TypstToken(0 /* SYMBOL */, `${key}: ${value_str}, `));
           }
         }
         matrix.forEach((row, i) => {
@@ -2145,7 +2254,7 @@ class TypstWriter {
   }
   flushQueue() {
     const SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
-    for (let i = 0;i < this.queue.length; i++) {
+    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) {
@@ -2183,9 +2292,19 @@ class TypstWriter {
     }
     return this.buffer;
   }
-}
+};
 
 // src/convert.ts
+var TYPST_INTRINSIC_SYMBOLS = [
+  "dim",
+  "id",
+  "im",
+  "mod",
+  "Pr",
+  "sech",
+  "csch"
+  // 'sgn
+];
 function tex_token_to_typst(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
@@ -2228,12 +2347,21 @@ function convert_overset(node, options) {
   if (is_def(sup) && is_eq(base)) {
     return new TypstNode("symbol", "eq.def");
   }
-  const op_call = new TypstNode("funcCall", "op", [convert_tex_node_to_typst(base, options)]);
-  op_call.setOptions({ limits: "#true" });
-  return new TypstNode("supsub", "", [], {
-    base: op_call,
-    sup: convert_tex_node_to_typst(sup, options)
-  });
+  const op_call = new TypstNode(
+    "funcCall",
+    "op",
+    [convert_tex_node_to_typst(base, options)]
+  );
+  op_call.setOptions({ limits: TYPST_TRUE });
+  return new TypstNode(
+    "supsub",
+    "",
+    [],
+    {
+      base: op_call,
+      sup: convert_tex_node_to_typst(sup, options)
+    }
+  );
 }
 function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
@@ -2242,7 +2370,11 @@ function convert_tex_node_to_typst(node, options = {}) {
     case "whitespace":
       return new TypstNode("whitespace", node.content);
     case "ordgroup":
-      return new TypstNode("group", "", node.args.map((n) => convert_tex_node_to_typst(n, options)));
+      return new TypstNode(
+        "group",
+        "",
+        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      );
     case "element":
       return new TypstNode("atom", tex_token_to_typst(node.content));
     case "symbol":
@@ -2254,9 +2386,17 @@ function convert_tex_node_to_typst(node, options = {}) {
     case "supsub": {
       let { base, sup, sub } = node.data;
       if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
-        return new TypstNode("funcCall", "overbrace", [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sup, options)]);
+        return new TypstNode(
+          "funcCall",
+          "overbrace",
+          [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sup, options)]
+        );
       } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
-        return new TypstNode("funcCall", "underbrace", [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sub, options)]);
+        return new TypstNode(
+          "funcCall",
+          "underbrace",
+          [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sub, options)]
+        );
       }
       const data = {
         base: convert_tex_node_to_typst(base, options)
@@ -2274,7 +2414,11 @@ function convert_tex_node_to_typst(node, options = {}) {
     }
     case "leftright": {
       const [left, body, right] = node.args;
-      const group = new TypstNode("group", "", node.args.map((n) => convert_tex_node_to_typst(n, options)));
+      const group = new TypstNode(
+        "group",
+        "",
+        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      );
       if ([
         "[]",
         "()",
@@ -2292,7 +2436,11 @@ function convert_tex_node_to_typst(node, options = {}) {
         group.args.shift();
         return new TypstNode("funcCall", "lr", [group]);
       }
-      return new TypstNode("funcCall", "lr", [group]);
+      return new TypstNode(
+        "funcCall",
+        "lr",
+        [group]
+      );
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
@@ -2300,20 +2448,40 @@ function convert_tex_node_to_typst(node, options = {}) {
       }
       if (node.content === "\\frac") {
         if (options.fracToSlash) {
-          return new TypstNode("fraction", "", node.args.map((n) => convert_tex_node_to_typst(n, options)));
+          return new TypstNode(
+            "fraction",
+            "",
+            node.args.map((n) => convert_tex_node_to_typst(n, options))
+          );
         }
       }
-      return new TypstNode("funcCall", tex_token_to_typst(node.content), node.args.map((n) => convert_tex_node_to_typst(n, options)));
+      return new TypstNode(
+        "funcCall",
+        tex_token_to_typst(node.content),
+        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      );
     }
     case "unaryFunc": {
       const arg0 = convert_tex_node_to_typst(node.args[0], options);
       if (node.content === "\\sqrt" && node.data) {
         const data = convert_tex_node_to_typst(node.data, options);
-        return new TypstNode("funcCall", "root", [data, arg0]);
+        return new TypstNode(
+          "funcCall",
+          "root",
+          [data, arg0]
+        );
       }
       if (node.content === "\\mathbf") {
-        const inner = new TypstNode("funcCall", "bold", [arg0]);
-        return new TypstNode("funcCall", "upright", [inner]);
+        const inner = new TypstNode(
+          "funcCall",
+          "bold",
+          [arg0]
+        );
+        return new TypstNode(
+          "funcCall",
+          "upright",
+          [inner]
+        );
       }
       if (node.content === "\\mathbb" && arg0.type === "atom" && /^[A-Z]$/.test(arg0.content)) {
         return new TypstNode("symbol", arg0.content + arg0.content);
@@ -2327,21 +2495,55 @@ function convert_tex_node_to_typst(node, options = {}) {
         if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
           return new TypstNode("symbol", text);
         } else {
-          return new TypstNode("funcCall", "op", [new TypstNode("text", text)]);
+          return new TypstNode(
+            "funcCall",
+            "op",
+            [new TypstNode("text", text)]
+          );
         }
       }
-      return new TypstNode("funcCall", tex_token_to_typst(node.content), node.args.map((n) => convert_tex_node_to_typst(n, options)));
+      return new TypstNode(
+        "funcCall",
+        tex_token_to_typst(node.content),
+        node.args.map((n) => convert_tex_node_to_typst(n, options))
+      );
     }
     case "beginend": {
       const matrix = node.data;
       const data = matrix.map((row) => row.map((n) => convert_tex_node_to_typst(n, options)));
       if (node.content.startsWith("align")) {
         return new TypstNode("align", "", [], data);
-      } else {
+      }
+      if (node.content.endsWith("matrix")) {
+        let delim = null;
+        switch (node.content) {
+          case "matrix":
+            delim = TYPST_NONE;
+            break;
+          case "pmatrix":
+            delim = "(";
+            break;
+          case "bmatrix":
+            delim = "[";
+            break;
+          case "Bmatrix":
+            delim = "{";
+            break;
+          case "vmatrix":
+            delim = "|";
+            break;
+          case "Vmatrix": {
+            delim = new TypstToken(0 /* SYMBOL */, "bar.v.double");
+            break;
+          }
+          default:
+            throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+        }
         const res = new TypstNode("matrix", "", [], data);
-        res.setOptions({ delim: "#none" });
+        res.setOptions({ "delim": delim });
         return res;
       }
+      throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
     }
     case "unknownMacro":
       return new TypstNode("unknown", tex_token_to_typst(node.content));
@@ -2413,8 +2615,10 @@ function convert_typst_node_to_tex(node) {
       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", "-");
@@ -2498,7 +2702,7 @@ function convert_typst_node_to_tex(node) {
       if (node.options) {
         if ("delim" in node.options) {
           switch (node.options.delim) {
-            case "#none":
+            case TYPST_NONE:
               return matrix;
             case "[":
               left_delim = "\\left[";
@@ -2559,6 +2763,8 @@ 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 */, "'"))) {
@@ -2573,7 +2779,14 @@ function eat_identifier_name(typst, start) {
   }
   return typst.substring(start, pos);
 }
-var TYPST_EMPTY_NODE = new TypstNode("empty", "");
+function try_eat_shorthand(typst, start) {
+  for (const shorthand of TYPST_SHORTHANDS) {
+    if (typst.startsWith(shorthand, start)) {
+      return shorthand;
+    }
+  }
+  return null;
+}
 function tokenize_typst(typst) {
   const tokens = [];
   let pos = 0;
@@ -2587,20 +2800,16 @@ function tokenize_typst(typst) {
         token = new TypstToken(6 /* CONTROL */, firstChar);
         pos++;
         break;
-      case `
-`:
+      case "\n":
         token = new TypstToken(7 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
-        if (pos + 1 < typst.length && typst[pos + 1] === `
-`) {
-          token = new TypstToken(7 /* NEWLINE */, `
-`);
+        if (pos + 1 < typst.length && typst[pos + 1] === "\n") {
+          token = new TypstToken(7 /* NEWLINE */, "\n");
           pos += 2;
         } else {
-          token = new TypstToken(7 /* NEWLINE */, `
-`);
+          token = new TypstToken(7 /* NEWLINE */, "\n");
           pos++;
         }
         break;
@@ -2617,8 +2826,7 @@ function tokenize_typst(typst) {
       case "/": {
         if (pos < typst.length && typst[pos + 1] === "/") {
           let newPos = pos + 2;
-          while (newPos < typst.length && typst[newPos] !== `
-`) {
+          while (newPos < typst.length && typst[newPos] !== "\n") {
             newPos++;
           }
           token = new TypstToken(3 /* COMMENT */, typst.slice(pos + 2, newPos));
@@ -2664,6 +2872,12 @@ function tokenize_typst(typst) {
         break;
       }
       default: {
+        const shorthand = try_eat_shorthand(typst, pos);
+        if (shorthand !== null) {
+          token = new TypstToken(0 /* SYMBOL */, reverseShorthandMap.get(shorthand));
+          pos += shorthand.length;
+          break;
+        }
         if (isdigit(firstChar)) {
           let newPos = pos;
           while (newPos < typst.length && isdigit(typst[newPos])) {
@@ -2730,7 +2944,7 @@ function find_closing_parenthesis(nodes, start) {
 }
 function primes(num) {
   const res = [];
-  for (let i = 0;i < num; i++) {
+  for (let i = 0; i < num; i++) {
     res.push(new TypstNode("atom", "'"));
   }
   return res;
@@ -2746,7 +2960,7 @@ function next_non_whitespace(nodes, start) {
 function trim_whitespace_around_operators(nodes) {
   let after_operator = false;
   const res = [];
-  for (let i = 0;i < nodes.length; i++) {
+  for (let i = 0; i < nodes.length; i++) {
     const current = nodes[i];
     if (current.type === "whitespace") {
       if (after_operator) {
@@ -2820,13 +3034,12 @@ function process_operators(nodes, parenthesis = false) {
     }
   }
 }
-
-class TypstParserError extends Error {
+var TypstParserError = class extends Error {
   constructor(message) {
     super(message);
     this.name = "TypstParserError";
   }
-}
+};
 var SUB_SYMBOL2 = new TypstToken(6 /* CONTROL */, "_");
 var SUP_SYMBOL2 = new TypstToken(6 /* CONTROL */, "^");
 var LEFT_PARENTHESES = new TypstToken(1 /* ELEMENT */, "(");
@@ -2838,10 +3051,7 @@ var RIGHT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "}");
 var COMMA = new TypstToken(1 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(1 /* ELEMENT */, ";");
 var SINGLE_SPACE = new TypstToken(4 /* SPACE */, " ");
-
-class TypstParser {
-  space_sensitive;
-  newline_sensitive;
+var TypstParser = class {
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -2860,8 +3070,7 @@ class TypstParser {
         if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === `
-`) {
+        if (!this.newline_sensitive && res.content === "\n") {
           continue;
         }
       }
@@ -2956,10 +3165,12 @@ class TypstParser {
     }
     return [node, start + 1];
   }
+  // start: the position of the left parentheses
   parseArguments(tokens, start) {
     const end = find_closing_match2(tokens, start);
     return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
   }
+  // start: the position of the left parentheses
   parseGroupsOfArguments(tokens, start) {
     const end = find_closing_match2(tokens, start);
     tokens = tokens.slice(0, end);
@@ -2968,11 +3179,11 @@ class TypstParser {
     let pos = start + 1;
     while (pos < end) {
       while (pos < end) {
-        let extract_named_params = function(arr) {
+        let extract_named_params2 = function(arr) {
           const COLON = new TypstNode("atom", ":");
           const np2 = {};
           const to_delete = [];
-          for (let i = 0;i < arr.length; i++) {
+          for (let i = 0; i < arr.length; i++) {
             if (arr[i].type !== "group") {
               continue;
             }
@@ -2993,7 +3204,7 @@ class TypstParser {
                 if (g.args.length !== 4 || !g.args[pos_colon + 2].eq(new TypstNode("symbol", "none"))) {
                   throw new TypstParserError("Invalid number of arguments for delim");
                 }
-                np2["delim"] = "#none";
+                np2["delim"] = TYPST_NONE;
               } else {
                 throw new TypstParserError("Not implemented for other types of delim");
               }
@@ -3001,18 +3212,19 @@ class TypstParser {
               throw new TypstParserError("Not implemented for other named parameters");
             }
           }
-          for (let i = to_delete.length - 1;i >= 0; i--) {
+          for (let i = to_delete.length - 1; i >= 0; i--) {
             arr.splice(to_delete[i], 1);
           }
           return [arr, np2];
         };
+        var extract_named_params = extract_named_params2;
         let next_stop = array_find(tokens, SEMICOLON, pos);
         if (next_stop === -1) {
           next_stop = end;
         }
         let row = this.parseCommaSeparatedArguments(tokens, pos, next_stop);
         let np = {};
-        [row, np] = extract_named_params(row);
+        [row, np] = extract_named_params2(row);
         matrix.push(row);
         Object.assign(named_params, np);
         pos = next_stop + 1;
@@ -3020,6 +3232,7 @@ class TypstParser {
     }
     return [matrix, named_params, end + 1];
   }
+  // start: the position of the first token of arguments
   parseCommaSeparatedArguments(tokens, start, end) {
     const args = [];
     let pos = start;
@@ -3046,17 +3259,19 @@ class TypstParser {
     }
     return args;
   }
-}
+};
 function parseTypst(typst) {
-  const parser = new TypstParser;
+  const parser = new TypstParser();
   let tokens = tokenize_typst(typst);
   return parser.parse(tokens);
 }
 
 // src/tex-writer.ts
-class TexWriter {
-  buffer = "";
-  queue = [];
+var TexWriter = class {
+  constructor() {
+    this.buffer = "";
+    this.queue = [];
+  }
   writeBuffer(token) {
     const str = token.toString();
     let no_need_space = false;
@@ -3095,7 +3310,7 @@ class TexWriter {
     this.queue = this.queue.concat(node.serialize());
   }
   flushQueue() {
-    for (let i = 0;i < this.queue.length; i++) {
+    for (let i = 0; i < this.queue.length; i++) {
       this.writeBuffer(this.queue[i]);
     }
     this.queue = [];
@@ -3104,46 +3319,41 @@ class TexWriter {
     this.flushQueue();
     return this.buffer;
   }
-}
+};
 
 // src/index.ts
 function tex2typst(tex, options) {
   const opt = {
     nonStrict: true,
     preferTypstIntrinsic: true,
+    preferShorthands: true,
     keepSpaces: false,
     fracToSlash: true,
+    inftyToOo: false,
     customTexMacros: {}
   };
-  if (options) {
-    if (options.nonStrict) {
-      opt.nonStrict = options.nonStrict;
-    }
-    if (options.preferTypstIntrinsic) {
-      opt.preferTypstIntrinsic = options.preferTypstIntrinsic;
-    }
-    if (options.customTexMacros) {
-      opt.customTexMacros = options.customTexMacros;
-    }
-    if (options.fracToSlash !== undefined) {
-      opt.fracToSlash = options.fracToSlash;
+  if (options !== void 0) {
+    for (const key in opt) {
+      if (options[key] !== void 0) {
+        opt[key] = options[key];
+      }
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
   const typstTree = convert_tex_node_to_typst(texTree, opt);
-  const writer = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
+  const writer = new TypstWriter(opt);
   writer.serialize(typstTree);
   return writer.finalize();
 }
 function typst2tex(typst) {
   const typstTree = parseTypst(typst);
   const texTree = convert_typst_node_to_tex(typstTree);
-  const writer = new TexWriter;
+  const writer = new TexWriter();
   writer.append(texTree);
   return writer.finalize();
 }
 export {
-  typst2tex,
+  symbolMap,
   tex2typst,
-  symbolMap
+  typst2tex
 };