tex2typst 0.3.1 → 0.3.2

package/README.md

@@ -1,4 +1,5 @@
-# tex2typst
+# tex2typst.js
+
 JavaScript library for conversion between TeX/LaTeX and Typst math formula code.
 
 Despite the name `tex2typst` due to the initial goal of converting TeX to Typst, the library can also convert Typst to TeX since version 0.3.0.
@@ -28,14 +29,13 @@ Replace `0.3.0` with the latest version number in case this README is outdated.
 
 ## Usage
 
-
 ```javascript
 import { tex2typst, typst2tex } from 'tex2typst';
 
 let tex = "e \overset{\text{def}}{=} \lim_{{n \to \infty}} \left(1 + \frac{1}{n}\right)^n";
 let typst = tex2typst(tex);
 console.log(typst);
-// e eq.def lim_(n arrow.r infinity)(1 + frac(1, n))^n
+// e eq.def lim_(n arrow.r infinity)(1 + 1/n)^n
 
 let tex_recovered = typst2tex(typst);
 console.log(tex_recovered);
@@ -44,6 +44,8 @@ console.log(tex_recovered);
 
 If you are using the library in a web page via a `<script>` tag, you don't need the line of `import`, function `tex2typst` and `typst2tex` should be available in the global scope.
 
+tex2typst.js supports some advanced options to customize the conversion. For more details, please refer to the [API Reference](docs/api-reference.md).
+
 ## Open-source license
 
 GPL v3. See [LICENSE](LICENSE) for details.

package/dist/index.js

@@ -1,5 +1,16 @@
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
+  ["cos", "cos"],
+  ["sin", "sin"],
+  ["tan", "tan"],
+  ["cot", "cot"],
+  ["sec", "sec"],
+  ["csc", "csc"],
+  ["mod", "mod"],
+  ["omicron", "omicron"],
+  ["Xi", "Xi"],
+  ["Upsilon", "Upsilon"],
+  ["lim", "lim"],
   ["nonumber", ""],
   ["vec", "arrow"],
   ["neq", "eq.not"],
@@ -59,44 +70,16 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["propto", "prop"],
   /* arrows */
   ["gets", "arrow.l"],
-  ["hookleftarrow", "arrow.l.hook"],
-  ["leftharpoonup", "harpoon.lt"],
-  ["leftharpoondown", "harpoon.lb"],
-  ["rightleftharpoons", "harpoons.rtlb"],
-  ["longleftarrow", "arrow.l.long"],
-  ["longrightarrow", "arrow.r.long"],
-  ["longleftrightarrow", "arrow.l.r.long"],
-  ["Longleftarrow", "arrow.l.double.long"],
-  ["Longrightarrow", "arrow.r.double.long"],
-  ["Longleftrightarrow", "arrow.l.r.double.long"],
   // ['longmapsto', 'arrow.r.bar'],
-  ["hookrightarrow", "arrow.r.hook"],
-  ["rightharpoonup", "harpoon.rt"],
-  ["rightharpoondown", "harpoon.rb"],
   ["iff", "arrow.l.r.double.long"],
   ["implies", "arrow.r.double.long"],
-  ["uparrow", "arrow.t"],
-  ["downarrow", "arrow.b"],
-  ["updownarrow", "arrow.t.b"],
-  ["Uparrow", "arrow.t.double"],
-  ["Downarrow", "arrow.b.double"],
-  ["Updownarrow", "arrow.t.b.double"],
-  ["nearrow", "arrow.tr"],
-  ["searrow", "arrow.br"],
-  ["swarrow", "arrow.bl"],
-  ["nwarrow", "arrow.tl"],
   ["leadsto", "arrow.squiggly"],
-  ["leftleftarrows", "arrows.ll"],
-  ["rightrightarrows", "arrows.rr"],
   ["Cap", "sect.double"],
   ["Cup", "union.double"],
   ["Delta", "Delta"],
   ["Gamma", "Gamma"],
   ["Join", "join"],
   ["Lambda", "Lambda"],
-  ["Leftarrow", "arrow.l.double"],
-  ["Leftrightarrow", "arrow.l.r.double"],
-  ["Longrightarrow", "arrow.r.double.long"],
   ["Omega", "Omega"],
   ["P", "pilcrow"],
   ["Phi", "Phi"],
@@ -152,7 +135,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["div", "div"],
   ["divideontimes", "times.div"],
   ["dotplus", "plus.dot"],
-  ["downarrow", "arrow.b"],
   ["ell", "ell"],
   ["emptyset", "nothing"],
   ["epsilon", "epsilon.alt"],
@@ -186,8 +168,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["lbrack", "bracket.l"],
   ["ldots", "dots.h"],
   ["le", "lt.eq"],
-  ["leadsto", "arrow.squiggly"],
-  ["leftarrow", "arrow.l"],
   ["leftthreetimes", "times.three.l"],
   ["leftrightarrow", "arrow.l.r"],
   ["leq", "lt.eq"],
@@ -224,7 +204,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["nu", "nu"],
   ["ntriangleleft", "lt.tri.not"],
   ["ntriangleright", "gt.tri.not"],
-  ["nwarrow", "arrow.tl"],
   ["odot", "dot.circle"],
   ["oint", "integral.cont"],
   ["oiint", "integral.surf"],
@@ -277,7 +256,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["supset", "supset"],
   ["supseteq", "supset.eq"],
   ["supsetneq", "supset.neq"],
-  ["swarrow", "arrow.bl"],
   ["tau", "tau"],
   ["theta", "theta"],
   ["times", "times"],
@@ -288,8 +266,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   // ['triangleleft', 'triangle.l.small'], 
   // ['triangleright', 'triangle.r.small'], 
   ["twoheadrightarrow", "arrow.r.twohead"],
-  ["uparrow", "arrow.t"],
-  ["updownarrow", "arrow.t.b"],
   ["upharpoonright", "harpoon.tr"],
   ["uplus", "union.plus"],
   ["upsilon", "upsilon"],
@@ -1081,6 +1057,7 @@ for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
   reverseSymbolMap.set(value, key);
 }
 reverseSymbolMap.set("dif", "mathrm{d}");
+reverseSymbolMap.set("oo", "infty");
 var typst_to_tex_map = /* @__PURE__ */ new Map([
   ["top", "top"],
   ["frac", "frac"],
@@ -1977,17 +1954,55 @@ function parseTex(tex, customTexMacros) {
   return parser.parse(tokens);
 }
 
+// src/typst-shorthands.ts
+var shorthandMap = /* @__PURE__ */ new Map([
+  ["arrow.l.r.double.long", "<==>"],
+  ["arrow.l.r.long", "<-->"],
+  ["arrow.r.bar", "|->"],
+  ["arrow.r.double.bar", "|=>"],
+  ["arrow.r.double.long", "==>"],
+  ["arrow.r.long", "-->"],
+  ["arrow.r.long.squiggly", "~~>"],
+  ["arrow.r.tail", ">->"],
+  ["arrow.r.twohead", "->>"],
+  ["arrow.l.double.long", "<=="],
+  ["arrow.l.long", "<--"],
+  ["arrow.l.long.squiggly", "<~~"],
+  ["arrow.l.tail", "<-<"],
+  ["arrow.l.twohead", "<<-"],
+  ["arrow.l.r", "<->"],
+  ["arrow.l.r.double", "<=>"],
+  ["colon.double.eq", "::="],
+  ["dots.h", "..."],
+  ["gt.triple", ">>>"],
+  ["lt.triple", "<<<"],
+  ["arrow.r", "->"],
+  ["arrow.r.double", "=>"],
+  ["arrow.r.squiggly", "~>"],
+  ["arrow.l", "<-"],
+  ["arrow.l.squiggly", "<~"],
+  ["bar.v.double", "||"],
+  ["bracket.l.double", "[|"],
+  ["bracket.r.double", "|]"],
+  ["colon.eq", ":="],
+  ["eq.colon", "=:"],
+  ["eq.not", "!="],
+  ["gt.double", ">>"],
+  ["gt.eq", ">="],
+  ["lt.double", "<<"],
+  ["lt.eq", "<="],
+  ["ast.op", "*"],
+  ["minus", "-"],
+  ["tilde.op", "~"]
+]);
+var reverseShorthandMap = /* @__PURE__ */ new Map();
+for (const [key, value] of shorthandMap.entries()) {
+  if (value.length > 1) {
+    reverseShorthandMap.set(value, key);
+  }
+}
+
 // src/typst-writer.ts
-var TYPST_INTRINSIC_SYMBOLS = [
-  "dim",
-  "id",
-  "im",
-  "mod",
-  "Pr",
-  "sech",
-  "csch"
-  // 'sgn
-];
 function is_delimiter(c) {
   return c.type === "atom" && ["(", ")", "[", "]", "{", "}", "|", "\u230A", "\u230B", "\u2308", "\u2309"].includes(c.content);
 }
@@ -2006,6 +2021,8 @@ function typst_primitive_to_string(value) {
     default:
       if (value === null) {
         return "#none";
+      } else if (value instanceof TypstToken) {
+        return value.toString();
       }
       throw new TypstWriterError(`Invalid primitive value: ${value}`, value);
   }
@@ -2018,13 +2035,14 @@ var TypstWriterError = class extends Error {
   }
 };
 var TypstWriter = class {
-  constructor(nonStrict, preferTypstIntrinsic, keepSpaces) {
+  constructor(opt) {
     this.buffer = "";
     this.queue = [];
     this.insideFunctionDepth = 0;
-    this.nonStrict = nonStrict;
-    this.preferTypstIntrinsic = preferTypstIntrinsic;
-    this.keepSpaces = keepSpaces;
+    this.nonStrict = opt.nonStrict;
+    this.preferShorthands = opt.preferShorthands;
+    this.keepSpaces = opt.keepSpaces;
+    this.inftyToOo = opt.inftyToOo;
   }
   writeBuffer(token) {
     const str = token.toString();
@@ -2063,9 +2081,19 @@ var TypstWriter = class {
         }
         break;
       }
-      case "symbol":
-        this.queue.push(new TypstToken(0 /* SYMBOL */, node.content));
+      case "symbol": {
+        let content = node.content;
+        if (this.preferShorthands) {
+          if (shorthandMap.has(content)) {
+            content = shorthandMap.get(content);
+          }
+        }
+        if (this.inftyToOo && content === "infinity") {
+          content = "oo";
+        }
+        this.queue.push(new TypstToken(0 /* SYMBOL */, content));
         break;
+      }
       case "text":
         this.queue.push(new TypstToken(2 /* TEXT */, node.content));
         break;
@@ -2267,6 +2295,16 @@ var TypstWriter = class {
 };
 
 // src/convert.ts
+var TYPST_INTRINSIC_SYMBOLS = [
+  "dim",
+  "id",
+  "im",
+  "mod",
+  "Pr",
+  "sech",
+  "csch"
+  // 'sgn
+];
 function tex_token_to_typst(token) {
   if (/^[a-zA-Z0-9]$/.test(token)) {
     return token;
@@ -2495,14 +2533,8 @@ function convert_tex_node_to_typst(node, options = {}) {
             delim = "|";
             break;
           case "Vmatrix": {
-            const matrix2 = new TypstNode("matrix", "", [], data);
-            matrix2.setOptions({ "delim": TYPST_NONE });
-            const group = new TypstNode("group", "", [
-              new TypstNode("symbol", "||"),
-              matrix2,
-              new TypstNode("symbol", "||")
-            ]);
-            return new TypstNode("funcCall", "lr", [group]);
+            delim = new TypstToken(0 /* SYMBOL */, "bar.v.double");
+            break;
           }
           default:
             throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
@@ -2731,6 +2763,8 @@ function convert_typst_node_to_tex(node) {
 }
 
 // src/typst-parser.ts
+var TYPST_EMPTY_NODE = new TypstNode("empty", "");
+var TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
 function eat_primes2(tokens, start) {
   let pos = start;
   while (pos < tokens.length && tokens[pos].eq(new TypstToken(1 /* ELEMENT */, "'"))) {
@@ -2745,7 +2779,14 @@ function eat_identifier_name(typst, start) {
   }
   return typst.substring(start, pos);
 }
-var TYPST_EMPTY_NODE = new TypstNode("empty", "");
+function try_eat_shorthand(typst, start) {
+  for (const shorthand of TYPST_SHORTHANDS) {
+    if (typst.startsWith(shorthand, start)) {
+      return shorthand;
+    }
+  }
+  return null;
+}
 function tokenize_typst(typst) {
   const tokens = [];
   let pos = 0;
@@ -2831,6 +2872,12 @@ function tokenize_typst(typst) {
         break;
       }
       default: {
+        const shorthand = try_eat_shorthand(typst, pos);
+        if (shorthand !== null) {
+          token = new TypstToken(0 /* SYMBOL */, reverseShorthandMap.get(shorthand));
+          pos += shorthand.length;
+          break;
+        }
         if (isdigit(firstChar)) {
           let newPos = pos;
           while (newPos < typst.length && isdigit(typst[newPos])) {
@@ -3279,27 +3326,22 @@ function tex2typst(tex, options) {
   const opt = {
     nonStrict: true,
     preferTypstIntrinsic: true,
+    preferShorthands: true,
     keepSpaces: false,
     fracToSlash: true,
+    inftyToOo: false,
     customTexMacros: {}
   };
-  if (options) {
-    if (options.nonStrict) {
-      opt.nonStrict = options.nonStrict;
-    }
-    if (options.preferTypstIntrinsic) {
-      opt.preferTypstIntrinsic = options.preferTypstIntrinsic;
-    }
-    if (options.customTexMacros) {
-      opt.customTexMacros = options.customTexMacros;
-    }
-    if (options.fracToSlash !== void 0) {
-      opt.fracToSlash = options.fracToSlash;
+  if (options !== void 0) {
+    for (const key in opt) {
+      if (options[key] !== void 0) {
+        opt[key] = options[key];
+      }
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
   const typstTree = convert_tex_node_to_typst(texTree, opt);
-  const writer = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic, opt.keepSpaces);
+  const writer = new TypstWriter(opt);
   writer.serialize(typstTree);
   return writer.finalize();
 }