tex2typst 0.3.26 → 0.3.27

package/tests/tex-to-typst.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, test, expect } from 'vitest';
+import { tokenize_tex } from '../src/tex-tokenizer';
+import { parseTex } from '../src/tex-parser';
+import { tex2typst } from '../src/index';
+import { TypstWriterError } from '../src/typst-writer';
+import { TexNode, TexToken } from '../src/tex-types';
+import type { Tex2TypstOptions } from '../src/exposed-types';
+import { loadTestCases, TestCase } from './test-common';
+import { ConverterError } from '../src/convert';
+
+describe('options', () => {
+    it('nonStrict = false', function () {
+        const input = '\\nonExistentCommand';
+        // must throw error
+        expect(() => tex2typst(input, { nonStrict: false })).toThrowError(ConverterError);
+    });
+
+
+    it('fracToSlash = true', function () {
+        const input = '\\frac{a}{b}';
+        const expected = 'a/b';
+        const res = tex2typst(input, { fracToSlash: true });
+        expect(res).toEqual(expected);
+    });
+
+    it('fracToSlash = false', function () {
+        const input = '\\frac{a}{b}';
+        const expected = 'frac(a, b)';
+        const res = tex2typst(input, { fracToSlash: false });
+        expect(res).toEqual(expected);
+    });
+
+
+    it('nonAsciiWrapper = ""', function () {
+        const input = 'a + b = \\text{こにちは、世界}';
+        const expected = 'a + b = "こにちは、世界"';
+        const res = tex2typst(input);
+        expect(res).toEqual(expected);
+    });
+
+    it('nonAsciiWrapper = "ut"', function () {
+        const input = 'a + b = \\text{こにちは、世界}';
+        const expected = 'a + b = ut("こにちは、世界")';
+        const res = tex2typst(input, { nonAsciiWrapper: 'ut' });
+        expect(res).toEqual(expected);
+    });
+
+    it('preferShorthands = true', function () {
+        const map = new Map<string, string>([
+            ['a \\rightarrow b', 'a -> b'],
+            ['a \\to b', 'a -> b'],
+            ['a \\implies b', 'a ==> b'],
+            ['a \\iff b', 'a <==> b'],
+            ['a \\ll b', 'a << b'],
+            ['a \\gg b', 'a >> b'],
+
+        ]);
+        for(const [input, expected] of map.entries()) {
+            const res = tex2typst(input, { preferShorthands: true });
+            expect(res).toEqual(expected);
+        }
+    });
+
+    it('preferShorthands = false', function () {
+        const map = new Map<string, string>([
+            ['a \\rightarrow b', 'a arrow.r b'],
+            ['a \\to b', 'a arrow.r b'],
+            ['a \\implies b', 'a arrow.r.double.long b'],
+            ['a \\iff b', 'a arrow.l.r.double.long b'],
+            ['a \\ll b', 'a lt.double b'],
+            ['a \\gg b', 'a gt.double b'],
+
+        ]);
+        for(const [input, expected] of map.entries()) {
+            const res = tex2typst(input, { preferShorthands: false });
+            expect(res).toEqual(expected);
+        }
+    });
+
+    it ('customTexMacros', function () {
+        const input = '\\myop y=\\sgn(x)';
+        const expected = 'op("myop") y = op("sgn")(x)';
+        const res = tex2typst(input, { customTexMacros: {
+            '\\myop': '\\operatorname{myop}',
+            '\\sgn': '\\operatorname{sgn}',
+        } });
+        expect(res).toEqual(expected);
+    });
+
+    it ('customTexMacros 2', function () {
+        const input = '123 \\foo 456';
+        const expected = '123 root(3, x) 456';
+        const res = tex2typst(input, { customTexMacros: {
+            '\\foo': '\\sqrt[3]{x}',
+        } });
+        expect(res).toEqual(expected);
+    });
+});
+
+
+const caseFiles = ["struct-tex2typst.yaml", "symbol.yml", "struct-bidirection.yaml", "integration-tex2typst.yaml"];
+
+caseFiles.forEach((ymlFilename) => {
+  const suite = loadTestCases(ymlFilename);
+  describe(ymlFilename, () => {
+    suite.cases.forEach((c: TestCase) => {
+      test(c.title, function() {
+        const {tex, typst} = c;
+        let tokens: null | TexToken[] = null;
+        let tex_node: null | TexNode = null;
+        let result: null | string = null;
+        try {
+          const settings: Tex2TypstOptions = {
+            nonStrict: c.nonStrict? c.nonStrict: false,
+            preferShorthands: c.preferShorthands !== undefined? c.preferShorthands: true,
+            inftyToOo: c.inftyToOo !== undefined? c.inftyToOo: false,
+            customTexMacros: c.customTexMacros? c.customTexMacros: {},
+          };
+          tokens = tokenize_tex(tex);
+          tex_node = parseTex(tex, settings.customTexMacros!);
+          result = tex2typst(tex, settings);
+          if (result !== typst) {
+            console.log(`====== 😭 Wrong ======`);
+            console.log(tex);
+            console.log(tokens);
+            console.dir(tex_node, {depth: null});
+          }
+          expect(result).toBe(typst);
+        } catch (e) {
+          console.log(`====== 😭 Error ======`);
+          if (e instanceof TypstWriterError) {
+            console.log(e.node);
+          }
+          if (tex_node !== null) {
+            console.dir(tex_node, {depth: null});
+          }
+          console.log(tex);
+          throw e;
+        }
+      })
+    });
+  });
+});

