tex2typst 0.3.28 → 0.4.0

package/dist/index.d.ts

@@ -6,17 +6,21 @@
  * Any undocumented options may be not working at present or break in the future!
  */
 export interface Tex2TypstOptions {
-    nonStrict?: boolean; /** default is true */
-    preferShorthands?: boolean; /** default is true */
-    keepSpaces?: boolean; /** default is false */
-    fracToSlash?: boolean; /** default is true */
-    inftyToOo?: boolean; /** default is false */
-    optimize?: boolean; /** default is true */
-    customTexMacros?: { [key: string]: string; };
+    nonStrict: boolean; /** default is true */
+    preferShorthands: boolean; /** default is true */
+    keepSpaces: boolean; /** default is false */
+    fracToSlash: boolean; /** default is true */
+    inftyToOo: boolean; /** default is false */
+    optimize: boolean; /** default is true */
+    customTexMacros: { [key: string]: string; };
 }
 
-export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
-export declare function typst2tex(typst: string): string;
+export interface Typst2TexOptions {
+    blockMathMode: boolean; /** default is true */
+}
+
+export declare function tex2typst(tex: string, options?: Partial<Tex2TypstOptions>): string;
+export declare function typst2tex(typst: string, options?: Partial<Typst2TexOptions>): string;
 
 export declare const symbolMap: Map<string, string>;
 export declare const shorthandMap: Map<string, string>;

package/dist/index.js

@@ -31,6 +31,8 @@ var TexToken = class _TexToken {
     return new TexTerminal(this);
   }
   static EMPTY = new _TexToken(0 /* EMPTY */, "");
