tex2typst 0.3.22 → 0.3.24

package/src/typst-types.ts

@@ -0,0 +1,221 @@
+import { array_includes } from "./generic";
+
+export enum TypstTokenType {
+    NONE,
+    SYMBOL,
+    ELEMENT,
+    LITERAL,
+    TEXT,
+    COMMENT,
+    SPACE,
+    CONTROL,
+    NEWLINE
+}
+
+
+export class TypstToken {
+    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 {
+    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])`
+ */
+export type TypstNodeType = 'terminal' | 'group' | 'supsub' | 'funcCall' | 'fraction'| 'leftright' | 'align' | 'matrix' | 'cases';
+
+export type TypstNamedParams = { [key: string]: TypstNode; };
+
+export abstract class TypstNode {
+    readonly type: TypstNodeType;
+    head: TypstToken;
+    args?: TypstNode[];
+    // Some Typst functions accept additional options. e.g. mat() has option "delim", op() has option "limits"
+    options?: TypstNamedParams;
+
+    constructor(type: TypstNodeType, head: TypstToken | null, args?: TypstNode[]) {
+        this.type = type;
+        this.head = head ? head : TypstToken.NONE;
+        this.args = args;
+    }
+
+    // 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 {
+    constructor(args: TypstNode[]) {
+        super('group', TypstToken.NONE, args);
+    }
+
+    public isOverHigh(): boolean {
+        return this.args!.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 {
+    constructor(head: TypstToken, args: TypstNode[]) {
+        super('funcCall', head, args);
+    }
+
+    public isOverHigh(): boolean {
+        if (this.head.value === 'frac') {
+            return true;
+        }
+        return this.args!.some((n) => n.isOverHigh());
+    }
+}
+
+export class TypstFraction extends TypstNode {
+    constructor(args: TypstNode[]) {
+        super('fraction', TypstToken.NONE, args);
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+}
+
+
+export class TypstLeftright extends TypstNode {
+    public left: TypstToken | null;
+    public right: TypstToken | null;
+
+    constructor(head: TypstToken | null, args: TypstNode[], data: TypstLeftRightData) {
+        super('leftright', head, args);
+        this.left = data.left;
+        this.right = data.right;
+    }
+
+    public isOverHigh(): boolean {
+        return this.args!.some((n) => n.isOverHigh());
+    }
+}
+
+export class TypstAlign extends TypstNode {
+    public matrix: TypstNode[][];
+
+    constructor(data: TypstNode[][]) {
+        super('align', TypstToken.NONE, []);
+        this.matrix = data;
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+}
+
+export class TypstMatrix extends TypstNode {
+    public matrix: TypstNode[][];
+
+    constructor(data: TypstNode[][]) {
+        super('matrix', TypstToken.NONE, []);
+        this.matrix = data;
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+}
+
+export class TypstCases extends TypstNode {
+    public matrix: TypstNode[][];
+
+    constructor(data: TypstNode[][]) {
+        super('cases', TypstToken.NONE, []);
+        this.matrix = data;
+    }
+
+    public isOverHigh(): boolean {
+        return true;
+    }
+}
+

package/src/typst-writer.ts

@@ -1,9 +1,11 @@
-import { TexNode, TypstNode, TypstPrimitiveValue, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TexNode } from "./tex-types";
+import { TypstAlign, TypstCases, TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstMatrix, TypstNode, TypstSupsub, TypstTerminal } from "./typst-types";
+import { TypstToken } from "./typst-types";
+import { TypstTokenType } from "./typst-types";
 import { shorthandMap } from "./typst-shorthands";
-import { assert } from "./util";
 
 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, '(');
@@ -13,20 +15,6 @@ const TYPST_NEWLINE: TypstToken = new TypstToken(TypstTokenType.SYMBOL, '\n');
 
 const SOFT_SPACE = new TypstToken(TypstTokenType.CONTROL, ' ');
 
-function typst_primitive_to_string(value: TypstPrimitiveValue) {
-    switch (typeof value) {
-        case 'string':
-            return `"${value}"`;
-        case 'number':
-            return (value as number).toString();
-        case 'boolean':
-            return (value as boolean) ? '#true' : '#false';
-        default:
-            assert(value instanceof TypstNode, 'Not a valid primitive value');
-            return (value as TypstNode).content;
-    }
-}
-
 export class TypstWriterError extends Error {
     node: TexNode | TypstNode | TypstToken;
 
@@ -106,62 +94,83 @@ 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.args!) {
+                    this.serialize(item);
                 }
-                this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 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);
+                }
+                if (left) {
+                    this.queue.push(left);
                 }
-                break;
-            case 'group':
                 for (const item of node.args!) {
                     this.serialize(item);
                 }
+                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.
@@ -184,11 +193,10 @@ 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]);
@@ -198,17 +206,15 @@ export class TypstWriter {
                 }
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        const value_str = typst_primitive_to_string(value);
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `, ${key}: ${value_str}`));
+                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `, ${key}: ${value.toString()}`));
                     }
                 }
                 this.queue.push(TYPST_RIGHT_PARENTHESIS);
-                if (node.content !== 'lr') {
-                    this.insideFunctionDepth--;
-                }
+                this.insideFunctionDepth--;
                 break;
             }
             case 'fraction': {
+                const node = abstractNode as TypstFraction;
                 const [numerator, denominator] = node.args!;
                 const pos = this.queue.length;
                 const no_wrap = this.appendWithBracketsIfNeeded(numerator);
@@ -225,7 +231,8 @@ export class TypstWriter {
                 break;
             }
             case 'align': {
-                const matrix = node.data as TypstNode[][];
+                const node = abstractNode as TypstAlign;
+                const matrix = node.matrix;
                 matrix.forEach((row, i) => {
                     row.forEach((cell, j) => {
                         if (j > 0) {
@@ -240,14 +247,14 @@ export class TypstWriter {
                 break;
             }
             case 'matrix': {
-                const matrix = node.data as TypstNode[][];
+                const node = abstractNode as TypstMatrix;
+                const matrix = node.matrix;
                 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)) {
-                        const value_str = typst_primitive_to_string(value);
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value_str}, `));
+                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}, `));
                     }
                 }
                 matrix.forEach((row, i) => {
@@ -276,14 +283,14 @@ export class TypstWriter {
                 break;
             }
             case 'cases': {
-                const cases = node.data as TypstNode[][];
+                const node = abstractNode as TypstCases;
+                const cases = node.matrix;
                 this.queue.push(new TypstToken(TypstTokenType.SYMBOL, 'cases'));
                 this.insideFunctionDepth++;
                 this.queue.push(TYPST_LEFT_PARENTHESIS);
                 if (node.options) {
                     for (const [key, value] of Object.entries(node.options)) {
-                        const value_str = typst_primitive_to_string(value);
-                        this.queue.push(new TypstToken(TypstTokenType.SYMBOL, `${key}: ${value_str}, `));
+                        this.queue.push(new TypstToken(TypstTokenType.LITERAL, `${key}: ${value.toString()}, `));
                     }
                 }
                 cases.forEach((row, i) => {
@@ -302,21 +309,13 @@ export class TypstWriter {
                 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);
-                }
-                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', 'fraction','empty'].includes(node.type);
+        let need_to_wrap = ['group', 'supsub', 'align', 'fraction','empty'].includes(node.type);
 
         if (node.type === 'group') {
             if (node.args!.length === 0) {

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);
     }

package/dist/types.d.ts

@@ -1,111 +0,0 @@
-export declare enum TexTokenType {
-    ELEMENT = 0,
-    COMMAND = 1,
-    TEXT = 2,
-    COMMENT = 3,
-    SPACE = 4,
-    NEWLINE = 5,
-    CONTROL = 6,
-    UNKNOWN = 7
-}
-export declare class TexToken {
-    type: TexTokenType;
-    value: string;
-    constructor(type: TexTokenType, value: string);
-    eq(token: TexToken): boolean;
-    toString(): string;
-}
-export interface TexSupsubData {
-    base: TexNode;
-    sup?: TexNode;
-    sub?: TexNode;
-}
-export type TexSqrtData = TexNode;
-export type TexArrayData = TexNode[][];
-/**
- * element: 0-9, a-z, A-Z, punctuations such as +-/*,:; etc.
- * symbol: LaTeX macro with no parameter. e.g. \sin \cos \int \sum
- * unaryFunc: LaTeX macro with 1 parameter. e.g. \sqrt{3} \log{x} \exp{x}
- * binaryFunc: LaTeX macro with 2 parameters. e.g. \frac{1}{2}
- * text: text enclosed by braces. e.g. \text{hello world}
- * empty: special type when something is empty. e.g. the base of _{a} or ^{a}
- * whitespace: space, tab, newline
- */
-type TexNodeType = 'element' | 'text' | 'comment' | 'whitespace' | 'control' | 'ordgroup' | 'supsub' | 'unaryFunc' | 'binaryFunc' | 'leftright' | 'beginend' | 'symbol' | 'empty' | 'unknownMacro';
-export declare class TexNode {
-    type: TexNodeType;
-    content: string;
-    args?: TexNode[];
-    data?: TexSqrtData | TexSupsubData | TexArrayData;
-    constructor(type: TexNodeType, content: string, args?: TexNode[], data?: TexSqrtData | TexSupsubData | TexArrayData);
-    eq(other: TexNode): boolean;
-    toString(): string;
-    serialize(): TexToken[];
-}
-export declare enum TypstTokenType {
-    NONE = 0,
-    SYMBOL = 1,
-    ELEMENT = 2,
-    TEXT = 3,
-    COMMENT = 4,
-    SPACE = 5,
-    CONTROL = 6,
-    NEWLINE = 7
-}
-export declare class TypstToken {
-    type: TypstTokenType;
-    value: string;
-    constructor(type: TypstTokenType, content: string);
-    eq(other: TypstToken): boolean;
-    isOneOf(tokens: TypstToken[]): boolean;
-    toNode(): TypstNode;
-    toString(): string;
-}
-export interface TypstSupsubData {
-    base: TypstNode;
-    sup?: TypstNode;
-    sub?: TypstNode;
-}
-export type TypstArrayData = TypstNode[][];
-export interface TypstLrData {
-    leftDelim: string | null;
-    rightDelim: string | null;
-}
-type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace' | 'none' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'cases' | 'unknown';
-export type TypstPrimitiveValue = string | boolean | TypstNode;
-export type TypstNamedParams = {
-    [key: string]: TypstPrimitiveValue;
-};
-export declare class TypstNode {
-    type: TypstNodeType;
-    content: string;
-    args?: TypstNode[];
-    data?: TypstSupsubData | TypstArrayData | TypstLrData;
-    options?: TypstNamedParams;
-    constructor(type: TypstNodeType, content: string, args?: TypstNode[], data?: TypstSupsubData | TypstArrayData | TypstLrData);
-    setOptions(options: TypstNamedParams): void;
-    eq(other: TypstNode): boolean;
-    isOverHigh(): boolean;
-}
-export declare const TYPST_NONE: TypstNode;
-export declare const TYPST_TRUE: TypstPrimitiveValue;
-export declare const TYPST_FALSE: TypstPrimitiveValue;
-/**
- * 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 {};