package/tests/typst-parser.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import { tokenize_typst } from '../src/typst-tokenizer';
+import { TypstParser } from '../src/typst-parser';
+import { TypstFraction, TypstFuncCall, TypstGroup, TypstLeftright, TypstSupsub, TypstTerminal, TypstToken, TypstTokenType } from '../src/typst-types';
+
+
+describe('typst-tokenizer', () => {
+    it('a + b', function () {
+        const res = tokenize_typst('a + b');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, '+'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, 'b'),
+        ]);
+    });
+
+    it('a (x)', function () {
+        const res = tokenize_typst('a (x)');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.ELEMENT, '('),
+            new TypstToken(TypstTokenType.ELEMENT, 'x'),
+            new TypstToken(TypstTokenType.ELEMENT, ')'),
+        ]);
+    });
+
+    it('f(x)', function () {
+        const res = tokenize_typst('f(x)');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'f'),
+            new TypstToken(TypstTokenType.ELEMENT, '('),
+            new TypstToken(TypstTokenType.ELEMENT, 'x'),
+            new TypstToken(TypstTokenType.ELEMENT, ')'),
+        ]);
+    });
+
+    it('comment', function() {
+        const res = tokenize_typst('a // comment');
+        expect(res).toEqual([
+            new TypstToken(TypstTokenType.ELEMENT, 'a'),
+            new TypstToken(TypstTokenType.SPACE, ' '),
+            new TypstToken(TypstTokenType.COMMENT, ' comment'),
+        ]);
+    })
+});
+
+describe('typst-parser', () => {
+    const parser = new TypstParser();
+    it('a + b', function () {
+        const tokens = tokenize_typst('a + b');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '+')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'b')),
+        ]));
+    });
+
+    it('a (x)', function () {
+        const tokens = tokenize_typst('a (x)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstLeftright(null, {
+                body: new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+                left: new TypstToken(TypstTokenType.ELEMENT, '('),
+                right: new TypstToken(TypstTokenType.ELEMENT, ')')
+            })
+        ]));
+    });
+
+    it('f(x)', function () {
+        const tokens = tokenize_typst('f(x)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFuncCall(new TypstToken(TypstTokenType.ELEMENT, 'f'), [
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+        ]));
+    });
+
+    it('root(x, 3)', function () {
+        const tokens = tokenize_typst('root(x, 3)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFuncCall(new TypstToken(TypstTokenType.SYMBOL, 'root'), [
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '3')),
+        ]));
+    });
+
+    it('lim_(x arrow.r 0)', function () {
+        const tokens = tokenize_typst('lim_(x arrow.r 0)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstSupsub({
+            base: new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'lim')),
+            sub: new TypstGroup([
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'x')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'arrow.r')),
+                new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '0')),
+            ]),
+            sup: null,
+        }));
+    });
+
+    it('a -> b', function () {
+        const tokens = tokenize_typst('a -> b');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstGroup([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'a')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SYMBOL, 'arrow.r')),
+            new TypstTerminal(new TypstToken(TypstTokenType.SPACE, ' ')),
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, 'b')),
+        ]));
+    });
+
+    it('1/(2/3)', function () {
+        const tokens = tokenize_typst('1/(2/3)');
+        const res = parser.parse(tokens);
+        expect(res).toEqual(new TypstFraction([
+            new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '1')),
+            new TypstFraction([
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '2')),
+                new TypstTerminal(new TypstToken(TypstTokenType.ELEMENT, '3')),
+            ]),
+        ]));
+    });
+});

package/tests/typst-to-tex.test.ts

