tex2typst 0.5.3 → 0.5.5

package/dist/index.js

@@ -570,13 +570,22 @@ var TEX_UNARY_COMMANDS = [
   "overrightarrow",
   "hspace",
   "substack",
-  "set",
   "displaylines",
   "mathinner",
   "mathrel",
   "mathbin",
   "mathop",
-  "not"
+  "not",
+  // the braket package
+  "bra",
+  "ket",
+  "braket",
+  "set",
+  "Bra",
+  "Ket",
+  "Braket",
+  "Set",
+  "pmod"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -719,7 +728,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;
@@ -734,6 +743,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");
@@ -795,7 +827,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];
@@ -1081,34 +1113,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);
@@ -1225,23 +1229,29 @@ 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 */, "|");
   static PLUS = new _TypstToken(2 /* ELEMENT */, "+");
   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 */, "["),
-    new _TypstToken(2 /* ELEMENT */, "{"),
-    new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "chevron.l"),
+    _TypstToken.LEFT_BRACE,
+    _TypstToken.VERTICAL_BAR,
+    _TypstToken.LEFT_ANGLE,
     new _TypstToken(1 /* SYMBOL */, "paren.l"),
     new _TypstToken(1 /* SYMBOL */, "brace.l")
   ];
   static RIGHT_DELIMITERS = [
-    new _TypstToken(2 /* ELEMENT */, ")"),
+    _TypstToken.RIGHT_PAREN,
     new _TypstToken(2 /* ELEMENT */, "]"),
-    new _TypstToken(2 /* ELEMENT */, "}"),
-    new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "chevron.r"),
+    _TypstToken.RIGHT_BRACE,
+    _TypstToken.VERTICAL_BAR,
+    _TypstToken.RIGHT_ANGLE,
     new _TypstToken(1 /* SYMBOL */, "paren.r"),
     new _TypstToken(1 /* SYMBOL */, "brace.r")
   ];
@@ -1291,7 +1301,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;
@@ -1321,7 +1331,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;
@@ -1352,6 +1362,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) {
@@ -1377,28 +1421,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);
@@ -1603,7 +1638,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 {
@@ -1676,9 +1713,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 {
@@ -1706,15 +1740,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 = [];
@@ -1791,6 +1823,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["tilde", "tilde"],
   ["hat", "hat"],
   ["sqrt", "sqrt"],
+  ["bmod", "mod"],
   ["nonumber", ""],
   ["vec", "arrow"],
   ["neq", "eq.not"],
@@ -3036,14 +3069,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 {
@@ -3124,6 +3157,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);
       }
@@ -3131,7 +3170,7 @@ function convert_tex_node_to_typst(abstractNode, options) {
         typ_left = escape_curly_or_paren(typ_left);
       }
       return new TypstLeftright(
-        new TypstToken(1 /* SYMBOL */, "lr"),
+        TypstToken.LR,
         { body: typ_body, left: typ_left, right: typ_right }
       );
     }
@@ -3214,12 +3253,6 @@ function convert_tex_node_to_typst(abstractNode, options) {
           [new TypstToken(4 /* TEXT */, "large").toNode(), arg0]
         );
       }
-      if (node2.head.value === "\\set") {
-        return new TypstLeftright(
-          null,
-          { body: arg0, left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
-        );
-      }
       if (node2.head.value === "\\not") {
         const sym = convert_tex_node_to_typst(node2.args[0], options);
         assert(sym.type === "terminal");
@@ -3234,12 +3267,87 @@ 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);
       }
       if (node2.head.value === "\\underset") {
         return convert_underset(node2, options);
       }
+      if (["\\bra", "\\ket", "\\braket", "\\set", "\\Bra", "\\Ket", "\\Braket", "\\Set"].includes(node2.head.value)) {
+        let process_vertical_bar2 = function(n, once) {
+          const mid_bar = new TypstFuncCall(
+            new TypstToken(1 /* SYMBOL */, "mid"),
+            [TypstToken.VERTICAL_BAR.toNode()]
+          );
+          if (n.type === "terminal" && n.head.eq(TypstToken.VERTICAL_BAR)) {
+            return mid_bar;
+          } else if (n.type === "group") {
+            const group = n;
+            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;
+          } else {
+            return n;
+          }
+        };
+        var process_vertical_bar = process_vertical_bar2;
+        switch (node2.head.value) {
+          case "\\bra":
+            return new TypstLeftright(
+              null,
+              { body: arg0, left: TypstToken.LEFT_ANGLE, right: TypstToken.VERTICAL_BAR }
+            );
+          case "\\ket":
+            return new TypstLeftright(
+              null,
+              { body: arg0, left: TypstToken.VERTICAL_BAR, right: TypstToken.RIGHT_ANGLE }
+            );
+          case "\\braket":
+            return new TypstLeftright(
+              null,
+              { body: arg0, left: TypstToken.LEFT_ANGLE, right: TypstToken.RIGHT_ANGLE }
+            );
+          case "\\set":
+            return new TypstLeftright(
+              null,
+              { body: arg0, left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
+            );
+          case "\\Bra":
+            return new TypstLeftright(
+              TypstToken.LR,
+              { body: arg0, left: TypstToken.LEFT_ANGLE, right: TypstToken.VERTICAL_BAR }
+            );
+          case "\\Ket":
+            return new TypstLeftright(
+              TypstToken.LR,
+              { body: arg0, left: TypstToken.VERTICAL_BAR, right: TypstToken.RIGHT_ANGLE }
+            );
+          case "\\Braket":
+            return new TypstLeftright(
+              TypstToken.LR,
+              { 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, true), left: TypstToken.LEFT_BRACE, right: TypstToken.RIGHT_BRACE }
+            );
+          default:
+        }
+      }
       if (node2.head.value === "\\frac") {
         if (options.fracToSlash) {
           return new TypstFraction(node2.args.map((n) => convert_tex_node_to_typst(n, options)).map(appendWithBracketsIfNeeded));
@@ -4147,14 +4255,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]);
     }
@@ -4162,6 +4262,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;
   }
 };