+  static COMMAND_DISPLAYSTYLE = new _TexToken(2 /* COMMAND */, "\\displaystyle");
+  static COMMAND_TEXTSTYLE = new _TexToken(2 /* COMMAND */, "\\textstyle");
 };
 var TexNode = class {
   type;
@@ -1229,14 +1231,18 @@ var TypstToken = class _TypstToken {
     new _TypstToken(2 /* ELEMENT */, "["),
     new _TypstToken(2 /* ELEMENT */, "{"),
     new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "angle.l")
+    new _TypstToken(1 /* SYMBOL */, "angle.l"),
+    new _TypstToken(1 /* SYMBOL */, "paren.l"),
+    new _TypstToken(1 /* SYMBOL */, "brace.l")
   ];
   static RIGHT_DELIMITERS = [
     new _TypstToken(2 /* ELEMENT */, ")"),
     new _TypstToken(2 /* ELEMENT */, "]"),
     new _TypstToken(2 /* ELEMENT */, "}"),
     new _TypstToken(2 /* ELEMENT */, "|"),
-    new _TypstToken(1 /* SYMBOL */, "angle.r")
+    new _TypstToken(1 /* SYMBOL */, "angle.r"),
+    new _TypstToken(1 /* SYMBOL */, "paren.r"),
+    new _TypstToken(1 /* SYMBOL */, "brace.r")
   ];
 };
 var TypstWriterError = class extends Error {
@@ -1655,6 +1661,7 @@ var TypstWriter = class {
 // src/map.ts
 var symbolMap = /* @__PURE__ */ new Map([
   ["displaystyle", "display"],
+  ["textstyle", "inline"],
   ["hspace", "#h"],
   ["|", "bar.v.double"],
   [",", "thin"],
@@ -2909,7 +2916,7 @@ function appendWithBracketsIfNeeded(node) {
     return node;
   }
 }
-function convert_tex_node_to_typst(abstractNode, options = {}) {
+function convert_tex_node_to_typst(abstractNode, options) {
   switch (abstractNode.type) {
     case "terminal": {
       const node2 = abstractNode;
@@ -3221,7 +3228,8 @@ function typst_token_to_tex(token) {
   }
 }
 var TEX_NODE_COMMA = new TexToken(1 /* ELEMENT */, ",").toNode();
-function convert_typst_node_to_tex(abstractNode) {
+function convert_typst_node_to_tex(abstractNode, options) {
+  const convert_node = (node) => convert_typst_node_to_tex(node, options);
   switch (abstractNode.type) {
     case "terminal": {
       const node = abstractNode;
@@ -3254,7 +3262,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "group": {
       const node = abstractNode;
-      const args = node.items.map(convert_typst_node_to_tex);
+      const args = node.items.map(convert_node);
       const alignment_char = new TexToken(7 /* CONTROL */, "&").toNode();
       const newline_char = new TexToken(7 /* CONTROL */, "\\\\").toNode();
       if (array_includes(args, alignment_char)) {
@@ -3270,7 +3278,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "leftright": {
       const node = abstractNode;
-      const body = convert_typst_node_to_tex(node.body);
+      const body = convert_node(node.body);
       let left = node.left ? typst_token_to_tex(node.left) : new TexToken(1 /* ELEMENT */, ".");
       let right = node.right ? typst_token_to_tex(node.right) : new TexToken(1 /* ELEMENT */, ".");
       if (node.isOverHigh()) {
@@ -3287,7 +3295,7 @@ function convert_typst_node_to_tex(abstractNode) {
         // `\left\| a + \frac{1}{3} \right\|` <- `norm(a + 1/3)`
         case "norm": {
           const arg0 = node.args[0];
-          const body = convert_typst_node_to_tex(arg0);
+          const body = convert_node(arg0);
           if (node.isOverHigh()) {
             return new TexLeftRight({
               body,
@@ -3308,7 +3316,7 @@ function convert_typst_node_to_tex(abstractNode) {
           const left = "\\l" + node.head.value;
           const right = "\\r" + node.head.value;
           const arg0 = node.args[0];
-          const body = convert_typst_node_to_tex(arg0);
+          const body = convert_node(arg0);
           const left_node = new TexToken(2 /* COMMAND */, left);
           const right_node = new TexToken(2 /* COMMAND */, right);
           if (node.isOverHigh()) {
@@ -3324,22 +3332,22 @@ function convert_typst_node_to_tex(abstractNode) {
         // special hook for root
         case "root": {
           const [degree, radicand] = node.args;
-          const data = convert_typst_node_to_tex(degree);
-          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\sqrt"), [convert_typst_node_to_tex(radicand)], data);
+          const data = convert_node(degree);
+          return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\sqrt"), [convert_node(radicand)], data);
         }
         // special hook for overbrace and underbrace
         case "overbrace":
         case "underbrace": {
           const [body, label] = node.args;
-          const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_typst_node_to_tex(body)]);
-          const script = convert_typst_node_to_tex(label);
+          const base = new TexFuncCall(typst_token_to_tex(node.head), [convert_node(body)]);
+          const script = convert_node(label);
           const data = node.head.value === "overbrace" ? { base, sup: script, sub: null } : { base, sub: script, sup: null };
           return new TexSupSub(data);
         }
         // special hook for vec
         // "vec(a, b, c)" -> "\begin{pmatrix}a\\ b\\ c\end{pmatrix}"
         case "vec": {
-          const tex_matrix = node.args.map(convert_typst_node_to_tex).map((n) => [n]);
+          const tex_matrix = node.args.map((arg) => [convert_node(arg)]);
           return new TexBeginEnd(new TexToken(3 /* LITERAL */, "pmatrix"), tex_matrix);
         }
         // special hook for op
@@ -3370,20 +3378,46 @@ function convert_typst_node_to_tex(abstractNode) {
           }
           return new TexFuncCall(
             new TexToken(2 /* COMMAND */, command),
-            [convert_typst_node_to_tex(node.args[1])]
+            [convert_node(node.args[1])]
           );
         }
+        // display(...) -> \displaystyle ... \textstyle
+        // The postprocessor will remove \textstyle if it is the end of the math code
+        case "display": {
+          const arg0 = node.args[0];
+          const group = new TexGroup([
+            TexToken.COMMAND_DISPLAYSTYLE.toNode(),
+            convert_node(arg0)
+          ]);
+          if (!options.blockMathMode) {
+            group.items.push(TexToken.COMMAND_TEXTSTYLE.toNode());
+          }
+          return group;
+        }
+        // inline(...) -> \textstyle ... \displaystyle
+        // The postprocessor will remove \displaystyle if it is the end of the math code
+        case "inline": {
+          const arg0 = node.args[0];
+          const group = new TexGroup([
+            TexToken.COMMAND_TEXTSTYLE.toNode(),
+            convert_node(arg0)
+          ]);
+          if (options.blockMathMode) {
+            group.items.push(TexToken.COMMAND_DISPLAYSTYLE.toNode());
+          }
+          return group;
+        }
         // general case
         default: {
           const func_name_tex = typst_token_to_tex(node.head);
           const is_known_func = TEX_UNARY_COMMANDS.includes(func_name_tex.value.substring(1)) || TEX_BINARY_COMMANDS.includes(func_name_tex.value.substring(1));
           if (func_name_tex.value.length > 0 && is_known_func) {
-            return new TexFuncCall(func_name_tex, node.args.map(convert_typst_node_to_tex));
+            return new TexFuncCall(func_name_tex, node.args.map(convert_node));
           } else {
             return new TexGroup([
               typst_token_to_tex(node.head).toNode(),
               new TexToken(1 /* ELEMENT */, "(").toNode(),
-              ...array_intersperse(node.args.map(convert_typst_node_to_tex), TEX_NODE_COMMA),
+              ...array_intersperse(node.args.map(convert_node), TEX_NODE_COMMA),
               new TexToken(1 /* ELEMENT */, ")").toNode()
             ]);
           }
@@ -3398,7 +3432,7 @@ function convert_typst_node_to_tex(abstractNode) {
             const color = node.options["fill"];
             return new TexFuncCall(
               new TexToken(2 /* COMMAND */, "\\textcolor"),
-              [convert_typst_node_to_tex(color), convert_typst_node_to_tex(node.fragments[0])]
+              [convert_node(color), convert_node(node.fragments[0])]
             );
           }
         }
@@ -3410,11 +3444,11 @@ function convert_typst_node_to_tex(abstractNode) {
     case "supsub": {
       const node = abstractNode;
       const { base, sup, sub } = node;
-      const sup_tex = sup ? convert_typst_node_to_tex(sup) : null;
-      const sub_tex = sub ? convert_typst_node_to_tex(sub) : null;
+      const sup_tex = sup ? convert_node(sup) : null;
+      const sub_tex = sub ? convert_node(sub) : null;
       if (base.head.eq(new TypstToken(1 /* SYMBOL */, "limits"))) {
         const limits = base;
-        const body_in_limits = convert_typst_node_to_tex(limits.args[0]);
+        const body_in_limits = convert_node(limits.args[0]);
         if (sup_tex !== null && sub_tex === null) {
           return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, body_in_limits]);
         } else if (sup_tex === null && sub_tex !== null) {
@@ -3424,7 +3458,7 @@ function convert_typst_node_to_tex(abstractNode) {
           return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\overset"), [sup_tex, underset_call]);
         }
       }
-      const base_tex = convert_typst_node_to_tex(base);
+      const base_tex = convert_node(base);
       const res = new TexSupSub({
         base: base_tex,
         sup: sup_tex,
@@ -3434,7 +3468,7 @@ function convert_typst_node_to_tex(abstractNode) {
     }
     case "matrixLike": {
       const node = abstractNode;
-      const tex_matrix = node.matrix.map((row) => row.map(convert_typst_node_to_tex));
+      const tex_matrix = node.matrix.map((row) => row.map(convert_node));
       if (node.head.eq(TypstMatrixLike.MAT)) {
         let env_type = "pmatrix";
         if (node.options) {
@@ -3481,8 +3515,8 @@ function convert_typst_node_to_tex(abstractNode) {
     case "fraction": {
       const node = abstractNode;
       const [numerator, denominator] = node.args;
-      const num_tex = convert_typst_node_to_tex(numerator);
-      const den_tex = convert_typst_node_to_tex(denominator);
+      const num_tex = convert_node(numerator);
+      const den_tex = convert_node(denominator);
       return new TexFuncCall(new TexToken(2 /* COMMAND */, "\\frac"), [num_tex, den_tex]);
     }
     default:
@@ -3989,6 +4023,14 @@ var TexWriter = class {
     this.queue = this.queue.concat(node.serialize());
   }
   flushQueue() {
+    while (this.queue.length > 0) {
+      const last_token = this.queue[this.queue.length - 1];
+      if (last_token.eq(TexToken.COMMAND_DISPLAYSTYLE) || last_token.eq(TexToken.COMMAND_TEXTSTYLE)) {
+        this.queue.pop();
+      } else {
+        break;
+      }
+    }
     for (let i = 0; i < this.queue.length; i++) {
       this.buffer = writeTexTokenBuffer(this.buffer, this.queue[i]);
     }
@@ -4001,7 +4043,7 @@ var TexWriter = class {
 };
 
 // src/index.ts
-function tex2typst(tex, options) {
+function tex2typst(tex, options = {}) {
   const opt = {
     nonStrict: true,
     preferShorthands: true,
@@ -4011,14 +4053,12 @@ function tex2typst(tex, options) {
     optimize: true,
     customTexMacros: {}
   };
-  if (options !== void 0) {
-    if (typeof options !== "object") {
-      throw new Error("options must be an object");
-    }
-    for (const key in opt) {
-      if (key in options) {
-        opt[key] = options[key];
-      }
+  if (typeof options !== "object") {
+    throw new Error("options must be an object");
+  }
+  for (const key in opt) {
+    if (key in options) {
+      opt[key] = options[key];
     }
   }
   const texTree = parseTex(tex, opt.customTexMacros);
@@ -4027,9 +4067,20 @@ function tex2typst(tex, options) {
   writer.serialize(typstTree);
   return writer.finalize();
 }
-function typst2tex(typst) {
+function typst2tex(typst, options = {}) {
+  const opt = {
+    blockMathMode: true
+  };
+  if (typeof options !== "object") {
+    throw new Error("options must be an object");
+  }
+  for (const key in opt) {
+    if (key in options) {
+      opt[key] = options[key];
+    }
+  }
   const typstTree = parseTypst(typst);
-  const texTree = convert_typst_node_to_tex(typstTree);
+  const texTree = convert_typst_node_to_tex(typstTree, opt);
   const writer = new TexWriter();
   writer.append(texTree);
   return writer.finalize();