@@ -0,0 +1,76 @@
+
+import { describe, it, test, expect } from 'vitest';
+import { parseTypst } from '../src/typst-parser';
+import { TexWriter } from '../src/tex-writer';
+import { convert_typst_node_to_tex } from '../src/convert';
+import { loadTestCases, TestCase  } from './test-common';
+
+
+
+describe('examples', () => {
+    it('a + b', function () {
+        const typst_node = parseTypst('a + b');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('a + b');
+    });
+
+    it('sqrt(x)', function () {
+        const typst_node = parseTypst('sqrt(x)');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\sqrt{x}');
+    });
+
+    it('integral_a^b f(x) dif x', function () {
+        const typst_node = parseTypst('integral_a^b f(x) dif x');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\int_a^b f(x) \\mathrm{d} x');
+    });
+
+    it('lr({a + 1/3))', function () {
+        const typst_node = parseTypst('lr({a + 1/3))');
+        const tex_node = convert_typst_node_to_tex(typst_node);
+        const writer = new TexWriter();
+        writer.append(tex_node);
+        const res = writer.finalize();
+        expect(res).toEqual('\\left\\{a + \\frac{1}{3} \\right)');
+    });
+});
+
+
+
+describe('struct-typst2tex.yaml', function () {
+    const suite = loadTestCases('struct-typst2tex.yaml');
+    suite.cases.forEach((c: TestCase) => {
+        test(c.title, function () {
+            const typst_node = parseTypst(c.typst);
+            const tex_node = convert_typst_node_to_tex(typst_node);
+            const writer = new TexWriter();
+            writer.append(tex_node);
+            const res = writer.finalize();
+            expect(res).toEqual(c.tex);
+        });
+    });
+});
+
+describe('struct-bidirection.yaml', function () {
+    const suite = loadTestCases('struct-bidirection.yaml');
+    suite.cases.forEach((c: TestCase) => {
+        test(c.title, function () {
+            const typst_node = parseTypst(c.typst);
+            const tex_node = convert_typst_node_to_tex(typst_node);
+            const writer = new TexWriter();
+            writer.append(tex_node);
+            const res = writer.finalize();
+            expect(res).toEqual(c.tex);
+        });
+    });
+});

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
+    /* This is not the full list because some meaningless options are not listed. */
 
     /* Projects */
     // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
@@ -11,7 +11,7 @@
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
 
     /* Language and Environment */
-    "target": "es2021",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "es2022",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
@@ -20,14 +20,12 @@
     // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
     // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
     // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "esnext",                                /* Specify what module code is generated. */
+    // "module": "es6",                                  /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    "moduleResolution": "bundler",                     /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
@@ -35,7 +33,7 @@
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
     // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
@@ -49,12 +47,11 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
 
     /* Emit */
-    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
     // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     // "noEmit": true,                                   /* Disable emitting files from a compilation. */
@@ -63,13 +60,11 @@
     // "sourceRoot": "./",                                 /* Specify the root path for debuggers to find the reference source code. */
     // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
     // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
     // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
     // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
     // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
     // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    "declarationDir": "./dist",                           /* Specify the output directory for generated declaration files. */
+    // "declarationDir": "./dist",                           /* Specify the output directory for generated declaration files. */
 
     /* Interop Constraints */
     // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
@@ -82,7 +77,7 @@
 
     /* Type Checking */
     "strict": true,                                      /* Enable all strict type-checking options. */
-    "noImplicitAny": false,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "noImplicitAny": false,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
     // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
     // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
@@ -106,10 +101,10 @@
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
   },
   "include": [
-    "src/**/*.ts"
+    "src/**/*.ts",
+    "tests/**/*.ts",
   ],
   "exclude": [
     "src/tex2typst.ts",
-    "tests/**/*"
   ]
 }

package/dist/convert.d.ts

@@ -1,9 +0,0 @@
-import { TexNode, Tex2TypstOptions, TexToken } from "./tex-types";
-import { TypstNode } from "./typst-types";
-import { TypstToken } from "./typst-types";
-export declare class ConverterError extends Error {
-    node: TexNode | TypstNode | TexToken | TypstToken | null;
-    constructor(message: string, node?: TexNode | TypstNode | TexToken | TypstToken | null);
-}
-export declare function convert_tex_node_to_typst(abstractNode: TexNode, options?: Tex2TypstOptions): TypstNode;
-export declare function convert_typst_node_to_tex(abstractNode: TypstNode): TexNode;

package/dist/generic.d.ts

