tex2typst 0.0.17 → 0.0.19

package/tsconfig.json

@@ -25,7 +25,7 @@
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
     /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
+    "module": "esnext",                                /* 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. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
@@ -35,7 +35,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. */
@@ -51,7 +51,7 @@
     /* Emit */
     "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. */
@@ -109,6 +109,7 @@
     "src/**/*.ts"
   ],
   "exclude": [
+    "src/tex2typst.ts",
     "tests/**/*"
   ]
 }

package/.github/workflows/github-ci.yml

@@ -1,35 +0,0 @@
-name: tex2typst Tests
-on:
-  push:
-    branches:
-      - main
-      - dev
-  pull_request:
-    branches:
-      - main
-
-jobs:
-  unit-tests:
-    name: Unit tests
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node: [18]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Setup node env
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node }}
-          cache: 'yarn'
-
-      - name: Install dependencies
-        run: yarn install
-
-      - name: Run Vitest Test
-        run: npx vitest run

package/dist/map.js

@@ -1,291 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbolMap = void 0;
-exports.symbolMap = new Map([
-    ['gets', 'arrow.l'],
-    ['nonumber', ''],
-    ['vec', 'arrow'],
-    ['mathbf', 'bold'],
-    ['boldsymbol', 'bold'],
-    ['mathfrak', 'frak'],
-    ['neq', 'eq.not'],
-    ['dot', 'dot'],
-    ['ddot', 'dot.double'],
-    ['doteq', 'dot(eq)'],
-    ['dots', 'dots.h'],
-    ['ldots', 'dots.h'],
-    ['vdots', 'dots.v'],
-    ['ddots', 'dots.down'],
-    ['widehat', 'hat'], // Ideally, the result of \widehat should be longer than \hat. But it is not implemented now.
-    ['widetilde', 'tilde'], // Ideally, the result of \widetilde should be longer than \tilde. But it is not implemented now.
-    ['quad', 'quad'],
-    ['qquad', 'wide'],
-    ['overbrace', 'overbrace'], // same
-    ['underbrace', 'underbrace'], // same
-    ['overline', 'overline'], // same
-    ['underline', 'underline'], // same
-    ['bar', 'macron'],
-    ['mathbb', 'bb'],
-    ['mathcal', 'cal'],
-    // TODO: This result it not proper. A solution is define scr in Typst code:
-    // #let scr(a) = text(font: "STIX Two Math", stylistic-set: 01)[#math.cal(a)]
-    // https://qiita.com/Yarakashi_Kikohshi/items/b7beaa0fba62a527df2b
-    // https://github.com/typst/typst/issues/1431
-    ['mathscr', 'cal'],
-    ['mathrm', 'upright'],
-    ['rm', 'upright'],
-    // TODO: \pmb need special logic to handle but it is not implemented now. See the commented test case.
-    ['pmb', 'bold'],
-    /* variants of plus,minus,times,divide */
-    ['pm', 'plus.minus'],
-    ['mp', 'minus.plus'],
-    ['oplus', 'xor'], // \oplus and also be plus.circle
-    ['boxplus', 'plus.square'],
-    ['otimes', 'times.circle'],
-    ['boxtimes', 'times.square'],
-    /* wave */
-    // tex: \sim \approx \cong \simeq \asymp \equiv \propto
-    // typst: tilde approx tilde.equiv tilde.eq ≍ equiv prop
-    ['sim', 'tilde'],
-    ['approx', 'approx'],
-    ['cong', 'tilde.equiv'],
-    ['simeq', 'tilde.eq'],
-    ['asymp', '≍'], // just use the unicode character :-)
-    ['equiv', 'equiv'],
-    ['propto', 'prop'],
-    /* arrows used in proofs */
-    // tex: \implies \iff \leftrightarrow \longleftrightarrow \rightrightarrows
-    // typst: arrow.r.double.long arrow.l.r.double.long arrow.l.r arrow.l.r.long arrows.rr
-    ['implies', 'arrow.r.double.long'],
-    ['Longrightarrow', 'arrow.r.double.long'], // Note: This macro is not supported by KaTeX
-    ['iff', 'arrow.l.r.double.long'],
-    ['Longleftrightarrow', 'arrow.l.r.double.long'], // Note: This macro is not supported by KaTeX
-    ['leftrightarrow', 'arrow.l.r'],
-    ['longleftrightarrow', 'arrow.l.r.long'],
-    ['rightrightarrows', 'arrows.rr'],
-    /* left and right floor,ceil */
-    // tex: \lfloor \rfloor \lceil \rceil
-    // typst: ⌊ ⌋ ⌈ ⌉ 
-    // TODO: Ideally, \lfloor x \rfloor should be translated to floor(x) but it is not implemented now.
-    // The KaTeX parser parses it as \lfloor x \rfloor. So it would take some effort to implement it.
-    ['lfloor', '⌊'],
-    ['rfloor', '⌋'],
-    ['lceil', '⌈'],
-    ['rceil', '⌉'],
-    ['Cap', 'sect.double'],
-    ['Cup', 'union.double'],
-    ['Delta', 'Delta'],
-    ['Gamma', 'Gamma'],
-    ['Join', 'join'],
-    ['Lambda', 'Lambda'],
-    ['Longrightarrow', 'arrow.r.double.long'],
-    ['Omega', 'Omega'],
-    ['Phi', 'Phi'],
-    ['Pi', 'Pi'],
-    ['Psi', 'Psi'],
-    ['Rightarrow', 'arrow.double'],
-    ['Sigma', 'Sigma'],
-    ['Theta', 'Theta'],
-    ['aleph', 'alef'],
-    ['alpha', 'alpha'],
-    // ['amalg', 'product.co'], 
-    ['angle', 'angle'],
-    ['approx', 'approx'],
-    ['approxeq', 'approx.eq'],
-    ['ast', 'ast'],
-    ['beta', 'beta'],
-    ['bigcap', 'sect.big'],
-    ['bigcirc', 'circle.big'],
-    ['bigcup', 'union.big'],
-    ['bigodot', 'dot.circle.big'],
-    ['bigoplus', 'xor.big'], // or "plus.circle.big"
-    ['bigotimes', 'times.circle.big'],
-    ['bigsqcup', 'union.sq.big'],
-    ['bigtriangledown', 'triangle.b'],
-    ['bigtriangleup', 'triangle.t'],
-    ['biguplus', 'union.plus.big'],
-    ['bigvee', 'or.big'],
-    ['bigwedge', 'and.big'],
-    // ['bowtie', 'join'], 
-    ['bullet', 'bullet'],
-    ['cap', 'sect'],
-    ['cdot', 'dot.op'], // 'dot.op' or 'dot.c'
-    ['cdots', 'dots.c'],
-    ['checkmark', 'checkmark'],
-    ['chi', 'chi'],
-    ['circ', 'circle.small'], // 'circle.small' or 'compose'
-    ['colon', 'colon'],
-    ['cong', 'tilde.equiv'],
-    ['coprod', 'product.co'],
-    ['cup', 'union'],
-    ['curlyvee', 'or.curly'],
-    ['curlywedge', 'and.curly'],
-    ['dagger', 'dagger'],
-    ['dashv', 'tack.l'],
-    ['ddagger', 'dagger.double'],
-    ['delta', 'delta'],
-    ['ddots', 'dots.down'],
-    ['diamond', 'diamond'],
-    ['div', 'div'],
-    ['divideontimes', 'times.div'],
-    ['dotplus', 'plus.dot'],
-    ['downarrow', 'arrow.b'],
-    ['ell', 'ell'],
-    ['emptyset', 'nothing'],
-    ['epsilon', 'epsilon.alt'],
-    ['equiv', 'equiv'],
-    ['eta', 'eta'],
-    ['exists', 'exists'],
-    ['forall', 'forall'],
-    // ['frown', 'paren.t'], 
-    ['gamma', 'gamma'],
-    ['ge', 'gt.eq'],
-    ['geq', 'gt.eq'],
-    ['geqslant', 'gt.eq.slant'],
-    ['gg', 'gt.double'],
-    ['hbar', 'planck.reduce'],
-    ['imath', 'dotless.i'],
-    ['iiiint', 'intgral.quad'],
-    ['iiint', 'integral.triple'],
-    ['iint', 'integral.double'],
-    ['in', 'in'],
-    ['infty', 'infinity'],
-    ['int', 'integral'],
-    ['intercal', 'top'], // 'top' or 'tack.b'
-    ['iota', 'iota'],
-    ['jmath', 'dotless.j'],
-    ['kappa', 'kappa'],
-    ['lambda', 'lambda'],
-    ['land', 'and'],
-    ['langle', 'angle.l'],
-    ['lbrace', 'brace.l'],
-    ['lbrack', 'bracket.l'],
-    ['ldots', 'dots.l'],
-    ['le', 'lt.eq'],
-    ['leadsto', 'arrow.squiggly'],
-    ['leftarrow', 'arrow.l'],
-    ['leftthreetimes', 'times.three.l'],
-    ['leftrightarrow', 'arrow.l.r'],
-    ['leq', 'lt.eq'],
-    ['leqslant', 'lt.eq.slant'],
-    ['lhd', 'triangle.l'],
-    ['ll', 'lt.double'],
-    ['longmapsto', 'arrow.long.bar'],
-    ['longrightarrow', 'arrow.long'],
-    ['lor', 'or'],
-    ['ltimes', 'times.l'],
-    ['mapsto', 'arrow.bar'],
-    ['measuredangle', 'angle.arc'],
-    ['mid', 'divides'],
-    ['models', 'models'],
-    ['mp', 'minus.plus'],
-    ['mu', 'mu'],
-    ['nRightarrow', 'arrow.double.not'],
-    ['nabla', 'nabla'],
-    ['ncong', 'tilde.nequiv'],
-    ['ne', 'eq.not'],
-    ['neg', 'not'],
-    ['neq', 'eq.not'],
-    ['nexists', 'exists.not'],
-    ['ni', "in.rev"],
-    ['nleftarrow', "arrow.l.not"],
-    ['nleq', "lt.eq.not"],
-    ['nparallel', "parallel.not"],
-    ['ngeq', 'gt.eq.not'],
-    ['nmid', 'divides.not'],
-    ['notin', 'in.not'],
-    ['nrightarrow', 'arrow.not'],
-    ['nsim', 'tilde.not'],
-    ['nsubseteq', 'subset.eq.not'],
-    ['nu', 'nu'],
-    ['ntriangleleft', 'lt.tri.not'],
-    ['ntriangleright', 'gt.tri.not'],
-    ['nwarrow', 'arrow.tl'],
-    ['odot', 'dot.circle'],
-    ['oint', 'integral.cont'],
-    ['oiint', 'integral.surf'],
-    ['oiiint', 'integral.vol'],
-    ['omega', 'omega'],
-    // ['omicron', 'omicron'], 
-    ['ominus', 'minus.circle'],
-    ['oplus', 'xor'], // or 'plus.circle'
-    ['otimes', 'times.circle'],
-    ['parallel', 'parallel'],
-    ['partial', 'diff'],
-    ['perp', 'perp'],
-    ['phi', 'phi.alt'],
-    ['pi', 'pi'],
-    ['pm', 'plus.minus'],
-    ['pounds', 'pound'],
-    ['prec', 'prec'],
-    ['preceq', 'prec.eq'],
-    ['prime', 'prime'],
-    ['prod', 'product'],
-    ['propto', 'prop'],
-    ['psi', 'psi'],
-    ['rangle', 'angle.r'],
-    ['rbrace', 'brace.r'],
-    ['rbrack', 'bracket.r'],
-    ['rhd', 'triangle'],
-    ['rho', 'rho'],
-    ['rightarrow', 'arrow.r'],
-    ['rightthreetimes', 'times.three.r'],
-    ['rtimes', 'times.r'],
-    ['setminus', 'without'],
-    ['sigma', 'sigma'],
-    ['sim', 'tilde'],
-    ['simeq', 'tilde.eq'],
-    ['slash', 'slash'],
-    ['smallsetminus', 'without'],
-    // ['smile', 'paren.b'], 
-    ['spadesuit', 'suit.spade'],
-    ['sqcap', 'sect.sq'],
-    ['sqcup', 'union.sq'],
-    ['sqsubseteq', 'subset.eq.sq'],
-    ['sqsupseteq', 'supset.eq.sq'],
-    ['star', 'star'],
-    ['subset', 'subset'],
-    ['subseteq', 'subset.eq'],
-    ['subsetneq', 'subset.neq'],
-    ['succ', 'succ'],
-    ['succeq', 'succ.eq'],
-    ['sum', 'sum'],
-    ['supset', 'supset'],
-    ['supseteq', 'supset.eq'],
-    ['supsetneq', 'supset.neq'],
-    ['swarrow', 'arrow.bl'],
-    ['tau', 'tau'],
-    ['theta', 'theta'],
-    ['times', 'times'],
-    ['to', 'arrow.r'],
-    ['top', 'top'],
-    ['triangle', 'triangle.t'],
-    ['triangledown', 'triangle.b.small'],
-    ['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'],
-    ['varepsilon', 'epsilon'],
-    ['varnothing', 'diameter'], // empty set
-    ['varphi', 'phi'],
-    ['varpi', 'pi.alt'],
-    ['varrho', 'rho.alt'],
-    ['varsigma', 'sigma.alt'],
-    ['vartheta', 'theta.alt'],
-    ['vdash', 'tack.r'],
-    ['vdots', 'dots.v'],
-    ['vee', 'or'],
-    ['wedge', 'and'],
-    ['wr', 'wreath'],
-    ['xi', 'xi'],
-    ['yen', 'yen'],
-    ['zeta', 'zeta'],
-    // extended
-    ['mathscr', 'scr'],
-    ['LaTeX', '#LaTeX'],
-    ['TeX', '#TeX'],
-]);

