tex2typst 0.3.23 → 0.3.25

package/src/typst-types.ts

@@ -0,0 +1,229 @@
+import { array_includes } from "./generic";
+
+export enum TypstTokenType {
+    NONE,
+    SYMBOL,
+    ELEMENT,
+    LITERAL,
+    TEXT,
+    COMMENT,
+    SPACE,
+    CONTROL,
+    NEWLINE
+}
+
+
+export class TypstToken {
+    readonly type: TypstTokenType;
+    value: string;
+
+    constructor(type: TypstTokenType, content: string) {
+        this.type = type;
+        this.value = content;
+    }
+
+    eq(other: TypstToken): boolean {
+        return this.type === other.type && this.value === other.value;
+    }
+
+    isOneOf(tokens: TypstToken[]): boolean {
+        return array_includes(tokens, this);
+    }
+
+    public toNode(): TypstNode {
+        return new TypstTerminal(this);
+    }
+
+    public toString(): string {
+        switch (this.type) {
+            case TypstTokenType.TEXT:
+                return `"${this.value}"`;
+            case TypstTokenType.COMMENT:
+                return `//${this.value}`;
+            default:
+                return this.value;
+        }
+    }
+
+    public static readonly NONE = new TypstToken(TypstTokenType.NONE, '#none');
+}
+
+export interface TypstSupsubData {
+    base: TypstNode;
+    sup: TypstNode | null;
+    sub: TypstNode | null;
+}
+
+
+export interface TypstLeftRightData {
+    body: TypstNode;
+    left: TypstToken | null;
+    right: TypstToken | null;
+}
+
+/**
+ * fraction: `1/2`, `(x + y)/2`, `(1+x)/(1-x)`
+ * group: `a + 1/3`
+ * leftright: `(a + 1/3)`, `[a + 1/3)`, `lr(]sum_(x=1)^n])`
+ * markupFunc: `#heading(level: 2)[something]`, `#text(fill: red)[some text and math $x + y$]`
+ */
+export type TypstNodeType = 'terminal' | 'group' | 'supsub' | 'funcCall' | 'fraction'| 'leftright' | 'matrixLike'| 'markupFunc';
+
+export type TypstNamedParams = { [key: string]: TypstNode; };
+
+export abstract class TypstNode {
+    readonly type: TypstNodeType;
+    head: TypstToken;
+    // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
+    options?: TypstNamedParams;
+
+    constructor(type: TypstNodeType, head: TypstToken | null) {
+        this.type = type;
+        this.head = head ? head : TypstToken.NONE;
+    }
+
+    // whether the node is over high so that if it's wrapped in braces, \left and \right should be used in its TeX form
+    // e.g. 1/2 is over high, "2" is not.
+    abstract isOverHigh(): boolean;
+
+    public setOptions(options: TypstNamedParams) {
+        this.options = options;
+    }
+
+    // Note that this is only shallow equality.
+    public eq(other: TypstNode): boolean {
+        return this.type === other.type && this.head.eq(other.head);
+    }
+
+    public toString(): string {
+        throw new Error(`Unimplemented toString() in base class TypstNode`);
+    }
+}
+
+export class TypstTerminal extends TypstNode {
+    constructor(head: TypstToken) {
+        super('terminal', head);
+    }
+
+    public isOverHigh(): boolean {
+        return false;
+    }
+
+    public toString(): string {
+        return this.head.toString();
+    }
+}
+
+export class TypstGroup extends TypstNode {
+    public items: TypstNode[];
+    constructor(items: TypstNode[]) {
+        super('group', TypstToken.NONE);
+        this.items = items;
+    }
+
+    public isOverHigh(): boolean {
+        return this.items.some((n) => n.isOverHigh());
+    }
+}
+
+export class TypstSupsub extends TypstNode {
+    public base: TypstNode;
+    public sup: TypstNode | null;
+    public sub: TypstNode | null;
+
+    constructor(data: TypstSupsubData) {
+        super('supsub', TypstToken.NONE);
+        this.base = data.base;
+        this.sup = data.sup;
+        this.sub = data.sub;
+    }
+
+    public isOverHigh(): boolean {
+        return this.base.isOverHigh();
+    }
+}
+
+export class TypstFuncCall extends TypstNode {
+    public args: TypstNode[];
+    constructor(head: TypstToken, args: TypstNode[]) {
+        super('funcCall', head);
+        this.args = args;
+    }
+
+    public isOverHigh(): boolean {
+        if (this.head.value === 'frac') {
+            return true;
+        }
+        return this.args.some((n) => n.isOverHigh());
+    }
+}
+
+export class TypstFraction extends TypstNode {
+    public args: TypstNode[];
+
+    constructor(args: TypstNode[]) {
+        super('fraction', TypstToken.NONE);
+        this.args = args;
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+}
+
+
+export class TypstLeftright extends TypstNode {
+    public body: TypstNode;
+    public left: TypstToken | null;
+    public right: TypstToken | null;
+
+    // head is either null or 'lr'
+    constructor(head: TypstToken | null, data: TypstLeftRightData) {
+        super('leftright', head);
+        this.body = data.body;
+        this.left = data.left;
+        this.right = data.right;
+    }
+
+    public isOverHigh(): boolean {
+        return this.body.isOverHigh();
+    }
+}
+
+
+export class TypstMatrixLike extends TypstNode {
+    public matrix: TypstNode[][];
+
+    // head is 'mat', 'cases' or null
+    constructor(head: TypstToken | null, data: TypstNode[][]) {
+        super('matrixLike', head);
+        this.matrix = data;
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+
+    static readonly MAT = new TypstToken(TypstTokenType.SYMBOL, 'mat');
+    static readonly CASES = new TypstToken(TypstTokenType.SYMBOL, 'cases');
+}
+
+export 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"}]
+    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.
+    */
+    public fragments: TypstNode[];
+
+    constructor(head: TypstToken, fragments: TypstNode[]) {
+        super('markupFunc', head);
+        this.fragments = fragments;
+    }
+
+    public isOverHigh(): boolean {
+        return this.fragments.some((n) => n.isOverHigh());
+    }
+}

package/src/typst-writer.ts

@@ -1,8 +1,11 @@
-import { TexNode, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TexNode } from "./tex-types";
+import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMarkupFunc, TypstMatrixLike, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
+import { TypstToken } from "./typst-types";
+import { TypstTokenType } from "./typst-types";
 import { shorthandMap } from "./typst-shorthands";
 
 function is_delimiter(c: TypstNode): boolean {
-    return c.type === 'atom' && ['(', ')', '[', ']', '{', '}', '|', '⌊', '⌋', '⌈', '⌉'].includes(c.content);
+    return c.head.type === TypstTokenType.ELEMENT && ['(', ')', '[', ']', '{', '}', '|', '⌊', '⌋', '⌈', '⌉'].includes(c.head.value);
 }
 
 const TYPST_LEFT_PARENTHESIS: TypstToken = new TypstToken(TypstTokenType.ELEMENT, '(');
@@ -51,7 +54,7 @@ export class TypstWriter {
     }
 
 
-    private writeBuffer(token: TypstToken) {
+    private writeBuffer(previousToken: TypstToken | null, token: TypstToken) {
         const str = token.toString();
 
         if (str === '') {
@@ -81,8 +84,13 @@ export class TypstWriter {
         no_need_space ||= this.buffer.endsWith('&') && str === '=';
         // before or after a slash e.g. "a/b" instead of "a / b"
         no_need_space ||= this.buffer.endsWith('/') || str === '/';
+        // "[$x + y$]" instead of "[ $ x + y $ ]"
+        no_need_space ||= token.type === TypstTokenType.LITERAL;
         // other cases
         no_need_space ||= /[\s_^{\(]$/.test(this.buffer);
+        if (previousToken !== null) {
+            no_need_space ||= previousToken.type === TypstTokenType.LITERAL;
+        }
         if (!no_need_space) {
             this.buffer += ' ';
         }
@@ -91,65 +99,81 @@ export class TypstWriter {
     }
 
     // Serialize a tree of TypstNode into a list of TypstToken
-    public serialize(node: TypstNode) {
-        switch (node.type) {
-            case 'none':
-                this.queue.push(new TypstToken(TypstTokenType.NONE, '#none'));
-                break;
-            case 'atom': {
-                if (node.content === ',' && this.insideFunctionDepth > 0) {
-                    this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 'comma'));
+    public serialize(abstractNode: TypstNode) {
+        switch (abstractNode.type) {
+            case 'terminal': {
+                const node = abstractNode as TypstTerminal;
+                if (node.head.type === TypstTokenType.ELEMENT) {
+                    if (node.head.value === ',' && this.insideFunctionDepth > 0) {
+                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 'comma'));
+                    } else {
+                        this.queue.push(node.head);
+                    }
+                    break;
+                } else if (node.head.type === TypstTokenType.SYMBOL) {
+                    let symbol_name = node.head.value;
+                    if(this.preferShorthands) {
+                        if (shorthandMap.has(symbol_name)) {
+                            symbol_name = shorthandMap.get(symbol_name)!;
+                        }
+                    }
+                    if (this.inftyToOo && symbol_name === 'infinity') {
+                        symbol_name = 'oo';
+                    }
+                    this.queue.push(new TypstToken(TypstTokenType.SYMBOL, symbol_name));
+                    break;
+                } else if (node.head.type === TypstTokenType.SPACE || node.head.type === TypstTokenType.NEWLINE) {
+                    for (const c of node.head.value) {
+                        if (c === ' ') {
+                            if (this.keepSpaces) {
+                                this.queue.push(new TypstToken(TypstTokenType.SPACE, c));
+                            }
+                        } else if (c === '\n') {
+                            this.queue.push(new TypstToken(TypstTokenType.SYMBOL, c));
+                        } else {
+                            throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
+                        }
+                    }
+                    break;
                 } else {
-                    this.queue.push(new TypstToken(TypstTokenType.ELEMENT, node.content));
+                    this.queue.push(node.head);
+                    break;
                 }
-                break;
             }
-            case 'symbol': {
-                let content = node.content;
-                if(this.preferShorthands) {
-                    if (shorthandMap.has(content)) {
-                        content = shorthandMap.get(content)!;
-                    }
-                }
-                if (this.inftyToOo && content === 'infinity') {
-                    content = 'oo';
+            case 'group': {
+                const node = abstractNode as TypstGroup;
+                for (const item of node.items) {
+                    this.serialize(item);
                 }
-                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, content));
                 break;
             }
-            case 'literal':
-                this.queue.push(new TypstToken(TypstTokenType.LITERAL, node.content));
-                break;
-            case 'text':
-                this.queue.push(new TypstToken(TypstTokenType.TEXT, node.content));
-                break;
-            case 'comment':
-                this.queue.push(new TypstToken(TypstTokenType.COMMENT, node.content));
-                break;
-            case 'whitespace':
-                for (const c of node.content) {
-                    if (c === ' ') {
-                        if (this.keepSpaces) {
-                            this.queue.push(new TypstToken(TypstTokenType.SPACE, c));
-                        }
-                    } else if (c === '\n') {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, c));
-                    } else {
-                        throw new TypstWriterError(`Unexpected whitespace character: ${c}`, node);
-                    }
+            case 'leftright': {
+                const node = abstractNode as TypstLeftright;
+                const LR = new TypstToken(TypstTokenType.SYMBOL, 'lr');
+                const {left, right} = node;
+                if (node.head.eq(LR)) {
+                    this.queue.push(LR);
+                    this.queue.push(TYPST_LEFT_PARENTHESIS);
                 }
-                break;
-            case 'group':
-                for (const item of node.args!) {
-                    this.serialize(item);
+                if (left) {
+                    this.queue.push(left);
+                }
+                this.serialize(node.body);
+                if (right) {
+                    this.queue.push(right);
+                }
+                if (node.head.eq(LR)) {
+                    this.queue.push(TYPST_RIGHT_PARENTHESIS);
                 }
                 break;
+            }
             case 'supsub': {
-                let { base, sup, sub } = node.data as TypstSupsubData;
+                const node = abstractNode as TypstSupsub;
+                let { base, sup, sub } = node;
                 this.appendWithBracketsIfNeeded(base);
 
                 let trailing_space_needed = false;
-                const has_prime = (sup && sup.type === 'atom' && sup.content === '\'');
+                const has_prime = (sup && sup.head.eq(new TypstToken(TypstTokenType.ELEMENT, "'")));
                 if (has_prime) {
                     // Put prime symbol before '_'. Because $y_1'$ is not displayed properly in Typst (so far)
                     // e.g.
@@ -172,15 +196,14 @@ export class TypstWriter {
                 break;
             }
             case 'funcCall': {
-                const func_symbol: TypstToken = new TypstToken(TypstTokenType.SYMBOL, node.content);
+                const node = abstractNode as TypstFuncCall;
+                const func_symbol: TypstToken = node.head;
                 this.queue.push(func_symbol);
-                if (node.content !== 'lr') {
-                    this.insideFunctionDepth++;
-                }
+                this.insideFunctionDepth++;
                 this.queue.push(TYPST_LEFT_PARENTHESIS);
-                for (let i = 0; i < node.args!.length; i++) {
-                    this.serialize(node.args![i]);
-                    if (i < node.args!.length - 1) {
+                for (let i = 0; i < node.args.length; i++) {
+                    this.serialize(node.args[i]);
+                    if (i < node.args.length - 1) {
                         this.queue.push(new TypstToken(TypstTokenType.ELEMENT, ','));
                     }
                 }
@@ -190,13 +213,12 @@ export class TypstWriter {
                     }
                 }
                 this.queue.push(TYPST_RIGHT_PARENTHESIS);
-                if (node.content !== 'lr') {
-                    this.insideFunctionDepth--;
-                }
+                this.insideFunctionDepth--;
                 break;
             }
             case 'fraction': {
-                const [numerator, denominator] = node.args!;
+                const node = abstractNode as TypstFraction;
+                const [numerator, denominator] = node.args;
                 const pos = this.queue.length;
                 const no_wrap = this.appendWithBracketsIfNeeded(numerator);
 
@@ -211,105 +233,95 @@ export class TypstWriter {
                 this.appendWithBracketsIfNeeded(denominator);
                 break;
             }
-            case 'align': {
-                const matrix = node.data as TypstNode[][];
-                matrix.forEach((row, i) => {
-                    row.forEach((cell, j) => {
-                        if (j > 0) {
-                            this.queue.push(new TypstToken(TypstTokenType.ELEMENT, '&'));
+            case 'matrixLike': {
+                const node = abstractNode as TypstMatrixLike;
+                const matrix = node.matrix;
+
+                let cell_sep: TypstToken;
+                let row_sep: TypstToken;
+                if (node.head.eq(TypstMatrixLike.MAT)) {
+                    cell_sep = new TypstToken(TypstTokenType.ELEMENT, ',');
+                    row_sep = new TypstToken(TypstTokenType.ELEMENT, ';');
+                } else if (node.head.eq(TypstMatrixLike.CASES)) {
+                    cell_sep = new TypstToken(TypstTokenType.ELEMENT, '&');
+                    row_sep = new TypstToken(TypstTokenType.ELEMENT, ',');
+                } else if (node.head.eq(TypstToken.NONE)){ // head is null
+                    cell_sep = new TypstToken(TypstTokenType.ELEMENT, '&');
+                    row_sep = new TypstToken(TypstTokenType.SYMBOL, '\\');
+                }
+
+                if (!node.head.eq(TypstToken.NONE)) {
+                    this.queue.push(node.head);
+                    this.insideFunctionDepth++;
+                    this.queue.push(TYPST_LEFT_PARENTHESIS);
+                    if (node.options) {
+                        for (const [key, value] of Object.entries(node.options)) {
+                            this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}, `));
                         }
-                        this.serialize(cell);
-                    });
-                    if (i < matrix.length - 1) {
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, '\\'));
-                    }
-                });
-                break;
-            }
-            case 'matrix': {
-                const matrix = node.data as TypstNode[][];
-                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 'mat'));
-                this.insideFunctionDepth++;
-                this.queue.push(TYPST_LEFT_PARENTHESIS);
-                if (node.options) {
-                    for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}, `));
                     }
                 }
+
                 matrix.forEach((row, i) => {
                     row.forEach((cell, j) => {
-                        // There is a leading & in row
-                        // if (cell.type === 'ordgroup' && cell.args!.length === 0) {
-                        // this.queue.push(new TypstNode('atom', ','));
-                        // return;
-                        // }
-                        // if (j == 0 && cell.type === 'newline' && cell.content === '\n') {
-                        // return;
-                        // }
                         this.serialize(cell);
-                        // cell.args!.forEach((n) => this.append(n));
                         if (j < row.length - 1) {
-                            this.queue.push(new TypstToken(TypstTokenType.ELEMENT, ','));
+                            this.queue.push(cell_sep);
                         } else {
                             if (i < matrix.length - 1) {
-                                this.queue.push(new TypstToken(TypstTokenType.ELEMENT, ';'));
+                                this.queue.push(row_sep);
                             }
                         }
                     });
                 });
-                this.queue.push(TYPST_RIGHT_PARENTHESIS);
-                this.insideFunctionDepth--;
+
+                if (!node.head.eq(TypstToken.NONE)) {
+                    this.queue.push(TYPST_RIGHT_PARENTHESIS);
+                    this.insideFunctionDepth--;
+                }
                 break;
             }
-            case 'cases': {
-                const cases = node.data as TypstNode[][];
-                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 'cases'));
-                this.insideFunctionDepth++;
+            case 'markupFunc': {
+                const node = abstractNode as TypstMarkupFunc;
+                this.queue.push(node.head);
                 this.queue.push(TYPST_LEFT_PARENTHESIS);
                 if (node.options) {
-                    for (const [key, value] of Object.entries(node.options)) {
-                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}, `));
+                    const entries = Object.entries(node.options);
+                    for (let i = 0; i < entries.length; i++) {
+                        const [key, value] = entries[i];
+                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}`));
+                        if (i < entries.length - 1) {
+                            this.queue.push(new TypstToken(TypstTokenType.ELEMENT, ','));
+                        }
                     }
                 }
-                cases.forEach((row, i) => {
-                    row.forEach((cell, j) => {
-                        this.serialize(cell);
-                        if (j < row.length - 1) {
-                            this.queue.push(new TypstToken(TypstTokenType.ELEMENT, '&'));
-                        } else {
-                            if (i < cases.length - 1) {
-                                this.queue.push(new TypstToken(TypstTokenType.ELEMENT, ','));
-                            }
-                        }
-                    });
-                });
                 this.queue.push(TYPST_RIGHT_PARENTHESIS);
-                this.insideFunctionDepth--;
-                break;
-            }
-            case 'unknown': {
-                if (this.nonStrict) {
-                    this.queue.push(new TypstToken(TypstTokenType.SYMBOL, node.content));
-                } else {
-                    throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
+
+                this.queue.push(new TypstToken(TypstTokenType.LITERAL, '['));
+                for (const frag of node.fragments) {
+                    this.queue.push(new TypstToken(TypstTokenType.LITERAL, '$'));
+                    this.serialize(frag);
+                    this.queue.push(new TypstToken(TypstTokenType.LITERAL, '$'));
                 }
+                this.queue.push(new TypstToken(TypstTokenType.LITERAL, ']'));
+
                 break;
             }
             default:
-                throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
+                throw new TypstWriterError(`Unimplemented node type to append: ${abstractNode.type}`, abstractNode);
         }
     }
 
     private appendWithBracketsIfNeeded(node: TypstNode): boolean {
-        let need_to_wrap = ['group', 'supsub', 'align', 'fraction','empty'].includes(node.type);
+        let need_to_wrap = ['group', 'supsub', 'matrixLike', 'fraction','empty'].includes(node.type);
 
         if (node.type === 'group') {
-            if (node.args!.length === 0) {
+            const group = node as TypstGroup;
+            if (group.items.length === 0) {
                 // e.g. TeX `P_{}` converts to Typst `P_()`
                 need_to_wrap = true;
             } else {
-                const first = node.args![0];
-                const last = node.args![node.args!.length - 1];
+                const first = group.items[0];
+                const last = group.items[group.items.length - 1];
                 if (is_delimiter(first) && is_delimiter(last)) {
                     need_to_wrap = false;
                 }
@@ -347,9 +359,11 @@ export class TypstWriter {
 
         this.queue = this.queue.filter((token) => !token.eq(dummy_token));
 
-        this.queue.forEach((token) => {
-            this.writeBuffer(token)
-        });
+        for(let i = 0; i < this.queue.length; i++) {
+            let token = this.queue[i];
+            let previous_token = i === 0 ? null : this.queue[i - 1];
+            this.writeBuffer(previous_token, token);
+        }
 
         this.queue = [];
     }

package/src/util.ts

@@ -7,7 +7,7 @@ export function isdigit(char: string): boolean {
     return '0123456789'.includes(char);
 }
 
-export function assert(condition: boolean, message: string = ''): void {
+export function assert(condition: boolean, message: string = 'Assertion failed.'): void {
     if (!condition) {
         throw new Error(message);
     }