tex2typst 0.3.25 → 0.3.27-beta.1

package/dist/index.d.ts

@@ -1,6 +1,24 @@
-import type { Tex2TypstOptions } from "./tex-types";
-import { symbolMap } from "./map";
-import { shorthandMap } from "./typst-shorthands";
-export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
-export declare function typst2tex(typst: string): string;
-export { Tex2TypstOptions, symbolMap, shorthandMap };
+
+/**
+ * ATTENTION:
+ * Don't use any options except those explicitly documented in
+ *   https://github.com/qwinsi/tex2typst/blob/main/docs/api-reference.md
+ * 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 */
+    nonAsciiWrapper?: string; /** default is "" */
+    customTexMacros?: { [key: string]: string; };
+}
+
+export declare function tex2typst(tex: string, options?: Tex2TypstOptions): string;
+export declare function typst2tex(typst: string): string;
+
+export declare const symbolMap: Map<string, string>;
+export declare const shorthandMap: Map<string, string>;

package/dist/index.js

@@ -10,6 +10,8 @@ function assert(condition, message = "Assertion failed.") {
 
 // src/tex-types.ts
 var TexToken = class _TexToken {
+  type;
+  value;
   constructor(type, value) {
     this.type = type;
     this.value = value;
@@ -28,11 +30,11 @@ var TexToken = class _TexToken {
   toNode() {
     return new TexTerminal(this);
   }
-  static {
-    this.EMPTY = new _TexToken(0 /* EMPTY */, "");
-  }
+  static EMPTY = new _TexToken(0 /* EMPTY */, "");
 };
 var TexNode = class {
+  type;
+  head;
   constructor(type, head) {
     this.type = type;
     this.head = head ? head : TexToken.EMPTY;
@@ -90,6 +92,7 @@ var TexText = class extends TexNode {
   }
 };
 var TexGroup = class extends TexNode {
+  items;
   constructor(items) {
     super("ordgroup", TexToken.EMPTY);
     this.items = items;
@@ -99,6 +102,9 @@ var TexGroup = class extends TexNode {
   }
 };
 var TexSupSub = class extends TexNode {
+  base;
+  sup;
+  sub;
   constructor(data) {
     super("supsub", TexToken.EMPTY);
     this.base = data.base;
@@ -142,6 +148,9 @@ var TexSupSub = class extends TexNode {
   }
 };
 var TexFuncCall = class extends TexNode {
+  args;
+  // For type="sqrt", it's additional argument wrapped square bracket. e.g. 3 in \sqrt[3]{x}
+  data;
   constructor(head, args, data = null) {
     super("funcCall", head);
     this.args = args;
@@ -164,6 +173,9 @@ var TexFuncCall = class extends TexNode {
   }
 };
 var TexLeftRight = class extends TexNode {
+  body;
+  left;
+  right;
   constructor(data) {
     super("leftright", TexToken.EMPTY);
     this.body = data.body;
@@ -181,6 +193,9 @@ var TexLeftRight = class extends TexNode {
   }
 };
 var TexBeginEnd = class extends TexNode {
+  matrix;
+  // for environment="array" or "subarray", there's additional data like {c|c} right after \begin{env}
+  data;
   constructor(head, matrix, data = null) {
     assert(head.type === 3 /* LITERAL */);
     super("beginend", head);
@@ -279,20 +294,23 @@ function matchcompare(m1, m2) {
   }
 }
 var Scanner = class {
+  _input;
+  _lexer;
+  // position within input stream
+  _pos = 0;
+  // current line number
+  _line = 0;
+  // current column number
+  _col = 0;
+  _offset = 0;
+  _less = null;
+  _go = false;
+  _newstate = null;
+  _state;
+  _text = null;
+  _leng = null;
+  _reMatchArray = null;
   constructor(input, lexer) {
-    // position within input stream
-    this._pos = 0;
-    // current line number
-    this._line = 0;
-    // current column number
-    this._col = 0;
-    this._offset = 0;
-    this._less = null;
-    this._go = false;
-    this._newstate = null;
-    this._text = null;
-    this._leng = null;
-    this._reMatchArray = null;
     this._input = input;
     this._lexer = lexer;
     this._state = lexer.states[0];
@@ -443,6 +461,8 @@ var Scanner = class {
   }
 };
 var JSLex = class {
+  states;
+  specification;
   constructor(spec3) {
     this.states = Object.keys(spec3);
     this.specification = {};
@@ -651,12 +671,16 @@ function tokenize_tex(input) {
 var IGNORED_COMMANDS = [
   "bigl",
   "bigr",
+  "bigm",
   "biggl",
   "biggr",
+  "biggm",
   "Bigl",
   "Bigr",
+  "Bigm",
   "Biggl",
-  "Biggr"
+  "Biggr",
+  "Biggm"
 ];
 var EMPTY_NODE = TexToken.EMPTY.toNode();
 function get_command_param_num(command) {
@@ -732,6 +756,8 @@ var LatexParserError = class extends Error {
 var SUB_SYMBOL = new TexToken(7 /* CONTROL */, "_");
 var SUP_SYMBOL = new TexToken(7 /* CONTROL */, "^");
 var LatexParser = class {
+  space_sensitive;
+  newline_sensitive;
   constructor(space_sensitive = false, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -1094,6 +1120,8 @@ function parseTex(tex, customTexMacros) {
 
 // src/typst-types.ts
 var TypstToken = class _TypstToken {
+  type;
+  value;
   constructor(type, content) {
     this.type = type;
     this.value = content;
@@ -1117,11 +1145,14 @@ var TypstToken = class _TypstToken {
         return this.value;
     }
   }
-  static {
-    this.NONE = new _TypstToken(0 /* NONE */, "#none");
-  }
+  static NONE = new _TypstToken(0 /* NONE */, "#none");
+  static EMPTY = new _TypstToken(2 /* ELEMENT */, "");
 };
 var TypstNode = class {
+  type;
+  head;
+  // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
+  options;
   constructor(type, head) {
     this.type = type;
     this.head = head ? head : TypstToken.NONE;
@@ -1149,6 +1180,7 @@ var TypstTerminal = class extends TypstNode {
   }
 };
 var TypstGroup = class extends TypstNode {
+  items;
   constructor(items) {
     super("group", TypstToken.NONE);
     this.items = items;
@@ -1158,6 +1190,9 @@ var TypstGroup = class extends TypstNode {
   }
 };
 var TypstSupsub = class extends TypstNode {
+  base;
+  sup;
+  sub;
   constructor(data) {
     super("supsub", TypstToken.NONE);
     this.base = data.base;
@@ -1169,6 +1204,7 @@ var TypstSupsub = class extends TypstNode {
   }
 };
 var TypstFuncCall = class extends TypstNode {
+  args;
   constructor(head, args) {
     super("funcCall", head);
     this.args = args;
@@ -1181,6 +1217,7 @@ var TypstFuncCall = class extends TypstNode {
   }
 };
 var TypstFraction = class extends TypstNode {
+  args;
   constructor(args) {
     super("fraction", TypstToken.NONE);
     this.args = args;
@@ -1190,6 +1227,9 @@ var TypstFraction = class extends TypstNode {
   }
 };
 var TypstLeftright = class extends TypstNode {
+  body;
+  left;
+  right;
   // head is either null or 'lr'
   constructor(head, data) {
     super("leftright", head);
@@ -1202,6 +1242,7 @@ var TypstLeftright = class extends TypstNode {
   }
 };
 var TypstMatrixLike = class extends TypstNode {
+  matrix;
   // head is 'mat', 'cases' or null
   constructor(head, data) {
     super("matrixLike", head);
@@ -1210,14 +1251,18 @@ var TypstMatrixLike = class extends TypstNode {
   isOverHigh() {
     return true;
   }
-  static {
-    this.MAT = new TypstToken(1 /* SYMBOL */, "mat");
-  }
-  static {
-    this.CASES = new TypstToken(1 /* SYMBOL */, "cases");
-  }
+  static MAT = new TypstToken(1 /* SYMBOL */, "mat");
+  static CASES = new TypstToken(1 /* SYMBOL */, "cases");
 };
 var TypstMarkupFunc = class 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"}]
+  At present, we haven't implemented anything about TypstMarkup.
+  So only pattens like `#heading(level: 2)[$x+y$]`, `#text(fill: red)[$x + y$]` are supported.
+  Therefore, fragments is always a list containing exactly 1 TypstNode in well-working situations.
+  */
+  fragments;
   constructor(head, fragments) {
     super("markupFunc", head);
     this.fragments = fragments;
@@ -1285,6 +1330,7 @@ var TYPST_COMMA = new TypstToken(2 /* ELEMENT */, ",");
 var TYPST_NEWLINE = new TypstToken(1 /* SYMBOL */, "\n");
 var SOFT_SPACE = new TypstToken(7 /* CONTROL */, " ");
 var TypstWriterError = class extends Error {
+  node;
   constructor(message, node) {
     super(message);
     this.name = "TypstWriterError";
@@ -1292,10 +1338,15 @@ var TypstWriterError = class extends Error {
   }
 };
 var TypstWriter = class {
+  nonStrict;
+  preferShorthands;
+  keepSpaces;
+  inftyToOo;
+  optimize;
+  buffer = "";
+  queue = [];
+  insideFunctionDepth = 0;
   constructor(options) {
-    this.buffer = "";
-    this.queue = [];
-    this.insideFunctionDepth = 0;
     this.nonStrict = options.nonStrict;
     this.preferShorthands = options.preferShorthands;
     this.keepSpaces = options.keepSpaces;
@@ -1853,6 +1904,7 @@ var symbolMap = /* @__PURE__ */ new Map([
   ["xi", "xi"],
   ["yen", "yen"],
   ["zeta", "zeta"],
+  ["intop", "limits(integral)"],
   // extended
   ["mathscr", "scr"],
   ["LaTeX", "#LaTeX"],
@@ -2679,6 +2731,7 @@ for (const [key, value] of texAliasMap) {
 
 // src/convert.ts
 var ConverterError = class extends Error {
+  node;
   constructor(message, node = null) {
     super(message);
     this.name = "ConverterError";
@@ -2995,10 +3048,10 @@ function convert_tex_node_to_typst(abstractNode, options = {}) {
           const align_node = node2.data;
           switch (align_node.head.value) {
             case "r":
-              matrix.forEach((row) => row[0].items.push(new TypstToken(7 /* CONTROL */, "&").toNode()));
+              matrix.forEach((row) => row.push(TypstToken.EMPTY.toNode()));
               break;
             case "l":
-              matrix.forEach((row) => row[0].items.unshift(new TypstToken(7 /* CONTROL */, "&").toNode()));
+              matrix.forEach((row) => row.unshift(TypstToken.EMPTY.toNode()));
               break;
             default:
               break;
@@ -3598,6 +3651,8 @@ var SEMICOLON = new TypstToken(2 /* ELEMENT */, ";");
 var SINGLE_SPACE = new TypstToken(6 /* SPACE */, " ");
 var CONTROL_AND = new TypstToken(7 /* CONTROL */, "&");
 var TypstParser = class {
+  space_sensitive;
+  newline_sensitive;
   constructor(space_sensitive = true, newline_sensitive = true) {
     this.space_sensitive = space_sensitive;
     this.newline_sensitive = newline_sensitive;
@@ -3838,10 +3893,8 @@ function parseTypst(typst) {
 
 // src/tex-writer.ts
 var TexWriter = class {
-  constructor() {
-    this.buffer = "";
-    this.queue = [];
-  }
+  buffer = "";
+  queue = [];
   append(node) {
     this.queue = this.queue.concat(node.serialize());
   }