tex2typst 0.5.4 → 0.5.6

package/dist/index.js

@@ -584,7 +584,9 @@ var TEX_UNARY_COMMANDS = [
   "Bra",
   "Ket",
   "Braket",
-  "Set"
+  "Set",
+  "pmod",
+  "cancel"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -727,7 +729,7 @@ function eat_whitespaces(tokens, start) {
 }
 function eat_parenthesis(tokens, start) {
   const firstToken = tokens[start];
-  if (firstToken.type === 1 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
+  if (firstToken.type === 1 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|", "<", ">"].includes(firstToken.value)) {
     return firstToken;
   } else if (firstToken.type === 2 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle", "lparen", "rparen", "lbrace", "rbrace"].includes(firstToken.value.slice(1))) {
     return firstToken;
@@ -742,6 +744,29 @@ function eat_primes(tokens, start) {
   }
   return pos - start;
 }
+function process_styled_parts(nodes) {
+  let style_token = null;
+  let bucket = [];
+  let res = [];
+  let i = 0;
+  while (true) {
+    if (i === nodes.length || nodes[i].head.eq(TexToken.COMMAND_DISPLAYSTYLE) || nodes[i].head.eq(TexToken.COMMAND_TEXTSTYLE)) {
+      if (bucket.length > 0) {
+        const g = bucket.length === 1 ? bucket[0] : new TexGroup(bucket);
+        res.push(style_token ? new TexFuncCall(style_token, [g]) : g);
+      }
+      if (i === nodes.length) {
+        break;
+      }
+      bucket = [];
+      style_token = nodes[i].head;
+    } else {
+      bucket.push(nodes[i]);
+    }
+    i++;
+  }
+  return res;
+}
 var LEFT_COMMAND = new TexToken(2 /* COMMAND */, "\\left");
 var RIGHT_COMMAND = new TexToken(2 /* COMMAND */, "\\right");
 var BEGIN_COMMAND = new TexToken(2 /* COMMAND */, "\\begin");
@@ -803,7 +828,7 @@ var LatexParser = class {
     if (pos >= tokens.length && closingToken !== null) {
       return [EMPTY_NODE, -1];
     }
-    const styledResults = this.applyStyleCommands(results);
+    const styledResults = process_styled_parts(results);
     let node;
     if (styledResults.length === 1) {
       node = styledResults[0];
@@ -1089,34 +1114,6 @@ var LatexParser = class {
     this.alignmentDepth--;
     return [allRows, pos];
   }
-  applyStyleCommands(nodes) {
-    for (let i = 0; i < nodes.length; i++) {
-      const styleToken = this.getStyleToken(nodes[i]);
-      if (styleToken) {
-        const before = this.applyStyleCommands(nodes.slice(0, i));
-        const after = this.applyStyleCommands(nodes.slice(i + 1));
-        let body;
-        if (after.length === 0) {
-          body = EMPTY_NODE;
-        } else if (after.length === 1) {
-          body = after[0];
-        } else {
-          body = new TexGroup(after);
-        }
-        const funcCall = new TexFuncCall(styleToken, [body]);
-        return before.concat(funcCall);
-      }
-    }
-    return nodes;
-  }
-  getStyleToken(node) {
-    if (node.type === "terminal") {
-      if (node.head.eq(TexToken.COMMAND_DISPLAYSTYLE) || node.head.eq(TexToken.COMMAND_TEXTSTYLE)) {
-        return node.head;
-      }
-    }
-    return null;
-  }
 };
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
   const is_script_mark = (token) => token.eq(SUB_SYMBOL) || token.eq(SUP_SYMBOL);
@@ -1174,6 +1171,8 @@ var shorthandMap = /* @__PURE__ */ new Map([
   ["dots.h", "..."],
   ["gt.triple", ">>>"],
   ["lt.triple", "<<<"],
+  ["arrow.l.r", "<->"],
+  // Typst's documentation doesn't include this. Wondering why
   ["arrow.r", "->"],
   ["arrow.r.double", "=>"],
   ["arrow.r.squiggly", "~>"],
@@ -1191,9 +1190,7 @@ var shorthandMap = /* @__PURE__ */ new Map([
   ["lt.eq", "<="],
   ["ast.op", "*"],
   ["minus", "-"],
-  ["tilde.op", "~"],
-  // Typst's documentation doesn't include this. Wondering why
-  ["arrow.l.r", "<->"]
+  ["tilde.op", "~"]
 ]);
 var reverseShorthandMap = /* @__PURE__ */ new Map();
 for (const [key, value] of shorthandMap.entries()) {
@@ -1233,6 +1230,8 @@ var TypstToken = class _TypstToken {
   static EMPTY = new _TypstToken(2 /* ELEMENT */, "");
   static LEFT_BRACE = new _TypstToken(2 /* ELEMENT */, "{");
   static RIGHT_BRACE = new _TypstToken(2 /* ELEMENT */, "}");
+  static LEFT_PAREN = new _TypstToken(2 /* ELEMENT */, "(");
+  static RIGHT_PAREN = new _TypstToken(2 /* ELEMENT */, ")");
   static LEFT_ANGLE = new _TypstToken(1 /* SYMBOL */, "chevron.l");
   static RIGHT_ANGLE = new _TypstToken(1 /* SYMBOL */, "chevron.r");
   static VERTICAL_BAR = new _TypstToken(2 /* ELEMENT */, "|");
@@ -1240,7 +1239,7 @@ var TypstToken = class _TypstToken {
   static MINUS = new _TypstToken(2 /* ELEMENT */, "-");
   static LR = new _TypstToken(1 /* SYMBOL */, "lr");
   static LEFT_DELIMITERS = [
-    new _TypstToken(2 /* ELEMENT */, "("),
+    _TypstToken.LEFT_PAREN,
     new _TypstToken(2 /* ELEMENT */, "["),
     _TypstToken.LEFT_BRACE,
     _TypstToken.VERTICAL_BAR,
@@ -1249,7 +1248,7 @@ var TypstToken = class _TypstToken {
     new _TypstToken(1 /* SYMBOL */, "brace.l")
   ];
   static RIGHT_DELIMITERS = [
-    new _TypstToken(2 /* ELEMENT */, ")"),
+    _TypstToken.RIGHT_PAREN,
     new _TypstToken(2 /* ELEMENT */, "]"),
     _TypstToken.RIGHT_BRACE,
     _TypstToken.VERTICAL_BAR,
@@ -1303,7 +1302,7 @@ var TypstTerminal = class extends TypstNode {
         return true;
       case 1 /* SYMBOL */:
       case 2 /* ELEMENT */: {
-        if (["(", "!", "}", "]"].includes(this.head.value)) {
+        if (["(", "!", ",", ")", "}", "]"].includes(this.head.value)) {
           return false;
         }
         return true;
@@ -1333,7 +1332,7 @@ var TypstTerminal = class extends TypstNode {
   serialize(env, options) {
     if (this.head.type === 2 /* ELEMENT */) {
       if (this.head.value === "," && env.insideFunctionDepth > 0) {
-        return [new TypstToken(1 /* SYMBOL */, "comma")];
+        return [SOFT_SPACE, new TypstToken(1 /* SYMBOL */, "comma")];
       }
     } else if (this.head.type === 1 /* SYMBOL */) {
       let symbol_name = this.head.value;
@@ -1364,6 +1363,40 @@ var TypstTerminal = class extends TypstNode {
     return [this.head];
   }
 };
+var TypstTokenQueue = class {
+  queue = [];
+  pushSoftSpace() {
+    if (this.queue.length === 0) {
+      return;
+    } else if (this.queue.at(-1).eq(SOFT_SPACE)) {
+      return;
+    } else if (["(", "{", "["].includes(this.queue.at(-1).value)) {
+      return;
+    }
+    this.queue.push(SOFT_SPACE);
+  }
+  pushAll(tokens) {
+    if (tokens.length == 0) {
+      return;
+    } else if (tokens[0].eq(SOFT_SPACE) && this.queue.length === 0) {
+      this.queue.push(...tokens.slice(1));
+    } else {
+      if ([")", "}", "]"].includes(tokens[0].value)) {
+        while (this.queue.at(-1)?.eq(SOFT_SPACE)) {
+          this.queue.pop();
+        }
+      }
+      this.queue.push(...tokens);
+    }
+  }
+  getQueue() {
+    const res = Array.from(this.queue);
+    while (res.at(-1)?.eq(SOFT_SPACE)) {
+      res.pop();
+    }
+    return res;
+  }
+};
 var TypstGroup = class extends TypstNode {
   items;
   constructor(items) {
@@ -1389,28 +1422,19 @@ var TypstGroup = class extends TypstNode {
     if (this.items.length === 0) {
       return [];
     }
-    const queue = [];
+    const q = new TypstTokenQueue();
     for (let i = 0; i < this.items.length; i++) {
       const n = this.items[i];
       const tokens = n.serialize(env, options);
-      if (n.isLeftSpaceful() && i > 0) {
-        if (queue.length > 0) {
-          const top = queue.at(-1);
-          let no_need_space = false;
-          no_need_space ||= top.eq(SOFT_SPACE);
-          no_need_space ||= ["{", "["].includes(top.value);
-          if (!no_need_space) {
-            queue.push(SOFT_SPACE);
-          }
-        }
+      if (n.isLeftSpaceful()) {
+        q.pushSoftSpace();
       }
-      queue.push(...tokens);
-      if (n.isRightSpaceful() && i < this.items.length - 1) {
-        if (!queue.at(-1)?.eq(SOFT_SPACE)) {
-          queue.push(SOFT_SPACE);
-        }
+      q.pushAll(tokens);
+      if (n.isRightSpaceful()) {
+        q.pushSoftSpace();
       }
     }
+    const queue = q.getQueue();
     if (queue.length > 0 && (queue[0].eq(TypstToken.MINUS) || queue[0].eq(TypstToken.PLUS))) {
       while (queue.length > 1 && queue[1].eq(SOFT_SPACE)) {
         queue.splice(1, 1);
@@ -1615,7 +1639,9 @@ var TypstMatrixLike = class _TypstMatrixLike extends TypstNode {
       row.forEach((cell, j) => {
         queue.push(...cell.serialize(env, options));
         if (j < row.length - 1) {
-          queue.push(SOFT_SPACE);
+          if (cell_sep.value === "&") {
+            queue.push(SOFT_SPACE);
+          }
           queue.push(cell_sep);
           queue.push(SOFT_SPACE);
         } else {
@@ -1688,9 +1714,6 @@ var TypstMarkupFunc = class extends TypstNode {
 };
 
 // src/typst-writer.ts
-var TYPST_LEFT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, "(");
-var TYPST_RIGHT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, ")");
-var TYPST_COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(1 /* SYMBOL */, "\n");
 var SOFT_SPACE2 = new TypstToken(7 /* CONTROL */, " ");
 var TypstWriter = class {
@@ -1718,15 +1741,13 @@ var TypstWriter = class {
     for (let i = 0; i < qu.length; i++) {
       let token = qu[i];
       if (token.eq(SOFT_SPACE2)) {
-        const to_delete = i === 0 || i === qu.length - 1 || qu[i - 1].type === 6 /* SPACE */ || qu[i - 1].isOneOf([TYPST_LEFT_PARENTHESIS2, TYPST_NEWLINE]) || qu[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS2, TYPST_COMMA, TYPST_NEWLINE]);
+        const to_delete = i === 0 || i === qu.length - 1 || qu[i - 1].type === 6 /* SPACE */ || qu[i - 1].eq(TYPST_NEWLINE) || qu[i + 1].eq(TYPST_NEWLINE);
         if (to_delete) {
           qu[i] = dummy_token;
         }
       }
     }
-    qu = qu.filter((token) => !token.eq(dummy_token));
-    for (let i = 0; i < qu.length; i++) {
-      let token = qu[i];
+    for (const token of qu) {
       this.buffer += token.toString();
     }
     this.queue = [];
@@ -1803,6 +1824,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["tilde", "tilde"],
   ["hat", "hat"],
   ["sqrt", "sqrt"],
+  ["bmod", "mod"],
   ["nonumber", ""],
   ["vec", "arrow"],
   ["neq", "eq.not"],
@@ -1827,6 +1849,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["tbinom", "binom"],
   ["dfrac", "frac"],
   ["tfrac", "frac"],
+  ["cancel", "cancel"],
   ["operatorname", "op"],
   ["operatorname*", "op"],
   ["boldsymbol", "bold"],
@@ -3048,14 +3071,14 @@ function convert_tex_array_align_literal(alignLiteral) {
   }
   return np;
 }
-var TYPST_LEFT_PARENTHESIS3 = new TypstToken(2 /* ELEMENT */, "(");
-var TYPST_RIGHT_PARENTHESIS3 = new TypstToken(2 /* ELEMENT */, ")");
+var TYPST_LEFT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, "(");
+var TYPST_RIGHT_PARENTHESIS2 = new TypstToken(2 /* ELEMENT */, ")");
 function appendWithBracketsIfNeeded(node) {
   let need_to_wrap = ["group", "supsub", "matrixLike", "fraction", "empty"].includes(node.type);
   if (need_to_wrap) {
     return new TypstLeftright(null, {
-      left: TYPST_LEFT_PARENTHESIS3,
-      right: TYPST_RIGHT_PARENTHESIS3,
+      left: TYPST_LEFT_PARENTHESIS2,
+      right: TYPST_RIGHT_PARENTHESIS2,
       body: node
     });
   } else {
@@ -3136,6 +3159,12 @@ function convert_tex_node_to_typst(abstractNode, options) {
       };
       let typ_left = left ? tex_token_to_typst(left, options) : null;
       let typ_right = right ? tex_token_to_typst(right, options) : null;
+      if (typ_left && typ_left.value === "<") {
+        typ_left = new TypstToken(1 /* SYMBOL */, "chevron.l");
+      }
+      if (typ_right && typ_right.value === ">") {
+        typ_right = new TypstToken(1 /* SYMBOL */, "chevron.r");
+      }
       if (typ_left === null && typ_right !== null) {
         typ_right = escape_curly_or_paren(typ_right);
       }
@@ -3240,6 +3269,13 @@ function convert_tex_node_to_typst(abstractNode, options) {
           }
         }
       }
+      if (node2.head.value === "\\pmod") {
+        const g = new TypstGroup([new TypstToken(1 /* SYMBOL */, "mod").toNode(), arg0]);
+        return new TypstLeftright(
+          null,
+          { body: g, left: TypstToken.LEFT_PAREN, right: TypstToken.RIGHT_PAREN }
+        );
+      }
       if (node2.head.value === "\\overset") {
         return convert_overset(node2, options);
       }
@@ -3247,7 +3283,7 @@ function convert_tex_node_to_typst(abstractNode, options) {
         return convert_underset(node2, options);
       }
       if (["\\bra", "\\ket", "\\braket", "\\set", "\\Bra", "\\Ket", "\\Braket", "\\Set"].includes(node2.head.value)) {
-        let process_vertical_bar2 = function(n) {
+        let process_vertical_bar2 = function(n, once) {
           const mid_bar = new TypstFuncCall(
             new TypstToken(1 /* SYMBOL */, "mid"),
             [TypstToken.VERTICAL_BAR.toNode()]
@@ -3259,6 +3295,9 @@ function convert_tex_node_to_typst(abstractNode, options) {
             for (let i = 0; i < group.items.length; i++) {
               if (group.items[i].type === "terminal" && group.items[i].head.eq(TypstToken.VERTICAL_BAR)) {
                 group.items[i] = mid_bar;
+                if (once) {
+                  break;
+                }
               }
             }
             return group;
@@ -3291,22 +3330,22 @@ function convert_tex_node_to_typst(abstractNode, options) {
           case "\\Bra":
             return new TypstLeftright(
               TypstToken.LR,
-              { body: process_vertical_bar2(arg0), left: TypstToken.LEFT_ANGLE, right: TypstToken.VERTICAL_BAR }
+              { body: arg0, left: TypstToken.LEFT_ANGLE, right: TypstToken.VERTICAL_BAR }
             );
           case "\\Ket":
             return new TypstLeftright(
               TypstToken.LR,
-              { body: process_vertical_bar2(arg0), left: TypstToken.VERTICAL_BAR, right: TypstToken.RIGHT_ANGLE }
+              { body: arg0, left: TypstToken.VERTICAL_BAR, right: TypstToken.RIGHT_ANGLE }
             );
           case "\\Braket":
             return new TypstLeftright(
               TypstToken.LR,
-              { body: process_vertical_bar2(arg0), left: TypstToken.LEFT_ANGLE, right: TypstToken.RIGHT_ANGLE }
+              { body: process_vertical_bar2(arg0, false), left: TypstToken.LEFT_ANGLE, right: TypstToken.RIGHT_ANGLE }
             );
           case "\\Set":
             return new TypstLeftright(
               TypstToken.LR,
-              { body: process_vertical_bar2(arg0), left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
+              { body: process_vertical_bar2(arg0, true), left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
             );
           default:
         }
@@ -4218,14 +4257,6 @@ var TexWriter = class {
     this.queue = this.queue.concat(node.serialize());
   }
   flushQueue() {
-    while (this.queue.length > 0) {
-      const last_token = this.queue[this.queue.length - 1];
-      if (last_token.eq(TexToken.COMMAND_DISPLAYSTYLE) || last_token.eq(TexToken.COMMAND_TEXTSTYLE)) {
-        this.queue.pop();
-      } else {
-        break;
-      }
-    }
     for (let i = 0; i < this.queue.length; i++) {
       this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
     }
@@ -4233,6 +4264,10 @@ var TexWriter = class {
   }
   finalize() {
     this.flushQueue();
+    this.buffer = this.buffer.replace(/\\displaystyle \\displaystyle/g, "\\displaystyle");
+    this.buffer = this.buffer.replace(/\\textstyle \\textstyle/g, "\\textstyle");
+    this.buffer = this.buffer.replace(/\s?\\textstyle\s?$/, "");
+    this.buffer = this.buffer.replace(/\s?\\displaystyle\s?$/, "");
     return this.buffer;
   }
 };