tex2typst 0.6.0 → 0.6.2

package/dist/index.js

@@ -323,8 +323,8 @@ function array_intersperse(array, sep) {
   return array.flatMap((x, i) => i !== array.length - 1 ? [x, sep] : [x]);
 }
 
-// src/jslex.ts
-var EOF = {};
+// src/lex.ts
+var EOF = null;
 function matchcompare(m1, m2) {
   const m1_len = m1.reMatchArray[0].length;
   const m2_len = m2.reMatchArray[0].length;
@@ -334,114 +334,31 @@ function matchcompare(m1, m2) {
     return m1.index - m2.index;
   }
 }
+var ScanResult = class _ScanResult {
+  result;
+  status;
+  constructor(status, result) {
+    this.result = result;
+    this.status = status;
+  }
+  static Accepted(result) {
+    return new _ScanResult(0 /* ACCEPTED */, result);
+  }
+  static Rejected() {
+    return new _ScanResult(1 /* REJECTED */, []);
+  }
+  static Error(message) {
+    return new _ScanResult(2 /* ERROR */, []);
+  }
+};
 var Scanner = class {
   _input;
-  _lexer;
+  rules;
   // 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) {
+  constructor(input, rules) {
     this._input = input;
-    this._lexer = lexer;
-    this._state = lexer.states[0];
-  }
-  /**
-   * Analogous to yytext and yyleng in lex - will be set during scan.
-   */
-  text() {
-    return this._text;
-  }
-  leng() {
-    return this._leng;
-  }
-  reMatchArray() {
-    return this._reMatchArray;
-  }
-  /**
-   * Position of in stream, line number and column number of match.
-   */
-  pos() {
-    return this._pos;
-  }
-  line() {
-    return this._line;
-  }
-  column() {
-    return this._col;
-  }
-  /**
-   * Analogous to input() in lex.
-   * @return {string} The next character in the stream.
-   */
-  input() {
-    return this._input.charAt(this._pos + this._leng + this._offset++);
-  }
-  /**
-   * Similar to unput() in lex, but does not allow modifying the stream.
-   * @return {int} The offset position after the operation.
-   */
-  unput() {
-    return this._offset = this._offset > 0 ? this._offset-- : 0;
-  }
-  /**
-   * Analogous to yyless(n) in lex - retains the first n characters from this pattern, and returns
-   * the rest to the input stream, such that they will be used in the next pattern-matching operation.
-   * @param {int} n Number of characters to retain.
-   * @return {int} Length of the stream after the operation has completed.
-   */
-  less(n) {
-    this._less = n;
-    this._offset = 0;
-    this._text = this._text.substring(0, n);
-    return this._leng = this._text.length;
-  }
-  /**
-   * Like less(), but instead of retaining the first n characters, it chops off the last n.
-   * @param {int} n Number of characters to chop.
-   * @return {int} Length of the stream after the operation has completed.
-   */
-  pushback(n) {
-    return this.less(this._leng - n);
-  }
-  /**
-   * Similar to REJECT in lex, except it doesn't break the current execution context.
-   * TIP: reject() should be the last instruction in a spec callback.
-   */
-  reject() {
-    this._go = true;
-  }
-  /**
-   * Analogous to BEGIN in lex - sets the named state (start condition).
-   * @param {string|int} state Name of state to switch to, or ordinal number (0 is first, etc).
-   * @return {string} The new state on successful switch, throws exception on failure.
-   */
-  begin(state) {
-    if (this._lexer.specification[state]) {
-      return this._newstate = state;
-    }
-    const s = this._lexer.states[parseInt(state)];
-    if (s) {
-      return this._newstate = s;
-    }
-    throw "Unknown state '" + state + "' requested";
-  }
-  /**
-   * Simple accessor for reading in the current state.
-   * @return {string} The current state.
-   */
-  state() {
-    return this._state;
+    this.rules = rules;
   }
   /**
    * Scan method to be returned to caller - grabs the next token and fires appropriate calback.
@@ -452,7 +369,7 @@ var Scanner = class {
       return EOF;
     }
     const str = this._input.substring(this._pos);
-    const rules = this._lexer.specification[this._state];
+    const rules = this.rules;
     const matches = [];
     for (let i = 0; i < rules.length; i++) {
       const rule = rules[i];
@@ -469,87 +386,50 @@ var Scanner = class {
       throw new Error("No match found for input '" + str + "'");
     }
     matches.sort(matchcompare);
-    this._go = true;
-    let result;
-    let matched_text;
-    for (let j = 0, n = matches.length; j < n && this._go; j++) {
-      this._offset = 0;
-      this._less = null;
-      this._go = false;
-      this._newstate = null;
-      const m = matches[j];
-      matched_text = m.reMatchArray[0];
-      this._text = matched_text;
-      this._leng = matched_text.length;
-      this._reMatchArray = m.reMatchArray;
-      result = m.rule.action(this);
-      if (this._newstate && this._newstate != this._state) {
-        this._state = this._newstate;
-        break;
+    for (const m of matches) {
+      const matched_text = m.reMatchArray[0];
+      const result = m.rule.action({
+        pos: this._pos,
+        text: matched_text,
+        reMatchArray: m.reMatchArray
+      });
+      if (result.status === 0 /* ACCEPTED */) {
+        this._pos += matched_text.length;
+        return result.result;
       }
     }
