tex2typst 0.3.7 → 0.3.9

package/dist/generic.d.ts

@@ -4,4 +4,5 @@ interface IEquatable {
 export declare function array_find<T extends IEquatable>(array: T[], item: T, start?: number): number;
 export declare function array_includes<T extends IEquatable>(array: T[], item: T): boolean;
 export declare function array_split<T extends IEquatable>(array: T[], sep: T): T[][];
+export declare function array_join<T>(array: T[], sep: T): T[];
 export {};

package/dist/index.js

@@ -1100,6 +1100,16 @@ function array_split(array, sep) {
   res.push(current_slice);
   return res;
 }
+function array_join(array, sep) {
+  const res = [];
+  for (let i = 0; i < array.length; i++) {
+    res.push(array[i]);
+    if (i != array.length - 1) {
+      res.push(sep);
+    }
+  }
+  return res;
+}
 
 // src/types.ts
 var TexToken = class {
@@ -1170,15 +1180,7 @@ var TexNode = class {
         return tokens;
       }
       case "ordgroup": {
-        let tokens = this.args.map((n) => n.serialize()).flat();
-        if (this.content === "parenthesis") {
-          const is_over_high = this.isOverHigh();
-          const left_delim = is_over_high ? "\\left(" : "(";
-          const right_delim = is_over_high ? "\\right)" : ")";
-          tokens.unshift(new TexToken(0 /* ELEMENT */, left_delim));
-          tokens.push(new TexToken(0 /* ELEMENT */, right_delim));
-        }
-        return tokens;
+        return this.args.map((n) => n.serialize()).flat();
       }
       case "unaryFunc": {
         let tokens = [];
@@ -1276,33 +1278,6 @@ var TexNode = class {
         throw new Error("[TexNode.serialize] Unimplemented type: " + this.type);
     }
   }
-  // whether the node is over high so that if it's wrapped in braces, \left and \right should be used.
-  // e.g. \frac{1}{2} is over high, "2" is not.
-  isOverHigh() {
-    switch (this.type) {
-      case "element":
-      case "symbol":
-      case "text":
-      case "control":
-      case "empty":
-        return false;
-      case "binaryFunc":
-        if (this.content === "\\frac") {
-          return true;
-        }
-      // fall through
-      case "unaryFunc":
-      case "ordgroup":
-        return this.args.some((n) => n.isOverHigh());
-      case "supsub": {
-        return this.data.base.isOverHigh();
-      }
-      case "beginend":
-        return true;
-      default:
-        return false;
-    }
-  }
 };
 var TypstToken = class {
   constructor(type, content) {
@@ -1374,6 +1349,30 @@ var TypstNode = class {
   eq(other) {
     return this.type === other.type && this.content === other.content;
   }
+  // whether the node is over high so that if it's wrapped in braces, \left and \right should be used in its TeX form
+  // e.g. 1/2 is over high, "2" is not.
+  isOverHigh() {
+    switch (this.type) {
+      case "fraction":
+        return true;
+      case "funcCall": {
+        if (this.content === "frac") {
+          return true;
+        }
+        return this.args.some((n) => n.isOverHigh());
+      }
+      case "group":
+        return this.args.some((n) => n.isOverHigh());
+      case "supsub":
+        return this.data.base.isOverHigh();
+      case "align":
+      case "cases":
+      case "matrix":
+        return true;
+      default:
+        return false;
+    }
+  }
 };
 
 // src/util.ts
@@ -1774,13 +1773,18 @@ var rules_map = /* @__PURE__ */ new Map([
     const match = text.match(regex);
     assert(match !== null);
     const command = match[1];
-    const arg1 = match[2].trimStart();
-    const arg2 = match[3];
-    return [
-      new TexToken(1 /* COMMAND */, command),
-      new TexToken(0 /* ELEMENT */, arg1),
-      new TexToken(0 /* ELEMENT */, arg2)
-    ];
+    if (BINARY_COMMANDS.includes(command.substring(1))) {
+      const arg1 = match[2].trimStart();
+      const arg2 = match[3];
+      return [
+        new TexToken(1 /* COMMAND */, command),
+        new TexToken(0 /* ELEMENT */, arg1),
+        new TexToken(0 /* ELEMENT */, arg2)
+      ];
+    } else {
+      s.reject();
+      return [];
+    }
   }],
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
     const text = s.text();
@@ -1788,11 +1792,16 @@ var rules_map = /* @__PURE__ */ new Map([
     const match = text.match(regex);
     assert(match !== null);
     const command = match[1];
-    const arg1 = match[2].trimStart();
-    return [
-      new TexToken(1 /* COMMAND */, command),
-      new TexToken(0 /* ELEMENT */, arg1)
-    ];
+    if (UNARY_COMMANDS.includes(command.substring(1))) {
+      const arg1 = match[2].trimStart();
+      return [
+        new TexToken(1 /* COMMAND */, command),
+        new TexToken(0 /* ELEMENT */, arg1)
+      ];
+    } else {
+      s.reject();
+      return [];
+    }
   }],
   [String.raw`\\[a-zA-Z]+`, (s) => {
     const command = s.text();
@@ -2840,7 +2849,9 @@ var TYPST_UNARY_FUNCTIONS = [
   "underline",
   "bb",
   "cal",
-  "frak"
+  "frak",
+  "floor",
+  "ceil"
 ];
 var TYPST_BINARY_FUNCTIONS = [
   "frac",
@@ -2864,6 +2875,7 @@ function typst_token_to_tex(token) {
   }
   return "\\" + token;
 }
+var TEX_NODE_COMMA = new TexNode("element", ",");
 function convert_typst_node_to_tex(node) {
   if (node.eq(new TypstNode("symbol", "eq.def"))) {
     return new TexNode("binaryFunc", "\\overset", [
@@ -2896,23 +2908,45 @@ function convert_typst_node_to_tex(node) {
       return new TexNode("comment", node.content);
     case "group": {
       const args = node.args.map(convert_typst_node_to_tex);
+      if (node.content === "parenthesis") {
+        const is_over_high = node.isOverHigh();
+        const left_delim = is_over_high ? "\\left(" : "(";
+        const right_delim = is_over_high ? "\\right)" : ")";
+        args.unshift(new TexNode("element", left_delim));
+        args.push(new TexNode("element", right_delim));
+      }
       return new TexNode("ordgroup", node.content, args);
     }
     case "funcCall": {
       if (TYPST_UNARY_FUNCTIONS.includes(node.content)) {
         if (node.content === "lr") {
-          const body = node.args[0];
-          if (body.type === "group") {
-            let left_delim = body.args[0].content;
-            let right_delim = body.args[body.args.length - 1].content;
-            left_delim = apply_escape_if_needed2(left_delim);
-            right_delim = apply_escape_if_needed2(right_delim);
+          const data = node.data;
+          if (data.leftDelim !== null) {
+            let left_delim = apply_escape_if_needed2(data.leftDelim);
+            assert(data.rightDelim !== null, "leftDelim has value but rightDelim not");
+            let right_delim = apply_escape_if_needed2(data.rightDelim);
             return new TexNode("ordgroup", "", [
               new TexNode("element", "\\left" + left_delim),
-              ...body.args.slice(1, body.args.length - 1).map(convert_typst_node_to_tex),
+              ...node.args.map(convert_typst_node_to_tex),
               new TexNode("element", "\\right" + right_delim)
             ]);
+          } else {
+            return new TexNode("ordgroup", "", node.args.map(convert_typst_node_to_tex));
+          }
+        }
+        if (node.content === "floor" || node.content === "ceil") {
+          let left = "\\l" + node.content;
+          let right = "\\r" + node.content;
+          const arg0 = node.args[0];
+          if (arg0.isOverHigh()) {
+            left = "\\left" + left;
+            right = "\\right" + right;
           }
+          return new TexNode("ordgroup", "", [
+            new TexNode("symbol", left),
+            convert_typst_node_to_tex(arg0),
+            new TexNode("symbol", right)
+          ]);
         }
         const command = typst_token_to_tex(node.content);
         return new TexNode("unaryFunc", command, node.args.map(convert_typst_node_to_tex));
@@ -2935,7 +2969,7 @@ function convert_typst_node_to_tex(node) {
         return new TexNode("ordgroup", "", [
           new TexNode("symbol", typst_token_to_tex(node.content)),
           new TexNode("element", "("),
-          ...node.args.map(convert_typst_node_to_tex),
+          ...array_join(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
           new TexNode("element", ")")
         ]);
       }
@@ -3104,23 +3138,39 @@ function tokenize_typst(input) {
   const lexer = new JSLex(spec2);
   return lexer.collect(input);
 }
-function find_closing_match2(tokens, start) {
-  assert(tokens[start].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2]));
+function _find_closing_match(tokens, start, leftBrackets, rightBrackets) {
+  assert(tokens[start].isOneOf(leftBrackets));
   let count = 1;
   let pos = start + 1;
   while (count > 0) {
     if (pos >= tokens.length) {
       throw new Error("Unmatched brackets");
     }
-    if (tokens[pos].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2])) {
-      count += 1;
-    } else if (tokens[pos].isOneOf([RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2])) {
+    if (tokens[pos].isOneOf(rightBrackets)) {
       count -= 1;
+    } else if (tokens[pos].isOneOf(leftBrackets)) {
+      count += 1;
     }
     pos += 1;
   }
   return pos - 1;
 }
+function find_closing_match2(tokens, start) {
+  return _find_closing_match(
+    tokens,
+    start,
+    [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2],
+    [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2]
+  );
+}
+function find_closing_delim(tokens, start) {
+  return _find_closing_match(
+    tokens,
+    start,
+    [LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2, VERTICAL_BAR],
+    [RIGHT_PARENTHESES, RIGHT_BRACKET, RIGHT_CURLY_BRACKET2, VERTICAL_BAR]
+  );
+}
 function find_closing_parenthesis(nodes, start) {
   const left_parenthesis = new TypstNode("atom", "(");
   const right_parenthesis = new TypstNode("atom", ")");
@@ -3246,6 +3296,7 @@ var LEFT_BRACKET = new TypstToken(1 /* ELEMENT */, "[");
 var RIGHT_BRACKET = new TypstToken(1 /* ELEMENT */, "]");
 var LEFT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "{");
 var RIGHT_CURLY_BRACKET2 = new TypstToken(1 /* ELEMENT */, "}");
+var VERTICAL_BAR = new TypstToken(1 /* ELEMENT */, "|");
 var COMMA = new TypstToken(1 /* ELEMENT */, ",");
 var SEMICOLON = new TypstToken(1 /* ELEMENT */, ";");
 var SINGLE_SPACE = new TypstToken(4 /* SPACE */, " ");
@@ -3361,9 +3412,13 @@ var TypstParser = class {
           casesNode.setOptions(named_params);
           return [casesNode, newPos2];
         }
+        if (firstToken.value === "lr") {
+          const [args2, newPos2, lrData] = this.parseLrArguments(tokens, start + 1);
+          const func_call2 = new TypstNode("funcCall", firstToken.value, args2, lrData);
+          return [func_call2, newPos2];
+        }
         const [args, newPos] = this.parseArguments(tokens, start + 1);
-        const func_call = new TypstNode("funcCall", firstToken.value);
-        func_call.args = args;
+        const func_call = new TypstNode("funcCall", firstToken.value, args);
         return [func_call, newPos];
       }
     }
@@ -3375,6 +3430,27 @@ var TypstParser = class {
     return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
   }
   // start: the position of the left parentheses
+  parseLrArguments(tokens, start) {
+    if (tokens[start + 1].isOneOf([LEFT_PARENTHESES, LEFT_BRACKET, LEFT_CURLY_BRACKET2, VERTICAL_BAR])) {
+      const end = find_closing_match2(tokens, start);
+      const inner_start = start + 1;
+      const inner_end = find_closing_delim(tokens, inner_start);
+      const inner_args = this.parseCommaSeparatedArguments(tokens, inner_start + 1, inner_end);
+      return [
+        inner_args,
+        end + 1,
+        { leftDelim: tokens[inner_start].value, rightDelim: tokens[inner_end].value }
+      ];
+    } else {
+      const [args, end] = this.parseArguments(tokens, start);
+      return [
+        args,
+        end,
+        { leftDelim: null, rightDelim: null }
+      ];
+    }
+  }
+  // start: the position of the left parentheses
   parseGroupsOfArguments(tokens, start, newline_token = SEMICOLON) {
     const end = find_closing_match2(tokens, start);
     tokens = tokens.slice(0, end);
@@ -3441,7 +3517,7 @@ var TypstParser = class {
     const args = [];
     let pos = start;
     while (pos < end) {
-      let arg = new TypstNode("group", "", []);
+      let nodes = [];
       while (pos < end) {
         if (tokens[pos].eq(COMMA)) {
           pos += 1;
@@ -3452,12 +3528,15 @@ var TypstParser = class {
         }
         const [argItem, newPos] = this.parseNextExpr(tokens, pos);
         pos = newPos;
-        arg.args.push(argItem);
+        nodes.push(argItem);
       }
-      if (arg.args.length === 0) {
+      let arg;
+      if (nodes.length === 0) {
         arg = TYPST_EMPTY_NODE;
-      } else if (arg.args.length === 1) {
-        arg = arg.args[0];
+      } else if (nodes.length === 1) {
+        arg = nodes[0];
+      } else {
+        arg = process_operators(nodes);
       }
       args.push(arg);
     }