@@ -1,9 +0,0 @@
-interface IEquatable {
-    eq(other: IEquatable): boolean;
-}
-export declare function array_equal<T extends IEquatable>(a: T[], b: T[]): boolean;
-export declare function array_find<T extends IEquatable>(array: T[], item: T, start?: number): number;
-export declare function array_includes<T extends IEquatable>(array: T[], item: T): boolean;
-export declare function array_split<T extends IEquatable>(array: T[], sep: T): T[][];
-export declare function array_intersperse<T>(array: T[], sep: T): T[];
-export {};

package/dist/jslex.d.ts

@@ -1,107 +0,0 @@
-/**
- * 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[];
-}
-export declare class Scanner<T> {
-    private _input;
-    private _lexer;
-    private _pos;
-    private _line;
-    private _col;
-    private _offset;
-    private _less;
-    private _go;
-    private _newstate;
-    private _state;
-    private _text;
-    private _leng;
-    private _reMatchArray;
-    constructor(input: string, lexer: JSLex<T>);
-    /**
-     * Analogous to yytext and yyleng in lex - will be set during scan.
-     */
-    text(): string | null;
-    leng(): number | null;
-    reMatchArray(): RegExpMatchArray | null;
-    /**
-     * Position of in stream, line number and column number of match.
-     */
-    pos(): number;
-    line(): number;
-    column(): number;
-    /**
-     * Analogous to input() in lex.
-     * @return {string} The next character in the stream.
-     */
-    input(): string;
-    /**
-     * Similar to unput() in lex, but does not allow modifying the stream.
-     * @return {int} The offset position after the operation.
-     */
-    unput(): number;
-    /**
-     * 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.
-     */
-    less(n: number): number;
-    /**
-     * 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.
-     */
-    pushback(n: number): number;
-    /**
-     * 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.
-     */
-    reject(): void;
-    /**
-     * 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.
-     */
-    begin(state: string | number): string;
-    /**
-     * Simple accessor for reading in the current state.
-     * @return {string} The current state.
-     */
-    state(): string;
-    /**
-     * Scan method to be returned to caller - grabs the next token and fires appropriate calback.
-     * @return {T} The next token extracted from the stream.
-     */
-    scan(): T | T[];
-}
-export declare class JSLex<T> {
-    states: string[];
-    specification: Record<string, IRule<T>[]>;
-    constructor(spec: ILexSpec<T>);
-    /**
-     * 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.
-     */
-    scanner(input: string): Scanner<T>;
-    /**
-     * 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.
-     */
-    lex(input: string, callback: (arg0: T | T[]) => void): void;
-    /**
-     * 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.
-     */
-    collect(input: string): T[];
-}
-export {};

package/dist/map.d.ts

@@ -1,5 +0,0 @@
-declare const symbolMap: Map<string, string>;
-declare const texAliasMap: Map<string, string>;
-declare const typstAliasMap: Map<string, string>;
-declare const reverseSymbolMap: Map<string, string>;
-export { reverseSymbolMap, symbolMap, texAliasMap, typstAliasMap };

package/dist/tex-parser.d.ts

@@ -1,23 +0,0 @@
-import { TexNode, TexToken } from "./tex-types";
-export declare class LatexParserError extends Error {
-    constructor(message: string);
-}
-type ParseResult = [TexNode, number];
-export declare class LatexParser {
-    space_sensitive: boolean;
-    newline_sensitive: boolean;
-    constructor(space_sensitive?: boolean, newline_sensitive?: boolean);
-    parse(tokens: TexToken[]): TexNode;
-    parseGroup(tokens: TexToken[], start: number, end: number): ParseResult;
-    parseNextExpr(tokens: TexToken[], start: number): ParseResult;
-    parseNextExprWithoutSupSub(tokens: TexToken[], start: number): ParseResult;
-    parseCommandExpr(tokens: TexToken[], start: number): ParseResult;
-    parseNextArg(tokens: TexToken[], start: number): ParseResult;
-    parseLeftRightExpr(tokens: TexToken[], start: number): ParseResult;
-    parseBeginEndExpr(tokens: TexToken[], start: number): ParseResult;
-    parseAligned(tokens: TexToken[]): TexNode[][];
-}
-export declare function parseTex(tex: string, customTexMacros: {
-    [key: string]: string;
-}): TexNode;
-export {};

package/dist/tex-tokenizer.d.ts

@@ -1,4 +0,0 @@
-import { TexToken } from "./tex-types";
-export declare const TEX_UNARY_COMMANDS: string[];
-export declare const TEX_BINARY_COMMANDS: string[];
-export declare function tokenize_tex(input: string): TexToken[];