tex2typst 0.5.2 → 0.5.4

package/dist/index.js

@@ -570,13 +570,21 @@ 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"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -1225,21 +1233,27 @@ 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_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 */, "("),
     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 */, ")"),
     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")
   ];
@@ -1280,6 +1294,39 @@ var TypstTerminal = class extends TypstNode {
   isOverHigh() {
     return false;
   }
+  isLeftSpaceful() {
+    switch (this.head.type) {
+      case 6 /* SPACE */:
+      case 8 /* NEWLINE */:
+        return false;
+      case 4 /* TEXT */:
+        return true;
+      case 1 /* SYMBOL */:
+      case 2 /* ELEMENT */: {
+        if (["(", "!", "}", "]"].includes(this.head.value)) {
+          return false;
+        }
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
+  isRightSpaceful() {
+    switch (this.head.type) {
+      case 6 /* SPACE */:
+      case 8 /* NEWLINE */:
+        return false;
+      case 4 /* TEXT */:
+        return true;
+      case 1 /* SYMBOL */:
+      case 2 /* ELEMENT */: {
+        return ["+", "=", ",", "\\/", "dot", "dot.op", "arrow", "arrow.r"].includes(this.head.value);
+      }
+      default:
+        return false;
+    }
+  }
   toString() {
     return this.head.toString();
   }
@@ -1326,13 +1373,48 @@ var TypstGroup = class extends TypstNode {
   isOverHigh() {
     return this.items.some((n) => n.isOverHigh());
   }
+  isLeftSpaceful() {
+    if (this.items.length === 0) {
+      return false;
+    }
+    return this.items[0].isLeftSpaceful();
+  }
+  isRightSpaceful() {
+    if (this.items.length === 0) {
+      return false;
+    }
+    return this.items.at(-1).isRightSpaceful();
+  }
   serialize(env, options) {
-    const queue = this.items.flatMap((n) => n.serialize(env, options));
-    if (queue.length > 0 && queue[0].eq(SOFT_SPACE)) {
-      queue.shift();
+    if (this.items.length === 0) {
+      return [];
+    }
+    const queue = [];
+    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);
+          }
+        }
+      }
+      queue.push(...tokens);
+      if (n.isRightSpaceful() && i < this.items.length - 1) {
+        if (!queue.at(-1)?.eq(SOFT_SPACE)) {
+          queue.push(SOFT_SPACE);
+        }
+      }
     }
-    if (queue.length > 0 && queue[queue.length - 1].eq(SOFT_SPACE)) {
-      queue.pop();
+    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);
+      }
     }
     return queue;
   }
@@ -1350,6 +1432,12 @@ var TypstSupsub = class extends TypstNode {
   isOverHigh() {
     return this.base.isOverHigh();
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return true;
+  }
   serialize(env, options) {
     const queue = [];
     let { base, sup, sub } = this;
@@ -1366,7 +1454,6 @@ var TypstSupsub = class extends TypstNode {
       queue.push(new TypstToken(2 /* ELEMENT */, "^"));
       queue.push(...sup.serialize(env, options));
     }
-    queue.push(SOFT_SPACE);
     return queue;
   }
 };
