tex2typst 0.3.18 → 0.3.19

package/dist/index.js

@@ -1633,8 +1633,8 @@ var JSLex = class {
   }
 };
 
-// src/tex-parser.ts
-var UNARY_COMMANDS = [
+// src/tex-tokenizer.ts
+var TEX_UNARY_COMMANDS = [
   "sqrt",
   "text",
   "bar",
@@ -1667,7 +1667,7 @@ var UNARY_COMMANDS = [
   "overrightarrow",
   "hspace"
 ];
-var BINARY_COMMANDS = [
+var TEX_BINARY_COMMANDS = [
   "frac",
   "tfrac",
   "binom",
@@ -1677,81 +1677,6 @@ var BINARY_COMMANDS = [
   "overset",
   "underset"
 ];
-var IGNORED_COMMANDS = [
-  "bigl",
-  "bigr",
-  "biggl",
-  "biggr",
-  "Bigl",
-  "Bigr",
-  "Biggl",
-  "Biggr"
-];
-var EMPTY_NODE = new TexNode("empty", "");
-function get_command_param_num(command) {
-  if (UNARY_COMMANDS.includes(command)) {
-    return 1;
-  } else if (BINARY_COMMANDS.includes(command)) {
-    return 2;
-  } else {
-    return 0;
-  }
-}
-var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
-var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
-var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
-var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
-function eat_whitespaces(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
-    pos++;
-  }
-  return tokens.slice(start, pos);
-}
-function eat_parenthesis(tokens, start) {
-  const firstToken = tokens[start];
-  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
-    return firstToken;
-  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
-    return firstToken;
-  } else {
-    return null;
-  }
-}
-function eat_primes(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
-    pos += 1;
-  }
-  return pos - start;
-}
-function find_closing_match(tokens, start, leftToken, rightToken) {
-  assert(tokens[start].eq(leftToken));
-  let count = 1;
-  let pos = start + 1;
-  while (count > 0) {
-    if (pos >= tokens.length) {
-      return -1;
-    }
-    if (tokens[pos].eq(leftToken)) {
-      count += 1;
-    } else if (tokens[pos].eq(rightToken)) {
-      count -= 1;
-    }
-    pos += 1;
-  }
-  return pos - 1;
-}
-var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
-var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
-function find_closing_right_command(tokens, start) {
-  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
-}
-var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
-var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
-function find_closing_end_command(tokens, start) {
-  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
-}
 function unescape(str) {
   const chars = ["{", "}", "\\", "$", "&", "#", "_", "%"];
   for (const char of chars) {
@@ -1780,13 +1705,14 @@ var rules_map = /* @__PURE__ */ new Map([
   [String.raw`\r?\n`, (_s) => new TexToken(5 /* NEWLINE */, "\n")],
   [String.raw`\s+`, (s) => new TexToken(4 /* SPACE */, s.text())],
   [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(0 /* ELEMENT */, s.text())],
+  // e.g. match `\frac13`, `\frac1 b`, `\frac a b`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`, (s) => {
     const text = s.text();
     const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])\s*([0-9a-zA-Z])`);
     const match = text.match(regex);
     assert(match !== null);
     const command = match[1];
-    if (BINARY_COMMANDS.includes(command.substring(1))) {
+    if (TEX_BINARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       const arg2 = match[3];
       return [
@@ -1799,13 +1725,14 @@ var rules_map = /* @__PURE__ */ new Map([
       return [];
     }
   }],
+  // e.g. match `\sqrt3`, `\sqrt a`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
     const text = s.text();
     const regex = RegExp(String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`);
     const match = text.match(regex);
     assert(match !== null);
     const command = match[1];
-    if (UNARY_COMMANDS.includes(command.substring(1))) {
+    if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       return [
         new TexToken(1 /* COMMAND */, command),
@@ -1835,6 +1762,83 @@ function tokenize_tex(input) {
   const lexer = new JSLex(spec);
   return lexer.collect(input);
 }
+
+// src/tex-parser.ts
+var IGNORED_COMMANDS = [
+  "bigl",
+  "bigr",
+  "biggl",
+  "biggr",
+  "Bigl",
+  "Bigr",
+  "Biggl",
+  "Biggr"
+];
+var EMPTY_NODE = new TexNode("empty", "");
+function get_command_param_num(command) {
+  if (TEX_UNARY_COMMANDS.includes(command)) {
+    return 1;
+  } else if (TEX_BINARY_COMMANDS.includes(command)) {
+    return 2;
+  } else {
+    return 0;
+  }
+}
+var LEFT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "{");
+var RIGHT_CURLY_BRACKET = new TexToken(6 /* CONTROL */, "}");
+var LEFT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "[");
+var RIGHT_SQUARE_BRACKET = new TexToken(0 /* ELEMENT */, "]");
+function eat_whitespaces(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && [4 /* SPACE */, 5 /* NEWLINE */].includes(tokens[pos].type)) {
+    pos++;
+  }
+  return tokens.slice(start, pos);
+}
+function eat_parenthesis(tokens, start) {
+  const firstToken = tokens[start];
+  if (firstToken.type === 0 /* ELEMENT */ && ["(", ")", "[", "]", "|", "\\{", "\\}", ".", "\\|"].includes(firstToken.value)) {
+    return firstToken;
+  } else if (firstToken.type === 1 /* COMMAND */ && ["lfloor", "rfloor", "lceil", "rceil", "langle", "rangle"].includes(firstToken.value.slice(1))) {
+    return firstToken;
+  } else {
+    return null;
+  }
+}
+function eat_primes(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && tokens[pos].eq(new TexToken(0 /* ELEMENT */, "'"))) {
+    pos += 1;
+  }
+  return pos - start;
+}
+function find_closing_match(tokens, start, leftToken, rightToken) {
+  assert(tokens[start].eq(leftToken));
+  let count = 1;
+  let pos = start + 1;
+  while (count > 0) {
+    if (pos >= tokens.length) {
+      return -1;
+    }
+    if (tokens[pos].eq(leftToken)) {
+      count += 1;
+    } else if (tokens[pos].eq(rightToken)) {
+      count -= 1;
+    }
+    pos += 1;
+  }
+  return pos - 1;
+}
+var LEFT_COMMAND = new TexToken(1 /* COMMAND */, "\\left");
+var RIGHT_COMMAND = new TexToken(1 /* COMMAND */, "\\right");
+function find_closing_right_command(tokens, start) {
+  return find_closing_match(tokens, start, LEFT_COMMAND, RIGHT_COMMAND);
+}
+var BEGIN_COMMAND = new TexToken(1 /* COMMAND */, "\\begin");
+var END_COMMAND = new TexToken(1 /* COMMAND */, "\\end");
+function find_closing_end_command(tokens, start) {
+  return find_closing_match(tokens, start, BEGIN_COMMAND, END_COMMAND);
+}
 var LatexParserError = class extends Error {
   constructor(message) {
     super(message);
@@ -2274,6 +2278,7 @@ var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
 var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
 var TYPST_COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(1 /* SYMBOL */, "\n");
+var SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
 function typst_primitive_to_string(value) {
   switch (typeof value) {
     case "string":
@@ -2397,7 +2402,7 @@ var TypstWriter = class {
           trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
         }
         if (trailing_space_needed) {
-          this.queue.push(new TypstToken(6 /* CONTROL */, " "));
+          this.queue.push(SOFT_SPACE);
         }
         break;
       }
@@ -2428,7 +2433,12 @@ var TypstWriter = class {
       }
       case "fraction": {
         const [numerator, denominator] = node.args;
-        this.appendWithBracketsIfNeeded(numerator);
+        const pos = this.queue.length;
+        const no_wrap = this.appendWithBracketsIfNeeded(numerator);
+        const wrapped = !no_wrap;
+        if (wrapped) {
+          this.queue.splice(pos, 0, SOFT_SPACE);
+        }
         this.queue.push(new TypstToken(2 /* ELEMENT */, "/"));
         this.appendWithBracketsIfNeeded(denominator);
         break;
@@ -2537,17 +2547,17 @@ var TypstWriter = class {
     return !need_to_wrap;
   }
   flushQueue() {
-    const SOFT_SPACE = new TypstToken(6 /* CONTROL */, " ");
+    const dummy_token = new TypstToken(1 /* SYMBOL */, "");
     for (let i = 0; i < this.queue.length; i++) {
       let token = this.queue[i];
       if (token.eq(SOFT_SPACE)) {
-        if (i === this.queue.length - 1) {
-          this.queue[i].value = "";
-        } else if (this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE])) {
-          this.queue[i].value = "";
+        const to_delete = i === 0 || i === this.queue.length - 1 || this.queue[i - 1].isOneOf([TYPST_NEWLINE]) || this.queue[i + 1].isOneOf([TYPST_RIGHT_PARENTHESIS, TYPST_COMMA, TYPST_NEWLINE]);
+        if (to_delete) {
+          this.queue[i] = dummy_token;
         }
       }
     }
+    this.queue = this.queue.filter((token) => !token.eq(dummy_token));
     this.queue.forEach((token) => {
       this.writeBuffer(token);
     });
@@ -2813,16 +2823,13 @@ function convert_tex_node_to_typst(node, options = {}) {
         );
       }
       if (node.content === "\\operatorname") {
-        const text = arg0.content;
-        if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
-          return new TypstNode("symbol", text);
-        } else {
-          return new TypstNode(
-            "funcCall",
-            "op",
-            [arg0]
-          );
+        if (options.optimize) {
+          const text = arg0.content;
+          if (TYPST_INTRINSIC_SYMBOLS.includes(text)) {
+            return new TypstNode("symbol", text);
+          }
         }
+        return new TypstNode("funcCall", "op", [arg0]);
       }
       if (node.content === "\\hspace") {
         const text = arg0.content;
@@ -3191,15 +3198,8 @@ function convert_typst_node_to_tex(node) {
   }
 }
 
-// src/typst-parser.ts
+// src/typst-tokenizer.ts
 var TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
-function eat_primes2(tokens, start) {
-  let pos = start;
-  while (pos < tokens.length && tokens[pos].eq(new TypstToken(2 /* ELEMENT */, "'"))) {
-    pos += 1;
-  }
-  return pos - start;
-}
 function generate_regex_for_shorthands() {
   const regex_list = TYPST_SHORTHANDS.map((s) => {
     s = s.replaceAll("|", "\\|");
@@ -3263,6 +3263,15 @@ function tokenize_typst(input) {
   const lexer = new JSLex(spec2);
   return lexer.collect(input);
 }
+
+// src/typst-parser.ts
+function eat_primes2(tokens, start) {
+  let pos = start;
+  while (pos < tokens.length && tokens[pos].eq(new TypstToken(2 /* ELEMENT */, "'"))) {
+    pos += 1;
+  }
+  return pos - start;
+}
 function _find_closing_match(tokens, start, leftBrackets, rightBrackets) {
   assert(tokens[start].isOneOf(leftBrackets));
   let count = 1;
@@ -3733,7 +3742,6 @@ var TexWriter = class {
 function tex2typst(tex, options) {
   const opt = {
     nonStrict: true,
-    preferTypstIntrinsic: true,
     preferShorthands: true,
     keepSpaces: false,
     fracToSlash: true,

package/dist/tex-parser.d.ts

@@ -1,5 +1,4 @@
 import { TexNode, TexToken } from "./types";
-export declare function tokenize_tex(input: string): TexToken[];
 export declare class LatexParserError extends Error {
     constructor(message: string);
 }

package/dist/tex-tokenizer.d.ts

@@ -0,0 +1,4 @@
+import { TexToken } from "./types";
+export declare const TEX_UNARY_COMMANDS: string[];
+export declare const TEX_BINARY_COMMANDS: string[];
+export declare function tokenize_tex(input: string): TexToken[];