tex2typst 0.3.0 → 0.3.2

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 arrow.r 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.0",
+  "version": "0.3.2",
   "description": "JavaScript library for converting TeX code to Typst",
   "type": "module",
   "main": "dist/index.js",
@@ -15,8 +15,8 @@
   ],
   "scripts": {
     "prebuild": "rimraf dist/",
-    "build:node": "bun build --entrypoints src/index.ts  --outdir ./dist  --target node",
-    "build:browser": "bun build --entrypoints src/tex2typst.ts --outdir ./dist --target browser --entry-naming [dir]/[name].min.[ext] --minify",
+    "build:node": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js --format=esm",
+    "build:browser": "esbuild src/tex2typst.ts --bundle --platform=browser --outfile=dist/tex2typst.min.js --minify",
     "build:types": "tsc --project ./tsconfig.json",
     "build": "npm run build:node && npm run build:browser && npm run build:types",
     "test": "vitest run",
@@ -27,9 +27,9 @@
     "js-yaml": "^4.1.0",
     "rimraf": "^3.0.2",
     "toml": "^3.0.0",
-    "ts-node": "^10.9.2",
     "typescript": "^5.5.3",
-    "vitest": "^2.0.2"
+    "vitest": "^2.0.2",
+    "esbuild": "^0.25.1"
   },
   "dependencies": {}
 }

package/src/convert.ts

