tex2typst 0.4.0 → 0.4.1

package/dist/index.js

@@ -1,4 +1,4 @@
-// src/util.ts
+// src/utils.ts
 function isalpha(char) {
   return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".includes(char);
 }
@@ -574,7 +574,8 @@ var TEX_UNARY_COMMANDS = [
   "mathinner",
   "mathrel",
   "mathbin",
-  "mathop"
+  "mathop",
+  "not"
 ];
 var TEX_BINARY_COMMANDS = [
   "frac",
@@ -1066,51 +1067,25 @@ var LatexParser = class {
     this.alignmentDepth++;
     let pos = start;
     pos += eat_whitespaces(tokens, pos).length;
-    const allRows = [];
-    let row = [];
-    allRows.push(row);
-    let group = new TexGroup([]);
-    row.push(group);
-    while (pos < tokens.length) {
-      if (tokens[pos].eq(closingToken)) {
-        break;
-      }
-      const [res, newPos] = this.parseNextExpr(tokens, pos);
-      pos = newPos;
-      if (res.head.type === 5 /* SPACE */ || res.head.type === 6 /* NEWLINE */) {
-        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
-          continue;
-        }
-        if (!this.newline_sensitive && res.head.value === "\n") {
-          continue;
-        }
-      }
-      if (res.head.eq(new TexToken(7 /* CONTROL */, "\\\\"))) {
-        row = [];
-        group = new TexGroup([]);
-        row.push(group);
-        allRows.push(row);
-      } else if (res.head.eq(new TexToken(7 /* CONTROL */, "&"))) {
-        group = new TexGroup([]);
-        row.push(group);
-      } else {
-        group.items.push(res);
-      }
-    }
-    if (pos >= tokens.length) {
+    let closure;
+    [closure, pos] = this.parseClosure(tokens, pos, closingToken);
+    if (pos === -1) {
       return [[], -1];
     }
-    if (allRows.length > 0 && allRows[allRows.length - 1].length > 0) {
-      const last_cell = allRows[allRows.length - 1][allRows[allRows.length - 1].length - 1];
-      if (last_cell.type === "ordgroup") {
-        const last_cell_items = last_cell.items;
-        while (last_cell_items.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(last_cell_items[last_cell_items.length - 1].head.type)) {
-          last_cell_items.pop();
-        }
+    let allRows;
+    if (closure.type === "ordgroup") {
+      const elements = closure.items;
+      while (elements.length > 0 && [5 /* SPACE */, 6 /* NEWLINE */].includes(elements[elements.length - 1].head.type)) {
+        elements.pop();
       }
+      allRows = array_split(elements, new TexToken(7 /* CONTROL */, "\\\\").toNode()).map((row) => {
+        return array_split(row, new TexToken(7 /* CONTROL */, "&").toNode()).map((arr) => new TexGroup(arr));
+      });
+    } else {
+      allRows = [[closure]];
     }
     this.alignmentDepth--;
-    return [allRows, pos + 1];
+    return [allRows, pos];
   }
 };
 function passIgnoreWhitespaceBeforeScriptMark(tokens) {
@@ -3083,6 +3058,20 @@ function convert_tex_node_to_typst(abstractNode, options) {
           { 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");
+        if (sym.head.type === 1 /* SYMBOL */) {
+          return new TypstToken(1 /* SYMBOL */, sym.head.value + ".not").toNode();
+        } else {
+          switch (sym.head.value) {
+            case "=":
+              return new TypstToken(1 /* SYMBOL */, "eq.not").toNode();
+            default:
+              throw new Error(`Not supported: \\not ${sym.head.value}`);
+          }
+        }
+      }
       if (node2.head.value === "\\overset") {
         return convert_overset(node2, options);
       }
@@ -3182,12 +3171,28 @@ function typst_token_to_tex(token) {
       return TexToken.EMPTY;
     case 1 /* SYMBOL */: {
       const _typst_symbol_to_tex = function(symbol) {
-        if (reverseSymbolMap.has(symbol)) {
-          return "\\" + reverseSymbolMap.get(symbol);
-        } else {
-          return "\\" + symbol;
+        switch (symbol) {
+          case "eq":
+            return "=";
+          case "plus":
+            return "+";
+          case "minus":
+            return "-";
+          case "percent":
+            return "%";
+          default: {
+            if (reverseSymbolMap.has(symbol)) {
+              return "\\" + reverseSymbolMap.get(symbol);
+            } else {
+              return "\\" + symbol;
+            }
+          }
         }
       };
+      if (token.value.endsWith(".not")) {
+        const sym = _typst_symbol_to_tex(token.value.slice(0, -4));
+        return new TexToken(2 /* COMMAND */, sym.startsWith("\\") ? `\\not${sym}` : `\\not ${sym}`);
+      }
       return new TexToken(2 /* COMMAND */, _typst_symbol_to_tex(token.value));
     }
     case 2 /* ELEMENT */: {
@@ -3632,32 +3637,34 @@ function find_closing_match(tokens, start) {
     [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2]
   );
 }
-function find_closing_delim(tokens, start) {
-  return _find_closing_match(
-    tokens,
-    start,
-    TypstToken.LEFT_DELIMITERS,
-    TypstToken.RIGHT_DELIMITERS
-  );
-}
-function find_closing_parenthesis(nodes, start) {
-  const left_parenthesis = new TypstToken(2 /* ELEMENT */, "(").toNode();
-  const right_parenthesis = new TypstToken(2 /* ELEMENT */, ")").toNode();
-  assert(nodes[start].eq(left_parenthesis));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= nodes.length) {
-      throw new Error("Unmatched '('");
+function extract_named_params(arr) {
+  const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
+  const np = {};
+  const to_delete = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i].type !== "group") {
+      continue;
     }
-    if (nodes[pos].eq(left_parenthesis)) {
-      count += 1;
-    } else if (nodes[pos].eq(right_parenthesis)) {
-      count -= 1;
+    const g = arr[i];
+    const pos_colon = array_find(g.items, COLON);
+    if (pos_colon === -1 || pos_colon === 0) {
+      continue;
+    }
+    to_delete.push(i);
+    const param_name = g.items[pos_colon - 1];
+    if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
+      if (g.items.length !== 3) {
+        throw new TypstParserError("Invalid number of arguments for delim");
+      }
+      np["delim"] = g.items[pos_colon + 1];
+    } else {
+      throw new TypstParserError("Not implemented for other named parameters");
     }
-    pos += 1;
   }
-  return pos - 1;
+  for (let i = to_delete.length - 1; i >= 0; i--) {
+    arr.splice(to_delete[i], 1);
+  }
+  return [arr, np];
 }
 function primes(num) {
   const res = [];
@@ -3696,30 +3703,16 @@ function trim_whitespace_around_operators(nodes) {
   }
   return res;
 }
-function process_operators(nodes, parenthesis = false) {
+function process_operators(nodes) {
   nodes = trim_whitespace_around_operators(nodes);
-  const opening_bracket = LEFT_PARENTHESES.toNode();
-  const closing_bracket = RIGHT_PARENTHESES.toNode();
   const stack = [];
   const args = [];
   let pos = 0;
   while (pos < nodes.length) {
-    const current = nodes[pos];
-    if (current.eq(closing_bracket)) {
-      throw new TypstParserError("Unexpected ')'");
-    } else if (current.eq(DIV)) {
-      stack.push(current);
-      pos++;
+    const current_tree = nodes[pos];
+    if (current_tree.eq(DIV)) {
+      stack.push(current_tree);
     } else {
-      let current_tree;
-      if (current.eq(opening_bracket)) {
-        const pos_closing = find_closing_parenthesis(nodes, pos);
-        current_tree = process_operators(nodes.slice(pos + 1, pos_closing), true);
-        pos = pos_closing + 1;
-      } else {
-        current_tree = current;
-        pos++;
-      }
       if (stack.length > 0 && stack[stack.length - 1].eq(DIV)) {
         let denominator = current_tree;
         if (args.length === 0) {
@@ -3738,13 +3731,9 @@ function process_operators(nodes, parenthesis = false) {
         args.push(current_tree);
       }
     }
+    pos++;
   }
-  const body = args.length === 1 ? args[0] : new TypstGroup(args);
-  if (parenthesis) {
-    return new TypstLeftright(null, { body, left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
-  } else {
-    return body;
-  }
+  return args.length === 1 ? args[0] : new TypstGroup(args);
 }
 function parse_named_params(groups) {
   const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
@@ -3772,7 +3761,6 @@ var LEFT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "{");
 var RIGHT_CURLY_BRACKET2 = new TypstToken(2 /* ELEMENT */, "}");
 var COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(2 /* ELEMENT */, ";");
-var SINGLE_SPACE = new TypstToken(6 /* SPACE */, " ");
 var CONTROL_AND = new TypstToken(7 /* CONTROL */, "&");
 var TypstParser = class {
   space_sensitive;
@@ -3785,33 +3773,8 @@ var TypstParser = class {
     const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
     return tree;
   }
-  parseGroup(tokens, start, end, parentheses = false) {
-    const results = [];
-    let pos = start;
-    while (pos < end) {
-      const [res, newPos] = this.parseNextExpr(tokens, pos);
-      pos = newPos;
-      if (res.head.type === 6 /* SPACE */ || res.head.type === 8 /* NEWLINE */) {
-        if (!this.space_sensitive && res.head.value.replace(/ /g, "").length === 0) {
-          continue;
-        }
-        if (!this.newline_sensitive && res.head.value === "\n") {
-          continue;
-        }
-      }
-      results.push(res);
-    }
-    let node;
-    if (parentheses) {
-      node = process_operators(results, true);
-    } else {
-      if (results.length === 1) {
-        node = results[0];
-      } else {
-        node = process_operators(results);
-      }
-    }
-    return [node, end + 1];
+  parseGroup(tokens, start, end) {
+    return this.parseUntil(tokens.slice(start, end), 0, null);
   }
   parseNextExpr(tokens, start) {
     let [base, pos] = this.parseNextExprWithoutSupSub(tokens, start);
@@ -3840,12 +3803,47 @@ var TypstParser = class {
       return [base, pos];
     }
   }
+  // return pos: (position of stopToken) + 1
+  // pos will be -1 if stopToken is not found
+  parseUntil(tokens, start, stopToken, env = {}) {
+    if (env.spaceSensitive === void 0) {
+      env.spaceSensitive = this.space_sensitive;
+    }
+    if (env.newlineSensitive === void 0) {
+      env.newlineSensitive = this.newline_sensitive;
+    }
+    const results = [];
+    let pos = start;
+    while (pos < tokens.length) {
+      if (stopToken !== null && tokens[pos].eq(stopToken)) {
+        break;
+      }
+      const [res, newPos] = this.parseNextExpr(tokens, pos);
+      pos = newPos;
+      if (res.head.type === 6 /* SPACE */ || res.head.type === 8 /* NEWLINE */) {
+        if (!env.spaceSensitive && res.head.value.replace(/ /g, "").length === 0) {
+          continue;
+        }
+        if (!env.newlineSensitive && res.head.value === "\n") {
+          continue;
+        }
+      }
+      results.push(res);
+    }
+    if (pos >= tokens.length && stopToken !== null) {
+      return [TypstToken.NONE.toNode(), -1];
+    }
+    const node = process_operators(results);
+    return [node, pos + 1];
+  }
   parseSupOrSub(tokens, start) {
     let node;
     let end;
     if (tokens[start].eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match(tokens, start);
-      [node, end] = this.parseGroup(tokens, start + 1, pos_closing);
+      [node, end] = this.parseUntil(tokens, start + 1, RIGHT_PARENTHESES);
+      if (end === -1) {
+        throw new Error("Unmatched '('");
+      }
     } else {
       [node, end] = this.parseNextExprWithoutSupSub(tokens, start);
     }
@@ -3860,8 +3858,12 @@ var TypstParser = class {
     const firstToken = tokens[start];
     const node = firstToken.toNode();
     if (firstToken.eq(LEFT_PARENTHESES)) {
-      const pos_closing = find_closing_match(tokens, start);
-      return this.parseGroup(tokens, start + 1, pos_closing, true);
+      const [body, end] = this.parseUntil(tokens, start + 1, RIGHT_PARENTHESES);
+      if (end === -1) {
+        throw new Error("Unmatched '('");
+      }
+      const res = new TypstLeftright(null, { body, left: LEFT_PARENTHESES, right: RIGHT_PARENTHESES });
+      return [res, end];
     }
     if (firstToken.type === 2 /* ELEMENT */ && !isalpha(firstToken.value[0])) {
       return [node, start + 1];
@@ -3909,70 +3911,41 @@ var TypstParser = class {
   }
   // start: the position of the left parentheses
   parseLrArguments(tokens, start) {
-    const lr_token = tokens[start];
+    const lr_token = new TypstToken(1 /* SYMBOL */, "lr");
     const end = find_closing_match(tokens, start);
-    if (tokens[start + 1].isOneOf(TypstToken.LEFT_DELIMITERS)) {
-      const inner_start = start + 1;
-      const inner_end = find_closing_delim(tokens, inner_start);
-      const [inner_args, _] = this.parseGroup(tokens, inner_start + 1, inner_end);
-      return [
-        new TypstLeftright(lr_token, { body: inner_args, left: tokens[inner_start], right: tokens[inner_end] }),
-        end + 1
-      ];
-    } else {
-      const [inner_args, _] = this.parseGroup(tokens, start + 1, end - 1);
-      return [
-        new TypstLeftright(lr_token, { body: inner_args, left: null, right: null }),
-        end + 1
-      ];
-    }
+    let left = null;
+    let right = null;
+    let inner_start = start + 1;
+    let inner_end = end;
+    if (inner_end > inner_start && tokens[inner_start].isOneOf(TypstToken.LEFT_DELIMITERS)) {
+      left = tokens[inner_start];
+      inner_start += 1;
+    }
+    if (inner_end - 1 > inner_start && tokens[inner_end - 1].isOneOf(TypstToken.RIGHT_DELIMITERS)) {
+      right = tokens[inner_end - 1];
+      inner_end -= 1;
+    }
+    const [inner_args, _] = this.parseGroup(tokens, inner_start, inner_end);
+    return [
+      new TypstLeftright(lr_token, { body: inner_args, left, right }),
+      end + 1
+    ];
   }
   // start: the position of the left parentheses
   parseMatrix(tokens, start, rowSepToken, cellSepToken) {
     const end = find_closing_match(tokens, start);
-    tokens = tokens.slice(0, end);
     const matrix = [];
     let named_params = {};
     let pos = start + 1;
     while (pos < end) {
       while (pos < end) {
-        let extract_named_params2 = function(arr) {
-          const COLON = new TypstToken(2 /* ELEMENT */, ":").toNode();
-          const np2 = {};
-          const to_delete = [];
-          for (let i = 0; i < arr.length; i++) {
-            if (arr[i].type !== "group") {
-              continue;
-            }
-            const g = arr[i];
-            const pos_colon = array_find(g.items, COLON);
-            if (pos_colon === -1 || pos_colon === 0) {
-              continue;
-            }
-            to_delete.push(i);
-            const param_name = g.items[pos_colon - 1];
-            if (param_name.eq(new TypstToken(1 /* SYMBOL */, "delim").toNode())) {
-              if (g.items.length !== 3) {
-                throw new TypstParserError("Invalid number of arguments for delim");
-              }
-              np2["delim"] = g.items[pos_colon + 1];
-            } else {
-              throw new TypstParserError("Not implemented for other named parameters");
-            }
-          }
-          for (let i = to_delete.length - 1; i >= 0; i--) {
-            arr.splice(to_delete[i], 1);
-          }
-          return [arr, np2];
-        };
-        var extract_named_params = extract_named_params2;
         let next_stop = array_find(tokens, rowSepToken, pos);
-        if (next_stop === -1) {
+        if (next_stop === -1 || next_stop > end) {
           next_stop = end;
         }
         let row = this.parseArgumentsWithSeparator(tokens, pos, next_stop, cellSepToken);
         let np = {};
-        [row, np] = extract_named_params2(row);
+        [row, np] = extract_named_params(row);
         matrix.push(row);
         Object.assign(named_params, np);
         pos = next_stop + 1;
@@ -3985,26 +3958,15 @@ var TypstParser = class {
     const args = [];
     let pos = start;
     while (pos < end) {
-      let nodes = [];
-      while (pos < end) {
-        if (tokens[pos].eq(sepToken)) {
-          pos += 1;
-          break;
-        } else if (tokens[pos].eq(SINGLE_SPACE)) {
-          pos += 1;
-          continue;
-        }
-        const [argItem, newPos] = this.parseNextExpr(tokens, pos);
-        pos = newPos;
-        nodes.push(argItem);
-      }
       let arg;
-      if (nodes.length === 1) {
-        arg = nodes[0];
-      } else {
-        arg = process_operators(nodes);
+      let newPos;
+      const env = { spaceSensitive: false, newlineSensitive: true };
+      [arg, newPos] = this.parseUntil(tokens.slice(0, end), pos, sepToken, env);
+      if (newPos == -1) {
+        [arg, newPos] = this.parseUntil(tokens.slice(0, end), pos, null, env);
       }
       args.push(arg);
+      pos = newPos;
     }
     return args;
   }