tex2typst 0.2.15 → 0.3.0-alpha

package/src/types.ts

@@ -1,3 +1,5 @@
+import { array_includes } from "./generic";
+
 export enum TexTokenType {
     ELEMENT,
     COMMAND,
@@ -9,6 +11,30 @@ export enum TexTokenType {
     UNKNOWN,
 }
 
+export class TexToken {
+    type: TexTokenType;
+    value: string;
+
+    constructor(type: TexTokenType, value: string) {
+        this.type = type;
+        this.value = value;
+    }
+
+    public eq(token: TexToken): boolean {
+        return this.type === token.type && this.value === token.value;
+    }
+
+    public toString(): string {
+        switch (this.type) {
+            case TexTokenType.TEXT:
+                return `\\text{${this.value}}`;
+            case TexTokenType.COMMENT:
+                return `%${this.value}`;
+            default:
+                return this.value;
+        }
+    }
+}
 
 
 export interface TexSupsubData {
@@ -33,6 +59,14 @@ export type TexArrayData = TexNode[][];
 type TexNodeType = 'element' | 'text' | 'comment' | 'whitespace' | 'control' | 'ordgroup' | 'supsub'
              | 'unaryFunc' | 'binaryFunc' | 'leftright' | 'beginend' | 'symbol' | 'empty' | 'unknownMacro';
 
+
+function apply_escape_if_needed(c: string) {
+    if (['{', '}', '%'].includes(c)) {
+        return '\\' + c;
+    }
+    return c;
+}
+
 export class TexNode {
     type: TexNodeType;
     content: string;
@@ -50,7 +84,8 @@ export class TexNode {
         this.data = data;
     }
 
-    public eq_shallow(other: TexNode): boolean {
+    // Note that this is only shallow equality.
+    public eq(other: TexNode): boolean {
         return this.type === other.type && this.content === other.content;
     }
 
@@ -62,11 +97,130 @@ export class TexNode {
                 throw new Error(`toString() is not implemented for type ${this.type}`);
         }
     }
+
+
+    public serialize(): TexToken[] {
+        switch (this.type) {
+            case 'empty':
+                return [];
+            case 'element': {
+                let c = this.content;
+                c = apply_escape_if_needed(c);
+                return [new TexToken(TexTokenType.ELEMENT, c)];
+            }
+            case 'symbol':
+                return [new TexToken(TexTokenType.COMMAND, this.content)];
+            case 'text':
+                return [new TexToken(TexTokenType.TEXT, this.content)];
+            case 'comment':
+                return [new TexToken(TexTokenType.COMMENT, this.content)];
+            case 'whitespace': {
+                const tokens: TexToken[] = [];
+                for (const c of this.content) {
+                    const token_type = c === ' ' ? TexTokenType.SPACE : TexTokenType.NEWLINE;
+                    tokens.push(new TexToken(token_type, c));
+                }
+                return tokens;
+            }
+            case 'ordgroup':
+                return this.args!.map((n) => n.serialize()).flat();
+            case 'unaryFunc': {
+                let tokens: TexToken[] = [];
+                tokens.push(new TexToken(TexTokenType.COMMAND, this.content));
+
+                // special hook for \sqrt
+                if (this.content === '\\sqrt' && this.data) {
+                    tokens.push(new TexToken(TexTokenType.ELEMENT, '['));
+                    tokens = tokens.concat((this.data! as TexSqrtData).serialize());
+                    tokens.push(new TexToken(TexTokenType.ELEMENT, ']'));
+                }
+                // special hook for \operatorname
+                if (this.content === '\\operatorname' && this.args!.length === 1 && this.args![0].type === 'text') {
+                    const text = this.args![0].content;
+                    tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                    // this.serialize(new TexNode('symbol', text));
+                    tokens.push(new TexToken(TexTokenType.COMMAND, text));
+                    tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+                    return tokens;
+                }
+
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                tokens = tokens.concat(this.args![0].serialize());
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+
+                return tokens;
+            }
+            case 'binaryFunc': {
+                let tokens: TexToken[] = [];
+                tokens.push(new TexToken(TexTokenType.COMMAND, this.content));
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                tokens = tokens.concat(this.args![0].serialize());
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                tokens = tokens.concat(this.args![1].serialize());
+                tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+                return tokens;
+            }
+            case 'supsub': {
+                let tokens: TexToken[] = [];
+                const { base, sup, sub } = this.data! as TexSupsubData;
+                tokens = tokens.concat(base.serialize());
+                if (sub) {
+                    tokens.push(new TexToken(TexTokenType.CONTROL, '_'));
+                    if (sub.type === 'ordgroup' || sub.type === 'supsub' || sub.type === 'empty') {
+                        tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                        tokens = tokens.concat(sub.serialize());
+                        tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+                    } else {
+                        tokens = tokens.concat(sub.serialize());
+                    }
+                }
+                if (sup) {
+                    tokens.push(new TexToken(TexTokenType.CONTROL, '^'));
+                    if (sup.type === 'ordgroup' || sup.type === 'supsub' || sup.type === 'empty') {
+                        tokens.push(new TexToken(TexTokenType.ELEMENT, '{'));
+                        tokens = tokens.concat(sup.serialize());
+                        tokens.push(new TexToken(TexTokenType.ELEMENT, '}'));
+                    } else {
+                        tokens = tokens.concat(sup.serialize());
+                    }
+                }
+                return tokens;
+            }
+            case 'control': {
+                return [new TexToken(TexTokenType.CONTROL, this.content)];
+            }
+            case 'beginend': {
+                let tokens: TexToken[] = [];
+                const matrix = this.data as TexArrayData;
+                tokens.push(new TexToken(TexTokenType.COMMAND, `\\begin{${this.content}}`));
+                tokens.push(new TexToken(TexTokenType.NEWLINE, '\n'));
+                for (let i = 0; i < matrix.length; i++) {
+                    const row = matrix[i];
+                    for (let j = 0; j < row.length; j++) {
+                        const cell = row[j];
+                        tokens = tokens.concat(cell.serialize());
+                        if (j !== row.length - 1) {
+                            tokens.push(new TexToken(TexTokenType.CONTROL, '&'));
+                        }
+                    }
+                    if (i !== matrix.length - 1) {
+                        tokens.push(new TexToken(TexTokenType.CONTROL, '\\\\'));
+                    }
+                }
+                tokens.push(new TexToken(TexTokenType.NEWLINE, '\n'));
+                tokens.push(new TexToken(TexTokenType.COMMAND, `\\end{${this.content}}`));
+                return tokens;
+            }
+            default:
+                throw new Error('[TexNode.serialize] Unimplemented type: ' + this.type);
+        }
+    }
 }
 
 export enum TypstTokenType {
     SYMBOL,
-    ATOM,
+    ELEMENT,
     TEXT,
     COMMENT,
     SPACE,
@@ -77,26 +231,63 @@ export enum TypstTokenType {
 
 export class TypstToken {
     type: TypstTokenType;
-    content: string;
+    value: string;
 
     constructor(type: TypstTokenType, content: string) {
         this.type = type;
-        this.content = content;
+        this.value = content;
     }
 
     eq(other: TypstToken): boolean {
-        return this.type === other.type && this.content === other.content;
+        return this.type === other.type && this.value === other.value;
     }
 
     isOneOf(tokens: TypstToken[]): boolean {
-        let found = false;
-        for (const token of tokens) {
-            if (this.eq(token)) {
-                found = true;
-                break;
+        return array_includes(tokens, this);
+    }
+
+    public toNode(): TypstNode {
+        switch(this.type) {
+            case TypstTokenType.TEXT:
+                return new TypstNode('text', this.value);
+            case TypstTokenType.COMMENT:
+                return new TypstNode('comment', this.value);
+            case TypstTokenType.SPACE:
+            case TypstTokenType.NEWLINE:
+                return new TypstNode('whitespace', this.value);
+            case TypstTokenType.ELEMENT:
+                return new TypstNode('atom', this.value);
+            case TypstTokenType.SYMBOL:
+                return new TypstNode('symbol', this.value);
+            case TypstTokenType.CONTROL: {
+                const controlChar = this.value;
+                switch (controlChar) {
+                    case '':
+                    case '_':
+                    case '^':
+                        return new TypstNode('empty', '');
+                    case '&':
+                        return new TypstNode('control', '&');
+                    case '\\':
+                        return new TypstNode('control', '\\');
+                    default:
+                        throw new Error(`Unexpected control character ${controlChar}`);
+                }
             }
+            default:
+                throw new Error(`Unexpected token type ${this.type}`);
+        }
+    }
+
+    public toString(): string {
+        switch (this.type) {
+            case TypstTokenType.TEXT:
+                return `"${this.value}"`;
+            case TypstTokenType.COMMENT:
+                return `//${this.value}`;
+            default:
+                return this.value;
         }
-        return found;
     }
 }
 
@@ -108,8 +299,8 @@ export interface TypstSupsubData {
 
 export type TypstArrayData = TypstNode[][];
 
-type TypstNodeType = 'atom' | 'symbol' | 'text' | 'softSpace' | 'comment' | 'whitespace'
-            | 'empty' | 'group' | 'supsub' | 'unaryFunc' | 'binaryFunc' | 'align' | 'matrix' | 'unknown';
+type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace'
+            | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'unknown';
 
 
 export class TypstNode {
@@ -132,7 +323,8 @@ export class TypstNode {
         this.options = options;
     }
 
-    public eq_shallow(other: TypstNode): boolean {
+    // Note that this is only shallow equality.
+    public eq(other: TypstNode): boolean {
         return this.type === other.type && this.content === other.content;
     }
 }