tex2typst 0.5.7 → 0.6.1

package/dist/index.js

@@ -78,6 +78,9 @@ var TexTerminal = class extends TexNode {
         throw new Error(`Unknown terminal token type: ${this.head.type}`);
     }
   }
+  bottomTopTraversalTransform(operationFn) {
+    return operationFn(this);
+  }
 };
 var TexText = class extends TexNode {
   constructor(head) {
@@ -92,8 +95,11 @@ var TexText = class extends TexNode {
       new TexToken(1 /* ELEMENT */, "}")
     ];
   }
+  bottomTopTraversalTransform(operationFn) {
+    return operationFn(this);
+  }
 };
-var TexGroup = class extends TexNode {
+var TexGroup = class _TexGroup extends TexNode {
   items;
   constructor(items) {
     super("ordgroup", TexToken.EMPTY);
@@ -102,8 +108,12 @@ var TexGroup = class extends TexNode {
   serialize() {
     return this.items.map((n) => n.serialize()).flat();
   }
+  bottomTopTraversalTransform(operationFn) {
+    const g = new _TexGroup(this.items.map((n) => n.bottomTopTraversalTransform(operationFn)));
+    return operationFn(g);
+  }
 };
-var TexSupSub = class extends TexNode {
+var TexSupSub = class _TexSupSub extends TexNode {
   base;
   sup;
   sub;
@@ -148,8 +158,16 @@ var TexSupSub = class extends TexNode {
     }
     return tokens;
   }
+  bottomTopTraversalTransform(operationFn) {
+    const s = new _TexSupSub({
+      base: this.base.bottomTopTraversalTransform(operationFn),
+      sup: this.sup ? this.sup.bottomTopTraversalTransform(operationFn) : null,
+      sub: this.sub ? this.sub.bottomTopTraversalTransform(operationFn) : null
+    });
+    return operationFn(s);
+  }
 };
-var TexFuncCall = class extends TexNode {
+var TexFuncCall = class _TexFuncCall extends TexNode {
   args;
   // For type="sqrt", it's additional argument wrapped square bracket. e.g. 3 in \sqrt[3]{x}
   data;
@@ -173,8 +191,12 @@ var TexFuncCall = class extends TexNode {
     }
     return tokens;
   }
+  bottomTopTraversalTransform(operationFn) {
+    const f = new _TexFuncCall(this.head, this.args.map((n) => n.bottomTopTraversalTransform(operationFn)), this.data);
+    return operationFn(f);
+  }
 };
-var TexLeftRight = class extends TexNode {
+var TexLeftRight = class _TexLeftRight extends TexNode {
   body;
   left;
   right;
@@ -193,8 +215,16 @@ var TexLeftRight = class extends TexNode {
     tokens.push(new TexToken(1 /* ELEMENT */, this.right ? this.right.value : "."));
     return tokens;
   }
+  bottomTopTraversalTransform(operationFn) {
+    const l = new _TexLeftRight({
+      body: this.body.bottomTopTraversalTransform(operationFn),
+      left: this.left,
+      right: this.right
+    });
+    return operationFn(l);
+  }
 };
-var TexBeginEnd = class extends TexNode {
+var TexBeginEnd = class _TexBeginEnd extends TexNode {
   matrix;
   // for environment="array" or "subarray", there's additional data like {c|c} right after \begin{env}
   data;
@@ -232,6 +262,12 @@ var TexBeginEnd = class extends TexNode {
     tokens.push(new TexToken(1 /* ELEMENT */, "}"));
     return tokens;
   }
+  bottomTopTraversalTransform(operationFn) {
+    const m = this.matrix.map((row) => row.map((cell) => cell.bottomTopTraversalTransform(operationFn)));
+    const d = this.data ? this.data.bottomTopTraversalTransform(operationFn) : null;
+    const be = new _TexBeginEnd(this.head, m, d);
+    return operationFn(be);
+  }
 };
 function writeTexTokenBuffer(buffer, token) {
   const str = token.toString();
@@ -287,7 +323,7 @@ function array_intersperse(array, sep) {
   return array.flatMap((x, i) => i !== array.length - 1 ? [x, sep] : [x]);
 }
 
-// src/jslex.ts
+// src/lex.ts
 var EOF = {};
 function matchcompare(m1, m2) {
   const m1_len = m1.reMatchArray[0].length;
@@ -1362,6 +1398,9 @@ var TypstTerminal = class extends TypstNode {
     }
     return [this.head];
   }
+  bottomTopTraversalTransform(transform) {
+    return transform(this);
+  }
 };
 var TypstTokenQueue = class {
   queue = [];
@@ -1397,7 +1436,7 @@ var TypstTokenQueue = class {
     return res;
   }
 };
-var TypstGroup = class extends TypstNode {
+var TypstGroup = class _TypstGroup extends TypstNode {
   items;
   constructor(items) {
     super("group", TypstToken.NONE);
@@ -1442,8 +1481,12 @@ var TypstGroup = class extends TypstNode {
     }
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const g = new _TypstGroup(this.items.map((n) => n.bottomTopTraversalTransform(transform)));
+    return transform(g);
+  }
 };
-var TypstSupsub = class extends TypstNode {
+var TypstSupsub = class _TypstSupsub extends TypstNode {
   base;
   sup;
   sub;
@@ -1480,8 +1523,16 @@ var TypstSupsub = class extends TypstNode {
     }
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const s = new _TypstSupsub({
+      base: this.base.bottomTopTraversalTransform(transform),
+      sup: this.sup?.bottomTopTraversalTransform(transform) || null,
+      sub: this.sub?.bottomTopTraversalTransform(transform) || null
+    });
+    return transform(s);
+  }
 };
-var TypstFuncCall = class extends TypstNode {
+var TypstFuncCall = class _TypstFuncCall extends TypstNode {
   args;
   constructor(head, args) {
     super("funcCall", head);
@@ -1521,8 +1572,13 @@ var TypstFuncCall = class extends TypstNode {
     env.insideFunctionDepth--;
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const f = new _TypstFuncCall(this.head, this.args.map((n) => n.bottomTopTraversalTransform(transform)));
+    f.options = this.options;
+    return transform(f);
+  }
 };
-var TypstFraction = class extends TypstNode {
+var TypstFraction = class _TypstFraction extends TypstNode {
   args;
   constructor(args) {
     super("fraction", TypstToken.NONE);
@@ -1545,10 +1601,14 @@ var TypstFraction = class extends TypstNode {
     queue.push(...denominator.serialize(env, options));
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const f = new _TypstFraction(this.args.map((n) => n.bottomTopTraversalTransform(transform)));
+    return transform(f);
+  }
 };
 var TYPST_LEFT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, "(");
 var TYPST_RIGHT_PARENTHESIS = new TypstToken(2 /* ELEMENT */, ")");
-var TypstLeftright = class extends TypstNode {
+var TypstLeftright = class _TypstLeftright extends TypstNode {
   body;
   left;
   right;
@@ -1594,6 +1654,14 @@ var TypstLeftright = class extends TypstNode {
     }
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const l = new _TypstLeftright(this.head, {
+      body: this.body.bottomTopTraversalTransform(transform),
+      left: this.left,
+      right: this.right
+    });
+    return transform(l);
+  }
 };
 var TypstMatrixLike = class _TypstMatrixLike extends TypstNode {
   matrix;
@@ -1661,10 +1729,16 @@ var TypstMatrixLike = class _TypstMatrixLike extends TypstNode {
     }
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const m = this.matrix.map((row) => row.map((cell) => cell.bottomTopTraversalTransform(transform)));
+    const ml = new _TypstMatrixLike(this.head, m);
+    ml.options = this.options;
+    return transform(ml);
+  }
   static MAT = new TypstToken(1 /* SYMBOL */, "mat");
   static CASES = new TypstToken(1 /* SYMBOL */, "cases");
 };
-var TypstMarkupFunc = class extends TypstNode {
+var TypstMarkupFunc = class _TypstMarkupFunc extends TypstNode {
   /*
   In idealized situations, for `#heading([some text and math $x + y$ example])`,
   fragments would be [TypstMarkup{"some text and math "}, TypstNode{"x + y"}, TypstMarkup{" example"}]
@@ -1711,6 +1785,11 @@ var TypstMarkupFunc = class extends TypstNode {
     queue.push(new TypstToken(3 /* LITERAL */, "]"));
     return queue;
   }
+  bottomTopTraversalTransform(transform) {
+    const mf = new _TypstMarkupFunc(this.head, this.fragments.map((n) => n.bottomTopTraversalTransform(transform)));
+    mf.options = this.options;
+    return transform(mf);
+  }
 };
 
 // src/typst-writer.ts
@@ -1830,7 +1909,6 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["neq", "eq.not"],
   ["dot", "dot"],
   ["ddot", "dot.double"],
-  ["doteq", "dot(eq)"],
   ["dots", "dots.h"],
   ["vdots", "dots.v"],
   ["ddots", "dots.down"],
@@ -2903,7 +2981,6 @@ var reverseSymbolMap = /* @__PURE__ */ new Map();
 for (const [key, value] of Array.from(symbolMap.entries()).reverse()) {
   reverseSymbolMap.set(value, key);
 }
-reverseSymbolMap.set("oo", "infty");
 var typst_to_tex_map = /* @__PURE__ */ new Map([
   ["top", "top"],
   ["frac", "frac"],
@@ -3514,21 +3591,6 @@ function convert_typst_node_to_tex(abstractNode, options) {
     case "terminal": {
       const node = abstractNode;
       if (node.head.type === 1 /* SYMBOL */) {
-        if (node.head.value === "eq.def") {
-          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [
-            new TexText(new TexToken(3 /* LITERAL */, "def")),
-            new TexToken(1 /* ELEMENT */, "=").toNode()
-          ]);
-        }
-        if (node.head.value === "comma") {
-          return new TexToken(1 /* ELEMENT */, ",").toNode();
-        }
-        if (node.head.value === "dif") {
-          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\mathrm"), [new TexToken(1 /* ELEMENT */, "d").toNode()]);
-        }
-        if (node.head.value === "hyph" || node.head.value === "hyph.minus") {
-          return new TexText(new TexToken(3 /* LITERAL */, "-"));
-        }
         if (/^([A-Z])\1$/.test(node.head.value)) {
           return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\mathbb"), [
             new TexToken(1 /* ELEMENT */, node.head.value[0]).toNode()
@@ -4275,6 +4337,74 @@ var TexWriter = class {
   }
 };
 
+// src/tex-semantic-analysis.ts
+var TEX_PREDEFINED_MACROS = /* @__PURE__ */ new Map([
+  // https://github.com/KaTeX/KaTeX/blob/434d4b8aef4c3311ebfd3405a9f0cce18ead953b/src/macros.ts#L351-L367
+  ["\\varGamma", "\\mathit{\\Gamma}"],
+  ["\\varDelta", "\\mathit{\\Delta}"],
+  ["\\varTheta", "\\mathit{\\Theta}"],
+  ["\\varLambda", "\\mathit{\\Lambda}"],
+  ["\\varXi", "\\mathit{\\Xi}"],
+  ["\\varPi", "\\mathit{\\Pi}"],
+  ["\\varSigma", "\\mathit{\\Sigma}"],
+  ["\\varUpsilon", "\\mathit{\\Upsilon}"],
+  ["\\varPhi", "\\mathit{\\Phi}"],
+  ["\\varPsi", "\\mathit{\\Psi}"],
+  ["\\varOmega", "\\mathit{\\Omega}"],
+  ["\\doteq", "\\dot{=}"]
+]);
+function _expand_tex_predefined_macros(node) {
+  switch (node.type) {
+    case "terminal": {
+      if (node.head.type === 2 /* COMMAND */) {
+        if (TEX_PREDEFINED_MACROS.has(node.head.value)) {
+          const target_str = TEX_PREDEFINED_MACROS.get(node.head.value);
+          return parseTex(target_str);
+        }
+      }
+    }
+    case "funcCall":
+    default:
+      return node;
+  }
+}
+function expand_tex_predefined_macros(node) {
+  return node.bottomTopTraversalTransform(_expand_tex_predefined_macros);
+}
+
+// src/typst-semantic-analyais.ts
+var TEX_PREDEFINED_VARIABLES = /* @__PURE__ */ new Map([
+  ["dif", "upright(d)"],
+  ["eq.def", 'limits(=)^"def"'],
+  ["oo", "infinity"],
+  ["comma", ","],
+  ["hyph", '"-"'],
+  ["hyph.minus", '"-"']
+  /*
+  ["AA", "bb(A)"],
+  ["BB", "bb(B)"],
+  ["CC", "bb(C)"],
+  */
+]);
+function _expand_typst_predefined_variables(node) {
+  switch (node.type) {
+    case "terminal": {
+      if (node.head.type === 1 /* SYMBOL */) {
+        if (TEX_PREDEFINED_VARIABLES.has(node.head.value)) {
+          const target_str = TEX_PREDEFINED_VARIABLES.get(node.head.value);
+          return parseTypst(target_str);
+        }
+      }
+    }
+    case "funcCall":
+    default:
+      return node;
+  }
+}
+function expand_typst_predefined_variables(node) {
+  return node.bottomTopTraversalTransform(_expand_typst_predefined_variables);
+}
+
 // src/index.ts
 function tex2typst(tex, options = {}) {
   const opt = {
@@ -4295,7 +4425,8 @@ function tex2typst(tex, options = {}) {
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
-  const typstTree = convert_tex_node_to_typst(texTree, opt);
+  const preprocessedTexTree = expand_tex_predefined_macros(texTree);
+  const typstTree = convert_tex_node_to_typst(preprocessedTexTree, opt);
   const writer = new TypstWriter(opt);
   writer.serialize(typstTree);
   return writer.finalize();
@@ -4313,7 +4444,8 @@ function typst2tex(typst, options = {}) {
     }
   }
   const typstTree = parseTypst(typst);
-  const texTree = convert_typst_node_to_tex(typstTree, opt);
+  const preprocessedTypstTree = expand_typst_predefined_variables(typstTree);
+  const texTree = convert_typst_node_to_tex(preprocessedTypstTree, opt);
   const writer = new TexWriter();
   writer.append(texTree);
   return writer.finalize();