tex2typst 0.3.0-beta-4 → 0.3.0-beta-6

package/dist/index.js

@@ -1100,8 +1100,17 @@ class TexNode {
         }
         return tokens;
       }
-      case "ordgroup":
-        return this.args.map((n) => n.serialize()).flat();
+      case "ordgroup": {
+        let tokens = this.args.map((n) => n.serialize()).flat();
+        if (this.content === "parenthesis") {
+          const is_over_high = this.isOverHigh();
+          const left_delim = is_over_high ? "\\left(" : "(";
+          const right_delim = is_over_high ? "\\right)" : ")";
+          tokens.unshift(new TexToken(0 /* ELEMENT */, left_delim));
+          tokens.push(new TexToken(0 /* ELEMENT */, right_delim));
+        }
+        return tokens;
+      }
       case "unaryFunc": {
         let tokens = [];
         tokens.push(new TexToken(1 /* COMMAND */, this.content));
@@ -1199,6 +1208,30 @@ class TexNode {
         throw new Error("[TexNode.serialize] Unimplemented type: " + this.type);
     }
   }
+  isOverHigh() {
+    switch (this.type) {
+      case "element":
+      case "symbol":
+      case "text":
+      case "control":
+      case "empty":
+        return false;
+      case "binaryFunc":
+        if (this.content === "\\frac") {
+          return true;
+        }
+      case "unaryFunc":
+      case "ordgroup":
+        return this.args.some((n) => n.isOverHigh());
+      case "supsub": {
+        return this.data.base.isOverHigh();
+      }
+      case "beginend":
+        return true;
+      default:
+        return false;
+    }
+  }
 }
 class TypstToken {
   type;
@@ -1873,7 +1906,7 @@ function parseTex(tex, customTexMacros) {
   return parser.parse(tokens);
 }
 
-// src/writer.ts
+// src/typst-writer.ts
 var TYPST_INTRINSIC_SYMBOLS = [
   "dim",
   "id",
@@ -1886,34 +1919,6 @@ var TYPST_INTRINSIC_SYMBOLS = [
 function is_delimiter(c) {
   return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "⌊", "⌋", "⌈", "⌉"].includes(c.content);
 }
-function convert_overset(node) {
-  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)) {
-        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");
-  }
-  const op_call = new TypstNode("funcCall", "op", [convertTree(base)]);
-  op_call.setOptions({ limits: "#true" });
-  return new TypstNode("supsub", "", [], {
-    base: op_call,
-    sup: convertTree(sup)
-  });
-}
 var TYPST_LEFT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, "(");
 var TYPST_RIGHT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, ")");
 var TYPST_COMMA = new TypstToken(1 /* ELEMENT */, ",");
@@ -1949,7 +1954,8 @@ class TypstWriter {
     let no_need_space = false;
     no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
     no_need_space ||= /^[})\]\|]$/.test(str);
-    no_need_space ||= /^[(_^,;!]$/.test(str);
+    no_need_space ||= /[^=]$/.test(this.buffer) && str === "(";
+    no_need_space ||= /^[_^,;!]$/.test(str);
     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 === "+";
@@ -1958,6 +1964,7 @@ class TypstWriter {
     no_need_space ||= this.buffer === "";
     no_need_space ||= /^\s/.test(str);
     no_need_space ||= this.buffer.endsWith("&") && str === "=";
+    no_need_space ||= this.buffer.endsWith("/") || str === "/";
     no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
     if (!no_need_space) {
       this.buffer += " ";
@@ -2046,6 +2053,25 @@ class TypstWriter {
         this.insideFunctionDepth--;
         break;
       }
+      case "fraction": {
+        const [numerator, denominator] = node.args;
+        if (numerator.type === "group") {
+          this.queue.push(TYPST_LEFT_PARENTHESIS);
+          this.serialize(numerator);
+          this.queue.push(TYPST_RIGHT_PARENTHESIS);
+        } else {
+          this.serialize(numerator);
+        }
+        this.queue.push(new TypstToken(1 /* ELEMENT */, "/"));
+        if (denominator.type === "group") {
+          this.queue.push(TYPST_LEFT_PARENTHESIS);
+          this.serialize(denominator);
+          this.queue.push(TYPST_RIGHT_PARENTHESIS);
+        } else {
+          this.serialize(denominator);
+        }
+        break;
+      }
       case "align": {
         const matrix = node.data;
         matrix.forEach((row, i) => {
@@ -2158,18 +2184,69 @@ class TypstWriter {
     return this.buffer;
   }
 }
-function convertTree(node) {
+
+// src/convert.ts
+function tex_token_to_typst(token) {
+  if (/^[a-zA-Z0-9]$/.test(token)) {
+    return token;
+  } else if (token === "/") {
+    return "\\/";
+  } else if (token === "\\|") {
+    return "parallel";
+  } else if (token === "\\\\") {
+    return "\\";
+  } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
+    return token;
+  } else if (token.startsWith("\\")) {
+    const symbol = token.slice(1);
+    if (symbolMap.has(symbol)) {
+      return symbolMap.get(symbol);
+    } else {
+      return symbol;
+    }
+  }
+  return 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)) {
+        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");
+  }
+  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)
+  });
+}
+function convert_tex_node_to_typst(node, options = {}) {
   switch (node.type) {
     case "empty":
       return new TypstNode("empty", "");
     case "whitespace":
       return new TypstNode("whitespace", node.content);
     case "ordgroup":
-      return new TypstNode("group", "", node.args.map(convertTree));
+      return new TypstNode("group", "", node.args.map((n) => convert_tex_node_to_typst(n, options)));
     case "element":
-      return new TypstNode("atom", convertToken(node.content));
+      return new TypstNode("atom", tex_token_to_typst(node.content));
     case "symbol":
-      return new TypstNode("symbol", convertToken(node.content));
+      return new TypstNode("symbol", tex_token_to_typst(node.content));
     case "text":
       return new TypstNode("text", node.content);
     case "comment":
@@ -2177,27 +2254,27 @@ function convertTree(node) {
     case "supsub": {
       let { base, sup, sub } = node.data;
       if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
-        return new TypstNode("funcCall", "overbrace", [convertTree(base.args[0]), convertTree(sup)]);
+        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", [convertTree(base.args[0]), convertTree(sub)]);
+        return new TypstNode("funcCall", "underbrace", [convert_tex_node_to_typst(base.args[0], options), convert_tex_node_to_typst(sub, options)]);
       }
       const data = {
-        base: convertTree(base)
+        base: convert_tex_node_to_typst(base, options)
       };
       if (data.base.type === "empty") {
         data.base = new TypstNode("text", "");
       }
       if (sup) {
-        data.sup = convertTree(sup);
+        data.sup = convert_tex_node_to_typst(sup, options);
       }
       if (sub) {
-        data.sub = convertTree(sub);
+        data.sub = convert_tex_node_to_typst(sub, options);
       }
       return new TypstNode("supsub", "", [], data);
     }
     case "leftright": {
       const [left, body, right] = node.args;
-      const group = new TypstNode("group", "", node.args.map(convertTree));
+      const group = new TypstNode("group", "", node.args.map((n) => convert_tex_node_to_typst(n, options)));
       if ([
         "[]",
         "()",
@@ -2219,14 +2296,19 @@ function convertTree(node) {
     }
     case "binaryFunc": {
       if (node.content === "\\overset") {
-        return convert_overset(node);
+        return convert_overset(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("funcCall", convertToken(node.content), node.args.map(convertTree));
+      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 = convertTree(node.args[0]);
+      const arg0 = convert_tex_node_to_typst(node.args[0], options);
       if (node.content === "\\sqrt" && node.data) {
-        const data = convertTree(node.data);
+        const data = convert_tex_node_to_typst(node.data, options);
         return new TypstNode("funcCall", "root", [data, arg0]);
       }
       if (node.content === "\\mathbf") {
@@ -2248,11 +2330,11 @@ function convertTree(node) {
           return new TypstNode("funcCall", "op", [new TypstNode("text", text)]);
         }
       }
-      return new TypstNode("funcCall", convertToken(node.content), node.args.map(convertTree));
+      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(convertTree));
+      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 {
@@ -2262,7 +2344,7 @@ function convertTree(node) {
       }
     }
     case "unknownMacro":
-      return new TypstNode("unknown", convertToken(node.content));
+      return new TypstNode("unknown", tex_token_to_typst(node.content));
     case "control":
       if (node.content === "\\\\") {
         return new TypstNode("symbol", "\\");
@@ -2275,26 +2357,205 @@ function convertTree(node) {
       throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
   }
 }
-function convertToken(token) {
+var TYPST_UNARY_FUNCTIONS = [
+  "sqrt",
+  "bold",
+  "arrow",
+  "upright",
+  "lr",
+  "op",
+  "macron",
+  "dot",
+  "dot.double",
+  "hat",
+  "tilde",
+  "overline",
+  "underline",
+  "bb",
+  "cal",
+  "frak"
+];
+var TYPST_BINARY_FUNCTIONS = [
+  "frac",
+  "root",
+  "overbrace",
+  "underbrace"
+];
+function apply_escape_if_needed2(c) {
+  if (["{", "}", "%"].includes(c)) {
+    return "\\" + c;
+  }
+  return c;
+}
+function typst_token_to_tex(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
-  } else if (token === "/") {
-    return "\\/";
-  } else if (token === "\\|") {
-    return "parallel";
-  } else if (token === "\\\\") {
-    return "\\";
-  } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
-    return token;
-  } else if (token.startsWith("\\")) {
-    const symbol = token.slice(1);
-    if (symbolMap.has(symbol)) {
-      return symbolMap.get(symbol);
-    } else {
-      return symbol;
+  } else if (token === "thin") {
+    return "\\,";
+  } else if (reverseSymbolMap.has(token)) {
+    return "\\" + reverseSymbolMap.get(token);
+  }
+  return "\\" + token;
+}
+function convert_typst_node_to_tex(node) {
+  if (node.eq(new TypstNode("symbol", "eq.def"))) {
+    return new TexNode("binaryFunc", "\\overset", [
+      new TexNode("text", "def"),
+      new TexNode("element", "=")
+    ]);
+  }
+  switch (node.type) {
+    case "empty":
+      return new TexNode("empty", "");
+    case "whitespace":
+      return new TexNode("whitespace", node.content);
+    case "atom":
+      return new TexNode("element", node.content);
+    case "symbol":
+      switch (node.content) {
+        case "comma":
+          return new TexNode("element", ",");
+        case "hyph":
+        case "hyph.minus":
+          return new TexNode("text", "-");
+        default:
+          return new TexNode("symbol", typst_token_to_tex(node.content));
+      }
+    case "text":
+      return new TexNode("text", node.content);
+    case "comment":
+      return new TexNode("comment", node.content);
+    case "group": {
+      const args = node.args.map(convert_typst_node_to_tex);
+      return new TexNode("ordgroup", node.content, args);
+    }
+    case "funcCall": {
+      if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
+        if (node.content === "lr") {
+          const body = node.args[0];
+          if (body.type === "group") {
+            let left_delim = body.args[0].content;
+            let right_delim = body.args[body.args.length - 1].content;
+            left_delim = apply_escape_if_needed2(left_delim);
+            right_delim = apply_escape_if_needed2(right_delim);
+            return new TexNode("ordgroup", "", [
+              new TexNode("element", "\\left" + left_delim),
+              ...body.args.slice(1, body.args.length - 1).map(convert_typst_node_to_tex),
+              new TexNode("element", "\\right" + right_delim)
+            ]);
+          }
+        }
+        const command = typst_token_to_tex(node.content);
+        return new TexNode("unaryFunc", command, node.args.map(convert_typst_node_to_tex));
+      } else if (TYPST_BINARY_FUNCTIONS.includes(node.content)) {
+        if (node.content === "root") {
+          const [degree, radicand] = node.args;
+          const data = convert_typst_node_to_tex(degree);
+          return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
+        }
+        if (node.content === "overbrace" || node.content === "underbrace") {
+          const [body, label] = node.args;
+          const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
+          const script = convert_typst_node_to_tex(label);
+          const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
+          return new TexNode("supsub", "", [], data);
+        }
+        const command = typst_token_to_tex(node.content);
+        return new TexNode("binaryFunc", command, node.args.map(convert_typst_node_to_tex));
+      } else {
+        return new TexNode("ordgroup", "", [
+          new TexNode("symbol", typst_token_to_tex(node.content)),
+          new TexNode("element", "("),
+          ...node.args.map(convert_typst_node_to_tex),
+          new TexNode("element", ")")
+        ]);
+      }
     }
+    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) {
+        sup_tex = convert_typst_node_to_tex(sup);
+      }
+      if (sub) {
+        sub_tex = convert_typst_node_to_tex(sub);
+      }
+      const res = new TexNode("supsub", "", [], {
+        base: base_tex,
+        sup: sup_tex,
+        sub: sub_tex
+      });
+      return res;
+    }
+    case "matrix": {
+      const typst_data = node.data;
+      const tex_data = typst_data.map((row) => row.map(convert_typst_node_to_tex));
+      const matrix = new TexNode("beginend", "matrix", [], tex_data);
+      let left_delim = "\\left(";
+      let right_delim = "\\right)";
+      if (node.options) {
+        if ("delim" in node.options) {
+          switch (node.options.delim) {
+            case "#none":
+              return matrix;
+            case "[":
+              left_delim = "\\left[";
+              right_delim = "\\right]";
+              break;
+            case "]":
+              left_delim = "\\left]";
+              right_delim = "\\right[";
+              break;
+            case "{":
+              left_delim = "\\left\\{";
+              right_delim = "\\right\\}";
+              break;
+            case "}":
+              left_delim = "\\left\\}";
+              right_delim = "\\right\\{";
+              break;
+            case "|":
+              left_delim = "\\left|";
+              right_delim = "\\right|";
+              break;
+            case ")":
+              left_delim = "\\left)";
+              right_delim = "\\right(";
+            case "(":
+            default:
+              left_delim = "\\left(";
+              right_delim = "\\right)";
+              break;
+          }
+        }
+      }
+      return new TexNode("ordgroup", "", [
+        new TexNode("element", left_delim),
+        matrix,
+        new TexNode("element", right_delim)
+      ]);
+    }
+    case "control": {
+      switch (node.content) {
+        case "\\":
+          return new TexNode("control", "\\\\");
+        case "&":
+          return new TexNode("control", "&");
+        default:
+          throw new Error("[convert_typst_node_to_tex] Unimplemented control: " + node.content);
+      }
+    }
+    case "fraction": {
+      const [numerator, denominator] = node.args;
+      const num_tex = convert_typst_node_to_tex(numerator);
+      const den_tex = convert_typst_node_to_tex(denominator);
+      return new TexNode("binaryFunc", "\\frac", [num_tex, den_tex]);
+    }
+    default:
+      throw new Error("[convert_typst_node_to_tex] Unimplemented type: " + node.type);
   }
-  return token;
 }
 
 // src/typst-parser.ts
@@ -2793,37 +3054,6 @@ function parseTypst(typst) {
 }
 
 // src/tex-writer.ts
-var TYPST_UNARY_FUNCTIONS = [
-  "sqrt",
-  "bold",
-  "arrow",
-  "upright",
-  "lr",
-  "op",
-  "macron",
-  "dot",
-  "dot.double",
-  "hat",
-  "tilde",
-  "overline",
-  "underline",
-  "bb",
-  "cal",
-  "frak"
-];
-var TYPST_BINARY_FUNCTIONS = [
-  "frac",
-  "root",
-  "overbrace",
-  "underbrace"
-];
-function apply_escape_if_needed2(c) {
-  if (["{", "}", "%"].includes(c)) {
-    return "\\" + c;
-  }
-  return c;
-}
-
 class TexWriter {
   buffer = "";
   queue = [];
@@ -2875,180 +3105,6 @@ class TexWriter {
     return this.buffer;
   }
 }
-function convert_typst_node_to_tex(node) {
-  if (node.eq(new TypstNode("symbol", "eq.def"))) {
-    return new TexNode("binaryFunc", "\\overset", [
-      new TexNode("text", "def"),
-      new TexNode("element", "=")
-    ]);
-  }
-  switch (node.type) {
-    case "empty":
-      return new TexNode("empty", "");
-    case "whitespace":
-      return new TexNode("whitespace", node.content);
-    case "atom":
-      return new TexNode("element", node.content);
-    case "symbol":
-      switch (node.content) {
-        case "comma":
-          return new TexNode("element", ",");
-        case "hyph":
-        case "hyph.minus":
-          return new TexNode("text", "-");
-        default:
-          return new TexNode("symbol", typst_token_to_tex(node.content));
-      }
-    case "text":
-      return new TexNode("text", node.content);
-    case "comment":
-      return new TexNode("comment", node.content);
-    case "group": {
-      const args = node.args.map(convert_typst_node_to_tex);
-      if (node.content === "parenthesis") {
-        args.unshift(new TexNode("element", "("));
-        args.push(new TexNode("element", ")"));
-      }
-      return new TexNode("ordgroup", "", args);
-    }
-    case "funcCall": {
-      if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
-        if (node.content === "lr") {
-          const body = node.args[0];
-          if (body.type === "group") {
-            let left_delim = body.args[0].content;
-            let right_delim = body.args[body.args.length - 1].content;
-            left_delim = apply_escape_if_needed2(left_delim);
-            right_delim = apply_escape_if_needed2(right_delim);
-            return new TexNode("ordgroup", "", [
-              new TexNode("element", "\\left" + left_delim),
-              ...body.args.slice(1, body.args.length - 1).map(convert_typst_node_to_tex),
-              new TexNode("element", "\\right" + right_delim)
-            ]);
-          }
-        }
-        const command = typst_token_to_tex(node.content);
-        return new TexNode("unaryFunc", command, node.args.map(convert_typst_node_to_tex));
-      } else if (TYPST_BINARY_FUNCTIONS.includes(node.content)) {
-        if (node.content === "root") {
-          const [degree, radicand] = node.args;
-          const data = convert_typst_node_to_tex(degree);
-          return new TexNode("unaryFunc", "\\sqrt", [convert_typst_node_to_tex(radicand)], data);
-        }
-        if (node.content === "overbrace" || node.content === "underbrace") {
-          const [body, label] = node.args;
-          const base = new TexNode("unaryFunc", "\\" + node.content, [convert_typst_node_to_tex(body)]);
-          const script = convert_typst_node_to_tex(label);
-          const data = node.content === "overbrace" ? { base, sup: script } : { base, sub: script };
-          return new TexNode("supsub", "", [], data);
-        }
-        const command = typst_token_to_tex(node.content);
-        return new TexNode("binaryFunc", command, node.args.map(convert_typst_node_to_tex));
-      } else {
-        return new TexNode("ordgroup", "", [
-          new TexNode("symbol", typst_token_to_tex(node.content)),
-          new TexNode("element", "("),
-          ...node.args.map(convert_typst_node_to_tex),
-          new TexNode("element", ")")
-        ]);
-      }
-    }
-    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) {
-        sup_tex = convert_typst_node_to_tex(sup);
-      }
-      if (sub) {
-        sub_tex = convert_typst_node_to_tex(sub);
-      }
-      const res = new TexNode("supsub", "", [], {
-        base: base_tex,
-        sup: sup_tex,
-        sub: sub_tex
-      });
-      return res;
-    }
-    case "matrix": {
-      const typst_data = node.data;
-      const tex_data = typst_data.map((row) => row.map(convert_typst_node_to_tex));
-      const matrix = new TexNode("beginend", "matrix", [], tex_data);
-      let left_delim = "\\left(";
-      let right_delim = "\\right)";
-      if (node.options) {
-        if ("delim" in node.options) {
-          switch (node.options.delim) {
-            case "#none":
-              return matrix;
-            case "[":
-              left_delim = "\\left[";
-              right_delim = "\\right]";
-              break;
-            case "]":
-              left_delim = "\\left]";
-              right_delim = "\\right[";
-              break;
-            case "{":
-              left_delim = "\\left\\{";
-              right_delim = "\\right\\}";
-              break;
-            case "}":
-              left_delim = "\\left\\}";
-              right_delim = "\\right\\{";
-              break;
-            case "|":
-              left_delim = "\\left|";
-              right_delim = "\\right|";
-              break;
-            case ")":
-              left_delim = "\\left)";
-              right_delim = "\\right(";
-            case "(":
-            default:
-              left_delim = "\\left(";
-              right_delim = "\\right)";
-              break;
-          }
-        }
-      }
-      return new TexNode("ordgroup", "", [
-        new TexNode("element", left_delim),
-        matrix,
-        new TexNode("element", right_delim)
-      ]);
-    }
-    case "control": {
-      switch (node.content) {
-        case "\\":
-          return new TexNode("control", "\\\\");
-        case "&":
-          return new TexNode("control", "&");
-        default:
-          throw new Error("[convert_typst_node_to_tex] Unimplemented control: " + node.content);
-      }
-    }
-    case "fraction": {
-      const [numerator, denominator] = node.args;
-      const num_tex = convert_typst_node_to_tex(numerator);
-      const den_tex = convert_typst_node_to_tex(denominator);
-      return new TexNode("binaryFunc", "\\frac", [num_tex, den_tex]);
-    }
-    default:
-      throw new Error("[convert_typst_node_to_tex] Unimplemented type: " + node.type);
-  }
-}
-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);
-  }
-  return "\\" + token;
-}
 
 // src/index.ts
 function tex2typst(tex, options) {
@@ -3056,6 +3112,7 @@ function tex2typst(tex, options) {
     nonStrict: true,
     preferTypstIntrinsic: true,
     keepSpaces: false,
+    fracToSlash: true,
     customTexMacros: {}
   };
   if (options) {
@@ -3070,7 +3127,7 @@ function tex2typst(tex, options) {
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
-  const typstTree = convertTree(texTree);
+  const typstTree = convert_tex_node_to_typst(texTree, opt);
   const writer = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
   writer.serialize(typstTree);
   return writer.finalize();