tex2typst 0.0.16 → 0.0.18

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "tex2typst",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "JavaScript library for converting TeX code to Typst",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/qwinsi/tex2typst",
@@ -14,7 +15,10 @@
   ],
   "scripts": {
     "prebuild": "rimraf dist/",
-    "build": "tsc --project ./tsconfig.json --outDir dist --declaration",
+    "build:node": "bun build --entrypoints src/index.ts  --outdir ./dist  --target node --external katex",
+    "build:browser": "bun build --entrypoints src/index.ts --outdir ./dist --target browser --entry-naming [dir]/tex2typst.min.[ext] --minify",
+    "build:types": "tsc --project ./tsconfig.json",
+    "build": "npm run build:node && npm run build:browser && npm run build:types",
     "test": "vitest run"
   },
   "devDependencies": {

package/src/index.ts

@@ -2,6 +2,7 @@ import { parseTex } from "./parser";
 import { Tex2TypstOptions } from "./types";
 import { TypstWriter } from "./writer";
 
+
 export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     const opt: Tex2TypstOptions = {
         nonStrict: false,
@@ -24,3 +25,10 @@ export function tex2typst(tex: string, options?: Tex2TypstOptions): string {
     writer.append(t);
     return writer.finalize();
 }
+
+
+if(typeof window !== 'undefined') {
+    (window as any).tex2typst = tex2typst;
+}
+
+export { Tex2TypstOptions };

package/src/map.ts

@@ -25,11 +25,6 @@ export const symbolMap = new Map<string, string>([
 
     ['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'],

package/src/parser.ts

@@ -1,6 +1,6 @@
 // @ts-ignore
 import katex from 'katex';
-import { TexNode, KatexParseNode, TexSupsubData } from './types.js';
+import { TexNode, KatexParseNode, TexSupsubData } from './types';
 
 
 const generateParseTree = katex.__parse;
@@ -101,10 +101,11 @@ export function katexNodeToTexNode(node: KatexParseNode): TexNode {
                 if (right === "\\}") {
                     right = "}";
                 }
+                const is_atom = (str:string) => (['(', ')', '[', ']', '{', '}'].includes(str));
                 res.args = [
-                    { type: 'atom', content: left },
+                    { type: is_atom(left)? 'atom': 'symbol', content: left },
                     body,
-                    { type: 'atom', content: right}
+                    { type: is_atom(right)? 'atom': 'symbol', content: right}
                 ];
                 break;
             }

package/src/writer.ts

@@ -132,7 +132,7 @@ export class TypstWriter {
         } else if (node.type === 'leftright') {
             const [left, body, right] = node.args!;
             // These pairs will be handled by Typst compiler by default. No need to add lr()
-            if (["[]", "()", "{}"].includes(left.content + right.content)) {
+            if (["[]", "()", "{}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
                 this.append(left);
                 this.append(body);
                 this.append(right);

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. */

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'],
-]);