package/dist/parser.js

@@ -1,265 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KatexNodeToTexNodeError = void 0;
-exports.katexNodeToTexNode = katexNodeToTexNode;
-exports.parseTex = parseTex;
-// @ts-ignore
-const katex_1 = __importDefault(require("katex"));
-const generateParseTree = katex_1.default.__parse;
-class KatexNodeToTexNodeError extends Error {
-    constructor(message, node) {
-        super(message);
-        this.name = "KatexNodeToTexNodeError";
-        this.node = node;
-    }
-}
-exports.KatexNodeToTexNodeError = KatexNodeToTexNodeError;
-function katexNodeToTexNode(node) {
-    try {
-        if (node.loc) {
-            delete node.loc;
-        }
-        let res = {};
-        switch (node.type) {
-            case 'atom':
-                // basic symbol like +, -, =, '(', ')', '\{', '\}'
-                // other punctuation-like macro such as \cdot, \to, \pm
-                res.type = 'atom';
-                res.content = node.text;
-                if (node.text === '\\{' || node.text === '\\}') {
-                    res.content = node.text.substring(1); // '{' or '}'
-                }
-                else if (node.text.startsWith('\\')) {
-                    res.type = 'symbol';
-                }
-                break;
-            case 'mathord':
-            // basic variable like a, b, c
-            // macro variable like \alpha, \beta, \gamma
-            case 'textord':
-            // - constant number like 1, 2, 3
-            // - operator symbol like \nabla, \partial
-            case 'op':
-            // \lim, \sum
-            case 'cr':
-                // new line symbol '\\'
-                res.type = 'symbol';
-                res.content = node.text;
-                if (node.type === 'op') {
-                    res.content = node['name'];
-                }
-                else if (node.type === 'cr') {
-                    res.content = '\\\\';
-                }
-                break;
-            case 'genfrac':
-                res.type = 'binaryFunc';
-                if (node['leftDelim'] === '(' && node['rightDelim'] === ')') {
-                    // This occurs for \binom \tbinom
-                    res.content = '\\binom';
-                }
-                else {
-                    res.content = '\\frac';
-                }
-                res.args = [
-                    katexNodeToTexNode(node['numer']),
-                    katexNodeToTexNode(node['denom'])
-                ];
-                break;
-            case 'supsub':
-                res.type = 'supsub';
-                res.irregularData = {};
-                if (node['base']) {
-                    res.irregularData.base = katexNodeToTexNode(node['base']);
-                }
-                if (node['sup']) {
-                    res.irregularData.sup = katexNodeToTexNode(node['sup']);
-                }
-                if (node['sub']) {
-                    res.irregularData.sub = katexNodeToTexNode(node['sub']);
-                }
-                break;
-            case 'mclass':
-            case 'ordgroup':
-                res.type = 'ordgroup';
-                res.args = node.body.map((n) => katexNodeToTexNode(n));
-                if (res.args.length === 1) {
-                    res = res.args[0];
-                }
-                break;
-            case 'leftright': {
-                const body = katexNodeToTexNode({
-                    type: 'ordgroup',
-                    mode: 'math',
-                    body: node.body
-                });
-                res.type = 'leftright';
-                let left = node['left'];
-                if (left === "\\{") {
-                    left = "{";
-                }
-                let right = node['right'];
-                if (right === "\\}") {
-                    right = "}";
-                }
-                const is_atom = (str) => (['(', ')', '[', ']', '{', '}'].includes(str));
-                res.args = [
-                    { type: is_atom(left) ? 'atom' : 'symbol', content: left },
-                    body,
-                    { type: is_atom(right) ? 'atom' : 'symbol', content: right }
-                ];
-                break;
-            }
-            case 'underline':
-            case 'overline':
-                res.type = 'unaryFunc';
-                res.content = '\\' + node.type;
-                res.args = [
-                    katexNodeToTexNode(node['body'])
-                ];
-                break;
-            case 'accent': {
-                res.type = 'unaryFunc';
-                res.content = node['label'];
-                res.args = [
-                    katexNodeToTexNode(node['base'])
-                ];
-                break;
-            }
-            case 'sqrt':
-                if (node['index']) {
-                    // There is a [] after \sqrt
-                    // \sqrt[some thing]{}
-                    res.irregularData = katexNodeToTexNode(node['index']);
-                }
-            // Fall through
-            case 'font':
-            case 'operatorname':
-                res.type = 'unaryFunc';
-                res.content = ('\\' + node.type);
-                if (node.type === 'font') {
-                    res.content = '\\' + node['font']; // e.g. \mathbf, \mathrm
-                }
-                if (Array.isArray(node.body)) {
-                    const obj = {
-                        type: 'ordgroup',
-                        mode: 'math',
-                        body: node.body
-                    };
-                    res.args = [
-                        katexNodeToTexNode(obj)
-                    ];
-                }
-                else {
-                    res.args = [
-                        katexNodeToTexNode(node.body)
-                    ];
-                }
-                break;
-            case 'horizBrace':
-                res.type = 'unaryFunc';
-                res.content = node['label']; // '\\overbrace' or '\\unerbrace'
-                res.args = [
-                    katexNodeToTexNode(node['base']),
-                ];
-                break;
-            case 'array':
-                if (node['colSeparationType'] === 'align') {
-                    // align environment
-                    res.type = 'align';
-                }
-                else {
-                    res.type = 'matrix';
-                }
-                res.irregularData = node.body.map((row) => {
-                    return row.map((cell) => {
-                        if (cell.type !== 'styling' || cell.body.length !== 1) {
-                            throw new KatexNodeToTexNodeError("Expecting cell.type==='\\styling' and cell.body.length===1", cell);
-                        }
-                        return katexNodeToTexNode(cell.body[0]);
-                    });
-                });
-                break;
-            case 'text': {
-                res.type = 'text';
-                let str = "";
-                node.body.forEach((n) => {
-                    if (n.mode !== 'text') {
-                        throw new KatexNodeToTexNodeError("Expecting node.mode==='text'", node);
-                    }
-                    str += n.text;
-                });
-                res.content = str;
-                break;
-            }
-            case 'spacing':
-            // res.type = 'spacing';
-            // res.content = node.text! as string;
-            // break;
-            case 'kern':
-                // This can occur for \implies, \iff. 
-                // e.g. \implies is parsed as [{type:'kern'}, {type:'atom', text:'\\Longrightarrow'}, {type:'kern'}]
-                // TODO: Ideally, we should output a single symbol \implies.
-                // But for now, we simply let the output be \Longrightarrow
-                res.type = 'empty';
-                res.content = ' ';
-                break;
-            case 'htmlmathml': {
-                // This can occur for \neq.
-                const element = node['mathml'][0]['body'][0];
-                if (element && element.type === 'textord' && element.text === '≠') {
-                    res.type = 'symbol';
-                    res.content = '\\neq';
-                    break;
-                }
-                else {
-                    // Fall through to throw error
-                }
-            }
-            case 'color':
-                // KaTeX encounters an unrecognized macro.
-                if (Array.isArray(node.body) && node.body.length === 1) {
-                    const sub_body = node.body[0];
-                    if (sub_body.type === 'text') {
-                        res.type = 'unknownMacro';
-                        const joined = sub_body.body.map((n) => n.text).join('');
-                        if (/^\\[a-zA-Z]+$/.test(joined)) {
-                            res.content = joined.substring(1);
-                            break;
-                        }
-                    }
-                }
-                throw new KatexNodeToTexNodeError(`Unknown error type in parsed result:`, node);
-            default:
-                throw new KatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
-                break;
-        }
-        return res;
-    }
-    catch (e) {
-        throw e;
-    }
-}
-function parseTex(tex, customTexMacros) {
-    // displayMode=true. Otherwise, "KaTeX parse error: {align*} can be used only in display mode."
-    const macros = Object.assign({ 
-        // KaTeX parse these commands so complicatedly that we need some hacks to keep things simple.
-        '\\mod': '\\operatorname{SyMb01-mod}', '\\liminf': '\\operatorname{SyMb01-liminf}', '\\limsup': '\\operatorname{SyMb01-limsup}', '\\qquad': '\\operatorname{SyMb01-qquad}', '\\quad': '\\operatorname{SyMb01-quad}', '\\cdots': '\\operatorname{SyMb01-cdots}', '\\colon': '\\operatorname{SyMb01-colon}', '\\imath': '\\operatorname{SyMb01-imath}', '\\\iiiint': '\\operatorname{SyMb01-iiiint}', '\\jmath': '\\operatorname{SyMb01-jmath}', '\\vdots': '\\operatorname{SyMb01-vdots}', '\\notin': '\\operatorname{SyMb01-notin}', '\\slash': '\\operatorname{SyMb01-slash}', '\\LaTeX': '\\operatorname{SyMb01-LaTeX}', '\\TeX': '\\operatorname{SyMb01-TeX}' }, customTexMacros);
-    const options = {
-        macros: macros,
-        displayMode: true,
-        strict: "ignore",
-        throwOnError: false
-    };
-    let treeArray = generateParseTree(tex, options);
-    let t = {
-        type: 'ordgroup',
-        mode: 'math',
-        body: treeArray,
-        loc: {}
-    };
-    return katexNodeToTexNode(t);
-}

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });