tex2typst 0.3.0-alpha → 0.3.0-beta-1

package/dist/index.js

@@ -42,7 +42,7 @@ var symbolMap = new Map([
   ["approx", "approx"],
   ["cong", "tilde.equiv"],
   ["simeq", "tilde.eq"],
-  ["asymp", "\u224D"],
+  ["asymp", "≍"],
   ["equiv", "equiv"],
   ["propto", "prop"],
   ["gets", "arrow.l"],
@@ -1027,12 +1027,6 @@ function array_split(array, sep) {
 }
 
 // src/types.ts
-function apply_escape_if_needed(c) {
-  if (["{", "}", "%"].includes(c)) {
-    return "\\" + c;
-  }
-  return c;
-}
 class TexToken {
   type;
   value;
@@ -1054,6 +1048,12 @@ class TexToken {
     }
   }
 }
+function apply_escape_if_needed(c) {
+  if (["{", "}", "%"].includes(c)) {
+    return "\\" + c;
+  }
+  return c;
+}
 
 class TexNode {
   type;
@@ -1166,7 +1166,8 @@ class TexNode {
         let tokens = [];
         const matrix = this.data;
         tokens.push(new TexToken(1 /* COMMAND */, `\\begin{${this.content}}`));
-        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
+        tokens.push(new TexToken(5 /* NEWLINE */, `
+`));
         for (let i = 0;i < matrix.length; i++) {
           const row = matrix[i];
           for (let j = 0;j < row.length; j++) {
@@ -1180,7 +1181,8 @@ class TexNode {
             tokens.push(new TexToken(6 /* CONTROL */, "\\\\"));
           }
         }
-        tokens.push(new TexToken(5 /* NEWLINE */, "\n"));
+        tokens.push(new TexToken(5 /* NEWLINE */, `
+`));
         tokens.push(new TexToken(1 /* COMMAND */, `\\end{${this.content}}`));
         return tokens;
       }
@@ -1280,6 +1282,46 @@ function assert(condition, message = "") {
 }
 
 // src/tex-parser.ts
+var UNARY_COMMANDS = [
+  "sqrt",
+  "text",
+  "bar",
+  "bold",
+  "boldsymbol",
+  "ddot",
+  "dot",
+  "hat",
+  "mathbb",
+  "mathbf",
+  "mathcal",
+  "mathfrak",
+  "mathit",
+  "mathrm",
+  "mathscr",
+  "mathsf",
+  "mathtt",
+  "operatorname",
+  "overbrace",
+  "overline",
+  "pmb",
+  "rm",
+  "tilde",
+  "underbrace",
+  "underline",
+  "vec",
+  "widehat",
+  "widetilde"
+];
+var BINARY_COMMANDS = [
+  "frac",
+  "tfrac",
+  "binom",
+  "dbinom",
+  "dfrac",
+  "tbinom",
+  "overset"
+];
+var EMPTY_NODE = new TexNode("empty", "");
 function get_command_param_num(command) {
   if (UNARY_COMMANDS.includes(command)) {
     return 1;
@@ -1289,6 +1331,10 @@ function get_command_param_num(command) {
     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)) {
@@ -1298,7 +1344,7 @@ function eat_whitespaces(tokens, start) {
 }
 function eat_parenthesis(tokens, start) {
   const firstToken = tokens[start];
-  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}"].includes(firstToken.value)) {
+  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;
@@ -1337,9 +1383,13 @@ function find_closing_match(tokens, start, leftToken, rightToken) {
   }
   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);
 }
@@ -1373,7 +1423,8 @@ function tokenize(latex) {
     switch (firstChar) {
       case "%": {
         let newPos = pos + 1;
-        while (newPos < latex.length && latex[newPos] !== "\n") {
+        while (newPos < latex.length && latex[newPos] !== `
+`) {
           newPos += 1;
         }
         token = new TexToken(3 /* COMMENT */, latex.slice(pos + 1, newPos));
@@ -1388,16 +1439,20 @@ function tokenize(latex) {
         token = new TexToken(6 /* CONTROL */, firstChar);
         pos++;
         break;
-      case "\n":
+      case `
+`:
         token = new TexToken(5 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
-        if (pos + 1 < latex.length && latex[pos + 1] === "\n") {
-          token = new TexToken(5 /* NEWLINE */, "\n");
+        if (pos + 1 < latex.length && latex[pos + 1] === `
+`) {
+          token = new TexToken(5 /* NEWLINE */, `
+`);
           pos += 2;
         } else {
-          token = new TexToken(5 /* NEWLINE */, "\n");
+          token = new TexToken(5 /* NEWLINE */, `
+`);
           pos++;
         }
         break;
@@ -1436,7 +1491,7 @@ function tokenize(latex) {
           token = new TexToken(0 /* ELEMENT */, latex.slice(pos, newPos));
         } else if (isalpha(firstChar)) {
           token = new TexToken(0 /* ELEMENT */, firstChar);
-        } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
+        } else if ("+-*/='<>!.,;?()[]|".includes(firstChar)) {
           token = new TexToken(0 /* ELEMENT */, firstChar);
         } else {
           token = new TexToken(7 /* UNKNOWN */, firstChar);
@@ -1464,87 +1519,6 @@ function tokenize(latex) {
   }
   return tokens;
 }
-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++) {
-    if (tokens[i].type === 4 /* SPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
-      continue;
-    }
-    if (tokens[i].type === 4 /* SPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
-      continue;
-    }
-    out_tokens.push(tokens[i]);
-  }
-  return out_tokens;
-}
-function passExpandCustomTexMacros(tokens, customTexMacros) {
-  let out_tokens = [];
-  for (const token of tokens) {
-    if (token.type === 1 /* COMMAND */ && customTexMacros[token.value]) {
-      const expanded_tokens = tokenize(customTexMacros[token.value]);
-      out_tokens = out_tokens.concat(expanded_tokens);
-    } else {
-      out_tokens.push(token);
-    }
-  }
-  return out_tokens;
-}
-function parseTex(tex, customTexMacros) {
-  const parser = new LatexParser;
-  let tokens = tokenize(tex);
-  tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
-  tokens = passExpandCustomTexMacros(tokens, customTexMacros);
-  return parser.parse(tokens);
-}
-var UNARY_COMMANDS = [
-  "sqrt",
-  "text",
-  "bar",
-  "bold",
-  "boldsymbol",
-  "ddot",
-  "dot",
-  "hat",
-  "mathbb",
-  "mathbf",
-  "mathcal",
-  "mathfrak",
-  "mathit",
-  "mathrm",
-  "mathscr",
-  "mathsf",
-  "mathtt",
-  "operatorname",
-  "overbrace",
-  "overline",
-  "pmb",
-  "rm",
-  "tilde",
-  "underbrace",
-  "underline",
-  "vec",
-  "widehat",
-  "widetilde"
-];
-var BINARY_COMMANDS = [
-  "frac",
-  "tfrac",
-  "binom",
-  "dbinom",
-  "dfrac",
-  "tbinom",
-  "overset"
-];
-var EMPTY_NODE = new TexNode("empty", "");
-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 */, "]");
-var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
-var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
-var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
-var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
 
 class LatexParserError extends Error {
   constructor(message) {
@@ -1575,7 +1549,8 @@ class LatexParser {
           if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
             continue;
           }
-          if (!this.newline_sensitive && res.content === "\n") {
+          if (!this.newline_sensitive && res.content === `
+`) {
             continue;
           }
         }
@@ -1826,7 +1801,8 @@ class LatexParser {
         if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === "\n") {
+        if (!this.newline_sensitive && res.content === `
+`) {
           continue;
         }
       }
@@ -1845,10 +1821,52 @@ 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++) {
+    if (tokens[i].type === 4 /* SPACE */ && i + 1 < tokens.length && is_script_mark(tokens[i + 1])) {
+      continue;
+    }
+    if (tokens[i].type === 4 /* SPACE */ && i - 1 >= 0 && is_script_mark(tokens[i - 1])) {
+      continue;
+    }
+    out_tokens.push(tokens[i]);
+  }
+  return out_tokens;
+}
+function passExpandCustomTexMacros(tokens, customTexMacros) {
+  let out_tokens = [];
+  for (const token of tokens) {
+    if (token.type === 1 /* COMMAND */ && customTexMacros[token.value]) {
+      const expanded_tokens = tokenize(customTexMacros[token.value]);
+      out_tokens = out_tokens.concat(expanded_tokens);
+    } else {
+      out_tokens.push(token);
+    }
+  }
+  return out_tokens;
+}
+function parseTex(tex, customTexMacros) {
+  const parser = new LatexParser;
+  let tokens = tokenize(tex);
+  tokens = passIgnoreWhitespaceBeforeScriptMark(tokens);
+  tokens = passExpandCustomTexMacros(tokens, customTexMacros);
+  return parser.parse(tokens);
+}
 
 // src/writer.ts
+var TYPST_INTRINSIC_SYMBOLS = [
+  "dim",
+  "id",
+  "im",
+  "mod",
+  "Pr",
+  "sech",
+  "csch"
+];
 function is_delimiter(c) {
-  return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
+  return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "⌊", "⌋", "⌈", "⌉"].includes(c.content);
 }
 function convert_overset(node) {
   const [sup, base] = node.args;
@@ -1878,178 +1896,37 @@ function convert_overset(node) {
     sup: convertTree(sup)
   });
 }
-function convertTree(node) {
-  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));
-    case "element":
-      return new TypstNode("atom", convertToken(node.content));
-    case "symbol":
-      return new TypstNode("symbol", convertToken(node.content));
-    case "text":
-      return new TypstNode("text", node.content);
-    case "comment":
-      return new TypstNode("comment", node.content);
-    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)]);
-      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
-        return new TypstNode("funcCall", "underbrace", [convertTree(base.args[0]), convertTree(sub)]);
-      }
-      const data = {
-        base: convertTree(base)
-      };
-      if (data.base.type === "empty") {
-        data.base = new TypstNode("text", "");
-      }
-      if (sup) {
-        data.sup = convertTree(sup);
-      }
-      if (sub) {
-        data.sub = convertTree(sub);
-      }
-      return new TypstNode("supsub", "", [], data);
-    }
-    case "leftright": {
-      const [left, body, right] = node.args;
-      const group = new TypstNode("group", "", node.args.map(convertTree));
-      if ([
-        "[]",
-        "()",
-        "\\{\\}",
-        "\\lfloor\\rfloor",
-        "\\lceil\\rceil",
-        "\\lfloor\\rceil"
-      ].includes(left.content + right.content)) {
-        return group;
-      }
-      return new TypstNode("funcCall", "lr", [group]);
-    }
-    case "binaryFunc": {
-      if (node.content === "\\overset") {
-        return convert_overset(node);
-      }
-      return new TypstNode("funcCall", convertToken(node.content), node.args.map(convertTree));
-    }
-    case "unaryFunc": {
-      const arg0 = convertTree(node.args[0]);
-      if (node.content === "\\sqrt" && node.data) {
-        const data = convertTree(node.data);
-        return new TypstNode("funcCall", "root", [data, arg0]);
-      }
-      if (node.content === "\\mathbf") {
-        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);
-      }
-      if (node.content === "\\operatorname") {
-        const body = node.args;
-        if (body.length !== 1 || body[0].type !== "text") {
-          throw new TypstWriterError(`Expecting body of \\operatorname to be text but got`, node);
-        }
-        const text = body[0].content;
-        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", convertToken(node.content), node.args.map(convertTree));
-    }
-    case "beginend": {
-      const matrix = node.data;
-      const data = matrix.map((row) => row.map(convertTree));
-      if (node.content.startsWith("align")) {
-        return new TypstNode("align", "", [], data);
-      } else {
-        const res = new TypstNode("matrix", "", [], data);
-        res.setOptions({ delim: "#none" });
-        return res;
-      }
-    }
-    case "unknownMacro":
-      return new TypstNode("unknown", convertToken(node.content));
-    case "control":
-      if (node.content === "\\\\") {
-        return new TypstNode("symbol", "\\");
-      } else if (node.content === "\\,") {
-        return new TypstNode("symbol", "thin");
-      } else {
-        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
-      }
-    default:
-      throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
-  }
-}
-function convertToken(token) {
-  if (/^[a-zA-Z0-9]$/.test(token)) {
-    return token;
-  } else if (token === "/") {
-    return "\\/";
-  } else if (token === "\\|") {
-    return "parallel";
-  } else if (token === "\\colon") {
-    return ":";
-  } 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;
-}
-var TYPST_INTRINSIC_SYMBOLS = [
-  "dim",
-  "id",
-  "im",
-  "mod",
-  "Pr",
-  "sech",
-  "csch"
-];
-var TYPST_LEFT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, "(");
-var TYPST_RIGHT_PARENTHESIS = new TypstToken(1 /* ELEMENT */, ")");
-var TYPST_COMMA = new TypstToken(1 /* ELEMENT */, ",");
-var TYPST_NEWLINE = new TypstToken(0 /* SYMBOL */, "\n");
-
-class TypstWriterError extends Error {
-  node;
-  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;
-  }
-  writeBuffer(token) {
-    const str = token.toString();
-    if (str === "") {
-      return;
+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;
+  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;
+  }
+  writeBuffer(token) {
+    const str = token.toString();
+    if (str === "") {
+      return;
     }
     let no_need_space = false;
     no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.test(str);
@@ -2058,7 +1935,8 @@ 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("\n");
+    no_need_space ||= str.startsWith(`
+`);
     no_need_space ||= this.buffer === "";
     no_need_space ||= /^\s/.test(str);
     no_need_space ||= this.buffer.endsWith("&") && str === "=";
@@ -2095,7 +1973,8 @@ class TypstWriter {
             if (this.keepSpaces) {
               this.queue.push(new TypstToken(4 /* SPACE */, c));
             }
-          } else if (c === "\n") {
+          } else if (c === `
+`) {
             this.queue.push(new TypstToken(0 /* SYMBOL */, c));
           } else {
             throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
@@ -2111,9 +1990,9 @@ class TypstWriter {
         let { base, sup, sub } = node.data;
         this.appendWithBracketsIfNeeded(base);
         let trailing_space_needed = false;
-        const has_prime = sup && sup.type === "atom" && sup.content === "\'";
+        const has_prime = sup && sup.type === "atom" && sup.content === "'";
         if (has_prime) {
-          this.queue.push(new TypstToken(1 /* ELEMENT */, "\'"));
+          this.queue.push(new TypstToken(1 /* ELEMENT */, "'"));
           trailing_space_needed = false;
         }
         if (sub) {
@@ -2261,6 +2140,146 @@ class TypstWriter {
     return this.buffer;
   }
 }
+function convertTree(node) {
+  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));
+    case "element":
+      return new TypstNode("atom", convertToken(node.content));
+    case "symbol":
+      return new TypstNode("symbol", convertToken(node.content));
+    case "text":
+      return new TypstNode("text", node.content);
+    case "comment":
+      return new TypstNode("comment", node.content);
+    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)]);
+      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
+        return new TypstNode("funcCall", "underbrace", [convertTree(base.args[0]), convertTree(sub)]);
+      }
+      const data = {
+        base: convertTree(base)
+      };
+      if (data.base.type === "empty") {
+        data.base = new TypstNode("text", "");
+      }
+      if (sup) {
+        data.sup = convertTree(sup);
+      }
+      if (sub) {
+        data.sub = convertTree(sub);
+      }
+      return new TypstNode("supsub", "", [], data);
+    }
+    case "leftright": {
+      const [left, body, right] = node.args;
+      const group = new TypstNode("group", "", node.args.map(convertTree));
+      if ([
+        "[]",
+        "()",
+        "\\{\\}",
+        "\\lfloor\\rfloor",
+        "\\lceil\\rceil",
+        "\\lfloor\\rceil"
+      ].includes(left.content + right.content)) {
+        return group;
+      }
+      if (right.content === ".") {
+        group.args.pop();
+        return group;
+      } else if (left.content === ".") {
+        group.args.shift();
+        return new TypstNode("funcCall", "lr", [group]);
+      }
+      return new TypstNode("funcCall", "lr", [group]);
+    }
+    case "binaryFunc": {
+      if (node.content === "\\overset") {
+        return convert_overset(node);
+      }
+      return new TypstNode("funcCall", convertToken(node.content), node.args.map(convertTree));
+    }
+    case "unaryFunc": {
+      const arg0 = convertTree(node.args[0]);
+      if (node.content === "\\sqrt" && node.data) {
+        const data = convertTree(node.data);
+        return new TypstNode("funcCall", "root", [data, arg0]);
+      }
+      if (node.content === "\\mathbf") {
+        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);
+      }
+      if (node.content === "\\operatorname") {
+        const body = node.args;
+        if (body.length !== 1 || body[0].type !== "text") {
+          throw new TypstWriterError(`Expecting body of \\operatorname to be text but got`, node);
+        }
+        const text = body[0].content;
+        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", convertToken(node.content), node.args.map(convertTree));
+    }
+    case "beginend": {
+      const matrix = node.data;
+      const data = matrix.map((row) => row.map(convertTree));
+      if (node.content.startsWith("align")) {
+        return new TypstNode("align", "", [], data);
+      } else {
+        const res = new TypstNode("matrix", "", [], data);
+        res.setOptions({ delim: "#none" });
+        return res;
+      }
+    }
+    case "unknownMacro":
+      return new TypstNode("unknown", convertToken(node.content));
+    case "control":
+      if (node.content === "\\\\") {
+        return new TypstNode("symbol", "\\");
+      } else if (node.content === "\\,") {
+        return new TypstNode("symbol", "thin");
+      } else {
+        throw new TypstWriterError(`Unknown control sequence: ${node.content}`, node);
+      }
+    default:
+      throw new TypstWriterError(`Unimplemented node type: ${node.type}`, node);
+  }
+}
+function convertToken(token) {
+  if (/^[a-zA-Z0-9]$/.test(token)) {
+    return token;
+  } else if (token === "/") {
+    return "\\/";
+  } else if (token === "\\|") {
+    return "parallel";
+  } else if (token === "\\colon") {
+    return ":";
+  } 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;
+}
 
 // src/typst-parser.ts
 function eat_primes2(tokens, start) {
@@ -2277,6 +2296,7 @@ function eat_identifier_name(typst, start) {
   }
   return typst.substring(start, pos);
 }