@@ -1,7 +1,18 @@
-import { TexNode, TypstNode, TexSupsubData, TypstSupsubData, TexSqrtData, Tex2TypstOptions } 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)) {
@@ -60,7 +71,7 @@ function convert_overset(node: TexNode, options: Tex2TypstOptions): TypstNode {
         'op',
         [convert_tex_node_to_typst(base, options)]
     );
-    op_call.setOptions({ limits: '#true' });
+    op_call.setOptions({ limits: TYPST_TRUE });
     return new TypstNode(
         'supsub',
         '',
@@ -240,11 +251,37 @@ export function convert_tex_node_to_typst(node: TexNode, options: Tex2TypstOptio
             if (node.content!.startsWith('align')) {
                 // align, align*, alignat, alignat*, aligned, etc.
                 return new TypstNode('align', '', [], data);
-            } else {
+            }
+            if (node.content!.endsWith('matrix')) {
+                let delim: TypstPrimitiveValue = null;
+                switch (node.content) {
+                    case 'matrix':
+                        delim = TYPST_NONE;
+                        break;
+                    case 'pmatrix':
+                        delim = '(';
+                        break;
+                    case 'bmatrix':
+                        delim = '[';
+                        break;
+                    case 'Bmatrix':
+                        delim = '{';
+                        break;
+                    case 'vmatrix':
+                        delim = '|';
+                        break;
+                    case 'Vmatrix': {
+                        delim = new TypstToken(TypstTokenType.SYMBOL, 'bar.v.double');
+                        break;
+                    }
+                    default:
+                        throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
+                }
                 const res = new TypstNode('matrix', '', [], data);
-                res.setOptions({ 'delim': '#none' });
+                res.setOptions({ 'delim': delim });
                 return res;
             }
+            throw new TypstWriterError(`Unimplemented beginend: ${node.content}`, node);
         }
         case 'unknownMacro':
             return new TypstNode('unknown', tex_token_to_typst(node.content));
@@ -416,7 +453,7 @@ export function convert_typst_node_to_tex(node: TypstNode): TexNode {
             if (node.options) {
                 if ('delim' in node.options) {
                     switch (node.options.delim) {
-                        case '#none':
+                        case TYPST_NONE:
                             return matrix;
                         case '[':
                             left_delim = "\\left[";

package/src/index.ts

@@ -1,6 +1,6 @@
 import { parseTex } from "./tex-parser";
-import { Tex2TypstOptions } from "./types";
-import { TypstWriter } from "./typst-writer";
+import type { Tex2TypstOptions } from "./types";
+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/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>([

package/src/tex-parser.ts

@@ -296,46 +296,39 @@ export class LatexParser {
     }
 
     parse(tokens: TexToken[]): TexNode {
+        const [tree, _] = this.parseGroup(tokens, 0, tokens.length);
+        return tree;
+    }
+
+    parseGroup(tokens: TexToken[], start: number, end: number): ParseResult {
         const results: TexNode[] = [];
-        let pos = 0;
-        while (pos < tokens.length) {
-            const results: TexNode[] = [];
-            let pos = 0;
-    
-            while (pos < tokens.length) {
-                const [res, newPos] = this.parseNextExpr(tokens, pos);
-                pos = newPos;
-                if(res.type === 'whitespace') {
-                    if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
-                        continue;
-                    }
-                    if (!this.newline_sensitive && res.content === '\n') {
-                        continue;
-                    }
+        let pos = start;
+        while (pos < end) {
+            const [res, newPos] = this.parseNextExpr(tokens, pos);
+            pos = newPos;
+            if(res.type === 'whitespace') {
+                if (!this.space_sensitive && res.content.replace(/ /g, '').length === 0) {
+                    continue;
                 }
-                if (res.type === 'control' && res.content === '&') {
-                    throw new LatexParserError('Unexpected & outside of an alignment');
+                if (!this.newline_sensitive && res.content === '\n') {
+                    continue;
                 }
-                results.push(res);
             }
-    
-            if (results.length === 0) {
-                return EMPTY_NODE;
-            } else if (results.length === 1) {
-                return results[0];
-            } else {
-                return new TexNode('ordgroup', '', results);
+            if (res.type === 'control' && res.content === '&') {
+                throw new LatexParserError('Unexpected & outside of an alignment');
             }
+            results.push(res);
         }
 
-
+        let node: TexNode;
         if (results.length === 0) {
-            return EMPTY_NODE;
+            node = EMPTY_NODE;
         } else if (results.length === 1) {
-            return results[0];
+            node = results[0];
         } else {
-            return new TexNode('ordgroup', '', results);
+            node = new TexNode('ordgroup', '', results);
         }
+        return [node, end + 1];
     }
 
     parseNextExpr(tokens: TexToken[], start: number): ParseResult {
@@ -396,8 +389,7 @@ export class LatexParser {
 
     parseNextExprWithoutSupSub(tokens: TexToken[], start: number): ParseResult {
         const firstToken = tokens[start];
-        const tokenType = firstToken.type;
-        switch (tokenType) {
+        switch (firstToken.type) {
             case TexTokenType.ELEMENT:
                 return [new TexNode('element', firstToken.value), start + 1];
             case TexTokenType.TEXT:
@@ -423,8 +415,7 @@ export class LatexParser {
                         if(posClosingBracket === -1) {
                             throw new LatexParserError("Unmatched '{'");
                         }
-                        const exprInside = tokens.slice(start + 1, posClosingBracket);
-                        return [this.parse(exprInside), posClosingBracket + 1];
+                        return this.parseGroup(tokens, start + 1, posClosingBracket);
                     case '}':
                         throw new LatexParserError("Unmatched '}'");
                     case '\\\\':
@@ -453,7 +444,7 @@ export class LatexParser {
 
         if (['left', 'right', 'begin', 'end'].includes(command.slice(1))) {
             throw new LatexParserError('Unexpected command: ' + command);
-        } 
+        }
 
 
         const paramNum = get_command_param_num(command.slice(1));
@@ -475,8 +466,7 @@ export class LatexParser {
                     if (posRightSquareBracket === -1) {
                         throw new LatexParserError('No matching right square bracket for [');
                     }
-                    const exprInside = tokens.slice(posLeftSquareBracket + 1, posRightSquareBracket);
-                    const exponent = this.parse(exprInside);
+                    const [exponent, _] = this.parseGroup(tokens, posLeftSquareBracket + 1, posRightSquareBracket);
                     const [arg1, newPos] = this.parseNextExprWithoutSupSub(tokens, posRightSquareBracket + 1);
                     return [new TexNode('unaryFunc', command, [arg1], exponent), newPos];
                 } else if (command === '\\text') {
@@ -529,15 +519,14 @@ export class LatexParser {
         if (pos >= tokens.length) {
             throw new LatexParserError('Expecting \\right after \\left');
         }
-        
+
         const rightDelimiter = eat_parenthesis(tokens, pos);
         if (rightDelimiter === null) {
             throw new LatexParserError('Invalid delimiter after \\right');
         }
         pos++;
 
-        const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
-        const body = this.parse(exprInside);
+        const [body, _] = this.parseGroup(tokens, exprInsideStart, exprInsideEnd);
         const args: TexNode[] = [
             new TexNode('element', leftDelimiter.value),
             body,
@@ -556,9 +545,9 @@ export class LatexParser {
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
         const envName = tokens[pos + 1].value;
         pos += 3;
-        
+
         pos += eat_whitespaces(tokens, pos).length; // ignore whitespaces and '\n' after \begin{envName}
-        
+
         const exprInsideStart = pos;
 
         const endIdx = find_closing_end_command(tokens, start);
@@ -567,7 +556,7 @@ export class LatexParser {
         }
         const exprInsideEnd = endIdx;
         pos = endIdx + 1;
-        
+
         assert(tokens[pos].eq(LEFT_CURLY_BRACKET));
         assert(tokens[pos + 1].type === TexTokenType.TEXT);
         assert(tokens[pos + 2].eq(RIGHT_CURLY_BRACKET));
@@ -575,7 +564,7 @@ export class LatexParser {
             throw new LatexParserError('Mismatched \\begin and \\end environments');
         }
         pos += 3;
-    
+
         const exprInside = tokens.slice(exprInsideStart, exprInsideEnd);
         // ignore spaces and '\n' before \end{envName}
         while(exprInside.length > 0 && [TexTokenType.SPACE, TexTokenType.NEWLINE].includes(exprInside[exprInside.length - 1].type)) {
@@ -606,7 +595,7 @@ export class LatexParser {
                     continue;
                 }
             }
-            
+
             if (res.type === 'control' && res.content === '\\\\') {
                 row = [];
                 group = new TexNode('ordgroup', '', []);

package/src/tex-writer.ts

@@ -1,5 +1,4 @@
 import { array_includes, array_split } from "./generic";
-import { reverseSymbolMap } from "./map";
 import { TexNode, TexToken, TexSupsubData, TexTokenType } from "./types";
 
 

package/src/types.ts

@@ -352,7 +352,13 @@ export type TypstArrayData = TypstNode[][];
 type TypstNodeType = 'atom' | 'symbol' | 'text' | 'control' | 'comment' | 'whitespace'
             | 'empty' | 'group' | 'supsub' | 'funcCall' | 'fraction' | 'align' | 'matrix' | 'unknown';
 
-export type TypstNamedParams = { [key: string]: string };
+export type TypstPrimitiveValue = string | boolean | null | TypstToken;
+export type TypstNamedParams = { [key: string]: TypstPrimitiveValue };
+
+// #none
+export const TYPST_NONE: TypstPrimitiveValue = null;
+export const TYPST_TRUE: TypstPrimitiveValue = true;
+export const TYPST_FALSE: TypstPrimitiveValue = false;
 
 export class TypstNode {
     type: TypstNodeType;
@@ -370,7 +376,7 @@ export class TypstNode {
         this.data = data;
     }
 
-    public setOptions(options: { [key: string]: string }) {
+    public setOptions(options: TypstNamedParams) {
         this.options = options;
     }
 
@@ -383,8 +389,10 @@ export class TypstNode {
 export interface Tex2TypstOptions {
     nonStrict?: boolean; // default is true
     preferTypstIntrinsic?: boolean; // default is true,
+    preferShorthands?: boolean; // default is true
     keepSpaces?: boolean; // default is false
     fracToSlash?: boolean; // default is true
+    inftyToOo?: boolean; // default is false
     customTexMacros?: { [key: string]: string };
     // TODO: custom typst functions
 }

package/src/typst-parser.ts

@@ -1,7 +1,14 @@
 
 import { array_find } from "./generic";
-import { TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
+import { TYPST_NONE, TypstNamedParams, TypstNode, TypstSupsubData, TypstToken, TypstTokenType } from "./types";
 import { assert, isalpha, isdigit } from "./util";
+import { reverseShorthandMap } from "./typst-shorthands";
+
+
+
+const TYPST_EMPTY_NODE = new TypstNode('empty', '');
+
+const TYPST_SHORTHANDS = Array.from(reverseShorthandMap.keys());
 
 // TODO: In Typst, y' ' is not the same as y''.
 // The parser should be able to parse the former correctly.
@@ -22,8 +29,14 @@ function eat_identifier_name(typst: string, start: number): string {
     return typst.substring(start, pos);
 }
 
-
-const TYPST_EMPTY_NODE = new TypstNode('empty', '');
+function try_eat_shorthand(typst: string, start: number): string | null {
+    for (const shorthand of TYPST_SHORTHANDS) {
+        if (typst.startsWith(shorthand, start)) {
+            return shorthand;
+        }
+    }
+    return null;
+}
 
 
 export function tokenize_typst(typst: string): TypstToken[] {
@@ -115,6 +128,13 @@ export function tokenize_typst(typst: string): TypstToken[] {
                 break;
             }
             default: {
+                const shorthand = try_eat_shorthand(typst, pos);
+                if (shorthand !== null) {
+                    token = new TypstToken(TypstTokenType.SYMBOL, reverseShorthandMap.get(shorthand)!);
+                    pos += shorthand.length;
+                    break;
+                }
+
                 if (isdigit(firstChar)) {
                     let newPos = pos;
                     while (newPos < typst.length && isdigit(typst[newPos])) {
@@ -450,7 +470,6 @@ export class TypstParser {
     // start: the position of the left parentheses
     parseArguments(tokens: TypstToken[], start: number): [TypstNode[], number] {
         const end = find_closing_match(tokens, start);
-        
         return [this.parseCommaSeparatedArguments(tokens, start + 1, end), end + 1];
     }
 
@@ -501,7 +520,7 @@ export class TypstParser {
                                 if(g.args!.length !== 4 || !g.args![pos_colon + 2].eq(new TypstNode('symbol', 'none'))) { 
                                     throw new TypstParserError('Invalid number of arguments for delim');
                                 }
-                                np['delim'] = "#none";
+                                np['delim'] = TYPST_NONE;
                             } else {
                                 throw new TypstParserError('Not implemented for other types of delim');
                             }