@@ -1382,6 +1469,12 @@ var TypstFuncCall = class extends TypstNode {
     }
     return this.args.some((n) => n.isOverHigh());
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return !["op", "bold", "dot"].includes(this.head.value);
+  }
   serialize(env, options) {
     const queue = [];
     const func_symbol = this.head;
@@ -1392,6 +1485,7 @@ var TypstFuncCall = class extends TypstNode {
       queue.push(...this.args[i].serialize(env, options));
       if (i < this.args.length - 1) {
         queue.push(new TypstToken(2 /* ELEMENT */, ","));
+        queue.push(SOFT_SPACE);
       }
     }
     if (this.options) {
@@ -1413,14 +1507,18 @@ var TypstFraction = class extends TypstNode {
   isOverHigh() {
     return true;
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return true;
+  }
   serialize(env, options) {
     const queue = [];
     const [numerator, denominator] = this.args;
-    queue.push(SOFT_SPACE);
     queue.push(...numerator.serialize(env, options));
     queue.push(new TypstToken(2 /* ELEMENT */, "/"));
     queue.push(...denominator.serialize(env, options));
-    queue.push(SOFT_SPACE);
     return queue;
   }
 };
@@ -1440,6 +1538,12 @@ var TypstLeftright = class extends TypstNode {
   isOverHigh() {
     return this.body.isOverHigh();
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return true;
+  }
   serialize(env, options) {
     const queue = [];
     const LR = new TypstToken(1 /* SYMBOL */, "lr");
@@ -1450,9 +1554,15 @@ var TypstLeftright = class extends TypstNode {
     }
     if (left) {
       queue.push(left);
+      if (isalpha(left.value[0])) {
+        queue.push(SOFT_SPACE);
+      }
     }
     queue.push(...this.body.serialize(env, options));
     if (right) {
+      if (isalpha(right.value[0])) {
+        queue.push(SOFT_SPACE);
+      }
       queue.push(right);
     }
     if (this.head.eq(LR)) {
@@ -1471,6 +1581,12 @@ var TypstMatrixLike = class _TypstMatrixLike extends TypstNode {
   isOverHigh() {
     return true;
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return false;
+  }
   serialize(env, options) {
     const queue = [];
     let cell_sep;
@@ -1499,10 +1615,16 @@ 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);
           queue.push(cell_sep);
+          queue.push(SOFT_SPACE);
         } else {
           if (i < this.matrix.length - 1) {
+            if (row_sep.value === "\\") {
+              queue.push(SOFT_SPACE);
+            }
             queue.push(row_sep);
+            queue.push(SOFT_SPACE);
           }
         }
       });
@@ -1532,6 +1654,12 @@ var TypstMarkupFunc = class extends TypstNode {
   isOverHigh() {
     return this.fragments.some((n) => n.isOverHigh());
   }
+  isLeftSpaceful() {
+    return true;
+  }
+  isRightSpaceful() {
+    return true;
+  }
   serialize(env, options) {
     const queue = [];
     queue.push(this.head);
@@ -1572,41 +1700,15 @@ var TypstWriter = class {
   constructor(options) {
     this.options = options;
   }
-  writeBuffer(previousToken, token) {
-    const str = token.toString();
-    if (str === "") {
-      return;
-    }
-    let no_need_space = false;
-    no_need_space ||= /[\(\[\|]$/.test(this.buffer) && /^\w/.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 ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
-    no_need_space ||= str.startsWith("\n");
-    no_need_space ||= this.buffer === "";
-    no_need_space ||= /\s$/.test(this.buffer) || /^\s/.test(str);
-    no_need_space ||= this.buffer.endsWith("&") && str === "=";
-    no_need_space ||= this.buffer.endsWith("/") || str === "/";
-    no_need_space ||= token.type === 3 /* LITERAL */;
-    no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
-    if (previousToken !== null) {
-      no_need_space ||= previousToken.type === 3 /* LITERAL */;
-    }
-    if (!no_need_space) {
-      this.buffer += " ";
-    }
-    this.buffer += str;
-  }
   // Serialize a tree of TypstNode into a list of TypstToken
   serialize(abstractNode) {
     const env = { insideFunctionDepth: 0 };
     this.queue.push(...abstractNode.serialize(env, this.options));
   }
   flushQueue() {
+    const queue1 = this.queue.filter((token) => token.value !== "");
     let qu = [];
-    for (const token of this.queue) {
+    for (const token of queue1) {
       if (token.eq(SOFT_SPACE2) && qu.length > 0 && qu[qu.length - 1].eq(SOFT_SPACE2)) {
         continue;
       }
@@ -1625,8 +1727,7 @@ var TypstWriter = class {
     qu = qu.filter((token) => !token.eq(dummy_token));
     for (let i = 0; i < qu.length; i++) {
       let token = qu[i];
-      let previous_token = i === 0 ? null : qu[i - 1];
-      this.writeBuffer(previous_token, token);
+      this.buffer += token.toString();
     }
     this.queue = [];
   }
@@ -1653,6 +1754,7 @@ var TypstWriter = class {
         this.buffer = pass(this.buffer);
       }
     }
+    this.buffer = this.buffer.replace(/& =/g, "&=");
     return this.buffer;
   }
 };
@@ -3041,7 +3143,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 }
       );
     }
@@ -3124,12 +3226,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");
@@ -3150,6 +3246,71 @@ function convert_tex_node_to_typst(abstractNode, 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) {
+          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;
+              }
+            }
+            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: process_vertical_bar2(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 }
+            );
+          case "\\Braket":
+            return new TypstLeftright(
+              TypstToken.LR,
+              { body: process_vertical_bar2(arg0), 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 }
+            );
+          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));