+var TYPST_EMPTY_NODE = new TypstNode("empty", "");
 function tokenize_typst(typst) {
   const tokens = [];
   let pos = 0;
@@ -2290,16 +2310,20 @@ function tokenize_typst(typst) {
         token = new TypstToken(6 /* CONTROL */, firstChar);
         pos++;
         break;
-      case "\n":
+      case `
+`:
         token = new TypstToken(7 /* NEWLINE */, firstChar);
         pos++;
         break;
       case "\r": {
-        if (pos + 1 < typst.length && typst[pos + 1] === "\n") {
-          token = new TypstToken(7 /* NEWLINE */, "\n");
+        if (pos + 1 < typst.length && typst[pos + 1] === `
+`) {
+          token = new TypstToken(7 /* NEWLINE */, `
+`);
           pos += 2;
         } else {
-          token = new TypstToken(7 /* NEWLINE */, "\n");
+          token = new TypstToken(7 /* NEWLINE */, `
+`);
           pos++;
         }
         break;
@@ -2316,7 +2340,8 @@ function tokenize_typst(typst) {
       case "/": {
         if (pos < typst.length && typst[pos + 1] === "/") {
           let newPos = pos + 2;
-          while (newPos < typst.length && typst[newPos] !== "\n") {
+          while (newPos < typst.length && typst[newPos] !== `
+`) {
             newPos++;
           }
           token = new TypstToken(3 /* COMMENT */, typst.slice(pos + 2, newPos));
@@ -2368,7 +2393,7 @@ function tokenize_typst(typst) {
             newPos += 1;
           }
           token = new TypstToken(1 /* ELEMENT */, typst.slice(pos, newPos));
-        } else if ("+-*/=\'<>!.,;?()[]|".includes(firstChar)) {
+        } else if ("+-*/='<>!.,;?()[]|".includes(firstChar)) {
           token = new TypstToken(1 /* ELEMENT */, firstChar);
         } else if (isalpha(firstChar)) {
           const identifier = eat_identifier_name(typst, pos);
@@ -2427,6 +2452,7 @@ function primes(num) {
   }
   return res;
 }
+var DIV = new TypstNode("atom", "/");
 function next_non_whitespace(nodes, start) {
   let pos = start;
   while (pos < nodes.length && nodes[pos].type === "whitespace") {
@@ -2511,13 +2537,6 @@ function process_operators(nodes, parenthesis = false) {
     }
   }
 }
-function parseTypst(typst) {
-  const parser = new TypstParser;
-  let tokens = tokenize_typst(typst);
-  return parser.parse(tokens);
-}
-var TYPST_EMPTY_NODE = new TypstNode("empty", "");
-var DIV = new TypstNode("atom", "/");
 
 class TypstParserError extends Error {
   constructor(message) {
@@ -2558,7 +2577,8 @@ class TypstParser {
         if (!this.space_sensitive && res.content.replace(/ /g, "").length === 0) {
           continue;
         }
-        if (!this.newline_sensitive && res.content === "\n") {
+        if (!this.newline_sensitive && res.content === `
+`) {
           continue;
         }
       }
@@ -2700,14 +2720,95 @@ class TypstParser {
     return args;
   }
 }
+function parseTypst(typst) {
+  const parser = new TypstParser;
+  let tokens = tokenize_typst(typst);
+  return parser.parse(tokens);
+}
 
 // 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 = [];
+  writeBuffer(token) {
+    const str = token.toString();
+    let no_need_space = false;
+    if (token.type === 4 /* SPACE */) {
+      no_need_space = true;
+    } else {
+      no_need_space ||= /[{\(\[\|]$/.test(this.buffer);
+      no_need_space ||= /\\\w+$/.test(this.buffer) && str === "[";
+      no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
+      no_need_space ||= ["\\{", "\\}"].includes(str);
+      no_need_space ||= str === "'";
+      no_need_space ||= this.buffer.endsWith("_") || this.buffer.endsWith("^");
+      no_need_space ||= /\s$/.test(this.buffer);
+      no_need_space ||= /^\s/.test(str);
+      no_need_space ||= this.buffer === "";
+      no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
+      no_need_space ||= this.buffer.endsWith("&") && str === "=";
+    }
+    if (!no_need_space) {
+      this.buffer += " ";
+    }
+    this.buffer += str;
+  }
+  append(node) {
+    const alignment_char = new TexNode("control", "&");
+    const newline_char = new TexNode("control", "\\\\");
+    if (node.type === "ordgroup" && array_includes(node.args, alignment_char)) {
+      const rows = array_split(node.args, newline_char);
+      const data = [];
+      for (const row of rows) {
+        const cells = array_split(row, alignment_char);
+        data.push(cells.map((cell) => new TexNode("ordgroup", "", cell)));
+      }
+      node = new TexNode("beginend", "aligned", [], data);
+    }
+    this.queue = this.queue.concat(node.serialize());
+  }
+  flushQueue() {
+    for (let i = 0;i < this.queue.length; i++) {
+      this.writeBuffer(this.queue[i]);
+    }
+    this.queue = [];
+  }
+  finalize() {
+    this.flushQueue();
+    return this.buffer;
+  }
+}
 function convert_typst_node_to_tex(node) {
   if (node.eq(new TypstNode("symbol", "eq.def"))) {
     return new TexNode("binaryFunc", "\\overset", [
@@ -2842,82 +2943,6 @@ function typst_token_to_tex(token) {
   }
   return "\\" + 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"
-];
-
-class TexWriter {
-  buffer = "";
-  queue = [];
-  writeBuffer(token) {
-    const str = token.toString();
-    let no_need_space = false;
-    if (token.type === 4 /* SPACE */) {
-      no_need_space = true;
-    } else {
-      no_need_space ||= /[{\(\[\|]$/.test(this.buffer);
-      no_need_space ||= /\\\w+$/.test(this.buffer) && str === "[";
-      no_need_space ||= /^[\.,;:!\?\(\)\]{}_^]$/.test(str);
-      no_need_space ||= ["\\{", "\\}"].includes(str);
-      no_need_space ||= str === "'";
-      no_need_space ||= this.buffer.endsWith("_") || this.buffer.endsWith("^");
-      no_need_space ||= /\s$/.test(this.buffer);
-      no_need_space ||= /^\s/.test(str);
-      no_need_space ||= this.buffer === "";
-      no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
-      no_need_space ||= this.buffer.endsWith("&") && str === "=";
-    }
-    if (!no_need_space) {
-      this.buffer += " ";
-    }
-    this.buffer += str;
-  }
-  append(node) {
-    const alignment_char = new TexNode("control", "&");
-    const newline_char = new TexNode("control", "\\\\");
-    if (node.type === "ordgroup" && array_includes(node.args, alignment_char)) {
-      const rows = array_split(node.args, newline_char);
-      const data = [];
-      for (const row of rows) {
-        const cells = array_split(row, alignment_char);
-        data.push(cells.map((cell) => new TexNode("ordgroup", "", cell)));
-      }
-      node = new TexNode("beginend", "aligned", [], data);
-    }
-    this.queue = this.queue.concat(node.serialize());
-  }
-  flushQueue() {
-    for (let i = 0;i < this.queue.length; i++) {
-      this.writeBuffer(this.queue[i]);
-    }
-    this.queue = [];
-  }
-  finalize() {
-    this.flushQueue();
-    return this.buffer;
-  }
-}
 
 // src/index.ts
 function tex2typst(tex, options) {
@@ -2940,16 +2965,16 @@ function tex2typst(tex, options) {
   }
   const texTree = parseTex(tex, opt.customTexMacros);
   const typstTree = convertTree(texTree);
-  const writer2 = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
-  writer2.serialize(typstTree);
-  return writer2.finalize();
+  const writer = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
+  writer.serialize(typstTree);
+  return writer.finalize();
 }
 function typst2tex(typst) {
   const typstTree = parseTypst(typst);
   const texTree = convert_typst_node_to_tex(typstTree);
-  const writer2 = new TexWriter;
-  writer2.append(texTree);
-  return writer2.finalize();
+  const writer = new TexWriter;
+  writer.append(texTree);
+  return writer.finalize();
 }
 export {
   typst2tex,