-    const text = this._less === null ? matched_text : matched_text.substring(0, this._less);
-    const len = text.length;
-    this._pos += len + this._offset;
-    const nlm = text.match(/\n/g);
-    if (nlm !== null) {
-      this._line += nlm.length;
-      this._col = len - text.lastIndexOf("\n") - 1;
-    } else {
-      this._col += len;
-    }
-    return result;
+    throw new Error("No match found for input '" + str + "'");
   }
 };
 var JSLex = class {
-  states;
-  specification;
-  constructor(spec3) {
-    this.states = Object.keys(spec3);
-    this.specification = {};
-    for (const s of this.states) {
-      const rule_map = spec3[s];
-      if (s in this.specification) {
-        throw "Duplicate state declaration encountered for state '" + s + "'";
-      }
-      this.specification[s] = [];
-      for (const [k, v] of rule_map.entries()) {
-        let re;
-        try {
-          re = new RegExp("^" + k);
-        } catch (err) {
-          throw "Invalid regexp '" + k + "' in state '" + s + "' (" + err.message + ")";
-        }
-        this.specification[s].push({
-          re,
-          action: v
-        });
+  rules = [];
+  constructor(ruleMap) {
+    for (const [k, v] of ruleMap.entries()) {
+      let re;
+      try {
+        re = new RegExp("^" + k);
+      } catch (err) {
+        throw "Invalid regexp '" + k + "' (" + err.message + ")";
       }
+      this.rules.push({
+        re,
+        action: v
+      });
     }
   }
-  /**
-   * Scanner function - makes a new scanner object which is used to get tokens one at a time.
-   * @param {string} input Input text to tokenize.
-   * @return {function} Scanner function.
-   */
-  scanner(input) {
-    return new Scanner(input, this);
-  }
   /**
    * Similar to lex's yylex() function, consumes all input, calling calback for each token.
    * @param {string} input Text to lex.
    * @param {function} callback Function to execute for each token.
    */
   lex(input, callback) {
-    const scanner = this.scanner(input);
+    const scanner = new Scanner(input, this.rules);
     while (true) {
       const token = scanner.scan();
       if (token === EOF) {
-        return;
-      }
-      if (token !== void 0) {
-        callback(token);
+        break;
       }
+      callback(token);
     }
   }
   /**
@@ -647,8 +527,8 @@ var rules_map = /* @__PURE__ */ new Map([
   [
     String.raw`\\begin{(array|subarry)}{(.+?)}`,
     (s) => {
-      const match = s.reMatchArray();
-      return [
+      const match = s.reMatchArray;
+      return ScanResult.Accepted([
         new TexToken(2 /* COMMAND */, "\\begin"),
         new TexToken(7 /* CONTROL */, "{"),
         new TexToken(3 /* LITERAL */, match[1]),
@@ -656,74 +536,69 @@ var rules_map = /* @__PURE__ */ new Map([
         new TexToken(7 /* CONTROL */, "{"),
         new TexToken(3 /* LITERAL */, match[2]),
         new TexToken(7 /* CONTROL */, "}")
-      ];
+      ]);
     }
   ],
   [
     String.raw`\\(text|operatorname\*?|textcolor|begin|end|hspace|array)\s*{(.+?)}`,
     (s) => {
-      const match = s.reMatchArray();
-      return [
+      const match = s.reMatchArray;
+      return ScanResult.Accepted([
         new TexToken(2 /* COMMAND */, "\\" + match[1]),
         new TexToken(7 /* CONTROL */, "{"),
         new TexToken(3 /* LITERAL */, unescape(match[2])),
         new TexToken(7 /* CONTROL */, "}")
-      ];
+      ]);
     }
   ],
-  [String.raw`%[^\n]*`, (s) => new TexToken(4 /* COMMENT */, s.text().substring(1))],
-  [String.raw`[{}_^&]`, (s) => new TexToken(7 /* CONTROL */, s.text())],
-  [String.raw`\\[\\,:;!> ]`, (s) => new TexToken(7 /* CONTROL */, s.text())],
-  [String.raw`~`, (s) => new TexToken(7 /* CONTROL */, s.text())],
-  [String.raw`\r?\n`, (_s) => new TexToken(6 /* NEWLINE */, "\n")],
-  [String.raw`\s+`, (s) => new TexToken(5 /* SPACE */, s.text())],
-  [String.raw`\\[{}%$&#_|]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
+  [String.raw`%[^\n]*`, (s) => ScanResult.Accepted(new TexToken(4 /* COMMENT */, s.text.substring(1)))],
+  [String.raw`[{}_^&]`, (s) => ScanResult.Accepted([new TexToken(7 /* CONTROL */, s.text)])],
+  [String.raw`\\[\\,:;!> ]`, (s) => ScanResult.Accepted([new TexToken(7 /* CONTROL */, s.text)])],
+  [String.raw`~`, (s) => ScanResult.Accepted([new TexToken(7 /* CONTROL */, s.text)])],
+  [String.raw`\r?\n`, (_s) => ScanResult.Accepted([new TexToken(6 /* NEWLINE */, "\n")])],
+  [String.raw`\s+`, (s) => ScanResult.Accepted([new TexToken(5 /* SPACE */, s.text)])],
+  [String.raw`\\[{}%$&#_|]`, (s) => ScanResult.Accepted([new TexToken(1 /* 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 match = s.reMatchArray();
+    const match = s.reMatchArray;
     const command = match[1];
     if (TEX_BINARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
       const arg2 = match[3];
-      return [
+      return ScanResult.Accepted([
         new TexToken(2 /* COMMAND */, command),
         new TexToken(1 /* ELEMENT */, arg1),
         new TexToken(1 /* ELEMENT */, arg2)
-      ];
+      ]);
     } else {
-      s.reject();
-      return [];
+      return ScanResult.Rejected();
     }
   }],
   // e.g. match `\sqrt3`, `\sqrt a`
   [String.raw`(\\[a-zA-Z]+)(\s*\d|\s+[a-zA-Z])`, (s) => {
-    const match = s.reMatchArray();
+    const match = s.reMatchArray;
     const command = match[1];
     if (TEX_UNARY_COMMANDS.includes(command.substring(1))) {
       const arg1 = match[2].trimStart();
-      return [
+      return ScanResult.Accepted([
         new TexToken(2 /* COMMAND */, command),
         new TexToken(1 /* ELEMENT */, arg1)
-      ];
+      ]);
     } else {
-      s.reject();
-      return [];
+      return ScanResult.Rejected();
     }
   }],
-  [String.raw`\\[a-zA-Z]+`, (s) => new TexToken(2 /* COMMAND */, s.text())],
+  [String.raw`\\[a-zA-Z]+`, (s) => ScanResult.Accepted(new TexToken(2 /* COMMAND */, s.text))],
   // Numbers like "123", "3.14"
-  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
-  [String.raw`[a-zA-Z]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
-  [String.raw`[+\-*/='<>!.,;:?()\[\]|]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
+  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => ScanResult.Accepted(new TexToken(1 /* ELEMENT */, s.text))],
+  [String.raw`[a-zA-Z]`, (s) => ScanResult.Accepted(new TexToken(1 /* ELEMENT */, s.text))],
+  [String.raw`[+\-*/='<>!.,;:?()\[\]|]`, (s) => ScanResult.Accepted(new TexToken(1 /* ELEMENT */, s.text))],
   // non-ASCII characters
-  [String.raw`[^\x00-\x7F]`, (s) => new TexToken(1 /* ELEMENT */, s.text())],
-  [String.raw`.`, (s) => new TexToken(8 /* UNKNOWN */, s.text())]
+  [String.raw`[^\x00-\x7F]`, (s) => ScanResult.Accepted(new TexToken(1 /* ELEMENT */, s.text))],
+  [String.raw`.`, (s) => ScanResult.Accepted([new TexToken(8 /* UNKNOWN */, s.text)])]
 ]);
-var spec = {
-  "start": rules_map
-};
 function tokenize_tex(input) {
-  const lexer = new JSLex(spec);
+  const lexer = new JSLex(rules_map);
   return lexer.collect(input);
 }
 
@@ -1398,6 +1273,9 @@ var TypstTerminal = class extends TypstNode {
     }
     return [this.head];
   }
+  bottomTopTraversalTransform(transform) {
+    return transform(this);
+  }
 };
 var TypstTokenQueue = class {
   queue = [];
@@ -1433,7 +1311,7 @@ var TypstTokenQueue = class {
     return res;
   }
 };
-var TypstGroup = class extends TypstNode {
+var TypstGroup = class _TypstGroup extends TypstNode {
   items;
   constructor(items) {
     super("group", TypstToken.NONE);
@@ -1478,8 +1356,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;
@@ -1516,8 +1398,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);
@@ -1557,8 +1447,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);
@@ -1581,10 +1476,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;
@@ -1630,6 +1529,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;
@@ -1697,10 +1604,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"}]
@@ -1747,6 +1660,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
@@ -1866,7 +1784,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"],
@@ -2939,7 +2856,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"],
@@ -3024,8 +2940,6 @@ function tex_token_to_typst(token, options) {
     case 7 /* CONTROL */: {
       if (token.value === "\\\\") {
         return new TypstToken(7 /* CONTROL */, "\\");
-      } else if (token.value === "\\!") {
-        return new TypstToken(1 /* SYMBOL */, "#h(-math.thin.amount)");
       } else if (token.value === "~") {
         const typst_symbol = symbolMap.get("~");
         return new TypstToken(1 /* SYMBOL */, typst_symbol);
@@ -3125,6 +3039,12 @@ function convert_tex_node_to_typst(abstractNode, options) {
   switch (abstractNode.type) {
     case "terminal": {
       const node2 = abstractNode;
+      if (node2.head.eq(new TexToken(7 /* CONTROL */, "\\!"))) {
+        return new TypstFuncCall(
+          new TypstToken(1 /* SYMBOL */, "#h"),
+          [new TypstToken(3 /* LITERAL */, "-math.thin.amount").toNode()]
+        );
+      }
       return tex_token_to_typst(node2.head, options).toNode();
     }
     case "text": {
@@ -3550,21 +3470,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()
@@ -3854,64 +3759,69 @@ function generate_regex_for_shorthands() {
 }
 var REGEX_SHORTHANDS = generate_regex_for_shorthands();
 var rules_map2 = /* @__PURE__ */ new Map([
-  [String.raw`//[^\n]*`, (s) => new TypstToken(5 /* COMMENT */, s.text().substring(2))],
-  [String.raw`/`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
-  [String.raw`[_^&]`, (s) => new TypstToken(7 /* CONTROL */, s.text())],
-  [String.raw`\r?\n`, (_s) => new TypstToken(8 /* NEWLINE */, "\n")],
-  [String.raw`\s+`, (s) => new TypstToken(6 /* SPACE */, s.text())],
-  [String.raw`\\[$&#_]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
-  [String.raw`\\\n`, (s) => {
-    return [
+  [String.raw`//[^\n]*`, (s) => ScanResult.Accepted(new TypstToken(5 /* COMMENT */, s.text.substring(2)))],
+  [String.raw`/`, (s) => ScanResult.Accepted(new TypstToken(2 /* ELEMENT */, s.text))],
+  [String.raw`[_^&]`, (s) => ScanResult.Accepted(new TypstToken(7 /* CONTROL */, s.text))],
+  [String.raw`\r?\n`, (_s) => ScanResult.Accepted(new TypstToken(8 /* NEWLINE */, "\n"))],
+  [String.raw`\s+`, (s) => ScanResult.Accepted(new TypstToken(6 /* SPACE */, s.text))],
+  [String.raw`\\[$&#_]`, (s) => ScanResult.Accepted(new TypstToken(2 /* ELEMENT */, s.text))],
+  [
+    String.raw`\\\n`,
+    (s) => ScanResult.Accepted([
       new TypstToken(7 /* CONTROL */, "\\"),
       new TypstToken(8 /* NEWLINE */, "\n")
-    ];
-  }],
+    ])
+  ],
   [String.raw`\\\s`, (s) => {
-    return [
+    return ScanResult.Accepted([
       new TypstToken(7 /* CONTROL */, "\\"),
       new TypstToken(6 /* SPACE */, " ")
-    ];
+    ]);
   }],
   // this backslash is dummy and will be ignored in later stages
-  [String.raw`\\\S`, (_s) => new TypstToken(7 /* CONTROL */, "")],
+  [String.raw`\\\S`, (_s) => ScanResult.Accepted(new TypstToken(7 /* CONTROL */, ""))],
   [
     String.raw`"([^"]|(\\"))*"`,
     (s) => {
-      const text = s.text().substring(1, s.text().length - 1);
+      const text = s.text.substring(1, s.text.length - 1);
       text.replaceAll('\\"', '"');
-      return new TypstToken(4 /* TEXT */, text);
+      return ScanResult.Accepted(new TypstToken(4 /* TEXT */, text));
     }
   ],
   [
     REGEX_SHORTHANDS,
     (s) => {
-      const shorthand = s.text();
+      const shorthand = s.text;
       const symbol = reverseShorthandMap.get(shorthand);
-      return new TypstToken(1 /* SYMBOL */, symbol);
+      return ScanResult.Accepted(new TypstToken(1 /* SYMBOL */, symbol));
     }
   ],
-  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
-  [String.raw`[+\-*/=\'<>!.,;?()\[\]|]`, (s) => new TypstToken(2 /* ELEMENT */, s.text())],
-  [String.raw`#h\((.+?)\)`, (s) => {
-    const match = s.reMatchArray();
-    return [
-      new TypstToken(1 /* SYMBOL */, "#h"),
-      new TypstToken(2 /* ELEMENT */, "("),
-      new TypstToken(3 /* LITERAL */, match[1]),
-      new TypstToken(2 /* ELEMENT */, ")")
-    ];
-  }],
-  [String.raw`#none`, (s) => new TypstToken(0 /* NONE */, s.text())],
+  [String.raw`[0-9]+(\.[0-9]+)?`, (s) => ScanResult.Accepted(new TypstToken(2 /* ELEMENT */, s.text))],
+  [String.raw`[+\-*/=\'<>!.,;?()\[\]|]`, (s) => ScanResult.Accepted(new TypstToken(2 /* ELEMENT */, s.text))],
+  [
+    String.raw`#h\((.+?)\)`,
+    (s) => {
+      const match = s.reMatchArray;
+      return ScanResult.Accepted([
+        new TypstToken(1 /* SYMBOL */, "#h"),
+        new TypstToken(2 /* ELEMENT */, "("),
+        new TypstToken(3 /* LITERAL */, match[1]),
+        new TypstToken(2 /* ELEMENT */, ")")
+      ]);
+    }
+  ],
+  [String.raw`#none`, (s) => ScanResult.Accepted(new TypstToken(0 /* NONE */, s.text))],
+  [
+    String.raw`#none`,
+    (s) => ScanResult.Accepted(new TypstToken(0 /* NONE */, s.text))
+  ],
   [String.raw`#?[a-zA-Z\.]+`, (s) => {
-    return new TypstToken(s.text().length === 1 ? 2 /* ELEMENT */ : 1 /* SYMBOL */, s.text());
+    return ScanResult.Accepted(new TypstToken(s.text.length === 1 ? 2 /* ELEMENT */ : 1 /* SYMBOL */, s.text));
   }],
-  [String.raw`.`, (s) => new TypstToken(2 /* ELEMENT */, s.text())]
+  [String.raw`.`, (s) => ScanResult.Accepted(new TypstToken(2 /* ELEMENT */, s.text))]
 ]);
-var spec2 = {
-  "start": rules_map2
-};
 function tokenize_typst(input) {
-  const lexer = new JSLex(spec2);
+  const lexer = new JSLex(rules_map2);
   return lexer.collect(input);
 }
 
@@ -4324,7 +4234,8 @@ var TEX_PREDEFINED_MACROS = /* @__PURE__ */ new Map([
   ["\\varUpsilon", "\\mathit{\\Upsilon}"],
   ["\\varPhi", "\\mathit{\\Phi}"],
   ["\\varPsi", "\\mathit{\\Psi}"],
-  ["\\varOmega", "\\mathit{\\Omega}"]
+  ["\\varOmega", "\\mathit{\\Omega}"],
+  ["\\doteq", "\\dot{=}"]
 ]);
 function _expand_tex_predefined_macros(node) {
   switch (node.type) {
@@ -4345,6 +4256,39 @@ 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 = {
@@ -4384,7 +4328,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();