tex2typst 0.3.1 → 0.3.3

package/dist/types.d.ts

@@ -69,7 +69,7 @@ export interface TypstSupsubData {
 }
 export type TypstArrayData = TypstNode[][];
 type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace' | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'unknown';
-export type TypstPrimitiveValue = string | boolean | null;
+export type TypstPrimitiveValue = string | boolean | null | TypstToken;
 export type TypstNamedParams = {
     [key: string]: TypstPrimitiveValue;
 };
@@ -89,8 +89,10 @@ export declare class TypstNode {
 export interface Tex2TypstOptions {
     nonStrict?: boolean;
     preferTypstIntrinsic?: boolean;
+    preferShorthands?: boolean;
     keepSpaces?: boolean;
     fracToSlash?: boolean;
+    inftyToOo?: boolean;
     customTexMacros?: {
         [key: string]: string;
     };

package/dist/typst-parser.d.ts

@@ -1,5 +1,5 @@
 import { TypstNamedParams, TypstNode, TypstToken } from "./types";
-export declare function tokenize_typst(typst: string): TypstToken[];
+export declare function tokenize_typst(input: string): TypstToken[];
 export declare class TypstParserError extends Error {
     constructor(message: string);
 }

package/dist/typst-shorthands.d.ts

@@ -0,0 +1,3 @@
+declare const shorthandMap: Map<string, string>;
+declare const reverseShorthandMap: Map<string, string>;
+export { shorthandMap, reverseShorthandMap };

package/dist/typst-writer.d.ts

@@ -1,17 +1,23 @@
 import { TexNode, TypstNode, TypstToken } from "./types";
-export declare const TYPST_INTRINSIC_SYMBOLS: string[];
 export declare class TypstWriterError extends Error {
     node: TexNode | TypstNode | TypstToken;
     constructor(message: string, node: TexNode | TypstNode | TypstToken);
 }
+export interface TypstWriterOptions {
+    nonStrict: boolean;
+    preferShorthands: boolean;
+    keepSpaces: boolean;
+    inftyToOo: boolean;
+}
 export declare class TypstWriter {
     private nonStrict;
-    private preferTypstIntrinsic;
+    private preferShorthands;
     private keepSpaces;
+    private inftyToOo;
     protected buffer: string;
     protected queue: TypstToken[];
     private insideFunctionDepth;
-    constructor(nonStrict: boolean, preferTypstIntrinsic: boolean, keepSpaces: boolean);
+    constructor(opt: TypstWriterOptions);
     private writeBuffer;
     serialize(node: TypstNode): void;
     private appendWithBracketsIfNeeded;

package/docs/api-reference.md

@@ -0,0 +1,64 @@
+# API Reference of tex2typst.js
+
+## Basic 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 -> infinity)(1 + 1/n)^n
+
+let tex_recovered = typst2tex(typst);
+console.log(tex_recovered);
+// e \overset{\text{def}}{=} \lim_{n \rightarrow \infty} \left(1 + \frac{1}{n} \right)^n
+```
+
+## Advanced options
+
+`tex2typst` function accepts an optional second argument, which is an object containing options to customize the conversion.
+
+```typescript
+interface Tex2TypstOptions {
+    preferShorthands?: boolean;
+    fracToSlash?: boolean;
+    inftyToOo?: boolean;
+}
+```
+
+- `preferShorthands`: If set to `true`, the function will prefer using shorthands in Typst (e.g., `->` instead of `arrow.r`, `<<` instead of `lt.double`) when converting TeX to Typst. Default is `ture`.
+
+```javascript
+let tex = "a \\rightarrow b \\ll c";
+let typst1 = tex2typst(tex, { preferShorthands: false });
+console.log(typst1);
+// a arrow.r b lt.double c
+let typst2 = tex2typst(tex, { preferShorthands: true });
+console.log(typst2);
+// a -> b << c
+```
+
+- `fracToSlash`: If set to `true`, the Typst result will use the slash notation for fractions. Default is `true`.
+
+```javascript
+let tex = "\\frac{a}{b}";
+let tpyst1 = tex2typst(tex, { fracToSlash: false });
+console.log(typst1);
+// frac(a, b)
+let typst2 = tex2typst(tex, { fracToSlash: true });
+console.log(typst2);
+// a / b
+```
+
+- `inftyToOo`: If set to `true`, `\\infty` converts to `oo` instead of `infinity`. Default is `false`.
+
+```javascript
+let tex = "\\infty";
+let typst1 = tex2typst(tex, { inftyToOo: false });
+console.log(typst1);
+// infinity
+let typst2 = tex2typst(tex, { inftyToOo: true });
+console.log(typst2);
+// oo
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tex2typst",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "JavaScript library for converting TeX code to Typst",
   "type": "module",
   "main": "dist/index.js",

package/src/convert.ts

@@ -1,7 +1,18 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue } from "./types";
-import { TypstWriterError, TYPST_INTRINSIC_SYMBOLS } from "./typst-writer";
+import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions, TYPST_NONE, TYPST_TRUE, TypstPrimitiveValue, TypstToken, TypstTokenType } from "./types";
+import { TypstWriterError } from "./typst-writer";
 import { symbolMap, reverseSymbolMap } from "./map";
 
+// symbols that are supported by Typst but not by KaTeX
+const TYPST_INTRINSIC_SYMBOLS = [
+    'dim',
+    'id',
+    'im',
+    'mod',
+    'Pr',
+    'sech',
+    'csch',
+    // 'sgn
+];
 
 function tex_token_to_typst(token: string): string {
     if (/^[a-zA-Z0-9]$/.test(token)) {
@@ -207,6 +218,22 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
             if (node.content === '\\mathbb' && arg0.type === 'atom' && /^[A-Z]$/.test(arg0.content)) {
                 return new TypstNode('symbol', arg0.content + arg0.content);
             }
+            // \overrightarrow{AB} -> arrow(A B)
+            if (node.content === '\\overrightarrow') {
+                return new TypstNode(
+                    'funcCall',
+                    'arrow',
+                    [arg0]
+                );
+            }
+            // \overleftarrow{AB} -> accent(A B, arrow.l)
+            if (node.content === '\\overleftarrow') {
+                return new TypstNode(
+                    'funcCall',
+                    'accent',
+                    [arg0, new TypstNode('symbol', 'arrow.l')]
+                );
+            }
             // \operatorname{opname} -> op("opname")
             if (node.content === '\\operatorname') {
                 const body = node.args!;
@@ -260,22 +287,8 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
                         delim = '|';
                         break;
                     case 'Vmatrix': {
-                        // mat(delim: "||") does not compile in Typst.
-                        // For a workaround, translate
-                        // \begin{Vmatrix}
-                        //   a & b \\
-                        //   c & d
-                        //   \end{Vmatrix}
-                        // to
-                        //  lr(||mat(delim: #none, a, b; c, d)||)
-                        const matrix = new TypstNode('matrix', '', [], data);
-                        matrix.setOptions({ 'delim': TYPST_NONE });
-                        const group = new TypstNode('group', '', [
-                            new TypstNode('symbol', '||'),
-                            matrix,
-                            new TypstNode('symbol', '||'),
-                        ]);
-                        return new TypstNode('funcCall', 'lr', [ group ]);
+                        delim = new TypstToken(TypstTokenType.SYMBOL, 'bar.v.double');
+                        break;
                     }
                     default:
                         throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);

package/src/index.ts

@@ -1,6 +1,6 @@
 import { parseTex } from "./tex-parser";
 import type { Tex2TypstOptions } from "./types";
-import { TypstWriter } from "./typst-writer";
+import { TypstWriter, type TypstWriterOptions } from "./typst-writer";
 import { convert_tex_node_to_typst, convert_typst_node_to_tex } from "./convert";
 import { symbolMap } from "./map";
 import { parseTypst } from "./typst-parser";
@@ -11,27 +11,24 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     const opt: Tex2TypstOptions = {
         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 !== undefined) {
-            opt.fracToSlash = options.fracToSlash;
+
+    if(options !== undefined) {
+        for (const key in opt) {
+            if (options[key] !== undefined) {
+                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 as TypstWriterOptions);
     writer.serialize(typstTree);
     return writer.finalize();
 }

package/src/jslex.ts

@@ -0,0 +1,304 @@
+/**
+ * Adapted from jslex - A lexer in JavaScript. https://github.com/jimbojw/jslex
+ * Licensed under MIT license
+ */
+
+
+interface ILexSpec<T> {
+    start: Map<string, (arg0: Scanner<T>) => T | T[]>;
+}
+
+interface IRule<T> {
+    re: RegExp;
+    action: (a: Scanner<T>) => T | T[];
+}
+
+interface IMatch<T> {
+    index: number;
+    text: string;
+    len: number;
+    rule: IRule<T>;
+}
+
+
+// End of File marker
+const EOF = {};
+
+/**
+ * Utility function for comparing two matches.
+ * @param {object} m1 Left-hand side match.
+ * @param {object} m2 Right-hand side match.
+ * @return {int} Difference between the matches.
+ */
+function matchcompare<T>(m1: IMatch<T>, m2: IMatch<T>): number {
+    if(m2.len !== m1.len) {
+        return m2.len - m1.len;
+    } else {
+        return m1.index - m2.index;
+    }
+}
+
+export class Scanner<T> {
+    private _input: string;
+    private _lexer: JSLex<T>;
+
+    // position within input stream
+    private _pos: number = 0;
+
+    // current line number
+    private _line: number = 0;
+
+    // current column number
+    private _col: number = 0;
+
+    private _offset: number = 0;
+    private _less: number | null = null;
+    private _go: boolean = false;
+    private _newstate: string | null = null;
+    private _state: string;
+
+    private _text: string | null = null;
+    private _leng: number | null = null;
+
+    constructor(input: string, lexer: JSLex<T>) {
+        this._input = input;
+        this._lexer = lexer;
+        this._state = lexer.states[0];
+    }
+
+    /**
+     * Analogous to yytext and yyleng in lex - will be set during scan.
+     */
+    public text(): string | null {
+        return this._text;
+    }
+
+    public leng(): number | null {
+        return this._leng;
+    }
+
+    /**
+     * Position of in stream, line number and column number of match.
+     */
+    public pos(): number {
+        return this._pos;
+    }
+
+    public line(): number {
+        return this._line;
+    }
+
+    public column(): number {
+        return this._col;
+    }
+
+    /**
+     * Analogous to input() in lex.
+     * @return {string} The next character in the stream.
+     */
+    public input(): string {
+        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.
+     */
+    public unput(): number {
+        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.
+     */
+    public less(n: number): number {
+        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.
+     */
+    public pushback(n: number): number {
+        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.
+     */
+    public reject(): void {
+        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.
+     */
+    public begin(state: string | number): string {
+        if (this._lexer.specification[state]) {
+            return this._newstate = state as string;
+        }
+        const s = this._lexer.states[parseInt(state as string)];
+        if (s) {
+            return this._newstate = s;
+        }
+        throw "Unknown state '" + state + "' requested";
+    }
+
+    /**
+     * Simple accessor for reading in the current state.
+     * @return {string} The current state.
+     */
+    public state(): string {
+        return this._state;
+    }
+
+    /**
+     * Scan method to be returned to caller - grabs the next token and fires appropriate calback.
+     * @return {T} The next token extracted from the stream.
+     */
+    public scan(): T | T[] {
+        if(this._pos >= this._input.length) {
+            return EOF as T;
+        }
+
+        const str = this._input.substring(this._pos);
+        const rules = this._lexer.specification[this._state];
+        const matches: IMatch<T>[] = [];
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+            const mt = str.match(rule.re);
+            if (mt !== null && mt[0].length > 0) {
+                matches.push({
+                    index: i,
+                    text: mt[0],
+                    len: mt[0].length,
+                    rule: rule
+                });
+            }
+        }
+        if (matches.length === 0) {
+            throw new Error("No match found for input '" + str + "'");
+        }
+        matches.sort(matchcompare);
+        this._go = true;
+
+        let result: T | T[];
+        let m: IMatch<T>;
+        for (let j = 0, n = matches.length; j < n && this._go; j++) {
+            this._offset = 0;
+            this._less = null;
+            this._go = false;
+            this._newstate = null;
+            m = matches[j];
+            this._text = m.text;
+            this._leng = m.len;
+            result = m.rule.action(this);
+            if (this._newstate && this._newstate != this._state) {
+                this._state = this._newstate;
+                break;
+            }
+        }
+        const text = this._less === null ? m!.text : m!.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!;
+    }
+}
+
+export class JSLex<T> {
+    public states: string[];
+    public specification: Record<string, IRule<T>[]>;
+
+    constructor(spec: ILexSpec<T>) {
+        this.states = Object.keys(spec);
+        this.specification = {};
+
+        // build out internal representation of the provided spec
+        for (const s of this.states) {
+            // e.g. s = "start"
+            const rule_map = spec[s] as Map<string, (arg0: Scanner<T>) => T | T[]>;
+
+            if (s in this.specification) {
+                throw "Duplicate state declaration encountered for state '" + s + "'";
+            }
+
+            this.specification[s] = [] as IRule<T>[];
+
+            for (const [k,v] of rule_map.entries()) {
+                let re: RegExp;
+                try {
+                    re = new RegExp('^' + k);
+                } catch (err) {
+                    throw "Invalid regexp '" + k + "' in state '" + s + "' (" + (err as Error).message + ")";
+                }
+                this.specification[s].push({
+                    re: 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.
+     */
+    public scanner(input: string): Scanner<T> {
+        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.
+     */
+    public lex(input: string, callback: (arg0: T | T[]) => void) {
+        const scanner = this.scanner(input);
+        while (true) {
+            const token = scanner.scan();
+            if (token === EOF) {
+                return;
+            }
+            if (token !== undefined) {
+                callback(token);
+            }
+        }
+    }
+
+    /**
+     * Consumes all input, collecting tokens along the way.
+     * @param {string} input Text to lex.
+     * @return {array} List of tokens, may contain an Error at the end.
+     */
+    public collect(input: string): T[] {
+        const tokens: T[] = [];
+        const callback = function(item: T | T[]) {
+            if (Array.isArray(item)) {
+                tokens.push(...item);
+            } else {
+                tokens.push(item);
+            }
+        };
+        this.lex(input, callback);
+        return tokens;
+    }
+};

package/src/map.ts

@@ -1,4 +1,16 @@
 const symbolMap = new Map<string, string>([
+    ['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,37 +71,11 @@ const symbolMap = new Map<string, string>([
 
     /* 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'], 
@@ -97,9 +83,6 @@ const symbolMap = new Map<string, string>([
     ['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'], 
@@ -153,7 +136,6 @@ const symbolMap = new Map<string, string>([
     ['div', 'div'], 
     ['divideontimes', 'times.div'], 
     ['dotplus', 'plus.dot'], 
-    ['downarrow', 'arrow.b'], 
     ['ell', 'ell'], 
     ['emptyset', 'nothing'], 
     ['epsilon', 'epsilon.alt'], 
@@ -186,8 +168,6 @@ const symbolMap = new Map<string, string>([
     ['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 @@ const symbolMap = new Map<string, string>([
     ['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 @@ const symbolMap = new Map<string, string>([
     ['supset', 'supset'], 
     ['supseteq', 'supset.eq'], 
     ['supsetneq', 'supset.neq'], 
-    ['swarrow', 'arrow.bl'], 
     ['tau', 'tau'], 
     ['theta', 'theta'], 
     ['times', 'times'], 
@@ -288,8 +266,6 @@ const symbolMap = new Map<string, string>([
     // ['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'], 
@@ -1086,6 +1062,7 @@ for(const [key, value] of Array.from(symbolMap.entries()).reverse()) {
     reverseSymbolMap.set(value, key);
 }
 reverseSymbolMap.set('dif', 'mathrm{d}');
+reverseSymbolMap.set('oo', 'infty');
 
 // force override some one-to-multiple mappings
 const typst_to_tex_map = new Map<string, string>([